text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Как сжать модель fastText в 100 раз
Модель fastText — одно из самых эффективных векторных представлений слов для русского языка. Однако её прикладная польза страдает из-за внушительных (несколько гигабайт) размеров модели. В этой статье мы показываем, как можно уменьшить модель fastText с 2.7 гигабайт до 28 мегабайт, не слишком потеряв в её качестве (3-4%). Спойлер: квантизация и отбор признаков работают хорошо, а матричные разложения — не очень. Также мы публикуем [пакет](https://github.com/avidale/compress-fasttext) на Python для этого сжатия и [примеры компактной модели](https://github.com/avidale/compress-fasttext/releases/tag/v0.0.1) для русских слов.
Зачем и о чём это
-----------------
Я не первый, кто пытается сжать fastText: сами разработчики fastText давно [предусмотрели](https://fasttext.cc/blog/2017/10/02/blog-post.html#model-compression) этот режим для своих классификаторов, сжимая их на порядки с помощью квантизации и отбора признаков. В прошлом году Андрей Васнецов [описал](https://medium.com/@vasnetsov93/shrinking-fasttext-embeddings-so-that-it-fits-google-colab-cd59ab75959e) один из способов сжатия для unsupervised модели — переупаковку матрицы хэшей n-грамм. Чуть позже Александр Кукушкин опубликовал [navec](https://github.com/natasha/navec) — библиотеку с очень компактными квантизированными glove-эмбеддингами для русских слов. Здесь я собираю все эти идеи воедино.
Немного контекста: зачем вообще всё это нужно? Эмбеддинг, или векторное представление слова — это, натурально, числовой вектор фиксированного размера (скажем, 300-мерный), описывающий какие-то признаки этого слова. Обычно эти эмбеддинги выучиваются нейросетью, которая пытается угадать пропущенное слово по его контексту (соседнему тексту). Ожидается, что слова, похожие по смыслу, встречаются в похожих контекстах, а значит, и эмбеддинги у них будут похожи. Использование предобученных эмбеддингов, хотя бы приблизительно обладающих таким свойством, позволяет обучать хорошие модели для понимания текста (например, определения тематики или распознавания сущностей) даже на небольшом количестве размеченных примеров. На практике это применимо, например, для создания "умных" чатботов.
Самые современные эмбеддинги слов — контекстные, такие как ELMO или BERT. Но эти модели заметно медленнее и сложнее в обслуживании, чем fastText. А самое интересное свойство fastText'а — что он учитывает (простым усреднением, но тем не менее) символьные n-граммы (подстроки фиксированной длины) при построении эмбеддинга слова. То есть слова, содержащие похожие подстроки, могут получить похожие векторные представления, что весьма актуально для русского языка, богатого на словообразование. Но это же свойство делает модели fastText весьма объемными, ведь различных символьных n-грамм существует очень много.
Подробнее про устройство модели fastText можно почитать в [оригинальной статье](https://arxiv.org/abs/1607.04606) от Facebook AI Research. Её применение можно приблизительно описать следующим ~~псевдо~~кодом:
```
def embed(word, model):
if word in model.vocab:
# после предподсчёта мы бы сразу отдали результат
# return model.vectors[word]
result = model.vectors_vocab[word]
else:
result = zeros()
n = 1
for ngram in get_ngrams(word, model.min_n, model.max_n):
result += model.vectors_ngrams[hash(ngram)]
n += 1
return result / n
```
То есть: эмбеддинг каждого слова — это среднее из его "личного" эмбеддинга (если таковой имеется), и всех эмбеддингов его n-грамм. Такой подход позволяет модели догадаться, что, скажем, ранее не виденное слово `минуточка` — это что-то среднее из `минут`, `уточк`, `точка`, и некоторых других менее понятных n-грамм. Что, конечно, не очень умно, но гораздо лучше, чем не обрабатывать неизвестное слово вообще никак.
Для обучения и применения моделей fastText стандартом являются две библиотеки: собственно [fastText](https://fasttext.cc/) (доступна в Python и из командной строки), и [Gensim](https://radimrehurek.com/gensim/models/fasttext.html) (чисто Python). В моей статье я привожу питонячий код, совместимый с Gensim.
По факту, после обучения в Gensim происходит предподсчёт эмбеддингов всех слов, входящих в словарь модели. То есть на основе `model.vectors_vocab` и `model.vectors_ngrams` вышеописанным кодом формируется матрица словных эмбеддингов `model.vectors`, в которой учтены и "личные" эмбеддинги слов, и эмбеддинги n-грамм. Теперь `model.vectors_vocab` больше напрямую не используется, а `model.vectors_ngrams` используется только для незнакомых слов.
Методы сжатия моделей
---------------------
FastText (как и все другие нейросетевые модели) состоит из больших числовых матриц. Конкретно в этой модели их две: эмбеддинги отдельно взятых слов, и эмбеддинги буквенных n-грамм, из которых строятся эмбеддинги незнакомых слов. Возможных буквенных n-грамм комбинаторно много, и чтобы не учитывать их всех явно, fastText использует [hashing trick](https://en.wikipedia.org/wiki/Feature_hashing): номер строки в матрице эмбеддингов, соответствующий n-грамме, вычисляется как хэш этой n-граммы. Чем длиннее матрица эмбеддингов, тем меньше в таком подходе будет коллизий (а значит, выше точность эмбеддингов), но тем больше будет в ней неиспользуемых строк. Например, в модели [ruscorpora\_none\_fasttextskipgram\_300\_2\_2019](http://vectors.nlpl.eu/repository/20/181.zip) с RusVectores 2 миллиона строк в матрице эмбеддингов, но только 330 тысяч из них реально используются.
Собственно, на этом параметре — длине матрицы эмбеддингов n-грамм — основан [рецепт сжатия fastText от Андрея Васнецова](https://medium.com/@vasnetsov93/shrinking-fasttext-embeddings-so-that-it-fits-google-colab-cd59ab75959e). Он уменьшает число строк в ней с 2 миллионов до 500 тысяч, размещая в каждой строке новой матрицы средневзвешенное из строк старой матрицы. В качестве весов используется число пар "слово + n-грамма из него", попадавших в соответствующие строки в старой и новой матрице; сами слова берутся из фиксированного словаря той же модели. Это позволяет сжать модель в несколько раз, не сильно изменив эмбеддинги слов, и без необходимости обучать модель заново. Насколько именно "не сильно", Васнецов предлагает оценивать по среднему косинусному сходству между эмбеддингами старой и новой модели. У него получается сжать англоязычную модель с 16 до 2 гигабайт, сохранив 94% сходство моделей, сжав вышеописанным образом эмбеддинги n-грамм, и отбросив эмбеддинги наименее частотных слов (частота слов в обучающей выборки зашита внутри модели `gensim`).
Коллеги из Фейсбука, исходно придумавшие fastText, сами предложили ещё один простой способ сократить число строк в матрице — обнулить "не очень полезные" эмбеддинги, и написали об этом (и о квантизации, о которой речь пойдёт ниже) [блогпост](https://fasttext.cc/blog/2017/10/02/blog-post.html#model-compression) и [статью](https://arxiv.org/abs/1612.03651). "Полезность" эмбеддинга слова или n-граммы для задачи классификации можно грубо оценить по векторной норме этого эмбеддинга. А для задачи получения представлений слов (она, в отличие от классификации, self-supervized) полезность можно оценить по частотности.
Кроме длины матрицы эмбеддингов, можно пытаться сократить её ширину. Стандартная размерность эмбеддинга fasttext — 300. Выполнив сингулярное разложение ([SVD](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BD%D0%B3%D1%83%D0%BB%D1%8F%D1%80%D0%BD%D0%BE%D0%B5_%D1%80%D0%B0%D0%B7%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5#%D0%9F%D1%80%D0%B8%D0%B1%D0%BB%D0%B8%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D0%B5%D0%B9_%D0%BC%D0%B5%D0%BD%D1%8C%D1%88%D0%B5%D0%B3%D0%BE_%D1%80%D0%B0%D0%BD%D0%B3%D0%B0)), можно представить матрицу `n*300` как произведение двух матриц `n*k` и `k*300`. Чем меньше `k` — тем более экономным и менее точным будет такое представление. Этот способ достаточно универсален (им можно сжимать любые матрицы, а значит, любые нейронки), но не то чтобы очень эффективен, если размерность уже не очень высокая (а 300 для нейросетей — это мало).
Ещё одно направление для экономии — уменьшать "глубину" матрицы, то есть её точность. Обычно веса нейронок представляются 32-разрядными числами с плавающей точкой. Заменив их на 16-разрядные, можно сократить размер модели вдвое, почти не поплатившись точностью. Ещё более коротких float'ов Python не поддерживает, но можно обнаглеть, и перейти сразу на целочисленное представление. С помощью 8 бит можно описать 256 различных значений. Значит, можно разделить все числа из исходной матрицы эмбеддингов на 256 кластеров, и хранить в большой матрице только номера кластеров, а отдельно хранить их центры. Такой подход называется [квантизацией](https://en.wikipedia.org/wiki/Vector_quantization) (или квантованием) векторов, и широко применяется в народном хозяйстве.
Итак, мы заменили 300 32-разрядных дробных чисел на 300 8-разрядных целых. Как сжать матрицу ещё больше? Правильно, сопоставить каждому целому числу не одно дробное, а несколько — целый небольшой вектор! Например, можно разрезать 300-мерный вектор на 100 3-мерных векторов, и каждый 3-мерный вектор заменить одним целым числом. Таблица с ключами, соответственно, будет сопоставлять эти целые числа 3-мерным векторам, полученным в результате кластеризации всех таких 3-мерных кусочков. Это называется [product quantization](https://lear.inrialpes.fr/pubs/2011/JDS11/jegou_searching_with_quantization.pdf), и это тоже очень популярно. В частности, на такой квантизации основана библиотека [navec](https://github.com/natasha/navec) Александра Кукушкина, с помощью которой он сжал матрицы glove-эмбеддингов до невероятно компактных размеров, 25 и 50 мб. Если бы существовал простой способ обобщить его эмбеддинги для незнакомых слов, то и сжимать fasttext особо не было бы нужды. А так я всё-таки попробовал.
Моя методология
---------------
Все вышеописанные подходы я попытался так или иначе воспроизвести. Я стартовал с модели [ruscorpora\_none\_fasttextskipgram\_300\_2\_2019](http://vectors.nlpl.eu/repository/20/181.zip) c 300-мерными эмбеддингами, 165K словами в словаре и 2000K эмбеддингами n-грамм (n от 3 до 5), обученную на леммах. В памяти такая занимает "всего лишь" 2.7 гигабайт. Я загружал модель в формате [gensim](https://radimrehurek.com/gensim), и везде дальше будет иметься в виду именно он (версия `gensim==3.8.1`). Кроме того, во всех экспериментах я по умолчанию буду уменьшать матрицу словаря и матрицу n-грамм в одно и то же число раз (просто чтобы измерять зависимость от одного параметра, а не от двух).
Оговорюсь про ещё одну поправку: после загрузки исходной модели, я применил к ней метод `adjust_vectors`, приводящий в соответствие друг другу векторы для слов и для n-грамм. Теоретически, он не должен менять в модели вообще ничего. Но модель `ruscorpora_none_fasttextskipgram_300_2_2019` была обучена до [обновления](https://github.com/RaRe-Technologies/gensim/pull/2313) пакета `gensim`, векторы в ней хранятся как-то иначе, и `adjust_vectors` меняет их значения. Почему это важно: с новыми значениями качество intrinsic evalution (про него будет ниже) ухудшается. То есть в ходе всех своих экспериментов я пытаюсь сжимать не самую лучшую модель. А чтобы избежать просадки в качестве, методы сжатия модели, меняющие словарь, нужно применять к моделям, обученным на достаточно новой версии пакета `gensim`. Но конкретно для моей задачи это не очень важно: мне нужно измерить, насколько падает качество модели при её сжатии, а не насколько качественна модель сама по себе.
Для подсчёта размера модели в памяти я всюду использовал функцию, комбинирующую `sys.getsizeof` (для оценки всех объектов, кроме `numpy`-массивов), `numpy.ndarray.nbytes` (для них, родимых), и `gc.get_referents` для получения ссылок на "дочерние" объекты. Размер модели, сохранённой на диск (стандартным методом `save` из `gensim`, который, в свою очередь, использует `pickle`) может отличаться от её размера в оперативной памяти, но в целом, кажется, неплохо с ним коррелирует.
Качество сжатия, как и Андрей Васнецов, я решил оценивать по средней косинусной близости векторов сжатой и оригинальной модели. Эту близость я усредняю по корпусу из 80К лемм, наиболее часто встречающихся (хотя бы 10 раз) в социальном сегменте [корпуса Тайга](https://tatianashavrina.github.io/taiga_site/segments). Леммы извлекал с помощью pymorphy2, выкидывал все однобуквенные слова и слова, не содержащие кириллицы; заменял ё на е. Оказалось, что 54К этих лемм входят в словарь исходной модели fastText, а 26К — отсутствуют. Сырые и лемматизированные словари выложены [в репозиторий](https://github.com/avidale/compress-fasttext/tree/master/data/model_vocab).
Не очевидно, как качество сжатия влияет на полезность эмбеддингов для прикладных задач. Поэтому кроме сходства старых и новых векторов я провёл так называемое *intrinsic evaluation*: проверку, насколько косинусное сходство векторов для пары слов соответствует человеческой оценке сходства этих слов. Это ещё не совсем то, чего хочется на самом деле измерить: на самом деле нас интересует, насколько хорошо эмбеддинги позволяют решить задачи классификации, NER, и т.п. Но такое сложно измерить быстро и качественно, т.к. нужно обучать дополнительные модели. Поэтому обойдёмся только сходствами векторов.
Для intrinsic оценки я использовал четыре размеченных датасета: `hj`, `ae` и `rt` взяты с воркшопа [RUSSE](https://russe.nlpub.org/downloads/), а `simlex965` (далее `sl`) — с [RusVectores](https://rusvectores.org/static/testsets/) ([статья](https://arxiv.org/abs/1801.06407) с описанием). `hj` и `sl` содержат дробные оценки сходства пар слов, и на них я оцениваю корреляцию Спирмана этих оценок и косинусного расстояния векторов. `ae` и `rt` содержат бинарные оценки сходства пар слов, и для них я оцениваю `2*ROC_AUC-1`, где ROC AUC вычисляется также для косинусного расстояния относительно бинарных меток. Я использую эту метрику, а не предлагаемую авторами `ae` и `rt` precision, чтобы не заниматься отдельно подбором порога для классификации. Все четыре датасета также выложены [в репозиторий](https://github.com/avidale/compress-fasttext/tree/master/data/word_similarity).
Эксперименты
------------
Первый и самый дешёвый шаг: отпиливаем от модели матрицу `vectors_vocab` (она нужна только для обучения модели, а не для применения), и сокращаем разрядность матриц `vectors` и `vectors_ngrams` с 32 до 16 бит. Эмбеддинги не изменились практически никак, а модель похудела с 2.7 до 1.28 ГБ. Что ж, хорошее начало. Любопытства ради оставляю в такой модели только n-граммы (1.14 ГБ) или только слова (136 МБ).
Следующая попытка: сокращение размерности матриц с помощью модели `TruncatedSVD` из `scikit-learn`. Сокращается она не очень охотно: при уменьшении матриц всего лишь вдвое теряется уже 8% точности. А мне хотелось бы с такой потерей качества сокращать модель в десятки раз.
Что ж, раз матричное разложение работает так себе, надо пробовать квантизацию. Я скопипастил квантизованное представление матриц из библиотеки `navec`, чуть упростив его (мне не нужны предподсчтёты для вычисления сходства векторов). Квантизация работает заметно приятнее: без сокращения размерности (чисто за счёт замены float на int) размер модели падает вдвое при 99.6% сходстве векторов. Если сократить размерность ещё втрое, сходство остаётся порядка 96%. Однако при дальнейшем сокращении размерности качество начинает падать драматически. Интуитивно это объяснимо: при уменьшении размерность сжатой матрицы, растет размерность кластеризуемых векторов, растёт (экспоненциально!) их многообразие, и они всё хуже приближаются 256 точками. Если сжать размерность в 12 раз (разбив эмбеддинг на 25 векторов), такая моделька будет занимать чуть меньше 94 МБ, но её сходство с оригиналом будет только 75%. Негоже.
Следующий эксперимент — избавление от редких слов и увеличение плотности хэшей в матрице n-грамм, т.е. метод Васнецова. Для меня было неожиданностью, что этот метод дал заметно более пологую кривую зависимости качества от размера модели. Так, при сжатии модели до 128 МБ (x10, по сравнению с базовым 16-разрядным вариантом) векторы остались похожи на 95%, а при сжатии до 25 МБ — на 82%. Ещё не идеал, но уже близко.
Почему переупаковка n-грамм так хорошо работает? Потому что большая часть строк в их матрице не используется или используется очень редко. Можно попробовать использовать это явно, вернувшись к старой идее отбора признаков. То есть: вместо изменения хэш-функции можно просто запомнить, какие строки матрицы n-грамм используются наиболее часто (в наибольшем количестве разных слов из словаря модели), и все остальные строки просто выкинуть. Если выкинуть только неиспользуемые строки (векторы от этого не изменятся почти ни насколько) и сохранить в словарике соответствие между старыми и новыми номерами строк, размер модели "бесплатно" сократится до 450 МБ (почти втрое). 45-мегабайтная версия даёт 93.6% сходства.
Чтобы жить стало совсем хорошо, можно сделать ещё один маленький шаг: объединить, как это сделали разработчики fastText-классификатора, "отбор признаков" и квантизацию. Одна из первых гибридных моделек (20К слов, 100К n-грамм, 100-мерная квантизация), при размере в 28 мегабайт (в 100 раз!), дала 96.15% сходство с оригиналом. Что можно считать успехом. Вдохновившись им, я перебрал 36 комбинаций размеров сокращенных словарей и степени квантизации.
Рисунок ниже отражает эти эксперименты. По горизонтальной оси — размер модели, по вертикальной — среднее косинусное сходство старых и новых словных эмбеддингов. Чем ближе мы к левому верхнему углу, тем лучше: маленькая модель воспроизводит полную достаточно точно. На всех трёх рисунках одни и те же модели, но раскрашены они в зависимости от размерности квантизованного вектора, либо от размера матрицы слов, либо от размера матрицы n-грамм.
Оказалось, что ни для одного из параметров нет "наилучшего" значения: любой из размеров словарей или степени квантизации является оптимальным при каком-то значении других параметров.
Подобным же образом можно отобразить все мои эксперименты (из 36 смешанных моделей здесь и далее я отобразил только 15 Парето-оптимальных, чтобы не засорять график). Видим, что фильтрация словаря эффективнее остальных методов, а применение квантизации делает её ещё эффективнее.
Больше метрик богу метрик!
--------------------------
В ходе экспериментов я сопоставлял размер модели в RAM и сходство её векторов с векторами оригинала на 80К леммах из корпуса Тайга. А что с остальными метриками?
Для начала, посмотрим на сходство эмбеддингов по отдельности для слов, входящих и не входящих в словарь исходной модели. Качественно зависимость примерно одинаковая. В целом, это неудивительно, ведь в большинстве экспериментов я сжимал эмбеддинги слов и эмбеддинги n-грамм в одно и то же число раз. При этом видно, что при квантизации незнакомые слова (т.е. n-граммы) страдают особенно сильно, по сравнению со знакомыми словами. Видимо, это связано с тем, что кластеризация, на которой основана квантизация, никак не учитывает то, что одни n-граммы встречаются чаще других — а значит, более важные.
Размер модели на диске, что ожидаемо, почти идентичен её размеру в памяти. Тут никаких сюрпризов.
Скорость модели будем оценивать средним временем на получение эмбеддинга слова, по тем же 80К леммам из Тайги. Здесь тоже ничего удивительного: квантизация и разложение матриц сильно замедляют работу модели. Методы, связанные с удалением строк в матрице, тормозят не так сильно, но только пока словарь остаётся достаточно большим — а потом всё чаще приходится составлять эмбеддинг из n-грамм, а не из готовых слов, и замедление таки происходит. Замедление от квантизации и от уменьшения словаря суммируется.
Наконец, intrinsic evaluation. На всех четырёх датасетах зависимость качества от размера и типа модели выглядит качественно примерно одинаково и точно так же, как сходство старых векторов с новыми. Единственное очевидное различие — сравнительное изменение качества при выкидывании из модели только слов либо только n-грамм. В зависимости от того, какую долю датасета составляют OOV слова, эти изменения сказываются на качестве модели по-разному.
Впрочем, точность воспроизведения векторов и intrinsic evaluation не равносильны друг другу. При том же значении среднего сходства, квантизация и сокращение размерности дают более высокое качество на парах слов, чем уменьшение словаря. Видимо, эти методы сильно искажают слова, но при этом искажают семантически близкие слова похожим образом, и поэтому intrinsic evaluation не так сильно страдает в результате сжатия.
Числа, по которым построены все вышеприведённые графики, выложены [в репозитории проекта](https://github.com/avidale/compress-fasttext/blob/master/experiments/metrics.csv).
Итоги
-----
Fasttext — полезная и удобная модель, но внушительные размеры не позволяют запускать её на тесных бесплатных хостингах, на которых можно было бы разместить чат-бота, включать её в мобильные продукты, или извлекать из неё пользу множеством других способов. Предложенные коллегами и собранные мною методы — квантизация и отбор признаков — позволяют сократить размеры модели в 100 раз, увеличивая её доступность для разработчиков. При этом векторы сжатой модели имеют 96% сходство с оригиналом, и лишь на 3% хуже работают на задачах оценки семантической близости.
Код для сжатия моделей их последующего применения доступен в [репозитории](https://github.com/avidale/compress-fasttext) и [на PyPI](https://pypi.org/project/compress-fasttext/). Также для скачивания доступны 13, 28, 51 и 180-мегабайтные [модели](https://github.com/avidale/compress-fasttext/releases/tag/v0.0.1) — сжатые версии модели [ruscorpora\_none\_fasttextskipgram\_300\_2\_2019](http://vectors.nlpl.eu/repository/20/181.zip) с сайта [RusVectores](https://rusvectores.org/ru/models/).
В ближайшем будущем я перейду от сжатия словных эмбеддингов к созданию компактной модели фразных эмбеддингов для русского языка. Если хотите поучаствовать, либо предложить или покритиковать что-нибудь, пишите мне на [Хабр](https://habr.com/ru/users/cointegrated/) или в [ODS](https://app.slack.com/team/U14DMFHJB).
Апдейт от 10.06.2021: успешно обучил [компактный русский BERT](https://habr.com/ru/post/562064/). | https://habr.com/ru/post/489474/ | null | ru | null |
# Выразить иерархически: вопрос как увидеть хамелеона
**Проблема** нейросетей - невозможность обучаться на единичных примерах. Справиться может табличное RL, но обучаться на данных большой размерности - иная неразрешимая сторона этой парадигмы <https://habr.com/ru/post/437020/>. **Решение** только в одном: видеть мир иерархически, где каждая его подчасть также может быть выражена иерархически.
Как здесь <https://habr.com/ru/post/420219/> - сложность игры которой сокращается за счет введения небоевого состояния, подсостояниями которого являются ожидание и патрулирование.
Хабр. Обзор техник реализации игрового ИИТеперь маштабируем этот подход. На этот счет интересны рассуждения В.Турчина
Турчин // Феномен науки. Кибернетический подход к эволюцииИ игра, и каждое из ее состояний, и каждый из классификаторов иерархии представлен какой-то отдельностью. Так видеть - естественно для человека. Но не для машины.
Вот что пишет об этом А. Карпатый <https://habr.com/ru/post/439674/>. Как только вы поймете «хитрость», с помощью которой работают эти алгоритмы, вы сможете понять их сильные и слабые стороны. В частности, **эти алгоритмы далеко отстают от людей в построении абстрактных представлений об играх**.
Так каков критерий видеть эти отдельности? Попытки представить предметы и явления как результат алгоритмов, например, свертки - лишь частный случай более фундаментального подхода.
![Р. Эшби .//Введение в кибернетику [стр 63]](https://habrastorage.org/r/w780q1/getpro/habr/upload_files/02f/fcc/e41/02ffcce41f9e16f70d0c0604d45097ee.jpg "Р. Эшби .//Введение в кибернетику [стр 63]")Р. Эшби .//Введение в кибернетику [стр 63]Пусть имеется мячик (синий квадрат) как в игре пинг-понг, летящий по некой траектории.
Как мы понимаем, что это отдельная сущность, а не множество синих мячей появляющихся и исчезающих в разных точках пространства? Контраст предмета синий и белого фона? А если этот предмет будет менять цвет, например на случайно выбранные синий, серый (код ниже, BALL\_CHANGE\_BG = True)? Вроде на фоне белого же. Но что если фоном будет случайно выбранные цвета?
Из трассировок видно, например, что из состояния (1,2) следует как состояние (1,3), так и состояния (2,3), (0,3). По этой причине невозможно (если переходы равновероятны) поймать синий мячик из этого состояния. Выигрыш не более 1/3, если основываться только на политике без учета предшествующих состояний.
**Можно попытаться найти такое действие, которое бы приводило к желаемой однозначности.** Им является предшествующее состояние. Тогда: (1,2) перейдет однозначно в (1,3) при действии (1,1); (1,2) перейдет только в (2,3) при действии (0,1); (1,2) перейдет только в (0,3) при (2,1).
Всегда ли можно найти однозначные преобразования, подобрав необходимые действия? Нет конечно. Но к этому нужно стремится. Ниже 4 фрагмента.
1. Действие неизвестно. По умолчанию оно одно (условно f). Коэффициент однозначности 0.6
2. Вносим неустраняемую неопределенность отскока от черного квадрата. Коэффициент будет ниже.
3. Выбраны верные действия. Коэффициент единица (однозначность сто процентов),. Теперь, зная граф переходов, безошибочно вычисляется куда прилетит синий мяч.
4. Добавляем неопределенность к верным действиям. Из состояния (1.2) она максимальна из-за черного квадрата (неопределенный отскок)
Так как же можно разглядеть явления, которые могут как влиять друг на друга, так и быть иерархически выстроены?
Ниже лабиринт (Л) - это одно из сменяемых состояний {11, 12, 14, 15} в результате действий {31, 32}. В свою очередь, состояние лабиринта ключ (11) тоже выражено сменой своих подсостояний {45, 44, 41} в результате действий {35, 36, 34}. И состояние лабиринта дверь (12) управляется ключом (11). Управляется по той причине, что состояния ключа являются действиями для двери. Когда подсостояние двери принимает значение открыто (54), агент может из лабиринта (Л) перейти в комнату (км) и найти клад (63). **В отдельно взятой таблице поиск оптимального пути может осуществляться средствами RL.**
Но! **В начале игры агент ничего не ведает**, что есть клад. Не ведает что есть эти отдельности (лабиринт, ключ, двер, комната). Он лишь наблюдает поток данных. Сначала [32, 52, .., 52, ..], затем [.., .., 44, .. 36] и т.д. Рассматривает **разные гипотезы, стремясь максимизировать коэффициент однозначности**. Так, рассмотрев черную гипотезу, приходит к выводу, что есть некая сущность (11), состояниями которой являются {45, 44, 41}. Обнаруживает также однозначность переходов сущности (12). И далее уже о сущности (Л) тоже мыслит как о какой-то отдельности, переходы состояний которой однозначны. По той простой причине, что для красной гипотезы (попытка понять что есть лабиринт) состояния {44, 41, 45} заменятся на (11), а состояния {52, 53, 54} заменятся на (12).
По Турчину, **(11) и (12) являются классификаторами нижнего уровня для классификатора (Л) более верхнего уровня, образуя иерархию понятий**.
Ниже представлен код для игры в понг, но без части максимизации однозначности и без оптимизации маршрута по графу (состояние и действие мяча, состояние и действие ловящего мяч) . Без комментариев.
```
# Выразить иерархически: вопрос как увидеть хамелена
from tkinter import *
import random
class Hd():
def __init__(self, graph):
self.graph = graph
def rnd_get(self, v):
return random.choice(v.split("|"))
def show(self, graph):
for x in graph:
print(x, ":", graph[x])
def get_ku(self, graph):
'''return (коэффициент однозначности, размер)'''
n = 0; u = 0
for x in graph:
for y in graph[x]:
if y[0]:
u += y[0].count("|")
n += 1
if n != 0:
return (round(1- u/(n+u), 3), n+u)
else:
return (None, None)
def get_states(self, x, f_list = [], n=11):
x_list = []
x_list.append(x)
if f_list != []:
for f in f_list:
xf = [xf for xf in g[x] if xf[1] == f]
if not xf:
x_list.append(''); f_list[len(x_list)-2] = ''
return (x_list, f_list[:len(x_list)-1])
x = self.rnd_get(xf[0][0])
x_list.append(x)
else:
for i in range(n):
if not self.graph[x]:
x_list.append(''); f_list.append('')
break
t = random.choice(self.graph[x])
f = t[1]
x = random.choice(t[0].split('|'))
x_list.append(x); f_list.append(f)
if len(f_list) == len(x_list) -1:
return (x_list, f_list)
else:
return ([], [])
def get_yfx(self, f_list, x_list, t = True):
if len(x_list) == len(f_list):
x_list.append('')
path = []
for i in range(len(f_list)):
path.append((x_list[i], f_list[i], x_list[i+1]))
if t:
return path #(x, f, next_x)
else:
p = []
for xfy in path:
if xfy[2] != '':
p.append(xfy[2]+'='+xfy[1]+'('+xfy[0]+')')
return p
def flow(self, path, rnd=False):
if not path: return []
fl = []
for p in path:
if not rnd:
fl.append(p[:-1])
else:
pr = list(p[:-1])
#random.shuffle(pr)
fl.append(tuple(pr))
fl.append(pr)
return fl
def fORx(self, flow, f=0):
'''index: f=0, x=1 or x=0, f=1'''
def add_empty():
empty = []
for k in graph:
for x in graph[k]:
z = list(set(x[0].split('|')) - set(list(graph.keys())))
if z:
empty.append(z[0])
return empty
if not flow: return []
graph = {}
fli = flow[0]
for t in flow[1:]:
if f == 0:
if fli[1] not in graph:
graph[fli[1]] = []
r = [(i, xf) for i,xf in enumerate(graph[fli[1]]) if xf[1] == fli[0]]
if r:
if t[1] not in r[0][1][0]:
x_new = r[0][1][0] + "|" + t[1]
if x_new != '':
graph[fli[1]][r[0][0]] = (x_new, r[0][1][1])
if not r:
if t[1] != '':
graph[fli[1]].append((t[1], fli[0]))
if f == 1:
if fli[0] not in graph:
graph[fli[0]] = []
r = [(i, xf) for i,xf in enumerate(graph[fli[0]]) if xf[1] == fli[1]]
if r:
if t[0] not in r[0][1][0]:
x_new = r[0][1][0] + "|" + t[0]
if x_new != '':
graph[fli[0]][r[0][0]] = (x_new, r[0][1][1])
if not r:
if t[0] != '':
graph[fli[0]].append((t[0], fli[1]))
fli = t
em = add_empty()
if em:
graph[em[0]] = []
return graph
def merge(self, g1, g2):
def find_index():
for i in range(len(graph[k])):
if graph[k][i][1] == x[1]:
return i
return -1
all_keys = set(list(g1.keys()) + list(g2.keys()))
graph = {}
for k in all_keys:
if k not in graph:
if k in g1:
graph[k] = g1[k]
else:
graph[k] = g2[k]
if k in g2:
for x in g2[k]:
ind = find_index()
if ind != -1:
if x[0] != []:
t1 = x[0].split('|')
if graph[k][ind] != -1:
t2 = graph[k][ind][0].split('|')
z = "|".join(set(t1+t2))
#xf = [z, graph[k][ind][1]]
xf = (z, graph[k][ind][1])
graph[k][ind] = xf
else:
graph[k].append(x)
return graph
class Wednesday():
def __init__(self, root, maps, ban):
self.root = root
self.maps = maps
self.ban = ban
Wednesday.time = {}
Wednesday.hierarchy = {}
Wednesday.neighbor = {}
self.init_3_dict()
def init_3_dict(self):
def is_en(yx):
if yx[0] < 0 or yx[0] > len(self.maps)-1: return
if yx[1] < 0 or yx[1] > len(self.maps[0])-1: return
if yx in self.ban: return
return True
for y in range(len(self.maps)):
for x in range(len(self.maps[0])):
Wednesday.hierarchy[(y,x)] = self.maps[y][x]
n = []
if is_en((y-1,x)):
n.append((y-1,x))
if is_en((y+1,x)):
n.append((y+1,x))
if is_en((y,x-1)):
n.append((y,x-1))
if is_en((y,x+1)):
n.append((y,x+1))
if is_en((y-1,x-1)):
n.append((y-1,x-1))
if is_en((y-1,x+1)):
n.append((y-1,x+1))
if is_en((y+1,x+1)):
n.append((y+1,x+1))
if is_en((y+1,x-1)):
n.append((y+1,x-1))
Wednesday.neighbor[(y,x)] = n
Wednesday.time[(y,x)] = 0
if (y, x) in self.ban:
lb = Label(text=" ", background = 'black')
lb.configure(text=self.maps[y][x])
else:
bg = "white"
if CHANGE_BG:
bg = random.choice(["yellow", "red", "white", "brown", "pink"])
lb = Label(text=" ", background = bg)
lb.configure(text=self.maps[y][x])
lb.grid(row=y, column=x, ipadx=15, ipady=10, padx=1, pady=1)
def update(self):
for y in range(len(self.maps)):
for x in range(len(self.maps[0])):
if Wednesday.time[(y,x)]:
Wednesday.time[(y,x)] -=1
else:
Wednesday.hierarchy[(y,x)] = self.maps[y][x]
if not (y, x) in self.ban:
bg = "white"
if CHANGE_BG:
bg = random.choice(["yellow", "red", "white", "brown", "pink"])
lb = Label(text=" ", background = bg)
lb.configure(text=Wednesday.hierarchy[(y,x)])
lb.grid(row=y, column=x, ipadx=15, ipady=10, padx=1, pady=1)
self.root.after(TIME, self.update)
class Base():
def __init__(self, root, color, node):
self.root = root
self.color = color
self.y = node[0]
self.x = node[1]
self.visit = {}
self.neighbor = {}
self.count = 0
def show(self, y, x, color):
lb = Label(text=" ", background = color)
try:
lb.configure(text=Wednesday.hierarchy[(y,x)] )
lb.grid(row=self.y, column=self.x, ipadx=15, ipady=10, padx=1, pady=1)
except:
pass
def add_neighbor(self):
try:
self.neighbor[(self.y, self.x)] = Wednesday.neighbor[(self.y, self.x)]
except:
pass
def choice(self, yx):
self.add_neighbor()
return random.choice(self.neighbor[yx])
def move(self):
yx = self.choice((self.y, self.x))
self.redraw(yx)
self.count +=1
def redraw(self, yx):
self.show(self.y, self.x, 'white')
self.y = yx[0]
self.x = yx[1]
self.show(yx[0], yx[1], self.color)
def update(self):
self.move()
self.root.after(TIME, self.update)
def env(self):
return (self.color, (self.y, self.x))
class WhoBeats(Base):
def __init__(self, root, color, node, lenYX):
super().__init__(root, color, node)
self.lenYX = lenYX
self.balls = []
def choice(self, yx):
self.add_neighbor()
if self.count % (self.lenYX[1] +PAUSE) == 0:
y = yx[0] + random.choice([-1, 0, 1])
if y < 0:
y = 0
if y > self.lenYX[0] -1:
y = self.lenYX[0] -1
dy = y-yx[0]
ball = Ball(root, "blue", (y, yx[1]), self.lenYX, dy)
self.balls.append(ball)
ball.update()
yx = list(random.choice(self.neighbor[yx]))
yx[1] = 0
return tuple(yx)
def get_balls(self):
for ball in self.balls:
pass
return self.balls
class Ball(Base):
def __init__(self, root, color, node, lenYX, dy):
super().__init__(root, color, node)
self.lenYX = lenYX
self.dy = dy
def choice(self, yx):
if BALL_CHANGE_BG:
self.color = random.choice(["grey", "blue"])
self.add_neighbor()
if yx[0] <= 0:
self.dy = 1
if yx[0] >= self.lenYX[0]-1:
self.dy = -1
try:
if (yx[0] +self.dy, yx[1] + 1) in self.neighbor[yx]:
yx = (yx[0] +self.dy, yx[1] + 1)
else:
if yx[1]+1 >= self.lenYX[1]:
yx = (yx[0], self.lenYX[1])
else:
v = []
for i in self.neighbor[yx]:
if not i in self.visit:
self.visit[i] = 0
v.append((i, self.visit[i]))
v.sort(key = lambda x: x[1], reverse = False)
v = [i for i in v if v[0][1] == i[1]]
v = random.choice(v)
self.visit[v[0]] += 1
yx = v[0]
self.dy = random.choice([-1,1])
except:
pass
return yx
class WhoСatches(Base):
def __init__(self, root, color, node, lenYX, whoBeats):
super().__init__(root, color, node)
self.lenYX = lenYX
self.whoBeats = whoBeats
self.win = 0
self.routes = []
self.route = []
self.gf = [{}, {}]
self.hdWC = Hd({})
def choice(self, yx):
self.add_neighbor()
self.neighbor[yx] = [x for x in self.neighbor[yx] if x[1] == self.lenYX[1]-1]
dy = self.action()
if (yx[0] +dy, yx[1]) in self.neighbor[(yx[0], self.lenYX[1]-1)]:
hd = Hd({})
hdF = self.tuple_str((dy,0))
hdX = self.tuple_str(yx)
hdY = self.tuple_str((yx[0] +dy, yx[1]))
path = hd.get_yfx([hdX, hdY], [hdF, ""])
gn = hd.fORx(hd.flow(path), f=0)
self.hdWC.graph = hd.merge(self.hdWC.graph, gn)
print("\nwhoСatches ku = ", self.hdWC.get_ku(self.hdWC.graph))
self.hdWC.show(self.hdWC.graph)
yx = (yx[0] +dy, self.lenYX[1]-1)
self.winner()
return yx
def action(self, choice = None):
if choice == None:
dy = random.choice([-1,0,1])
return dy
def hypothesis(self, x_list, f = None):
if f == None:
f_list = ["f"]*len(x_list)
return (f_list, x_list)
else:
f_list = x_list[:-1] #дейсвие = предыдущее состояние
x_list = x_list[1:]
return (f_list, x_list)
def tuple_str(self, v, convert = True):
if convert:
delimiter = ','
r = delimiter.join([str(x) for x in v])
else:
r = [ x for x in v.split(',')]
return r
def winner(self):
balls = self.whoBeats.get_balls()
for i, ball in enumerate(balls):
if ball.env()[1][1] == 1:
self.route = []
self.route.append(ball.env()[1])
elif ball.env()[1][1] < self.lenYX[1]-1:
self.route.append(ball.env()[1])
else:
self.route.append(ball.env()[1])
if self.route not in self.routes:
self.routes.append(self.route)
if self.x == ball.env()[1][1]:
if self.y == ball.env()[1][0]:
self.win +=1
else:
self.win -=1
root.title("win = " + str(self.win))
self.whoBeats.balls.pop(i)
if self.routes:
hd = Hd({})
for x_list in self.routes:
x_list = [self.tuple_str(x) for x in x_list]
if HYPOTHESIS:
f_list, x_list = self.hypothesis(x_list, f=True)
else:
f_list, x_list = self.hypothesis(x_list)
path = hd.get_yfx(x_list, f_list)
gn = hd.fORx(hd.flow(path), f=0)
self.gf[0] = hd.merge(self.gf[0], gn)
ku = hd.get_ku(self.gf[0])
print("\n\nball ku =", ku)
hd.show(self.gf[0])
print("\nroutes")
t = [print(x) for x in self.routes]
#--------- main ---------#
if __name__ == "__main__":
TIME = 500 #частота обновления
PAUSE = 5
HYPOTHESIS = True
CHANGE_BG = False
BALL_CHANGE_BG = False
#CHANGE_BG = True
#BALL_CHANGE_BG = True
root = Tk()
#ban=[(1,3), (1,5), (1,6), (1,7), (0,7), (1,4), (2,4), (3,4), (4,3), (4,4), (5,6), (5,7), (4,7), (3,7), (2,7)]
#M=8; N=12
ban=[(1,3)]
#ban = []
M=3; N=6
maps = [["" for i in range(N)] for j in range(M)]
def update():
#w1.update()
b1.update()
c1.update()
w1 = Wednesday(root, maps, ban)
b1 = WhoBeats(root, "red", (1,0), (M, N))
c1 = WhoСatches(root, "green", (1,N-1), (M, N), b1)
update()
root.mainloop()
``` | https://habr.com/ru/post/690518/ | null | ru | null |
# Разработка UI с помощью Flutter
Привет, Хабр! Представляем вашему вниманию перевод статьи "[Building Layouts](https://flutter.io/docs/development/ui/layout#whats-the-point)".
Сегодня мы узнаем:
------------------
* Как работают механики построения UI на Flutter
* Как верстать экраны горизонтально и вертикально
* Как сверстать экран, используя Flutter
Результатом сегодняшнего урока будет следующий сверстанный экран
Шаг 0: Настройка проекта
------------------------
Для начала создадим новый проект File -> New Flutter Project -> next, next, next…
Далее необходимо, создать директорию images в корне проекта и положить туда файл с именем lake.jpg — сам файл скачать можно отсюда — [link](https://raw.githubusercontent.com/flutter/website/master/src/_includes/code/layout/lakes/images/lake.jpg)
Так же необходимо поправить конфигурационный файл pubspec.yaml (что-то вроде gradle для android и cocoa pods в iOS, в нем мы можем добавить внешние зависимости). Сам текст файла можно скачать [здесь](https://raw.githubusercontent.com/flutter/website/master/src/_includes/code/layout/lakes/pubspec.yaml)
Исходник проекта можно скачать [здесь](https://raw.githubusercontent.com/flutter/website/master/src/_includes/code/layout/lakes/main.dart) — его необходимо поместить в файл main.dart
Шаг 1: Диаграмма экрана
-----------------------
Для начала разобьем макет на простые элементы
* Определим строки и столбцы
* Определим включает ли макет сетку?
* Есть ли перекрывающие элементы
* Нужны ли вкладки для пользовательского интерфейса?
* Обратим внимание на области требующие выравнивания или отступы
Сперва определим основные крупные элементы. В этом примере — 4 элемента расположены в виде столбца: картина, две строки и блок теста
Далее разберем каждую строку. Первая строка, которая называется «Заголовок» имеет 3 дочерних элемента — столбец текста, иконка звезды и число. Первый столбец содержит 2 строки. Первый столбец занимает много места, поэтому следует обернуть его в расширяемый виджет.
Следущий ряд, называемый секцией кнопок, так же имеет 3 дочерних элемента. Каждый из них содержит картинку и текст.
Наконец мы разложили макет на простые элементы. Проще всего использовать подход «снизу-вверх» для верстки дисплея. Для того чтобы избегать сложной структуры разбивайте UI на переменные и функции.
Шаг 2: Построим ряд заголовка
-----------------------------
Сперва, мы должны построить левый столбец секции заголовка. Вставка столбца внутри расширяемого виджета растягивает столбец для использования всего оставшегося места в ряду. Установим свойство crossAxisAlignment для CrossAxisAlignment.start для выравнивания столбца к началу строки.
Размещение строки текста внутри контейнера позволяет активировать отступы. Второй дочерний элемент в столбце это тоже текст, он отображается серым цветом. Последние два элемента иконка «звезды» нарисована красным цветом и текст со значением «41». Поместим целую строку в контейнер и добавим отступы по 32 пикселя с каждой стороны. Код для выполнения этих действий представлен ниже
```
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
Widget titleSection = Container(
padding: const EdgeInsets.all(32.0),
child: Row(
children: [
Expanded(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Container(
padding: const EdgeInsets.only(bottom: 8.0),
child: Text(
'Oeschinen Lake Campground',
style: TextStyle(
fontWeight: FontWeight.bold,
),
),
),
Text(
'Kandersteg, Switzerland',
style: TextStyle(
color: Colors.grey[500],
),
),
],
),
),
Icon(
Icons.star,
color: Colors.red[500],
),
Text('41'),
],
),
);
//...
}
```
Шаг 3: Построим ряд кнопок
--------------------------
Секция кнопок состоит из 3 столбцов, которые строятся по похожему принципу — иконка над строкой текста. Столбец в этой строке равномерно заполняется и текст и иконки рисуются основным цветом, который выбран голубым в нашем проекте в методе build().
```
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
//...
return MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
primarySwatch: Colors.blue,
),
//...
}
```
Так как код построения каждого ряда будет практически идентичен, то наиболее эффективно будет использовать вложенную функцию, такую как buildButtonColumn(), которая включает в себя иконку и текст и возвращает столбец с этим виджетом.
```
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
//...
Column buildButtonColumn(IconData icon, String label) {
Color color = Theme.of(context).primaryColor;
return Column(
mainAxisSize: MainAxisSize.min,
mainAxisAlignment: MainAxisAlignment.center,
children: [
Icon(icon, color: color),
Container(
margin: const EdgeInsets.only(top: 8.0),
child: Text(
label,
style: TextStyle(
fontSize: 12.0,
fontWeight: FontWeight.w400,
color: color,
),
),
),
],
);
}
//...
}
```
Функция построения добавляет иконку прямо в столбец. Поместим текст в контейнер для того чтобы добавить отступы и отделить его от иконки. Построим каждый ряд этих столбцов, вызывая функцию, и передавая иконку и текст внутрь столбца. Выровняем столбца вдоль главной оси, используя MainAxisAlignment.spaceEvenly, организуя свободное место до, между и после каждого столбца.
```
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
//...
Widget buttonSection = Container(
child: Row(
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
children: [
buildButtonColumn(Icons.call, 'CALL'),
buildButtonColumn(Icons.near_me, 'ROUTE'),
buildButtonColumn(Icons.share, 'SHARE'),
],
),
);
//...
}
```
Шаг 4: Построим секцию описания
-------------------------------
Определим секцию описания, которая довольно длинная. Поместим текст в контейнер и добавим отступы 32 пикселя от каждого края.
```
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
//...
Widget textSection = Container(
padding: const EdgeInsets.all(32.0),
child: Text(
'''
Lake Oeschinen lies at the foot of the Blüemlisalp in the Bernese Alps. Situated 1,578 meters above sea level, it is one of the larger Alpine Lakes. A gondola ride from Kandersteg, followed by a half-hour walk through pastures and pine forest, leads you to the lake, which warms to 20 degrees Celsius in the summer. Activities enjoyed here include rowing, and riding the summer toboggan run.
''',
softWrap: true,
),
);
//...
}
```
Шаг 5: Построим секцию с изображением
-------------------------------------
Три из четырех столбцов уже построены, осталось сделать только только столбец изображения. Изображение, которе используется в данном проекте находится доступно онлайн под лицензией «Creative Commons license». Но оно большое и загружаться оно будет медленно. В шаге 0 мы добавили изображение к нашему проекту и обновили конфигурационный файл, теперь добавим ссылку на него в своем коде.
```
return MaterialApp(
//...
body: ListView(
children: [
Image.asset(
'images/lake.jpg',
height: 240.0,
fit: BoxFit.cover,
),
// ...
],
),
//...
);
```
BoxFit.cover говорит фреймворку Flutter, что изображение должно быть как можно меньше, но при этом охватывать всю область рендеринга.
Шаг 6: Объединим все вместе
---------------------------
В финальном шаге соберем все кусочки нашего кода вместе. Виджет организован в ListView, а не Column потому ListView автоматически скроллится во время прокрутки на маленьком устройстве.
```
//...
return MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
primarySwatch: Colors.blue,
),
home: Scaffold(
appBar: AppBar(
title: Text('Top Lakes'),
),
body: ListView(
children: [
Image.asset(
'images/lake.jpg',
width: 600.0,
height: 240.0,
fit: BoxFit.cover,
),
titleSection,
buttonSection,
textSection,
],
),
),
);
//...
``` | https://habr.com/ru/post/433256/ | null | ru | null |
# Контролируем переполнение ячейки таблицы с помощью max-width
Допустим, мы хотим сделать двухколоночную раскладку с помощью свойства table-cell. Левая колонка будет занимать всю доступную ширину, правая же может иметь два варианта в нашем случае:
* мы зададим этой колонке фиксированную ширину;
* она будет равняться минимальной ширине контента → [minimum content width (MCW)](http://www.w3.org/TR/CSS21/tables.html#auto-table-layout).
У способа вёрстки на колонках есть один существенный минус → если содержимое внутри блока выходит за его рамки то ограничение заданное через width на него действовать не будет, потому что MCW в данном случае больше. Если же мы хотим растянуть левую колонку по всей ширине то нам придётся задать её ширину равной 100%. Соответственно, max-width: 100%; не даст никакого результата, потому что MCW и так выше этого значения. В результате вся наша вёрстка растянется и выйдет за пределы контейнера, какие бы ограничения мы не ставили.
Вот пример вёрстки с вариантом фиксированной колонки справа:
```
Левая колонка
Правая колонка
```
```
.leftBlock, .rightBlock
{
display: table-cell;
vertical-align: top;
}
.leftBlock
{
width: 100%;
}
.rightBlock
{
width: 200px;
max-width: 200px;
min-width: 200px;
}
```
[Пример на jsfiddle](http://jsfiddle.net/CyberAP/4ey6r/)
Как видим пока никаких проблем нет. Теперь добавим в левую колонку элементы которые будут превышать ширину контейнера за вычетом колонки справа:
[Пример на jsfiddle](http://jsfiddle.net/CyberAP/4ey6r/1/)
Ячейка слева растянулась несмотря на ограниченную ширину контейнера, появился скролл. Самое время представить хак. Как я уже сказал ранее, max-width: 100%; здесь не будет иметь никакого эффекта, но если мы зададим max-width: 0; то ячейка займёт всю доступную ширину с учётом ширины контейнера и ячейки справа. К сожалению, в спецификации нет уточнений по поводу этого эффекта, но он работает одинаково во всех браузерах.
Не забываем добавить левой колонке overflow: hidden; и word-wrap: break-word;, иначе содержимое будет вылезать за пределы контейнера.
[Окончательный пример на jsfiddle](http://jsfiddle.net/CyberAP/NUHTk/)
При втором варианте с нефиксированной правой колонкой всё будет ровно так же, только без задания каких-либо параметров ширины. | https://habr.com/ru/post/217911/ | null | ru | null |
# Псевдо Lens Flare
Привет, Хабр! Представляю вашему вниманию перевод статьи [«Pseudo Lens Flare»](http://john-chapman-graphics.blogspot.com/2013/02/pseudo-lens-flare.html) автора John Chapman.
**Lens flare** (блики на линзах) ― это фотографический артефакт, возникающий при рассеивании и преломлении света в системе линз. Хотя он является артефактом, существует множество поводов использовать **lens flare** в компьютерной графике:
* он увеличивает воспринимаемую яркость и видимый динамический диапазон изображения.
* **lens flare** часто встречается на фотографиях, поэтому его отсутствие может бросаться в глаза
* он может играть важную роль в стилистике или драматизме, или может быть частью геймплея в играх (представьте блики, ослепляющие игрока)
Традиционно **lens flare** в realtime реализовывался с помощью технологий, основанных на спрайтах. Хотя спрайты дают легко контролируемые и очень реалистичные результаты, они должны быть размещены явно и требуют данные окклюзии для корректного отображения. Здесь я опишу простой и относительно дешевый screen space эффект, который создает псевдо **lens flare** из входного color buffer. Он не основан на физике, поэтому результат немного отличается от фотореалистичного, но его можно использовать в комбинации с (или как замену) традиционными sprite-based эффектами.
Алгоритм
--------
Состоит из 4 этапов:
1. Downsample / threshold.
2. Генерация элементов **lens flare**.
3. Размытие.
4. Upscale / смешивание с оригинальным изображением.
### 1. Downsample / Threshold
**Downsampling** (уменьшение разрешения) ― оптимизация, чтобы уменьшить стоимость последующих этапов. Кроме того, мы хотим выбрать подмножество самых ярких пикселей исходного изображения. Использование **scale/bias** (масштаб/смещение) обеспечивает гибкий способ достичь этого:
```
uniform sampler2D uInputTex;
uniform vec4 uScale;
uniform vec4 uBias;
noperspective in vec2 vTexcoord;
out vec4 fResult;
void main()
{
fResult = max(vec4(0.0), texture(uInputTex, vTexcoord) + uBias) * uScale;
}
```
Регулировка **scale/bias** является основным способом настройки эффекта; самые лучшие настройки будут зависеть от динамического диапазона color buffer, а также от того, насколько тонким вы хотите видеть результат. Из-за того, что техника является аппроксимацией, тонкость вероятней будет выглядеть лучше.
### 2. Генерация элементов lens flare
Элементы **lens flare** имеют тенденцию вращаться относительно центра изображения. Имитируя этот эффект, мы можем развернуть результат предыдущего этапа горизонтально/вертикально. Это легко сделать на этапе генерации элементов, разворачивая текстурные координаты:
```
vec2 texcoord = -vTexcoords + vec2(1.0);
```
Делать это не обязательно; генерация элементов работает отлично как с этим, так и без этого. Однако результат изменения текстурных координат помогает визуально отделить эффект **lens flare** от исходного изображения.
#### GHOSTS
“**Ghosts**” (призраки) ― это повторяющиеся блики, которые отражают яркие области в color buffer, разворачиваясь относительно центра изображения. Подход, который я выбрал для генерации, заключается в получении вектора от текущего пикселя к центру экрана, а затем совершении нескольких выборок вдоль этого вектора.
```
uniform sampler2D uInputTex;
uniform int uGhosts; // number of ghost samples
uniform float uGhostDispersal; // dispersion factor
noperspective in vec2 vTexcoord;
out vec4 fResult;
void main()
{
vec2 texcoord = -vTexcoord + vec2(1.0);
vec2 texelSize = 1.0 / vec2(textureSize(uInputTex, 0));
// ghost vector to image centre:
vec2 ghostVec = (vec2(0.5) - texcoord) * uGhostDispersal;
// sample ghosts:
vec4 result = vec4(0.0);
for (int i = 0; i < uGhosts; ++i)
{
vec2 offset = fract(texcoord + ghostVec * float(i));
result += texture(uInputTex, offset);
}
fResult = result;
}
```
Обратите внимание, что я использую *fract()*, чтобы гарантировать, что текстурные координаты обернуться вокруг; эквивалентно вы можете использовать для текстуры wrap mode *GL\_REPEAT*.
Вот результат:
Вы можете улучшить результат, позволяя только ярким областям ближе к центру изображения генерировать призраков. Мы можем этого добиться, добавляя веса, которые будут уменьшаться от центра, для сэмплов:
```
vec4 result = vec4(0.0);
for (int i = 0; i < uGhosts; ++i)
{
vec2 offset = fract(texcoord + ghostVec * float(i));
float weight = length(vec2(0.5) - offset) / length(vec2(0.5));
weight = pow(1.0 - weight, 10.0);
result += texture(uInputTex, offset) * weight;
}
```
Weight функция проста настолько, насколько это возможно ― линейная. Причина, по которой мы вычисляем weight внутри цикла, заключается в том, что яркие области в центре входного изображения могут “отбрасывать” призраков на границы, но яркие области на границах не могут отбрасывать призраков в центр.
Окончательное улучшение ― радиальное изменение цвета призрака, в соответствии с 1D текстурой:
Оно применяется после цикла, чтобы повлиять на финальный цвет призрака:
```
result *= texture(uLensColor, length(vec2(0.5) - texcoord) / length(vec2(0.5)));
```
#### HALOS (ореолы)
Если мы возьмем вектор к центру изображения, как в расчете **ghost**, но зафиксируем длину вектора, мы получим другой эффект: исходное изображение деформируется радиально:
Мы можем это использовать для того, чтобы создать “ореол”, умножая вес на сэмпл, тем самым ограничивая вклад деформированного изображения кольцом, радиус которого контролируется **uHaloWidth**:
```
// sample halo:
vec2 haloVec = normalize(ghostVec) * uHaloWidth;
float weight = length(vec2(0.5) - fract(texcoord + haloVec)) / length(vec2(0.5));
weight = pow(1.0 - weight, 5.0);
result += texture(uInputTex, texcoord + haloVec) * weight;
```
#### CHROMATIC DISTORTION (цветовое искажение)
Некоторые блики на линзах имеют цветовое искажение, вызванное вариацией преломлений света на разных длинах волн. Мы можем смоделировать это, создав функцию, которая выбирает красный, зеленый и синий каналы отдельно с немного разными смещениями вдоль вектора выборки:
```
vec3 textureDistorted(
in sampler2D tex,
in vec2 texcoord,
in vec2 direction, // direction of distortion
in vec3 distortion // per-channel distortion factor
)
{
return vec3(
texture(tex, texcoord + direction * distortion.r).r,
texture(tex, texcoord + direction * distortion.g).g,
texture(tex, texcoord + direction * distortion.b).b
);
}
```
Ее можно использовать как прямую замену для вызова **texture()** в предыдущем листинге. Я рассчитываю **direction** и **distortion** следующим образом:
```
vec2 texelSize = 1.0 / vec2(textureSize(uInputTex, 0));
vec3 distortion = vec3(-texelSize.x * uDistortion, 0.0, texelSize.x * uDistortion);
vec3 direction = normalize(ghostVec);
```
Хотя функция выборки простая, она стоит x3 выборок из текстуры, хотя все они должны быть cache-friendly, если вы не зададите **uDistortion** какое-нибудь гигантское значение.
С генерацией элементов все. Вот результат:
### 3. Размытие
Без размытия элементы **lens flare** (в частности, призраки), как правило, сохраняют внешний вид изображения. Добавляя размытие на элементы **lens flare**, мы ослабляем высокие частоты и тем самым уменьшаем контраст с входным изображением, что помогает нам продать эффект.
Я не буду рассказывать, как сделать размытие; об этом можно почитать на различных интернет ресурсах (Gaussian blur).
### 4. Upscale / смешивание с оригинальным изображением
Итак, у нас есть наши элементы **lens flare**, хорошо размытые. Как мы можем объединить их с оригинальным исходным изображением? Есть несколько важных соображений относительно всего render pipeline:
* Любой последующий **motion blur** или **depth of field** должен быть применен до объединения с **lens flare**, таким образом элементы **lens flare** не будут участвовать в этих эффектах.
* **Lens flare** должен быть применен до любого **tonemapping**. Это имеет физический смысл, поскольку **tonemapping** имитирует реакцию пленки / CMOS на входящий свет, составной частью которой является **lens flare**.
Имея это в виду, есть пару вещей, которые мы можем сделать на этом этапе, чтобы улучшить результат:
#### LENS DIRT
Во-первых, нужно модифицировать элементы **lens flare** с помощью “грязной” текстуры в полном разрешении (которая широко используется в Battlefield 3):
```
uniform sampler2D uInputTex; // source image
uniform sampler2D uLensFlareTex; // input from the blur stage
uniform sampler2D uLensDirtTex; // full resolution dirt texture
noperspective in vec2 vTexcoord;
out vec4 fResult;
void main()
{
vec4 lensMod = texture(uLensDirtTex, vTexcoord);
vec4 lensFlare = texture(uLensFlareTex, vTexcoord) * lensMod;
fResult = texture(uInputTex, vTexcoord) + lensflare;
}
```
Ключ к этому ― сама текстура грязи на линзах. Если контрастность низкая, формы элементов **lens flare**, как правило, доминируют в результате. По мере увеличения контрастности, элементы **lens flare** приглушаются, что дает другой эстетический вид, а также скрывает некоторые дефекты.
#### DIFFRACTION STARBURST
В качестве дополнительного улучшения мы можем использовать **starburst** текстуру добавляя ее к **lens dirt**:
В виде текстуры **starburst** выглядит не очень хорошо. Тем не менее, мы можем передать матрицу преобразования в шейдер, которая позволит нам вращать / деформировать **starburst** каждый кадр и получить желаемый эффект динамичности:
```
uniform sampler2D uInputTex; // source image
uniform sampler2D uLensFlareTex; // input from the blur stage
uniform sampler2D uLensDirtTex; // full resolution dirt texture
uniform sampler2D uLensStarTex; // diffraction starburst texture
uniform mat3 uLensStarMatrix; // transforms texcoords
noperspective in vec2 vTexcoord;
out vec4 fResult;
void main()
{
vec4 lensMod = texture(uLensDirtTex, vTexcoord);
vec2 lensStarTexcoord = (uLensStarMatrix * vec3(vTexcoord, 1.0)).xy;
lensMod += texture(uLensStarTex, lensStarTexcoord);
vec4 lensFlare = texture(uLensFlareTex, vTexcoord) * lensMod;
fResult = texture(uInputTex, vTexcoord) + lensflare;
}
```
Матрица преобразования **uLensStarMatrix** основана на значении, полученном из ориентации камеры следующим образом:
```
vec3 camx = cam.getViewMatrix().col(0); // camera x (left) vector
vec3 camz = cam.getViewMatrix().col(1); // camera z (forward) vector
float camrot = dot(camx, vec3(0,0,1)) + dot(camz, vec3(0,1,0));
```
Есть и другие способы получения значения camrot; главное оно должно меняться непрерывно при повороте камеры. Сама матрица строится следующим образом:
```
mat3 scaleBias1 = (
2.0f, 0.0f, -1.0f,
0.0f, 2.0f, -1.0f,
0.0f, 0.0f, 1.0f,
);
mat3 rotation = (
cos(camrot), -sin(camrot), 0.0f,
sin(camrot), cos(camrot), 0.0f,
0.0f, 0.0f, 1.0f
);
mat3 scaleBias2 = (
0.5f, 0.0f, 0.5f,
0.0f, 0.5f, 0.5f,
0.0f, 0.0f, 1.0f,
);
mat3 uLensStarMatrix = scaleBias2 * rotation * scaleBias1;
```
**Scale** и **bias** матрицы нужны смещения начала координат текстуры, чтобы мы могли поворачивать **starburst** относительно центра изображения.
Заключение
----------
Итак, теперь все! Этот метод демонстрирует как относительно упрощенный пост процесс дает прилично выглядящий **lens flare**. Он не совсем фотореалистичный, но при правильном применении может дать прекрасный результат.
**UPD**Автор также опубликовал [статью](https://john-chapman.github.io/2017/11/05/pseudo-lens-flare.html) с небольшими оптимизациями.
Исходный код можно посмотреть [здесь](https://github.com/john-chapman/GfxSamples/tree/master/data/LensFlare_ScreenSpace) и [здесь](https://github.com/john-chapman/GfxSamples/tree/master/src/LensFlare_ScreenSpace). | https://habr.com/ru/post/439408/ | null | ru | null |
# FaaS и serverless-решения на примере PoC kubeless-функции
Первая ассоциация, которая приходит на ум при упоминании serverless-решений, — это облачные сервисы вроде AWS Lambda, Azure Functions или Google Functions, а на российском рынке — [Yandex Cloud Functions](https://cloud.yandex.ru/services/functions). У них имеются определённые бесплатные лимиты, и это подкупает. В случаях когда вы уже используете в работе K8s, смысла выносить отдельные части вашего приложения за кластер нет. Если вам интересно познакомиться с возможностями использования функций и с вариантами serverless-решений на bare-metal Kubernetes, а также узнать, как и где можно бесплатно развернуть своё PoC-решение на облачной виртуальной машине, то приглашаю под кат.
### Зачем вам FaaS, если у вас K8s
Ссылки на авторитетные источники принято оставлять по поводу и без, поэтому в качестве примера возможной микросервисной архитектуры я приведу иллюстрацию, взятую со странички [Serverless Architectures](https://martinfowler.com/articles/serverless.html) Мартина Фаулера:
Вместо монолитного API у нас две функции.
Монолиты определенно не в тренде, но сложно категорично сказать, что они уже отжили свой век; зато очевидно, что FaaS-решения (function-as-a-service) обладают определёнными плюсами:
* Более низкая стоимость.
* Более высокая скорость разработки. Возможность разрабатывать сервисы различными командами одновременно.
* Повышенная отказоустойчивость и, как правило, лучшая масштабируемость.
* Меньший и, следовательно, более понятный объём кода. Вы не привязаны к одному языку программирования: каждую функцию можно писать на своём языке. Если захотите, то сможете переписать любую функцию в относительно короткие сроки.
Основным минусом я бы назвал то, что функции гораздо сложнее тестировать. С монолитными приложениями таких трудностей не возникает. Кроме того, взаимосвязи между функциями (если они есть) в FaaS-решениях не всегда очевидны. Этого недостатка монолиты также лишены.
Облачные функции обладают «болячкой» в виде лимитов на использование памяти, времени выполнения, размера payload. Ну и, конечно же, у них имеется ограничение на количество бесплатных запусков. За деньги все ограничения снимаются и даже появляются возможности масштабирования облачных решений в соответствии с планируемой загрузкой.
Serverless-решения довольно хорошо вписываются в микросервисную архитектуру. Есть определённые кейсы, когда они лучше подходят под планируемое решение, чем Docker-контейнеры, содержащие в себе ОС и приложение. Например, если кодовая база довольно невелика, то смысла разворачивать отдельный контейнер с операционной системой нет. Это расточительно с точки зрения использования ресурсов Kubernetes. Разумеется, в таком случае проще использовать определённую функцию — особенно если какая-то операция выполняется раз в сутки или реже. Иногда функции используются как временные вспомогательные службы, либо как сервисы, применяемые для тестовой среды.
Два самых популярных способа запустить функцию — это HTTP- и CronJob-триггеры. Первые требуют конфигурации ingress и выполняют функцию после запроса, отправленного на определённый URL. Вторые же, как следует из названия, будут запускать функцию по расписанию. Кроме них есть и другие виды триггеров: различные webhooks; триггеры очереди; какие-либо триггеры, срабатывающие при загрузке файла. Иногда функции объединяют в цепочку. В таком случае одна функция по завершении своей работы вызывает другую.
### Как выбрать serverless-фреймворк под себя
Если у вас уже имеется свой созданный кластер Kubernetes, то вы можете развернуть среду для написания безлимитных и бессерверных функций — Kubernetes-based installable serverless platform. Таких платформ-фреймворков несколько, и вы можете выбрать подходящую под свои нужды.
На что следует обратить внимание при выборе serverless-фреймворка, так это на поддержку языков программирования. Не всё и не везде поддерживается. JS доступен практически везде. Python и Go также пользуются довольно широкой поддержкой. Очень часто имеется возможность использовать Ruby, Java или C#.
Отличное сравнение самостоятельно устанавливаемых serverless-платформ, основанных на Kubernetes, содержится в следующем артикуле на сайте Cisco: [Examining the FaaS on K8S Market](https://blogs.cisco.com/cloud/examining-the-faas-on-k8s-market). Я даже приведу изображение из этого артикула для большей наглядности (по скриншоту сразу становится понятно, что оно взято «с блога Сisco» :), но первоначального источника я не нашёл):
От себя добавлю, что Knative — это уже скорее CaaS (container-as-a-service), а не FaaS.
### Чем интересен Kubeless
Kubeless большей частью написан на Go. Хочется верить, что проект, рождённый в стенах Google Go, будет ближе других к изначально их же Kubernetes.
К минусам Kubeless относят отсутствие поддержки scale-to-zero. Данный функционал удаляет все реплики, если в них нет необходимости. Эти возможности есть, например, у OpenFaaS. Зато у Kubeless имеется функция автоматического масштабирования с помощью кубернетовского [Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/).
Почитать об этих возможностях можно здесь: [Autoscaling function deployment in Kubeless](https://kubeless.io/docs/autoscaling/).
Начиная с версии Kubernetes 1.16, доступна возможность использовать фичу под названием [HPAScaleToZero](https://kubernetes.io/docs/reference/command-line-tools-reference/feature-gates/). На момент написания статьи она находится в стадии Alpha.
### Как потрогать Kubernetes своими руками
Для этого хорошо бы обзавестись собственной нодой Kubernetes. Если вы под Linux, то это для вас совсем не проблема. Если же вы под Windows, то можете не выходя из системы установить Docker с WSL и добавить интеграцию Kubernetes. Docker on Mac, кстати, тоже содержит в настройках возможность включить single-node кластер Kubernetes.
В Сети есть несколько сервисов, предоставляющих Kubernetes на бесплатной основе для создания PoC. Для меня открытием оказался [Kubernautic](http://kubernautic.com). Он предоставляет Alpine Linux с уже установленным Kubernetes, но, как оказалось, с определёнными ограничениями, и у меня банально не хватило прав для того, чтобы установить на нём Kubeless. Примерно такие же впечатления остались от сервиса под названием [Krucible](https://usekrucible.com/).
Помимо Kubernautic, есть чуть более известный сервис Okteto. Его бесплатный тариф позволяет пользоваться сервисом через день. Это, конечно, не очень удобно с точки зрения разработки проектов, но для PoC иногда годится.
Оставлю ссылку на англоязычный мануал: [Serverless Development with Kubeless and Okteto](https://okteto.com/blog/serverless-development-with-kubeless/index.html).
### Мой тест в облаке
Так как FaaS всё-таки относится больше к облакам, я предпочитаю работать в них. Поэтому для демо решено было завести виртуальную машину у одного из крупных провайдеров. И где бы вы думали я её завел? В Oracle Cloud. Дело в том, что AWS и Azure предлагают виртуалки бесплатно только в первый год пользования аккаунтом, а Oracle — на постоянной основе. Справедливости ради упомяну, что и в Google Cloud также можно «взять погонять» виртуалку бесплатно на постоянной основе, но с 2016 года в России регистрация доступна только для юридических лиц.
Характеристики оракловской виртуалочки следующие:
1 core OCPU, 1 GB memory, 0.48 Gbps network bandwidth.
Существует несколько способов установить Kubernetes локально на одну машину и устроить себе learning environment для тестов и разработки. Один из самых популярных — это, пожалуй, [Minikube](https://kubernetes.io/ru/docs/tasks/tools/install-minikube/). Он разворачивает кластер внутри виртуальной машины. Его основным плюсом, помимо популярности, является универсальность: развернуть его можно практически на любой ОС. Но Minikube первой же проверкой сузил мне круг выбора. Команда:
```
grep -E --color 'vmx|svm' /proc/cpuinfo
```
не возвратила ничего. Виртуализация не поддерживается моей виртуальной машиной.
У Minikube есть масса конкурентов:
* [Microk8s](https://microk8s.io/) от разработчиков Ubuntu. Он работает без VM и устанавливается с помощью Snap.
* Заманчивый и очень лёгкий (менее 100 МБ) [K3s](https://github.com/k3s-io/k3s). Хорошо подходит для IoT.
* Милый [kind](https://github.com/kubernetes-sigs/kind) (Kubernetes IN Docker) — self-contained Linux-приложение, которое скачивается и записывается в PATH.
* Просто обязан упомянуть OpenShift’овские [CodeReady Containers](https://github.com/code-ready/crc) и [Minishift](https://github.com/minishift/minishift).
В результате я остановился на K3s. Кластер «завёлся» с одной команды, ну или точнее, с одного скрипта:
```
curl -sfL https://get.k3s.io | sh -
```
Для того чтобы всё заработало на Oracle Linux, мне пришлось отключить файрвол командой:
```
sudo systemctl stop firewalld
```
Добавить права на файл конфигурации:
```
sudo chmod 644 /etc/rancher/k3s/k3s.yaml
```
И установить значение переменной среды KUBECONFIG:
```
export KUBECONFIG=/etc/rancher/k3s/k3s.yaml
```
Скрипт автоматически установил и утилиту [kubectl](https://kubernetes.io/ru/docs/tasks/tools/install-kubectl/). Убедиться, что с нодой всё в порядке, можно следующей командой:
```
kubectl get nodes
```
А ещё лучше проверить, что все поды работают:
```
kubectl get pods --all-namespaces
```
Если что-то пойдёт не так, то рестартануть K3s можно с помощью systemctl:
```
sudo systemctl restart k3s
```
### Установка Kubeless
Теперь приступим к установке Kubeless. Для этого нам необходимо скачать и установить CLI. Этот процесс немного автоматизирован, и номер актуальной версии подтягивается с GitHub автоматически с помощью следующей команды:
```
export RELEASE=$(curl -s https://api.github.com/repos/kubeless/kubeless/releases/latest | grep tag_name | cut -d '"' -f 4)
```
Теперь мы можем использовать $RELEASE в командах для скачивания и установки Kubeless:
```
export OS=$(uname -s| tr '[:upper:]' '[:lower:]')
curl -OL https://github.com/kubeless/kubeless/releases/download/$RELEASE/kubeless_$OS-amd64.zip && \
unzip kubeless_$OS-amd64.zip && \
sudo mv bundles/kubeless_$OS-amd64/kubeless /usr/local/bin/
```
Далее мы создаём namespace, в котором будут содержаться все наши объекты, относящиеся к Kubeless:
```
kubectl create ns kubeless
```
И наконец, устанавливаем сам Kubeless:
```
kubectl create -f https://github.com/kubeless/kubeless/releases/download/$RELEASE/kubeless-$RELEASE.yaml
```
Я использую команду для RBAC (role-based access control), так как он более прост и популярен по сравнению с ABAC (attribute-based access control).
Прежде чем приступить к следующему шагу, убедитесь, что контейнер запустился:
```
kubectl get pods -n kubeless
```
#### Работа с функциями
Теперь мы можем перейти к написанию функций. Примеры Kubeless-функций для различных платформ можно найти [тут](https://github.com/kubeless/kubeless/tree/master/examples). Я взял пример .NET Core.
Воспользуемся vi для создания первой функции.
Создаём файл:
```
vi testfunction.cs
```
```
using System;
using Kubeless.Functions;
public class module
{
public string handler(Event k8Event, Context k8Context)
{
return "Hello world";
}
}
```
Не буду приводить список всех команд vi. Достаточно будет только двух.
Чтобы сохранить, нажимаем Esc, а затем :w! Enter.
Чтобы выйти — Esc, а затем :q! Enter.
Деплоим функцию так:
```
kubeless function deploy hello --runtime dotnetcore2.2 \
--from-file testfunction.cs \
--handler module.handler
```
В этой команде первый параметр “hello” — это имя функции.
Далее идёт используемый runtime. Чтобы получить список поддерживаемых runtime, можно выполнить команду:
```
kubeless get-server-config
```
Ну и наконец, имя файла и handler, описывающий путь к запускаемому методу (имя класса и имя метода, разделённые точкой).
Проверить, задеплоена ли уже функция, можно командой:
```
kubeless function ls hello
```
Удалить — с помощью:
```
kubeless function delete hello
```
Если необходимо вывести список всех функций:
```
kubectl get functions
```
Проверить состояние пода:
```
kubectl get pods -l function=hello
```
Теперь создадим простой Cron-триггер:
```
kubeless trigger cronjob create \
cron-test-hello \
--function hello \
--schedule "*/0 * * * *"
```
Он должен будет выполнять нашу функцию каждые 10 минут. Для каждого выполнения будет создан новый под — это то, что называется cold start. Следует учитывать, что cold start занимает какое-то время и ваша функция будет выполнена не ровно через 10 минут.
CronJob может мониторить какой-нибудь health-сервис и отправлять сообщения в случае «падения». Также он может проверять наличие новых данных и производить их обработку — получится что-то вроде ETL (extract, transform and load). Можно разбить какую-нибудь долгую операцию на несколько небольших batch job’ов и выполнять их по таймеру CronJob.
Очень часто возникает необходимость вызвать триггер из Сети. Для этого можно создать HTTP-триггер. Чтобы получить доступ к функции, вашему кластеру необходим ingress. В K3s уже установлен по умолчанию Traefik, и HTTP-триггер можно создать сразу командой:
```
kubeless trigger http create helloingress --function-name hello
```
Проверить, что ingress был создан, можно командой:
```
kubectl get ing или kubectl get ingress
```
Удалить можно так:
```
kubeless trigger http delete helloingress
```
У меня этот способ не сработал, поэтому пришлось создавать ingress вручную. Для этого мне потребовалось название сервиса функции и её порт. Получить эти данные можно, выполнив команду:
```
kubectl get svc
```
Мне она выдала такой результат:
 Ну и теперь можно создавать ingress:
```
vi ingress.yaml
```
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: minimal-ingress-v1
spec:
rules:
- http:
paths:
- path: /hello
pathType: Prefix
backend:
service:
name: hello
port:
number: 8080
```
На всякий случай лишний раз предупреждаю: пробелы довольно важны в YAML-файлах. Создаём ingress командой:
```
kubectl create -f ingress.yaml
```
Для того чтобы он начал работать и перенаправлять запросы на сервис hello, необходимо разрешить виртуальной машине доступ извне по протоколу TCP.
На странице Instance виртуальной машины заходите в Primary VNIC и кликайте на вашу Subnet. Со страницы Subnet заходите в Security Lists (у вас будет один security list, созданный по умолчанию). Теперь вам нужно разрешить доступ с вашего IP-адреса по TCP-протоколу, добавив Ingress Rule. Чтобы указать единственный IP в виде CIDR, достаточно добавить к нему /32.
Теперь с помощью curl вы можете активировать триггер (IP адрес — это адрес вашей виртуальной машины):
```
curl http://140.238.222.93:80/hello
```
А вот убедиться, что функция отработала, в нашем простом случае можно только проверив логи (указав при этом начало интервала времени, чтобы отсечь старые записи):
```
kubectl logs hello-5b5cf4b6d4-28tgl --since-time=2021-05-14T17:31:00.000000000Z
```
В этой команде hello-5b5cf4b6d4-28tgl — это имя пода.
#### Заключение
Надеюсь, что на этом примере вы разобрались, как создать бессерверное решение на Kubeless и как с ним можно работать. Если у вас имеется Kubernetes-кластер, то, учитывая, что его ресурсы не бесконечны, вы можете перенести какую-то логику на serverless. Экономия ресурсов — это далеко не единственный кейс. Редко выполняемые операции; задания, выполняемые по таймеру; stateless-операции, требующие создания отдельного экземпляра; обработка файлов и видео, — все эти кейсы довольно благоприятно вписываются в архитектуру в качестве serverless-решений. | https://habr.com/ru/post/556832/ | null | ru | null |
# Разбор ошибок в игровом движке Stride
Stride – это мощный, бесплатный и активно развивающийся игровой движок, реализованный на C#. Он вполне может стать альтернативой Unity, но насколько качественный исходный код Stride? Узнаем это с помощью статического анализатора PVS-Studio.
### Введение
Следствием активного развития проекта является не только внедрение нового функционала и возможностей, но и возникновение новых ошибок. В этой статье мы разберём самые интересные из них. К слову, разбор ошибок в проекте — отличный способ оценить его качество. Однако проверка крупных проектов отнюдь не простая задача, поэтому найти ошибки в игровом движке нам поможет статический анализатор PVS-Studio.
Проверка проводилась на релизе Stride Game Engine 4.1.0.1734. Исходный код доступен на [GitHub](https://github.com/stride3d/stride/releases/tag/releases%2F4.1.0.1734).
### Разбор ошибок Stride Game Engine
#### Использование анонимной функции для отмены подписки на событие
**Issue 1**
```
private void RemoveEditor(....)
{
....
if (....)
{
multiEditor.OpenedAssets.CollectionChanged -= (_, e) =>
MultiEditorOpenAssetsChanged(multiEditor, e);
....
}
....
}
```
Срабатывание PVS-Studio: [V3084](https://pvs-studio.com/ru/docs/warnings/v3084/). Anonymous function is used to unsubscribe from 'CollectionChanged' event. No handlers will be unsubscribed, as a separate delegate instance is created for each anonymous function declaration. AssetEditorsManager.cs 444
В приведённом примере выполняется отписка от события *CollectionChanged*. Однако это не сработает, т. к. в качестве ссылки на объект обработчика используется анонимная функция. При её объявлении создается новый экземпляр делегата, отличный от ранее подписанного на *CollectionChanged*. Даже если тела функций идентичны, они всё равно будут представлять разные объекты. Таким образом, отписка от события с помощью анонимной функции не произойдёт и значение *CollectionChanged* никак не изменится.
#### Риск null-разыменования при обращении к свойству
**Issue 2**
```
private void SetIsVisible(bool isVisible)
{
if (isVisible)
PreviewService.OnShowPreview(); //<=
else
PreviewService.OnHidePreview(); //<=
}
```
Срабатывание PVS-Studio: [V3080](https://pvs-studio.com/ru/docs/warnings/v3080/). Possible null dereference. Consider inspecting 'PreviewService'. PreviewViewModel.cs 109
В данном случае анализатор предупреждает о возможном разыменовании нулевой ссылки. Обратите внимание на метод *SetIsVisible*. Здесь отсутствуют проверки *PreviewService* на *null*. На их необходимость указывает реализация этого свойства:
```
private IAssetPreviewService PreviewService
{
get
{
if (previewService != null)
return previewService;
previewService = ServiceProvider.TryGet();
if (previewService == null)
return null;
previewService.PreviewAssetUpdated += PreviewAssetUpdated;
return previewService;
}
}
```
Из реализации видно, что *PreviewService* действительно может вернуть *null*. Следовательно, угроза возникновения ошибки вполне реальна и требует соответствующей обработки. Возможным решением проблемы может стать добавление условия:
```
private void SetIsVisible(bool isVisible)
{
if (PreviewService != null) //<=
{
if (isVisible)
PreviewService.OnShowPreview();
else
PreviewService.OnHidePreview();
}
}
```
#### Лишнее присваивание значения
**Issue 3**
```
public TexAtlas(...., TexImage atlas) : base(....)
{
....
Name = atlas.Name;
....
Name = "";
}
```
Срабатывание PVS-Studio: [V3008](https://pvs-studio.com/ru/docs/warnings/v3008/). The 'Name' variable is assigned values twice successively. Perhaps this is a mistake. TexAtlas.cs 48, 43
В конструкторе свойству *Name* два раза присваивается значение. Предположительно, разработчик хотел протестировать функционал класса при пустом *Name*. Для этого он добавил второе присваивание, но позднее забыл его удалить. Теперь, независимо от входных параметров конструктора, этому свойству всегда будет присваиваться пустая строка. Это неизбежно приведёт к нарушению в логике программы, использующей значение этого свойства.
#### Потерялась проверка на null
**Issue 4**
```
public override void EndScreenDeviceChange(....)
{
....
window.FullscreenIsBorderlessWindow = FullscreenIsBorderlessWindow; // <=
if (....)
{
....
if (window != null)
{
window.ClientSize = new Size2(clientWidth, clientHeight);
}
....
}
else
{
....
if (window != null)
{
window.ClientSize = new Size2(clientWidth, clientHeight);
window.Location = savedFormLocation;
....
window.BringToFront();
}
}
....
}
```
Срабатывание PVS-Studio: [V3095](https://pvs-studio.com/ru/docs/warnings/v3095/). The 'window' object was used before it was verified against null. GameWindowSDL.cs 64, 70.
В начале метода *EndScreenDeviceChange* объект *window* используется без предварительной проверки на *null*, о чём и предупреждает анализатор. На актуальность этого предупреждения указывает последующий код: все обращения к переменной выполняются внутри блока условного оператора, реализующего такую проверку.
Предупреждения анализатора о потенциальных ошибках, приводящих к исключению типа *NullReferenceException,* встречаются при проверке C# проектов намного чаще, чем предупреждения других типов. Наверное, стоит уделять этой проблеме отдельное внимание при написании кода. Давайте рассмотрим ещё одно срабатывание такого же типа.
**Issue 5**
```
private async Task Update()
{
while (....)
{
....
if (....)
{
....
materialFilterRenderFeature.MaterialFilter =
(materialFilterRenderFeature != null && ....)? ....
....
}
}
}
```
Срабатывание PVS-Studio: [V3095](https://pvs-studio.com/ru/docs/warnings/v3095/). The 'materialFilterRenderFeature' object was used before it was verified against null. EditorGameRenderModeService.cs 106, 107.
В отличие от предыдущего случая, в этом примере есть проверка на *null*, но реализована она несколько... странно. Выполняется обращение к свойству *MaterialFilter* объекта *materialFilterRenderFeature*. Далее этому свойству присваивается результат выполнения тернарного оператора. Условное выражение этого оператора содержит проверку *materialFilterRenderFeature* на *null*. Однако в ней нет никакой необходимости. В случае если *materialFilterRenderFeature* равен *null*, выполнение программы благополучно завершится исключением *NullReferenceException* ещё при обращении к свойству *MaterialFilter* :).
#### Когда проверка на null приводит к NullReferenceException
**Issue 6**
```
public Palette GlobalPalette
{
get {....}
set
{
SetTagValue("GlobalPalette", (value != null) ? null : value.Data);
}
}
```
Срабатывание PVS-Studio: [V3080](https://pvs-studio.com/ru/docs/warnings/v3080/). Possible null dereference. Consider inspecting 'value'. MetadataModels.cs 132
Методу *SetTagValue* в качестве второго аргумента передаётся тернарное выражение. Это выражение проверяет наличие значения *null* у переменной *value*. Если *value* равно *null*, в качестве аргумента методу передаётся *value.Data.* Обращение к свойству этой переменной неизбежно приведёт к вызову исключения *NullReferenceException*. Предположительно, разработчик перепутал операнды местами. Таким образом, корректная реализация тернарного оператора может выглядеть так:
```
(value != null) ? value.Data : null
```
#### Одинаковое условие, но разное предназначение
**Issue 7**
```
internal IObjectNode SetTarget(....)
{
if (....)
{
var targetValue = targetNode.Retrieve();
if (targetValue != null && !type.IsInstanceOfType(targetValue))
throw new InvalidOperationException(@"The type of the retrieved" +
"node content does not match" +
"the type of this reference");
if (targetValue != null && !type.IsInstanceOfType(targetValue))
throw new InvalidOperationException("TargetNode type does not " +
"match the reference type.");
....
}
....
}
```
Срабатывание PVS-Studio: [V3021](https://pvs-studio.com/ru/docs/warnings/v3021/). There are two 'if' statements with identical conditional expressions. The first 'if' statement contains method return. This means that the second 'if' statement is senseless.ObjectReference.cs 134
Анализатор обнаружил два похожих оператора *if* с идентичными условиями. В теле обоих условных операторов вызывается исключение, тем самым прерывая выполнение программы. На первый взгляд, здесь нет ничего страшного, просто немного лишнего кода. Однако обратите внимание на сообщения, передаваемые в исключения, — они разные. Можно предположить, что разработчик хотел реализовать две различные проверки. Возможно, он скопировал одну из них и поменял сообщение, но забыл изменить условное выражение. Таким образом, одна из возможных ошибок осталась необработанной и всё ещё представляет угрозу для корректной работы программы.
Исходя из сообщения второго исключения, можно предположить, что корректная реализация соответствующего *if* должна выглядеть так:
```
if (targetNode!= null && !type.IsInstanceOfType(targetNode))
throw new InvalidOperationException("TargetNode type does not " +
"match the reference type.");
```
Рассмотрим аналогичный случай, найденный анализатором в этом игровом движке.
**Issue 8**
```
private GraphViewModel(....) : base(serviceProvider)
{
....
if (rootPresenters == null)
throw new ArgumentNullException(nameof(rootPresenters));
....
if (rootPresenters == null)
throw new ArgumentNullException(nameof(rootNode));
....
}
```
Срабатывание PVS-Studio: [V3021](https://pvs-studio.com/ru/docs/warnings/v3021/). There are two 'if' statements with identical conditional expressions. The first 'if' statement contains method return. This means that the second 'if' statement is senseless. GraphViewModel.cs 40
Перед нами снова два оператора *if* с одинаковыми условиями. Как и в предыдущем случае, на ошибку указывают аргументы, передаваемые в конструктор исключения. В этот раз они являются наименованиями проверяемых переменных. Очевидно, что ошибка допущена во втором условном операторе. Его корректная реализация, скорее всего, должна иметь следующий вид:
```
if (rootNode == null)
throw new ArgumentNullException(nameof(rootNode));
```
#### Copy paste ошибки или какой case лишний?
**Issue 9**
```
public override void AddPoint(....)
{
....
switch (Component)
{
case VectorComponent.X:
value.X = realPoint.Y;
break;
case VectorComponent.Y:
value.Y = realPoint.Y;
break;
case VectorComponent.Z:
value.Z = realPoint.Y; // <=
break;
case VectorComponent.W:
value.Z = realPoint.Y; // <=
break;
default:
throw new NotSupportedException();
}
....
}
```
Срабатывание PVS-Studio: [V3139](https://pvs-studio.com/ru/docs/warnings/v3139/). Two or more case-branches perform the same actions. RotationComponentCurveViewModel.cs 53
Перед вами *switch*, операторы *case* которого очень похожи друг на друга. Метки каждого из них соответствуют шаблону: *VectorComponent.{0}*, где вместо *{0}* может быть любое из следующих свойств: *X*, *Y*, *Z* или *W*. В теле каждого оператора *case* выполняется присваивание вида *value.{0} = realPoint.Y*. А теперь обратите внимание на последний из них. Он имеет метку *VectorComponent.W*, а в теле производится операция *value.Z = realPoint.Y*. Она идентична присваиванию в предыдущем *case*. Согласно выявленному нами шаблону, вместо *value.Z* в данном выражении должно быть *value.W*.
Таким образом, корректная реализация последнего *case* может выглядеть так:
```
case VectorComponent.W:
value.W = realPoint.Y;
break;
```
#### Не стоит жалеть кода на обработку NullReferenceException
**Issue 10**
```
protected override Size ArrangeOverride(....)
{
....
if (....)
{
for (....)
{
var child = itemsControl.ItemContainerGenerator
.ContainerFromIndex(i) as TreeViewItem;
....
if (child != null)
{
child.Arrange(....);
currentY += child.ActualHeight;
}
....
}
}
else
{
for (....)
{
var child = itemsControl.ItemContainerGenerator
.ContainerFromIndex(i) as UIElement;
child?.Arrange(....);
currentY += child.DesiredSize.Height; //<=
}
}
....
}
```
Срабатывание PVS-Studio: [V3125](https://pvs-studio.com/ru/docs/warnings/v3125/). The 'child' object was used after it was verified against null. VirtualizingTreePanel.cs 430, 429
Обратите внимание на блоки *then* и *else* условного оператора. Они чем-то похожи, не так ли? В обоих выполняется цикл, внутри которого переменная *child* инициализируется с помощью оператора *as*. Но есть одно существенное отличие – в первом цикле все обращения к переменной *child* защищены от *NullReferenceException* соответствующей проверкой, а вот во втором случае – не совсем. Можно предположить, что разработчик намеренно не стал добавлять явную проверку, обработав первое обращение к *child* оператором *null-conditional*:
```
child?.Arrange(....);
```
При этом он не обратил внимания на второе обращение:
```
currentY += child.DesiredSize.Height;
```
Результатом этой операции все также может стать выбрасывание исключения *NullReferenceException*.
### Заключение
Потенциально опасные фрагменты кода, найденные в Stride Game Engine, оказались вполне интересными и определённо заслуживают внимания. Но насколько же оказались верны срабатывания анализатора? Мне кажется, точно ответить на этот вопрос могут только разработчики игрового движка, проведя собственное исследование с помощью PVS-Studio.
В любом случае отсутствие потенциально опасного кода лучше, чем его наличие. Статический анализатор позволяет быстро обнаружить такой код, тем самым помогая свести количество ошибок в проекте к минимуму, не тратя огромное количество времени и сил на их поиск.
Вы легко можете в этом убедиться, скачав [PVS-Studio](https://pvs-studio.com/pvs-studio/try-free/?utm_source=website&utm_medium=habr&utm_campaighn=article&utm_content=0994&utm_term=link_try-free) и опробовав его на своих проектах в течение пробного периода.
Для наилучшего пользовательского опыта рекомендую ознакомиться с основами использования анализатора. Это можно сделать, прочитав соответствующие разделы в [документации](https://pvs-studio.com/ru/docs/).
На этом статья завершается. Надеюсь, она была вам интересна :).
Чистого вам кода и успешных проектов! До встречи в следующих статьях!
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey Moskalev. [Stride Game Engine error review](https://pvs-studio.com/en/blog/posts/csharp/0994/). | https://habr.com/ru/post/690962/ | null | ru | null |
# 4 способа добавить иконки на сайт из Figma — все плюсы и минусы
Привет, друзья!
Поговорим о том, **КАК ДОБАВИТЬ ИКОНКИ НА САЙТ ИЗ FIGMA**. Для тех, кому интереснее смотреть видео, прикрепляю свой видосик на YouTube:
Проверяя html-макеты верстальщиков и разработчиков наблюдаю проблемы с добавлением иконок на сайт. Они их добавляют чёрт пойми как… Могут добавить их как png изображения, а могут вообще использовать не иконки из макета, а похожие иконки, использовав, к примеру, FontAwesome. Это жестко, скажу я вам.
В связи с этим я хочу расставить все точки над i в этой теме и рассказать достаточно подробно о том, как лучше всего добавлять иконки на сайт из макета Figma.
Способов хватает, и выбор конкретного способа зависит от самого проекта и дизайнера, который делал макет. Собственно об этом всём мы и поговорим!
### Способ №1 - это экспортировать иконки в svg формат и вставлять их либо как код, либо как изображение, либо как CSS свойство.
Сосбтвенно, выделяем иконку в Figma и жмём на экспорт в SVG формат, сохраняем в наш проект и вставляем на сайт:
```
.icon-refresh {
position: relative;
display: inline-block;
width: 16px;
height: 16px;
background-image: url('img/icon-refresh.svg');
background-size: 100%;
background-repeat: no-repeat;
background-position: center;
}
```
Сам по себе вариант самый очевидный, простой и достаточно хороший.
**Однако тут у нас выступает 2 очень неприятные проблемы.**
**Первая проблема** - если мы используем svg код, то сам код становится достаточно большим так как сама иконка может быть очень сложной по цветам и количеству вектора внутри.
**Вторая проблема** - это если мы подключаем иконку таким способом, то нам проблематично менять её цвет через CSS или даже JS. Придётся экспортировать дубль иконки, но с другим цветом. А в случае с тегом object у нас вообще не будет нормально работать ссылка, если мы обернули её в тег .
Есть также ещё **небольшой минус** - он связан с тем, что мы не можем задать размер иконки через свойство font-size (то есть мы не наследуем размер шрифта). Приходится всё время "играться" с шириной и высотой.
**Из плюсов**, пожалуй, только то, что вариант простой и экономит немного времени в небольших проектах.
Поэтому этот вариант на самом деле подходит тогда, когда иконок в макете не много (то есть максимум штук 3-5) и их цвета нигде не меняются (к примеру по наведению или теме макета).
### Способ №2 - это создать 1 файл со всеми иконками. По-другому это называют текстура иконок.
Вариант также подразумевает экспорт иконок в svg или png формат, но одним файлом, где будут все иконки одного размера. Это довольно старый вариант, но знать о нём нужно. Я точно знаю, что ВКонтакте использовали этот способ очень долго, и после редизайна они отказались от этого способа в пользу SVG + JS.
К примеру, иконки соц. сетей:
Прописываем код для иконки ВК и Instagram:
```
.icon {
position: relative;
display: inline-block;
width: 40px;
height: 40px;
background-image: url('img/socials-pack.svg');
background-size: 287px;
background-repeat: no-repeat;
}
.icon\_vk {
/\* начальная позиция стоит по-умолчанию \*/
}
.icon\_instagram {
background-position: 239px 0;
}
```
**Тут у нас выступает 2 проблемы:**
**Первая** - у нас может занять много времени подготовка CSS свойств.
**Вторая** - опять очень проблематично менять цвета. Придётся экспортировать столько дублей иконок, сколько нужно цветов.
Зато тут есть 1 приятный плюс - это небольшой HTML код, так как мы используем только класс, чтобы добавить иконку.
Сам вариант нужно использовать с осторожностью и только по особенности проекта (к примеру, если мы хотим сделать плагин со смайликами для чата). В других же ситуациях нужно использовать другие варианты.
### Способ №3 - использовать готовый сервис иконок. Тут вам важно уточнить у дизайнера - ОТКУДА ВЗЯТЫ ИКОНКИ.
> Небольшое отступление - вам в принципе нужно всегда спрашивать у дизайнера: какие иконки, откуда изображения, где взять шрифт и т.п. вопросы.
>
>
Часто бывает такое, что иконки взяты с какого-то сервиса, который позволяет подключить иконки через стили или скрипты.
В Figma дизайнеры часто используют сервис Iconify.
Либо дизайнер мог использовать другие иконки, где есть готовое подключение на сайт. Тот же EvaIcons, к примеру.
Пример подключения через Iconify:
```
```
**Тут я уже начну с плюсов:**
* во-первых, мы можем очень легко и быстро подключить все иконки на сайт
* во-вторых, цвет иконки меняется очень просто по свойству color в css
* в-третьих, размер иконки наследуется от шрифта и мы можем его менять по свойству font-size
* да и в целом в нашем html коде всё аккуратно, иконки занимают 1 строку
**Из минусов**, пожалуй, только то, что мы подключаем сторонний сервис/библиотеку, и вместе с этим много лишнего кода. Но это мелочь, особенно если дедлайн проекта горит.
Этот вариант следует использовать, если иконок в макете больше 5 и их цвета не нигде не меняются.
### Способ №4 - это самостоятельно превратить все иконки в иконочный шрифт
В этом случае вам не повезло, потому что дизайнер использовал иконки, для которых нет никакого решения для подключения на сайт (вот подлец🤔).
**Что мы делаем:**
* мы экспортируем все иконки в svg формат (будет лучше, если все они будут чёрные, латиницой без символов и слова "icon")
* импортируем их в сервис [icomoon](https://icomoon.io/app/) (чтобы сэкономить кучу времени). Тут важно, чтобы у вас все иконки были в кривых (fill), а не обводкой (stroke). Сервис не работает с обводкой, и он вас предупредит, если какая-то иконка будет сделана обводкой
* генерируем иконочный шрифт и получаем готовый CSS файл и превьюшку с иконками
Наш код:
```
Кнопка с иконкой
.button:before {
content: '\e90a';
font-family: 'icomoon', sans-serif;
}
```
**Из плюсов я выделю:**
* возможность легко менять цвет через CSS свойтсво `color`
* возможность задавать размер иконки через `font-size` (то есть иконка наследует размеры щрифта)
* небольшой html-код, так как мы используем только 1 небольшой класс для добавления иконки
* простая поддержка иконок (легко добавлять и удалять иконки из нашего арсенала)
* экономим пространство тем, что у нас находятся только те иконки и код, которые нужны (в отличии от использования готового решения, где может быть больше сотни иконок)
**Из минусов:**
* мы тратим немного больше времени на подготовку иконочного шрифта
* нам важно следить, чтобы иконки были в кривых, а не обводочными
Данный вариант подходит, когда иконок в макете много и когда их цвета могут меняться.
### Заключение
Друзья! Поверьте, этого всего вам достаточно, чтобы научиться правильно и без проблем подключать любые иконки на любой сайт. Ведь сами понимаете, как важно, чтобы html-макет соответствовал макету в Figma, при это без ущерба производительности и качеству кода.
Пишите в комментариях - что вы думаете по этому поводу.
Не забывайте подписываться [на меня](https://www.youtube.com/c/AVISTV) в YouTube, там также много полезного.
Удачи вам в ваших макетах и увидимся в следующих видео/статьях. Пока! | https://habr.com/ru/post/648741/ | null | ru | null |
# WPF: Что делать, когда свойство не поддерживает привязку
Введение
--------
WPF — замечательная технология, которую, не смотря на все ее недостатки, очень люблю. Тем не менее, часто приходится писать не разметку, а код, который помогает первой работать как надо. Хотелось бы этого избегать и писать чистый XAML, но до сих пор ни одно мое приложение сложнее простого не обходилось без различных хелперов (классов-помощников), написанных на C#. К счастью, есть распространенные случаи, где можно одним хелпером решить сразу группу проблем.
Речь ниже пойдет о привязке в обычных свойствах визуальных элементов, которые не являются свойствами зависимостей (dependency properties). Штатными средствами WPF этого сделать не получится. Ко всему прочему, мы не можем узнать об изменениях такого свойства, кроме как подписавшись на специальное событие, что противоречит шаблону [MVVM](http://ru.wikipedia.org/wiki/Model-View-ViewModel "Model-View-View-Model"). Такие события для каждого свойства могут быть свои. Самый распространенный пример — это *PasswordBox* и его свойство *Password*. Так у нас сделать не получится:
```
```
Не будем вдаваться в подробности, зачем разработчики *PasswordBox* не разрешили привязываться к свойству пароля. Подумаем, что тут можно сделать.
Если вам не хочется читать мои рассуждения, то в конце статьи опубликован финальный код и ссылка на Github.
Определяемся со способом реализации
-----------------------------------
И так! Хотелось бы такое решение, чтобы в обращении походило на обычную привязку, но с некоторыми дополнительными параметрами. Также, неплохо иметь возможность делать привязку в обе стороны (two way binding). Для реализации перечисленного хелперу понадобятся три входных параметра:
1. Свойство визуального элемента
2. Событие, сообщающее об изменениях
3. Источник данных для привязки
К примеру, для *PasswordBox* это будут соответственно: свойство *Password*, событие *PasswordChanged* и источник *OtherProperty*.
Есть разные способы достичь желаемого. Остановимся на стандартном для таких случаев механизме — поведениях.
Поведение (behavior) — это класс, который добавляет визуальному элементу дополнительную функциональность. Есть два вида поведений: статические и наследуемые от класса *Behavior*. Описание их различий выходит за рамки статьи. Я выбрал второй вариант, как обладающий большими возможностями.
Пишем код
---------
Добавим ссылку на сборку *System.Windows.Interactivity.dll*. Это часть SDK редактора Expression Blend и находится в разделе «Расширения» окна выбора сборок Visual Studio.
Создадим класс, наследуемый от *Behavior*:
```
public class DependecyPropertyBehavior : Behavior
{
}
```
Тип генерика *DependencyObjec*t выбран как наиболее общий. Ведь мы пишем универсальный класс, подходящий для любого элемента, а не только *PasswordBox*.
Алгоритм работы будет краток. Для привязки от свойства к источнику:
1. Подписываемся на событие об изменении свойства визуального элемента.
2. В обработчике записываем обновленное значение в источник.
Для обратной привязки:
1. Через привязку определяем момент изменения значения источника.
2. Записываем обновленное значение в свойство визуального элемента.
Для вышеописанных входных параметров создадим три свойства:
```
public string Property { get; set; }
public string UpdateEvent { get; set; }
public static readonly DependencyProperty BindingProperty = DependencyProperty.RegisterAttached(
"Binding",
typeof(object),
typeof(DependecyPropertyBehavior),
new FrameworkPropertyMetadata { BindsTwoWayByDefault = true }
);
public object Binding
{
get { return GetValue(BindingProperty); }
set { SetValue(BindingProperty, value); }
}
```
* *Property* — имя свойства визуального элемента, не поддерживающее привязку;
* *UpdateEvent* — имя события, уведомляющего об изменении значения нашего свойства;
* *Binding* - свойство зависимостей для привязки к источнику данных. Позволяет применять знакомый механизм привязки.
В данном случае свойства *Property* и *UpdateEvent* являются обычными, этого достаточно. Свойство *Binding*, напротив, должно быть свойством зависимостей, ведь именно сюда подключается источник данных.
Теперь, когда у нас есть все входные данные, приступим к их обработке в переопределенном методе *OnAttached()*. Он вызывается при присоединении поведения к визуальному элементу. К последнему можно обращаться через свойство класса *AssociatedObject*. В противовес, при отсоединении вызывается *OnDetaching()*.
Нам нужны объекты для работы со свойством визуального элемента и событием через рефлексию. Ниже показано их получение и подписывание на событие, уведомляющее об изменениях свойства визуального элемента.
Далее в примерах я опустил различные проверки на *null*, чтобы не засорять внимание. В итоговом варианте класса они присутствуют.
```
private Delegate _handler;
private EventInfo _eventInfo;
private PropertyInfo _propertyInfo;
protected override void OnAttached()
{
Type elementType = AssociatedObject.GetType();
// Получаем свойство визуального элемента
_propertyInfo = elementType.GetProperty(Property, BindingFlags.Instance | BindingFlags.Public);
// Получаем событие, уведомляющее об изменении визуального элемента
_eventInfo = elementType.GetEvent(UpdateEvent);
// Создаем делегат для подписывания на событие
_handler = CreateDelegateForEvent(_eventInfo, EventFired);
// Подписываемся
_eventInfo.AddEventHandler(AssociatedObject, _handler);
}
protected override void OnDetaching()
{
// Отписываемся
_eventInfo.RemoveEventHandler(AssociatedObject, _handler);
}
```
В коде выше имеется метод *CreateDelegateForEvent()*. Он компилирует объект делегата для указанного события во время выполнения. Ведь заранее мы не знаем сигнатуру обработчика события. При компиляции в делегат помещается вызов метода *action*, которым в нашем случае является *EventFired()*. В нем мы будем выполнять нужные нам действия для обновления значения источника данных.
```
private static Delegate CreateDelegateForEvent(EventInfo eventInfo, Action action)
{
ParameterExpression[] parameters =
eventInfo
.EventHandlerType
.GetMethod("Invoke")
.GetParameters()
.Select(parameter => Expression.Parameter(parameter.ParameterType))
.ToArray();
return Expression.Lambda(
eventInfo.EventHandlerType,
Expression.Call(Expression.Constant(action), "Invoke", Type.EmptyTypes),
parameters
)
.Compile();
}
```
Эта операция довольно ресурсоемка, но выполняется лишь раз, при подключении поведения. Ее можно оптимизировать жертвуя гибкостью, предположив, что события могут быть только *RoutedEvent*. Тогда, вместо дорогой компиляции, достаточно подписаться на событие с указанием обработчика *EventFired()*, предварительно изменив ему сигнатуру на совместимую с *RoutedEventHandler*. Но оставим здесь оригинальный вариант. Преждевременная оптимизация — зло.
Метод *EventFired()* предельно прост, он записывает новое значение в источник данных:
```
private void EventFired()
{
Binding = _propertyInfo.GetValue(AssociatedObject, null);
}
```
Осталась самая малость — менять значение свойства визуального элемента при изменении источника данных. Для этого подойдет переопределяемый метод *OnPropertyChanged()*, который сообщает об изменениях свойств зависимостей класса. Так как при изменении источника данных меняется и свойство *Binding*, то нам достаточно отслеживать его новые значения.
```
protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
{
if (e.Property.Name != "Binding") return;
if (_propertyInfo.CanWrite)
_propertyInfo.SetValue(AssociatedObject, e.NewValue, null);
base.OnPropertyChanged(e);
}
```
Все, вроде бы, прекрасно. Мы задаем новое значение свойства визуального элемента и… получаем *StackOverflowException*.
Проблема в том, что при изменении свойства автоматом вызывается уведомляющее событие, на которое мы подписаны. В событии изменяется значение источника, а при изменении источника меняется свойство *Binding*, что приводит нас снова в метод *OnPropertyChanged()*. Рекурсия.
Самым простым решением будет добавление сравнения старого и нового значения свойства:
```
protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
{
if (e.Property.Name != "Binding") return;
object oldValue = _propertyInfo.GetValue(AssociatedObject, null);
if (oldValue.Equals(e.NewValue)) return;
if (_propertyInfo.CanWrite)
_propertyInfo.SetValue(AssociatedObject, e.NewValue, null);
base.OnPropertyChanged(e);
}
```
Здесь делаем допущение, что *Equals()* у типа реализован как надо и не будет вечно возвращать *false*.
Наш хелпер готов!
Результат
---------
Пример использования:
```
```
В данном случае *TextBox* и *PasswordBox* будут синхронно менять значения.
Заключение
----------
Мы добились работы привязки для свойства визуального элемента, которое изначально ее не поддерживало. Привязка работает в оба направления и можно использовать класс поведения для любого элемента, не беспокоясь о различиях в именах свойств и событий.
Заранее извиняюсь за неточности в тексте, моя первая статья.
Как и обещал, финальный код:
**Без проверок на null для быстрого ознакомления**
```
using System;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Windows;
using System.Windows.Interactivity;
using Expression = System.Linq.Expressions.Expression;
namespace DependecyPropertyBehaviorNamesapce
{
public class DependecyPropertyBehavior : Behavior
{
private Delegate \_handler;
private EventInfo \_eventInfo;
private PropertyInfo \_propertyInfo;
public static readonly DependencyProperty BindingProperty = DependencyProperty.RegisterAttached(
"Binding",
typeof(object),
typeof(DependecyPropertyBehavior),
new FrameworkPropertyMetadata { BindsTwoWayByDefault = true }
);
public object Binding
{
get { return GetValue(BindingProperty); }
set { SetValue(BindingProperty, value); }
}
public string Property { get; set; }
public string UpdateEvent { get; set; }
protected override void OnAttached()
{
Type elementType = AssociatedObject.GetType();
\_propertyInfo = elementType.GetProperty(Property, BindingFlags.Instance | BindingFlags.Public);
\_eventInfo = elementType.GetEvent(UpdateEvent);
\_handler = CreateDelegateForEvent(\_eventInfo, EventFired);
\_eventInfo.AddEventHandler(AssociatedObject, \_handler);
}
protected override void OnDetaching()
{
\_eventInfo.RemoveEventHandler(AssociatedObject, \_handler);
}
protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
{
if (e.Property.Name != "Binding") return;
object oldValue = \_propertyInfo.GetValue(AssociatedObject, null);
if (oldValue.Equals(e.NewValue)) return;
if (\_propertyInfo.CanWrite)
\_propertyInfo.SetValue(AssociatedObject, e.NewValue, null);
base.OnPropertyChanged(e);
}
private static Delegate CreateDelegateForEvent(EventInfo eventInfo, Action action)
{
ParameterExpression[] parameters =
eventInfo
.EventHandlerType
.GetMethod("Invoke")
.GetParameters()
.Select(parameter => Expression.Parameter(parameter.ParameterType))
.ToArray();
return Expression.Lambda(
eventInfo.EventHandlerType,
Expression.Call(Expression.Constant(action), "Invoke", Type.EmptyTypes),
parameters
)
.Compile();
}
private void EventFired()
{
Binding = \_propertyInfo.GetValue(AssociatedObject, null);
}
}
}
```
**Итоговый вариант со всеми проверками**
```
using System;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Windows;
using System.Windows.Interactivity;
using Expression = System.Linq.Expressions.Expression;
namespace DependecyPropertyBehaviorNamesapce
{
public class DependecyPropertyBehavior : Behavior
{
private Delegate \_handler;
private EventInfo \_eventInfo;
private PropertyInfo \_propertyInfo;
public static readonly DependencyProperty BindingProperty = DependencyProperty.RegisterAttached(
"Binding",
typeof(object),
typeof(DependecyPropertyBehavior),
new FrameworkPropertyMetadata { BindsTwoWayByDefault = true }
);
public object Binding
{
get { return GetValue(BindingProperty); }
set { SetValue(BindingProperty, value); }
}
public string Property { get; set; }
public string UpdateEvent { get; set; }
protected override void OnAttached()
{
Type elementType = AssociatedObject.GetType();
// Getting property.
if (Property == null)
{
PresentationTraceSources.DependencyPropertySource.TraceData(
TraceEventType.Error,
1,
"Target property not defined."
);
return;
}
\_propertyInfo = elementType.GetProperty(Property, BindingFlags.Instance | BindingFlags.Public);
if (\_propertyInfo == null)
{
PresentationTraceSources.DependencyPropertySource.TraceData(
TraceEventType.Error,
2,
string.Format("Property \"{0}\" not found.", Property)
);
return;
}
// Getting event.
if (UpdateEvent == null) return;
\_eventInfo = elementType.GetEvent(UpdateEvent);
if (\_eventInfo == null)
{
PresentationTraceSources.MarkupSource.TraceData(
TraceEventType.Error,
3,
string.Format("Event \"{0}\" not found.", UpdateEvent)
);
return;
}
\_handler = CreateDelegateForEvent(\_eventInfo, EventFired);
\_eventInfo.AddEventHandler(AssociatedObject, \_handler);
}
protected override void OnDetaching()
{
if (\_eventInfo == null) return;
if (\_handler == null) return;
\_eventInfo.RemoveEventHandler(AssociatedObject, \_handler);
}
protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
{
if (e.Property.Name != "Binding") return;
if (AssociatedObject == null) return;
if (\_propertyInfo == null) return;
object oldValue = \_propertyInfo.GetValue(AssociatedObject, null);
if (oldValue.Equals(e.NewValue)) return;
if (\_propertyInfo.CanWrite)
\_propertyInfo.SetValue(AssociatedObject, e.NewValue, null);
base.OnPropertyChanged(e);
}
private static Delegate CreateDelegateForEvent(EventInfo eventInfo, Action action)
{
ParameterExpression[] parameters =
eventInfo
.EventHandlerType
.GetMethod("Invoke")
.GetParameters()
.Select(parameter => Expression.Parameter(parameter.ParameterType))
.ToArray();
return Expression.Lambda(
eventInfo.EventHandlerType,
Expression.Call(Expression.Constant(action), "Invoke", Type.EmptyTypes),
parameters
)
.Compile();
}
private void EventFired()
{
if (AssociatedObject == null) return;
if (\_propertyInfo == null) return;
Binding = \_propertyInfo.GetValue(AssociatedObject, null);
}
}
}
```
[Github](https://github.com/AndreyMikhailov/DependecyPropertyBehavior "Github") | https://habr.com/ru/post/215249/ | null | ru | null |
# Расширяем C# с помощью Roslyn. Безопасные вызовы
У вас никогда не возникало ощущения, что в языке X, на котором вы в данный момент программируете чего-то не хватает? Какой-нибудь небольшой, но приятной плюшки, которая может и не сделала бы вашу жизнь абсолютно счастливой, но определенно добавила бы немало радостных моментов. И вот вы с черной завистью посматриваете на язык Y, в котором эта штуковина есть, грустно вздыхаете и тайком льете по ночам слезы бессилия в любимую подушку. Бывало?
Пожалуй, C# дает своим адептам и меньше поводов для такой зависти, в сравнении с многими другими, поскольку динамично развивается, добавляя все новые и новые упрощающие жизнь фичи. И все же, нет предела совершенству, причем для каждого из нас — своего.
Сразу отмечу, что приоритетом в данной работе для меня было желание попробовать на зуб Roslyn, а сама идея, которую я дальше опишу, была скорее поводом и тестовым примером для испытаний этой библиотеки. Однако в процессе изучения и реализации я выяснил, что хоть и с некоторыми бубноплясками, но результат действительно можно использовать на практике для реального расширения синтаксиса языка. Как это сделать, кратко опишу в самом конце. А пока приступим.
### Безопасные вызовы и монада Maybe
Идея безопасных вызовов заключается в том, чтобы избавиться от надоедающих проверок любых классов на null, которые являясь необходимостью, в то же время значительно засоряют код и ухудшают его читабельность. В то же время, нет никакого желания находиться под постоянной угрозой выпадения NullReferenceException.
Данная проблема решена в функциональных языках программирования с помощью [монады Maybe](http://en.wikipedia.org/wiki/Monad_(functional_programming)#Maybe_monad), суть которой заключается в том, что после boxing'а использующийся в конвеерных вычислениях тип может содержать некоторое значение, либо значение Nothing. В случае, если предыдущее вычисление в конвеере дало некоторый результат, то производится следующее вычисление, если же оно вернуло Nothing, то вместо следующего вычисления вновь возвращается Nothing.
В С# созданы все условия для реализации данной монады — вместо Nothing используется null, для структурных типов могут использоваться их Nullable версии. В принципе, идея уже витает в воздухе, и было несколько статей, в которых реализовывалась данная монада в C# с помощью LINQ. [Одна](http://devtalk.net/csharp/chained-null-checks-and-the-maybe-monad/) из них принадлежит Дмитрию Нестеруку [mezastel](http://habrahabr.ru/users/mezastel/), есть еще и [другая](http://mikehadlow.blogspot.com/2011/01/monads-in-c-5-maybe.html).
Но нельзя не отметить, что при всей заманчивости такого подхода, результирующий код с использованием монады выглядит весьма туманно, из-за необходимости использовать вместо прямых вызовов обертки из лямбда-функций и LINQ. Однако без синтаксических средств языка реализовать ее более элегантно вряд ли представляется возможным.
Достаточно элегантный, как мне показалось, способ реализации данной идеи я обнаружил в спецификации еще пока не созданного языка Kotlin для JDK от ребят из горячо мною любимой компании JetBrains ([Null-safety](http://confluence.jetbrains.net/display/Kotlin/Null-safety)). Как оказалось, такой есть уже в Groovy, возможно и еще где-то.
Итак, что же это за оператор безопасного вызова? Предположим, у нас есть выражение:
```
string text = SomeObject.ToString();
```
В случае, если SomeObject является null, мы неминуемо, как уже говорилось, получим NullReferenceException. Чтобы этого избежать, определим в дополнение к оператору прямого вызова '.' еще и оператор безопасного вызова '?.' который выглядит следующим образом:
```
string text = SomeObject?.ToString();
```
и представляет собой на самом деле выражение:
```
string text = SomeObject != null ? SomeObject.ToString() : null;
```
В случае, если безопасно вызываемый метод или свойство возвращает структурный тип, необходимо чтобы присваиваемая переменная имела тип Nullable.
```
int? count = SomeList?.Count;
```
Как и обычные вызовы, такие безопасные вызовы можно использовать цепочками, например:
```
int? length = SomeObject?.ToString()?.Length;
```
который преобразуется в выражение:
```
int? length = SomeObject != null ? SomeObject.ToString() != null ? SomeObject.ToString().Length : null : null;
```
Здесь скрывается некоторый недостаток предлагаемого мной преобразования, поскольку оно порождает дополнительные вызовы функций. На самом деле желательно было бы преобразовывать его, например, к виду:
```
var temp = SomeObject;
string text = null;
if (temp != null)
text = temp.ToString();
```
Однако в ввиду некоторой многословности Roslyn, для того, чтобы примеры не были бы чересчур раздутыми и занудными, я решил сделать преборазование попроще. Впрочем об этом в следующих частях.
### Project Roslyn
Как вы может уже слышали, совсем недавно была выпущена CTP версия [проекта Roslyn](http://habrahabr.ru/blogs/net/130884/), в рамках которого разработчиками языков C# и VB были полностью переписаны компиляторы языков с использованием managed кода, и открыт доступ к этим компиляторам в виде API. С его помощью разработчики могут делать много полезных вещей, например очень удобно и просто анализировать, оптимизировать, генерировать код, писать экстеншны и код фиксы для студии, а возможно и собственные DSL. Выйдет она, правда, еще не скоро, аж через одну версию Visual Studio, но пощупать хочется уже сейчас.
Перейдем к решению нашей задачи и прежде всего представим, как бы нам хотелось видеть использование данного расширения языка в действии? Очевидно: мы пишем код, как обычно, в любимой IDE, используем где надо операторы безопасного вызова, жмем Build, во время компиляции написанная нами с помощью Project Roslyn утилита преобразует все это в синтаксически верный C#-код и вуа-ля, все скомпилировано. Спешу вас разочаровать — Roslyn не позволяет вмешиваться в процесс работы текущего компилятора csc.exe, что в принципе довольно объяснимо. Вполне вероятно, если в той самой vNext студии компилятор заменят на его Managed аналог, то такая возможность появится. Но пока ее нет.
В то же время, существует аж два обходных пути:
1. Можно создать свой собственный компилятор взамен нынешнему csc.exe с использованием все того же Roslyn API, и изменить свою build-систему, заменив csc.exe на свой аналог, включив в него помимо дефолтной компиляции (довольно, кстати, просто программирующейся) свои предварительные преобразования кода.
2. Вы можете использовать свою консольную программу в качестве Pre-Build задачи, которая преобразует файлы исходного кода и сохраняет полученные новые исходники в папку Obj. Очень похожим образом осуществляется в данный момент компиляция WPF, когда xaml файлы в фазе pre-build преобразуются в .g.cs файлы.
Project Roslyn предоставляет несколько видов функциональности, однако одна из ключевых — построение, разбор и преобразование абстрактного синтаксического дерева. Именно эту его функциональность мы и будем использовать далее.
### Имплементация
Конечно, все написанное ниже лишь пример, страдает от множества пороков и не может использоваться в реальности без существенных доработок, однако показывает, что такие вещи сделать в принципе можно.
Перейдем к реализации. Для того, чтобы написать программу, нам прежде всего надо установить Roslyn SDK, который скачивается по [ссылке](http://www.microsoft.com/download/en/details.aspx?id=27746), также предварительно придется поставить Service Pack 1 для Visual Studio 2010, и Visual Studio 2010 SDK SP1.
После всех этих операций в меню создания новых проектов появится подпункт Roslyn, который включает в себя несколько шаблонов проектов (некоторые из которых могут интегрироваться в IDE). Мы создадим простое консольное приложение.
Для примера будем использовать следующий «исходный код»:
```
public class Example
{
public const string CODE =
@"using System;
using System.Linq;
using System.Windows;
namespace HelloWorld
{
public class TestClass
{
public string TestField;
public string TestProperty { get; set; }
public string TestMethod() { return null; }
public string TestMethod2(int k, string p) { return null; }
public TestClass ChainTest;
}
public class OtherClass
{
public void Test()
{
TestClass test;
string testStr1;
testStr1 = test?.TestField;
string testStr3 = test?.TestProperty;
string testStr4 = test?.TestMethod();
string testStr5 = test?.TestMethod2(100, testStr3);
var test3 = test?.ChainTest?.TestField;
}
}
}";
}
```
Данный исходный код за исключением операторов безопасного вызова являются не только синтаксически правильным, но и компилируемым, хотя для нашего преобразования это и не обязательно.
Прежде всего, необходимо по файлу с исходным кодом построить абстрактное синтаксическое дерево. Делается это в два счета:
```
SyntaxTree tree = SyntaxTree.ParseCompilationUnit(Example.CODE);
SyntaxNode root = tree.Root;
```
Синтаксическое дерево задается классом SyntaxTree и представляет собой, как ни странно, дерево узлов, наследуемых от базового типа SyntaxNode, каждый из которых представляет некоторое выражение — бинарные выражения, условные выражения, выражения вызова методов, определения свойств и переменных. Естественно, абсолютно любая конструкция C# может быть отображена некоторым экзмепляром класса-наследника SyntaxNode. Кроме того, класс SyntaxTree содержит в себе наборы SyntaxToken, определяющих разбор исходного кода на уровне минимальных синтаксических блоков — ключевых слов, литералов, идентификаторов и пунктуации (фигурные и круглые скобки, запятые, точки с запятыми). Наконец, SyntaxTree в содержит в себе элементы SyntaxTrivia — те, которые по большому счету не важны для понимания кода — пробелы и табуляции, комментарии, директивы препроцессора и.т.д.
Тут следует знать одну небольшую деталь — Roslyn является очень толерантным к синтаксическому разбору файлов. То есть, хотя по-хорошему, ему для разбора надо подавать синтаксически корректный исходный код, на самом деле он абсолютно любой текст пытается некоторым образом преобразовать в некоторое AST. В том числе и наш синтаксически неверный код. Этим фактом мы и воспользуемся. Попробуем построить синтаксическое дерево, и выяснить, каким же образом Roslyn отображает в дереве наш оператор безопасного вызова.
Оказывается все просто: с точки зрения Roslyn выражение test?.TestField является тернарным оператором с условием — «test», выражением «когда верно» — ".TestField", и пустым выражением «когда неверно». Вооружившись этой информацией, будем преобразовывать наше дерево. Тут натыкаемся еще на одну особенность Roslyn — строимое им синтаксическое дерево является неизменяемым, т. е. поправить что-либо прямо в имеющейся структуре не получится. Но не беда. Roslyn предлагает для такой операции использовать класс SyntaxRewriter, который наследует класс SyntaxVisitor, который, как следует из названия, имплментирует небезызвестный паттерн [Visitor](http://en.wikipedia.org/wiki/Visitor_pattern). Он содержит в себе множество виртуальных методов, обрабатывающих посещение узла каждого конкретного типа (например VisitFieldDeclaration, VisitEnumMemberDeclaration,… всего их порядка 180 штук).
Нам необходимо создать своего наследника класса SyntaxRewriter и переопределить метод VisitConditionalExpression, который вызывается, когда визитор обходит выражение, являющееся тернарным оператором. Далее я приведу целиком код имплементации, тем более, что он невелик, и добавлю лишь некоторые пояснения:
```
// Находит в синтаксическом дереве операторы безопасного вызова и заменяет их на тернарные операторы
public class SafeCallRewriter : SyntaxRewriter
{
//Был ли в данный проход заменен хотя бы один оператор ?.
public bool IsSafeCallRewrited { get; set; }
protected override SyntaxNode VisitConditionalExpression(ConditionalExpressionSyntax node)
{
if (IsSafeCallExpression(node))
{
//Строим expression для объекта, проверяемого на null
string identTxt = node.Condition.GetText();
ExpressionSyntax ident = Syntax.ParseExpression(identTxt);
//Строим expression для кода, вызываемого при успешной проверка на != null
string exprTxt = node.WhenTrue.GetText();
exprTxt = exprTxt.Substring(1, exprTxt.Length - 1);//убираем точку из записи выражения
exprTxt = identTxt + '.' + exprTxt;
ExpressionSyntax expr = Syntax.ParseExpression(exprTxt);
ExpressionSyntax synt =
Syntax.ConditionalExpression(//тернарный оператор
condition: Syntax.BinaryExpression(//проверяемое условие ident != null
SyntaxKind.NotEqualsExpression,
left: ident, //левый операнд - проверяемый объект
right: Syntax.LiteralExpression(SyntaxKind.NullLiteralExpression)), //литерал null
whenTrue: expr,
whenFalse: Syntax.LiteralExpression(SyntaxKind.NullLiteralExpression));
IsSafeCallRewrited = true;
return synt;
}
return base.VisitConditionalExpression(node);
}
//Является ли тернарный оператор на самом деле оператором безопасного вызова
private bool IsSafeCallExpression(ConditionalExpressionSyntax node)
{
return node.WhenTrue.GetText()[0] == '.';
}
}
```
Отмечу, что первая моя реализация пыталась работать только с логической структурой AST, брезгуя работой с текстовым представлением выражений, но сложность ее очень скоро стала превышать все мыслимые пределы. Одних только функций для определения безопасного вызова и его типа было три штуки: для полей и свойств, для вызова методов, для цепочек безопасных вызовов, ибо все это представлялось разными наследниками класса SyntaxNode, и еще множество функций для преобразования различных типов безопасных операторов. Совершенно выдохнувшись, я выбросил первый вариант в мусорку и во второй раз я воспользовался удобными функциями GetText и ParseExpression, которые предоставляет Roslyn и некоторыми грязными хаками на уровне строк :).
Также советую обратить внимание на процесс создания синтаксического узла (в данном случае ConditionalExpression) и приятность использования в этом случае такой фишки C#, как именованные параметры. Ручаюсь, если бы ее не было, в процессе построения синтаксических узлов можно было бы сойти с ума.
Приведем теперь код основной процедуры:
```
static void Main(string[] args)
{
//Строим синтаксическое дерево
SyntaxTree tree = SyntaxTree.ParseCompilationUnit(Example.CODE);
SyntaxNode root = tree.Root;
SafeCallRewriter rewriter = new SafeCallRewriter();
do
{
rewriter.IsSafeCallRewrited = false;
//Обходим дерево, производя заданные операции в различных типах узлов и переписывая дерево
root = rewriter.Visit(root);
} while (rewriter.IsSafeCallRewrited);//за предыдущий проход был найден и преобразован хоть 1 maybe-оператор
root = root.Format();//программный Ctrl+K, Ctrl+D
Console.WriteLine(root.ToString());
}
```
Поясню, что несколько перезаписей дерева необходимо для того, чтобы обработать цепочки вызовов. Конечно это можно было сделать рекурсией, но пожалуй в данном случае это только затуманило бы код. Также обратите внимание на чудесную функцию Format. Она программно делает заданное стилистическое форматирование кода, т.е. добавляет в AST все необходимые SyntaxTrivia.
В результате имеем следующий код:
```
using System;
using System.Linq;
using System.Windows;
namespace HelloWorld
{
public class TestClass
{
public string TestField;
public string TestProperty
{
get;
set;
}
public string TestMethod()
{
return null;
}
public string TestMethod2(int k, string p)
{
return null;
}
public TestClass ChainTest;
}
public class OtherClass
{
public void Test()
{
TestClass test;
string testStr1;
testStr1 = test != null ? test.TestField : null;
string testStr3 = test != null ? test.TestProperty : null;
string testStr4 = test != null ? test.TestMethod() : null;
string testStr5 = test != null ? test.TestMethod2(100, testStr3) : null;
var test3 = test != null ? test.ChainTest != null ? test.ChainTest.TestField : null : null;
}
}
}
```
Итак, первое знакомство с Roslyn прошло успешно, и перспективы его в целом, не обязательно для написания языковых расширений, видятся очень неплохие. Возможно, если есть энтузиасты, этим можно было бы заняться глубже и серьезнее. В C# же есть еще много, чего нам не хватает. :)
P. S. Еще один пример подобного использования Roslyn, который мне значительно помог, приведен [здесь](http://www.mindscapehq.com/blog/index.php/2011/10/20/in-bed-with-roslyn/). | https://habr.com/ru/post/133340/ | null | ru | null |
# Prometheus in Action: from default counters to SLO-related queries
A Gentle Intro
--------------
All Prometheus metrics are based on **time series** - streams of timestamped values belonging to the same metric. Each time series is uniquely identified by its metric name and optional key-value pairs called labels. The metric name specifies some characteristics of the measured system, such as `http_requests_total` - the total number of received HTTP requests. In practice, you often will be interested in some subset of the values of a metric, for example, in the number of requests received by a particular endpoint; and here is where the labels come in handy. We can partition a metric by adding `endpoint` label and see the statics for a particular endpoint: `http_requests_total{endpoint="api/status"}.` Every metric has two automatically created labels: `job_name` and `instance`. We see their roles in the next section.
Prometheus provides a functional query language called PromQL. The result of the query might be evaluated to one of four types:
* **Scalar** (aka float)
* ***String*** *(currently unused)*
* **Instant Vector** - a set of time series that have exactly one value per timestamp.
* **Range Vector** - a set of time series that have a range of values between two timestamps.
At first glance, **Instant Vector** might look like an array, and **Range Vector** as a matrix.
If that would be the case, then a Range Vector for a single time series "downgrades" to an Instant Vector. However, that's not the case: the difference between a Range Vector and an Instant Vector is not in the number of tracked time series but in the relation between a value of the metric and the corresponding timestamp. In Instant Vector a time series has a single value at the timestamp, in Range Vector a time series has an arbitrary number of values between two timestamps. Therefore, we can more accurately visualize a Range Vector in the following form:
The difference between an instant vector and a range vector will be more clearly seen in the action: let's instrument a Go application and see how can Prometheus help us with insights.
A **Counter** is a metric that only goes up, for example, a number of the incoming HTTP requests.
A **Gauge** is a metric that can have an arbitrary float value, for example, current CPU usage.
A **Histogram** summarizes observations into statistical buckets, for example, we can track an API's response times. Why would one need a histogram and can't just measure the average response time? This is because we are not always interested in the average response times only. Let's say we have an SLO and 95% of the requests should take no longer than 300 ms. We need to single out all requests that took 300 ms or less, count their amount, and divide it by the total number of the request. To do so in Prometheus, we configure a histogram to have a bucket with an upper limit of 0.3 seconds for a response. Later we see how can we configure an alert if we fail to comply with the SLO.
There is also a **Summary,** however it is left mostly for historical reasons and serves the same purpose as a histogram.
Instrumenting a Go application
------------------------------
Let's start **without** a Prometheus server.
```
package main
import (
"net/http"
"github.com/prometheus/client_golang/prometheus/promhttp"
)
func main() {
http.Handle("/metrics", promhttp.Handler())
http.ListenAndServe(":2112", nil)
}
```
`promhttp.Handler` returns an http.Handler which is already instrumented with the default metrics. Let's see what we get right out of the box by issuing a GET request to the `/metrics` endpoint.
> `http localhost:2112/metrics`
>
>
```
# HELP go_gc_duration_seconds A summary of the pause duration of garbage collection cycles.
# TYPE go_gc_duration_seconds summary
go_gc_duration_seconds{quantile="0"} 0
go_gc_duration_seconds{quantile="0.25"} 0
go_gc_duration_seconds{quantile="0.5"} 0
go_gc_duration_seconds{quantile="0.75"} 0
go_gc_duration_seconds{quantile="1"} 0
go_gc_duration_seconds_sum 0
go_gc_duration_seconds_count 0
# HELP go_goroutines Number of goroutines that currently exist.
# TYPE go_goroutines gauge
go_goroutines 8
# HELP go_info Information about the Go environment.
# TYPE go_info gauge
go_info{version="go1.15.5"} 1
# HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
# TYPE go_memstats_alloc_bytes gauge
[truncated]
```
As we can see we have a rather impressive list of metrics of all types: counters, gauges, and summaries.
One of particular interest is a gauge for currently existing goroutines:
```
# HELP go_goroutines Number of goroutines that currently exist.
# TYPE go_goroutines gauge
go_goroutines 7
```
Note, that it is the number of **existing** goroutines, but not the **running** ones: some of the goroutines might be in the suspended state. One of the goroutines is our `main` function; the rest are running helper functions from `runtime` package, and are responsible for tasks such as garbage collection. Later we see how we can use this metric to reveal potential memory leaks.
At the end very end, we see a familiar metric for the received HTTP request with label `code`.
```
promhttp_metric_handler_requests_total{code="200"} 1
promhttp_metric_handler_requests_total{code="500"} 0
promhttp_metric_handler_requests_total{code="503"} 0
```
At the next curl request, the metric will be increased by one.
Now, this is already looking promising, but how can we instrument **our own** code? Let's add a simple metric for the processed orders; as this number can only increase, the counter type is a natural choice.
```
package main
import (
"net/http"
"time"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promauto"
"github.com/prometheus/client_golang/prometheus/promhttp"
)
var counter = promauto.NewCounter(prometheus.CounterOpts{
Name: "orders_processed",
})
func main() {
go func() {
for {
counter.Inc()
// simulate some processing function
time.Sleep(time.Second)
}
}()
http.Handle("/metrics", promhttp.Handler())
http.ListenAndServe(":2112", nil)
}
```
`prometheus` package provides metrics data types, and `promauto` package automates some routine tasks, such as metric registration.
Now, we can see how well our processing goes:
> http localhost:2112/metrics | grep orders\_processed
>
>
```
# HELP orders_processed
# TYPE orders_processed counter
orders_processed 7
```
If we issue the request again we can verify that the processing is up and running:
```
# HELP orders_processed
# TYPE orders_processed counter
orders_processed 10
```
If you have a feeling that these values are not that illuminating, then you are on the right track. **Prometheus is a statistical instrument** at its core: it is intended to work with the trends, and not with the individual results. Later we see how to get some insights with `rate` and `increase` functions.
Now, we have already instrumented our application **and have not yet run Prometheus itself.** Why do we need one? A Prometheus server allows us to aggregate data from several instances of our application. It scrapes our application and collects the values of metrics. Here is a simple Prometheus configuration:
```
scrape_configs:
- job_name: myapp
scrape_interval: 10s
static_configs:
- targets:
- 127.0.0.1:2112
```
Prometheus server will scrape our application on port 2112 every 10 seconds and collects the metrics. Let's bind this configuration to a docker container and run a Prometheus server:
```
docker run \
--network "host" \
-p 9090:9090 \
-v $HOME/GolandProjects/go-learn/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml \
prom/prometheus
```
Note, that we have to enable networking in `host` mode: our docker container needs to access `metric` endpoint in our application which is outside of the docker network.
Now we can access Prometheus UI on [localhost:9090](http://localhost:9090). Here we can see that we are successfully scraping metrics from our application.
How many goroutines do we have? In a table view we see the last recorded value:
And in a table view we can see the trend:
The result of this query (`go_goroutines`) is an instant vector that contains a single time series. What will be the result for the same query when we run a second instance of our application? Then `instance` label will have two possible values for two instances, therefore we get two time series. And as noted above we still have an instant vector, not a range vector.
Let's add one more target to our configuration and start the second instance of our application at port `21112`.
```
scrape_configs:
- job_name: myapp
scrape_interval: 10s
static_configs:
- targets:
- 127.0.0.1:2112
- 127.0.0.1:21112
```
Here we can see the number of goroutines for both our instances.
If we provide a time range we get a range vector:
In this case, we requested a **range** of values between two timestamps: now and five minutes in the past with a step equal to 1 minute. In the output, symbol `@`separates a value of a metric from its timestamp.
Neither `Prometheus` no `Grafana` can picture the graph for a range vector. However, all function that takes a range vector as input returns an instant vector which in turn can be pictured.
Prometheus Functions and Modifiers
----------------------------------
The two most useful range functions are `increase` and `rate;` both of them should be used only with counters. Let's have a look at our `orders_processed` metric.
Prometheus is happy to tell us that one of the instances has processed ~7000 orders so far.
What insights can we get from this number? Actually, not that much. For example, it would be more interesting to know how many orders did we processed recently. Here we calculate the increase in the number of processed orders during the last 5 minutes.
This number could shed some light on the health of our application if we knew how many orders we expected to process under normal conditions. Let's compare it with some reference point in the past: let's imagine that we just deployed a nightly build of our application, and two hours ago we were running a thoroughly tested stable version.
Modifier `offset`changes the time offset for the vector in the query:
Currently, we have roughly the same increase in the number of orders as 2 hours ago: therefore, we can **assume** that our new build didn't break anything (yet).
What is our current rate of order processing?
We processed 197 orders during the last 5 minutes, therefore the per-second average rate of increase is calculated as `197 orders / 5 * 60 seconds` and is equal to ~0.7 orders per second. Prometheus has in-build function `rate` for this purpose:
As you can see from the graphs `rate` and `increase` are basically reveals the same pattern.
Now, how can we calculate the total rate of order processing for all instances of the application? We need to sum the rates of all instances:
However, if we try to sum rates of different instances we get `Empty query result`. This happens because before the application of a binary operation Prometheus selects time series that have exactly the same set of labels from the left and right operands. In our case, Prometheus didn't find matching time series due to the difference in `instance` label.
We can use `on` keyword to specify that we only want to match by `job` label (and effectively ignore the difference in `instance` label)
Or we can use `ignoring` keyword to explicitly ignore `instance` label:
What happens if we have ten instances of our application instead of two? Especially, taking into consideration that Kubernetes is free to kill any instance at any time, and spin up a new one. Prometheus offers aggregate functions that relieve us from the manual bookkeeping:
Note, that we applied aggregate operaion `sum` to `rate` function and not vise versa. We always take `rate` first and then apply the aggregation; otherwise, `rate` cannot detect counters restarts when the application restarts. As [Robust Perception Blog](https://www.robustperception.io/rate-then-sum-never-sum-then-rate) puts it:
> The only mathematical operations you can safely directly apply to a counter's values are rate, irate, increase, and resets. Anything else will cause you problems.
>
>
`orders_processed` is a rather generic metric; it could possibly have another label `application` that partitions it by different applications. In this case query `sum(rate(orders_processed[5m]))` returns the total rate for all applications which would be rather useless. We calculate the rate per application by using `by` keyword: `sum by (application) (rate(orders_processed[5m]))`.
We can check a potential memory leak by comparing the current total number of goroutines for the application with the total number of goroutines recorded an hour ago:
```
sum(rate(go_goroutines[5m] offset 1h)) /
sum(rate(go_goroutines[5m]))
```
SLO-related queries
-------------------
### API Errors Rate
Let's say we have counter `http_requests_total` that tracks the number of the received requests and has label `status_code`.
We can determine the rate for the failed requests due to server errors:
```
rate(http_requests_total{status_code=~"5.*"}[5m])
```
We calculate the error ratio by dividing the rate of failed request on the total rate:
```
sum(rate(http_requests_total{status_code=~"5.*"}[5m])
/ sum(rate(http_requests_total[5m])
```
Finally, we can check whether the proportion of failed API requests is larger than 10%
```
sum(rate(http_requests_total{status_code=~"5.*"}[5m])) /
sum(rate(http_requests_total[5m]))
> 0.1
```
### Request Latency
Another metric `response_latency_ms` tracks the latency of the API responses in ms. We can check whether 95% of the responses take less or equal than 5 seconds.
```
histogram_quantile(
0.95,
sum(rate(request_latency_ms_bucket[5m])) by (le)
) / 1e3 > 5
```
`le` (less or equal) - is a required label that denotes an inclusive upper limit for the bucket, in our case 0.95-quantile. We divide the query result by `1e3` (1000) to convert from milliseconds to seconds.
Conclusion
----------
As we can Prometheus is a powerful and flexible tool. This article covers its usage from basic instrumentation of a Go application to SLO-related PromQl queries. | https://habr.com/ru/post/538692/ | null | en | null |
# ТОП-10 ошибок, найденных в C#-проектах за 2020 год
Наконец-то столь нелёгкий 2020 подходит к концу, а это значит, что пришло время подвести итоги! За этот год командой PVS-Studio было написано немало статей, в которых разбирались разнообразные ошибки, найденные анализатором в open-source проектах. Самые же интересные из них вы можете увидеть прямо здесь, в ТОП-е ошибок, обнаруженных в C#-проектах за 2020 год. Приятного просмотра!
Как формировался топ
--------------------
В данном списке собраны самые интересные, на мой взгляд, срабатывания, о которых мы с коллегами писали в статьях за 2020 год. Важным критерием отбора была степень уверенности в том, что в соответствующем фрагменте кода действительно допущена ошибка. И, конечно, при отборе, а также расстановке мест, учитывалась, собственно, 'интересность' срабатывания, но это уже моё субъективное мнение — оспорить его вы всегда можете в комментариях.
Я старался сделать топ максимально разнообразным: как в плане сообщений PVS-Studio, так и в плане проектов, на код которых были выданы предупреждения. В список попали срабатывания на исходники 8 проверенных проектов. При этом и диагностические правила почти не повторяются — встретить дважды тут можно только [V3022](https://www.viva64.com/ru/w/v3022/) и [V3106](https://www.viva64.com/ru/w/v3106/) (и нет, их делал не я, но, видимо, это мои любимые). Таким образом, разнообразие вам тут обеспечено :).
Что ж, начнём! Топ 10!
----------------------
### 10 место – Новая старая лицензия
Открывает наш топ срабатывание из [статьи](https://www.viva64.com/ru/b/0740/) одного очень хорошего человека про проверку C#-проектов под Linux и macOS, где в качестве примера использовался проект RavenDB:
```
private static void UpdateEnvironmentVariableLicenseString(....)
{
....
if (ValidateLicense(newLicense, rsaParameters, oldLicense) == false)
return;
....
}
```
**Предупреждение анализатора**: [V3066](https://www.viva64.com/ru/w/v3066/) Possible incorrect order of arguments passed to 'ValidateLicense' method: 'newLicense' and 'oldLicense'. LicenseHelper.cs(177) Raven.Server
Казалось бы, что тут не так? Код же вполне компилируется. С чего анализатор решил, будто надо сначала передавать *oldLicense*, а потом *newLicense*? Вы уже догадались, не так ли? Глянем-ка на объявление *ValidateLicense*:
```
private static bool ValidateLicense(License oldLicense,
RSAParameters rsaParameters,
License newLicense)
```
Ух ты, и правда – сначала в параметрах идёт старая, а только потом — новая лицензия. А ну-ка скажите, может этот ваш динамический анализ такое отловить? :)
В любом случае, срабатывание интересное. Может, там на самом деле и не важен порядок, но такие фрагменты лучше перепроверять, согласны?
### 9 место – 'FirstOrDefault' и неожиданный 'null'
На 9 месте оказалось срабатывание из статьи "[В "osu!" играй, про ошибки не забывай](https://www.viva64.com/ru/b/0704/)", написанной в начале ныне уходящего года:
```
public ScoreInfo CreateScoreInfo(RulesetStore rulesets)
{
var ruleset = rulesets.GetRuleset(OnlineRulesetID);
var mods = Mods != null ? ruleset.CreateInstance()
.GetAllMods().Where(....)
.ToArray() : Array.Empty();
....
}
```
Видите ошибку? А она есть! Что же говорит анализатор?
**Предупреждение анализатора**: [V3146](https://www.viva64.com/ru/w/v3146/) [CWE-476] Possible null dereference of 'ruleset'. The 'FirstOrDefault' can return default null value. APILegacyScoreInfo.cs 24
Да-да, я снова не дал всей необходимой информации сразу. На самом деле, в этом коде и правда нельзя увидеть ничего подозрительного. Ведь *FirstOrDefault*, о котором нам говорит анализатор, находится в определении метода *GetRuleset*:
```
public RulesetInfo GetRuleset(int id) =>
AvailableRulesets.FirstOrDefault(....);
```
Страшное дело! Метод вернёт *RulesetInfo*, если найдёт подходящий. А если нет? Спокойненько возвращаем *null*. И выстрелит уже в том месте, где результат вызова будет использован. В данном случае – при вызове *ruleset.CreateInstance()*.
Может возникнуть вопрос: ну а вдруг там никогда не бывает *null*? Вдруг в коллекции всегда найдётся нужный элемент? Ну что ж, если разработчик уверен в этом, то почему бы вместо *FirstOrDefault* не использовать *First*?
### 8 место – Привет из Python
Последнее срабатывание из первой тройки было выдано на код проекта RunUO. Статья, посвящённая его проверке, написана в феврале и доступна по [этой ссылке](https://www.viva64.com/ru/b/0711/).
Найденный фрагмент крайне подозрителен, хотя сложно сказать наверняка, является ли он ошибкой:
```
public override void OnCast()
{
if ( Core.AOS )
{
damage = m.Hits / 2;
if ( !m.Player )
damage = Math.Max( Math.Min( damage, 100 ), 15 );
damage += Utility.RandomMinMax( 0, 15 );
}
else { .... }
}
```
**Предупреждение анализатора**: [V3043](https://www.viva64.com/ru/w/v3043/) The code's operational logic does not correspond with its formatting. The statement is indented to the right, but it is always executed. It is possible that curly brackets are missing. Earthquake.cs 57
Всё верно – дело в отступах! Создаётся впечатление, что строка *damage += Utility.RandomMinMax( 0, 15 )* должна была выполняться только в том случае, если *m.Player* – *false*. Подобным образом работал бы код на Python, где отступы пишутся не только для красоты, но и для определения логики приложения. Но компилятор C# придерживается другого мнения в данном вопросе! Интересно, а какое мнение было у разработчика?
Вообще в данной ситуации есть 2 варианта. Либо тут действительно пропущены фигурные скобки, и всё работает неправильно, либо всё работает правильно, но со временем точно найдётся человек, который посчитает это ошибкой и "исправит" её.
Возможно, я не прав, и действительно бывают случаи, когда нормально написать что-то такое. Если вам такие известны, то, пожалуйста, напишите комментарий – мне было бы действительно интересно узнать о таких кейсах.
### 7 место – Perfect или Perfect – вот в чём вопрос!
Распределять предупреждения по местам становится всё труднее, а мы переходим ко второму в этом списке срабатыванию из [статьи про osu!](https://www.viva64.com/ru/b/0704/).
Как много времени вам понадобится, чтобы увидеть ошибку?
```
protected override void CheckForResult(....)
{
....
ApplyResult(r =>
{
if ( holdNote.hasBroken
&& (result == HitResult.Perfect || result == HitResult.Perfect))
result = HitResult.Good;
....
});
}
```
**Предупреждение анализатора**: [V3001](https://www.viva64.com/ru/w/v3001/) There are identical sub-expressions 'result == HitResult.Perfect' to the left and to the right of the '||' operator. DrawableHoldNote.cs 266
Думаю, немного, ведь достаточно лишь прочитать предупреждение PVS-Studio. Разработчики, использующие статический анализ, так обычно и делают :). Можно было бы спорить про предыдущие места в топе, но здесь ошибка налицо. Сложно сказать, какой именно элемент перечисления *HitResult* здесь должны были использовать вместо второго *Perfect* (ну или вместо первого), но в итоге написано явно что-то не то. Что ж, ничего страшного – ошибка найдена, а значит, её можно легко исправить.
### 6 место – null (не) пройдёт!
На 6 месте оказалось очень крутое срабатывание на код из проекта Open XML SDK. Статью, посвящённую его проверке, можно прочитать [здесь](https://www.viva64.com/ru/b/0777/).
Разработчик хотел реализовать свойство, которое не вернёт *null*, даже если его присвоить напрямую. И это действительно здорово, когда можешь быть уверен, что *null* ни при каких обстоятельствах не будет записан. Жаль, что это совсем не та ситуация:
```
internal string RawOuterXml
{
get => _rawOuterXml;
set
{
if (string.IsNullOrEmpty(value))
{
_rawOuterXml = string.Empty;
}
_rawOuterXml = value;
}
}
```
**Предупреждение анализатора**: [V3008](https://www.viva64.com/ru/w/v3008/) The '\_rawOuterXml' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 164, 161. OpenXmlElement.cs 164
Получается, что в *\_rawOuterXml* будет записано *value* вне зависимости от того *null* оно или нет. Невнимательно взглянув на этот код, можно посчитать, что в это свойство никогда не будет записан *null* – ведь проверка-то есть! Что ж, раз так, то под ёлкой можно обнаружить не подарки, а неожиданный *NullReferenceException* :(
### 5 место – Выстрел из массива с массивом внутри
Топ-5 срабатывание 2020 года было выдано анализатором на лично мною проверенный проект TensorFlow.NET. Перейдя по [ссылке](https://www.viva64.com/ru/b/0725/), можно ознакомиться со статьёй, посвящённой проверке этого проекта (ох, и много ж я там повидал всякого).
Кстати, если вы любите смотреть примеры интересных ошибок из реальных C#-проектов, то предлагаю вам подписаться на [мой твиттер](https://twitter.com/Nikita30005701). Там я планирую выкладывать любопытные срабатывания и просто интересные фрагменты кода, многие из которых, увы, не попадут в статьи. Буду рад вас видеть! :)
Ну а теперь перейдём-таки к срабатыванию:
```
public TensorShape(int[][] dims)
{
if(dims.Length == 1)
{
switch (dims[0].Length)
{
case 0: shape = new Shape(new int[0]); break;
case 1: shape = Shape.Vector((int)dims[0][0]); break;
case 2: shape = Shape.Matrix(dims[0][0], dims[1][2]); break; // <=
default: shape = new Shape(dims[0]); break;
}
}
else
{
throw new NotImplementedException("TensorShape int[][] dims");
}
}
```
**Предупреждение анализатора**: [V3106](https://www.viva64.com/ru/w/v3106/) Possibly index is out of bound. The '1' index is pointing beyond 'dims' bound. TensorShape.cs 107
На самом деле, было очень сложно выбрать, на какое место поставить это срабатывание, так как оно действительно интересное, но и другие в этом плане не отстают. Итак, давайте разбираться, что же тут происходит.
Если количество массивов в *dims* не равно 1, то кидается исключение типа *NotImplementedException*. А что будет, если в *dims* ровно один массив? Производится проверка количества элементов в этом 'массиве внутри массива'. Обратите внимание на то, что происходит, когда оно равно 2. В качестве одного из аргументов конструктора *Shape.Matrix* передаётся, неожиданно, *dims[1][2]*. А теперь давайте-ка вспомним — сколько там было элементов в массиве *dims*?
Верно, ровно один – мы ведь это проверяли только что! Попытка получения второго элемента из массива, в котором всего один элемент, приведёт к выбрасыванию исключения типа *IndexOutOfRangeException*. Очевидно, ошибка. А вот очевиден ли способ её исправления?
Первым, что приходит на ум, будет изменение *dims[1][2]* на *dims[0][2]*. Ошибка исчезнет? Как бы не так! Опять будет то же самое исключение. Но на этот раз оно будет связано с тем, что в данной case-ветке количество элементов в *dims[0]* равно 2. Неужели разработчик допустил две ошибки в индексе подряд? Или всё-таки там должна использоваться какая-то другая переменная? Кто знает… Дело анализатора – ошибку найти, а уж исправлять её придётся допустившему её человеку или его коллегам.
### 4 место – Свойство объекта, которого нет
Ещё одно срабатывание попало в это топ из [статьи про проверку OpenRA](https://www.viva64.com/ru/b/0754/). Возможно, оно и заслуживает большего, но волею судьбы это срабатывание оказалось на 4 месте. Что ж, это тоже весьма неплохо! Давайте же глянем, какую ошибку смог обнаружить PVS-Studio на этот раз:
```
public ConnectionSwitchModLogic(....)
{
....
var logo = panel.GetOrNull("MOD\_ICON");
if (logo != null)
{
logo.GetSprite = () =>
{
....
};
}
if (logo != null && mod.Icon == null) // <=
{
// Hide the logo and center just the text
if (title != null)
title.Bounds.X = logo.Bounds.Left;
if (version != null)
version.Bounds.X = logo.Bounds.X;
width -= logo.Bounds.Width;
}
else
{
// Add an equal logo margin on the right of the text
width += logo.Bounds.Width; // <=
}
....
}
```
**Предупреждение анализатора**: [V3125](https://www.viva64.com/ru/w/v3125/) The 'logo' object was used after it was verified against null. Check lines: 236, 222. ConnectionLogic.cs 236
На что тут стоит обратить внимание? Ну, для начала, в *logo* наверняка может быть записан *null*. На это намекают и постоянные проверки, и название метода *GetOrNull*, который возвращает значение, записываемое в *logo*. Раз так, давайте подумаем, что же произойдёт, если *GetOrNull* и правда вернёт *null*. Поначалу всё в порядке, но затем происходит проверка условия *logo != null && mod.Icon == null*. Как вы понимаете, в результате будет произведён переход к *else*-ветке и… Попытка обращения к свойству *Bounds* переменной, в которую записан *null*, а затем — бдыщ! *NullReferenceException* стучится в дверь.
### 3 место – Элемент Шрёдингера
Наконец, мы подошли к тройке финалистов. Топ-3 ошибка за 2020 год обнаружилась в проекте Nethermind, о проверке которого была написана статья с интригующим названием "[Код в одну строку или проверка Nethermind с помощью PVS-Studio C# для Linux](https://www.viva64.com/ru/b/0737/)". Ошибка невероятно проста, но при этом незаметна для человеческого глаза, особенно если учесть размеры проекта. Как вы считаете, достойно ли своего места это срабатывание?
```
public ReceiptsMessage Deserialize(byte[] bytes)
{
if (bytes.Length == 0 && bytes[0] == Rlp.OfEmptySequence[0])
return new ReceiptsMessage(null);
....
}
```
**Предупреждение анализатора**: [V3106](https://www.viva64.com/ru/w/v3106/) Possibly index is out of bound. The '0' index is pointing beyond 'bytes' bound. Nethermind.Network ReceiptsMessageSerializer.cs 50
Наверное, иметь возможность взять первую вещь, лежащую в пустой коробке, было бы круто, но здесь такое желание приведёт лишь к выбрасыванию *IndexOutOfRangeException*. Всего одна мелочь – крошечная ошибка в операторе, а приложение уже работает неправильно, а может и вовсе падает.
Очевидно, вместо '&&' тут стоит использовать '||'. Подобные логические ошибки – не редкость, особенно в сложных конструкциях. Поэтому проверять такие моменты в автоматическом режиме достаточно удобно.
### 2 место – Меньше 2, но больше 3
На втором место я поставил ещё одно срабатывание на код из проекта RavenDB. Напомню, что о результатах его проверки (и не только) можно почитать в соответствующей [статье](https://www.viva64.com/ru/b/0740/).
Ну а теперь встречайте — топ-2 ошибка 2020 года:
```
private OrderByField ExtractOrderByFromMethod(....)
{
....
if (me.Arguments.Count < 2 && me.Arguments.Count > 3)
throw new InvalidQueryException(....);
....
}
```
**Предупреждение анализатора**: [V3022](https://www.viva64.com/ru/w/v3022/) Expression 'me.Arguments.Count < 2 && me.Arguments.Count > 3' is always false. Probably the '||' operator should be used here. QueryMetadata.cs(861) Raven.Server
Ранее мы рассматривали моменты, в которых выбрасывалось неожиданное исключение, а теперь наоборот – ожидаемое исключение не будет выброшено никогда. Ну или всё-таки будет выброшено, если кто-нибудь придумает число, которое будет меньше 2, но при этом больше 3.
Не удивлюсь, если вы не согласитесь, но это срабатывание действительно нравится мне больше всех предыдущих. Да, ошибка невероятно простая, а для её исправления нужно лишь поменять оператор. На это, кстати, намекает и сообщение, передаваемое в конструктор *InvalidQueryException*: "Invalid ORDER BY 'spatial.distance(from, to, roundFactor)' call, expected 2-3 arguments, got " + *me.Arguments.Count*.
Соглашусь, это элементарная оплошность, но её никто не заметил и не поправил, как минимум, до тех пор, пока она не была найдена с помощью PVS-Studio. Это напоминает мне о том, что программисты, сколь бы опытны они ни были, всё равно остаются (к сожалению?) людьми. А люди, независимо от квалификации, могут пропустить даже такие глупые ошибки по самым разным причинам. Иногда ошибка выстреливает сразу, а иногда можно долго-долго гадать, почему же пользователь не видит сообщение о некорректном вызове ORDER BY.
### 1 место – Кавычки на +100% к безопасности кода
Ура, ура, ура! Мы наконец-то добрались до срабатывания, которое я посчитал самым интересным, забавным, классным и так далее. Оно было выдано на код из проекта ONLYOFFICE, с анализом которого связана одна из самых последних статей этого года – "[ONLYOFFICE Community Server: как баги способствуют возникновению проблем с безопасностью](https://www.viva64.com/ru/b/0783/)".
Ну что ж, представляю вам самую грустную историю про *ArgumentException*, который никогда не будет создан:
```
public void SetCredentials(string userName, string password, string domain)
{
if (string.IsNullOrEmpty(userName))
{
throw new ArgumentException("Empty user name.", "userName");
}
if (string.IsNullOrEmpty("password"))
{
throw new ArgumentException("Empty password.", "password");
}
CredentialsUserName = userName;
CredentialsUserPassword = password;
CredentialsDomain = domain;
}
```
**Предупреждение анализатора**: [V3022](https://www.viva64.com/ru/w/v3022/) Expression 'string.IsNullOrEmpty("password")' is always false. SmtpSettings.cs 104
Было очень сложно выбрать, какую ошибку на какое место поставить, но это срабатывание для меня с самого начала было лидером среди всех. Простейшая мелкая опечатка – и код уже работает неправильно. Не спасла ни подцветка в IDE, ни ревью, ни старый добрый здравый смысл. Это ведь маленькая, простая, красиво написанная функция. И даже здесь PVS-Studio смог найти то, что было пропущено профессионалами.
Как обычно, дьявол кроется в деталях. Разве бы не было здорово, если бы все такие детали искались автоматически? Конечно, было бы! А разработчик пусть занимается тем, чем статический анализатор заниматься не может – создаёт новые прекрасные и безопасные приложения. Творит, не думая о том, поставил он лишние кавычки при проверке переменной или нет.
Заключение
----------
Найти 10 интересных ошибок в статьях 2020 года было несложно. А вот распределить их по местам оказалось той ещё задачкой. С одной стороны, некоторые срабатывания лучше отражают работу продвинутых механизмов анализатора. С другой – какие-то из ошибок просто кажутся в некоторой мере забавными. Многие из представленных позиций можно было бы поменять местами – например, топ-2 и топ-3.
А может, вы считаете, что в этом списке вообще должны быть какие-то другие срабатывания? На самом деле, у вас есть возможность даже составить собственный топ, перейдя по [ссылке](https://www.viva64.com/ru/tags/?page=1&q=CSharp) к списку статей и отыскав там самые вкусные по вашему мнению срабатывания. В таком случае, обязательно скидывайте свои топы 2020 в комментарии, я с большим удовольствием почитаю. Сможете ли вы составить список интереснее моего?
Конечно, вопрос 'интересности' предупреждений в любом случае субъективен. На мой взгляд, главный критерий оценки срабатывания состоит в том, будет ли программист, увидевший предупреждение от PVS-Studio, менять что-то в соответствующем коде? Данный список как раз и был собран из срабатываний на фрагменты, которые, на мой взгляд, выглядели бы лучше, если бы разработчики использовали статический анализ. К тому же, нет никаких проблем с тем, чтобы попробовать PVS-Studio, проверив собственные или какие-то другие проекты. Достаточно лишь перейти по [ссылке](https://www.viva64.com/ru/pvs-studio-download/), скачать там нужную версию анализатора и запросить триальный ключ, заполнив маленькую форму.
Ну а на этом у меня всё, большое спасибо за внимание и до новых встреч!
[](https://habr.com/en/company/pvs-studio/blog/534832/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Nikita Lipilin. [Top-10 Bugs Found in C# Projects in 2020](https://habr.com/en/company/pvs-studio/blog/534832/). | https://habr.com/ru/post/534834/ | null | ru | null |
# Фильтрация изображения на FPGA
Данная статья является продолжением моей предыдущей [статьи о детектировании движения на ПЛИС](https://habrahabr.ru/post/323258/). В ней я хочу рассмотреть реализацию трёх алгоритмов фильтрации изображения, один из которых является наиболее важным при разработке детектора движения.
Необходимость применять фильтрацию вызвана шумами, присутствующими в кадре. Эти шумы имеют разную природу: одни вносит сама камера, другие вносят алгоритмы преобразования, третьи вносит окружающая среда, но все они создают нам препоны для детектирования объектов.
В данном проекте я столкнулся с шумами, которые вносит камера и алгоритмы бинаризации изображения (Background subtraction и Frame difference). Эти шумы проявляют себя в виде отдельных точек или их скопления как локально, так и по всему кадру. В зависимости от применяемого алгоритма обнаружения, они могут быть проигнорированы или приняты за объект.
Во избежание такого ложного обнаружения или сведения его вероятности к минимуму, мы и будем применять фильтрацию.
#### Медианный фильтр
Медианный фильтр, на мой взгляд, является наиболее значимым для подавления помех, с которыми мне пришлось столкнуться при разработке этого проекта. Он, как раз, подходит для устранения всякого рода мелких рассредоточенных вкраплений, однако он не является идеальным инструментом т.к. пропускает чуть более крупные области сосредоточенных помех.
Медианный фильтр представляет собой скользящие окно, в нашем случае, размерностью 3x3 пикселя. На вход он принимает 9 значений (пикселей), а на выход выдаёт одно. Работает медианный фильтр так: сортирует входные данные (пиксели) в порядке возрастания и выдаёт серединный результат (медиану).
Данный алгоритм довольно просто реализуется на языке Си, но для ПЛИС его реализация несколько отличается. Функциональная классическая схема фильтра показана на рисунке ниже. Она состоит из 19-ти базовых элементов.
Каждый базовый элемент (узел) представляет собой компаратор и мультиплексор.
На языке Verilog это выглядит так:
**Median filter node**
```
module median_node
#(
parameter DATA_WIDTH = 8,
parameter LOW_MUX = 1, // disable low output
parameter HI_MUX = 1 // disable high output
)(
input wire [DATA_WIDTH-1:0] data_a,
input wire [DATA_WIDTH-1:0] data_b,
output reg [DATA_WIDTH-1:0] data_hi,
output reg [DATA_WIDTH-1:0] data_lo
);
wire sel0;
alt_compare cmp(
.dataa(data_a),
.datab(data_b),
.agb(sel0),
.alb()
);
always @(*)
begin : mux_lo_hi
case (sel0)
1'b0 :
begin
if(LOW_MUX == 1)
data_lo = data_a;
if(HI_MUX == 1)
data_hi = data_b;
end
1'b1 :
begin
if(LOW_MUX == 1)
data_lo = data_b;
if(HI_MUX == 1)
data_hi = data_a;
end
default :
begin
data_lo = {DATA_WIDTH{1'b0}};
data_hi = {DATA_WIDTH{1'b0}};
end
endcase
end
endmodule
```
В качестве компаратора используется мегафункция **alt\_compare**. Далее все узлы соединяются согласно схеме. Симуляция работы фильтра в ModelSim выглядит так:
Красный прямоугольник — входные данные, жёлтый — выход фильтра. Выходной сигнал задержан на 1 такт т.к. Фильтр имеет синхронный регистровый выход.
Итак, с медианным фильтром всё понятно, осталось разобраться с окном 3x3.
#### Скользящее окно 3x3
Вот так оно выглядет в действии. Я себе это представляю не как окно скользит по картинке, а как картинка проходит сквозь статичное окно ), но сути это не меняет.
В ПЛИС окно делается не сложно, но требует 2 элемента FIFO размером в одну строку, в нашем случае 320 элементов. Выглядит это так:
Нижний **Line buffer** — это строка 1, верхний **Line buffer** — строка 2, а данные строки 3 берутся прямо из потока когда оба FIFO заполнены по 320, в нашем случае, элементов.
На языке Verilog это сделано так:
**Line buffer**
```
wire [7:0] line3_data = data_in;
wire line2_empty;
wire line2_wr_rq = (data_in_en && !line2_data_ready);
wire line2_data_valid = !line2_empty;
wire line2_data_ready;
wire [7:0] line2_data;
wire [7:0] median_out_t, sobel_out_t, gaus_out_t;
reg [7:0] filter_out_r = 0;
// row 3 FIFO
alt_fifo_512x8 LINE2_FIFO (
.aclr(),
.clock(clk),
.data(line3_data),
.rdreq(line1_wr_rq),
.wrreq(line2_wr_rq),
.almost_full(line2_data_ready),
.empty(line2_empty),
.full(),
.q(line2_data),
.usedw()
);
wire line1_wr_rq = (line2_data_valid && !line1_data_ready);
wire line1_data_ready;
wire [7:0] line1_data;
// row 2 FIFO
alt_fifo_512x8 LINE1_FIFO (
.aclr(),
.clock(clk),
.data(line2_data),
.rdreq(line1_rd_rq),
.wrreq(line1_wr_rq),
.almost_full(line1_data_ready),
.empty(),
.full(),
.q(line1_data),
.usedw()
);
// median filter top
median_top
#(
.DATA_WIDTH(8)
) median_top (
.clk(clk),
.a0(a0),
.b0(b0),
.c0(c0),
.a1(a1),
.b1(b1),
.c1(c1),
.a2(a2),
.b2(b2),
.c2(c2),
.median(median_out_t)
);
```
#### Детектор Собеля
Детектор собеля представляет собой оператор, вычисляющий приблизительный градиент яркости. Как и медианный фильтр, детектор Собеля — это оконная, в нашем случае 3x3, функция с 9-ю входами и одним выходом. В классическом исполнении выходом данной функции является квадратный корень из суммы квадратов градиентов по осям X и Y. Результат работы детектора выглядит как белые контуры контрастных объектов на черном фоне.
Матрица коэффициентов фильтра:
Градиент вычисляется методом свёртки значений пикселей с коэффициентами матрицы фильтра по формуле:
Как и в случае с медианным фильтром, нам нужно использовать формирование окна 3x3 пикселя для работы с этим фильтром:
**Shift register** 1, 2 и 3 на функциональной схеме это запайплайненные входные данные из FIFO, на Verilog выглядит так:
```
reg [7:0] a0,b0,c0,a1,b1,c1,a2,b2,c2;
always @(posedge clk or negedge nRst)
if (!nRst) begin
a0 <= 8'd0; b0 <= 8'd0; c0 <= 8'd0;
a1 <= 8'd0; b1 <= 8'd0; c1 <= 8'd0;
a2 <= 8'd0; b2 <= 8'd0; c2 <= 8'd0;
end else begin
a0 <= line1_data;
b0 <= line2_data;
c0 <= line3_data;
//pipeline step 1
a1 <= a0;
b1 <= b0;
c1 <= c0;
//pipeline step 2
a2 <= a1;
b2 <= b1;
c2 <= c1;
end
```
Код самого детектора очень прост:
**Edge detector**
```
module sobel_detector (clk,z0,z1,z2,z3,z4,z5,z6,z7,z8,edge_out);
input clk;
input [7:0] z0,z1,z2,z3,z4,z5,z6,z7,z8;
output [7:0] edge_out;
reg signed [10:0] Gx;
reg signed [10:0] Gy;
reg signed [10:0] abs_Gx;
reg signed [10:0] abs_Gy;
reg [10:0] sum;
always @ (posedge clk) begin
//original
//Gx<=((z2-z0)+((z5-z3)<<1)+(z8-z6)); //masking in x direction
//Gy<=((z0-z6)+((z1-z7)<<1)+(z2-z8)); //masking in y direction
// modified
Gx <= (z4-z3);
Gy <= (z4-z1);
abs_Gx <= (Gx[10]?~Gx+1'b1:Gx);//if negative, then invert and add to make pos.
abs_Gy <= (Gy[10]?~Gy+1'b1:Gy);//if negative, then invert and add to make pos.
sum <= abs_Gx+abs_Gy;
end
//Apply Threshold
assign edge_out = (sum > 20) ? 8'hff : 8'h00;
endmodule
sobel_detector sobel (
.clk(clk),
.z0(a0),
.z1(a1),
.z2(a2),
.z3(b0),
.z4(b1),
.z5(b2),
.z6(c0),
.z7(c1),
.z8(c2),
.edge_out(sobel_out_t)
);
```
Однако, при тестировании этого детектора выяснилось, что очень много шума идёт на его выход, и вместо красивого белого контура на черном фоне мы видим белые пятна. С чем связан такой результат я не понял, применение разных пороговых значений классического детектора не дало желаемого результата.
Заниматься поисками причины такого поведения детектора я не стал, т.к. данный детектор не представляет для меня практического интереса, только познавательный. Вместо этого я модифицировал матрицу оператора Собеля и получил приемлемый результат.
Классическая матрица:
Модифицированная матрица:
#### Фильтр Гаусса
Фильтр Гаусса, как и медианный фильтр, используется для устранения шума в кадре, однако у него есть и побочный эффект — размытие изображения. В нашем проекте нет такого шума, который нужно удалять фильтром Гаусса, поэтому реализация данного фильтра имеет исключительно академический интерес.
Как и два ранее рассмотренных фильтра, оператор Гаусса тоже является оконной функцией 3x3.
Схематично его реализация выглядит так:
Код на языке Verilog:
**Gaussian filter**
```
module gaus_filter
#(
parameter DATA_IN_WIDTH = 8
)(
input wire [DATA_IN_WIDTH-1:0] d00_in,
input wire [DATA_IN_WIDTH-1:0] d01_in,
input wire [DATA_IN_WIDTH-1:0] d02_in,
input wire [DATA_IN_WIDTH-1:0] d10_in,
input wire [DATA_IN_WIDTH-1:0] d11_in,
input wire [DATA_IN_WIDTH-1:0] d12_in,
input wire [DATA_IN_WIDTH-1:0] d20_in,
input wire [DATA_IN_WIDTH-1:0] d21_in,
input wire [DATA_IN_WIDTH-1:0] d22_in,
output wire [DATA_IN_WIDTH-1:0] ftr_out,
);
wire [10:0] s1 = d00_in+(d01_in<<1)+d02_in+(d10_in<<1);
wire [10:0] s2 = (d11_in<<2)+(d12_in<<1)+d20_in+(d21_in<<1);
wire [11:0] s3 = s1+s2+d22_in;
assign ftr_out = s3>>4;
endmodule
gaus_filter
#(
.DATA_IN_WIDTH(8)
) gaus_filter_inst(
.d00_in (a0),
.d01_in (a1),
.d02_in (a2),
.d10_in (b0),
.d11_in (b1),
.d12_in (b2),
.d20_in (c0),
.d21_in (c1),
.d22_in (c2),
.ftr_out (gaus_out_t),
);
```
#### Входные значения фильтров
На вход медианного фильтра подаётся абсолютная разница кадров grayscale представления для его последующей фильтрации, в то время как на вход детектора Собеля и фильтра Гаусса подаётся само grayscale представление, а не его разница.
#### Выводы
Рассмотренные выше фильтры не были доведены до совершенства т.к. в этом не было нужды для данного проекта. При желании можно реализовать и использовать более сложные и ресурсоёмкие конструкции фильтров под конкретную задачу, а эта статья носит только ознакомительный характер.
Для дальнейшего развития этого проекта нам потребуется только медианный фильтр.
#### Демонстрация результата
На правой половине экрана попеременно отображаются разные режимы работы, обозначенные цветовыми маркерами (*квадрат в углу изображения*)
Черный — grayscale представление без фильтрации
Красный — разница кадров без фильтрации
Зелёный — разница кадров отфильтрованная медианным фильтром
Синий — детектор Собеля
Белый — фильтр Гаусса
Первый проход на видео — это работа алгоритма Frame difference. Фильтрация медианным фильтром не очень заметна на видео. Второй проход — Background subtraction. Здесь заметна разница между разницей без фильтрации и с фильтрацией — исчезли некоторые отдельные белые точки.
После фильтра Гаусса изображение сменяется на grayscale и становится заметна разница: с Гауссом изображение менее резкое чем просто grayscale.
#### Материалы
→ [Median filter FPGA implementation](http://halcyon.usc.edu/~pk/prasannawebsite/papers/2013/Sanny-reconfig2013.pdf)
→ [Sobel filter implementation](http://edge.kitiyo.com/2009/codes/sobel-core-verilog-module.html)
→ [Gaussian filter on FPGA](https://thesai.org/Downloads/Volume7No7/Paper_71-FPGA_implementation_of_filtered_image_using%202D.pdf) | https://habr.com/ru/post/324070/ | null | ru | null |
# Анализ производительности отдельных подсистем программы по Linux perf report
Обычно для подготовки отчета по профилированию на Linux я использовал только самые простые варианты запуска `perf report` (сами данные по производительности должны быть получены до запуска `perf report` командой `perf record`, вот [тут можно подробнее прочесть с примером](http://stackoverflow.com/questions/1777556/alternatives-to-gprof/10958510#10958510)):
Отчет по модулям:
```
$ perf report --stdio --kallsyms=/boot/System.map-$(uname -r) --sort=dso -g none
```
Отчет по функциям:
```
perf report -g none --stdio --kallsyms=/boot/System.map-$(uname -r)
```
Отчет по функциям с построением callgraph:
```
perf report --stdio --kallsyms=/boot/System.map-$(uname -r) -g
```
Для многих ситуаций таких отчетов было вполне достаточно, чтобы найти проблемы с производительностью. Однако некоторое время назад я столкнулся с ситуацией когда отчет по callgraph показывал очень большое дерево вызовов и его было затруднительно понимать.
Для лучшего понимания отчета по производительности хотелось разбить его на отдельные отчеты, которые бы точно соответствовали подсистемам программы:
1. Подсистема получения сообщения, основная функция: `amqp_service::on_message()`
2. Подсистема обработки сообщения, основная функция: `input_handler::execute()`
3. Подсистема рассылки нотификаций, основная функция: `event_handler::on_msg()`
Оказалось, что у Linux perf есть ключ, который позволяет выбрать только события относящиеся к одной функции в стеке вызовов:
```
-p, --parent=
A regex filter to identify parent. The parent is a caller of this function and searched through the callchain,
thus it requires callchain information recorded. The pattern is in the exteneded regex format and
defaults to "^sys\_|^do\_page\_fault"
```
Этот ключ позволил мне проанализировать производительность отдельно для каждой важной мне функции. Предварительно надо сказать, что по отчету общее количество событий в perf.dat было такое:
```
# Event count (approx.): 72784958041
```
#### Анализ amqp\_service::on\_message()
Построение отчета по amqp\_service::on\_message():
```
$ perf report -x --stdio --kallsyms=/boot/System.map-$(uname -r) \
-g -p "amqp_service::on_message"
```
Количество событий с таким фильтром
```
# Event count (approx.): 1590851860
```
Получается, что 1590851860 событий — это примерно 2% от общего числа событий 72784958041. То есть эта функция не генерировала много событий даже под большой нагрузкой. На всякий случай я смотрю какие функции были в топе, когда работала `amqp_service::on_message()` и нет ли в топе `pthread_mutex_lock()/pthread_mutex_unlock()`:
```
$ perf report -x --stdio --kallsyms=/boot/System.map-$(uname -r) \
-g -p "amqp_service::on_message" | \
grep -E -e "^[ ]+[0-9]" | sed -re 's/[ ]+data_provider::.*+$//' | head
29.38% data_provider [kernel.kallsyms] [k] clear_page_c
11.09% data_provider libc-2.12.so [.] memcpy
6.01% data_provider [kernel.kallsyms] [k] __alloc_pages_nodemask
5.27% data_provider [kernel.kallsyms] [k] compact_zone
4.44% data_provider [kernel.kallsyms] [k] page_fault
4.08% data_provider [kernel.kallsyms] [k] get_pageblock_flags_group
4.05% data_provider [kernel.kallsyms] [k] __reset_isolation_suitable
3.55% data_provider [kernel.kallsyms] [k] compaction_alloc
1.78% data_provider libpthread-2.12.so [.] pthread_mutex_lock
1.61% data_provider [kernel.kallsyms] [k] __mem_cgroup_commit_charge
```
По этим данным и по полному отчету с callgraph для `amqp_service::on_message()` я вижу, что под нагрузкой функция в основном тратит время на копирование сообщений. Блокирование на мьютеках в этой функции не является проблемой, всего 1,8% под нагрузкой, большого contention на мьютеках в этой функции и в функциях вызываемых из нее по отчету нет.
#### Анализ функции input\_handler::execute().
Построение отчета по этой отдельной функции:
```
$ perf report -x --stdio --kallsyms=/boot/System.map-$(uname -r) \
-g -p "input_handler::execute"
```
Количество событий с таким фильтром:
```
# Event count (approx.): 16423187486
```
Получается, что 16423187486 событий — это 22% от общего числа событий 72784958041. Это уже большое количество работы относительно общего количества событий perf и тут я смотрел более внимательно на то, где алгоритм проводит время.
```
$ perf report -x --stdio --kallsyms=/boot/System.map-$(uname -r) \
-g -p "input_handler::execute" | \
grep -E -e "^[ ]+[0-9]" | sed -re 's/[ ]+data_provider::.*+$//' | head
7.31% data_provider data_provider.005.00 [.] dtl::basic_string_ref >::empty() const
7.19% data\_provider data\_provider.005.00 [.] dtl::string\_parser::fail() const
4.95% data\_provider data\_provider.005.00 [.] dtl::string\_parser::eof() const
4.87% data\_provider data\_provider.005.00 [.] dtl::string\_parser::peek() const
3.46% data\_provider data\_provider.005.00 [.] meta::json::decoder::parse\_value(dtl::basic\_string\_ref >&)
3.08% data\_provider data\_provider.005.00 [.] dtl::basic\_string\_ref >::operator[](unsigned long) const
2.53% data\_provider data\_provider.005.00 [.] dtl::basic\_string\_ref >::remove\_prefix(unsigned long)
2.30% data\_provider data\_provider.005.00 [.] dtl::hash\_seq(unsigned char const\*, unsigned long)
2.21% data\_provider data\_provider.005.00 [.] bool dtl::strtou<(unsigned char)10, unsigned char>(dtl::basic\_string\_ref >&, unsigned char&)
```
Однако, судя по этим данным, функция выполняет большое количество декодирования, но проблем с масштабированием в коде нет — нет значительного количества вызовов pthread\_mutex\_lock(). То есть можно добавлять еще потоки для input\_handler::execute() и ожидать увеличения общей производительности.
#### Анализ функции event\_handler::on\_msg().
Я пропущу анализ количества событий и просто отмечу, что вызовы, сделанные из этой функции, больше все времени проводили в блокировании. Это возможно потребует исправления так как для масштабирования такое большое количество блокировов плохо.
```
$ perf report -x --stdio --kallsyms=/boot/System.map-$(uname -r) \
-g -p "event_handler::on_msg" | \
grep -E -e "^[ ]+[0-9]" | sed -re 's/[ ]+data_provider::.*+$//' | head
6.73% data_provider libpthread-2.12.so [.] pthread_mutex_lock
4.90% data_provider libpthread-2.12.so [.] pthread_mutex_unlock
4.45% data_provider data_provider.005.00 [.] std::__atomic_base::operator++()
3.84% data\_provider [kernel.kallsyms] [k] \_spin\_lock
3.54% data\_provider data\_provider.005.00 [.] std::\_\_atomic\_base::fetch\_add(unsigned long, std::memory\_order)
3.47% data\_provider data\_provider.005.00 [.] dtl::intrusive\_ptr::intrusive\_ptr(dtl::intrusive\_ptr const&)
2.92% data\_provider data\_provider.005.00 [.] (anonymous namespace)::page\_allocator\_base::allocate\_obj(dtl::page\_allocation\_info&)
2.70% data\_provider data\_provider.005.00 [.] std::char\_traits::length(char const\*)
2.18% data\_provider data\_provider.005.00 [.] dtl::string::size() const
1.96% data\_provider data\_provider.005.00 [.] dtl::string::create\_(dtl::basic\_string\_ref > const&)
```
В итоге, построение отчета с использованием ключа `--parent` помогло проанализировать производительность отдельных частей моей програмы. Однако из-за того, что используемая Lua библиотека, видимо, была собрана без `-fno-omit-frame-pointer`, часть функций, которые выполнялись в `input_handler::execute()` при анализе с `--parent` в отчет не попали, хотя они и есть в общем отчете. | https://habr.com/ru/post/305188/ | null | ru | null |
# ATtiny85: прототип беспроводного сенсора
Обычно, для перехода от идеи к реализации, необходим прототип устройства, удобный для проверки и отладки на месте, что особенно важно для мобильного устройства. Далее постараюсь максимально подробно разобрать процесс создания прототипа беспроводного сенсора на базе ATtiny85.
Цель — создать сенсор работающий, условно говоря, в коробке с искусственным освещением и передающий температуру и статус освещения с немедленной реакцией на изменение освещения: включилось, отключилось, мигнуло. Сенсор решено было сделать мобильным и питать от элемента CR2032, иначе говоря, при разряде до 2.7V (предел для датчика TMP36), можно рассчитывать на 200mAh.
Микроконтроллер ATtiny85 имеет всего 5 портов ввода/вывода и возможность отключить RESET в пользу дополнительного порта. Данный бюджет был распределён следующим образом:
* **3 порта** — радиомодуль NRF24L01+, спецификация требует пять портов, но в данном случае это не приемлемо и будет использована 3-х пиновая конфигурация;
* **1 порт** — датчик освещения на базе фототранзистора BPW17N;
* **2 порта** — температурный датчик на базе TMP36, второй порт нужен для подачи питания, чтобы иметь возможность отключать датчик при необходимости.
Элементная база определена, можно приступать к проектированию.
RESET в качестве порта ввода/вывода
-----------------------------------
Ситуация требует использовать RESET в качестве порта ввода/вывода. Однако RESET необходим для программирования микроконтроллера, в том числе и для прошивки настроек (Fuses). Соответственно, после отключения RESET программировать устройство будет не возможно. Таким образом, чтобы не получить «кирпич» первым делом необходимо раздобыть высоковольтный (12V) программатор, для сброса Fuse-ов.
Подходящую схему и скетч для Arduino можно найти по ссылке [ATTiny Fuse Reset with 12 Volt Charge Pump](https://sites.google.com/site/wayneholder/attiny-fuse-reset-with-12-volt-charge-pump). Данная схема не требует дополнительного питания, и для получения 12V используется умножитель (Charge Pump).
**Описание работы схемы высоковольтного программатора**Схема находится на сайте по ссылке, расположенной выше.
На вывод (4) подается питание 5V, при этом на выводе (2) устанавливается низкий уровень (земля), конденсатор **C1** заряжается до 5V. Затем на (2) подается 5V и на обкладках **С1** образуются 10V, они через диод **D2**, при низком уровне на (3), попадают на **C2**. Затем уровни на (3) и (2) меняются местами и уже 15V поступают на **C3**, следующая итерация сливает 20V (на самом деле ~17V) на **C4**. Затем напряжение через делитель **R2**/**R3** попадает на аналоговый вход **A0**, где сравнивается с опорным значением, и если напряжение выше 12V, то раскачка (смена уровней на (2) и (3)) выключается. Транзистор **Q1** нужен для быстрой разрядки конденсаторов и формирования необходимого импульса для программатора. Резисторы на выводах ATtiny85 необходимы для защиты микроконтроллера при неправильном подключении.
У меня получился следующий дизайн:
**Высоковольтный программатор в сборе (фото и комментарии)**
Неудобно, что USB разъём накрывает контактные пины, но дизайн платы таков, что здесь к микроконтроллеру сложно даже штатное питание подвести. Проще говоря, было место на плате, появилась идея добавить пины для подключения обычного программатора в следующей конфигурации:
Позже стало очевидно, что использовать схему в таком виде целесообразно только в самом крайнем случае.
Принципиальная схема
--------------------
Разработка схемы вместе с макетной платой будет производится в [KiCad EDA](http://kicad-pcb.org/), это свободный пакет для автоматизации разработки электронных схем.
Исходные файлы KiCad проекта размещены на [GitHub](https://github.com/alexcustos/attwlight-sensor), в папке **attwlight\_sensor.pcb**.
Существует множество хороших инструкций по работе с данным редактором, например стоит посмотреть ролик на YouTube [KiCAD Quick-Start Tutorial](https://www.youtube.com/watch?v=zK3rDhJqMu0).
Если совсем кратко, то для начала работы над схемой в KiCad достаточно запустить редактор схемы  и справа пройтись по иконкам, чтобы добавить: элементы , питание , провода  и метки .
Метки нужны, чтобы не загромождать схему проводами. При разводке печатной платы все одинаковые метки необходимо будет соединить дорожками.
Если в доступных библиотеках нет необходимого элемента его можно создать с нуля либо изменить один из существующих. В последнем случае достаточно поставить курсор на нужный элемент и нажать Ctrl+E (редактировать элемент в редакторе) и в новом окне: создать элемент из текущего , отредактировать его внешний вид и свойства , затем сохранить в новую библиотеку .
Чтобы созданную библиотеку можно было использовать, её необходимо подключить в **Preferences → Component Libraries**, воспользовавшись кнопкой **Add** в верхней части. Для добавления в библиотеку других элементов, её нужно выбрать  и после добавления сохранить .
Итоговая схема:
По сути, устройство состоит из трех независимых частей. Проверив их по отдельности вполне можно ожидать, что в сборе всё заработает как было задумано. Прототип как раз и нужен, чтобы проверить насколько данное ожидание соответствует действительности. Ниже, в комментариях к схеме, я остановлюсь на том, что пошло не так.
### Датчик температуры TMP36
В рабочем режиме питание на датчик подается с порта PB5 микроконтроллера. В отладочной конфигурации подать питание на датчик можно установив перемычку между выводами VCC и D10 контактной площадки P2. Сигнал RESET активен при низком уровне и высокий уровень не мешает работе микроконтроллера и даже увеличивает стабильность по сравнению с висящим в воздухе RESET. Для съема данных с датчика используется аналоговый порт ADC2.
Засада ждала в виде ёмкости C1, которая была подключена непосредственно к RESET микроконтроллера. Понятно, что емкость на RESET снижает время активности сигнала или даже блокирует его, мешая программированию устройства, поэтому до сборки был проведен эксперимент, но как оказалось не достаточно чистый. Дело в том, что если на работающую схему добавить данный конденсатор, то процесс проходит успешно ровно один раз, если включить схему с ним — то не разу. Пока дело дошло до конденсатора, была впаяна перемычка между D1 и SCK, очевидно, что эта часть схемы не мешает установке на SCK низкого уровня, но подозреваемых больше не было. После установки перемычки между C1 и землей, программировать устройство стало можно, но только с питанием 5V. Однако в инструкции указано 1.8-5.5V и эксперименты с этим микроконтроллером и питанием 3V были успешными. Оказалось что на питании TMP36 есть встроенная ёмкость 10nF и этого достаточно, чтобы блокировать процесс при низком напряжении. В результате перемычка встала на своё место.
### Радиомодуль NRF24L01+
Нумерация выводов у штыревых разъёмов в KiCad не соответствует принятой для данного модуля, поэтому нумерация здесь зеркальная относительно указанной в инструкции для NRF24L01+. Для работы радиомодуля в 3х пиновой конфигурации необходимо поменять местами выводы MISO и MOSI, и добавить часть схемы справа, состоящую из элементов: R3, D1 и C2. Схема данной конфигураци взята отсюда [nRF24L01+ with ATtiny85 3 Pins](https://www.hackster.io/arjun/nrf24l01-with-attiny85-3-pins-74a1f2).
Работа данной схема возможна по тому, что на CE (chip enable) можно сразу установить высокий уровень, а CSN (chip select) нужен только для передачи модулю сигнала о начале новой команды, что достигается сбросом высокого уровня в низкий. Соответственно, CSN можно объединить с одним из оставшихся выводов, в данном случае SCK (clock). Штатные импульсы SCK не успевают зарядить конденсатор C2 и на CSN остается низкий уровень, перед началом передачи команды нужно установить на SCK высокий уровень на более длительное время, чтобы получить высокий уровень на CSN. С чем связанна необходимость поменять местами MISO и MOSI я не понял, видимо так было удобно.
Для стабильной работы модуля желательно наличие ёмкости 1-10μF на выводах питания модуля, для этих целей на схеме предусмотрен конденсатор C4.
После устранения проблем с датчиком температуры, первым делом была проверена возможность прошить ATtiny85 с установленным радиомодулем. Процесс не пошёл, avrdude ругнулся на не верную сигнатуру, но я проявил упорство и запустил прошивку… и в итоге тоже ошибка. В результате эксперимента радиомодуль не пострадал, правда и шансов что-то в него прошить не было из-за модификаций приведенных выше. А вот микроконтроллер пришлось реанимировать с помощью высоковольтного программатора. Идея оказалась неудачной, но попробовать стоило.
### Микроконтроллер ATtiny85
В процессе тестирования микроконтроллер успешно работал от внутреннего осциллятора без делителя на частоте 8MHz, однако с непосредственно подключенным радиомодулем его работа стала не стабильной. В том смысле, что если соединить радиомодуль с разъёмом проводами длиной 30cm, всё работает нормально, а с модулем, установленным в разъем, что-либо отправить невозможно. Все попытки стабилизировать систему дополнительными конденсаторами, ровно как и сделать её нестабильной, разместив вынесенный радиомодуль вплотную к микроконтроллеру, ни к чему не привели. В результате пришлось включить делитель, что вернуло микроконтроллер к заводским настройкам. Работа ATtiny85 на частоте 1MHz каких либо сложностей не вызвала, но заметно сократила ожидаемое время работы от батареи. Подробнее об этом в конце статьи.
### Датчик освещения на BPW17N
С этим датчиком всё относительно просто, на него попадает только искусственное освещение, а регистрировать он должен только моменты его включения и отключения. Для максимально быстрой реакции на событие датчик генерирует прерывание на порту PCINT3 (Pin Change Interrupt).
Элементы R1 и C3 подстроечные, для них предусмотрено место на плате, но они не распаяны. С3 параллельно с фототранзистором Q1 может понадобиться, чтобы исключить дребезг сигнала. Проблема в том, что стандартный для таких случаев конденсатор 0.1μF, разряжается через резистор 10MΩ около секунды, что не приемлемо для регистрации события — свет мигнул. Соответственно, можно установить конденсатор меньшей ёмкости и/или уменьшить сопротивление резистора R2, но сначала нужно проверить, есть ли в этом смысл.
Поскольку здесь используется прерывание может показаться, что в схеме нужен компаратор, но эти мысли сразу отпадают, как только становится понятно сколько эта штука потребляет. Правда и потребление микроконтроллера, при уровне сигнала вблизи центра рабочего диапазона, подскакивает с 7μA примерно до 260μA в режиме сна. Однако данную проблему проще решить программно, а именно, после срабатывания прерывания (PCINT3 или WDT), можно проверить напряжение на аналоговом входе ADC3, если оно неприемлемо, сообщить о проблеме и пропустить активацию PCINT3. В любом случае это нештатная ситуация, которая требует внимания.
Макетная плата
--------------
Готовую схему необходимо развести на плате. Это также можно сделать в KiCad. Для этого сначала требуется завершить работу со схемой:
1. Промаркировать элементы на схеме , все настройки можно оставить по умолчанию.
2. Сопоставить элементы схемы с посадочными местами на плате . Появится следующее окно:
Здесь для наглядности следует включить просмотр выбранного элемента .
Поскольку предстоит работать с макетной платой необходимо следить, чтобы все посадочные места укладывались в сетку 1/10" (2.54mm). Если требуемый элемент найти не удаётся, проще назначить похожий, затем, в редакторе печатной платы, изменить его (Ctrl+E) и записать в свою библиотеку.
Как только все посадочные места будут назначены нужно сохранить результат и вернуться в редактор схемы.
3. Сгенерировать netlist , настройки по умолчанию вполне приемлемы.
Редактор схемы можно закрыть и перейти к редактору печатной платы . Здесь нажать , затем загрузить ранее созданный netlist (Read Current Netlist), убедиться, что не было ошибок и закрыть окно. Если схема была изменена или элементам были назначены другие посадочные места, необходимо обновить netlist и загрузить его здесь снова.
При первой загрузке netlist все посадочные места окажутся стопкой в одной куче. Сначала необходимо переключить сетку на 1/10" (2.54mm), растащить элементы (используя кнопку m), убрать лишние надписи **Visibles → Render → Values** и, пользуясь подсказками редактора, соединить элементы дорожками.
Результат будет выглядеть примерно так:
Оставшиеся белые линии, указывают какие посадочные места необходимо соединить проводами. К сожалению в KiCad нет способа вывести результат, так чтобы его было удобно воспроизвести на макетной плате. Но в данном случае макетная плата получилась не большой, и с ней можно поступить просто: отключить лишние надписи **Visibles → Render → Footprints Front**, снять скриншот и зеркально отразить его по вертикали.
Готовый макет:
Тут два несоответствия со схемой выше: не распаяны подстроечные элементы R1,C3 и диод короче на одно отверстие.
Плата немного побита жёсткой отладкой, но на то она и макетная. Большинство других вариантов, после всех модификаций, выглядело бы хуже.
Подготовка IDE и программатора
------------------------------
Arduino IDE наиболее доступное кроссплатформенное программное обеспечение для программирования AVR микроконтроллеров и вполне удобное для небольших проектов.
Не смотря на то, что Arduino IDE официально не поддерживает ATtiny85, существует штатный способ добавить данный микроконтроллер в список поддерживаемых. Как это сделать, подробно описано по ссылке [Programming an ATtiny w/ Arduino 1.6](http://highlowtech.org/?p=1695). Однако данный способ годится только для непосредственного программирования ATtiny85 и не позволяет использовать Arduino код. С одной стороны это хорошо, код чище будет, но задача в данном случае — разработать скетч демонстрирующий способность устройства функционировать как было задумано, и такая оптимизация здесь преждевременна.
Значит нужно Arduino ядро для ATtiny85, его можно взять здесь [arduino-tiny](https://code.google.com/p/arduino-tiny/), версия для Arduino 1.5 подойдет. Доступны будут не все функции, но базовый набор, включая программный последовательный порт, для отладки, можно будет использовать. К сожалению в актуальной, на данный момент, Arduino IDE v1.6.6 что-то сломали, и c этим ядром необходимо использовать версию 1.6.5.
**Подключение ядра к Arduino IDE v1.6.5**1. В директории с Arduino скетчами нужно создать папку hardware;
2. Скачать в эту папку файл [arduino-tiny-0150-0020.zip](https://arduino-tiny.googlecode.com/files/arduino-tiny-0150-0020.zip) и распаковать его;
3. Скопировать файл «Prospective Boards.txt» в boards.txt в той же директории, и зачистить последний от ненужных конфигураций, в данном случае всё что не ATtiny85, чтобы не мешались;
4. Теперь если запустить или перезапустить Arudino IDE в меню **Tools → Board** в самом низу списка появятся добавленные конфигурации.
Осталось приготовить программатор. Для этого совсем не обязательно использовать специальное устройство, можно в ближайшую Arduino прошить скетч из **File → Examples → ArduinoISP**, затем соединить с сенсором, как указанно на принципиальной схеме, и не забыть про конденсатор 10μF, который необходимо установить между RST и GND выводами Arduino.
Программировать устройство нужно без установленных радиомодуля и перемычек. В меню **Tools → Board** нужно выбрать конфигурацию микроконтроллера, в данном случае: ATtiny85 @ 1 MHz (internal oscillator; BOD disabled), в меню **Tools → Port** выбрать USB порт программатора и в меню **Tools → Programmer** указать тип программатора, в данном случае: Arduino as ISP, затем воспользоваться кнопкой Upload.
Программное обеспечение
-----------------------
Тестовый скетч для работы с сенсором получился довольно интересным, в нем можно найти широкий набор примеров, а именно:
* Работа с радиомодулем NRF24L01+;
* Измерение напряжения питания средствами микроконтроллера;
* Перевод микроконтроллера в режим сна;
* Пробуждение по таймеру WDT (WatchDog Timer);
* Пробуждение по Pin Change прерыванию PCINT;
* Работа с аналоговыми и цифровыми портами.
Чтобы скомпилировать скетч необходимы сторонние библиотеки:
* [TMRh20/RF24](https://github.com/TMRh20/RF24)
* [TMRh20/RF24Network](https://github.com/TMRh20/RF24Network)
Это оптимизированные версии библиотек для работы с радиомодулем NRF24L01+, которые подходят для микроконтроллера ATtiny85. Их необходимо скачать и распаковать в папку libraries в директории со скетчами Arduino.
Ниже будут приведены наиболее интересные куски кода с подробными комментариями. Полностью скетч можно найти на [GitHub](https://github.com/alexcustos/attwlight-sensor) в папке **attwlight\_sensor**, также в папке **attwlight\_rx** находится скетч для приёмника.
### Перевод микроконтроллера в режим сна
Функция void sleep() вызывается в главном цикле void loop() и останавливает его до тех пор пока не сработает одно из прерываний PCINIT3 либо WDT. Затем выполняется полезная работа и снова вызывается данная функция.
Функция содержит обращения к регистрам микроконтроллера, и что при этом происходит не всегда очевидно. Чтобы с этим разобраться нужно заглянуть в документацию на микроконтроллер [ATtiny85 datasheet](http://www.atmel.com/images/atmel-2586-avr-8-bit-microcontroller-attiny25-attiny45-attiny85_datasheet.pdf) раздел «23. Register Summary», в нем приведен полный список регистров с прямой ссылкой на страницу с подробным описанием для чего предназначен тот или иной бит.
```
#include
#include
#include
#define WDTO\_INFINITE 255
#define SLEEP\_PERIOD WDTO\_8S
#define SKIP\_WDT\_WAKEUPS 14 // x SLEEP\_PERIOD + SLEEP\_PERIOD (14 ~= 120 sec)
// Вектор (функция) прерывания PCINT, у ATtiny85 один порт (B), следовательно только один вектор PCINT
ISR(PCINT0\_vect)
{
light\_pcint = true;
}
// Вектор прерывания таймера WDT
ISR(WDT\_vect)
{
wakeup\_counter++;
}
void sleep()
{
GIMSK = \_BV(PCIE); // Включить Pin Change прерывания
if (SLEEP\_PERIOD == WDTO\_INFINITE || payload.light != LIGHT\_FUZZY)
PCMSK |= \_BV(LIGHT\_PIN); // PCINT3; включить если нет проблем с освещением или иначе нет шансов проснуться
ADCSRA &= ~\_BV(ADEN); // отключить ADC; уменьшает энергопотребление
if (SLEEP\_PERIOD != WDTO\_INFINITE) {
wdt\_enable(SLEEP\_PERIOD); // установить таймер
WDTCR |= \_BV(WDIE); // включить прерывания от таймера; фикс для ATtiny85
}
// Установить режим сна Power-down; MCUSR &= ~\_BV(SM0); MCUSR |= \_BV(SM1);
set\_sleep\_mode(SLEEP\_MODE\_PWR\_DOWN);
sleep\_enable(); // разрешить режим сна; MCUSR |= \_BV(SE);
sei(); // включить прерывания
sleep\_cpu(); // заснуть
cli(); // отключить прерывания; для безопасного отключения PCINT3
PCMSK &= ~\_BV(LIGHT\_PIN); // PCINT3; отключить
sleep\_disable(); // запретить режим сна; MCUSR &= ~\_BV(SE);
ADCSRA |= \_BV(ADEN); // включить ADC
sei(); // включить прерывания; иначе таймеры не будут работать
}
```
### Опрос датчика освещения
Особенности работы с данным датчиком уже были разобраны в разделе «Принципиальная схема». Отмечу только, что параметры здесь выбраны так, чтобы потребление микроконтроллера в режиме сна не превышало 20μA.
```
#define FUZZY_VOLTAGE 0.4 // ширина зоны неприемлемого напряжения в середине, включая концы
const unsigned int fuzzy_start = int(1024.0 * (1.0 - FUZZY_VOLTAGE) / 2.0);
const unsigned int fuzzy_stop = 1023 - fuzzy_start;
light_t readLightStatus(unsigned int ms)
{
delay(ms); // если нужно время на стабилизацию
int input = analogRead(LIGHT_PIN); // ADC3
// оценка надёжности результата
if (input >= fuzzy_start && input <= fuzzy_stop)
return LIGHT_FUZZY;
if (input < fuzzy_start)
return LIGHT_OFF;
if (input > fuzzy_stop)
return LIGHT_ON;
// заглушка; на случай ошибки в коде
return LIGHT_UNKNOWN;
}
```
### Измерение напряжения питания
Если не использовать вывод AREF микроконтроллера, который предназначен для задания опорного напряжения, все измерения на аналоговом порту будут привязаны к напряжению питания. Батарея не стабилизированный источник, следовательно для корректного считывания показаний датчика температуры, необходим способ измерять напряжение питания в процессе работы. Напряжение питания также является хорошим индикатором состояния батареи.
Ниже приведен код, который позволяет произвести требуемые измерения полагаясь на стабильность внутреннего опорного напряжения Vbg (Bandgap reference voltage) равного 1.1V. Согласно спецификации Vbg может находится в пределах 1.0-1.2V, поэтому необходимо убедиться в точности измерений и при необходимости скорректировать константу 1125300.
```
long readVcc()
{
// Установка референса в Vcc и измерение внутреннего Vbg == 1.1V
ADMUX = _BV(MUX3) | _BV(MUX2);
delay(2); // требуется минимум 1ms для стабилизации
ADCSRA |= _BV(ADSC); // ADC Start conversion - начать опрос
while (bit_is_set(ADCSRA, ADSC)); // ADSC == 1 пока опрос активен
// Чтение ADCL блокирует ADCH, чтение ADCH разблокирует оба регистра => ADCL читать первым
uint8_t low = ADCL; // младший регистр данных ADC
uint8_t high = ADCH; // старший регистр данных ADC
long result = (high << 8) | low;
result = 1125300L / result; // 1125300 = 1.1*1023*1000
return result; // Vcc в милливольтах
}
```
### Измерение температуры
Получив напряжение питания, легко вычислить точное напряжение на аналоговом входе микроконтроллера и перевести его в температуру.
```
float readTmp36(long vcc)
{
int input = analogRead(TMP36_PIN); // напряжение относительно refVolts
float refVolts = float(vcc) / 1000.0;
float voltage = float(input) * refVolts / 1024.0; // фактическое напряжение
float temperatureC = (voltage - 0.5) * 100.0; // смещение 500mV & 10mV == 1°C
return temperatureC;
}
```
Остальная часть скетча нужна, чтобы собрать данные вместе и отправить их наиболее оптимальным образом, с точки зрения энергопотребления. Ничего интересного там нет, обычная логика, надеюсь, комментариев в коде достаточно, чтобы разобраться как всё работает.
Если скомпилировать данный код, можно увидеть, что он свободно умещается в 8KiB и даже есть куда развернуться:
```
Sketch uses 7,120 bytes (86%) of program storage space. Maximum is 8,192 bytes.
Global variables use 227 bytes (44%) of dynamic memory, leaving 285 bytes for local variables. Maximum is 512 bytes.
```
Осталось проверить, что всё работает как было задумано, и можно прошивать Fuses переключающие RESET в порт ввода/вывода. Готовой конфигурации в Arduino IDE для этого нет, поэтому нужно воспользоваться командной строкой:
```
avrdude -c stk500v1 -p attiny85 -P /dev/ttyUSB0 -v -C /etc/avrdude.conf -b 19200 -U lfuse:w:0x62:m -U hfuse:w:0x5f:m -U efuse:w:0xff:m
```
* **avrdude** — команда из пакета Arduino IDE находящаяся в папке **hardware/tools/avr/bin/**;
* **/dev/ttyUSB0** — устройство программатора;
* **/etc/avrdude.conf** — ссылка на файл находящийся в директории с Arduino IDE по адресу **hardware/tools/avr/etc/avrdude.conf**.
Что из себя представляют данные Fuses, можно посмотреть в калькуляторе [Engbedded Atmel AVR® Fuse Calculator](http://www.engbedded.com/fusecalc/).
Если кратко, то эти настройки предписывают: использовать встроенный осциллятор с делителем частоты на 8 (итоговая частота 1MHz); использовать стандартные задержки при старте, необходимые для стабилизации осциллятора; отключить BOD (Brown-out Detector) — перезагрузка при низком напряжении питания для защиты памяти от записи мусора; включить возможность считывать прошивку; и собственно отключить RESET.
Энергопотребление
-----------------
Пришло время измерить энергопотребление получившегося устройства. Вводные следующие: данные передается каждые 120sec, если пришло прерывание от датчика освещения, то немедленно; событиями от датчика освещения можно пренебречь; ёмкость батареи 200mAh.
| | | |
| --- | --- | --- |
| **Частота** | 1MHz | 8MHz |
| **Радиомодуль** (потребление) | 15.7mA | 18.3mA |
| **Микроконтроллер** (потребление) | 1.1mA | 4.3mA |
| **Режим сна** (потребление) | 7μA | 7μA |
| **Радиомодуль** (активен за цикл) | 51ms | 16ms |
| **Микроконтроллер** (активен за цикл) | 15ms | 4ms |
| **Оценка времени работы** (дней) | 513 | 739 |
Как видно, тут было ради чего бороться. К сожалению, стабильности на 8MHz добиться не удалось. Видимо без внешнего осциллятора, это не реально.
Все исходные коды проекта доступны на [GitHub](https://github.com/alexcustos/attwlight-sensor) | https://habr.com/ru/post/388079/ | null | ru | null |
# Совершенно секретно или статичный IP на Windows Phone
Понадобилось мне недавно сделать статичным IP на своем Windows Phone.
Пошел я искать решение в гугл. Все, что я там нашел, было связано непосредственно с настройкой роутера или полностью рутованными телефонами (мой рут накрылся после обновления до Tango), поэтому данное решение мне также не подошло. И вот, в голову пришла гениальная идея — а что если ребята из Samsung уже потрудились, однако сообщить об этом забыли? Так неоднократно было с меню Diagnosis. Напомню, через дыру в него создавали полноценный рут, запускали exe файлы без подписей и многое-многое другое. В прошлом. Снова гуглим, но это ничего не дает — никто толком не знает рабочих кодов диагностики. Хорошо. Ищем xap меню диагностики. На удивление, нашел, т.к. обычно они внедрены глубоко в ядро. Ядро было написано на нативном коде, однако интерфейс — на C#. То, что нужно! Нашел, правда, в кэше китайского ресурса на последней странице, но не суть.
Что же, в путь! Открываем любимый [dotPeek](http://www.jetbrains.com/decompiler/) от JetBrains и видим следующую картину:
Те пункты, в которых деревья отказались открываться — это dll, содержащие нативный код. Их сразу отбросим.
Отбросим также и те, которые начинаются со слов Microsoft. Это лишь ссылки. Остался первый проект — DiagnosisApp.
Разворачиваем и смотрим пространства имен, корневую и главную:
В корневой видим, что тут постарался DotObfuscator, что сильно усложняет процесс: лишние goto, пустые условия, циклы, однобуквенные названия переменных…
В DiagnosisApp уже интереснее. Видим тут класс, отвечающий за сам код страницы. Вся логика, в лучших традициях быдлокода, лежит не в ViewModel, а прямо в классе. Без всяких там partial. В начале класса видим переменные типа Button. То, что нужно! Это ведь панель набора кода:
```
internal Button btnDelete;
internal Button btn1;
internal Button btn3;
internal Button btn2;
internal Button btn4;
internal Button btn5;
internal Button btn6;
internal Button btn7;
internal Button btn8;
internal Button btn9;
internal Button btnSharp;
internal Button btn0;
internal Button btnStar;
```
Ищем событие Click:
```
this.btn1.Click += new RoutedEventHandler(this.b);
this.btn2.Click += new RoutedEventHandler(this.b);
this.btn3.Click += new RoutedEventHandler(this.b);
this.btn4.Click += new RoutedEventHandler(this.b);
this.btn5.Click += new RoutedEventHandler(this.b);
this.btn6.Click += new RoutedEventHandler(this.b);
this.btn7.Click += new RoutedEventHandler(this.b);
this.btn8.Click += new RoutedEventHandler(this.b);
this.btn9.Click += new RoutedEventHandler(this.b);
this.btn0.Click += new RoutedEventHandler(this.b);
this.btnStar.Click += new RoutedEventHandler(this.b);
this.btnSharp.Click += new RoutedEventHandler(this.b);
```
Ведет оно в никуда, лишь управление кнопкой delete и вибрацией.
```
private void b(object A_0, RoutedEventArgs A_1)
{
if (1 == 0)
;
label_2:
this.timer_btn.Stop();
this.timer_btn.Start();
this.vibrate.Start(TimeSpan.FromSeconds(0.05));
this.e((string) ((ContentControl) A_0).Content);
bool flag = this.txtDial.Text.Length <= 0;
int num = 1;
while (true)
{
switch (num)
{
case 0:
this.btnDelete.Visibility = Visibility.Visible;
num = 2;
continue;
case 1:
if (!flag)
{
num = 0;
continue;
}
else
goto label_7;
case 2:
goto label_5;
default:
goto label_2;
}
}
label_5:
return;
label_7:;
}
```
Что же, и слава богу, разбираться в этом лучше и не начинать…
Казалось бы, тупик, однако оказывается, что всем управляет таймер, включающийся после каждого нажатия кнопки:
```
this.timer_btn.Tick += new EventHandler(this.ParseDial);
public void ParseDial(object sender, EventArgs e)
{
if (1 == 0)
;
this.timer_btn.Stop();
this.GetEnumFromList(this.f(this.txtDial.Text));
}
public void GetEnumFromList(uint hashCode)
{
label_2:
int A_0 = 0;
int num = 12;
bool flag;
while (true)
{
switch (num)
{
case 0:
case 16:
num = 3;
continue;
case 1:
if (!flag)
{
num = 10;
continue;
}
else
{
flag = Convert.ToBoolean(this.iNVBlock);
num = 14;
continue;
}
case 2:
this.TitleBrush.Color = Color.FromArgb(byte.MaxValue, (byte) 0, (byte) 80, byte.MaxValue);
this.textBlockPageTitle.Foreground = (Brush) this.TitleBrush;
this.NavigationService.Navigate(new Uri(string.Format(HiddenKeyTable.Current.hashTable[A_0].strPage, (object) HiddenKeyTable.Current.hashTable[A_0].iPageMode, (object) HiddenKeyTable.Current.hashTable[A_0].iHashcode), UriKind.Relative));
num = 9;
continue;
case 3:
case 9:
case 15:
num = 4;
continue;
case 4:
if (1 == 0)
;
++A_0;
num = 17;
continue;
case 5:
if (flag)
{
this.TitleBrush.Color = Color.FromArgb(byte.MaxValue, byte.MaxValue, (byte) 0, (byte) 0);
this.textBlockPageTitle.Foreground = (Brush) this.TitleBrush;
num = 0;
continue;
}
else
{
num = 8;
continue;
}
case 6:
if (!flag)
{
num = 13;
continue;
}
else
goto case 4;
case 7:
if (!flag)
{
num = 11;
continue;
}
else
{
flag = HiddenKeyTable.Current.hashTable[A_0].iHash.CompareTo(hashCode) != 0;
num = 6;
continue;
}
case 8:
this.TitleBrush.Color = Color.FromArgb(byte.MaxValue, byte.MaxValue, (byte) 127, (byte) 0);
this.textBlockPageTitle.Foreground = (Brush) this.TitleBrush;
this.NavigationService.Navigate(new Uri(string.Format(HiddenKeyTable.Current.hashTable[A_0].strPage, (object) HiddenKeyTable.Current.hashTable[A_0].iPageMode), UriKind.Relative));
num = 16;
continue;
case 10:
this.NavigationService.Navigate(new Uri(string.Format(HiddenKeyTable.Current.hashTable[A_0].strPage, (object) HiddenKeyTable.Current.hashTable[A_0].iPageMode, (object) HiddenKeyTable.Current.hashTable[A_0].iHashcode), UriKind.Relative));
num = 15;
continue;
case 11:
goto label_26;
case 12:
case 17:
flag = A_0 < this.length;
num = 7;
continue;
case 13:
this.HybridInterface_FCRProxy.w(out this.iNVBlock);
flag = !this.g(A_0);
num = 1;
continue;
case 14:
if (flag)
{
this.TitleBrush.Color = Color.FromArgb(byte.MaxValue, byte.MaxValue, (byte) 127, (byte) 0);
this.textBlockPageTitle.Foreground = (Brush) this.TitleBrush;
flag = this.d();
num = 5;
continue;
}
else
{
num = 2;
continue;
}
default:
goto label_2;
}
}
label_26:;
}
```
Господи, чтобы разобраться в этом коде нужно много алкоголя… Удаляем все, кроме навигации на страницы:
```
this.NavigationService.Navigate(new Uri(string.Format(HiddenKeyTable.Current.hashTable[A_0].strPage, (object) HiddenKeyTable.Current.hashTable[A_0].iPageMode, (object) HiddenKeyTable.Current.hashTable[A_0].iHashcode), UriKind.Relative));
this.NavigationService.Navigate(new Uri(string.Format(HiddenKeyTable.Current.hashTable[A_0].strPage, (object) HiddenKeyTable.Current.hashTable[A_0].iPageMode), UriKind.Relative));
this.NavigationService.Navigate(new Uri(string.Format(HiddenKeyTable.Current.hashTable[A_0].strPage, (object) HiddenKeyTable.Current.hashTable[A_0].iPageMode, (object) HiddenKeyTable.Current.hashTable[A_0].iHashcode), UriKind.Relative));
```
Уже лучше. Тут видно, что навигация идет через некую таблицу HiddenKeyTable, а в качестве ключа туда передается результат некой функции f(A\_0), которая является хэшем введенного кода. Смотрим код функции:
```
private uint f(string A_0)
{
switch (0) // Этот switch пуст, единственная ветвь в нем - default, можно смело убирать
{
default: // Это тоже
label_2: // Бесполезный label
uint num1 = 0U;
int index = 0;
int num2 = 2;
uint num3;
bool flag; // А это вообще не скомпилируется, значение не установлено
while (true)
{
switch (num2) // Запутывающий switch, его легко распутать через дебаггер
{
case 0:
goto label_9;
case 1:
case 2:
flag = index < A_0.Length;
num2 = 4;
continue;
case 3:
num3 = num1;
num2 = 0;
continue;
case 4:
if (!flag)
{
num2 = 3;
continue;
}
else
{
num1 = (num1 << 5) + num1 + (uint) A_0[index]; // А вот то, что нам нужно
++index;
if (1 == 0)
;
num2 = 1;
continue;
}
default:
goto label_2;
}
}
label_9:
return num3;
}
}
```
Что же, придется разобраться без алкоголя. Убираем строки кода, которые просто сбивают с толка, такие как switch (0), лишние case, дебаггером проходимся по коду и смотрим, куда он приводит в конце концов (переделано в читаемый вид):
```
private static uint GetHashCode(string code)
{
var hash = 0U;
foreach (var ch in code)
hash = (hash << 5) + hash + ch;
return hash;
}
```
Найдя уже нерабочие коды, я обнаружил, что везде используется нечто вроде \*#123#, т.е. числовой код начинается с \*# и заканчиваются #. Сформируем строку:
```
const string format = "*#{0}#"
```
А теперь метод полного перебора, чтобы пробить хэш и сравнить его со значением из таблицы:
```
public static void Main()
{
BruteHash("0{0}"); // Некоторые коды начинаются с 0, а некоторые - нет, поэтому используем оба случая
BruteHash("{0}"); // Тут без нуля
}
private static void BruteHash(string f)
{
const string format = "*#{0}#"; // Так выглядит код
var thread = new Thread(() =>
{
var i = 0;
while (true)
{
var code = string.Format(f, i);
var codeStr = string.Format(format, code);
var value = GetHashCode(codeStr); // Ищем хэш код строки вида *#123#
if (IsIpHash(value)) // Сверяемся с хэшкодом
{
Console.Write(codeStr); // Выводим
return;
}
i++;
}
});
thread.Start();
}
private static uint GetHashCode(string code)
{
var hash = 0U;
foreach (var ch in code)
hash = (hash << 5) + hash + ch;
return hash;
}
private static bool IsIpHash(uint hash)
{
return hash == 3974577854U;
}
```
Значение 3974577854U найти достаточно просто: в таблице HiddenKeyTable поиском IP я нашел ключ g\_IPSetting, значением которого является именно это число. Осталось только запустить и буквально через секунду мы получаем результат — код \*#232340#, вводим, и вуаля! Мы можем изменить IP адрес, маску подсети, шлюз, DNS. Работает только с Diagnosis 1109, Samsung Omnia W. На других не проверял, увы. Непонятны причины скрытия этого кода, правда. Покапавшись в таблице, я нашел и некоторые другие рабочие коды:
\*#9900# — DEBUGDUMP
\*#745# — RILDUMP (SLOG\_DUMP, sth to file)
\*#9990# — g\_VERIFYCOMPARE (IMEI compare for PLS operation 8)
\*#2470# — g\_CAMERAUPDATE (CameraFWUpdate)
\*#0589# !- g\_LIGHTSENSORTEST
\*#1111# — g\_SWversionFTA (Test Mode FTA SW version)
\*#2222# — g\_HWversionFTA (Test Mode FTA HW version)
\*#1234# — g\_SWversionEx (Version of systems, wifi, bt, csc, pda, phone)
\*#0228# — g\_BATTERYINFO
\*#0842# — g\_DEVICETEST
\*#0283# — g\_PHONELOOPBACKTEST
\*#7284# — g\_USBPATHCHANGE
\*#232337# — g\_BLUETOOTH\_MAC\_VIEWER
\*#232331# — g\_BLUETOOTH\_RF\_TEST
\*#232338# — g\_WIFI\_MAC\_VIEWER
\*#770# — g\_VPHONE770
\*#771# — g\_VPHONE771
\*#772# — g\_VPHONE772
\*#773# — g\_VPHONE773
\*#774# — g\_VPHONE774
\*#775# — g\_VPHONE775
\*#776# — g\_VPHONE776
\*#777# — g\_VPHONE777
\*#778# — g\_VPHONE778
\*#779# — g\_VPHONE779
\*#7451# — g\_ERROR\_REPORT\_ON
\*#6381# — g\_RILNETLOG\_ON
\*#6380# — g\_RILNETLOG\_OFF
\*#9908# — g\_GUMITEST3G\_CAB\_INSTALL
\*#9920# — g\_CONNECTION\_SETTING (connection string)
\*#07# — g\_VIEWHISTORYNW
\*#2663# — g\_TouchFirmare\_2663 (touch screen version)
\*#99785# — g\_PVKKey
\*#997856# — g\_PVKFileName
\*#86824# — g\_TouchkeySensitivity (firmware deupgrade available! (from 09 to 08))
\*#0123# — g\_MPS (MPS viewer, connection string)
\*#232340# — g\_IPSetting (IP SETTINGS!!!)
Остальные помечены в таблице BlockType.none, я так и не понял, как их вызывать, там есть функция HybridInterface\_FCRProxy.w(), которая что-то возвращает, но разобраться я так и не смог.
[Ссылка на скачивание XAP архива](http://www.mediafire.com/download.php?n3aoag36i9ansxq). Извиняюсь, не знаю, куда правильно лить.
**P.S.** Если я написал или оформил что-то неправильно, просьба — укажите об этом в ЛС. Пока что не знаю точно, как оформлять. Спасибо. | https://habr.com/ru/post/173325/ | null | ru | null |
# Mkcert: валидные HTTPS-сертификаты для localhost
В наше время использование HTTPS становится обязательным для всех сайтов и веб-приложений. Но в процессе разработки возникает проблема корректного тестирования. Естественно, Let’s Encrypt и другие CA не выдают сертификаты для localhost.
Традиционно есть два решения.
1. Самоподписанные сертификаты, сгенерированные через openssl или др. Вот самый простой способ сгенерировать приватный ключ и самоподписанный сертификат для localhost:
```
openssl req -x509 -out localhost.crt -keyout localhost.key \
-newkey rsa:2048 -nodes -sha256 \
-subj '/CN=localhost' -extensions EXT -config <( \
printf "[dn]\nCN=localhost\n[req]\ndistinguished_name = dn\n[EXT]\nsubjectAltName=DNS:localhost\nkeyUsage=digitalSignature\nextendedKeyUsage=serverAuth")
```
Но такой сертификат вызовет ошибки доверия в браузерах, потому что в доверенном хранилище отсутствует соответствующий центр сертификации.
2. Трюк с регистрацией нового домена типа localhost.example.com, который локально ресолвится в 127.0.0.1 (в /etc/hosts), с получением обычного сертификата для данного домена. Но такая махинация сомнительна с точки зрения безопасности — по крайней мере, для публичных сервисов подобный ресолвинг делать [крайне не рекомендуется](https://letsencrypt.org/docs/certificates-for-localhost/) из-за возможной MiTM-атаки со сменой на враждебный IP-адрес. Если ограничиться только локальной машиной, то может это и подходящий вариант, хотя тоже возникают некоторые сомнения. К тому же, такой сертификат могут отозвать. В любом случае, есть вариант проще и безопаснее (см. ниже).
Речь идёт о [mkcert](https://github.com/FiloSottile/mkcert) — простой утилите для генерации локально-доверенных сертификатов с **собственным центром сертификации**. Она работает под всеми ОС и не требует какой-то конфигурации.
#### Версия для Linux
Сначала нужно установить `certutil`.
```
sudo apt install libnss3-tools
-или-
sudo yum install nss-tools
-или-
sudo pacman -S nss
```
затем
```
brew install mkcert
```
или собрать из исходников:
```
go get -u github.com/FiloSottile/mkcert
$(go env GOPATH)/bin/mkcert
```
#### Версия для macOS
```
brew install mkcert
brew install nss # if you use Firefox
```
#### Версия для Windows
Под Windows можно скачать [собранные бинарники](https://github.com/FiloSottile/mkcert/releases) либо воспользоваться одним из пакетных менеджеров: Chocolatey или Scoop.
```
choco install mkcert
-или-
scoop install mkcert
```
Наличие локального центра сертификации — самое важное принципиальное отличие mkcert от openssl и самоподписанных сертификатов, потому что при запуске такого CA локально не возникает никаких ошибок доверия.
В принципе, запустить и настроить собственный CA можно и другими средствами, но это требует нетривиальных знаний и навыков. Здесь всё делает само собой, без всяких дополнительных ключей и настроек. Просто устанавливаем программу — и она автоматически создаёт локальный центр сертификации и прописывает его в доверенное хранилище системы и доверенное хранилище Firefox.
```
$ mkcert -install
Created a new local CA at "/Users/filippo/Library/Application Support/mkcert"
The local CA is now installed in the system trust store! ️
The local CA is now installed in the Firefox trust store (requires restart)!
``` | https://habr.com/ru/post/435476/ | null | ru | null |
# Портирование WPF приложений на netcore 3.0
Ожидаемый релиз netcore 3.0 позволяет запускать wpf на netcore. Процедура перевода для одного несложного проекта занимает один-два дня. Каждый последующий — много быстрее.
Подготовка и конвертация проектов
---------------------------------
Первый этап подготовки — установить и запустить Portability Analyzer. На выходе получим Excel табличку, в которой увидим на сколько наш код соответствует новым требованиям.
Процедуру конвертации старых проектов провернули в несколько этапов.
1. Microsoft рекомендует поднять для старых проектов версию фреймворка до .Net Framework 4.7.3.
2. Сконвертировать структуру старых проектов в новый формат. Заменить packages.config на PackageReference.
3. В-третьих, скорректировать структуру файла csproj в формат netcore.
Хочу поблагодарить Янгирова Эмиля с его докладом по миграции на netcore, который очень пригодился. [Ссылка на его доклад.](https://www.youtube.com/watch?v=jLBUk1hvLoU)
Получилось, что первый этап мы решили пропустить. Второй этап подразумевал необходимость конвертации больше 100 проектов. Как осуществляется этот процесс можно подробно прочитать [здесь](https://docs.microsoft.com/ru-ru/nuget/consume-packages/migrate-packages-config-to-package-reference).
Поняли, что без автоматизации никак не обойтись. Воспользовались уже готовым решением: [CsprojToVs2017](https://github.com/hvanbakel/CsprojToVs2017). Пусть название проекта вас не смущает: утилита конвертит и для Visual Studio 2019.
### Что произойдёт?
Уменьшится размер файлов csproj. За счет чего? Из csproj уйдут все подключенные файлы с исходным кодом, уберутся лишние строки и т.п.
```
-
-
- True
- Settings.settings
- True
-
```
Сократятся записи подключенных библиотек и подпроектов.
```
-
- ..\packages\NLog.4.3.3\lib\net45\NLog.dll
- False
-
-
- {7ce118f6-2978-42a7-9e6a-ee5cd3057e29}
- WpfCommon
-
+
+
```
Общие настройки для нескольких проектов можно унести в Directory.BuildProps. Это такой специальный файл, в который заглядывает MsBuild.
По аналогии с .gitignore и .editorconfig у нас есть глобальный файл с общими настройками.
Частные настройки PropertyGroup для подкаталогов/проектов добавляем в конкретные csproj файлы. Подробно можно почитать [здесь.](https://docs.microsoft.com/ru-ru/visualstudio/msbuild/customize-your-build?view=vs-2019)
Зависимости
-----------
Старые зависимости будут для netframework. Придется найти альтернативу или похожие пакеты для nuget. Для многих проектов уже есть Nuget-пакет, которые поддерживают netcore или netstandard.
К примеру, в проекте использовалась старая версия DI Unity. При переходе на новую версию пришлось обновить using и поправить код в двух-трёх местах.
```
using Microsoft.Practices.Unity -> using Unity;
```
А возможно будет достаточно апнуть все версии пакетов. И на всякий случай перезапустить студию.
Изменить csproj на использование netcore
----------------------------------------
В проектах, которые используют WPF контролы, нужно изменить формат на Microsoft.NET.Sdk.WindowsDesktop:
```
-xml version="1.0" encoding="utf-8"?
-
-
-
```
```
+
+
+ netcoreapp3.0
+ MyEnterpriseLibrary
+ MyEnterpriseLibrary
+ ..\bin\$(Configuration)\
+ true
+
+ false
```
Для ClassLibrary достаточно оставить тип Microsoft.NET.Sdk:
```
netcoreapp3.0
MyEnterpriseLibrary
MyEnterpriseLibrary
..\bin\$(Configuration)\
```
Возможно, в некоторых проектах, которые используются контролы Windows Forms придётся ещё и воткнуть обращение к UseWindowsForms:
```
true
```
В csproj изменился подход к потоку компиляции ресурсов. Раньше формат позволял подключить файл и к ресурсам, и к Content,
и хоть куда.
Теперь, если файл попал в какую-то коллекцию, то его нужно из неё вытащить, а уже потом включить в нужную группу.
Вот код, который вытаскивает file.json из коллекции None и подключает его к коллекции Resource.
```
```
Соответственно, все файлы, которые не являются исходниками, надо вытащить из коллекции None и подключить к ресурсам. Например, так:
```
```
Некоторые строки придётся удалить, так как сбивают версию фреймворка на .net framework 4.0.
```
Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets"
```
Кое-где после конвертации останутся странные записи, которые не дают проекту компилироваться. Вот примеры таких конструкций:
```
-
-
-
-
```
Клиенты WCF
-----------
Если использовался WCF, то придётся перегенерировать привязки. Как это сделать правильно можно прочитать тут: [docs.microsoft.com/en-us/dotnet/desktop-wpf/migration/convert-project-from-net-framework#updating-wcf-client-usage](https://docs.microsoft.com/en-us/dotnet/desktop-wpf/migration/convert-project-from-net-framework#updating-wcf-client-usage)
Что не взлетит?
===============
Stylecop и анализ кода.
-----------------------
В части наших проектов использовались статические анализаторы кода. При переходе на современные редакции MsBuild сборщик явно предлагает использовать вместо старых статических анализаторов кода новые Roslyn-анализаторы.
Пришлось перевести старые правила на использование Nuget-пакетов Stylecop.Analyzers и FxCop.Analyzers следуя [этому руководству Microsoft.](https://docs.microsoft.com/en-us/visualstudio/code-quality/fxcop-analyzers?view=vs-2019).
Если у вас несколько проектов в разных папках (монорепозиторий), то гораздо удобнее вынести подключение анализаторов в Build.props и настраивать едиными ruleset.
Вот что получилось:
```
- true
+
```
Файлы — сироты
--------------
Старый формат csproj подразумевал явное подключение .cs файлов. При этом иногда при переименованиях или рефакторингах старые файлы удалялись из csproj, но не удалялись явно с файловой системы. В новом формате csproj автоматически подхватятся все файлы, которые находятся в папке с проектом, как раз те самые, которые не были удалены ранее. Скорее всего в них будут ошибки, обращения к уже несуществующим классам, методам, ресурсам. Выльется в банальные ошибки при сборке.
Ресурсы
-------
В одном из проектов использовались SplashScreen, один из которых случайно выбирался при запуске. Экземпляру SplashScreen при инициализации скармливался путь к ресурсу. Почему-то на netcore 3 победить не удалось: ругается на отсутствие ресурса.
Код, который вроде работает
---------------------------
Код, который работал в .Net Framework, с большой вероятностью заработает и в netcore. Но могут быть участки кода, на которые компилятор закрыл глаза. В этом случае, если код доберется до инструкций, которые не реализованы в netcore, мы словим PlatformException.
Для того, чтобы поискать такие места, есть специальный анализатор: [github.com/dotnet/platform-compat](https://github.com/dotnet/platform-compat) .
Зачем всё это, если проект работает?
====================================
Преимуществ не так много, но тем не менее, они есть.
* Ваш код получит все оптимизации, добавленные в netcore.
* Увеличится скорость запуска приложения.
* Нацеливание на будущие версии C#.
* Уменьшится время сборки проектов благодаря новым версиям csproj.
* Упаковка в единственный exe.
Microsoft не подталкивает к переводу приложений на новые рельсы. Тем не менее, если ваше приложение является плагином другого бОльшего, то есть смысл нацелиться на будущие релизы, которые могут быть и на netcore.
Полезные ссылки
===============
* [docs.microsoft.com/ru-ru/dotnet/desktop-wpf/migration/convert-project-from-net-framework](https://docs.microsoft.com/ru-ru/dotnet/desktop-wpf/migration/convert-project-from-net-framework)
* [docs.microsoft.com/ru-ru/dotnet/core/porting/winforms](https://docs.microsoft.com/ru-ru/dotnet/core/porting/winforms)
* [devblogs.microsoft.com/dotnet/migrating-a-sample-wpf-app-to-net-core-3-part-1](https://devblogs.microsoft.com/dotnet/migrating-a-sample-wpf-app-to-net-core-3-part-1/)
* [devblogs.microsoft.com/dotnet/migrating-a-sample-wpf-app-to-net-core-3-part-2](https://devblogs.microsoft.com/dotnet/migrating-a-sample-wpf-app-to-net-core-3-part-2/)
* [devblogs.microsoft.com/dotnet/how-to-port-desktop-applications-to-net-core-3-0](https://devblogs.microsoft.com/dotnet/how-to-port-desktop-applications-to-net-core-3-0/)
* [www.nuget.org/packages/Microsoft.Windows.Compatibility](https://www.nuget.org/packages/Microsoft.Windows.Compatibility/)
* [www.youtube.com/watch?v=jLBUk1hvLoU](https://www.youtube.com/watch?v=jLBUk1hvLoU) | https://habr.com/ru/post/470401/ | null | ru | null |
# Компоненты-агностики в Angular
Когда работаешь над библиотекой переиспользуемых компонентов, вопрос API встает особенно остро. С одной стороны, нужно сделать надежное, аккуратное решение, с другой — удовлетворить массу частных случаев. Это относится и к работе с данными, и к внешним особенностям различных кейсов использования. Кроме того, все должно легко обновляться и раскатываться по проектам.
Таким компонентам нужна беспрецедентная гибкость. При этом настройку нельзя делать слишком сложной, ведь их будут использовать как сеньоры, так и джуны. Уменьшение дублирования кода — одна из задач библиотеки компонентов. Поэтому конфигурацию нельзя превращать в копирование кода.
Data-agnostic компоненты
------------------------
Допустим, мы делаем кнопку с выпадающим меню. Каким будет его API? Разумеется, ему нужен на вход некий *items* — массив пунктов меню. Скорее всего, первый вариант интерфейса будет таким:
```
interface MenuItem {
readonly text: string;
readonly onClick(): void;
}
```
Довольно быстро к этому добавится `disabled: boolean`. Потом придут дизайнеры и нарисуют меню с иконками. А ребятам с соседнего проекта они нарисуют иконки с другой стороны. И вот интерфейс растет, необходимо покрывать все больше частных случаев, а от обилия флагов компонент начинает напоминать Ассамблею ООН.
На помощь приходят дженерики. Если организовать компонент так, чтобы ему не было дела до модели данных, то все эти проблемы отпадут. Вместо того чтобы по клику вызывать `item.onClick`, меню будет просто эмитить наружу кликнутый пункт. Что с ним делать после — задача для пользователей библиотеки. Пусть даже они вызовут тот же `item.onClick`.
В случае состояния `disabled`, к примеру, вопрос решается с помощью специальных обработчиков. В компонент передается метод `disabledItemHandler: (item: T) => boolean`, через который прогоняется каждый пункт. Полученный результат говорит, заблокирован ли данный элемент.
Если вы делаете *ComboBox* — на ум может прийти интерфейс, хранящий строку для отображения и реальное произвольное значение, которое используется в коде. Эта идея понятна. Ведь, когда пользователь печатает текст, *ComboBox* должен фильтровать варианты по введенной строке.
```
interface ComboBoxItem {
readonly text: string;
readonly value: any;
}
```
Но тут тоже всплывут ограничения подобного подхода — стоит только появиться дизайну, в котором строки́ будет недостаточно. Кроме того, форма будет содержать обертку вместо реального значения, поиск не всегда осуществляется исключительно по строковому представлению (к примеру, мы можем вбивать номер телефона, но отображаться должно имя человека). А число интерфейсов будет расти с появлением других компонентов, даже если модель данных под ними одна и та же.
Здесь тоже помогут дженерики и обработчики. Дадим возможность передавать в компонент `stringify` функцию `(item: T) => string`. В качестве значения по умолчанию подойдет `item => String(item)`. Таким образом можно даже использовать классы в качестве вариантов, задав в них метод `toString()`. Как упоминалось выше, бывает необходимость фильтровать варианты не только по строковому представлению. Это тоже хороший кейс для использования обработчиков. Можно предоставить в компонент функцию, получающую на вход строку поиска и элемент. Она вернет `boolean` — это подскажет, подходит ли элемент под запрос.
> Еще один частый пример использования интерфейса — уникальный id, по которому сопоставляются копии JavaScript-объектов. Когда значение формы мы получили сразу, а варианты для выбора пришли отдельным запросом с сервера — в них будет только копия текущего элемента. Такую задачу решает обработчик, получающий на вход два элемента и возвращающий их равенство. По умолчанию подойдет обычное сравнение `===`.
Компоненту отображения вкладок, по факту, не нужно знать в каком виде ему передали вкладку: хоть текстом, хоть объектом с дополнительными полями, хоть ещё как. Знание о формате необязательно для реализации, но многие делают завязку на конкретный формат. Отсутствие завязок означает, что компоненты не повлекут за собой ломающие изменения при доработке, не заставят пользователей адаптировать под них свои данные и позволят комбинировать атомарные компоненты друг с другом как кубики лего.
Один и тот же выбор из пунктов подойдет как для контекстного меню, так и для комбобокса, селекта, мультиселекта, простые компоненты легко включаются в более сложные конструкции. Однако произвольные данные нужно уметь как-то отображать.
*Списки могут содержать аватарки, разные цвета, иконки, количество непрочитанных сообщений и многое другое*
> Для этого компоненты должны работать с внешним видом в схожей с дженериками манере.
Design-agnostic компоненты
--------------------------
Angular предоставляет мощные инструменты для задания внешнего вида.
Для примера рассмотрим *ComboBox*, так как он может выглядеть очень разнообразно. Разумеется, определенный уровень ограничений будет заложен в компонент, ведь он должен подчиняться общему дизайну приложения. Его размер, цвета по умолчанию, отступы — всё это должно работать само. Мы не хотим заставлять пользователей думать обо всем, что касается внешнего вида.
Произвольные данные подобны воде: они не имеют формы, не несут в себе ничего конкретного. Наша задача — предоставить возможность задавать для них «сосуд». В этом понимании разработка компонента, абстрагированного от внешнего вида, выглядит следующим образом:
Компонент представляет собой подобие полочки нужных размеров, а для отображения содержимого используется настраиваемый шаблон, который на нее «ставится». Стандартный способ вроде вывода строкового представления заложен в компонент изначально, а более сложные варианты пользователь может передать снаружи. Давайте рассмотрим, какие возможности для этого есть в Angular.
1. Простейший вариант изменения внешнего вида — интерполяция строки. Но неизменная строка не сгодится для отображения пунктов меню, ведь она ничего не знает про каждый пункт — и они все будут выглядеть одинаково. **Статичная строка лишена контекста**. Но она вполне подойдет для задания текста «Ничего не найдено», если список вариантов пуст.
```
{{content}}
```
2. Мы уже говорили о строковом представлении произвольных данных. Результат также является строкой, но определяется входным значением. В такой ситуации контекстом будет элемент списка. Это более гибкий вариант, хотя он не позволяет стилизовать результат — строка не интерполируется в HTML — и уж тем более не даст использовать директивы или компоненты.
```
{{content(context)}}
```
3. Для задания переиспользуемого блока разметки в Angular предусмотрены шаблоны `ng-template` и структурная директива `*ngTemplateOutlet`. С их помощью мы можем определить кусочек HTML, ожидающий на вход некие данные, и передать его в компонент. Там он будет инстанциирован с конкретным контекстом. Мы передадим ему на вход наш элемент, не заботясь о модели. Составить правильный шаблон под свои объекты — задача разработчика-потребителя нашего компонента.
Шаблон — очень мощный инструмент, но его нужно определить в каком-то уже существующем компоненте. Это значительно затрудняет его переиспользование. Иногда один и тот же внешний вид требуется в разных частях приложения и даже в разных приложениях. В моей практике это, к примеру, внешний вид выбора счета с отображением названия, валюты и остатка.
4. Наиболее сложный вариант кастомизации внешнего вида, который решает эту проблему, — динамические компоненты. В Angular уже давно существует директива `*ngComponentOutlet`, чтобы создавать их декларативно. Она не позволяет передавать контекст, но эта задача решается внедрением зависимостей. Мы можем сделать токен для контекста и добавить его в `Injector`, с которым компонент создается.
Стоит отметить, что в качестве контекста может выступать не только элемент, который мы хотим отобразить, но и обстоятельства, в которых он находится:
```
```
К примеру, в случае вывода счета состояние сфокусированности пункта отражается на внешнем виде — фон иконки меняется с серого на белый. В общем виде в контекст имеет смысл передавать те условия, которые потенциально влияют на отображение шаблона. Этот момент является, пожалуй, единственным ограничением-интерфейсом такого подхода.
Универсальный Outlet
--------------------
Описанные выше инструменты доступны в Angular с пятой версии. Но нам хочется легко переключаться с одного варианта на другой. Для этого мы соберем компонент, принимающий на вход содержимое и контекст и реализующий соответствующий способ вставки этого контента автоматически. В целом нам достаточно научиться различать типы `string`, `number`, `(context: T) => string | number`, `TemplateRef` и `Type` (но тут есть несколько нюансов, которых мы коснемся ниже).
Шаблон компонента будет выглядеть следующим образом:
```
{{content}}
{{content(context)}}
```
В коде будет геттер на тип для выбора соответствующего способа. Нужно отметить, что в общем виде отличить компонент от функции мы не сможем. При использовании lazy-модулей нам понадобится `Injector`, знающий о существовании компонента. Для этого мы создадим класс-обертку. Это также даст возможность определять его по `instanceof`:
```
export class ComponentContent {
constructor(
readonly component: Type,
private readonly injector: Injector | null = null,
) {}
}
```
Добавим ему метод для создания инжектора с переданным контекстом:
```
createInjectorWithContext(injector: Injector, context: C): Injector {
return Injector.create({
parent: this.injector || injector,
providers: [
{
provide: CONTEXT,
useValue: context,
},
],
});
}
```
Что касается шаблонов, для большинства случаев можно работать с ними как есть. Но надо иметь в виду, что шаблон подчиняется проверке изменений места своего определения. Если передать его во *View*, находящийся параллельно или выше по дереву от места определения, то изменения, которые могут быть спровоцированы в нем, не будут подцеплены в исходном *View*.
Для исправления этой ситуации будем использовать не просто шаблон, а директиву, которая будет иметь при себе также `ChangeDetectorRef` места своего определения. Так мы сможем запускать проверку изменений, когда это необходимо.
Полиморфные шаблоны
-------------------
На практике бывает полезно управлять поведением шаблона в зависимости от типа контента, который в него пришел.
К примеру, мы хотим дать возможность передать шаблон в компонент для чего-то особенного. В то же время в большинстве случаев нужна просто иконка. В такой ситуации можно настроить поведение по умолчанию и задействовать его, когда на вход попал примитив или функция. Иногда даже тип примитива бывает важен: например, если у вас есть компонент-бейдж для отображения числа непрочитанных сообщений на вкладке, но при этом вы хотите подсветить особой иконкой страницы, требующие внимания.
Для этого нужно добавить еще одну вещь — передачу шаблона для отображения примитивов. Добавим в компонент `@ContentChild`, берущий из содержимого `TemplateRef`. Если таковой нашелся и в контент передана функция, строка или число, мы можем инстанциировать его с примитивом в качестве контекста:
```
{{primitive}}
```
Теперь мы можем стилизовать интерполяцию или даже передать результат в какой-нибудь компонент для отображения:
```
{{primitive}}
```
Пора применить наш код на практике.
Использование
-------------
Для примеров набросаем два компонента: вкладки и *ComboBox*. Шаблон вкладок будет просто состоять из content-outlet на каждую вкладку, где в качестве контекста будет переданный пользователем объект:
Нужно заложить стили по умолчанию: например, размер шрифта, подчеркивание под текущей вкладкой, цвет. Но конкретный внешний вид мы оставим на content. Код компонента будет примерно таким:
```
export class TabsComponent {
@Input()
tabs: ReadonlyArray = [];
@Input()
content: Content = ({$implicit}) => String($implicit);
@Input()
disabledItemHandler: (tab: T) => boolean = () => false;
@Input()
activeTab: T | null = null;
@Output()
activeTabChange = new EventEmitter();
getContext($implicit: T): IContextWithActive {
return {
$implicit,
active: $implicit === this.activeTab,
};
}
onClick(tab: T) {
this.activeTab = tab;
this.activeTabChange.emit(tab);
}
}
```
Мы получили компонент, который умеет работать с произвольным массивом, отображая его как вкладки. Можно передать туда просто строки и получить базовый внешний вид:
А можно передать объекты и шаблон для их отображения и настроить внешний вид под свои нужды, добавить HTML, иконки, индикаторы:
В случае с *ComboBox* мы сначала сделаем два базовых компонента, из которых он состоит: поле ввода с иконкой и меню. Последний не имеет смысла расписывать подробно — он очень похож на вкладки, только расположен вертикально и имеет иные базовые стили. А поле ввода можно реализовать следующим образом:
```
```
Если сделать *input* позиционированным абсолютно — он перекроет собой outlet и все клики придутся по нему. Это удобно для простого поля ввода с декоративной иконкой, например со значком увеличительного стекла. На примере выше применен подход полиморфного шаблона — переданная строка будет использоваться как `innerHTML` для вставки SVG-иконки. Если же нам, например, нужно показать аватар введенного пользователя — можем передать туда шаблон.
Для *ComboBox* тоже нужна иконка, но она должна быть интерактивной. Чтобы она не нарушала фокус, добавим обработчик `onMouseDown` на outlet:
```
onMouseDown(event: MouseEvent, input: HTMLInputElement) {
event.preventDefault();
input.focus();
}
```
Передача шаблона в качестве содержимого позволит поднять его выше через CSS, просто сделав иконку *position: relative*. Тогда на клики по ней можно будет подписаться в самом *ComboBox*:
```
```
Благодаря такой организации мы получим нужное поведение:
Код компонента, как и в случае вкладок, обходится без знания о модели данных. Выглядит это приблизительно так:
```
export class ComboBoxComponent {
@Input() items: ReadonlyArray = [];
@Input() content: Content = ({$implicit}) => String($implicit);
@Input() stringify = (item: T) => String(item);
@Input() value: T | null = null;
@Output() valueChange = new EventEmitter();
stringValue = '';
// Это лучше реализовать через пайп чтобы избежать лишних пересчётов
get filteredItems(): ReadonlyArray {
return this.items.filter(item =>
this.stringify(item).includes(this.stringValue),
);
}
}
```
Такой простой код позволяет использовать в *ComboBox* любые объекты и настраивать их отображение очень гибко. После некоторых доработок, не относящихся к описываемой концепции, он готов к использованию. Внешний вид можно настроить на любой вкус:
Вывод
-----
Создание компонентов-агностиков освобождает от необходимости учитывать каждый частный случай. При этом пользователи получают простой инструмент для настройки компонента под конкретную ситуацию. Эти решения легко переиспользовать. Независимость от модели данных делает код универсальным, надежным и расширяемым. При этом мы написали не так уж много строк и в основном задействовали встроенные инструменты Angular.
Используя описанный подход, вы быстро заметите, как удобно мыслить категориями контента, а не конкретными строками или шаблонами. Отображение сообщений об ошибке валидации, тултипы, модальные окна — этот подход хорош не только для кастомизации внешнего вида, но и для передачи содержимого в целом. Набрасывать макеты и тестировать логику очень легко! К примеру, для показа попапа пользователю не нужно создавать компонент или даже шаблон, можно просто передать строку-заглушку и вернуться к ней позже.
Мы в Tinkoff.ru уже давно успешно применяем описанный подход и вынесли его в крошечную (1 КБ gzip) open-source-библиотеку под названием ***ng-polymorpheus***.
[Исходный код](https://github.com/TinkoffCreditSystems/ng-polymorpheus)
[npm-пакет](https://www.npmjs.com/package/@tinkoff/ng-polymorpheus)
[Интерактивное демо и «песочница»](https://codesandbox.io/s/github/TinkoffCreditSystems/ng-polymorpheus/tree/master/projects/demo)
> У вас тоже есть что-то, что вы мечтали выложить в open source, но вас отпугивают сопутствующие хлопоты? Попробуйте [Angular Open-source Library Starter](https://github.com/TinkoffCreditSystems/angular-open-source-starter), который мы сделали для своих проектов. В нём уже настроен CI, проверки при коммитах, линтеры, генерация CHANGELOG, покрытие тестами и всё в этом духе. | https://habr.com/ru/post/473108/ | null | ru | null |
# 22 совета Angular-разработчику. Часть 1
Автор статьи, первую часть перевода которой мы публикуем, говорит, что он уже около двух лет работает над крупномасштабным Angular-приложением в [Trade Me](https://preview.trademe.co.nz/). В течение последних нескольких лет команда разработчиков приложения постоянно занимается совершенствованием проекта — как в плане качества кода, так и в том, что касается производительности.
[](https://habr.com/company/ruvds/blog/425661/)
В этой серии материалов речь пойдёт о подходах к разработке, используемые командой Trade Me, которые выражены в виде более чем двух десятков рекомендаций, касающихся таких технологий, как Angular, TypeScript, RxJS и @ngrx/store. Кроме того, определённое внимание здесь будет уделено универсальным техникам программирования, которые направлены на то, чтобы сделать код приложений чище и аккуратнее.
1. О trackBy
------------
Применяя `ngFor` для обхода массивов в шаблонах, используйте эту конструкцию с функцией `trackBy`, которая возвращает уникальный идентификатор для каждого элемента.
### ▍Пояснения
Когда массив изменяется, Angular выполняет повторный рендеринг всего дерева DOM. Но если вы используете `trackBy`, система будет знать о том, какой элемент изменился и внесёт в DOM изменения, касающиеся только этого конкретного элемента. Подробности об этом можно почитать [здесь](https://netbasal.com/angular-2-improve-performance-with-trackby-cc147b5104e5).
### ▍До
```
- {{ item }}
```
### ▍После
```
// в шаблоне
- {{ item }}
// в компоненте
trackByFn(index, item) {
return item.id; // уникальный id, соответствующий элементу
}
```
2. Ключевые слова const и let
-----------------------------
Если вы собираетесь объявить переменную, значение которой менять не планируется — используйте ключевое слово `const`.
### ▍Пояснения
Уместное использование ключевых слов `let` и `const` проясняет намерение, касающееся применения объявленных с их помощью сущностей. Кроме того, такой подход облегчает распознавание проблем, вызванных случайной перезаписью значений констант. В такой ситуации выдаётся ошибка компиляции. Кроме того, это улучшает читабельность кода.
### ▍До
```
let car = 'ludicrous car';
let myCar = `My ${car}`;
let yourCar = `Your ${car};
if (iHaveMoreThanOneCar) {
myCar = `${myCar}s`;
}
if (youHaveMoreThanOneCar) {
yourCar = `${youCar}s`;
}
```
### ▍После
```
// значение car не перезаписывается, поэтому мы можем сделать car константой
const car = 'ludicrous car';
let myCar = `My ${car}`;
let yourCar = `Your ${car};
if (iHaveMoreThanOneCar) {
myCar = `${myCar}s`;
}
if (youHaveMoreThanOneCar) {
yourCar = `${youCar}s`;
}
```
3. Конвейеризуемые операторы
----------------------------
При работе с RxJS используйте конвейризуемые операторы.
### ▍Пояснения
Конвейеризуемые операторы поддерживают алгоритм tree-shake, то есть — при их импорте в проект будет включён лишь код, который планируется выполнять. Это, кроме того, упрощает идентификацию неиспользуемых операторов в файлах.
Обратите внимание на то, что эта рекомендация актуальна для Angular версии 5.5 и выше.
### ▍До
```
import 'rxjs/add/operator/map';
import 'rxjs/add/operator/take';
iAmAnObservable
.map(value => value.item)
.take(1);
```
### ▍После
```
import { map, take } from 'rxjs/operators';
iAmAnObservable
.pipe(
map(value => value.item),
take(1)
);
```
4. Изоляция исправлений API
---------------------------
Не все API совершенно стабильны и лишены ошибок. Поэтому иногда требуется вводить в код некую логику, направленную на исправление проблем API. Вместо того чтобы размещать эту логику в компонентах, где используются исправляемые API, лучше будет где-то её изолировать, например — в сервисе, и обращаться из компонента уже не к проблемному API, а к соответствующему сервису.
### ▍Пояснения
Предложенный подход позволяет держать исправления «ближе» к API, то есть, настолько близко к тому коду, из которого выполняются сетевые запросы, насколько это возможно. В результате уменьшается объём кода приложения, взаимодействующего с проблемными API. Кроме того, так оказывается, что все исправления находятся в одном месте, в результате с ними легче будет работать. Если вам приходится исправлять ошибки в API, то гораздо проще делать это в каком-то одном файле, чем разбрасывать эти исправления по всему приложению. Это облегчает не только создание исправлений, но и поиск соответствующего кода в проекте, и его поддержку.
Кроме того, можно создавать собственные теги, наподобие `API_FIX` (что напоминает тег `TODO`), и помечать ими исправления. Это упрощает поиск таких исправлений.
5. Подписка в шаблоне
---------------------
Избегайте подписки на наблюдаемые объекты (observables) из компонентов. Вместо этого оформляйте подписки на них в шаблонах.
### ▍Пояснения
Асинхронные конвейеризуемые операторы автоматически отписывают сами себя, что упрощает код, исключая необходимость в ручном управлении подписками. Это, кроме того, уменьшает риск того, что разработчик забудет отписаться от подписки в компоненте, что может привести к утечкам памяти. Снизить вероятность возникновения утечек памяти можно и с использованием правил линтера, направленных на выявление наблюдаемых объектов, от которых не отписались.
Кроме того, применение такого подхода приводит к тому, что компоненты перестают быть компонентами с состоянием, что может приводить к ошибкам когда данные меняются вне подписки.
### ▍До
```
// шаблон
{{ textToDisplay }}
// компонент
iAmAnObservable
.pipe(
map(value => value.item),
takeUntil(this._destroyed$)
)
.subscribe(item => this.textToDisplay = item);
```
### ▍После
```
// шаблон
{{ textToDisplay$ | async }}
// компонент
this.textToDisplay$ = iAmAnObservable
.pipe(
map(value => value.item)
);
```
6. Удаление подписок
--------------------
Подписываясь на наблюдаемые объекты всегда следите за тем, чтобы подписки на них правильно удалялись, используя операторы наподобие `take`, `takeUntil` и так далее.
### ▍Пояснения
Если не отписаться от наблюдаемого объекта — это приведёт к утечкам памяти, так как поток наблюдаемого объекта останется открытым, что возможно даже после разрушения компонента или после того, как пользователь перейдёт на другую страницу приложения.
Ещё лучше будет создать правило линтера для обнаружения наблюдаемых объектов с действующей подпиской на них.
### ▍До
```
iAmAnObservable
.pipe(
map(value => value.item)
)
.subscribe(item => this.textToDisplay = item);
```
### ▍После
Воспользуйтесь оператором `takeUntil` в том случае, если вы хотите наблюдать за изменениями какого-то объекта до тех пор, пока другой наблюдаемый объект не сгенерирует некое значение:
```
private destroyed$ = new Subject();
public ngOnInit (): void {
iAmAnObservable
.pipe(
map(value => value.item)
// Мы хотим прослушивать iAmAnObservable до разрушения компонента
takeUntil(this._destroyed$)
)
.subscribe(item => this.textToDisplay = item);
}
public ngOnDestroy (): void {
this._destroyed$.next();
}
```
Использование чего-то наподобие `this` — это паттерн, применяемый для управления удалением подписок на множество наблюдаемых объектов в компоненте.
Используйте `take` если вам нужно лишь первое значение, выдаваемое наблюдаемым объектом:
```
iAmAnObservable
.pipe(
map(value => value.item),
take(1),
takeUntil(this._destroyed$)
)
.subscribe(item => this.textToDisplay = item);
```
Обратите внимание на то, что здесь мы используем `takeUntil` с `take`. Это делается для того, чтобы избежать утечек памяти, вызванных тем, что подписка не привела к получению значения до разрушения компонента. Если бы здесь не использовалась функция `takeUntil`, подписка существовала бы до получения первого значения, но так как компонент был бы уже уничтожен, это значение никогда не было бы получено, что привело бы к утечке памяти.
7. Использование подходящих операторов
--------------------------------------
Используя сглаживающие операторы с наблюдаемыми объектами, применяйте те из них, которые соответствуют особенностям решаемой задачи.
* Используйте `switchMap` когда вам нужно игнорировать предыдущее диспетчеризованное действие при поступлении нового действия.
* Используйте `mergeMap` в том случае, если нужно параллельно обрабатывать все диспетчеризованные действия.
* Используйте `concatMap` тогда, когда действия нужно обрабатывать одно за другим, в порядке их поступления.
* Используйте `exhaustMap` в ситуациях, когда, в процессе обработки ранее поступивших действий, вам нужно игнорировать новые.
Подробности об этом можно почитать [здесь](https://blog.angularindepth.com/switchmap-bugs-b6de69155524).
### ▍Пояснения
Использование, если есть такая возможность, одного оператора, вместо того, чтобы достигать того же эффекта за счёт объединения в цепочку нескольких операторов, приводит к сокращению объёма кода приложения, который нужно отправить пользователю. Использование неудачно выбранного оператора может привести к неправильному поведению программы, так как разные операторы по-разному обрабатывают наблюдаемые объекты.
8. Ленивая загрузка
-------------------
Тогда, когда это возможно, попытайтесь организовать ленивую загрузку модулей Angular-приложения. Данная техника сводится к тому, что нечто загружается только в том случае, если оно используется. Например — компонент загружается только тогда, когда его нужно вывести на экран.
### ▍Пояснения
Ленивая загрузка уменьшает размер материалов приложения, которые приходится загружать пользователю. Это может улучшить скорость загрузки приложения за счёт того, что неиспользуемые модули не передаются с сервера клиентам.
### ▍До
```
// app.routing.ts
{ path: 'not-lazy-loaded', component: NotLazyLoadedComponent }
```
### ▍После
```
// app.routing.ts
{
path: 'lazy-load',
loadChildren: 'lazy-load.module#LazyLoadModule'
}
// lazy-load.module.ts
import { NgModule } from '@angular/core';
import { CommonModule } from '@angular/common';
import { RouterModule } from '@angular/router';
import { LazyLoadComponent } from './lazy-load.component';
@NgModule({
imports: [
CommonModule,
RouterModule.forChild([
{
path: '',
component: LazyLoadComponent
}
])
],
declarations: [
LazyLoadComponent
]
})
export class LazyModule {}
```
9. О подписках внутри других подписок
-------------------------------------
Иногда вам, для выполнения некоего действия, могут понадобиться данные из нескольких наблюдаемых объектов. В подобной ситуации избегайте создания подписок на такие объекты внутри блоков `subscribe` других наблюдаемых объектов. Вместо этого применяйте подходящие операторы для объединения команд в цепочки. Среди таких операторов можно отметить `withLatestFrom` и `combineLatest`. Рассмотрим примеры, после чего прокомментируем их.
### ▍До
```
firstObservable$.pipe(
take(1)
)
.subscribe(firstValue => {
secondObservable$.pipe(
take(1)
)
.subscribe(secondValue => {
console.log(`Combined values are: ${firstValue} & ${secondValue}`);
});
});
```
### ▍После
```
firstObservable$.pipe(
withLatestFrom(secondObservable$),
first()
)
.subscribe(([firstValue, secondValue]) => {
console.log(`Combined values are: ${firstValue} & ${secondValue}`);
});
```
### ▍Пояснения
Если говорить о читабельности, о сложности кода, или о признаках плохого кода, то, когда в программе возможности RxJS в полной мере не используются, это говорит о том, что разработчик недостаточно хорошо знаком с API RxJS. Если затронуть тему производительности, то окажется, что если наблюдаемому объекту нужно некоторое время на инициализацию, то будет осуществлена подписка на `firstObservable`, потом система будет ждать завершения операции, и только после этого начнётся работа со вторым наблюдаемым объектом. Если эти объекты представляют собой сетевые запросы, то выглядеть это будет как синхронное выполнение запросов.
10. О типизации
---------------
Всегда старайтесь объявлять переменные или константы с типом, отличающимся от `any`.
### ▍Пояснения
При объявлении в TypeScript переменной или константы без указания типа тип будет выведен на основании назначаемого ей значения. Это может привести к проблемам. Рассмотрим классический пример поведения системы в подобной ситуации:
```
const x = 1;
const y = 'a';
const z = x + y;
console.log(`Value of z is: ${z}`
// Вывод
Value of z is 1a
```
Предполагается, что `y` здесь является числом, но наша программа об этом не знает, поэтому она выводит нечто такое, что выглядит неправильно, но никаких сообщений об ошибках не выдаёт. Подобных проблем можно избежать, назначая переменным и константам подходящие типы.
Перепишем вышеприведённый пример:
```
const x: number = 1;
const y: number = 'a';
const z: number = x + y;
// Тут появится ошибка компиляции:
Type '"a"' is not assignable to type 'number'.
const y:number
```
Это помогает избежать ошибок, связанных с типами данных.
Ещё одно преимущество систематического подхода к типизации заключается в том, что это упрощает рефакторинг и снижает вероятность ошибок в ходе этого процесса.
Рассмотрим пример:
```
public ngOnInit (): void {
let myFlashObject = {
name: 'My cool name',
age: 'My cool age',
loc: 'My cool location'
}
this.processObject(myFlashObject);
}
public processObject(myObject: any): void {
console.log(`Name: ${myObject.name}`);
console.log(`Age: ${myObject.age}`);
console.log(`Location: ${myObject.loc}`);
}
// Вывод
Name: My cool name
Age: My cool age
Location: My cool location
```
Предположим, что мы хотели поменять, в объекте `myFlashObject`, имя свойства `loc` на `location` и допустили ошибку в ходе редактирования кода:
```
public ngOnInit (): void {
let myFlashObject = {
name: 'My cool name',
age: 'My cool age',
location: 'My cool location'
}
this.processObject(myFlashObject);
}
public processObject(myObject: any): void {
console.log(`Name: ${myObject.name}`);
console.log(`Age: ${myObject.age}`);
console.log(`Location: ${myObject.loc}`);
}
// Вывод
Name: My cool name
Age: My cool age
Location: undefined
```
Если при создании объекта `myFlashObject` не используется типизация, то в нашем случае система полагает, что значением свойства `loc` объекта `myFlashObject` является `undefined`. Она не задумывается о том, что `loc` может представлять собой недопустимое имя свойства.
Если при описании объекта `myFlashObject` применяется типизация, то в подобной ситуации мы увидим, при компиляции кода, замечательное сообщение об ошибке:
```
type FlashObject = {
name: string,
age: string,
location: string
}
public ngOnInit (): void {
let myFlashObject: FlashObject = {
name: 'My cool name',
age: 'My cool age',
// Ошибка компиляции
Type '{ name: string; age: string; loc: string; }' is not assignable to type 'FlashObjectType'.
Object literal may only specify known properties, and 'loc' does not exist in type 'FlashObjectType'.
loc: 'My cool location'
}
this.processObject(myFlashObject);
}
public processObject(myObject: FlashObject): void {
console.log(`Name: ${myObject.name}`);
console.log(`Age: ${myObject.age}`)
// Ошибка компиляции
Property 'loc' does not exist on type 'FlashObjectType'.
console.log(`Location: ${myObject.loc}`);
}
```
Если вы начинаете работу над новым проектом, полезно будет задать, в файле `tsconfig.json`, опцию `strict:true` для того, чтобы включить строгую проверку типов.
11. Об использовании линтера
----------------------------
У [tslint](https://palantir.github.io/tslint/) имеются различные стандартные правила наподобие [no-any](https://palantir.github.io/tslint/rules/no-any), [no-magic-numbers](https://palantir.github.io/tslint/rules/no-magic-numbers), [no-console](https://palantir.github.io/tslint/rules/no-console). Линтер можно настраивать, редактируя файл `tslint.json` для того, чтобы организовать проверку кода по определённым правилам.
### ▍Пояснения
Использование линтера для проверки кода означает, что, если в коде встречается что-то такое, что запрещено правилами, вы получите сообщение об ошибке. Это способствует единообразию кода проекта, улучшает его читабельность. [Здесь](https://palantir.github.io/tslint/rules/) можно ознакомиться с другими правилами tslint.
Надо отметить, что некоторые правила включают в себя и средства исправления того, что в соответствии с ними считается недопустимым. При необходимости можно создавать собственные правила. Если вам это интересно — взгляните на [данный](https://medium.com/@phenomnominal/custom-typescript-lint-rules-with-tsquery-and-tslint-144184b6ff2d) материал, в котором идёт речь о создании собственных правил для линтера с использованием [TSQuery](https://github.com/phenomnomnominal/tsquery).
### ▍До
```
public ngOnInit (): void {
console.log('I am a naughty console log message');
console.warn('I am a naughty console warning message');
console.error('I am a naughty console error message');
}
// Вывод. Никаких сообщений об ошибках, в консоль выводится следующее:
I am a naughty console message
I am a naughty console warning message
I am a naughty console error message
```
### ▍После
```
// tslint.json
{
"rules": {
.......
"no-console": [
true,
"log", // команда console.log запрещена
"warn" // команда console.warn запрещена
]
}
}
// ..component.ts
public ngOnInit (): void {
console.log('I am a naughty console log message');
console.warn('I am a naughty console warning message');
console.error('I am a naughty console error message');
}
// Вывод. Линтер выводит ошибки для команд console.log and console.warn и не сообщает об ошибках применительно к console.error, так как эта команда не упомянута в настройках
Calls to 'console.log' are not allowed.
Calls to 'console.warn' are not allowed.
```
Итоги
-----
Сегодня мы рассмотрели 11 рекомендаций, которые, надеемся, пригодятся Angular-разработчикам. В следующий раз ждите ещё 11 советов.
**Уважаемые читатели!** Пользуетесь ли вы фреймворком Angular для разработки веб-проектов?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/425661/ | null | ru | null |
# Проблемы пакетной обработки запросов и их решения (часть 2)
Это продолжение статьи [«Проблемы пакетной обработки запросов и их решения»](https://habr.com/ru/company/custis/blog/460291). Рекомендуется сначала ознакомиться с первой частью, так как в ней подробно описана суть задачи и некоторые подходы к ее решению. Здесь же мы рассмотрим другие методы.
**Содержание**[Краткое повторение задачи](#Revision)
[Увеличение пакетов](#Enlargement)
[Реверс-инжиниринг](#ReverseEngineering)
[Сбор всех запросов](#RequirementsGathering)
[Параллельность](#Parallelism)
[Проблемы](#Problems)
[Выводы](#Summary1)
[Бизнес-эвристики](#BusinessHeuristics)
[Решение проблемы контракта](#ManagingContractProblem1)
[Поиск полезных ограничений](#UsefulRestrictions)
[Ошибки эвристик](#Mistakes)
[Выводы](#Summary2)
[Агрегаты в стиле DDD](#DDDAgregates)
[Логика укрупнения запросов внутри агрегата](#EnlargementInside)
[Логика укрупнения запросов вне агрегата](#EnlargementOutside)
[Выводы](#Summary3)
[Проксирование и двойной вызов](#Proxying)
[Решение проблемы контракта](#ManagingContractProblem2)
[Выводы](#Summary4)
[Заключение](#Conclusion)
Краткое повторение задачи
-------------------------
Есть чат для согласования документа с предопределенным набором участников. Сообщения содержат текст и файлы. И, как в обычных чатах, сообщения могут быть ответами (reply) и пересылками (forward).
**Модель сообщения чата**`**data class****ChatMessage**(
// nullable так как появляется только после persist
**val**id: **Long**? = **null**,
/\*\* Ссылка на автора \*/
**val**author: **UserReference**,
/\*\* Сообщение \*/
**val**message: **String**,
/\*\* Ссылки на аттачи \*/
// из-за особенностей связки JPA+СУБД проще поддерживать и null, и пустые списки
**val**files: **List**<**FileReference**>? = **null**,
/\*\* Если является ответом, то здесь будет оригинал \*/
**val**replyTo: **ChatMessage**? = **null**,
/\*\* Если является пересылкой, то здесь будет оригинал \*/
**val**forwardFrom: **ChatMessage**? = **null**
)`
**Через Dependency Injection нам доступны реализации следующих внешних сервисов:**`**interface****ChatMessageRepository**{
**fun****findLast**(*n*: **Int**): **List**<**ChatMessage**>
}
**data class****FileHeadRemote**(
**val**id: **FileReference**,
**val**name: **String**
)
**interface****FileRemoteApi**{
**fun****getHeadById**(*id*: **FileReference**): **FileHeadRemote**
**fun****getHeadsByIds**(*id*: **Set**<**FileReference**>): **Set**<**FileHeadRemote**>
**fun****getHeadsByIds**(*id*: **List**<**FileReference**>): **List**<**FileHeadRemote**>
}
**data class****UserRemote**(
**val**id: **UserReference**,
**val**name: **String**
)
**interface****UserRemoteApi**{
**fun****getUserById**(*id*: **UserReference**): **UserRemote**
**fun****getUsersByIds**(*id*: **Set**<**UserReference**>): **Set**<**UserRemote**>
**fun****getUsersByIds**(*id*: **List**<**UserReference**>): **List**<**UserRemote**>
}`
Нам нужно реализовать REST-контроллер:
`**interface****ChatRestApi**{
**fun****getLast**(*n*: **Int**): **List**<**ChatMessageUI**>
}`
**Где:**`/\*\* В таком виде отдаются ссылки на сущности для фронта \*/
**data class****ReferenceUI**(
/\*\* Идентификатор для url \*/
**val**ref: **String**,
/\*\* Видимое пользователю название ссылки \*/
**val**name: **String**
)
**data class****ChatMessageUI**(
**val**id: **Long**,
/\*\* Ссылка на автора \*/
**val**author: **ReferenceUI**,
/\*\* Сообщение \*/
**val**message: **String**,
/\*\* Ссылки на аттачи \*/
**val**files: **List**<**ReferenceUI**>,
/\*\* Если являтся ответом, то здесь будет оригинал \*/
**val**replyTo: **ChatMessageUI**? = **null**,
/\*\* Если являтся пересылкой, то здесь будет оригинал \*/
**val**forwardFrom: **ChatMessageUI**? = **null**
)`
В предыдущей части мы рассмотрели наивную реализацию сервиса, использующего пакетную обработку, и несколько способов ее ускорить. Эти способы очень просты, но их применение не обеспечивает достаточно хорошую производительность.
Увеличение пакетов
------------------
Главной проблемой наивных решений стал маленький размер пакетов.
Для того чтобы вызовы группировать в пакеты большего размера, нужно как-то накапливать запросы. Вот эта строка не подразумевает накопления запросов:
`author = userRepository.getUserById(author).***toFrontReference***(),`
Сейчас у нас в рантайме нет специального места для хранения перечня пользователей — он формируется постепенно. Это придется менять.
Для начала нужно отделить логику получения данных от маппинга в методе ChatMessage.toFrontModel:
`**private fun****ChatMessage**.**toFrontModel**(
*getUser*: (**UserReference**) -> **UserRemote**,
*getFile*: (**FileReference**) -> **FileHeadRemote**,
*serializeMessage*: (**ChatMessage**) -> **ChatMessageUI**
): **ChatMessageUI**=
ChatMessageUI(
id = id ?: **throw**IllegalStateException(**"****$****this****must be persisted"**),
author = *getUser*(author).***toFrontReference***(),
message = message,
files = files?.***let*****{**
**it**.***map***(*getFile*).***map*****{***it*.***toFrontReference***() **}**
**}**?: ***listOf***(),
forwardFrom = forwardFrom?.***let***(*serializeMessage*),
replyTo = replyTo?.***let***(*serializeMessage*)
)`
Получается, что эта функция зависит только от трех внешних функций (а не от целых классов, как было вначале).
После такой переделки тело функции не стало менее понятным, а контракт стал жестче (в этом есть как плюсы, так и минусы).
В действительности можно и не делать такое сужение контракта и оставить зависимости от интерфейсов. Главное, чтобы в них точно не было ничего лишнего, так как нам понадобится делать альтернативные реализации.
Поскольку функция serializeMessage похожа на рекурсивную, на первом шаге рефакторинга это и можно сделать в виде явной рекурсии:
`**class****ChatRestController**(
**private val**messageRepository: **ChatMessageRepository**,
**private val**userRepository: **UserRemoteApi**,
**private val**fileRepository: **FileRemoteApi**
) : **ChatRestApi**{
**override fun****getLast**(*n*: **Int**) =
messageRepository.findLast(*n*)
.***map*****{***it*.***toFrontModel***() **}**`
Я сделал заглушку для метода toFrontModel, которая пока работает ровно так же, как в нашей первой наивной реализации (реализация всех трех внешних функций осталась прежней).
`**private fun****ChatMessage**.**toFrontModel**(): **ChatMessageUI**=
***toFrontModel***(
getUser = userRepository::getUserById,
getFile = fileRepository::getHeadById,
serializeMessage = **{***it*.***toFrontModel***()**}**
)`
Но нам нужно сделать так, чтобы функции getUser, getFile и serializeMessage работали эффективно, то есть слали запросы соответствующим сервисам пакетами нужных размеров (для каждого сервиса теоретически этот размер может быть разным) или вообще по одному запросу в каждый сервис, если разрешены безлимитные запросы.
Проще всего добиться такой группировки, если до начала обработки у нас будут на руках все нужные запросы. Для этого нужно перед вызовом toFrontModel собрать все необходимые ссылки, сделать пакетную обработку и потом уже использовать результат.
Еще можно попробовать схемы с накоплением запросов и постепенным их исполнением. Однако такие схемы потребуют асинхронного выполнения, а мы пока остановимся на синхронных.
Итак, чтобы начать использовать пакетную обработку, так или иначе придется узнать заранее как можно больше запросов (желательно все), которые нам придется сделать. Если речь про REST-контроллер, было бы прекрасно объединить запросы к каждому сервису по всей сессии.
**Группировка всех вызовов**В некоторых ситуациях все данные, которые необходимы в рамках сессии, могут быть получены сразу и не вызовут проблем с ресурсами ни у инициатора запроса, ни у исполнителя. В таком случае мы можем не ограничивать размер пакета для вызова сервиса и получать сразу вообще все данные.
Еще одно допущение, которое сильно облегчает жизнь, — считать, что у инициатора хватит ресурсов на обработку всех данных. Запросы к внешним сервисам можно слать и ограниченными пакетами, если они этого требуют.
Упрощение логики в этом случае касается того, как будут сопоставляться места, где данные нужны, с результатами вызовов. Если считать, что ресурсы инициатора сильно ограничены, и при этом пытаться минимизировать количество внешних вызовов, получится довольно сложная задача на оптимальное разрезание графа. Скорее всего, придется просто пожертвовать производительностью ради уменьшения потребления ресурсов.
Будем считать, что конкретно в нашем демо-проекте инициатор не особо ограничен в ресурсах, может получать все необходимые данные и хранить их до окончания сессии. Если будут проблемы с ресурсами, мы просто сделаем пагинацию поменьше.
Поскольку в моей практике именно такой подход наиболее востребован, дальнейшие примеры будут касаться этого варианта.
Можно выделить такие способы получения больших наборов запросов:
* реверс-инжиниринг;
* бизнес-эвристики;
* агрегаты в стиле DDD;
* проксирование и двойной вызов.
Пройдемся по всем вариантам на примере нашего проекта.
#### Реверс-инжиниринг
**Сбор всех запросов**
Поскольку у нас есть код реализации всех функций, участвующих в сборе информации и ее преобразовании для фронтенда, можно сделать реверс-инжиниринг и из этого кода понять, какие будут запросы:
`**class****ChatRestController**(
**private val**messageRepository: **ChatMessageRepository**,
**private val**userRepository: **UserRemoteApi**,
**private val**fileRepository: **FileRemoteApi**
) : **ChatRestApi**{
**override fun**getLast(*n*: **Int**) =
messageRepository.findLast(*n*)
.***let*****{***messages***->**
// получаем полный список сообщений, включая forward и reply
**val**allMessages = *messages*.***asSequence***().***flatMap*****{**
***sequenceOf***(*it*, *it*.forwardFrom, **it**.replyTo).***filterNotNull***()
**}**.***toSet***()
**val**allUserReq = allMessages.***map*****{****it**.author **}**
**val**allFileReq = allMessages.***flatMap*****{***it*.files ?: ***listOf***() **}**.***toSet***()`
Все запросы собраны, теперь нужно сделать собственно пакетную обработку.
Для allUserReq и allFileReq делаем внешние запросы и группируем их по id. Если ограничений на размер пакета нет, то это будет выглядеть примерно так:
`userRepository.getUsersByIds(allMessages.***map*****{****it**.author **}**.***toSet***())
.***associateBy*****{****it**.id **}**::get
fileRepository.getHeadsByIds(allMessages.***flatMap*****{****it**.files ?: ***listOf***() **}**.***toSet***())
.***associateBy*****{***it*.id **}**::get`
Если ограничение есть, то код примет такой вид:
`**val**userApiChunkLimit = **100**
allMessages.***map*****{****it**.author **}**.***asSequence***().***distinct***()
.***chunked***(userApiChunkLimit, userRepository::getUsersByIds)
.***flatten***()
.***associateBy*****{***it*.id **}**::get`
К сожалению, в отличие от Stream, в Sequence нельзя легко перейти на параллельный запрос пакетов.
Если вы считаете параллельный запрос допустимым и нужным, можно сделать, например, так:
`allMessages.***map*****{***it*.author **}**.parallelStream().distinct()
.***chunked***(**userApiChunkLimit**, userRepository::getUsersByIds)
.***flatten***()
.***associateBy*****{***it*.id **}**::get`
Видно, что особо ничего не изменилось. В этом нам помогло использование некоторого количества Kotlin-магии:
`**fun**<*T*, *R*> **Stream**<**out***T*>.**chunked**(*size*: **Int**, *transform*: (**List**<*T*>) -> *R*): **Stream**<**out***R*> =
***batches***(**this**, *size*).map(*transform*)
**fun**<*T*> **Stream**<**out****Collection**<*T*>>.**flatten**(): **Stream**<*T*> =
flatMap **{***it*.stream() **}**
**fun**<*T*, *K*> **Stream**<*T*>.**associateBy**(*keySelector*: (*T*) -> *K*): **Map**<*K*, *T*> =
collect(**Collectors**.toMap(*keySelector*, **{****it****}**))`
**Теперь осталось собрать все вместе:**`**override fun****getLast**(*n*: **Int**) =
messageRepository.findLast(*n*)
.***let*****{***messages***->**
// получаем полный список сообщений, включая forward и reply
**val**allMessages = *messages*.***asSequence***().***flatMap*****{***message***->**
***sequenceOf***(*message*, *message*.forwardFrom, *message*.replyTo)
.***filterNotNull***()
**}**.***toSet***()
*messages*.***map***(ValueHolder<(**ChatMessage**) -> **ChatMessageUI**>().***apply*****{**
value = ***memoize*****{***message*: **ChatMessage****->**
*message*.***toFrontModel***(
// для этого сервиса есть ограничение размера пакета, но возможны параллельные запросы
getUser = **allMessages**.***map*****{****it**.author **}**.parallelStream().distinct()
.***chunked***(**userApiChunkLimit**, userRepository::getUsersByIds)
.***flatten***()
.***associateBy*****{****it**.id **}**::get.***orThrow*****{**IllegalArgumentException(**"User****$****it"**) **}**,
// для этого сервиса нет ограничений на размер пакета
getFile = fileRepository.getHeadsByIds(**allMessages**.***flatMap*****{***it*.files ?: ***listOf***() **}**.***toSet***())
.***associateBy*****{***it*.id **}**::get.***orThrow*****{**IllegalArgumentException(**"File****$****it"**) **}**,
// рекурсивный вызов этой же функции с мемоизацией
serializeMessage = value
)
**}**
**}**.value)
**}**`
**Пояснения и упрощения**Первое, что наверняка бросится в глаза, — это функция memoize. Дело в том, что функция serializeMessage почти наверняка будет вызываться для одних и тех же сообщений несколько раз (из-за reply и forward). Непонятно, зачем нам делать toFrontModel отдельно для каждого такого сообщения (в некоторых случаях это может быть нужно, но не в нашем). Поэтому можно сделать мемоизацию для функции serializeMessage. Реализуется это, например, так:
`**fun**<*A*, *R*> **memoize**(*func*: (*A*) -> *R*) = *func***as?****Memoize2**?: Memoize2(*func*)
**class****Memoize2**<*A*, *R*>(**val**func: (*A*) -> *R*) : (*A*) -> *R*, java.util.function.**Function**<*A*, *R*> {
**private val**cache = ***hashMapOf***<*A*, *R*>()
**override fun****invoke**(*p1*: *A*) = cache.***getOrPut***(*p1*, **{**func(*p1*) **}**)
**override fun****apply**(*t*: *A*): *R*= invoke(*t*)
}`
Далее нам нужно сконструировать мемоизированную функцию serializeMessage, но при этом у нее внутри будет использоваться она же. Здесь важно использовать внутри именно тот же экземпляр функции, иначе вся мемоизация пойдет псу под хвост. Для разрешения этой коллизии используем класс ValueHolder, который просто хранит ссылку на значение (можно взять вместо него что-то стандартное, например AtomicReference). Чтобы сократить запись для рекурсии, можно сделать так:
`**inline fun**<*A*, *R*> **recursiveMemoize**(**crossinline***func*: (*A*, (*A*) -> *R*) -> *R*): (*A*) -> *R*=
ValueHolder<(*A*) -> *R*>().***apply*****{**
value = ***memoize*****{***a***->****func**(*a*, value) **}**
**}**.value`
Если вы смогли понять этот стрелочный силлогизм с первого раза — поздравляю, вы функциональный программист :-)
Теперь код будет выглядеть следующим образом:
`**override fun****getLast**(*n*: **Int**) =
messageRepository.findLast(*n*)
.***let*****{***messages***->**
// получаем полный список сообщений, включая forward и reply
**val**allMessages = *messages*.***asSequence***().***flatMap*****{***message***->**
***sequenceOf***(*message*, *message*.forwardFrom, *message*.replyTo)
.***filterNotNull***()
**}**.***toSet***()
// для этого сервиса есть ограничение размера пакета, но возможны параллельные запросы
**val**getUser = allMessages.***map*****{****it**.author **}**.parallelStream().distinct()
.***chunked***(**userApiChunkLimit**, userRepository::getUsersByIds)
.***flatten***()
.***associateBy*****{***it*.id **}**::get.***orThrow*****{**IllegalArgumentException(**"User****$***it***"**) **}**
// для этого сервиса нет ограничений на размер пакета
**val**getFile = fileRepository.getHeadsByIds(allMessages.***flatMap*****{****it**.files ?: ***listOf***() **}**.***toSet***())
.***associateBy*****{***it*.id **}**::get.***orThrow*****{**IllegalArgumentException(**"File****$****it"**) **}**
*messages*.***map***(***recursiveMemoize*****{***message*, *memoized*: (**ChatMessage**) -> **ChatMessageUI****->**
*message*.***toFrontModel***(
getUser = getUser,
getFile = getFile,
// рекурсивный вызов этой же функции с мемоизацией
serializeMessage = *memoized*
)
**}**)`
Можно заметить еще orThrow, который определяется так:
`/\*\* Бросает указанный ***[exception]***, если функция возвращает null \*/
**fun**<*P*, *R*> ((*P*) -> *R*?).**orThrow**(*exception*: (*P*) -> **Exception**): (*P*) -> *R*=
**{***p***->**invoke(*p*).***let*****{****it**?: **throw****exception**(*p*) **} }**`
Если во внешних сервисах отсутствуют данные по нашим id и это считается легальной ситуацией, нужно обрабатывать ее как-то по-другому.
После этого исправления ожидается, что время выполнения getLast будет в районе 300 мс. Причем это время вырастет несильно, даже если запросы перестанут укладываться в ограничения на размер пакета (так как пакеты запрашиваются параллельно). Напомню, что наша цель-минимум — 500 мс, а нормальной работой можно будет считать 250 мс.
**Параллельность**
Но нужно двигаться дальше. Обращения к userRepository и fileRepository являются полностью независимыми, и их можно легко распараллелить, в теории приблизившись к 200 мс.
**Например, через нашу функцию join:**`**override fun****getLast**(*n*: **Int**) =
messageRepository.findLast(*n*)
.***let*****{***messages***->**
// получаем полный список сообщений, включая forward и reply
**val**allMessages = *messages*.***asSequence***().***flatMap*****{***message***->**
***sequenceOf***(*message*, *message*.forwardFrom, *message*.replyTo)
.***filterNotNull***()
**}**.***toSet***()
***join***(**{**
// для этого сервиса есть ограничение размера пакета, но возможны параллельные запросы
**allMessages**.***map*****{****it**.author **}**.parallelStream().distinct()
.***chunked***(**userApiChunkLimit**, userRepository::getUsersByIds)
.***flatten***()
.***associateBy*****{***it*.id **}**
**}**, **{**
// для этого сервиса нет ограничений на размер пакета
fileRepository.getHeadsByIds(**allMessages**.***flatMap*****{***it*.files ?: ***listOf***() **}**.***toSet***())
.***associateBy*****{****it**.id **}**
**}**).***let*****{**(users, files) **->**
*messages*.***map***(***recursiveMemoize*****{***message*, *memoized*: (**ChatMessage**) -> **ChatMessageUI****->**
*message*.***toFrontModel***(
getUser = users::get.***orThrow*****{**IllegalArgumentException(**"User****$****it"**) **}**,
getFile = files::get.***orThrow*****{**IllegalArgumentException(**"File****$***it***"**) **}**,
// рекурсивный вызов этой же функции с мемоизацией
serializeMessage = *memoized*
)
**}**)
**}**
**}**`
Как показывает практика, на исполнение затрачивается в районе 200 мс, и очень важно, что с увеличением количества сообщений время особо не растет.
**Проблемы**
В целом код стал, конечно, менее читабельным, чем наша наивная первая версия, но хорошо, что сама сериализация (реализация toFrontModel) почти не изменилась и осталась вполне читабельной. Вся логика хитрой работы с внешними сервисами живет в одном месте.
Минус этого подхода в том, что наша абстракция протекает.
Если нам понадобится внести изменения в toFrontModel, почти наверняка придется вносить изменения и в функцию getLast, что нарушает [принцип подстановки Барбары Лисков](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%BF%D0%BE%D0%B4%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B8_%D0%91%D0%B0%D1%80%D0%B1%D0%B0%D1%80%D1%8B_%D0%9B%D0%B8%D1%81%D0%BA%D0%BE%D0%B2) (Liskov Substitution Principle).
Например, мы договорились расшифровывать приложенные файлы только в основных сообщениях, но не в ответах и пересылках (reply/forward), или только в ответах и пересылках первого уровня. В таком случае после внесения изменений в код toFrontModel придется сделать соответствующие исправления и в коде сбора запросов для файлов. Причем исправление будет нетривиальным:
`fileRepository.getHeadsByIds(
**allMessages**.***flatMap*****{***it*.files ?: ***listOf***() **}**.***toSet***()
)`
И здесь мы плавно подходим к еще одной проблеме, тесно связанной с предыдущей: правильность работы кода в целом зависит от грамотности проведенного реверс-инжиниринга. В некоторых сложных случаях код может сработать неправильно именно из-за некорректной работы сбора запросов. Нет никакой гарантии, что у вас получится быстро придумать юнит-тесты, которые покроют все такие хитрые ситуации.
**Выводы**
Плюсы:
1. Очевидный способ предварительного получения запросов, который легко отделяется от основного кода.
2. Почти полное отсутствие накладных расходов памяти и времени, связанное с использованием только тех данных, которые все равно были бы получены.
3. Хорошее масштабирование и возможность построить сервис, который в теории будет отвечать за предсказуемое время вне зависимости от размера запроса извне.
Минусы:
1. Довольно сложный код самой пакетной обработки.
2. Большая и ответственная работа по анализу запросов в существующей реализации.
3. Протекающая абстракция и, как следствие, хрупкость всей схемы по отношению к изменениям в реализации.
4. Сложности в поддержке: ошибки в блоке предсказания запросов трудно отличить от ошибок в основном коде. В идеале нужно применять в два раза больше юнит-тестов, поэтому и разбирательства с ошибками в продакшене будут в два раза сложнее.
5. Соблюдение принципов SOLID при написании кода: код должен быть готов к отчуждению логики пакетной обработки. Само по себе внедрение этих принципов даст некоторые преимущества, так что данный минус самый несущественный.
Важно отметить, что использовать этот метод можно и не делая реверс-инжиниринга как такового. Нам нужно получить контракт getLast, от которого зависит контракт предварительного расчета запросов (далее — prefetch). В данном случае мы сделали это, рассмотрев реализацию getLast (реверс-инжиниринг). Однако при таком подходе возникают сложности: правка этих двух кусков кода всегда должна быть синхронной, а обеспечить это никак невозможно (вспомните hashCode и equals, там ровно то же самое). Следующий подход, который я хотел бы показать, как раз призван решить эту проблему (или хотя бы смягчить).
#### Бизнес-эвристики
**Решение проблемы контракта**
Что если оперировать не точным контрактом и, следовательно, точным набором запросов, а примерным? Причем мы построим примерный набор так, что он будет строго включать точный и базироваться на особенностях предметной области.
Таким образом, вместо зависимости контракта prefetch от getLast установим зависимость их обоих от какого-то общего контракта, который будет диктоваться пользователем. Основная сложность будет в том, чтобы как-то овеществить этот общий контракт в виде кода.
**Поиск полезных ограничений**
Давайте попробуем сделать это на нашем примере.
В нашем случае есть следующие бизнес-особенности:
* список участников чата предопределен;
* чаты абсолютно изолированы друг от друга;
* вложенность цепочек reply/forward небольшая (~2–3 сообщения).
Из первого ограничения следует, что не нужно бегать по сообщениям, смотреть, какие там есть пользователи, выбирать уникальных и по ним делать запрос. Можно просто сделать запрос по предопределенному списку. Если вы согласились с этим утверждением, значит, я вас поймал.
На самом деле все не так просто. Список может быть предопределен, но в нем могут быть тысячи пользователей. Такие вещи необходимо уточнять. В нашем случае участников чата, как правило, будет два — три, редко больше. Так что вполне допустимо получать данные по ним всем.
Далее, если список пользователей чата предопределен, но этой информации нет в сервисе пользователей (что очень вероятно), то толку от такой информации тоже не будет. Мы сделаем лишний запрос списка пользователей чата, а потом все равно придется делать запрос(-ы) к сервису пользователей.
Допустим, что информация о связи пользователей и чата хранится в сервисе пользователей. В нашем случае это так, поскольку связь определяется правами пользователя. Тогда для пользователей получится такой prefetch-код:
Здесь может показаться удивительным то, что мы не передаем никакого идентификатора чата. Я сделал это намеренно, чтобы не загромождать код примеров.
Из второго ограничения, на первый взгляд, ничего не следует. Во всяком случае, у меня так и не получилось вывести из него что-то полезное.
Третье ограничение мы уже использовали ранее. Оно может оказать существенное влияние на то, как мы будем хранить и получать цепочки сообщений. Не станем развивать эту тему, так как к REST-контроллеру и пакетной обработке это не имеет отношения.
Что же делать с файлами? Очень хочется получить список всех файлов чата одним простым запросом. По условиям API нам нужны только заголовки файлов, без тел, так что это не выглядит ресурсоемкой и опасной задачей для вызывающей стороны.
С другой стороны, нужно помнить, что мы получаем не все сообщения чата, а только последние N, и легко может оказаться, что они не содержат вообще никаких файлов.
Здесь не может быть универсального ответа: все сильно зависит от бизнес-специфики и вариантов использования. При создании продуктового решения можно попасть впросак, если заложить эвристику под один вариант использования, а потом пользователи будут работать с функционалом другим способом. Для демонстраций и пресейлов это хороший вариант, но сейчас мы пытаемся написать честный продакшен-сервис.
Так что, увы, делать для файлов бизнес-эвристику здесь можно будет только по итогам эксплуатации и сбора статистики (либо после экспертной оценки).
Поскольку хочется все-таки как-то применить наш метод, допустим, что статистика показала следующее:
1. Типичная цепочка начинается с сообщения, включающего один или несколько файлов, за которым следуют ответные сообщения (reply) без файлов.
2. Почти все сообщения входят в типичные цепочки.
3. Ожидаемое количество уникальных файлов в рамках одного чата ~20.
Отсюда следует, что для отображения почти всех сообщений понадобится получить заголовки каких-то файлов (потому что так устроен ChatMessageUI) и что общее количество файлов невелико. В таком случае разумным выглядит получение всех файлов чата одним запросом. Для этого в наш API для файлов придется добавить следующее:
`**fun****getHeadsByChat**(): **List**<**FileHeadRemote**>`
Метод getHeadsByChat не выглядит надуманным и сделанным чисто из-за нашего желания оптимизировать производительность (хотя это тоже вполне себе обоснование). Довольно часто в чатах с файлами пользователи хотят увидеть все использованные файлы, причем в порядке их добавления (поэтому используем List).
Реализация такой явной связи потребует хранения дополнительной информации в файловом сервисе или в нашем приложении. Все зависит от того, в чьей зоне ответственности, как мы считаем, должна храниться эта избыточная информация о связи файла с чатом. Избыточная она потому, что с файлом уже связано сообщение, а оно в свою очередь связано с чатом. Можно не использовать денормализацию, а извлекать эту информацию на лету из сообщений, то есть внутри SQL получать сразу все файлы по всему чату (это в нашем приложении) и запрашивать их все сразу у файлового сервиса. Такой вариант будет работать похуже, если сообщений в чате окажется много, но зато нам не понадобится денормализация. Я бы оба варианта скрыл за getHeadsByChat.
Код получился такой:
`**override fun**getLast(*n*: **Int**) =
messageRepository.findLast(*n*)
.***let*****{***messages***->**
***join***(
**{**userRepository.getUsersByChat().***associateBy*****{***it*.id **} }**,
**{**fileRepository.getHeadsByChat().***associateBy*****{****it**.id **} }**
)
.***let*****{**// здесь ничего не изменилось
**}**
**}**`
Видно, что по сравнению с предыдущим вариантом изменилось очень мало и изменения коснулись только части с prefetch, что замечательно.
Код prefetch стал намного короче и понятнее.
Время исполнения не изменилось, что логично, так как количество запросов осталось прежним. Теоретически возможны случаи, когда масштабирование будет лучше, чем у честного реверс-инжиниринга (только за счет убирания звена сложного расчета). Однако в равной степени вероятны противоположные ситуации: эвристики гребут слишком много лишнего. Как показывает практика, если удается придумать адекватные эвристики, то особых перемен во времени исполнения быть не должно.
Однако это еще не все. Мы не учли, что теперь получение детальных данных по пользователям и файлам не связано с получением сообщений и запросы можно запустить параллельно:
Такой вариант дает стабильные 100 мс на запрос.
**Ошибки эвристик**
Что если при использовании эвристик набор запросов окажется не больше, а чуть меньше, чем должен быть? Для большинства вариантов такие эвристики подойдут, но будут исключения, ради которых придется делать отдельный запрос. В моей практике такого рода решения оказывались неудачными, так как каждое исключение сильно сказывалось на производительности, и в конце концов какой-то пользователь делал запрос, полностью состоящий из исключений. Я бы сказал, что в таких ситуациях лучше использовать реверс-инжиниринг, даже если алгоритм сбора запросов получается жуткий и нечитаемый, но, конечно, все зависит от критичности сервиса.
**Выводы**
Плюсы:
1. Логика бизнес-эвристик легко читается и обычно тривиальна. Это хорошо для того, чтобы понять границы применимости, верифицировать и изменять контракт prefetch.
2. Масштабируемость такая же хорошая, как у реверс-инжиниринга.
3. Уменьшается связность кода по данным, что может привести к лучшей параллелизации кода.
4. Логика prefetch, как и основная логика REST-контроллера, базируется на требованиях. Это слабый плюс, если требования часто меняются.
Минусы:
1. Из требований не так легко вывести эвристики для предсказаний запросов. Могут понадобиться уточнения требований, причем до такой степени, которая плохо совместима с agile.
2. Можно получить лишние данные.
3. Для обеспечения эффективной работы контракта prefetch, вероятно, понадобится денормализация хранения данных. Это слабый минус, так как эти оптимизации следуют из бизнес-логики и потому, скорее всего, будут востребованы разными процессами.
Из нашего примера можно сделать вывод, что применить данный подход очень сложно и овчинка не стоит выделки. На самом деле в реальных бизнес-проектах количество ограничений огромно и из этой кучи часто удается достать что-то полезное, что позволяет партиционировать данные или предсказывать статистику. Главный плюс этого подхода в том, что используемые ограничения трактуются бизнесом, поэтому они легко понимаются и валидируются.
Обычно самой большой проблемой при попытке использовать этот подход оказывается разделение деятельности. Разработчик должен хорошо погрузиться в бизнес-логику и задавать уточняющие вопросы аналитику, что требует определенного уровня инициативности.
#### Агрегаты в стиле DDD
В больших проектах часто можно увидеть использование практик DDD, поскольку они позволяют эффективно структурировать код. Не обязательно использовать в проекте все шаблоны DDD — иногда можно получить хорошую отдачу даже от внедрения одного. Рассмотрим такое понятие DDD, как агрегат. Агрегатом называют объединение логически связанных сущностей, работа с которыми осуществляется только через корень агрегата (обычно это сущность, которая является вершиной графа связности сущностей).
С точки зрения получения данных главное в агрегате то, что вся логика работы со списками сущностей находится в одном месте — агрегате. Есть два подхода к тому, что следует передавать в агрегат при его конструировании:
1. Передаем в агрегат функции для получения внешних данных. Логика определения необходимых данных живет внутри агрегата.
2. Передаем все необходимые данные. Логика определения необходимых данных живет вне агрегата.
Выбор подхода во многом зависит от того, насколько легко можно вынести prefetch за рамки агрегата. Если логика prefetch базируется на бизнес-эвристиках, то обычно ее несложно отделить от агрегата. Выносить за рамки агрегата логику, основанную на анализе его использования (реверс-инжиниринг), может оказаться опасным, так как мы разносим логически связанный код по разным классам.
**Логика укрупнения запросов внутри агрегата**
Попробуем набросать агрегат, который бы соответствовал понятию «чат». Наши классы ChatMessage, UserReference, FileReference соответствуют модели хранения, поэтому их можно было бы переименовать с каким-то соответствующим префиксом, но у нас проект маленький, поэтому оставим как есть. Агрегат назовем Chat, а его составляющие — ChatPage и ChatPageMessage:
`**interface****Chat**{
**fun****getLastPage**(*n*: **Int**): **ChatPage**
}
**interface****ChatPage**{
**val**messages: **List**<**ChatPageMessage**>
}
**data class****ChatPageMessage**(
**val**id: **Long**,
**val**author: **UserRemote**,
**val**message: **String**,
**val**files: **List**<**FileHeadRemote**>,
**val**replyTo: **ChatPageMessage**?,
**val**forwardFrom: **ChatPageMessage**?
)`
Пока что получается довольно много бессмысленного дублирования. Это связано с тем, что наша предметная модель похожа на модель хранения и они обе похожи на модель для фронтенда.
Я использую классы FileHeadRemote и UserRemote напрямую, чтобы не писать лишнего кода, хотя обычно в домене стоит избегать прямого использования таких классов.
Если использовать такой агрегат, наш REST-контроллер можно переписать так:
`**class****ChatRestController**(
**private val**chat: **Chat**
) : **ChatRestApi**{
**override fun****getLast**(*n*: **Int**) =
chat.getLastPage(*n*).***toFrontModel***()
**private fun****ChatPage**.**toFrontModel**() =
messages.***map*****{****it**.***toFrontModel***() **}**
**private fun****ChatPageMessage**.**toFrontModel**(): **ChatMessageUI**=
ChatMessageUI(
id = id,
author = author.***toFrontReference***(),
message = message,
files = files.***toFrontReference***(),
forwardFrom = forwardFrom?.***toFrontModel***(),
replyTo = replyTo?.***toFrontModel***()
)
}`
Этот вариант во многом напоминает нашу первую наивную реализацию, но при этом имеет важное преимущество: контроллер больше не занимается получением данных напрямую и не зависит от классов, связанных с хранением данных, а зависит только от агрегата, который задан через интерфейсы. Таким образом, и логики prefetch больше нет в контроллере. Контроллер занимается только преобразованием агрегата в модель фронтенда, что дает нам соблюдение принципа единственной ответственности (Single Responsibility Principle, SRP).
К сожалению, для всех описанных в агрегате методов придется написать реализацию.
**Попробуем просто сохранить логику контроллера, реализованную при использовании бизнес-эвристик.**`**class****ChatImpl**(
**private val**messageRepository: **ChatMessageRepository**,
**private val**userRepository: **UserRemoteApi**,
**private val**fileRepository: **FileRemoteApi**
) : **Chat**{
**override fun****getLastPage**(*n*: **Int**) = **object**: **ChatPage**{
**override val**messages: **List**<**ChatPageMessage**>
**get**() =
***runBlocking***(**IO**) **{**
**val**prefetch = ***async***(
**{**userRepository.getUsersByChat().***associateBy*****{****it**.id **} }**,
**{**fileRepository.getHeadsByChat().***associateBy*****{***it*.id **} }**
)
***withContext***(**IO**) **{**messageRepository.findLast(**n**) **}**
.***map***(
prefetch.await().***let*****{**(users, files) **->**
***recursiveMemoize*****{***message*, *memoized*: (**ChatMessage**) -> **ChatPageMessage****->**
*message*.***toDomainModel***(
getUser = users::get.***orThrow*****{**IllegalArgumentException(**"User****$***it***"**) **}**,
getFile = files::get.***orThrow*****{**IllegalArgumentException(**"File****$***it***"**) **}**,
// рекурсивный вызов этой же функции с мемоизацией
serializeMessage = *memoized*
)
**}**
**}**
)
**}**
}
}
**private fun****ChatMessage**.**toDomainModel**(
*getUser*: (**UserReference**) -> **UserRemote**,
*getFile*: (**FileReference**) -> **FileHeadRemote**,
*serializeMessage*: (**ChatMessage**) -> **ChatPageMessage**
) = ChatPageMessage(
id = id ?: **throw**IllegalStateException(**"****$****this****must be persisted"**),
author = *getUser*(author),
message = message,
files = files?.***map***(*getFile*) ?: ***listOf***(),
forwardFrom = forwardFrom?.***let***(*serializeMessage*),
replyTo = replyTo?.***let***(*serializeMessage*)
)`
Здесь получилось, что в самой функции getLastPage живет стратегия получения данных, включая prefetch, а функция toDomainModel чисто техническая и отвечает за преобразование хранимых моделей в модель предметной области.
Параллельные вызовы userRepository, fileRepository и messageRepository я переписал в более привычном для Kotlin виде. Надеюсь, что понятность кода из-за этого не пострадала.
В целом такой метод уже вполне работоспособен, производительность при его применении будет такой же, как при простом использовании реверс-инжиниринга или бизнес-эвристик.
**Логика укрупнения запросов вне агрегата**
В процессе создания агрегата мы сразу же столкнемся с проблемой: для конструирования ChatPage размер страницы нужно будет задавать как константу при создании Chat, а не передавать его в getLast(), как обычно. Придется поменять сам интерфейс агрегата:
`**interface****Chat**{
**fun****getPage**(): **ChatPage**
}`
Поскольку у нас есть дочитка остальных сообщений и мы твердо хотим получать все данные за рамками агрегата, нам придется вообще отказаться от агрегата уровня Chat и сделать корнем ChatPage:
`**class****ChatPageImpl**(
**private val**messageData: **List**<**ChatMessage**>,
**private val**userData: **List**<**UserRemote**>,
**private val**fileData: **List**<**FileHeadRemote**>
) : **ChatPage**{
**override val**messages: **List**<**ChatPageMessage**>
**get**() =
messageData.***map***(
(userData.***associateBy*****{****it**.id **}*****to***fileData.***associateBy*****{***it*.id **}**)
.***let*****{**(users, files) **->**
***recursiveMemoize*****{***message*, *self*: (**ChatMessage**) -> **ChatPageMessage****->**
*message*.***toDomainModel***(
getUser = users::get.***orThrow***(),
getFile = files::get.***orThrow***(),
// рекурсивный вызов этой же функции с мемоизацией
serializeMessage = *self*
)
**}**
**}**
)
}`
Далее необходимо создать код prefetch, отдельный от агрегата:
`**fun****chatPagePrefetch**(
*pageSize*: **Int**,
*messageRepository*: **ChatMessageRepository**,
*userRepository*: **UserRemoteApi**,
*fileRepository*: **FileRemoteApi**
) =
***runBlocking***(**IO**) **{**
***async***(
**{****userRepository**.getUsersByChat() **}**,
**{****fileRepository**.getHeadsByChat() **}**,
**{****messageRepository**.findLast(**pageSize**) **}**
)
**}**`
Теперь для того, чтобы создать агрегат, нужно его состыковать с prefetch. В DDD такого рода оркестрациями занимаются Application Services.
`**class****ChatService**(
**private val**messageRepository: **ChatMessageRepository**,
**private val**userRepository: **UserRemoteApi**,
**private val**fileRepository: **FileRemoteApi**
) {
**private fun****chatPagePrefetch**(*pageSize*: **Int**) =
***runBlocking***(**IO**) **{**
***async***(
**{**messageRepository.findLast(**pageSize**) **}**,
**{**userRepository.getUsersByChat() **}**,
**{**fileRepository.getHeadsByChat() **}**
).await()
**}**
**fun****getLastPage**(*n*: **Int**): **ChatPage**=
chatPagePrefetch(*n*)
.***let*****{**(messageData, userData, fileData) **->**
ChatPageImpl(messageData, userData, fileData)
**}**
}`
Ну а контроллер особо не изменится, нужно только вместо Chat::getLastPage использовать ChatService::getLastPage. То есть код изменится так:
`**class**ChatRestController(
**private val**chat: **ChatService**
) : **ChatRestApi**`
**Выводы**
1. Логику prefetch можно поместить как внутрь агрегата, так и в отдельное место.
2. Если логика prefetch сильно связана с внутренней логикой агрегата, лучше не выносить ее наружу, так как это может нарушить инкапсуляцию. Я лично не вижу особого смысла выносить prefetch за пределы агрегата, поскольку это сильно ограничивает возможности и увеличивает неявную связность кода.
3. На производительность пакетной обработки сама по себе организация агрегатов влияет положительно, так как контроля над тяжелыми запросами становится больше и место для логики prefetch становится вполне определенным.
В следующей главе мы рассмотрим такой вариант реализации prefetch, который невозможно реализовать в отрыве от основной функции.
#### Проксирование и двойной вызов
**Решение проблемы контракта**
Как мы уже разобрались в предыдущих частях, основная проблема контракта prefetch в том, что он сильно связан с контрактом функции, для которой он должен подготовить данные. Если быть более точным, то он зависит от того, какие данные могут понадобиться основной функции. Что если мы не будем пытаться предсказывать, а попробуем сделать реверс-инжиниринг средствами самого кода? В простых ситуациях нам может помочь подход проксирования, широко используемый в тестировании. Такие библиотеки, как Mockito, генерируют классы с имплементаций интерфейсов, которые могут в том числе накапливать информацию о вызовах. [Похожий подход используется в нашей библиотеке](https://habr.com/ru/company/custis/blog/243803/).
Если вызвать основную функцию с проксированными репозиториями и собрать информацию о необходимых данных, то потом можно будет эти данные получить в виде пакета и повторно вызвать основную функцию для получения финального результата.
Основное условие следующее: запрашиваемые данные не должны влиять на последующие запросы. Прокси будет возвращать не реальные данные, а только какие-то заглушки, поэтому все ветвления и получения связанных данных отпадают.
В нашем случае это означает, что бесполезно проксировать messageRepository, поскольку по результатам запроса сообщений и делаются дальнейшие запросы. Это не проблема, так как к messageRepository у нас всего один запрос, так что никакой пакетной обработки здесь и не требуется.
Поскольку проксировать мы будем простые функции UserReference->UserRemote и FileReference->FileHeadRemote, то накапливать нужно просто два списка аргументов.
**В итоге получаем следующее:**`**class****ChatRestController**(
**private val**messageRepository: **ChatMessageRepository**,
**private val**userRepository: **UserRemoteApi**,
**private val**fileRepository: **FileRemoteApi**
) : **ChatRestApi**{
**override fun****getLast**(*n*: **Int**): **List**<**ChatMessageUI**> {
**val**messages = messageRepository.findLast(*n*)
// функция получения списка сообщений
**fun****transform**(
*getUser*: (**UserReference**) -> **UserRemote**,
*getFile*: (**FileReference**) -> **FileHeadRemote**
): **List**<**ChatMessageUI**> =
**messages**.***map***(
***recursiveMemoize*****{***message*, *self***->**
*message*.***toFrontModel***(*getUser*, *getFile*, *self*)
**}**
)
// накапливаем запросы
**val**userIds = ***mutableSetOf***<**UserReference**>()
**val**fileIds = ***mutableSetOf***<**FileReference**>()
transform(
**{****userIds**+= **it**; UserRemote(**0L**, **""**) **}**,
**{****fileIds**+= *it*; FileHeadRemote(**0L**, **""**) **}**
)
**return*****runBlocking***(**IO**) **{**
// получаем данные по всем запросам сразу
***async***(
**{**userRepository.getUsersByIds(**userIds**).***associateBy*****{***it*.id **}**::get.***orThrow***() **}**,
**{**fileRepository.getHeadsByIds(**fileIds**).***associateBy*****{***it*.id **}**::get.***orThrow***() **}**
).await().***let*****{**(getUser, getFile) **->**
transform(getUser, getFile)
**}**
**}**
}
}`
Если измерить производительность, получится, что при данном подходе она не хуже, чем при использовании методов реверс-инжиниринга, хотя мы вызываем функцию два раза. Это связано с тем, что по сравнению со временем выполнения внешних запросов, временем выполнения функции преобразования можно пренебречь (в нашем случае).
Если сравнивать с производительностью при использовании бизнес-эвристик, то в нашем случае накопление запросов окажется менее эффективным. Но нужно учитывать, что не всегда удается найти такие хорошие эвристики. Например, если количество пользователей в чате будет большим, как и количество файлов, и при этом файлы будут прикрепляться к сообщениям редко, то наш алгоритм на бизнес-эвристиках сразу же начнет проигрывать честному получению списку запросов.
**Выводы**
Плюсы:
1. Для реализации prefetch не нужен реверс-инжиниринг кода получения данных.
2. В большинстве случаев изменения основной функции не повлияют на prefetch.
3. Масштабируемость такая же хорошая, как у реверс-инжиниринга.
Минусы:
1. Требуется независимость следующих запросов от результатов предыдущих.
2. Редко используется, поэтому логика не так очевидна.
Несмотря на кажущуюся экзотичность, накопление запросов через проксирование и повторный вызов вполне применимо в ситуациях, когда логика основной функции не завязана на получаемые данные. Основная сложность здесь такая же, как при реверс-инжиниринге: мы закладываемся на текущую реализацию функции, хотя и в гораздо меньшей степени (только на тот факт, что следующие запросы не зависят от результатов предыдущих запросов).
Производительность упадет незначительно, зато в коде prefetch не нужно будет учитывать всех нюансов реализации основной функции.
Можно использовать такой подход, когда не получается построить хороших бизнес-эвристик для предсказания запросов, а связность prefetch и функции хочется уменьшить.
Заключение
----------
Использование пакетной обработки не так просто, как кажется на первый взгляд. Думаю, все шаблоны проектирования обладают этим свойством (вспомните кэширование).
Для эффективной пакетной обработки запросов вызывающей стороне важно собрать вместе как можно больше запросов, что часто затрудняется структурой приложения. Выхода два: либо проектировать приложение в расчете на эффективную работу с данными (очень может быть, что это приведет к реактивному устройству приложения), либо, как это часто бывает, пытаться внедрить пакетную обработку в существующее приложение без значительной его перестройки.
Самый очевидный способ собрать запросы в кучу — это реверс-инжиниринг существующего кода в поисках тяжелых запросов. Главным недостатком этого подхода будет увеличение неявной связности кода. Альтернатива — задействовать информацию о бизнес-особенностях для того, чтобы разделить данные на порции, которые часто используются совместно и целиком. Иногда для такого эффективного разделения придется денормализовать хранение, но зато, если такое получится осуществить, логика пакетной обработки будет определятся предметной областью, что хорошо.
Менее очевидный способ получить все запросы — реализовать два прохода. На первом этапе собираем все необходимые запросы, на втором работаем с уже полученными данными. Применимость такого подхода ограничена требованием независимости запросов друг от друга. | https://habr.com/ru/post/467919/ | null | ru | null |
# Lombok. Полное руководство
Здесь изложен необходимый минимум информации, которую нужно изучить, если хочешь приступить к использованию проекта Lombok. Рассмотрим, как интегрировать его в вашу IDE и использовать, чтобы сократить объем шаблонного кода.
Java – отличный язык, только многословный. Возможно, вам придется писать много кода, чтобы достичь даже самых простых целей. Кроме того, в Java определенно присутствует повторяющийся код, например, геттеры и сеттеры. Поэтому у вас получаются огромные объемы повторяющегося и необязательного кода. Мало того, что такой код не добавляет ничего нового в бизнес-логику вашего приложения, так и писать его долго и скучно. Именно поэтому следует переходить к использованию библиотек и инструментов – они помогают повысить продуктивность и избежать этой рутины. Именно здесь в игру вступает Lombok!
Это библиотека Java, в которой предоставляется ряд аннотаций, направленных на исключение именно того кода Java, о котором известно, что он часто становится повторяющимся и/или шаблонным. Проект Lombok включается прямо в процесс сборки. Затем Lombok автоматически сгенерирует для Java байт-код, который вставляет в файлы *.class*, необходимые для реализации желаемого поведения, в зависимости от используемых вами аннотаций. Следовательно, каждая аннотация, предлагаемая в проекте Lombok, позволяет частично обойтись без написания методов и логики, без которых вы хотели бы обойтись. Речь о конструкторах, равенствах и функциях хеш-кода. Так вы сможете сэкономить массу времени и сосредоточиться на бизнес-логике вашего проекта. Кроме того, вы сможете держать базу кода сравнительно компактной, чистой, удобной для чтения и поддержки.
Сначала рассмотрим, что представляет собой проект Lombok и как он работает. Затем изучим наиболее распространенные и актуальные аннотации Lombok, разберемся, какие из них наиболее важные, где и как их использовать. Далее рассмотрим, как интегрировать их в вашу IDE ([интегрированную среду разработки](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D1%80%D0%B5%D0%B4%D0%B0_%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B8)) и почему не стоит опасаться их использовать.
Предпосылки
-----------
Вот что вам нужно установить, чтобы воспроизвести все примеры, приведенные ниже:
* Java >= 1.8
* Gradle >= 4.x or Maven 3.6.x
* Project Lombok >= 1.18.20
Что такое Lombok
----------------
[Проект Lombok](https://projectlombok.org/) (далее – просто *Lombok*) – это основанная на аннотациях библиотека Java, позволяющая сократить шаблонный код. В Lombok предлагаются различные аннотации, цель которых – заменить ненужный повторяющийся код, писать который утомительно. Например, Lombok избавит вас от написания безаргументных конструкторов, методов toString(), equals() и hashCode(), для этого нужно просто добавить несколько аннотаций. Плюс, как будет показано ниже, эта библиотека подключается прямо к вашей IDE, поэтому работа воспринимается так, словно вы написали весь шаблонный код сами.
Установить Lombok легко – добавьте `lombok` к вашим зависимостям. Если вы пользуетесь [Gradle](https://projectlombok.org/setup/gradle), допишите следующие две строки с зависимостями в ваш файл `build`.`gradle`:
```
compileOnly 'org.projectlombok:lombok:1.18.20'
annotationProcessor 'org.projectlombok:lombok:1.18.20'
```
Тогда как если работаете с [Maven](https://projectlombok.org/setup/maven), добавьте следующую зависимость в ваш файл `pom`.`xml`:
```
org.projectlombok
lombok
1.18.20
provided
```
Кроме того, добавьте зависимость Lombok в конфигурационный раздел `maven-compiler-plugin` следующим образом:
```
org.apache.maven.plugins
maven-compiler-plugin
3.5.1
11
11
org.projectlombok
lombok
1.18.20
```
Теперь вы настроили все необходимое, чтобы приступить к работе с Lombok.
Наиболее распространенные аннотации Lombok
------------------------------------------
Ниже перечислены самые распространенные и важные аннотации Lombok. Каждая из них будет объяснена и рассмотрена на практике в сравнении с эквивалентным «переводом» на обычный язык Java. Чтобы посмотреть примеры и получить дополнительную поддержку, можно щелкнуть по любой аннотации и посетить посвященную ей страницу на сайте с [официальной документацией по Lombok](https://projectlombok.org/features/all).
#### @Getter, @Setter
Когда после аннотировано `@Getter` и/или `@Setter`, Lombok автоматически сгенерирует заданный по умолчанию геттер и/или сеттер, соответственно. Заданная по умолчанию реализация геттеров просто берет на себя возврат аннотированного поля. Аналогично, заданная по умолчанию реализация сеттеров принимает один параметр того же типа, что и аннотированное поле, и просто устанавливает его в полученное значение. Когда поле под названием `value` аннотируется одновременно `@Getter` и `@Setter`, Lombok определит метод getValue() (или isValue(), если это поле типа `boolean`) и setValue(). Сгенерированный метод, действующий как геттер и сеттер, будет публичным (public), если не указан конкретный уровень доступа (`AccessLevel`). Допустимые значения `AccessLevel` – это PUBLIC, PROTECTED, PACKAGE и PRIVATE. Обратите внимание: можно аннотировать и целый класс. В таком случае данная логика будет применяться к каждому из его полей.
**С Lombok**
```
@Getter
@Setter
public class Author {
private int id;
private String name;
@Setter(AccessLevel.PROTECTED)
private String surname;
}
```
**Просто Java**
```
public class User {
private int id;
private String name;
private String surname;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSurname() {
return surname;
}
protected void setSurname(String surname) {
this.surname = surname;
}
}
```
#### @NoArgsConstructor, @RequiredArgsConstructor, @AllArgsConstructor
Когда класс аннотирован `@NoArgsConstructor`, Lombok возьмет на себя автоматическую генерацию непараметризованного конструктора. Аналогично, когда класс аннотирован `@AllArgsConstructor`, будет сгенерирован конструктор с одним параметром для каждого поля вашего класса. Далее, `@RequiredArgsConstructor` позволит получить конструктор с параметром для каждого поля, но эти параметры потребуют специальной обработки. В частности, здесь мы будем работать с неинициализированными полями `final`, а также с любыми полями, помеченными как `@NonNull`, которые не инициализируются при объявлении. Пожалуйста, не забудьте, что статические поля будут этими аннотациями игнорироваться.
**С Lombok**
```
@NoArgsConstructor
@AllArgsConstructor
@RequiredArgsConstructor
public class Author {
private int id;
private String name;
private String surname;
private final String birthPlace;
}
```
**Просто Java**
```
public class Author {
private int id;
private String name;
private String surname;
private final String birthPlace;
// @NoArgsConstructor
public Author() {}
// @AllArgsConstructor
public Author(int id, String name, String surname, String birthPlace) {
this.id = id
this.name = name
this.surname = surname
this.birthPlace = birthPlace
}
// @RequiredArgsConstructor
public Author(String birthPlace) {
this.birthPlace = birthPlace
}
}
```
#### @ToString
Когда класс аннотирован `@ToString`, Lombok позаботится о том, чтобы сгенерировать нужную реализацию метода toString(). По умолчанию будет возвращаться строка, в которой содержится имя класса, за которой следуют значения всех полей, разделенные запятыми. Устанавливая параметр `includeFieldNames` в значение *true*, добьемся того, что имя каждого поля будет ставиться перед его значением. По умолчанию при генерировании метода toString() будут учитываться все нестатические поля. Если мы хотим, чтобы Lombok проигнорировал поле, нужно аннотировать его `@ToString`.`Exclude`. Как вариант, можете сами указать, какие поля на ваше усмотрение должны аннотироваться, для этого воспользуйтесь `@`ToString(`onlyExplicitlyIncluded`=true). Затем пометьте при помощи `@ToString`.`Include` каждое поле, которое хотите включить.
**С Lombok**
```
@ToString(includeFieldNames=true)
public class Author {
private int id;
private String name;
private String surname;
}
```
**Просто Java**
```
public class Author {
private int id;
private String name;
private String surname;
@Override
public String toString() {
return "Author(id=" + this.id + ", name=" + this.name + ", surnname=" + this.surname + ")";
}
}
```
#### @EqualsAndHashCode
Если аннотировать класс при помощи `@EqualsAndHashCode`, то Lombok автоматически реализует за вас методы equals() и hashCode(). По умолчанию будут учитываться все нестатические непереходные поля. Можно повлиять на то, какие поля будут использоваться, аннотировав их `@EqualsAndHashCode`.`Include` или `@EqualsAndHashCode`.`Exclude`. Как вариант, можете аннотировать ваш класс при помощи `@`EqualsAndHashCode(`onlyExplicitlyIncluded`=true), а затем в точности указать, какие поля или методы вы хотите использовать, пометив их `@EqualsAndHashCode`.`Include`. Обратите внимание: Lombok сгенерирует методы [equals()](https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Object) и [hashCode()](https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#hashCode(), не нарушая контракта между ними. Перейдите по ссылкам о двух этих методах на сайт с официальной документацией Java и почитайте подробнее о тех контрактах, которым должны удовлетворять реализации equals() и hashCode().
**С Lombok**
```
@Getter
@Setter
@EqualsAndHashCode
public class Author {
private int id;
private String name;
private String surname;
}
```
**Просто Java**
```
public class Author {
// геттеры и сеттеры ...
@Override
public int hashCode() {
final int PRIME = 31;
int result = 1;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((surname == null) ? 0 : surname.hashCode());
return result;
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (!(o instanceof Author)) return false;
Author other = (Author) o;
if (!other.canEqual((Object)this)) return false;
if (this.getId() == null ? other.getId() != null : !this.getId().equals(other.getId())) return false;
if (this.getName() == null ? other.getName() != null : !this.getName().equals(other.getName())) return false;
if (this.getSurname() == null ? other.getSurname() != null : !this.getSurname().equals(other.getSurname())) return false;
return true;
}
}
```
#### @NonNull
Можно аннотировать при помощи `@NonNull` компонент записи, параметр, метод или целый конструктор, В таком случае Lombok сгенерирует для вас команды для проверки на нуль.
**С Lombok**
```
public class Author {
private int id;
private String name;
private String surname;
public Author(
@NonNull int id,
@NonNull String name,
String surname
) {
this.id = id;
this.name = name;
this.surname = surname;
}
}
```
**Просто Java**
```
public class Author {
private int id;
private String name;
private String surname;
public Author(
int id,
String name,
String surname
) {
if (id == null) {
throw new NullPointerException("id is marked @NonNull but is null");
}
this.id = id;
if (name == null) {
throw new NullPointerException("name is marked @NonNull but is null");
}
this.name = name;
this.surname = surname;
}
}
```
#### @Data
`@Data` – это сокращенная аннотация, сочетающая возможности `@ToString`, `@EqualsAndHashCode`, `@Getter` `@Setter` и `@RequiredArgsConstructor`. Так что `@Data` генерирует весь шаблонный код, вовлеченный в работу с объектами POJO ([Plain Old Java Objects](https://en.wikipedia.org/wiki/Plain_old_Java_object)). Это, в частности, дает нам геттеры для всех полей, сеттеры для всех нефинальных полей, правильные реализации `toString`, `equals` и `hashCode`, охватывающие все поля класса, а также конструктор для всех финальных полей.
**С Lombok**
```
@Data
public class Author {
private final int id;
private String name;
private String surname;
}
```
**Просто Java**
```
public class Author {
private final int id;
private String name;
private String surname;
public Author(int id) {
this.id = id;
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSurname() {
return surname;
}
public void setSurname(String surname) {
this.surname = surname;
}
@Override
public int hashCode() {
final int PRIME = 31;
int result = 1;
result = prime * result + getId();
result = prime * result + ((getName() == null) ? 0 : getName().hashCode());
result = prime * result + ((getSurname() == null) ? 0 : getSurname().hashCode());
return result;
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (!(o instanceof Author)) return false;
Author other = (Author) o;
if (!other.canEqual((Object)this)) return false;
if (this.getId() == null ? other.getId() != null : !this.getId().equals(other.getId())) return false;
if (this.getName() == null ? other.getName() != null : !this.getName().equals(other.getName())) return false;
if (this.getSurname() == null ? other.getSurname() != null : !this.getSurname().equals(other.getSurname())) return false;
return true;
}
}
```
#### @Value
`@Value` – это неизменяемый вариант `@Data`. С этой аннотацией Lombok по умолчанию делает все поля private и `final`. Кроме того, сеттеры не генерируются, а класс как таковой помечается `final`. Таким образом, от этого класса нельзя наследовать. Точно как и в случае с `@Data`, создаются реализации toString(), equals() и hashCode().
**С Lombok**
```
@Data
public class Author {
int id;
String name;
String surname;
}
```
**Просто Java**
```
public final class Author {
private final int id;
private final String name;
private final String surname;
public Author(int id, String name, String surname) {
this.id = id
this.name = name
this.surname = surname
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public String getSurname() {
return surname;
}
@Override
public int hashCode() {
final int PRIME = 31;
int result = 1;
result = prime * result + getId();
result = prime * result + ((getName() == null) ? 0 : getName().hashCode());
result = prime * result + ((getSurname() == null) ? 0 : getSurname().hashCode());
return result;
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (!(o instanceof Author)) return false;
Author other = (Author) o;
if (!other.canEqual((Object)this)) return false;
if (this.getId() == null ? other.getId() != null : !this.getId().equals(other.getId())) return false;
if (this.getName() == null ? other.getName() != null : !this.getName().equals(other.getName())) return false;
if (this.getSurname() == null ? other.getSurname() != null : !this.getSurname().equals(other.getSurname())) return false;
return true;
}
}
```
Продвинутые аннотации Lombok
----------------------------
Ниже рассмотрены самые сложные аннотации Lombok. Подробнее о каждой из них рассказано на собственной странице в [официальной документации Lombok](https://projectlombok.org/features/all).
#### @Cleanup
Аннотация `@Cleanup` позволяет гарантировать, что заданный ресурс будет автоматически очищаться перед тем, как покинет актуальную область видимости. По умолчанию предполагается, что метод очистки аннотированного ресурса будет close(), но вы можете сами указать имя того метода, который, по вашему желанию, будет вызываться вместо него. Обратите внимание: эта аннотация активно использует команды [try-with-resources](https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html).
**С Lombok**
```
public class CleanupDemo {
public static void main(String[] args) throws IOException {
@Cleanup
InputStream input = new FileInputStream(args[0]);
@Cleanup
OutputStream output = new FileOutputStream(args[1]);
byte[] b = new byte[10000];
while (true) {
int r = input.read(b);
if (r == -1)
break;
output.write(b, 0, r);
}
}
}
```
**Просто Java**
```
public class CleanupDemo {
public static void main(String[] args) throws IOException {
try (OutputStream output = new FileOutputStream(args[1])) {
try (InputStream input = new FileInputStream(args[0])) {
byte[] b = new byte[10000];
while (true) {
int r = input.read(b);
if (r == -1)
break;
output.write(b, 0, r);
}
}
}
}
}
```
#### @Synchronized
Аннотация `@Synchronized` действует примерно так же, как и ключевое слово `synchronized`, но защелкивается на других объектах. Ключевое слово защелкивается на this, а эта аннотация – на особом приватном поле под названием `$lock`. Если это поле не существует, то Lombok создаст его. Такое поведение задано по умолчанию, но вы можете и сами указать те объекты, на которых будет происходить защелкивание. При работе с методами static аннотация будет защелкиваться на статическом поле `$`LOCK. Учтите, что эта аннотация, как и ключевое слово `synchronized`, может использоваться только со статическими методами и методами экземпляра.
**С Lombok**
```
public class SynchronizedDemo {
private final Object objectToLock = new Object();
@Synchronized
public static void sayHello() {
System.out.println("Hello!");
}
@Synchronized
public int getOne() {
return 1;
}
@Synchronized("objectToLock")
public void printObject() {
System.out.println(objectToLock);
}
}
```
**Просто Java**
```
public class SynchronizedDemo {
private static final Object $LOCK = new Object[0];
private final Object $lock = new Object[0];
private final Object readLock = new Object();
public static void sayHello() {
synchronized($LOCK) {
System.out.println("Hello");
}
}
public int getOne() {
synchronized($lock) {
return 1;
}
}
public void printObject() {
synchronized(readLock) {
System.out.println(objectToLock);
}
}
}
```
#### @SneakyThrows
Аннотация `@SneakyThrows` позволяет бесшумно выбрасывать проверяемые исключения, не объявляя их явно в условии `throws` вашего метода, как принято делать. Итак, эта аннотация позволяет вам полностью избавиться от (как правило, необходимых в таких случаях) блоков try-`catch`, поскольку тихо обрабатывает все проверяемые исключения. В противном случае она запутала бы компилятор. Фактически, на уровне файлов классов JVM ([виртуальной машины Java](https://en.wikipedia.org/wiki/Java_virtual_machine)), все исключения могут выбрасываться безотносительно условия `throws`, присутствующего в ваших методах, поэтому-то данный механизм и работает. Вот почему стоит прочитать [эту](https://projectlombok.org/features/SneakyThrows) страницу из официальной документации Lombok, чтобы подробнее разобраться в этой аннотации и понять, как ею пользоваться.
#### @Builder
Возможно, вам потребуется разработать объект-строитель, который позволял бы вам создавать объекты, следуя пошаговой процедуре, например, `Author`.builder().id("1").name("Maria").surname("Williams").build();. Это особенно полезно, когда имеешь дело с большими классами, в каждом из которых по несколько полей. Вместо использования конструктора со многими полями, можно попробовать этот подход, более удобочитаемый. При помощи аннотации `@Builder` вы поручаете Lombok генерировать строители за вас. Аннотируя класс при помощи `@Builder`, Lombok выдает класс, реализующий вышеупомянутый паттерн «строитель». Например, аннотируя ею класс `Author`, получим автоматически сгенерированный класс `AuthorBuilder`. Поскольку поведение вашего строителя может быть сложным или сильно подогнанным под задачу, Lombok предлагает много параметров, при помощи которых можно достичь желаемого результата. Все они находятся [здесь](https://projectlombok.org/features/Builder).
#### @Log
Большинство средств логирования требуют закладывать экземпляр логгера для каждого класса, в котором вы хотите вести лог. Разумеется, при этом возникает шаблонный код. Lombok, аннотируя класс при помощи `@Log`, автоматически добавляет статическое финальное поле `log`, инициализируемое вашей библиотекой логирования как требуемое. Вот почему Lombok дает разработчикам по аннотации на каждый из наиболее популярных фреймворков логирования. Их полный список находится [здесь](https://projectlombok.org/features/log).
Плагин Lombok
-------------
К наиболее популярным и широко используемым IDE прилагается официальный плагин Lombok, предназначенный именно для упрощения работы с Lombok. В частности, он предлагает шорткаты для наиболее распространенных аннотаций Lombok. Кроме того, подсказывает, какие аннотации вам могут потребоваться или заинтересовать вас, в зависимости от того, где вы щелкаете мышью. На момент написания оригинала официально поддерживались [IntelliJ IDEA](https://projectlombok.org/setup/intellij), [Eclipse, Spring Tool Suite, (Red Hat) JBoss Developer Studio, MyEclipse](https://projectlombok.org/setup/eclipse), [Microsoft Visual Studio Code](https://projectlombok.org/setup/vscode) и [Netbeans](https://projectlombok.org/setup/netbeans). Полный список поддерживаемых IDE и советы по установке даны на официальном сайте [Lombok](https://projectlombok.org/). .
Рискованно ли работать с Lombok?
--------------------------------
Возможно, вас беспокоит, а что будет, если вы расставите аннотации Lombok по всей вашей базе кода. В самом деле, а что будет, если после этого вы решите избежать работы с Lombok? Возможно, в таком случае работа забуксует. Но на практике это не слишком большая проблема, поскольку в Lombok есть инструмент *delombok*. Как указано в [официальной документации](https://projectlombok.org/features/delombok) (где, правда, не покрыты все возможные IDE и случаи), этот инструмент действительно упрощает процесс разломбочивания вашего кода. Фактически, он обеспечивает автоматическую генерацию исходного кода Java, содержащего в байт-коде ровно те же возможности, которые внедрялись бы при помощи Lombok. Таким образом, ваша база кода, аннотированная Lombok, просто заменяется стандартной базой кода на Java, без Lombok. После этого весь ваш проект больше вообще не будет зависеть от Lombok. Соответственно, работа с Lombok не представляет никаких рисков для развития вашего проекта в будущем.
Заключение
----------
В этой статье было рассмотрено, как использовать проект Lombok - библиотеку Java, которая автоматически подключается к вашему редактору и инструментам сборки, чтобы вам не приходилось писать скучного шаблонного повторяющегося кода, который так характерен для языка Java. Как показано в статье, Lombok помогает разработчику легко повысить производительность труда и не тратить времени на утомительную рутину. Научившись пользоваться самыми важными аннотациями, можно обойтись без написания тысяч строк кода, который не несет никакой реальной пользы для бизнес-логики вашего проекта. Кроме того, в любой момент можно легко отвязать ваш проект от использования проекта Lombok. | https://habr.com/ru/post/676394/ | null | ru | null |
# Рефакторинг функций расширения в Kotlin: использование объекта-компаньона
В Kotlin есть отличная возможность использовать функции расширения, позволяющие писать более выразительный и компактный код. Под капотом это просто статические методы, которые могут навредить кодовой базе при некорректном использовании. В этой статье я расскажу, как работать с функциями расширения, которые со временем из небольших добавлений к коду трансформировались в монстров, содержащих бизнес-логику.
Точка отсчёта
-------------
Допустим, у нас есть такая функция:
```
fun Context.canUseBiometrics(): Boolean =
when (BiometricManager.from(this)) {
BiometricManager.BIOMETRIC_SUCCESS -> true
else -> false
}
```
Описанный далее подход к рефакторингу можно применять и к функциям верхнего уровня, а также к методам синглтона:
```
fun canUseBiometrics(context: Context): Boolean = { /* implementation */ }
object BiometricUtils {
fun canUseBiometrics(context: Context): Boolean = { /* implementation */ }
}
```
Как видите, функции проверяют, доступна ли биометрия на текущем устройстве. Довольно простая и понятная логика для реализации в виде метода расширения.
Тестируемость
-------------
Функции расширения по сути являются `@JVMStatic` методами конкретного вспомогательного класса. Вот Java-эквивалент этого метода:
```
class BiometricsUtils {
public static boolean canUseBiometrics(Context $this$) { /* implementation */ }
}
```
Вообще мы используем старомодный синглтон (определённый в области видимости класса с помощью статического модификатора), к которому можем обращаться из любого места кода, чтобы воспользоваться его логикой. А в чём главная проблема синглтонов? В тестируемости.
Рассмотрим такой случай:
```
class ScreenViewModel(applicationContext: Context): ViewModel() {
val displayBiometricsOption = MutableLiveData(false)
init {
displayBiometricsOption.value = applicationContext.canUseBiometrics()
}
}
```
Удобен ли этот код для тестирования? Не очень. Ведь даже если вы подставите в тесте заглушку `Context`, эффективно её использовать всё равно не получится, поскольку она опосредованно используется в `BiometricManager`. Вам нужно знать подробности реализации `BiometricManager` и то, как именно он использует `Context`, чтобы правильно настроить эту заглушку.
Решить эту проблему можно с помощью `Robolectric` или запуска теста на устройстве. Но нужно ли нам это? Эти варианты тестирования займут намного больше времени.
Усложнение логики
-----------------
Что ещё может произойти со вспомогательными функциями? Они могут сильно усложниться, а мы поздно это заметим. В контексте предыдущего примера представим, что у нас появилось новое требование: при каждой проверке доступности аппаратной биометрии нужно также проверять результат А/В-теста, чтобы активировать функциональность.
Во-первых, не следует отправлять в продакшен код, который я сейчас покажу (это просто пример). Во-вторых, рано или поздно вы всё равно столкнётесь с проблемой усложнения функций расширения в продакшен-коде. Никто не идеален.
Пример:
```
fun Context.canUseBiometrics(abTestStore: AbTestStore): Boolean =
if (abTestStore.isEnabled(AbTests.BIOMETRICS)) {
when (BiometricManager.from(context)) {
BiometricManager.BIOMETRIC_SUCCESS -> true
else -> false
}
} else {
false
}
```
```
class ScreenViewModel(
applicationContext: Context,
++ abTestStore: AbTestStore
): ViewModel() {
val displayBiometricsOption = MutableLiveData(false)
init {
-- displayBiometricsOption.value = applicationContext.canUseBiometrics()
++ displayBiometricsOption.value = applicationContext.canUseBiometrics(abTestStore)
}
}
```
Получилась весьма неприглядная функция расширения, в которой смешаны бизнес-логика и логика данных. Её может быть трудно отрефакторить, если она применяется во многих местах.
Проблема большой кодовой базы
-----------------------------
А что мешает нам просто реализовать новый класс для обработки логики и внедрить в конструктор каждого класса, который его использует? Мешает размер пул-реквеста.
В больших кодовых базах функция расширения может использоваться в десятках и даже сотнях разных мест. И для каждого места в коде потребуется вносить изменения в соответствующий конструктор класса. Если у вас многомодульное приложение с прямыми и явными зависимостями, то может потребоваться явно объявить новый класс в виде зависимости в каждом модуле, который его использует.
Из-за всех этих изменений ваш пул-реквест может раздуться до гигантских размеров — и его будет сложно проверить. К тому же возрастёт риск пропустить ошибку.
С помощью описанного ниже подхода мы сможем реализовать каждый этап в виде отдельного пул-реквеста.
Замена функции расширения на синглтон
-------------------------------------
Сначала признаем проблему использования синглтонов. Нам нужно заменить неявный синглтон на явный:
```
-- fun Context.canUseBiometrics(abTestStore: AbTestStore): Boolean { /* implementation */ }
++ object BiometricsUtils {
++ fun canUseBiometrics(context: Context, abTestStore: AbTestStore): Boolean { /* implementation */ }
++ }
```
```
class ScreenViewModel(
applicationContext: Context,
abTestStore: AbTestStore
): ViewModel() {
val displayBiometricsOption = MutableLiveData(false)
init {
-- displayBiometricsOption.value = applicationContext.canUseBiometrics(abTestStore)
++ displayBiometricsOption.value = BiometricsUtils.canUseBiometrics(applicationContext, abTestStore)
}
}
```
Волшебство объекта-компаньона интерфейса
----------------------------------------
Теперь у нас есть класс, с которым можно работать. Поскольку мы стремимся к тестируемости, в будущем мы заменим прямые использования класса `BiometricsUtils` на интерфейс. Сейчас интерфейс выглядит так:
```
interface BiometricsUtils {
fun canUseBiometrics(context: Context, abTestStore: AbTestStore)
}
```
Но потом нам понадобится убрать из списка параметров метода `Context` и `AbTestStore`, потому что они одинаковы во всех местах вызова метода: `Context` — это контекст приложения, а `AbTestStore` — локальный синглтон в графе зависимостей.
```
interface BiometricsUtils {
fun canUseBiometrics()
}
```
Вернёмся к варианту с параметрами в методе и в конце дополнительным этапом мигрируем на вариант без них.
Теперь у нас есть интерфейс и синглтон-класс. Как нам их соединить друг с другом, чтобы потом не пришлось вносить изменения во всех случаях использования метода?
Нам поможет объект-компаньон.
Объекты-компаньоны появились на заре развития Kotlin, ещё до выхода версии 1.0. В то время их преимущества перед обычными объектами и статическими методами Java не были очевидны. Особенно потому, что при каждом обращении к компаньону приходилось использовать слово `Companion`.
```
class Foo {
companion object {
fun bar()
}
}
fun main() {
Foo.Companion.bar()
}
```
К счастью, требование использовать `Companion` отменили. И теперь мы можем обращаться к объектам-компаньонам в привычной манере — как к статическим функциям Java.
```
fun main() {
Foo.bar()
}
```
Более того, компилятор Kotlin достаточно сообразителен, чтобы различать вызовы методов интерфейса и его компаньона.
```
interface Foo {
companion object {
fun bar()
}
}
fun main() {
Foo.bar()
}
```
И поскольку объекты-компаньоны в Kotlin — это обычный синглтон-класс, они могут расширять классы и интерфейсы. Это приводит нас к объекту-компаньону, который реализует интерфейс своего родителя:
```
interface Foo {
fun bar()
companion object : Foo {
override fun bar()
}
}
fun main() {
Foo.bar()
}
```
Мы можем вызвать абстрактную функцию bar применительно к интерфейсу `Foo`, делегируя её объекту-компаньону `Foo`. Воспользуемся этой методикой для рефакторинга кода:
```
interface BiometricsUtils {
fun canUseBiometrics(context: Context, abTestStore: AbTestStore): Boolean
companion object : BiometricsUtils {
override fun canUseBiometrics(context: Context, abTestStore: AbTestStore): Boolean { /* implementation */ }
}
}
```
Мы по-прежнему можем спокойно использовать `BiometricsUtils.canUseBiometrics(applicationContext, abTestStore)`. Теперь мы на шаг ближе к завершению рефакторинга.
Внедрение интерфейса в качестве значения по умолчанию
-----------------------------------------------------
Раз у нас теперь есть интерфейс, мы можем передать его в качестве параметра конструктора.
```
class ScreenViewModel(
applicationContext: Context,
abTestStore: AbTestStore,
++ biometricsUtils: BiometricsUtils = BiometricsUtils
): ViewModel() {
val displayBiometricsOption = MutableLiveData(false)
init {
-- displayBiometricsOption.value = BiometricsUtils.canUseBiometrics(applicationContext, abTestStore)
++ displayBiometricsOption.value = biometricsUtils.canUseBiometrics(applicationContext, abTestStore)
}
}
```
Как значение по умолчанию параметра `biometricsUtils` используем `BiometricsUtils.Companion`. Тогда нам не придётся менять код, создающий этот класс. Но это изменение важно и ещё по одной причине. Мы наконец-то можем протестировать `ScreenViewModel` с помощью JVM-тестов. `BiometricsUtils` является интерфейсом, и мы можем применить в тесте заглушку:
```
class ScreenViewModelTest {
@Test
fun `WHEN biometrics available THEN displayBiometricsOption true`() {
val utils = mock {
on { canUseBiometrics(any(), any()) } doReturn true
}
val viewModel = ScreenViewModel(
applicationContext = mock(),
abTestStore = mock(),
biometricsUtils = utils
)
assertEquals(true, viewModel.displayBiometricsOption.value)
}
}
```
Поскольку в качестве параметров `canUseBiometrics` мы используем только `applicationContext` и `abTestStore`, можно подставить пустые заглушки. Больше нет нужды в заглушках для других методов этих классов, как раньше. С помощью модульных тестов можно отдельно проверить логику метода `canUseBiometrics`, чтобы убедиться, что всё работает как нужно.
Убираем значение по умолчанию
-----------------------------
Теперь можно убрать значение по умолчанию параметра `biometricsUtils` и через DI-систему подставить реальное значение.
```
class ScreenViewModel(
applicationContext: Context,
abTestStore: AbTestStore,
-- biometricsUtils: BiometricsUtils = BiometricsUtils
++ biometricsUtils: BiometricsUtils
): ViewModel()
```
```
@Module
@InstallIn(SingletonComponent::class)
class BiometricsModule {
@Provide
fun biometricsUtils(): BiometricsUtils = BiometricsUtils
}
```
Улучшаем интерфейс
------------------
Перенесём параметры `biometricsUtils` в конструктор класса и обновим все места его использования. Затем текущую функцию отметим как `@Deprecated` и добавим новую. Кроме того, поскольку мы уже убрали все использования `BiometricsUtils.Companion`, можно избавиться и от него самого.
```
interface BiometricsUtils {
++ @Deprecated
fun canUseBiometrics(context: Context, abTestStore: AbTestStore): Boolean
++ fun canUseBiometrics(): Boolean
-- companion object : BiometricsUtils {
-- override fun canUseBiometrics(context: Context, abTestStore: AbTestStore): Boolean { /* implementation */ }
-- }
}
```
Добавим новую реализацию `BiometricsUtils`:
```
class BiometricsUtilsImpl(
applicationContext: Context,
abTestStore: AbTestStore
) : BiometricsUtils {
fun canUseBiometrics(): Boolean { /* implementation */ }
@Deprecated
fun canUseBiometrics(context: Context, abTestStore: AbTestStore): Boolean =
canUseBiometrics()
}
```
Теперь через DI-систему предоставим новый класс:
```
@Module
@InstallIn(SingletonComponent::class)
class BiometricsModule {
-- @Provide
-- fun biometricsUtils(): BiometricsUtils = BiometricsUtils
++ @Binds
++ abstract fun biometricsUtils(impl: BiometricsUtilsImpl): BiometricsUtils
}
```
Можем убрать все применения старого метода и обновить использовавшие его тесты.
Заключение
----------
Мы смогли аккуратно отрефакторить метод расширения, поэтапно внося изменения. При этом мы не создали помехи коллегам и минимизировали количество конфликтов слияния.
Объект-компаньон интерфейса — это мощная функция, позволяющая использовать синглтоны, которые легко внедрить в конструктор и заменить заглушками. | https://habr.com/ru/post/575550/ | null | ru | null |
# Наслаждайтесь миллиардами цветов с 10-битным HEVC
Человеческий глаз способен видеть намного больше цветов, чем показывают ему современные видео дисплеи. Каким бы навороченным не был компьютер, он все равно может воспроизвести лишь конечное количество цветов. В этой статье мы расскажем об использовании 10-битной глубины цвета в сравнении с 8-битной, исходя из функционала процессоров Intel Core седьмого поколения и оптимизирующих возможностей Intel Software Tools. В статье вы также найдете ссылку на пример программы, реализующей 10-битное HEVC кодирование.
Глубина цвета
-------------
Глубина цвета, известная также как битовая глубина — это количество битов, используемое для отображения цвета отдельного пикселя. Одно и то же изображение или кадр с различной глубиной цвета выглядят различно, поскольку количество цветов в пикселе зависит от глубины цвета.
Количество битов в изображении включает в себя набор битов на канал для каждого типа цвета в пикселе. Количество цветовых каналов в пикселе зависит от используемого цветового пространства. Например, цветовые каналы в цветовом пространстве RGBA — красный ( R), зеленый (G), синий (B) и альфа (A). Каждый дополнительный бит удваивает количество информации, которое мы можем хранить для каждого цвета. В 8-битном изображении общее количество доступных цветов пикселя равняется 256. В Таблице 1 показано возможное количество доступных цветов для каждой соответствующей глубины цвета.
| Глубина канала | Оттенков на канал на пиксель | Общее количество возможных оттенков |
| --- | --- | --- |
| 8-бит | 256 | 16.78 миллионов |
| 10-бит | 1024 | 1.07 миллиарда |
| 12-бит | 4096 | 68.68 миллиардов |
Большинство мониторов и телевизоров способны отображать лишь 8-битный контент, 10-битные изображения в них преобразуются в 8-битные. Однако преимущества 10-битной глубины имеют место уже сейчас:
* при обработке изображений или видео после съемки
* при использовании High Dynamic Range (HDR) мониторов или камер.
Если контент снят с глубиной 10 бит, важно не потерять ее при дальнейшей обработке, поскольку это может привести к снижению резкости, контраста и других важных характеристик. В том случае, если редактируется 8-битный контент, это также может привести к уменьшению глубины и вызвать эффект цветовых полос.
Эффект цветовых полос
---------------------
При захвате изображения иногда случается так, что сенсор не может распознать минимальное различие между двумя двумя соседними цветами, и возникает проблема некорректного отображения цветов. Как результат, область рисунка закрашивается одним цветом за неимением более подходящего другого. Таким образом, на рисунке появляются цветные полосы вместо плавного перехода из одного цвета в другой.
Возможные варианты решения проблемы цветовых полос:
* увеличить глубину цвета на канал
* применить цветовую дискретизацию (не рассматривается в этой статье).
Неоткалиброванный дисплей может также вызвать эффект полос. Чтобы этого избежать, воспользуйтесь утилитой [Intel Graphics Control Panel](http://www.intel.com/content/www/us/en/support/graphics-drivers/000005596.html).
*Рисунок 1. Сравнение 8-битного (слева) и 10-битного (справа) изображения. Слева виден эффект полос.*
Рисунок 1 показывает разницу между 8-битным и 10-битным изображениями применительно к эффекту цветовых полос. На левом изображении необходимая цветовая детализация не была передана сенсором, что привело у меньшему, чем надо, количеству цветов и цветовым полосам. На правом фото цветовой информации достаточно и переход между цветами получился плавным. Для обеспечения плавности цветовых переходов необходим более широкий цветовой диапазон, описанный в стандарте BT2020.
Стандарт BT. 2020
-----------------
Седьмое поколение процессоров Intel Xeon и Core поддерживает стандарт BT. 2020 (известный также как Rec. 2020) в таких случаях как создание/воспроизведение 4K Ultra-high definition (UHD) контента, использование HDR с поддержкой 10 битов и т.д. UHD-мониторы имеют разрешение 3840\*2160 при различной диагонали. Поддержка стандарта BT.2020 улучшает качество картинки при столь высоком разрешении.
*Рисунок 2. Сравнение цветовых пространств BT.2020 и BT.709*
Рекомендации The International Telecommunications Union (ITU) BT.2020 представляют значительно больший диапазон цветов, чем ранее используемые BT.709. Сравнение соответствующих цветовых пространств показано на Рисунке 2, представляющим диаграмму цветности CIE 1931. Оси X и Y показывают относительные координаты цветности с длинами волн соответствующих цветовых пространств (синий шрифт). Желтый треугольник покрывает цветовое пространство по стандарту BT. 709. Черный треугольник показывает цветовое пространство BT. 2020, значительно большее по размеру и, следовательно, содержащее большее количество цветов для плавных переходов. BT. 2020 также определяет различные аспекты UHD TV такие как разрешение дисплея, частоту кадров, цветовую субдискретизацию и глубину цвета в добавление к цветовому пространству.
Процессоры Intel 7 поколения поддерживают профили HEVC Main 10 profile, VP9 Profile 2 и High Dynamic Range (HDR) видео рендеринг с использованием стандарта BT.2020.
Профиль HEVC Main 10
--------------------
High Efficiency Video Coding (HEVC), также известный как H.265 — стандарт видео сжатия, наследник хорошо известного стандарта H.264/AVC. По сравнению с предшественниками, HEVC использует более сложные алгоритмы сжатия. Больше информации о стандарте можно узнать [здесь](https://software.intel.com/en-us/blogs/2015/12/11/codecs-are-they-slowing-you-down). Профиль Main 10 позволяет использовать 8-битный или 10-битный цвет с цветовой субдискретизацией 4:2:0.
Поддержка декодирования HEVC 10b появилась начиная с 6 поколения процессоров Intel. Команда ниже показывает, как тестовая утилита *sample\_decode* из [набора примеров кода Intel Media SDK](https://github.com/Intel-Media-SDK/samples) может быть использована для получения сырых кадров из простейшего HEVC потока.
```
sample_decode.exe h265 -p010 -i input.h265 -o raw_farmes.yuv -hw
```
Используемый выше входной поток (input.h265) может быть взят [здесь](https://ngcodec.com/hevc-bitstreams/). Выходной поток (raw\_frames.yuv) должен быть в формате P010, используемом как исходный материал для утилиты *sample\_encode*.
Аппаратная поддержка кодирования/декодирования HEVC 10b внедрена начиная с 7 поколения процессоров Intel. Кодирование 10-битного HEVC реализовано с помощью дополнительного кода *modified\_sample\_encode*, специально измененного для этой конкретной функциональности. Данный пример работает с Intel Media SDK 2016 R2. Инструкция по сборке приведена в [руководстве по примерам медиа](https://github.com/Intel-Media-SDK/samples/blob/master/samples/Media_Samples_Guide_Windows.pdf) в [образцах кода Intel Media SDK](https://github.com/Intel-Media-SDK/samples).
Ниже показан пример 10-битного кодирования с использованием *sample\_encode* из добавленной *modified\_sample\_encode*.
```
sample_encode.exe h265 -i raw_frames.yuv -o output.265 -w 3840 -h 2160 -p010 -hw
```
*Рисунок 3. Скриншот утилиты Video Quality Caliper, показывающий, показывающий, что кодированный поток имеет 10 бит на пиксель.*
Профиль VP9 2
-------------
VP9 — формат видео кодирования, разработанный Google как наследник VP8. Платформы Intel седьмого поколения поддерживают аппаратное ускорение декодирования VP9 10-бит, тогда как кодирование пока комбинированное, софтово-хардварное.
Высокий динамический диапазон (High Dynamic Range, HDR)
-------------------------------------------------------
Динамический диапазон — это отношение значения самой светлой к самой темной точке на изображении. Видео высокого динамического диапазона (HDR) позволяет получить лучший динамический диапазон, чем обычное (SDR) видео, использующее нелинейные операции для кодирования и декодирования уровня освещенности.
Видео контент HDR поддерживается при использовании кодека HEVC Main 10 или VP9.2, аппаратно ускоренных начиная с 7 поколения процессоров Intel. Для передачи контента HDR, система должна быть оснащена портом DisplayPort 1.4 или HDMI 2.0a. Данная функциональность пока находится на стадии тестирования и не включена в общедоступные релизы.
Заключение
----------
Как мы выяснили, разработчики сейчас имеют возможность создавать красивое, реалистичное видео в самых современных форматах, расцвеченных ярками красками 10-битного цвета, идеальным для HD/UHD дисплеев. Используя процессоры Intel седьмого поколения для создания контента стандарта BT.2020, а также возможности оптимизации Intel Media SDK, мы уже сейчас можем заглянуть за пределы разрешения 4K UHD и стандартной на сегодня кадровой скорости. В дальнейшем область применения современных аппаратно-ускоренных видео кодеков будет расширяться.
В этой статье упоминались следующие программные средства (со ссылками для скачивания):
* **Программное обеспечение** — [Intel Media SDK 2016 R2](https://software.intel.com/en-us/media-sdk)
* **Входной видео поток** — MHD\_2013\_2160p\_ShowReel\_R\_9000f\_24fps\_RMN\_QP23\_10b.hevc из [Бесплатные потоки H.265/HEVC](https://ngcodec.com/hevc-bitstreams/)
* **Кодек** — H.265/HEVC
* **Средство анализа** — Video Quality Caliper (VQC), компонент [Intel Media Server Studio](https://software.intel.com/en-us/intel-media-server-studio) Professional Edition и Intel Video Pro Analyzer
* **Тестовый стенд**:
+ **ЦПУ**: Intel Core i7-7500U CPU @ 2.70GHz
+ **ОС**: Microsoft Windows 10 Professional 64-bit
+ **Графика**: Intel HD Graphics 620
Полезные ссылки
---------------
* [Поддержка глубокого цвета в Intel Graphics](http://www.intel.com/content/dam/www/public/us/en/documents/white-papers/deep-color-support-graphics-paper.pdf)
* [Видео кодек VP9](https://www.webmproject.org/vp9/)
* [Рекомендация ITU-R BT.2020-2](https://www.itu.int/rec/R-REC-BT.2020-2-201510-I/en)
* [10-bit and 16-bit YUV видео форматы](https://msdn.microsoft.com/en-us/library/windows/desktop/bb970578(v=vs.85).aspx)
* [Достижение высокого качества и производительности HEVC с Intel Media Server Studio](https://software.intel.com/sites/default/files/managed/b8/d0/intel-hevc-whitepaper.pdf)
* [Бесплатные потоки H.265/HEVC](https://ngcodec.com/hevc-bitstreams/)
* [**Пример программы, реализующей 10-битное HEVC кодирование**](https://software.intel.com/protected-download/267270/721547) | https://habr.com/ru/post/330568/ | null | ru | null |
# Часть I. InterSystems GlobalsDB .Net — разведка боем с заглядыванием под капот
Наконец-то вместо уговоров подождать еще немного, на вопрос “Есть ли InterSystems GlobalsDB/Caché Extreme под Microsoft .Net?” можно ответить утвердительно. В новой версии Caché 2012.2 (Field Test) и GlobalsDB v2012.296 появилась поддержка этой платформы.
Попытаюсь в любимом для многих разработчиков на одной шестой суши стиле, то есть без чтения [install notes](http://globalsdb.org/getting-started/quickstart/#Quickstart_Windows) и прочего, исследовать, что, собственно говоря, представляет дистрибутив GlobalsDB под Windows.
Качаем [дистрибутив](http://globalsdb.org/downloads/) под Windows и .Net. Получаем globals\_setup\_2012.296.exe размером в 25 мегабайт. Запускается инсталлятор InstallShield. Запускал я его не в режиме администратора под Windows 7x64, работающий в VMWare Fusion под Mac OS X.
Установка прошла предсказуемо, в качестве домашней директории я указал C:\usr\isc\globals. Для чистоты эксперимента надо сказать, что у меня уже стоит в этой операционке Caché.
Изучаю то, что поставилось. В \usr\isc\globals три папки: bin, dev, mgr — стандартная для Caché структура. В bin лежат бинарники и либы самой СУБД, в mgr — конфигурация и файлы базы данных, плюс, что немаловажно — системный лог, в нашем случае globalsdb.log
Идем в .\dev — папка с различным инструментарием для разработчика. Нас интересует .\dev\dotnet, состоящая из bin, help и samples. В .\bin лежит сборка InterSystems.GlobalsDB, в help замечаем chm аналог javadocs, в samples — проект Visual Studio c небольшим примером использования.
Жму на проект. Запускается моя Visual Studio 10 и начинает конвертацию проекта из 2008 в свой формат — разработчики InterSystems все еще сидят на восьмерке, хотя в новом релизе Caché есть уже сборки под .Net 4. Конвертация заканчивается успешно, запускаю Debug на исполнение — и о чудо, оно заработало!
Мое удивление вызвано тем, что в случае GlobalsDB для Java надо было запускать базу через .\bin\globalsdb start и для доступа к базе необходимо было взводить переменные окружения GLOBALS\_HOME и PATH.
Исследую вопрос с помощью Sysinternals Process Explorer. Обнаруживаю шесть процессов cache.exe, стартовавших из C:\usr\isc\globalsdb (это кстати и есть значение для GLOBALS\_HOME). Смотрю на окружение моей застартованной Visual Studio — в нем есть уже GLOBALS\_HOME и нужный путь в PATH — %GLOBALS\_HOME%\bin. Смотрю на список сервисов Windows — обнаруживаю GlobalsDB сервис. В общем инсталлятор позаботился о мелочах — хорошая тенденция. Кстати сказать, старт/стоп через команду %GLOBALS\_HOME%\bin\globalsdb start или stop эквивалентен старту или стопу сервиса и наоборот.
Ну что же — консольное приложение работает, правда, пример скорее представляет собой набор тестов разработчика GlobalsDB, который методично проверял, что все перегрузки методов GlobalsDB API под .Net работают. Поэтому чтобы разобраться с API, создадим свой новый проект. Заодно посмотрим, что нужно сделать в VS, чтобы подцепить GlobalsDB.
Создаем новый проект под консольное приложение. Добавляем референс на InterSystems.GlobalsDB, который лежит в %GLOBALS\_HOME%\dev\dotnet\bin. В моем случае это сборка C:\usr\isc\globals\dev\dotnet\bin\InterSystems.GlobalsDB.dll.
```
using System;
using System.Diagnostics;
using InterSystems.Globals;
namespace globals
{
class Program
{
static void Main(string[] args)
{
}
}
}
```
System.Diagnostics будем использовать для измерений скорости работы.
Теперь подсмотрим в примере, как делается соединение и перенесем в наш код:
```
static void Main(string[] args)
{
Connection connection = ConnectionContext.GetConnection()
connection.Close();
Console.ReadLine();
}
```
Запускаем. Получаем исключение An attempt was made to load a program with an incorrect format. Все понятно, мой проект по умолчанию собирает под x32. Идем в проектные Properties->Build и ставим Platform target в x64. Запускаем — все хорошо.
Идем дальше — попытаемся что-нибудь записать в базу. Это что-нибудь называется в GlobalsDB глобалами, или, используя полное название — global variables, то есть глобальные переменные Caché, которые в отличие от локальных, живущих в памяти конкретного процесса базы данных, живут на диске и таким образом доступны всем подключениям к базе данных. В GlobalsDb мы можем работать только с глобалами.
Глобалы каждый воспринимает в силу своей испорченности — кто-то называет их многомерными переменными, другие видят их как деревья или key-value хранилища, мне ближе представлять их как ассоциативные массивы или MultiMap. Если не предаваться фантазиям, то глобал — это атомарная структура хранения данных в Caché (например атомарной структурой для реляционок будет таблица), которая имеет имя, состоит из элементов, называемых узлами. Каждый узел состоит из левой части, которая называется сабскриптом (часто ее называют индексом или ключом) и правой части — собственно хранимыми данными, которые могут быть либо простым типом (числа, строки), либо списком, элементы которого опять же либо простые типы либо списки.
Примеры глобалов (псевдокод).
a. Для тех, кто думает, что это key value или коллекция с доступом по ключу:
`test(1) = “some text or number limited to 3641144 bytes”
test(“any string limited to 500 bytes”) = 3.14`
b. Для тех, кто думает, что это дерево:
`test(1,”post”) = “root”
test(1,2,”post”) = “branch A”
test(1,3,”post”) = “branch B”`
c. Пустой сабскрипт тоже сабскрипт:
`test = 2`
d. Похожее на табличное хранение данных с использованием списков:
`orders(1)=list(1001,”20.12.2012”,3,,999.99)
orders(2)=list(1002,”04.12.2012”,4,,249.99)`
Попробуем теперь сохранить данные в глобал. Для этого нужно указать имя глобала, создать новый узел глобала, указать для узла сабскрипт (ключ или индекс, как вы видите из примера) и данные, которые хранятся в этом узле. Для работы с узлами глобалов в GlobalsDB API используется объект класса NodeReference. Фактически это указатель на некоторый узел в глобале. Так как узел идентифицируется своим сабскриптом, то можно считать, что NodeReference это ссылка на некоторый сабскрипт. Ссылку на глобал, которая первоначально указывает на головной узел, мы получаем через соединение:
NodeReference testArray = connection.CreateNodeReference(«test»); //global name is test
Для начала используем простой метод NodeReference.Set(). В обобщенном виде его можно воспринимать как NodeReference.Set(data,subscript) и соответственно после его исполнения у нас появляется узел глобала в базе такого вида:
globalName(subscript) = data
Таким образом, код выглядит вот так:
```
static void Main(string[] args)
{
Connection connection = ConnectionContext.GetConnection();
NodeReference node = connection.CreateNodeReference("test");
node.Set("some text or number limited to 3641144 bytes",1);
node.Set(3.14, "any string or primitive type or several values limited to 500 bytes");
connection.Close();
Console.ReadLine();
}
```
Bыполняем. Получаем исключение: Must connect before calling Connection.CreateNodeReference(). Все верно, смотрим код примера — за установление соединения мы отвечаем сами, а не фабрика. Почему так? Не знаю. Тут можно заметить одно, что есть вопросы, связанные с многопотоковой работой с соединением и на будущее об этом важно помнить в случае необходимости. Добавляем установление соединения:
if (!connection.IsConnected()) connection.Connect();
Теперь все хорошо. Замечаем, что работают хинты для GlobalsDB API. Добавляем примеры на работу с многомерным сабскриптом и на предельные значения для сабскрипта и данных справа:
```
static void Main(string[] args)
{
Connection connection = ConnectionContext.GetConnection();
if (!connection.IsConnected()) connection.Connect();
NodeReference node = connection.CreateNodeReference("test");
node.Set("some text or number limited to 3641144 bytes",1);
node.Set(3.14, "any string limited to 500 bytes");
node.Set("root",new object[2] {1,"post"}) ;
node.Set("branch A",new object[3] {1,1,"post"}) ;
node.Set("branch B",new object[3] {1,2,"post"}) ;
node.Set(2);
node.Close();
node = connection.CreateNodeReference("limit");
String longestKey = new String('k', 500);
String longestValue = new String('v', 3641144);
node.Set(longestValue, longestKey);
connection.Close();
Console.ReadLine();
}
```
Как посмотреть, что произошла вставка узлов глобалов в базу? Можно воспользоваться одним из методов чтения NodeReference. Однако для отладки можно использовать такой прием, не документированный в GlobalsDB, но знакомый тем, кто работал с Caché (тем более, что в поставке GlobalsDB утилит администрирования пока нет). Итак, идем в %GLOBALS\_HOME% и в командной строке выполняем:
```
C:\usr\isc\globals\bin>cache -s ..\mgr -U Data
DATA>_
```
В результате мы получаем терминальную сессию к базе данных. Что это такое? Это стандартный процесс базы данных, запущенный в терминальном режиме, который позволяет исполнять нам команды на языке [Caché Object Script.](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=GCOS) Независимые процессы, работающие с базой данных — это одна из особенностей Caché, которая позволяет использовать ее как сервер приложений — запускать процессы, где будет работать, к примеру, пользовательский код приложения. В случае GlobalsDB таким процессом становится процесс CLR, в котором исполняется наш .Net код.
Как посмотреть созданные узлы? Для этого есть команды write (сокращенно w) и zwrite (zw). Пример:
```
DATA>zw ^test
^test=2
^test(1)="some text or number limited to 3641144 bytes"
^test(1,1,"post")="branch A"
^test(1,2,"post")="branch B"
^test(1,"post")="root"
^test("any string limited to 500 bytes")=3.1400000000000001243
```
Удаление узла или всего глобала — команда kill (сокращенно k):
```
DATA>kill ^test
```
Запись данных:
```
DATA>s ^test(1,"name") = "Athens"
```
Вставка в цикле:
```
DATA>for i=1:1:100 { s ^test(i) = i }
```
Выход из терминала — команда halt (сокращенно h):
```
DATA>h
C:\usr\isc\globals\bin>
```
Замер времени:
```
DATA>s st=$zh for i=1:1:100000 { s ^test(i)=i} w $zh-st,!
.064444
```
Теперь попробуем вставить 100 000 записей из .Net и засечь время:
```
static public void testInserts(int loop)
{
Connection connection = ConnectionContext.GetConnection();
if (!connection.IsConnected()) connection.Connect();
NodeReference node = connection.CreateNodeReference("test");
node.Kill();
Stopwatch dbTimer = Stopwatch.StartNew();
for (int i = 0; i < loop; i++)
{
node.Set(i+" item", i);
}
dbTimer.Stop();
Console.WriteLine(dbTimer.ElapsedMilliseconds + " milliseconds to save " + loop + " items");
Console.WriteLine("It is " + dbTimer.Elapsed.Seconds + " seconds");
node.Close();
connection.Close();
}
```
Результаты для серии тестов:
```
for (int i = 100000; i <= 1100000; i += 200000) testInserts(i);
ConnectionContext.GetConnection().Close();
```
```
C:\src\globals\globals\bin\Release>.\globals.exe
430 ms to save 100000 items. 232558 records/second
1223 ms to save 300000 items. 245298 records/second
1958 ms to save 500000 items. 255362 records/second
2754 ms to save 700000 items. 254175 records/second
3559 ms to save 900000 items. 252880 records/second
4436 ms to save 1100000 items. 247971 records/second
```
Более 200 000 записей в секунду. Все это происходит c включенным журналированием и в транзакции. С другой стороны, данные носят совсем макетный характер. С третьей, это происходит под виртуалкой, у которой осталось 5 метров свободного дискового пространства. С четвертой, на таких скоростях все очень сильно зависит от конкретики — размеры записей и случайность ключа, интенсивность потока транзакций, возможность обрабатывать попакетно, необходимость в транзакциях и тд.
Для начала достаточно — GlobalsDB установлен, проект работает, сделаны общие выводы по быстродействию.
В дальнейшем разберем такие важные темы, как навигация по узлам глобалов и операции обхода узлов, работа со списками, транзакции, счетчики, блокировки. Отдельно рассмотрим интересный вопрос, как GlobalsDB ведет себя при работе с несколькими потоками. | https://habr.com/ru/post/141546/ | null | ru | null |
# CDD — Cli Driven Development
Все-таки самоизоляция не проходит бесследно. Сидишь себе дома, а в голову разные мысли приходят. Как, чем осчастливить человечество? И вот оно: CDD! (И еще PDD / SOLID / KISS / YAGNI / TDD / Bootstraping...)
### 1. CDD - Cli Driven Development - Новый подход
#### Немного истории
Как-то поручили мне сделать Cli в одном нашем embedded устройстве. Разумеется, C/C++ (пусть будет C++, раз ресурсов хватает). Конечно есть много Cli-фреймворков.
Но я сделал свой вариант.
Для Linux можно использовать и получать коды символов после установки свойств терминала:
```
signal(SIGINT, SIGINT_Handler); // Ctrl+C
signal(SIGTSTP, SIGTSTP_Handler); // Ctrl+Z
int res_tcgetattr = tcgetattr(STDIN_FILENO, &terminal_state_prev);
terminal_state_new = terminal_state_prev;
terminal_state_new.c_lflag &= ~(ICANON | ECHO);
int res_tcsetattr = tcsetattr(STDIN_FILENO, TCSANOW, &terminal_state_new);
```
Для Windows можно использовать .
Добавляем немного классов, делаем список команд, и добавляем команды по типу:
```
{
Cli_Command_Abstract_t *cmd = new Cli_Command_Abstract_t(Cli_Command_ID_help);
cmd->Add(help_keyword);
cmd->Help_Set("show this help, \"help full\" - show all available commands");
command_tree->Add(cmd);
}
```
И все-бы ничего, пока команд 10-20. Ну пусть еще help / quit / debug cli (типа очень нужная команда - об этом позже). Интересно, что основной функционал уложился в 20 команд, а вот разные обвязки… Управление SNMP / Syslog / NTP / Users / FTP / SSH / VLAN … и у нас - 250 команд. Ух ты! Начинаются проблемы с монолитным приложением, и очень хочется разбить все на модули, желательно попроще и поменьше. И вот отсюда и начинается **CDD - Cli Driven Development**.
**1.1 Использование Cli в различных типах приложений**
Вообще, Cli, не смотря на GUI, используется во многих типах приложений: САПР, игры, базы данных, среды выполнения (Erlang, Lua и др.), IDE. Можно утверждать, что включение консоли могло бы сделать многие приложения более удобными (например, можно представить Paint с командной строкой: количество команд невелико, VBA будет лишним, но одна лишь возможность выполнения скриптов могла бы значительно изменить работу с программой).
**1.2 Введение в CDD**
Cli-интерфейс жив и развивается. Cisco-like - это вполне вполне рабочий термин.
Что же может современный Cli? - Довольно много:
* развитую систему команд с выводом подробной информации, в том числе об аргументах команды;
* группировку команд ("уровни");
* задание группы объектов для управления ("параметры");
* логгирование;
* исполнение скриптов;
* типизированный ввод данных с валидацией;
Я придумал еще одну функцию: debug cli - проверка команд (CMD\_ID / CMD\_Item / CMD\_Handler)
* может показать число ID ("задуманные команды"), Realized- и NotRealized-команды для каждого модуля; (В идеале счетчики ID, Realized должны быть равны, но если NotRealized не равен 0, то это еще один стимул для разработчика: ну осталось всего-то 30...20...5...2 нереализованных команд - неужели оставим так? может лучше доделать? - и это работает!)
**1.3 Основные идеи CDD**
Можно сформулировать основные идеи CDD:
1. Если есть какой-то функционал, должны быть Cli-команды, обеспечивающие управление этим функционалом и команды получения информации о данном функционале. Не должно быть функционала без Cli-команд.
2. Модульное построение: любой модуль можно убрать или заменить с предсказуемыми изменениями в функционале.
3. Модули связываются только на самом верхнем уровне: все связи должны легко прослеживаться (фактически мы пользуемся тем, что приложений с полной связностью не существует / не может быть / мы должны избегать).
**1.4 mCli - Реализация CDD**
CDD использовано при построении mCli - Cli-фреймворка модульного типа (github.com/MikeGM2017/mCli). В текущем состоянии имеются события, типы и модули.
**1.4.1 События mCli**
В простейшем виде для ввода с клавиатуры нужно определение кода нажатой клавиши и (отдельно) определение нажатия Enter (ввод команды) и Ctrl+C (прерывание команды). В полном наборе необходимо определение нажатия Enter (ввод команды), Ctrl+C (прерывание команды), Up/Down (просмотр истории команд), Left/Right/Home/End (перемещение по строке ввода), Back/Delete (изменение строки ввода).
**1.4.2 Типы mCli**
mCli предполагает использование типов при вводе данных. В текущей реализации имеются следующие типы:
* Word / Word\_List / Word\_Range (ключевые слова, List - можно ввести несколько ключевых слов через запятую, Range - выбор одного ключевого слова из нескольких вариантов)
* Int / Int\_List / Int\_Range
* Str
* IP4 / IP6
* MAC
* Date / Time / DateTime
* EQU\_Range ( == != > < >= <= - для использования в скриптах, условное выполнение)
* Rem (комментарий - для использования в скриптах)
**1.4.3 Модули mCli**
Модули mCli можно разделить на базовые, платформо-зависимые и кастомные.
Базовые модули:
* Base\_Quit (выход из приложения)
* Base\_Help (вывод информации по командам и их аргументам)
* Base\_Modules (вывод информации по задействованным модулям)
* Base\_History (история команд)
* Base\_Script (выполнение скриптов)
* Base\_Rem (комментарий, для использования в скриптах)
* Base\_Wait (пауза, для использования в скриптах)
* Base\_Log (управление логом)
* Base\_Debug (проверка списка команд, определение нереализованных команд)
* Check (условное выполнение, для использования в скриптах)
#### Платформо-зависимые модули
**Вывод:**
* Output\_printf (Linux/Window)
* Output\_cout (Linux/Window)
* Output\_ncurses (Linux)
* Output\_pdcurses (Linux/Window)
**Ввод:**
* Input\_termios (Linux)
* Input\_conio (Window)
* Input\_ncurses (Linux)
* Input\_pdcurses (Linux/Window)
**Кастомные модули:**
* ConfigureTerminal (демо: тестирование переменных)
* SecureTerminal (демо: вход в модуль по паролю)
* TestTerminal (демо: тестирование типов)
**1.5 Объединение модулей в mCli**
Связывание модулей происходит на самом верхнем уровне, например в функции main():
```
Cli_Modules Modules;
// Modules Add - Begin
Modules.Add(new Cli_Module_Base_Rem(Str_Rem_DEF, Cli_Output));
bool Cmd_Quit = false;
Modules.Add(new Cli_Module_Base_Quit(Cmd_Quit));
Str_Filter str_filter('?', '*');
Modules.Add(new Cli_Module_Base_Help(User_Privilege, Modules, str_filter, Cli_Output));
Modules.Add(new Cli_Module_Base_Modules(User_Privilege, Modules, str_filter, Cli_Output));
Cli_History History;
Modules.Add(new Cli_Module_Base_History(History, Cli_Output));
Modules.Add(new Cli_Module_Base_Log(Cli_Input));
bool Cmd_Script_Stop = false;
int Script_Buf_Size = 1024;
Modules.Add(new Cli_Module_Base_Script(History, Cli_Output,
Str_Rem_DEF, Cmd_Script_Stop, Cmd_Quit, Script_Buf_Size,
CMD_Processor));
bool Log_Wait_Enable = true;
bool Cmd_Wait_Stop = false;
Modules.Add(new Cli_Module_Base_Wait(Log_Wait_Enable, Cmd_Wait_Stop, Cli_Input, Cli_Output));
Modules.Add(new Cli_Module_Test_Tab_Min_Max());
Modules.Add(new Cli_Module_Test_Terminal(Cli_Input, Cli_Output));
Modules.Add(new Cli_Module_Base_Debug(User_Privilege, Modules, Levels, CMD_Processor, Cli_Output));
Modules.Add(new Cli_Module_Check(Modules, Values_Map, str_filter, Cli_Output, Cmd_Script_Stop));
// Modules Add - End
```
**1.6 CDD и SOLID**
SOLID в CDD достаточно легко обнаружить на уровне подключения и объединения модулей. Какие-то модули практически всегда используются, например Cli\_Output нужен в большинстве модулей. Другие - гораздо реже (например, Cli\_Input нужен только в модулях, в которых команда требует подтверждения).
Таким образом, SOLID в CDD - это:
* S - каждый модуль отвечает за свой круг задач
* O - здесь есть проблема: в каждом модуле есть enum Local\_CmdID, и получается, что при наследовании список Local\_CmdID не так просто расширить? Но в новом модуле мы можем завести новый enum Local\_CmdID или (лучше) можно ввести новый enum Local\_CmdID только для новых команд, стартующий с последнего элемента предыдущего enum (для этого можно использовать CMD\_ID\_LAST)
* L - модуль может быть заменен на другой, с доработанной реализацией
* I - при замене модуля может возникнуть ситуация, что потребуется больше (или меньше) связанных модулей; при создании экземпляра модуля это легко учесть (через конструктор или статический инициализатор)
* D - модули связываются на верхнем уровне
**1.7 CDD и KISS**
В целом, набор команд любого модуля стремится к расширению: более удобный формат команд, новые флаги, новые возможности. Но сам список команд всегда доступен, и, если он сильно разрастается… то просто делим модуль на 2 или более модуля!
На уровне модуля команды могут различаться флагами или дополнительными параметрами. Но реализация у них может быть одна. Например, "help" и "help full" реализуются одним методом, в качестве параметра принимающий строку фильтра - "\*". Так что KISS сохраняется в таком смысле:
* команда выполняется методом, имеющим несколько флагов (да, из-за этого метод делается чуть сложнее, зато несколько команд Cli могут выполняться однотипно).
**1.8 CDD и DRY**
Повторяющийся код выносим в отдельный класс, создаем объект и ссылку на него используем при создании модуля.
**1.9 CDD и YAGNI**
Нужно убрать какой-то ненужный функционал? - Убираем ненужный модуль (или команды в модуле). За счет слабой связности модулей это несложно.
**1.10 CDD и Bootstraping**
В некоторых случаях (например, Embedded Baremetal) у нас есть только консоль. CDD может быть применено для разработки приложения "с нуля".
**1.11 CDD и TDD**
За счет наличия скриптов и модуля условного исполнения автоматизация тестирования сводится к следующему сценарию:
* вручную вводится последовательность тестируемых команд;
* история команд сохраняется в файле скрипта;
* при необходимости скрипт редактируется / дополняется проверкой правильности выполнения;
* вызов скрипта добавляется в общий скрипт тестирования или используется сам по себе;
**1.12 CDD и GUI**
А что GUI? GUI (да и Web - тоже) пусть посылает текстовые команды в Cli - эстетично, наглядно, надежно.
### 2. CDD и PDD
А вот еще и PDD!!!
**2.1 PDD - Provocation Driven Development - еще один новый термин :)**
Вообще, PDD - это то, что нас настигает постоянно. Допустим, есть путь, по которому мы идем к цели. Но на что нас провоцирует этот путь? Считаю, что мы должны осознавать это. Например, на что провоцируют языки программирования:
* C провоцирует на нарушения доступа к памяти и на плохо контролируемые приведения типов;
* C++ - на создание монолита (если за этим не следить, то имеем типовой пример: class MyCoolGame; myCoolGame.Run());
* SQL, Lua - "все есть таблица";
* Assembler - "стандартов нет";
* Java - "щас понаделаем объектов";
* JavaScript - "щас наподключаем библиотек, не самим же все делать"; … и так далее - дополнительные примеры каждый, думаю, сможет придумать.
**2.2 Что есть PDD для CDD?**
В первую очередь - это тенденция на разбиение проекта на модули. Действительно:
* Есть объект управления? - Выносим в модуль.
* Есть повторяющийся код? - Выносим в модуль.
* Новый функционал? - Добавляем новый модуль.
* Новая архитектура? - Заменяем модули.
Описание команд - это текстовое описание функционала, фактически мы получаем DSL. Чтобы получить информацию о доступном функционале, достаточно ввести команду "help".
Предсказательный характер архитектуры:
* пусть в расчетах на каждую Cli-команду отводим 1 (один) человеко-день. Да, можно за 1 день ввести 10-20 простых Cli-команд (да, простые или однотипные команды реализуются быстро), но не нужно обманываться: будет (обязательно будет!) функция, которая потребует 10 дней на реализацию и тестирование. Поэтому проект средней сложности на 200-300 Cli-команд займет 200-300 человеко-дней (хотя, это скорее оценка "сверху", реально проект может быть закончен раньше).
Скрипты с возможностью условного исполнения означают встроенную возможность тестирования, что (в теории) уменьшает вероятность регресса.
Расширяемость: новый модуль может, конечно, добавлять новые команды в глобальную видимость, но предпочтительный путь - группировка команд на уровне модуля, тогда в глобальной видимости появится всего лишь одна команда - переход на "уровень" модуля.
В Cli достаточно легко задавать обработку группы объектов. Можно, например:
* ввести список объектов в команду;
* ввести фильтр по именам объектов в команду;
* ввести список объектов как параметр;
* или даже ввести модуль Selection для управления группировкой объектов. Таким образом, можно использовать различные варианты групповой обработки.
Приложение достаточно легко поддерживать в постоянно рабочем состоянии: да, какой-то функционал еще не введен, зато все остальное - работает.
По-видимому, CDD ортогональна другим подходам, так как CDD может быть применено как в Waterfall, так и в Agile. Действительно, ввод сначала новых команд, а потом их реализация - близок к Waterfall. Но модульное построения и малая связность модулей способствуют применению Agile. Но CDD не мешает ни Waterfall, ни Agile, а только помогает.
### 3. Встроенный язык скриптов
**3.1 Модуль Check**
Условное выполнение реализовано в модуле "Check".
Для условного выполнения команд, в принципе, достаточно всего двух команд: "check label " - установка метки "check if == goto " - условный переход (здесь сравнение может быть не только на равенство: == != > < >= <= - вот полный список, но при этом команду можно оставить одну и ту же, а операторы сравнения ввести в виде списка возможных значений)
Переменные в простейшем случае - глобальные, заносятся в map, для чего в модуле предусмотрен виртуальный метод .To\_Map().
Для работы с переменными введены команды условного и безусловного присвоения, объединения, вывода на экран. Для полноценного языка этого, возможно, мало, но для задач тестирования функционала - вполне приемлемо.
**3.2 Модуль Check vs Lua**
Да, вместо встроенных модулей скриптов и условного выполнения можно подключить Lua. Однако, вместо нескольких команд (в действительности модуль условного выполнения Check получается не такой уж маленький - более 30 команд, хотя и однотипных) подключение Lua означает большое увеличение размера исполняемого файла, а в некоторых случаях это может быть критичным. Но как вариант, Lua выглядит очень привлекательно.
**3.3 Модуль Check vs Erlang**
Было бы неплохо, но запросы… Уж очень большие у Erlang требования к ресурсам. Возможно, на "жирных" устройствах, как вариант, можно и Erlang подключить.
### 4. CDD vs Erlang
Неплохая попытка, подход Erlang - довольно похож на CDD. Но задумаемся, в чем PDD для Erlang? - "Ошибаемся и еще раз ошибаемся, а система все равно работает". Это, конечно, сильно. Поэтому вопрос: "CDD или Erlang" безусловно стоит. Но CDD можно реализовать на многих языках программирования (C/C++, C#, Java, JavaScript). А у Erlang - очень специфичный подход. Может быть, не Erlang vs CDD, а Erlang + CDD ??? Кажется, надо попробовать...
### 5. CDD и дробление монолита
Примерный путь преобразования монолита в CDD-приложение:
* создаем CDD-приложение из Base-модулей;
* legacy-монолит добавляем в виде нового Cli-модуля на новом "уровне" с минимальными командами вида "version get" / "info get" - на первом этапе достаточно "установить контакт" с монолитом;
* в новом модуле вводим команды, специфичные для него: "start" / "stop" / "configure" …;
* скорее всего новые команды будут группироваться вокруг каких-то понятий / объектов / процедур и т. п. - это повод выделить такие группы в отдельные модули + объекты управления; при этом в основном монолите вводятся ссылки на выделенные объекты;
* в результате должен получиться набор модулей, причем каждый модуль должен содержать не более 10-20 команд;
* когда монолит разбит на модули, можно изменять модули по отдельности, заменять их, вводить новый функционал, добавлять модули и т. д.
### 6. Итоги
CDD выполняет SOLID, KISS, DRY, YAGNI, Bootstraping, TDD.
CDD провоцирует на модульное построение.
CDD дает возможность выполнения скриптов и внутреннее тестирование.
CDD может быть основой большого количества типов приложений.
CDD позволяет вводить новый функционал прогнозируемым способом.
CDD может быть основой построения OS.
CDD может быть использовано для относительного удобного поглощения монолитов. Причем вполне возможна оркестрация как монолитов, так и сервисов.
CDD дает возможность разделения работ:
* постановщик задачи описывает новый модуль в виде набора команд;
* исполнитель реализует команды;
* тестировщик пишет скрипты для проверки нового функционала.
CDD поддерживает введение нового функционала, в том числе на разных уровнях:
* новые модули;
* новые команды в существующих модулях.
CDD обеспечивает безопасность при вводе команд:
* команды парсятся, данные валидируются, сделать что-то вне Cli-команд невозможно (если, конечно, не вводить команды типа exec / system / eval).
CDD фактически дает документацию по функционалу приложения:
* достаточно подать команду "help \* verbose" - и описание команд и их аргументов уже есть.
Этого мало?
Тогда вот вам напоследок: CDD позволяет захватить мир. КМК …
Да, и Linux стоит переписать по CDD. КМК | https://habr.com/ru/post/550488/ | null | ru | null |
# GObject: инкапсуляция, инстанциация, интроспекция
… а также другие страшные слова! (с)
Прежде чем мы познакомимся с некоторыми продвинутыми возможностями объектной системы типов GLib, необходимо поговорить о ряде моментов, которые мы не затронули в предыдущих двух статьях. В этот раз мы познакомимся ближе с базовым типом GObject, поговорим о том, что любой наследник базового GObject представляет собой двуединство (а зачастую триединство) отдельных объектов-структур, во что раскрываются загадочные макросы в начале заголовочных файлов и файлов с исходным кодом, при помощи какого инструментария работает суровый местный RTTI, почему у GObject и его потомков два деструктора (и три конструктора), равно как и о ряде других интересных мелочей.
#### Весь цикл о GObject:
[GObject: основы](https://habr.com/post/348204/)
[GObject: наследование и интерфейсы](https://habr.com/post/350132/)
GObject: инкапсуляция, инстанциация, интроспекция
### Структуры. Много структур.
Как мы знаем, потомки GObject могут быть наследуемыми — derivable и ненаследуемыми — final. В общем случае derivable GObject состоит из совокупности трёх объектов: структуры-класса, структуры-инстанции и структуры с приватными данными.
Со структурой-классом всё более-менее просто — она описывается в заголовочном файле и содержит экземпляр классовой структуры родителя и указатели на функции — «виртуальные методы». Хорошим тоном считается добавить последним полем структуры небольшой массив void-указателей для обеспечения ABI-совместимости. Экземпляр такой структуры создаётся в одном экземпляре при создании первой инстанции данного типа.
```
/* animalcat.h */
/* С вашего позволения, продолжу разбирать тему на котопримерах :) */
typedef struct _AnimalCat AnimalCat;
typedef struct _AnimalCatClass AnimalCatClass;
typedef struct _AnimalCatPrivate AnimalCatPrivate;
struct _AnimalCatClass
{
GObjectClass parent_class; /* родительская классовая структура */
void (*say_meow) (AnimalCat*); /* виртуальный метод */
gpointer padding[10]; /* массив указателей; gpointer - переопределение void* */
};
```
Для final-типов определять структуру-класс нет необходимости.
Структура с приватными данными нужна для derivable-объектов. Она определяется в файле с исходным кодом, а доступ к ней можно получить через автоматически генерируемую функцию вида animal\_cat\_get\_instance\_private(). В таком случае макрос в начале.с-файла должен иметь вид G\_DEFINE\_TYPE\_WITH\_PRIVATE (NamespaceObject, namespace\_object, PARENT\_TYPE). Можно использовать и макрос G\_DEFINE\_TYPE\_WITH\_CODE (с включенным в него макросом G\_ADD\_PRIVATE).
```
/* animalcat.c */
#include "animalcat.h"
G_DEFINE_TYPE_WITH_PRIVATE(AnimalCat, animal_cat, G_TYPE_OBJECT)
/* G_DEFINE_TYPE_WITH_CODE(AnimalCat, animal_cat, G_TYPE_OBJECT, G_ADD_PRIVATE (AnimalCat)) */
struct _AnimalCatPrivate
{
char* name;
double weight;
int age;
};
static void animal_cat_init(AnimalCat* self)
{
AnimalCatPrivate* priv = animal_cat_get_instance_private(self);
priv->age = 0;
priv->name = "Barsik";
/* и так далее */
}
```
Предполагается, что все данные инкапсулированы. Для доступа к ним можно использовать обычные обёртки — геттеры и сеттеры, но, как мы увидим впоследствии, GObject предоставляет для этого куда как более мощное средство — свойства (properties).
Структура-инстанция, как и структура с приватными данными, создаётся для каждого экземпляра объекта. Это, собственно, сам объект, с которым в основном будет работать конечный пользователь. Структура автоматически генерируется для derivable-типов посредством макроса из заголовочного файла, так что программисту нет нужды делать это самому. Для final-типов же её необходимо описывать вручную в файле с исходным кодом. Поскольку в данном случае структура не является частью публичного интерфейса объекта, она может содержать приватные данные. Очевидно, в таком случае нет необходимости в создании отдельной private-структуры.
```
/* animaltiger.c */
struct _AnimalTiger
{
AnimalCat parent; /* обязательно первым полем должен идти экземпляр родительского объекта */
int speed; /* приватные данные */
};
```
Что касается интерфейсов, для их реализации необходимо определить лишь интерфейсную структуру, очень похожей на обычную классовую. Структура самого объекта вида \_AnimalPredator будет сгенерирована автоматически.
```
/* animalpredator.h */
typedef struct _AnimalPredatorInterface AnimalPredatorInterface;
struct _AnimalPredatorInterface
{
GTypeInterface parent; /* все интерфейсы унаследованы от GTypeInterface */
void (*hunt) (AnimalPredator* self); /* виртуальный метод */
};
```
Наглядная таблица-шпаргалка:
### Динамическое определение типа на практике
В заголовочных файлах мы начинали описание нового типа с использования двух макросов, которые, в свою очередь, преобразуются в целый набор макроопределений. В старых версиях GLib было необходимо вручную описывать весь этот инструментарий. Посмотрим, чем из этого мы можем воспользоваться.
ANIMAL\_TYPE\_CAT: возвращает целочисленный идентификатор типа GType. Этот макрос тесно связан с системой типов GType, лежащей в основе GObject. С ним вы обязательно встретитесь, я упомянул его лишь для того, чтобы было понятно, откуда он берётся. Функции вида animal\_cat\_get\_type(), которые использует данное макроопределение, генерируются автоматически в файле с исходным кодом при раскрытии макросов семейства G\_DEFINE\_TYPE.
ANIMAL\_CAT (obj): приведение к указателю на данный тип. Обеспечивает безопасный каст, а также производит проверки времени исполнения. Как вы могли заметить, система наследования в GObject в общем случае построена на том, что структуры содержат первым полем экземпляр родительской структуры, а значит, по соглашениям вызовов Си, указатель на объект совпадает с указателем на всех предков, от от которых он унаследован. Несмотря на это, желательно пользоваться предоставленным макросом, а не обычным Си-кастом. Кроме того, в ряде случаев (например, при приведении к типу реализованного интерфейса), приведение в стиле Си вообще не будет работать.
ANIMAL\_CAT\_CLASS (klass): аналогичный макрос для классовых структур. Соглашение предписывает не использовать слово class для совместимости с компиляторами С++.
ANIMAL\_IS\_CAT (obj): как следует из названия, это макроопределение производит проверку, является ли obj указателем на данный тип (и не является ли NULL-указателем). Хорошим тоном считается начинать методы объекта с такой проверки.
```
void animal_cat_run (AnimalCat *self)
{
assert(ANIMAL_IS_CAT (self));
g_return_if_fail (ANIMAL_IS_CAT (self)); /* или средствами GLib */
/* остальной код */
}
```
ANIMAL\_IS\_CAT\_CLASS (klass): то же самое для классовых структур.
ANIMAL\_CAT\_GET\_CLASS (obj): возвращает указатель на соответствующую классовую структуру.
Похожий набор макроопределений генерируется и для интерфейсов.
ANIMAL\_PREDATOR (obj): каст к типу интерфейса.
ANIMAL\_IS\_PREDATOR (obj): проверка на соответствие типа.
ANIMAL\_PREDATOR\_GET\_IFACE (obj): получение структуры интерфейса.
Имя объекта можно получить, используя макрос G\_OBJECT\_TYPE\_NAME (obj), возвращающий си-строку с именем типа.
Макросы в начале файла с исходным кодом G\_DEFINE\_TYPE и его расширенные версии генерируют указатель вида animal\_cat\_parent\_class, возвращающий указатель на классовую структуру родительского объекта, а также функцию вида animal\_cat\_get\_instance\_private(), если мы использовали соответствующий макрос.
### Деструкторы и другие виртуальные функции
Как мы помним, при создании любого наследника GObject запускаются функции вида animal\_cat\_init(). Они выполняют ту же роль, что и конструкторы C++ и Java. С деструкторами ситуация сложнее.
Управление памятью в GObject реализовано с использованием подсчёта ссылок. При вызове функции g\_object\_new(), количество ссылок устанавливается равным единице. В дальнейшем мы можем увеличивать их число при помощи g\_object\_ref() и уменьшать при помощи g\_object\_unref(). Когда число ссылок станет равным нулю, будет запущена процедура уничтожения объекта, состоящая из двух фаз. Сначала вызывается функция dispose(), которая может вызываться многократно. Основная её задача — разрешить в случае необходимости циклические ссылки. После этого единожды вызывается функция finalize(), в которой выполняется всё то, для чего обычно используются деструкторы — освобождается память, закрываются открытые файловые дискрипторы и т. д.
Такая сложная система была спроектирована для облегчения создания биндингов к высокоуровневым языкам, в том числе с автоматическим управлением памятью. На практике, в Си-коде используется обычно только finalize(), если объект предполагает наличие деструктора.
Функции dispose() и finalize(), а также ряд других, о которых мы будем говорить дальше, виртуальные и определены в GObjectClass.
```
static void animal_cat_finalize(GObject* obj)
{
g_print("Buy!\n"); /* вариант printf() из GLib */
/* освобождаем память и т. д. */
G_OBJECT_CLASS (animal_cat_parent_class)->finalize(obj); /* в конце обязательно вызывайте аналогичный деструктор родительского класса */
}
static void animal_cat_class_init(AnimalCatClass* klass)
{
GObjectClass* obj_class = G_OBJECT_CLASS (klass);
obj_class->finalize = animal_cat_finalize; /* переопределяем деструктор */
}
```
Последняя строчка функции animal\_cat\_finalize() может показаться требующей дополнительных пояснений. Указатель animal\_cat\_parent\_class на родительский класс создаётся при раскрытии макроса G\_DEFINE\_TYPE и его расширенных версий. Мы вызываем соответствующую функцию из родительского класса, который в данном случае непосредственно является структурой GObjectClass, а она, в свою очередь, вызывает finalize() предыдущего класса в цепочке. Нет необходимости беспокоиться о том, что родительский класс может не содержать переопределения finalize(), об этом позаботится система GObject.
Осталось только напомнить о том, что деструктор вызывается лишь тогда, когда обнуляется счётчик ссылок:
```
int main(int argc, char** argv)
{
AnimalCat* cat = animal_cat_new();
g_object_unref(cat); /* без этой строчки не сработает */
}
```
Кроме двух деструкторов, GObjectClass содержит два дополнительных виртуальных конструктора. constructor() вызывается до уже известного нам animal\_cat\_init() и непосредственно создаёт экземпляр данного типа, constructed() — после. Нелегко придумать ситуацию, в которой вам понадобится переопределять эти функции, если вы, конечно, не решили пропатчить сам GLib. В документации разработчики приводят пример с реализацией синглтона, но в реальном коде я ни разу подобные случаи не встречал. Однако для достижения максимальной гибкости на всех этапах жизненного цикла инстанции объекта разработчики посчитали нужным сделать эти функции виртуальными.
Кроме того, GObjectClass содержит виртуальные функции get\_property() и set\_property(), которые необходимо переопределить для использования в своих собственных объектах такой мощной возможности базового типа GObject и его потомков, как свойства. Об этом мы поговорим в следующей статье. | https://habr.com/ru/post/418443/ | null | ru | null |
# По мотивам GUIRunner
[Часть 1](http://habrahabr.ru/post/232955/).
[Часть 2](http://habrahabr.ru/post/234801/).
[Часть 3](http://habrahabr.ru/post/241301/).
Сегодня дописал [пост](http://habrahabr.ru/post/241301/) о том, как мы решили написать свой GUIRunner для FireMonkey. В комментарии к посту в одной из соцсетей [Алексей Тимохин](https://plus.google.com/+AlekseyTimohin) обратил мое внимание на другой известный фреймворк для тестирования — DUnitX.
Я пытался найти альтернативу, использовать консольный вариант, но Александр был неумолим. Когда же зайдя в репозиторий я увидел готовый GUIRunner под FireMonkey, совсем поник.
Однако.
После первого запуска первым моим сообщением Александру было — " lol. Там «галочек» нету." Так что проблему решал не зря. После более внимательного изучения сложилось впечатление, что человек, который писал эту форму, тоже отчасти «поглядывал» в Original GUIRunner.
В целом я бы очень обрадовался такому подарку с месяц назад, пока шишки FireMonkey ещё не набились. Ну а сегодня мне было просто интересно, как решал эту же задачу другой программист.
Ряд ошибок мы допустили практически одинаковых. В посте я писал о том, как мы «связываем» тесты и ветки и в конце закончил предложением о рефакторинге с использованием TDictionary. Напомню, как в оригинале:
```
l_Test.GUIObject := aNode.Items[l_Index];
...
l_TreeViewItem.Tag := FTests.Add(aTest);
```
Разработчик DUnitX поступил примерно также, правда, он сделали обертку над TTreeViewItem (в будущем добавлю к себе):
```
type
TTestNode = class(TTreeViewItem)
strict private
FFullName: String;
FImage: TImage;
public
constructor Create(Owner: TComponent; Text: String; TestFullName: String); reintroduce;
destructor Destroy; override;
property FullName: String read FFullName;
procedure SetResultType(resultType: TTestResultType);
procedure Reload;
end;
```
И связал каждый тест с веткой по имени теста.
```
function TGUIXTestRunner.GetNode(FullName: String): TTreeViewItem;
var
i: Integer;
begin
Result := nil;
i := 0;
repeat begin
if (TestTree.ItemByGlobalIndex(i) as TTestNode).FullName = FullName then
Result := TestTree.ItemByGlobalIndex(i);
Inc(i);
end
until Assigned(Result) or (i >= TestTree.GlobalCount);
end;
```
Удивило меня другое:
```
FFailedTests: TDictionary;
```
Угадайте, зачем нам ключ String? Правильно, чтобы по нему добраться до ветки и сообщить о её состоянии после результата теста. Как по мне, перемудрили.
Отдельного упоминания заслуживает класс TTreeNode. Он в себе хранит «ссылку» на тест и картинку, которая будет изменять состояние ветки. Так как класс унаследован от TreeViewItem, такой код живет отлично:
```
var
testNode : TTreeViewItem;
...
testNode := CreateNode(TestTree, test.Name, test.Fixture.FullName + '.' + test.Name);
...
function TGUIXTestRunner.CreateNode(Owner: TComponent; Text: String; TestFullName: String): TTreeViewItem;
begin
Result := TTestNode.Create(Owner, Text, TestFullName);
end;
...
constructor TTestNode.Create(Owner: TComponent; Text, TestFullName: String);
begin
inherited Create(Owner);
Self.Text := Text;
FFullName := TestFullName;
FImage := TImage.Create(Owner);
FImage.Parent := Self;
{$IFDEF DELPHI_XE6_UP}
FImage.Align := TAlignLayout.Right;
{$ELSE}
FImage.Align := TAlignLayout.alRight;
{$ENDIF}
FImage.Bitmap.Create(15, 15);
FImage.Bitmap.Clear(TAlphaColorRec.Gray);
FImage.SendToBack;
end;
```
В целом DUnitX произвёл на меня хорошее впечатление. Фреймворк кажется намного солиднее своего старшего брата. Интерфейсы и архитектуру ребята пересмотрели и, думаю, даже улучшили. Весь код очень аккуратный. Комментариев больше в разы. Буду присматриваться и сравнивать.
#### Ссылки
Репозиторий [Delphi-Mocks](https://github.com/VSoftTechnologies/Delphi-Mocks.git). Необходим для компилирования фреймворка;
Репозиторий [DUnitX](https://github.com/VSoftTechnologies/DUnitX.git). | https://habr.com/ru/post/241377/ | null | ru | null |
# WWDC 2019: Custom Instruments и SF Symbols, а также новые подходы к разработке iOS-приложений
В народе говорят, что везение — это результат упорного и длительного труда. Наверное, отчасти это правда. Двое наших сотрудников выиграли в рандомную лотерею билеты на самую востребованную конференцию Apple и отправились этим летом в Сан-Хосе.
Если бы не это событие, то мечты об обсуждении с профи новых фич от Apple, знакомство с топовыми iOS-разработчиками мира и публичное выступление на [iThink #3](https://youtu.be/jxK2xHSndJE) так и остались бы в мечтах.
Принять участие в конференции WWDC мечтает любой iOS-разработчик. Конечно, вы можете возразить: «Есть же онлайн-трансляция, неужели её возможностей мало?» Да, есть, но мы хотим заметить, что на случайном розыгрыше билетов на мероприятие конкуренция просто зашкаливает! И это явно неспроста.
К сожалению, зрители онлайн-трансляции видят не более 25-30 % всего события, а самое главное — они не участвуют в мастер-классах и сессиях. К сожалению, именно эти, самые интересные, мероприятия остаются за кадром онлайн-трансляции и доступны только тем, кто лично посетил конференцию.
Как раз ради присутствия на этой закрытой части разработчики всего мира участвуют в розыгрыше билетов и ночами не спят, ожидая результат. Именно здесь им рассказывают о важных обновлениях и изменениях в написании кода, знакомят с инструментами, которые будут использоваться в будущем.
Только посетив мероприятие лично, можно оценить его значение. Без преувеличения, можно сказать, что WWDC 2019 — это самое значимое мероприятие за последние 5 лет.
Именно на нём посетителям сообщили, что Apple целиком изменила сложившуюся годами и привычную всем нам технологию написания кода, серьезно упростив её. А это заставит многих разработчиков серьёзно переосмыслить свои методы работы, взглянув по-новому на многие, хорошо знакомые вещи.
Мы хотим рассказать вам о реальных задачах, с которыми в самое ближайшее время соприкоснётся мировое сообщество iOS-разработчиков. А конкретно, мы рассмотрим варианты использования и возможности Custom Instruments и SF Symbols и приведём примеры из нашей работы с новыми инструментами на WWDC 2019.
Custom Instruments
==================
Эта фирменная «фишка» для разработчиков была показана Apple ещё в прошлом году. А вот подробности о ней стали известны только сейчас. В ходе сессий WWDC 2019 специалисты Apple подробно рассказали гостям мероприятия о том, как работают кастомные инструменты, какая от них польза разработчику, а самое главное, как эффективно их применять на практике.
Представленный в прошлом году трассировщик os\_signpost является основным в данном инструментарии. В число его главных задач входит создание простых событий и интервалов.
Apple также познакомила разработчиков с низкозатратным трассировщиком os\_signpost. По словам докладчиков, его уже сейчас можно легко встроить даже в финальные версии. Но программисты Apple рекомендуют аккуратно пользоваться этим инструментом, контролируя количество аргументов в ходе трассировки, не злоупотребляя ими.
Архитектура инструментария устроена следующим образом:
* Поток данных (Data stream). Решить задачу получения потока данных можно с помощью трассировщика os\_signpost, переводящего данные в input-таблицу. Структура таблиц input и output описывается в специально созданном XML-файле. А процесс считывания и записи данных в таблицу представляет собой пошаговую трассировку.
* Моделлер (Modeller). Обрабатывает и анализирует данные из input-таблицы. Сам Modeller, написанный на специальном языке CLIPS, имеет две части — декларативную и императивную. Именно в этом его уникальность! Он обрабатывает новые события и конвертирует данные. Используя Modeller, можно производить кастомный подсчёт или преобразование данных в нужный разработчику формат. По окончании конвертации новые значения буду сохранены в output-таблице. Этот процесс и называется «моделлинг».
* Инструменты (Instruments). С их помощью считывается записанная в таблице информации для её вывода на экран. Управлять форматом отображения можно с помощью XML-формы. Правда, её надо для этого создать.
* Утилита StandartUI. Отвечает за считывание и визуализацию информации из output-таблицы.
CloudKit + CoreData
===================
Это одна из самых свежих фирменных «фишек». На неё возложена задача синхронизации Core Data и Cloud Kit в автоматическом режиме. Чтобы активировать её, надо отметить нужные позиции до начала проекта:
Обратите внимание на то, что уведомления, а также CLoudKit в Capabilities в автоматическом режиме не включатся. Это придется делать вручную.
На этом ваша работа заканчивается, всё остальное сделает Xcode в автоматическом режиме. Он сам создаст контейнер для агрегации работы на основе базы данных и CloudKit.
Отдельно заметим, что эта новая и весьма полезная фича будет корректно работать и в ранее запущенных проектах. Всё, что для этого нужно сделать разработчику, это создать новый Container вместо имеющегося. Как видите, процесс синхронизации в старых проектах теперь стал гораздо проще.
SF Symbols
==========
Эта тема на WWDC 2019 вызвала самое большое количество вопросов, что неудивительно, ведь докладчики «прошлись» по ней буквально галопом. Именно такое ускоренное, краткое изложение и вызвало непонимание у гостей конференции.
Многие посетители серьезно задумались над вопросом: «Для чего Apple показала и ввела новые символы? Ведь уже много лет разработчики прекрасно используют привычные всем картинки .png/.jpg/.pdf». Да, этот способ имеет определенные недостатки, но он настолько знаком и привычен разработчикам UI, что для отказа от него нужна весьма веская причина.
Но даже с учётом этого не стоит недооценивать значение новых иконок, представленных Apple для создания дружелюбного пользовательского интерфейса. Ведь неудачно выбрав иконки, вы рискуете тем, что приложение потеряет свою нативность, станет неудобным и непонятным для пользователя, а это неминуемо снизит его популярность.
Для разработчика очень важно правильно понимать и оценивать функциональность иконок в приложении, их внешний вид и влияние на удобство работы пользователя.
Чтобы легче было понять назначение иконок, мы сгруппировали их в три категории:
* разделение контекста;
* объединение контекста;
* визуальное соответствие контексту.
Благодаря такому разделению мы поняли, что SF Symbols специально создан для помощи в оптимальном выборе иконок. Заметим, что компания Apple для этого даже разработала отдельное приложение <https://developer.apple.com/design/human-interface-guidelines/sf-symbols/overview/>, в нём можно детально изучить примерно 1500 новых символов. Для удобства разработчика в приложении есть поиск и настраиваемые параметры. Используя их, вы сможете оценить, как будут выглядеть иконки при смене их значений.
Ну, а если среди 1500 символов вы не найдёте нужную иконку, всегда можно нарисовать свою. Как это сделать, мы рассказали в нашем [руководстве](https://developer.apple.com/design/human-interface-guidelines/sf-symbols/overview).
Учтите, что в приложении вы создаете векторное изображение иконки, включающее в себя текстовые метаданные. Возможно, кому-то работа с векторной графикой будет непривычна. Не случайно на WWDC отдельную сессию посвятили процессу создания новых символов. На ней наглядно показали, что старые, проверенные временем иконки безнадежно устарели и потеряли свою эффективность. И сегодня самый актуальный тренд в iOS-разработке — это думать о символах как о UIFont.
На практике это выглядит следующим образом. Для использования иконок в своих проектах ничего не потребуется, потому что они интегрированы в системный шрифт San Francisco. Для создания символа потребуются новые инициализаторы UIImage:
Из кода видно, что один из инициализаторов получил новый параметр `UIImage.Configuration`. В него можно передать значение параметра `UIImage.SymbolConfiguration`, который является наследником `UIImage.Configuration`. Учтите, что конфигурации неизменяемые, и применить новые параметры вы сможете только при использовании `applying(:)` (https://developer.apple.com/documentation/uikit/uiimage/configuration/3294236-applying).
Используя конфигурацию, можно изменять:
* PointSize;
* UIImage.SymbolScale;
* UIFont.TextStyle;
* UIImage.SymbolWeight;
* UIFont.
Расскажем подробнее о каждом пункте.
**Point size**
Этот параметр отвечает за размеры символов, а также показывает, что символ теперь не является обычной картинкой формата PNG. Также запомните, что с этого момента `Point size (CGFloat) != CGSize`. Поэтому теперь рассматривайте SF Symbols только вместе со значением point size. Эта взаимосвязь четко видна при совместном использовании символов и текста.
**UIImage.SymbolWeight**
Если вам нужно изменить толщину или жирность символов, как и у UIFont, воспользуйтесь для этого параметром `UIImage.SymbolWeight`.
**SymbolConfiguration.init (font: UIFont)**
Работать с этим параметром очень просто. С его помощью вам достаточно выбрать нужный UIFont, а дальше система всё сделает на «автопилоте».
**UIImage.SymbolScale**
На наш взгляд, это один из самых неоднозначных параметров. Первая функция, которую он выполняет — это изменение размера символа. И вот тут начинается самое интересное. Дело в том, что теперь у нас есть целых два активных параметра, влияющих на это. Но не стоит нервничать!
Из практического опыта можно сказать, что эти параметры не просто легко «уживаются вместе», а отлично дополняют друг друга. Мы специально смоделировали ситуацию и задали идентичный point size нашему UIFont в лайбе. И увидели, что размеры символа на экране визуально отличаются от размера текста (он остается больше или меньше него). Для облегчения работы, и чтобы не создавать ещё одну конфигурацию с использованием нового значения point size, рекомендуем воспользоваться параметром `SymbolScale`. Он изменит размер изображения, не меняя его point size.
**UIFont.TextStyle**
Это самый легкий в использовании параметр. Разработчики Apple рекомендуют пользоваться им, когда есть необходимость в реализации dynamic font type.
Из нашего рассказа видно, что большая часть представленных обновлений нацелена на то, чтобы разработчики приложений переосмыслили старые методы работы. Хотя нам кажется, что это только лишь малая часть того, с чем вы можете столкнуться в ближайшее время. Ну, а чтобы нововведения не застали вас врасплох, мы рекомендуем вам начать их освоение в ближайшее время! | https://habr.com/ru/post/470736/ | null | ru | null |
# Как «взломать» RedBull
На самом деле правильнее назвать статью «как накрутить себе баллы в конкурсе, чтобы выиграть целый холодильник RedBull». У нас, кстати, в офисе уже стоит такой холодильник с напитками.
Когда в очередной раз в офис доставили соки, газировки и другие напитки в офис, я обнаружил листовку с рекламой конкурса, суть которого заключалась в прохождении игры и победитель выигрывал холодильник энергетических напитков.
Второй холодильник нам бы не помешал – мы как раз расширились, и у нас появились новые офисные кабинеты. Поэтому я прошел по ссылке и решил попытать удачу, моя попытка оказалась провальной и я оказался где-то в конце рейтинга. Игра заключалась в том, чтобы пройти несколько уровней лабиринта максимально быстро.
Теперь надо надеть солнцезащитные очки, включить vpn, всевозможные прокси и т.д.
### Перейдем к делу
Прекрасно понимая, что любая игра в вебе – это последовательность запросов, и зная рынок разработки, на котором немало дилетантов, я решил попытать удачу в другом направлении и вдруг наткнусь на дыры в игре. Не то, чтобы мне так нужен был этот холодильник, просто появился спортивный интерес.
<http://redbull.ru/work>
Будем отслеживать запросы в браузере, после этого попробуем эти же запросы отправить, но уже с измененными значениями.
Первым делом идет запрос на старт игры:
```
https://rb-prjct-crtns-gamebackend-eu.herokuapp.com/api/high-scores/games/8970c40a-98f0-4395-85c8-66177fb38af0/runs
```
При этом в ссылке замечаем `id = 8970c40a-98f0-4395-85c8-66177fb38af0`.
Пару раз обновляем страницу в браузере, открывает с другого ip и в другом браузере, этот параметр не меняется, предполагаем, что это константа-идентификатор игры.
Еще замечаем, что в параметрах заголовка типа данных
```
accept:
application/vnd.api+json
```
В ответ на этот запрос получаем ответ:
```
{
"data":{
"attributes":{
"finished_at":null,
"game_day":114,
"game_week":17,
"score":null
},
"id":"4f89d56d-884e-42e8-909d-d1e7547cc1d8",
"links":{
"self":"https://rb-prjct-crtns-gamebackend-eu.herokuapp.com/runs/4f89d56d-884e-42e8-909d-d1e7547cc1d8"
},
"relationships":{},
"type":"runs"
},
"included":[],
"links":{
"self":"https://rb-prjct-crtns-gamebackend-eu.herokuapp.com/runs/4f89d56d-884e-42e8-909d-d1e7547cc1d8"
}
}
```
В ответе можно заметить разные атрибуты и еще один `id = 4f89d56d-884e-42e8-909d-d1e7547cc1d8`, который судя по всему является нашим персональным идентификатором игры.
Начинаем игру.
Наблюдаем над запросами. Видим, что ничего нового не появляется, то есть никакие этапы прохождения игры не триггерятся. На всякий случай проверил, может что-то ходит по веб-сокетам – там тоже пусто.
По завершению игры мы где-то в рейтинге, но мы не первые, что нас сильно огорчает. Пока что.
Смотрим в консоль и видим, что отправились еще 2 запроса, но один из них на получение статей, другой на получение рейтинга игроков. Полезного тут мало, запоминаем рейтинг первого места – 61454667.
Нажимаем на кнопку сохранения результата.
Отправился еще один запрос на url
```
https://rb-prjct-crtns-gamebackend-eu.herokuapp.com/api/high-scores/games/8970c40a-98f0-4395-85c8-66177fb38af0/runs/4f89d56d-884e-42e8-909d-d1e7547cc1d8/submit
```
с параметрами
```
{
"data":{
"id":"8970c40a-98f0-4395-85c8-66177fb38af0",
"type":"runs",
"attributes":{
"score":11041900
}
}
}
```
Становится очевидным, что ссылка формируется из статичного id игры и id нашей сессии. В параметрах передается счет, который будет сохранен за нами и участвовать в рейтинге.
На следующем этапе открывается страница с формой, которая подгружается в iframe. Замечаем, что в ссылке участвует наш сессионный id:
```
https://redbull.jotform.com/93071907238864&runid=4f89d56d-884e-42e8-909d-d1e7547cc1d8&runscore=11041900&redirect=https://maze.redbull.com
```
После отправки формы, получаем подтверждение.
Теперь повторим все те же самые запросы, но уже не через браузер.
Я буду использовать Postman.
Отправляем запрос на
```
https://rb-prjct-crtns-gamebackend-eu.herokuapp.com/api/high-scores/games/8970c40a-98f0-4395-85c8-66177fb38af0/runs
```
Получили ответ:
```
{
"data": {
"attributes": {
"finished_at": null,
"game_day": 114,
"game_week": 17,
"score": null
},
"id": "f95dad7c-eecf-4d3a-88e9-a32661a484e4",
"links": {
"self": "https://rb-prjct-crtns-gamebackend-eu.herokuapp.com/runs/f95dad7c-eecf-4d3a-88e9-a32661a484e4"
},
"relationships": {},
"type": "runs"
},
"included": [],
"links": {
"self": "https://rb-prjct-crtns-gamebackend-eu.herokuapp.com/runs/f95dad7c-eecf-4d3a-88e9-a32661a484e4"
}
}
```
Самое важное тут
```
id = f95dad7c-eecf-4d3a-88e9-a32661a484e4
```
Теперь формируем ссылку для получения рейтинга. Нам нужен будет наш сессионный id и результат, который будет больше текущего рекорда 61454667. Возьмем для эстетики первый цифры числа 2\*pi, как раз чуть больше рекорда.
Отправляем запрос
```
https://rb-prjct-crtns-gamebackend-eu.herokuapp.com/api/high-scores/games/8970c40a-98f0-4395-85c8-66177fb38af0/runs/f95dad7c-eecf-4d3a-88e9-a32661a484e4/leaderboard?score=62831853&filter[interval]=none
```
В ответе видим, что мы уже первые в списке, теперь сохраним результат.
Отправим запрос на
```
https://rb-prjct-crtns-gamebackend-eu.herokuapp.com/api/high-scores/games/8970c40a-98f0-4395-85c8-66177fb38af0/runs/f95dad7c-eecf-4d3a-88e9-a32661a484e4/submit
```
В этом запросе важно еще прописать атрибуты заголовков.
Супер! Все прошло ок, получили подтверждение результата. Теперь необходимо отправить контактные данные, чтобы с нами связались RedBull.
Для этого просто в браузере открываем ссылку с формой с нашим сессионным id.
```
https://redbull.jotform.com/93071907238864&runid=f95dad7c-eecf-4d3a-88e9-a32661a484e4&runscore=61454667&redirect=https://maze.redbull.com
```
Заполняем форму.
Отправляем.
Получаем подтверждение!
Конкурс уже закончился, он действовал до 31 января 2020.
P.S. На момент публикации розыгрыш завершен, во время проведения акции мы в ней не участвовали, на победу не претендовали. Все описания носят только информационный характер. Никакие коммерческие и иные ценности этими действиями не преследовались. | https://habr.com/ru/post/491446/ | null | ru | null |
# Макросы и квазицитаты в Scala 2.11.0
Не так давно состоялся [релиз Scala 2.11.0](http://habrahabr.ru/post/220469/). Одним из примечательных нововведений этой версии являются квазицитаты — удобный механизм для описания синтаксических деревьев Scala с помощью разбираемых во время компиляции строк; очевидно, что в первую очередь этот механизм предназначен для использования совместно с макросами.
Удивительно, но на хабре пока тему макросов в Scala рассматривают не слишком-то активно; [последний пост](http://habrahabr.ru/post/176285/)
с серьёзным рассмотрением макросов был аж целый год назад.
В данном посте будет подробно рассмотрено написание простого макроса, предназначенного для генерации кода десериализации JSON в иерархию классов.
#### Постановка задачи
Существует замечательная библиотека для работы с JSON для Scala — [spray.json](https://github.com/spray/spray-json).
Обычно для того, чтобы десериализовать какой-то JSON-объект с помощью этой библиотеки, достаточно пары импортов:
```
// Объявление класса, который будем десериализовывать:
case class MyClass(field: String)
// Импорт объектов spray.json:
import spray.json._
import DefaultJsonProtocol._
implicit val myClassFormat = jsonFormat1(MyClass)
val json = """{ "field\": "value" }"""
val obj = json.parseJson.convertTo[MyClass] // ok
```
Достаточно просто, не правда ли? А если мы хотим десериализовать иерархию классов целиком? Приведу пример иерархии, которую мы будем рассматривать в дальнейшем:
```
abstract sealed class Message()
case class SimpleMessage() extends Message
case class FieldMessage(field: String) extends Message
case class NestedMessage(nested: Message) extends Message
case class MultiMessage(field: Int, nested: Message) extends Message
```
Как видно, несколько десериализуемых классов с разным количеством аргументов различных типов наследуются от абстрактного родителя. Вполне естественное желание при десериализации таких сущностей — это добавить поле `type` в JSON-объект, а при десериализации диспетчеризоваться по этому полю. Идея может быть выражена следующим псевдокодом:
```
json.type match {
case "SimpleMessage" => SimpleMessage()
case "FieldMessage" => FieldMessage(json.field)
// ...
}
```
Библиотека spray.json предоставляет возможность определить конвертацию JSON в любые типы по определяемым пользователем правилам посредством расширения форматтера `RootJsonFormat`. Звучит совсем как то, что нам нужно. Ядро нашего форматтера должно выглядеть следующим образом:
```
val typeName = ...
typeName match {
case "FieldMessage" => map.getFields("field") match {
case Seq(field) => new FieldMessage(field.convertTo[String])
}
case "NestedMessage" => map.getFields("nested") match {
case Seq(nested) => new NestedMessage(nested.convertTo[Message])
}
case "MultiMessage" => map.getFields("field", "nested") match {
case Seq(field, nested) => new MultiMessage(field.convertTo[Int], nested.convertTo[Message])
}
case "SimpleMessage" => map.getFields() match {
case Seq() => new SimpleMessage()
}
}
```
Выглядит этот код немного… шаблонным. Это же отличная задача для макроса! Оставшаяся часть статьи посвящена разработке макроса, который сможет сгенерировать такой код, имея в качестве отправной точки лишь тип `Message`.
##### Организация проекта
Первое препятствие, с которым программист сталкивается при разработке макросов, заключается в том, что SBT не хочет компилировать одновременно и макрос, и использующий его код. Данная проблема рассмотрена в документации SBT и я рекомендую описанное ниже решение.
Нужно разделить код макросов и основной код приложения на два проекта, на которые следует сослаться в главном файле `project/Build.sbt`. В сопровождающем статью коде уже сделаны эти приготовления, вот ссылки на результирующие файлы:
* [главный сборочный файл `project/Build.sbt`](https://github.com/ForNeVeR/macrojson/blob/master/project/Build.scala);
* [проект для макросов: `macro/build.sbt`](https://github.com/ForNeVeR/macrojson/blob/master/macro/build.sbt);
* [основной проект: `main/build.sbt`](https://github.com/ForNeVeR/macrojson/blob/master/main/build.sbt).
Ещё одна тонкость заключается в том, что если вы хотите, чтобы макрос работал с иерархией классов — на момент раскрытия макроса эта иерархия должна быть известна. Это вызывает некоторые проблемы, т.к. последовательность обработки файлов компилятором не всегда очевидна. Решение этого вопроса — либо располагать классы, с которыми должен работать макрос, в одном проекте с макросом (при этом раскрытие макроса по-прежнему должно быть в другом проекте), или просто разместить нужные классы в том же файле, в котором производится раскрытие макроса.
При отладке макросов очень помогает параметр компилятора `-Ymacro-debug-lite`, который позволяет вывести в консоль результаты разворачивания всех макросов в проекте (эти результаты очень похожи на код Scala, и зачастую могут быть без изменений скомпилированы вручную при передаче компилятору, что может помочь в отладке нетривиальных случаев).
#### Макросы
Макросы в Scala работают почти так же, как reflection. Обратите внимание, Scala reflection API значительно отличается от Java reflection, поскольку не все концепции Scala известны стандартной библиотеке Java.
Механизм макросов в Scala предоставляет возможность создания участков кода во время компиляции. Это делается с помощью строго типизированного API, который генерирует синтаксические деревья, соответствующие коду, который вы хотите создать. Макросы Scala значительно отличаются от всем привычных макросов языка C, так что путать их не стоит.
В основе макросов Scala лежит класс `Context`. Экземпляр этого класса всегда передаётся макросу при раскрытии. Затем можно из него импортировать внутренности объекта `Universe` и использовать их точно так же, как в runtime reflection — запрашивать оттуда дескрипторы типов, методов, свойств и т.п. Этот же контекст позволяет создавать синтаксические деревья при помощи классов наподобие `Literal`, `Constant`, `List` и др.
По сути макрос — это функция, которая принимает и возвращает синтаксические деревья. Напишем шаблон нашего макроса:
```
import scala.language.experimental.macros
import scala.reflect.macros.blackbox.Context
import spray.json._
object Parsers {
def impl[T: c.WeakTypeTag](c: Context)(typeName: c.Expr[String], map: c.Expr[JsObject]): c.Expr[T] = {
import c.universe._
val cls = weakTypeOf[T].typeSymbol.asClass
val tree = ??? // построение синтаксического дерева будет рассмотрено дальше
c.Expr[T](tree)
}
def parseMessage[T](typeName: String, map: JsObject): T = macro Parsers.impl[T]
}
```
Макрос `parseMessage[T]` принимает тип `T`, который является базовым для иерархии десериализуемых классов, и синтаксическое дерево для получения типа десериализуемого объекта `map`, а возвращает синтаксическое дерево для получения десериализованного объекта, приведённого к базовому типу `T`.
Аргумент типа `T` описан специальным образом: указано, что компилятор должен приложить к нему неявно сгенерированный объект типа `c.WeakTypeTag`. Вообще говоря, неявный аргумент `TypeTag` используется в Scala для того, чтобы работать с типами-аргументами генериков, обычно недоступными во время выполнения из-за [type erasure](http://en.wikipedia.org/wiki/Generics_in_Java#Problems_with_type_erasure). Для аргументов макросов компилятор требует использовать не просто `TypeTag`, а `WeakTypeTag`, что, насколько я понимаю, связано с особенностями работы компилятора (у него нет «полноценного» `TypeTag` для типа, который может быть ещё не полностью сгенерирован во время раскрытия макроса). Тип, ассоциированный с `TypeTag`, можно получить при помощи метода `typeOf[T]` объекта `Universe`; соответственно, для `WeakTypeTag` существует метод `weakTypeOf[T]`.
Одним из недостатков макросов является неочевидность описания синтаксических деревьев. Например, фрагмент кода `2 + 2` при генерации должен выглядеть как `Apply(Select(Literal(Constant(2)), TermName("$plus")), List(Literal(Constant(2))))`; ещё более серьёзные случаи начинаются, когда нам нужно представить более крупные куски кода с подстановкой шаблонов. Естественно, такая сложность нам не нравится и мы будем её преодолевать.
#### Квазицитаты
Вышеупомянутый недостаток макросов начиная с версии Scala 2.11.0 может быть легко решён с помощью квазицитат. Например, вышеупомянутая конструкция, описывающая выражение `2 + 2`, в виде квазицитаты будет выглядеть просто как `q"2 + 2"`, что очень удобно. В целом квазицитаты в Scala — это набор строковых интерполяторов, которые расположены в объекте `Universe`. После импортирования этих интерполяторов в текущей область видимости появляется возможность использовать ряд символов перед строковой константой, которые определяют её обработку компилятором. В частности, при реализации рассматриваемой задачи нам пригодятся интерполяторы `pq` для паттернов, `cq` для веток выражения `match`, а также `q` для законченных выражений языка.
Как и для других строковых интерполяторов языка Scala, из квазицитат можно ссылаться на переменные окружающей их области видимости. Например, для генерации выражения `2 + 2` можно воспользоваться следующим кодом:
```
val a = 2
q"$a + $a"
```
Для переменных разных типов интерполяция может происходить по-разному. Например, переменные строкового типа в генерируемых деревьях становятся *строковыми константами*. Для того, чтобы сослаться на переменную по имени, нужно создать объект `TermName`.
Как видно из примера генерируемого кода, приведённого в начале статьи, нам нужно уметь генерировать следующие элементы:
* `match` по переменной `typeName` с ветками `case`, соответствующими каждому типу иерархии;
* в каждой ветке — передача списка названий аргументов конструктора соответствующего класса в метод `map.getFields`;
* там же — деконструкция полученной последовательности (с помощью того же выражения `match`) на переменные и передача этих переменных в конструктор типа.
В первую очередь рассмотрим генерацию общего дерева всего выражения `match`. Для этого придётся использовать интерполяцию переменных в контексте квазицитаты:
```
val clauses: Set[Tree] = ??? // см. ниже
val tree = q"$typeName match { case ..$clauses }"
```
В данном участке кода используется особый вид интерполяции. Выражение `case ..$clauses` внутри блока `match` будет раскрыто как список ветвей `case`. Как мы помним, каждая ветвь должна выглядеть следующим образом:
```
case "FieldMessage" => map.getFields("field") match {
case Seq(field) => new FieldMessage(field.convertTo[String])
}
```
В виде квазицитаты такая ветка может быть записана следующим образом:
```
val tpe: Type // обрабатываемый наследник
val constructorParameters: List[Symbol] // список параметров конструктора
val parameterNames = constructorParameters.map(_.name)
val parameterNameStrings = parameterNames.map(_.toString)
// Паттерны для дальнейшего матчинга создаются с помощью интерпорятора pq:
val parameterBindings = parameterNames.map(name => pq"$name")
// Это будут выражения, результаты которых передаются в конструктор:
val args = constructorParameters.map { param =>
val parameterName = TermName(param.name.toString)
val parameterType = param.typeSignature
q"$parameterName.convertTo[$parameterType]"
}
// Генерируем окончательный вид ветки case:
val typeName = tpe.typeSymbol
val typeNameString = typeName.name.toString
cq"""$typeNameString =>
$map.getFields(..$parameterNameStrings) match {
case Seq(..$parameterBindings) => new $typeName(..$args)
}"""
```
В данном фрагменте кода используется несколько квазицитат: выражение `pq"$name"` создаёт набор паттернов, которые в дальнейшем подставляются в выражение `Seq(...)`. Каждое из этих выражений имеет тип `JsValue`, который нужно преобразовать к соответствующему типу перед передачей в конструктор; для этого используется квазицитата, генерирующая вызов метода `convertTo`. Обратите внимание, этот метод может рекурсивно вызвать наш форматтер при необходимости (то есть можно вкладывать объекты типа `Message` друг в друга.
Наконец, результирующее синтаксическое дерево, состоящее из выражения `match` со сгенерированными нами ветками `case` может быть построено также с использованием интерполяции:
```
val tree = q"$typeName match { case ..$clauses }"
```
Это дерево будет встроено компилятором по месту применения макроса.
#### Выводы
В течение всего времени развития технологий, метапрограммирование становится всё более важным элементом языков программирования, всё чаще его применяют в повседневном коде для реализации различных концепций. Макросы Scala являются актуальным инструментом, который может избавить нас от различной рутинной работы, которую в мире JVM ранее было принято реализовывать через рефлексию или кодогенерацию.
Безусловно, макросы — это мощный инструмент, которым следует пользоваться осторожно: при неправильном использовании достаточно просто отстрелить себе ногу и упасть в пропасть неподдерживаемого кода. Однако всегда стоит стараться автоматизировать рутинную деятельность, и если макросы смогут стать для нас подспорьем в этой задаче — они будут использоваться и будут приносить пользу сообществу.
#### Использованные материалы
1. [Обзор макросов из документации Scala](http://docs.scala-lang.org/overviews/macros/overview.html).
2. [Обзор квазицитат из документации Scala](http://docs.scala-lang.org/overviews/quasiquotes/intro.html).
3. [Обзор строковой интерполяции из документации Scala](http://docs.scala-lang.org/overviews/core/string-interpolation.html).
4. [Руководство по макропроектам для SBT](http://www.scala-sbt.org/0.13.2/docs/Detailed-Topics/Macro-Projects.html).
5. [Исходный код и тесты к статье](https://github.com/ForNeVeR/macrojson). | https://habr.com/ru/post/224229/ | null | ru | null |
# Техническая реализация REST & user friendly уведомлений после редиректов
Иногда есть необходимость показывать пользователю уведомления после редиректа уже на новой странице.
В статье описаны достоинства и недостатки нескольких реализаций таких уведомлений,
#### Пример
Есть внутренний поиск по сайту:
Хотим в случаях когда результат только один сразу редиректить на его страницу, минуя полу-бесполезный список:
#### Удивлённый пользователь — счастливый пользователь
Просто так это делать плохо: что если наш поиск нашёл совсем не того Васю Пупкина которого искал пользователь, например, если другого у нас попросту нет?
Решение: на странице с профилем Васи мы будем выводить уведомление, что у нас есть только один Вася Пупкин и на его страницу вы сейчас смотрите:
#### Не REST-friendly решение
Перед тем как перенапавить пользователя на страницу Васи мы пишем в сессионное хранилище признак того, что хотим показать ему уведомление.
Грубый пример на PHP:
`php<br/
function doRedirect($location) {
$_SESSION['show_notice'] = true;
header("Location: $location");
}`
Когда показываем страницу Васи, проверяем флаг:
`php<br/
if (@$_SESSION['show_notice']) {
... показываем уведомление ...
}`
Чем плохо такое решение?
1. Если пользователь начнёт открывать много страниц одновременно, то в зависимости от реализации может наблюдать разные интересные эффекты (мелочи по сути).
2. Если вы захотите целиком кэшировать страницы, проблемы с учётом зависимостей не заставят себя долго ждать.
1-ую проблему можно решать рядом способов, но по сути полученное хитросплетение условий и таймаутов лишний раз намекнёт на то что в сессии этой информации не место.
UPD: Кстати если вместо сессии использовать куки то вторая проблема обретает решение. Жаль что первая обостряется только сильнее :)
Чтобы обойти эти две проблемы информацию о том показывать уведомление или нет надо передавать в URL-e.
Приходим к очередному решению.
#### GET параметр
Тут всё просто — просто кидаем пользователя, скажем, на [location/vasya/?show\_notice=1](http://location/vasya/?show_notice=1):
`php<br/
function doRedirect($location) {
header("Location: $location?show_notice=1");
}`
и при рендериге шаблона проверяем флаг:
`php<br/
if (@$_GET['show_notice']) {
... показываем уведомление ...
}`
* Никаких глюков с одновременно открывающимися страницами.
* Можно кэшировать страницы «в лоб» по URL-у.
Самый настоящий REST и только две неприятности:
* если будем кэшировать — страница будет лежать в кэше два раза — с блоком, и без него (по сути мелочь).
* пользователи начнут давать друг другу ссылки с "?show\_notice=1" — это уже не очень приятно..
#### document.location.hash
Ещё одно место куда можно запихнуть информацию об уведомлении это хэш.
Получится что-то вроде:
`php<br/
function doRedirect($location) {
header("Location: $location#show_notice");
}`
тогда пользователя перебросит, например, на [localhost/vasya/#show\_notice](http://localhost/vasya/#show_notice)
В отличие от GET параметров, сервер эту информацию попросту не получит так что показать уведомление получится только на клиенте, например, с помощью Javascript + PrototypeJS:
`Найдена только одна страница
<br/>
if(document.location.hash == '#show\_notice')) {<br/>
$("notice").show();<br/>
document.location.hash = '';<br/>
}<br/>`
Сразу после загрузки страницы [localhost/vasya/#show\_notice](http://localhost/vasya/#show_notice) адрес сменится (без перезагрузки!) на [localhost/vasya/#](http://localhost/vasya/#) (назойливую решётку убрать никак не получается, но ничего страшного в ней опять же нет). | https://habr.com/ru/post/69894/ | null | ru | null |
# Сыграем в DOOM на серверах
[](https://habr.com/ru/company/ruvds/blog/522314/)
У меня возникла безумная идея – это сыграть в классический DOOM по сети установленный на VPS под управлением Windows. В целом, это задумывалось как тестирование новых фич, которые мы внедряем: клонирование серверов и разворачивание локальной сети. Да, и на самом деле, это круто сыграть в DOOM прямо на серверах, особенно [после просмотра баек от Джона Ромеро](https://habr.com/ru/company/ruvds/blog/516800/) было невозможно не поиграть в легенду компьютерных игр.
Давайте посмотрим, что же из этого получилось, с какими проблемами столкнулся и как их решили.
В чём фишка?
------------
У нас появились две интересные возможности: разворачивание локальной сети и создание снапшотов. Если с локальной сетью всё более-менее понятно – это прекрасная альтернатива тому же VPN и разворачивается она сильно проще, то вот что такое снапшот – не все понимают. Да, и буду честен, я тоже не сразу понял. Снапшот позволяет сделать текущий образ сервера и потом на его базе создать другой сервер, даже с другими параметрами, таких как размер диска, памяти, количество ядер. Это очень удобно, особенно если вам необходимо ваш VPS-север перенести из одного дата-центра в другой. Другая возможность, которую мы будем использовать, это однократная настройка рабочего сервера, и потом клонирование его для ваших клиентов.
Понимаю, что всё это выглядит слишком рекламно, но изначально это был боевой тест наших внедрённых фишек. И благодаря ему мы смогли оценить все возникшие проблемы и оперативно их исправить. Поэтому и родилась данная статья.
Разворачиваем мастерсервер
--------------------------
Для этого проекта выбрал сервер со следующими параметрами.
Думаю, для наших задач такой конфигурации более чем достаточно. Изначально хотел использовать Windows Server 2003, но Doom наотрез отказался на ней работать, поэтому всё же решил остановиться на 2016.
Спустя несколько минут, после разворачивания сервера и загрузки операционной системы, мы увидим готовую панель, а главное IP адрес нашего сервера.
В качестве сетевого **DOOM** я использовал какую-то хитрую сборку Zandronum, DoomSeeker, BrutalDoom, которую мне дали друзья. Но, по сути, вам нужен будет один Zandronum и DoomSeeker для создания сервера, плюс оригинальный .wad-файл, если хотите поиграть на «тех самых картах». Ну или найти подобную сборку на просторах сети. Сразу признаюсь, я не большой знаток модов DOOM, попробовал несколько сборок, поэтому показываю работающий вариант. Возможно, если вы захотите это повторить, у вас должно получиться и с другими сборками. Тот же BrutalDoom намного более весёлый и резвый для игры по сети.
Итак, копируем эту сборку на наш сервер (я рекомендую использовать папку “c:\game\doom”), запускаем zandronum.exe.
И выбираем папку, содержащую WAD-файлы, на которых будем играть. Именно они и определят те карты, на которых вы будете играть. У меня они лежат в папке files вместе с игрой.
Всё готово, чтобы играть. Теперь сделаем копии нашего сервера и добавим их в единую локальную сеть, чтобы смогли поиграть и другие игроки по сети.
Создание копии серверов и объединение в единую локальную сеть
-------------------------------------------------------------
Для того, чтобы сделать копию сервера, нужно выключить сервер, зайти во вкладку «Снапшоты».
И выбрать «Сделать снапшот». Если сервер не выключен, то его предложат выключить в интерактивном режиме, так как снимок сервера для переноса осуществляется в выключенном состоянии (фактически копия диска).
В результате будет создан снапшот нашего сервера.
Основной сервер после этого можно запустить, а на базе данного снапшота мы можем создать новые сервера. Для этого идём во вкладку «Заказать»
В разделе, где выбирается «Шаблон сервера», в самом низу будет наш Snapshot, выбираем его.
Обратите внимание, что можно выбрать сервер с другими параметрами. Это очень удобно, если вам необходимо увеличить объём жёсткого диска, ОЗУ и прочего. Разве, что нет возможности сохранить IP-адрес.
В результате, после описанных операций, через некоторое время мы получаем копию нашего сервера. Копия от оригинала отличается только паролём входа, и другими IP и MAC-адресами.
После создания второго сервера, давайте объединим их единую локальную сеть Для это переходим во вкладку «Сеть» любого сервера.
Там выбираем «Настроить локальные сети».
Далее можно дать название нашей локальной сети, например Doom, выбираем диапазоны подсети; после чего можно добавляем сервера, которые мы хотим подключить в эту локальную сеть. После нажимаем «Создать локальную сеть».
И окончательно сеть разворачивается после нажатия на кнопку «Развернуть локальную сеть».
Вот тут кроется одна проблема: Windows очень любит обновления, не даёт перезагрузить сервер в момент установки изменений. Так как Windows обновляется часто, то достаточно легко можно попасть на момент обновления в момент создания сети. Во время подготовки материала для статьи я так попал дважды. Для создания сети требуется перезагрузка сервера, и если перезагрузить не удалось, то сеть может создаться с ошибкой.
**Установка проклятых обновлений в момент создания сети.**
Во избежание таких проблем при создании сети, самое правильное данные процедуры проводить на выключенных серверах, ибо всё равно потребуется перезагрузка для разворачивания сети. А у выключенного сервера внезапно обновления ставиться не будет.
После всех описанных процедур у нас будет развёрнута локальная сеть и в панели управления серверами будет такая картина.
**Сервера в единой сети.**
После воспоминаний о проблемах и тонкостях разворачивании OpenVPN, этот вариант создания локальной сети просто чудо-чудное! Лично для меня он оказался наиболее удобным.
Как вы понимаете, таким же точно способом мы создаём ещё несколько серверов, на которых уже смогут играть мои коллеги.
Создаём игровой сервер и играем.
--------------------------------
Всё, теперь нам осталось только запустить сервер DOOM и играть. На мастер-сервере запускаем doomseeker.exe.
Выбираем «Create Server».
После чего выбираем для какого движка создаём сервер, какой wad-файл использовать и карту.
И жмём «Start server».
После этого на главной машине и на клиентских запускаем zandronum.exe и идём в `Multiplayer`. `Browse servers->internal browse`, там выбрать `local`. Это меню не всегда срабатывает, поэтому в него надо заходить несколько раз.
Не забываем выбрать наш сервер. Жмём «join game» и мы в игре!
Итог
----
**Коллеги играют в DOOM на рабочем месте.**
Наш коллектив достаточно классно порубился в игру, и теперь у нас есть удалённые рабочие машины с запущенной игрой. Их можно передавать другим коллегам или играть из дома. Это, кстати актуально, для пошаговых стратегий, когда можно таким образом сохранять прогресс.
Но главное, что удалось в игровой форме протестировать внедрение новых фич. Все остались довольны.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=dlinyj&utm_content=doom_on_vps#order)
[](http://ruvds.com/ru-rub/news/read/123?utm_source=habr&utm_medium=article&utm_campaign=dlinyj&utm_content=doom_on_vps) | https://habr.com/ru/post/522314/ | null | ru | null |
# Mono 2.10.1 и MonoDevelop 2.6 с работающим дизайнером форм в extras-testing репозиториях для N900
А вдруг я ещё не всех задолбал?
В общем, с помощью чёрной магии, лома и какой-то матери мне таки удалось заставить Mono собираться под скрэтчбоксом, а MonoDevelop довести до вменяемого состояния, так что теперь нормально работает редактор GUI.
Чтобы поставить это чудо себе на железку, надо подключить extras-testing (этого ещё кто-то не сделал?) и выбрать его в менеджере программ. Если была установлена версия из прошлого поста, то её лучше зачистить, ибо может криво обновиться.
#### Нестандартные технические решения
На аппарате нет понятия правого клика. Вообще нет, его нечем делать. В том же WinMobile это есть с незапамятных времён, причём отключаемо для тех окошек, которым оно не надо (см. SHRecognizeGesture). Ну, не положили и не положили. Наверное это как-то было оправдано. Ну да ладно, вешаем при инициализации биндингов к Gtk фильтр на все оконные события и правим их как надо. В общем, правый клик теперь работает при нажатой клавише Fn (со стрелочкой).
Ну, менюшки менюшками, а гуёвый дизайнер хоть и работает, но компоненты на форму класть не даёт. Почему? А всё просто. В *GTK отключен Drag-n-Drop*. Когда я копал, пытаясь понять в чём дело, я обнаружил в начале функции gtk\_begin\_drag следующее:
```
#ifdef MAEMO_CHANGES
/* Reject any DND requests unconditionally. */
return NULL;
#endif
```
Нормально, да? Никаких тебе конфигов, настроек и переменных окружения. Просто топорно вырубили. Это, видимо, задел на будущее для добавления «новых» фич раскомментированием кода. После перекомпиляци без этой строчки Drag-n-Drop чудесным образом заработал, представляете? Ну, системное гтк трогать не стоит, мало ли что у них там из-за этого сломается, так что теперь так и гружу правильную библиотеку через LD\_PRELOAD.
Автобилдер для репов с логикой не дружит совершенно. Пример. В пакете исходного кода есть пакеты только с архитектурой all. Их собирают под i386. Если там помимо архитектуры all засветилось i386, то где это всё начнут компилять? Правильно, под ARM.
Об остальных особенностях, пожалуй, промолчу, пора уже заканчивать пятиминутку ненависти. В принципе сама IDE завелась практически без патчей (большая часть косяков, связанных с GTK исправляется спец. кодом в биндингах). Это говорит в пользу программистов Novell (или кто там их купил?), особенно учитывая, что Maemo до сих пор базируется на коде Debian 3.0. Кстати, свежего MonoDevelop пока что даже в репах debian experimental нет.
Что же касается самого рантайма, то основная идея состоит в том, чтобы распилить пакет исходников на 2 части, одна из которых будет под i386 спокойно собирать управляемые бинарники, а вторая их вообще не трогает и занимается только нативным.
Соответственно после получения собранного рантайма заставить компилер работать в arm-ом скрэтчбоксе было делом пары скриптов и похищенных предварительно из i386-ного нормальных библиотек. Бинари для i386 грузятся мимо qemu-arm, так что если перетащить ld-linux.so.2 с нужными зависимостями, то ничто не мешает запускать родной для процессора код. В результате компилер стартует именно таким образом.
В общем, как-то так. Теперь у нас есть полноценная IDE.
UPD: Я, похоже, проворонил какие-то неочевидные зависимости. Если не запускается, ставьте ещё mono-complete. Пофикшенный пакет сейчас компилируется. | https://habr.com/ru/post/118435/ | null | ru | null |
# Сенсорная крышка для мусорного ведра своими руками
В статье расскажу, как превратить обычное ведро с крышкой в автоматическое.
Подошел к ведру — крышка открылась, положил в него что надо, отошел — крышка закрылась.
Ведро использовано металлическое блестящее, крышка открывается педалью, такие ведра можно найти во многих магазинах.
Для доработки ведра использованы ИК светодиод, ИК приемник, сервопривод, микроконтроллер.
Управление и контроль перегрузки сервопривода осуществляется c помощью микроконтроллера ATtiny44A фирмы Atmel.
Программа управления написана на C в Atmel Studio 6.1.
#### Электронная начинка
##### Алгоритм работы
* ИК светодиод постоянно шлет некий бинарный код, ИК приемник его читает и если произошло совпадение выдается команда на открытие крышки.
* После открытия крышки ждем 7 сек и закрываем крышку, если сенсор не активен.
* Если во время открытия крышка уперлась в препятствие, то — пищим, ждем некоторое время (3 сек) и повторяем попытку. При повторной неудачи «засыпаем» на более длительное время (60 сек).
##### ИК Датчик
Принцип работы основан на свойстве отражения ИК лучей от препятствия.
ИК диод посылает в пространство модулированную кодовую посылку, а ИК приемник ее принимает.
Для регулирования мощности передачи используется подстроечный резистор RV1.
Несущая частота сигнала 38 кГц.
Используется бифазное (манчестерское) кодирование. Для него не требуется кварцевой стабилизации частоты.
Вот осциллограммы кодирования бита:
Вот осциллограмма пакета:
ИК приемник (я использовал Vishay TSOP4838) принимает сигнал, декодирует и выдает на выход пакет в инвертированном виде.
Пакет повторяется через определенное время:
ИК приемник устройство «умное» и пытается отфильтровать сигнал, подавляя помехи, различные импульсы, которые не подходят под его понимания подходящего формата пакета.
Поэтому между пакетами должны быть пауза не меньше минимальной.
Например, при использовании TSOP4838, если сделать паузу в 15 бит при длине пакета 8 бит, то приемник будет достаточно часто пропускать пакеты.
При паузе в 30 бит — пакеты не пропускаются.
##### Сервопривод
Для открывания крышки используется стандартная серва Futaba S3001.
У нее выдаваемое усилие при 4.8 В около 2.4 кг-см, а при 6 В — 3 кг-см.
Крышка металлическая и относительно тяжелая, но данного сервопривода для нее хватает.
Питание на сервопривод подается только на время его позиционирования. Для этого используется Logic level MOSFET транзистор.
Для контроля потребляемого сервоприводом тока используется резистор 0.5 Ом.
Микроконтроллер замеряет падение напряжения на нем и, при превышении, отключает питание сервопривода.
Пиковое значение потребляемого тока во время открытия крышки 500 мА, во время закрытия — 150 мА, при «заклинивании» — 550 мА.
Сервопривод управляется импульсами длительностью от 1.1 до 1.8 мс, которые следуют каждые 0.02 секунды.
После окончания управляющего импульса сервопривод, при необходимости, начинает позиционироваться.
Осциллограммы:
Желтым — управляющие импульсы, голубым — потребление сервопривода (падение напряжения на шунте).
Вот осциллограмма начала нормального позиционирования сервопривода:
Нормальное позиционирование, где-то в середине перемещения:
Вот осциллограммы заклинивания сервы:
При старте держим руками:
Как можно видеть, в самом начале идет достаточно большое потребление практически не зависимо от того может сервопривод перемещаться или нет.
Так же видно, что моментальное потребление сервопривода не может быть больше определенного значения, и для контроля невозможности перемещения привода нужно, в идеальном случае, вычислять площадь под голубым графиком.
В программе падение напряжения на шунте считываются c помощью АЦП и используется простой способ суммирования моментальных значений в течении периода. Если сумма превышает определенный порог — сервопривод останавливается.
Порог подбирается экспериментально.
Значение при котором произошло срабатывание защиты сохраняется в EEPROM.
Схема:
##### Программа
Программа написана на С в Atmel Studio 6.1.
Использован микроконтроллер AVR ATtiny44A c 14 выводами в DIP корпусе.
Работает он на частоте приблизительно 7904000 Гц для того, чтобы легко получить 38000 Гц для ИК светодиода.
По умолчанию частота 8 МГц, и частота 7.9 МГц получена путем изменения регистра OSCCAL.
У меня получилось значение 0xA7 при напряжении 5 В.
При изменении напряжения питания или температуры частота немного уйдет, но на работоспособность ИК датчика это влияния не оказывает.
Для передачи — приема ИК сигнала, управления сервоприводом, отсчета времени используется один единственный 8-ми битный таймер, работающий на частоте 988 кHz и настроенный на режим Fast PWM.
Частота сигнала задается регистром OCR0A. В нем значение, при котором будет обнуляться счетчик таймера (TCNT0).
В OCR0B заносится значение, определяющее коэффициент заполнения импульсов. В нашем случае — 50%.
Таймер настроен так, что смена значения на выводе контроллера, к которому подключен ИК диод, происходит 2 раза в период (заданный OCR0A) — при нулевом значении TCNT0 и когда TCNT0 равен OCR0B.
В прерывании по равенству TCNT0 и OCR0B выполняется все работа по приему — передачи ИК сигнала.
```
ISR(TIM0_COMPB_vect)
{
static uint8_t IR_error = 0;
if(++IR_pulsecnt == IR_BIT_LENGTH/2)
{
if(IR_pausecnt == 0)
{
if(((IRSENS_IN & IRSENS) == 0) != ((TCCR0A & (1<>=1;
}
}
}
}
```
Особенность функции отправки такова — пакет считается отправлен, когда битовый буфер равен 0. Это значит, что в старшем разряде пакета для отправки всегда должна быть единица.
Генерирование ИК сигнала начинается при установки бита COM0B1 в регистре TCCR0A. Подразумевается, что бит COM0B0 равен 0 и нигде до этого не устанавливался.
Управление сервоприводом, отсчет времени, подавление дребезга контакта кнопок выполняются в прерывании по переполнению этого же таймера.
В стандартном режиме, открытие крышки выполняется в два этапа — сначала несколько циклов медленно, затем быстро до полного открытия. Сделано для уменьшении нагрузки на сервопривод и тяги.
Первая кнопка используется для ручного открытия или закрытия крышки.
Вторая кнопка для остановки открытия и для включения/выключения быстрого режима открытия.
##### Сборка
Сервопривод подключается к вертикальной тяге, горизонтальная тяга и педаль выбрасываются.
ИК диод и приемник крепятся в выступающую пластиковую ножку. Места для них там как раз хватает.
Видео:
Исходник:
[yadi.sk/d/OGTOvX73Agk8h](http://yadi.sk/d/OGTOvX73Agk8h) | https://habr.com/ru/post/197070/ | null | ru | null |
# Кто умнее чем IDEA?
Два года назад я вызвался постоять на стенде нашей компании JetBrains на последней конференции [JBreak](https://2018.jbreak.ru/) в Новосибирске. Перед конференцией мне спустили сверху вот такие карточки:
И сказали, мол, ну раздай каким-нибудь людям на конференции на своё усмотрение. Я запаниковал. Как же я буду людей-то выбирать?
Тогда я довольно плотно работал с анализом потока данных в статическом анализаторе IntelliJ IDEA для Java. Во-первых, я обкатывал новые фичи, проверяя код самой IDE. Во-вторых, разгребал входящие баг-репорты. Иногда IDEA находила удивительные проблемы, и мне приходилось долго разбираться, чтобы вообще понять, правильное ли предупреждение она выдаёт или это баг.
Пока шёл первый доклад конференции, я решил из этого материала быстренько сварганить игру. Набрал пачку свежих примеров из головы (в основном из реального кода). В каждом случае стояла задача объяснить предупреждение, которое выдаёт IDEA, или обосновать, что предупреждение ложное. За правильные ответы я и раздавал трёхмесячные лицензии на все наши десктопные продукты.
Теперь я предлагаю те же самые задачки решить вам. Многие простые, на внимательность. Но есть такие, где надо хорошенько подумать.
1 Обход списка
**Отгадка**Предупреждение верное. Мы не знаем ни длину входного списка `args`, ни длину массива `parameters`. Однако сколько бы ни было параметров на первой итерации цикла `i == 0`, а длина списка не может быть меньше нуля по контракту. Это означает, что до второй итерации дело никогда не дойдёт, потому что исключение вылетит уже на первой.
2 Наилучшая точка
**Отгадка**Предупреждение верное. Массив `variants` определён прямо здесь и имеет четыре элемента. Значит, мы точно зайдём в цикл. На первой итерации `if (best == null || distance > d)` совершенно точно истинно, потому что в начале `best == null`. Значит, `best = variant` будет точно выполнено. А `variant`, конечно, никогда не `null`. Даже если бы мы не видели инициализаторов массива, мы можем это сказать потому что был вызван метод `variant.distance`.
3 Свойства драйверов
**Отгадка**Предупреждение ошибочное. В переменной `value` действительно может быть `null`, но в этом случае массив `result` будет пустым, и мы в цикл никак не зайдём. IDEA 2018.1 не понимала таких тонкостей, но в скором времени мы её научили. Теперь этого предупреждения нет.
4 Нулл или не нулл?
**Отгадка**Этот код прислал пользователь в наш баг-трекер, сказав, что IDEA выдаёт ложное предупреждение. На самом деле предупреждение верное. Входной массив имеет заведомо ненулевую длину, операция `map` не меняет число элементов стрима (возможно, автор хотел написать `filter`), а значит, операция `findFirst` точно что-то найдёт и ветка `orElse(null)` никогда не выполнится.
5 Инициализация поля
Может быть все дочерние классы по контракту устанавливают поле `name`, и предупреждение ложно?
**Отгадка**Предупреждение в целом верное. Только стоит писать не "may produce", а "will produce" (в свежих версиях это исправлено). У нас нет шанса инициализировать поле `name`, какая бы ни была реализация метода `init()`. Дело в том что объект `this` не утекает из конструктора. Метод `init()` вызывается, но на родительском объекте, который передан параметром. Из него мы никак не сможем доступиться до объекта, который сейчас конструируется. Да, `init()` может устанавливать `name` родительского объекта, но `name` текущего ему не доступен, а значит, мы можем быть уверены, что после вызова `init()` там всё ещё `null`.
6 Генерация имён классов
**Отгадка**Предупреждение верное. Я разбирал этот случай в отдельной статье "[Статический анализ → уязвимость → профит](https://habr.com/ru/post/326384/)"
7 Индикаторы
**Отгадка**Предупреждение ложное. Видно, что подсвеченный метод вызовется только при `indicator == 2`, а это возможно только если и `riseBinding`, и `sinkBinding` не равный null. С тех пор, конечно, IDEA поумнела и нормально разбирается в таком коде, не выдавая предупреждения.
8 Лямбда с побочным эффектом
**Отгадка**Предупреждение верное. Мы видим лямбду, в которой `exception[0]` может перезаписаться заведомо ненулевым исключением. Проблема однако в том, что до условного оператора лямбда ни разу не могла быть выполнена. Она используется после условия. Соответственно, `exception[0]` не мог быть перезаписан. Вероятно, условие и последующий вызов следует переставить местами.
9 Груви-туплы
**Отгадка**Предупреждение верное. Тут всё просто: вместо `i < initializers.length` было написано `initializers.length < i`. Соответственно индекс массива всегда больше его длины. Учитывая, что этот код существовал давно, скорее всего неправильное условие никогда не выполнялось и до исключения дело не доходило. Интересно, что `return` в котором подсвечена ошибка — единственный полезный выхлоп всего условия `if (parent instanceof GrTuple)`. То есть десять строчек этого метода никогда не делали никакой полезной работы.
10 Префиксы
**Отгадка**Тоже несложно. `filePrefix` и `linePrefix` могут быть переприсвоены только одновременно. Им присваиваются элементы массивов `filePrefixes` и `linePrefixes` соответственно, в которых нет нуллов. То есть если `filePrefix` оказался не нуллом, то и в `linePrefix` нулла быть не может. Предупреждение верное, хотя в целом это не ошибка, просто перестраховочное условие.
Надеюсь, задачки вам понравились. К чему я всё это вспомнил через два года? Всё потому что 29 февраля в Новосибирске пройдёт новая Java-конференция [SnowOne](https://snowone.ru/). JetBrains также будет спонсировать эту конференцию, и я сейчас вовсю готовлю новую порцию задачек. Призы будут такие же — трёхмесячная лицензия на все продукты JetBrains. Приходите поиграть! | https://habr.com/ru/post/489156/ | null | ru | null |
# Диаграммы в LaTeX
Многие достаточно часто сталкиваются с необходимостью создания различных диаграмм, графов, деревьев для удобного представления информации. Особенно важным этот вопрос может оказаться при создании презентаций. Большинство офисных пакетов предоставляют возможность создавать красивые диаграммы при помощи интерактивного интерфейса. А если нужно создать большую диаграмму? Или записать в ней математические формулы? Сосредоточиться на содержании, а не оформлении и расположении элементов на экране?
Преимущества использования LaTeX уже неоднократно [обсуждались](http://habrahabr.ru/blogs/latex/46073/). Так же как и способы [создания](http://habrahabr.ru/blogs/latex/62584/) презентаций при помощи beamer и векторная [графика](http://habrahabr.ru/blogs/latex/48260/) из пакета PGF/Tikz. Но возможно ли получить в LaTeX диаграммы, не уступающие по внешнему виду полученным в больших и сложных пакетах? Один из способов предложен ниже.
### Начало
Для начала нам потребуется LaTeX (для Windows подойдет [MiKTeX](http://miktex.org/), для Linux или Mac — [TeXlive](http://www.tug.org/texlive/)), а также пакеты [beamer](http://latex-beamer.sourceforge.net/) и [tikz](http://sourceforge.net/projects/pgf/). Оба входят в комплект поставки MiKTeX. Скачать последние версии можно либо со страниц проектов, либо из [CTAN](http://ctan.org/). Также потребуются базовые знания о LaTeX, и использовании в нем этих пакетов. Поскольку beamer ориентирован на использование pdflatex, использоваться будет в основном именно PDF.
### Простая диаграмма
Попробуем сделать небольшую и простую диаграмму. В качестве примера возьмем последовательное преобразование форматов при работе LaTeX: .tex > .dvi > .ps > .pdf. Допустим у нас уже есть документ, в который надо эту диаграмму поместить. В преамбуле подключаем пакет tikz и подключаем нужные библиотеки. В данном случае нам потребуются positioning и arrows, которые нужны для расположения элементов друг относительно друга и рисования стрелок между ними соответственно.
> `**\usepackage**{tikz}
>
> **\usetikzlibrary**{positioning,arrows}`
Необходимо заметить, что при перечислении имен библиотек через запятую не допускаются пробелы. Это связано с тем, что tikz подставляет строку полностью как часть имени файла с библиотекой.
В нужном месте документа добавляем окружение tikzpicture, внутри которого перечисляются команды tikz. Каждая команда должна оканчиваться точкой с запятой. Команды могут быть вложенными, например для создания стрелки с подписью или дочерних элементов. Общий синтаксис команды:
> `\command [parameters] (name) {contents} arguments;`
где * command — собственно команда;
* parameters — параметры команды через запятую;
* name — имя создаваемого объекта;
* contents — содержание объекта (может включать другие объекты);
* arguments — аргументы, например точки пути или размеры, а также другие команды (но уже без обратного слеша).
Все части, кроме самой команды, необязательны. В tikz сотни команд, интересными для нас будут path и node.
Команда \path создает «контур» в терминологии векторной графики. В качестве параметра указывается что именно следует сделать с этим контуром: * draw — только нарисовать контур;
* fill — только залить;
* fill,draw — нарисовать контур и залить;
* use as bounding box — использовать контур как ограничение размера для картинки.
Также указать на наличие и направление стрелок <-, ->, <->, цвет, толщину линии и другие параметры, полный перечень можно прочитать в документации к пакету.
В качестве аргументов передаются координаты, через которые контур должен проходить. В tikz существует много вариантов задания координат: * относительные координаты точки (1,5);
* реальные на листе, во всех форматах LaTeX (10pt, 3mm);
* использование полярных и даже введение собственной системы координат;
* относительно предыдущей точки ++(0,1);
* относительно начальной точки +(-1,2);
* относительно именованного объекта (name).
Точки, между которыми требуется провести линию разделяются оператором --. Наиболее подходящим к идеологии LaTeX является позиционирование относительно объектов. Например для рисования связи между краями объектов foo и bar достаточно выполнить команду
> `**\path** (foo) edge (bar);`
Команда \node создает узел (или объект), как правило содержащий некий текст. Её параметрами могут быть стиль текста, цвет, информация о наличии, форме и цвете очертаний, расположение относительно других объектов и многие другие. Расположить узел в конкретном месте с координатами (x, y) можно при помощи аргумента at (x, y). Но наиболее интересным является расположение относительно других объектов, предоставляемое библиотекой positioning. Для его использования достаточно указать в параметрах в каком направлении относительно другого объекта должен находиться данный. Например
> `**\node** (foo) {foo};`
Более подробную информацию можно получить в документации. Перечисленного вполне достаточно, чтобы создать первую несложную диаграмму. В ней должно быть 4 объекта, и 3 стрелки между ними. Реализация выглядит так
> `**\node** (tex) {.tex};`
### Улучшаем диаграмму
Первая картинка у нас уже получилась, но она совершенно не смотрится: смещенная линия текста, отсутствие рамок вокруг текста, слишком близко расположенные объекты. И это вместо красивых картинок с градиентами и прозрачностью? Диаграмму определенно стоит улучшить, и для этого мы воспользуемся заданием стилей. Стиль задается при помощи команды
> `**\tikzstyle**{name} = [parameters]`
Имя стиля потом может быть передано как параметр другой команды. Для дальнейшей работы нам также потребуется подключить библиотеки shapes и shadows. Хорошей фигурой для текста будет прямоугольник со скругленными краями, который имеется в библиотеке. Для него дополнительно потребуется описать фон и контур. Прежде чем это сделать, давайте разберемся со способами задания цвета в tikz.
Цвет может задаваться названием из предопределенных в LaTeX и пакете xcolor. Также можно определить свой RGB-цвет при помощи команды
> `**\definecolor**{name}{rgb}{0.5,0.5,0.5}`
Через запятую указаны RGB-компоненты и их количество от 0 до 1. Или в других системах, о чем можно подробнее прочитать в документации пакета xcolor. Также предопределенные цвета можно смешивать. Синтаксис этой операции таков:
> `color1!percent!color2`
В результате получится цвет, содержащий percent% первого цвета и (100-percent)% второго. Если второй не указан — по умолчанию используется белый цвет. Смешивание цветов можно повторять, не сохраняя промежуточный цвет, например
> `red!50!black!50!white`
Сначала будет получен цвет из 50% красного и 50% черного, а потом результат смешан с 50% белого. В результирующем красного и черного цветов окажется по 25%.
Теперь можем перейти непосредственно к заданию стиля
> `**\tikzstyle**{format} = [rounded rectangle,`
Данный стиль предписывает нарисовать прямоугольник со скругленными краями, жирной линией контура с цветом red!50!black!50, залить его используя градиент сверху вниз от белого цвета до red!50!black!20, с тенью, внутренний текст печатать курсивом.
Далее нам следует выровнять базовую линию текста. Для этого сначала разберемся, почему он оказался смещенным. Слова «tex», «ps» и «pdf» имеют разную высоту, и соответственно различным образом были отцентрованы внутри объекта. Таким образом явное задание высоты текста должно решить эту проблему.
Окружение tikzpicture также позволяет задавать параметры, которые действуют для всех команд внутри этого окружения. Воспользуемся этим и зададим в нем толщину линии связи, минимальное расстояние между объектами и параметры высоты текста.
> `**\begin**{tikzpicture}[thick,`
### Усложняем задачу
Теперь, когда мы получили приемлемый вариант простой диаграммы попробуем усложнить задание. Добавим в эту диаграмму способы представления данных (на экране и печатная) и возможности преобразования без промежуточных форматов. Поскольку линий на диаграмме будет немало, то стоит их подписать.
Определим другой стиль узла для способа представления данных. Пусть это будет эллипс с синим градиентом сверху вниз, темно-синим контуром и тенью. Описание стиля будет похожим на предыдущее.
> `**\tikzstyle**{format} = [ellipse,`
Но при добавлении дополнительных линий возникает ещё одна проблема. Если задать путь от (tex) до (pdf) tikz по умолчанию проведет его прямой линией, что нас совершенно не устраивает. К сожалению, использовать возможности graphviz пакет пока не умеет, поэтому придется самим описывать путь вокруг элементов. Для этого будем использовать относительное задание путей.
> `**\path**[->, draw] (tex) -- +(0,2) -| (pdf);`
Первый контур начинается от узла (tex) и поднимается на 2 относительные единицы вверх. После чего продолжается вправо до образования перпендикуляра к узлу (pdf) и опускается к нему. Второй контур начинается от узла (dvi), поднимается на 1 единицу, идет вправо на 3 единицы относительно предыдущей точки, и по прямой направляется к узлу (pdf). Для добавления подписей к контурам воспользуемся вложенными командами и добавим узел к контуру:
> `**\path**[->, draw] (tex) -- +(0,2) -| node[near start] {pdf**\LaTeX**} (pdf);`
Но данная команда добавит объект таким образом, чтобы центры контура и узла совпали. Текст окажется перечеркнутым линией связи. Чтобы этого не произошло в окружении tikzpicture укажем параметр автоматического позиционирования подписей auto. Теперь описание нашей диаграммы примет вид
> `**\begin**{tikzpicture}[thick,`
### Используем в презентации
Полученную диаграмму можно использовать как статическую картинку в статье или описании. Но для презентации часто требуется, чтобы объекты диаграммы появлялись в определенном порядке. В LaTeX для создания презентаций используется пакет beamer. Его работа строится вокруг понятия оверлеев — различных представлений одного и того же слайда. Об использовании beamer уже писали, поэтому вспомним о спецификации оверлеев. Их можно добавить практически к любой команде LaTeX, и команды tikz не исключение. Поэтому любые иллюстрации, полученные с помощью этого пакета легко разделяются на части и интегрируются с beamer. Однако сейчас команды расположены не совсем удобно для добавления оверлеев. Если потребуется, чтобы одновременно появлялись объект и все его связи с уже существующими, придется добавлять спецификации к каждой из команд. Логичнее было бы расположить команды последовательно по времени появления на слайде. На помощь тут приходит возможность группировать команды, о которой было сказано в самом начале. В команде \path можно указать узлы, которые она будет соединять. Таким образом мы можем сделать по одной команде на каждый оверлей.
> `**\begin**{frame}`
---
Что получилось в результате можно посмотреть [здесь](https://docs.google.com/leaf?id=0B_kKkcpg74fNMTU4ODAzY2UtYjVkMi00YzM2LTllZTEtMmUxYjBmMjgzZDAx&hl=en).
\_\_\_\_\_\_\_\_\_
**При подготовке использованы**
[PGF/Tikz manual](http://www.ctan.org/tex-archive/graphics/pgf/base/doc/generic/pgf/pgfmanual.pdf)
[Xcolor manual](http://www.tex.ac.uk/tex-archive/macros/latex/contrib/xcolor/xcolor.pdf)
[Beamer manual](http://www.ctan.org/tex-archive/macros/latex/contrib/beamer/doc/beameruserguide.pdf)
[The TeX workflow example](http://www.texample.net/tikz/examples/tex-workflow/) | https://habr.com/ru/post/81751/ | null | ru | null |
# Обзор Cool Dates — сервиса анонсов будущих событий
[](http://cooldates.ru)
На прошлой неделе [someone](https://geektimes.ru/users/someone/), в своем посте [«Уведомления о событиях»](http://someone.habrahabr.ru/blog/58105/) представил идею по созданию сервиса-уведомителя о предстоящих событиях. Как и обещала, подготовила обзор подобного сервиса.
[Cool Dates](http://cooldates.ru) – это сервис, посвященный анонсам будущих событий. Я пользуюсь им уже около 2,5 лет.
Сервис позволяет знакомиться с будущими событиями, которые создали зарегистрированные пользователи. Тематика неограниченна. Это может быть: личное событие (день рождения соседа-любовника; дата предстоящего экзамена по философии; дата, когда я поговорю «по-мужски» с соседом — любовником моей жены); события политические (предстоящие выборы, дебаты и т.д.); события праздничные (День пищевика, День десантника и т.д.); события, связанные с деятельностью той или иной компании (пресс-релизы, анонсы мероприятий); события, связанные, например, с группой «Земфира» (концерты, ближайшие пресс-конференции, выход нового альбома); анонсы, готовящихся к выходу на экраны, фильмов; релизы компьютерных игр, систем, программ, ну и т.д.
На события можно подписаться. Можно получать на почту напоминания-уведомления по каждому выбранному событию, либо подписаться на ленту RSS: на новые события, на ближайшие события, на события блога сервиса и события в группах.
Существует возможность разместить HTML-кнопку-счетчик событий, например, у себя на блоге:
«персональный» — ``,
счетчик одного события ``
и, третий счетчик, самый большой, состоит из трех ближайших событий, созданных самим или события, созданные любым выбранным пользователем. ``
Подробно о счетчиках можно почитать [здесь](http://cooldates.ru/public/AboutCounters.aspx), а создать счетчик можно, нажав на знак рядом с выбранным событием.
Понятно, что зарегистрировавшись, вы сами можете создавать свои события, подписываться на них и получать уведомления на почту. А пометив свое событие как «Публичное», пользователи сервиса могут его видеть в заданные дни.
На мой непредвзятый взгляд, сервис может служить и как личная система уведомлений, так и публичная, используемая в коммерческих целях, но совершенно бесплатно.
Если есть, что добавить, присоединяйтесь. | https://habr.com/ru/post/58446/ | null | ru | null |
# Пишем Ruby gem для Yandex Direct API
Очень хотелось изучить Ruby получше, а рабочего проекта не было. И я попробовал написать gem для работы с Yandex Direct API.
Причин было несколько. Среди них: Yandex Direct API очень типичен для Яндекса и современных REST-сервисов вообще. Если разобраться и преодолеть типичные ошибки, то можно легко и быстро написать аналоги для прочих API Яндекса (и не только). И ещё: у всех аналогов, которые мне удалось найти, были проблемы с поддержкой версий Директа: одни были заточены под 4, другие под новую 5, и поддержке units я нигде не нашёл.
Метапрограммирование — великая вещь
===================================
Основная идея gem-а — раз в языке вроде Ruby или Python можно создавать новые методы и JSON-подобные объекты на лету, то методы интерфейс для доступа к REST-сервису могут повторять функции самого Rest-сервиса. Чтобы можно было писать так:
```
request = {
"SelectionCriteria" => {
"Types" => ["TEXT_CAMPAIGN"]
},
"FieldNames" => ["Id", "Name"],
"TextCampaignFieldNames" => ["BiddingStrategy"]
}
options = { token: Token }
@direct = Ya::API::Direct::Client.new(options)
json = direct.campaigns.get(request)
```
А вместо того, чтобы писать справку, отсылать пользователей к мануалам по указанному API.
Методы из старых версий вызывать, например, так:
```
json = direct.v4.GetCampaignsList
```
На тот случай, если вам не интересно читать, а хочется попробовать — готовый gem можно взять отсюда:
* [ya-api-direct на RubyGems](http://rubygems.org/gems/ya-api-direct/)
* [ya-api-direct на GitHub](http://github.com/rikkimongoose/ya-api-direct)
О получении omniauth-token из rails можно узнать [из примера по twitter](https://www.sitepoint.com/rails-authentication-oauth-2-0-omniauth/). А названия методов и процедура регистрации очень подробно расписана в [документации от Яндекса](https://tech.yandex.ru/direct/).
Если интересны подробности — они дальше.
Начинаем разработку
-------------------
Разумеется, в статье описан самый базовый опыт и самые простые вещи. Но она может быть полезна начинающим (вроде меня), как памятка по созданию типового gem-а. Собирать информацию по статьям, конечно, интересно, — но долго.
Наконец, может быть, что кому-то из читателей действительно надо по быстрому добавить поддержку Yandex Direct API в свой проект.
А ещё она будет полезна мне — в плане фидбека.
Проверочный скрипт
------------------
Для начала зарегистрируемся в Yandex Direct, создадим там тестовое приложение и получим для него временный Token.
Потом откроем [справку по Yandex Direct API](https://tech.yandex.ru/direct/) и поучимся вызывать методы. Как-нибудь так:
Для версии 5:
```
require "net/http"
require "openssl"
require "json"
Token = "TOKEN" # Сюда пишем тестовый TOKEN.
def send_api_request_v5(request_data)
url = "https://%{api}.direct.yandex.com/json/v5/%{service}" % request_data
uri = URI.parse(url)
request = Net::HTTP::Post.new(uri.path, initheader = {
'Client-Login' => request_data[:login],
'Accept-Language' => "ru",
'Authorization' => "Bearer #{Token}"
})
request.body = {
"method" => request_data[:method],
"params" => request_data[:params]
}.to_json
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
response = http.request(request)
if response.kind_of? Net::HTTPSuccess
JSON.parse response.body
else
raise response.inspect
end
end
p send_api_request_v5 api: "api-sandbox", login: "YOUR LOGIN HERE", service: "campaigns", method: "get", params: {
"SelectionCriteria" => {
"Types" => ["TEXT_CAMPAIGN"]
},
"FieldNames" => ["Id", "Name"],
"TextCampaignFieldNames" => ["BiddingStrategy"]
}
```
Для версии 4 Live (Token подходит к обоим):
```
require "net/http"
require "openssl"
require "json"
Token = "TOKEN" # Сюда пишем тестовый TOKEN.
def send_api_request_v4(request_data)
url = "https://%{api}.direct.yandex.com/%{version}/json/" % request_data
uri = URI.parse(url)
request = Net::HTTP::Post.new(uri.path)
request.body = {
"method" => request_data[:method],
"param" => request_data[:params],
"locale" => "ru",
"token" => Token
}.to_json
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
response = http.request(request)
if response.kind_of? Net::HTTPSuccess
JSON.parse(response.body)
else
raise response.inspect
end
end
p send_api_request_v4 api: "api-sandbox", version: "live/v4", method: "GetCampaignsList", params: []
```
Эти скрипты уже годятся для отладки и быстрых тестовых запросов.
Но, как учит нас (мифический) человеко-месяц, скрипт для себя и библиотека для других — это два разных класса приложений. И чтобы передалать один в другой, предстоит попотеть.
Создаём gem
===========
Для начала надо было определиться с названием — простым и не занятым. И пришёл к выводу, что **ya-api-direct** — это то, что надо.
Во-первых, сама структура логична — и если появится, к примеру, ещё и ya-api-weather, то будет ясно, к чему он относится. Во-вторых, у меня всё-таки не официальный продукт от Яндекса, чтобы использовать торговую марку как префикс. К тому же, это намёк на [ya.ru](http://ya.ru/), где бережно хранится прежний лаконичный дизайн.
Создавать руками все папки немного лениво. Пусть за нас это сделает bundler:
```
bundle gem ya-api-direct
```
В качестве средства для UnitTest я указал minitest. Потом будет ясно, почему.
Теперь у нас есть папка, и в ней готовый для сборки gem. Его единственный недостаток в том, что он совершенно пуст.
Но сейчас мы это исправим.
Пишем тесты
-----------
UnitTest-ы невероятно полезны для выявления хитро спрятаных багов. Почти каждый программист, который всё-таки сподобился их написать и исправил попутно пару десятков багов, что затаились в исходниках, обещает себе, что будет их теперь писать всегда. Но всё равно не пишет.
В некоторых проектах (наверное, их пишут особенно неленивые программисты) есть одновременно и test и spec-тесты. Но в последних версиях minitest вдруг научился spec-интерфейсу, и я решил обойтись и одними spec-ами.
Так как интерфейс у нас онлайновый и, к тому же, за каждый запрос с нас списываются баллы, мы подделаем ответы от Yandex Direct API. Для этого нам потребуются хитрый gem [webmock](https://github.com/bblimke/webmock).
Добавляем в gems
```
group :test do
gem 'rspec', '>= 2.14'
gem 'rubocop', '>= 0.37'
gem 'webmock'
end
```
Обновляем, переименовываем папку test в spec. Так как я торопился, то тесты написал только для внешних интерфейсов.
```
require 'ya/api/direct'
require 'minitest/autorun'
require 'webmock/minitest'
describe Ya::API::Direct::Client do
Token = "TOKEN" # Не трогаем, т.к. API всё равно ненастоящий.
before do
@units = {
just_used: 10,
units_left: 20828,
units_limit: 64000
}
units_header = {"Units" => "%{just_used}/%{units_left}/%{units_limit}" % @units }
@campaigns_get_body = {
# Тут взятый из справки Yandex Direct API пример результата запроса
}
# Тут другие инициализации
stub_request(:post, "https://api-sandbox.direct.yandex.ru/json/v5/campaigns")
.with(
headers: {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Accept-Language'=>'en', 'Authorization'=>'Bearer TOKEN', 'Client-Login'=>'', 'User-Agent'=>'Ruby'},
body: {"method" => "get", "params"=> {}}.to_json)
.to_return(:status => 200,
body: @campaigns_get_body.to_json,
headers: units_header)
# Дальше инициализируем другие запросы
@clientV4 = Ya::API::Direct::Client.new(token: Token, api: :v4)
@clientV5 = Ya::API::Direct::Client.new(token: Token)
end
```
webmock подменяет методы стандартных библиотек для работы с HTTP, чтобы при запросах с определёнными телом и заголовками возвращался соответствующий ответ.
Если вы ошиблись настройке, это не страшно. Когда вы попытаетесь отправить запрос, которого нет в фильтре, то webmock сообщит об ошибке и даже подскажет, как написать стаб правильно.
И пишем spec-и:
```
describe "when does a request" do
it "works well with version 4" do
assert @clientV4.v4.GetCampaignsList == @campaigns_get_body
end
it "works well with version 5" do
assert @clientV5.campaigns.get == @campaigns_get_body
end
end
# и все остальные
```
### Rake
Rake реализован настолько гибко и просто, что чуть ли не в каждой библиотеке он устроен по-своему. Поэтому я просто велел ему запускать все файлы, которые назваются spec\_\*.rb и лежат в директории spec:
```
require "bundler/gem_tasks"
require "rake/testtask"
task :spec do
Dir.glob('./spec/**/spec_*.rb').each { |file| require file}
end
task test: [:spec]
task default: [:spec]
```
Теперь наши spec-и можно вызывать так:
```
rake test
```
Или даже:
```
rake
```
Правда, тестировать ему пока нечего.
Пишем gem
---------
Сначала заполяем с информацией о gem-е (без этого bundle откажется запускаться). Потом пишем в gemspec, какие сторонние библиотеки будем использовать.
```
gem 'jruby-openssl', platforms: :jruby
gem 'rake'
gem 'yard'
group :test do
gem 'rspec', '>= 2.14'
gem 'rubocop', '>= 0.37'
gem 'webmock'
gem 'yardstick'
end
```
Делаем
```
bundle install
```
и отправляемся в lib создавать файлы.
Файлы у нас будут такие:
* **client.rb** — внешний интерфейс
* **direct\_service\_base.rb** — базовый сервис для работы с API
* **direct\_service\_v4.rb** — сервис для работы с API 4 и 4 Live
* **direct\_service\_v5.rb** — сервис для работы с API 5
* **gateway.rb** — пересылает и обрабатывает сетевые запросыю=
* **url\_helper.rb** — всякие статические функции, которым не место в **gateway.rb**
* **constants.rb** — список доступных методов Yandex DIrect API
* **exception.rb** — исключение, чтобы ошибки API показывать
* **version.rb** — служебный файл с настройками версии
### Контроллеры для разных версий
Для начала создадим файл с константами, в который и запишем все функции из API.
**contants.rb**
```
module Ya
module API
module Direct
API_V5 = {
"Campaigns" => [
"add", "update", "delete", "suspend", "resume", "archive", "unarchive", "get"
],
# и т.д.
}
API_V4 = [
"GetBalance",
# и т.д.
]
API_V4_LIVE = [
"CreateOrUpdateCampaign",
# и т.д.
]
end
end
end
```
Теперь создадим базовый сервис-обёртку, от которого мы унаследуем сервис для версий 4 и 5.
**direct\_service\_base.rb**
```
module Ya::API::Direct
class DirectServiceBase
attr_reader :method_items, :version
def initialize(client, methods_data)
@client = client
@method_items = methods_data
init_methods
end
protected
def init_methods
@method_items.each do |method|
self.class.send :define_method, method do |params = {}|
result = exec_request(method, params || {})
callback_by_result result
result[:data]
end
end
end
def exec_request(method, request_body)
client.gateway.request method, request_body, @version
end
def callback_by_result(result={})
end
end
end
```
В конструкторе он получает исходный клиент и список методов. А потом создаёт их внутри себя через :define\_method.
А почему нам не обойтись методом respond\_to\_missing? (как до сих пор делают многие gem-ы)? Потому что он медленней и не такой удобный. И без того небыстрый интерпретатор попадает в него после исключения и проверки в is\_respond\_to\_missing?.. К тому же, созданные таким образом методы попадают в результаты вызова methods, а это удобно для отладки.
Теперь создадим сервис для версий 4 и 4 Live.
**direct\_service\_v4.rb**
```
require "ya/api/direct/constants"
require "ya/api/direct/direct_service_base"
module Ya::API::Direct
class DirectServiceV4 < DirectServiceBase
def initialize(client, methods_data, version = :v4)
super(client, methods_data)
@version = version
end
def exec_request(method, request_body = {})
@client.gateway.request method, request_body, nil, (API_V4_LIVE.include?(method) ? :v4live : @version)
end
end
end
```
В версии 5 сервер не просто отвечает на запросы пользователя, но ещё и сообщает, сколько баллов потрачено на последнем запросе, сколько осталось и сколько их было в текущей сессии всего. Наш сервис должен уметь их разбирать (но мы пока не написали, как он это сделает). Но мы заранее укажем, что он должен обновлять поля в основном клиентском классе.
**direct\_service\_v5.rb**
```
require "ya/api/direct/direct_service_base"
module Ya::API::Direct
class DirectServiceV5 < DirectServiceBase
attr_reader :service, :service_url
def initialize(client, service, methods_data)
super(client, methods_data)
@service = service
@service_url = service.downcase
@version = :v5
end
def exec_request(method, request_body={})
@client.gateway.request method, request_body, @service_url, @version
end
def callback_by_result(result={})
if result.has_key? :units_data
@client.update_units_data result[:units_data]
end
end
end
end
```
Кстати, вы заметили, что за вызов запроса отвечает какой-то загадочный gateway?
### Gateway и UrlHelper
Класс Gateway обеспечивает запросы. В него переехала большая часть кода из нашего скрипта.
**gateway.rb**
```
require "net/http"
require "openssl"
require "json"
require "ya/api/direct/constants"
require "ya/api/direct/url_helper"
module Ya::API::Direct
class Gateway
# конструктор тоже есть
def request(method, params, service = "", version = nil)
ver = version || (service.nil? ? :v4 : :v5)
url = UrlHelper.direct_api_url @config[:mode], ver, service
header = generate_header ver
body = generate_body method, params, ver
uri = URI.parse url
request = Net::HTTP::Post.new(uri.path, initheader = header)
request.body = body.to_json
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
http.verify_mode = @config[:ssl] ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
response = http.request(request)
if response.kind_of? Net::HTTPSuccess
UrlHelper.parse_data response, ver
else
raise response.inspect
end
end
# а чуть ниже объявлены generate_header и generate_body
# они есть в исходниках, поэтому обрезаны
end
end
```
Стандартый Net::HTTP задействован, потому что прост как грабли. Вполне можно посылать запросы и из [faraday](https://github.com/lostisland/faraday). На ней и так работает OmniAuth (про который я расскажу ниже), так что лишними gem-ами приложение не обрастёт.
Наконец, UrlHelper заполняем статичными функциями, которые генерируют URL, разбирают данные и парсят Units (что несложно):
```
require "json"
require "ya/api/direct/exception"
module Ya::API::Direct
RegExUnits = Regexp.new /(\d+)\/(\d+)\/(\d+)/
class UrlHelper
def self.direct_api_url(mode = :sandbox, version = :v5, service = "")
format = :json
protocol = "https"
api_prefixes = {
sandbox: "api-sandbox",
production: "api"
}
api_prefix = api_prefixes[mode || :sandbox]
site = "%{api}.direct.yandex.ru" % {api: api_prefix}
api_urls = {
v4: {
json: '%{protocol}://%{site}/v4/json',
soap: '%{protocol}://%{site}/v4/soap',
wsdl: '%{protocol}://%{site}/v4/wsdl',
},
v4live: {
json: '%{protocol}://%{site}/live/v4/json',
soap: '%{protocol}://%{site}/live/v4/soap',
wsdl: '%{protocol}://%{site}/live/v4/wsdl',
},
v5: {
json: '%{protocol}://%{site}/json/v5/%{service}',
soap: '%{protocol}://%{site}/v5/%{service}',
wsdl: '%{protocol}://%{site}/v5/%{service}?wsdl',
}
}
api_urls[version][format] % {
protocol: protocol,
site: site,
service: service
}
end
def self.extract_response_units(response_header)
matched = RegExUnits.match response_header["Units"]
matched.nil? ? {} :
{
just_used: matched[1].to_i,
units_left: matched[2].to_i,
units_limit: matched[3].to_i
}
end
private
def self.parse_data(response, ver)
response_body = JSON.parse(response.body)
validate_response! response_body
result = { data: response_body }
if [:v5].include? ver
result.merge!({ units_data: self.extract_response_units(response) })
end
result
end
def self.validate_response!(response_body)
if response_body.has_key? 'error'
response_error = response_body['error']
raise Exception.new(response_error['error_detail'], response_error['error_string'], response_error['error_code'])
end
end
end
end
```
Если сервер вернул ошибку, мы кидаем Exception с её текстом.
Код выглядит самоочевидным и это весьма хорошо. Самоочевидный код легче поддерживать.
### Client
Теперь нам нужно написать сам класс клиента, с которым взаимодействуют внешние интерфейсы. Так как большая часть функционала уже переехала во внутренние классы, то он будет очень коротким.
```
require "ya/api/direct/constants"
require "ya/api/direct/gateway"
require "ya/api/direct/direct_service_v4"
require "ya/api/direct/direct_service_v5"
require "ya/api/direct/exception"
require 'time'
module Ya::API::Direct
AllowedAPIVersions = [:v5, :v4]
class Client
attr_reader :cache_timestamp, :units_data, :gateway,
:v4, :v5
def initialize(config = {})
@config = {
token: nil,
app_id: nil,
login: '',
locale: 'en',
mode: :sandbox,
format: :json,
cache: true,
api: :v5,
ssl: true
}.merge(config)
@units_data = {
just_used: nil,
units_left: nil,
units_limit: nil
}
raise "Token can't be empty" if @config[:token].nil?
raise "Allowed Yandex Direct API versions are #{AllowedVersions}" unless AllowedAPIVersions.include? @config[:api]
@gateway = Ya::API::Direct::Gateway.new @config
init_v4
init_v5
start_cache! if @config[:cache]
yield self if block_given?
end
def update_units_data(units_data = {})
@units_data.merge! units_data
end
def start_cache!
case @config[:api]
when :v4
result = @gateway.request("GetChanges", {}, nil, :v4live)
timestamp = result[:data]['data']['Timestamp']
when :v5
result = @gateway.request("checkDictionaries", {}, "changes", :v5)
timestamp = result[:data]['result']['Timestamp']
update_units_data result[:units_data]
end
@cache_timestamp = Time.parse(timestamp)
@cache_timestamp
end
private
def init_v4
@v4 = DirectServiceV4.new self, (API_V4 + API_V4_LIVE)
end
def init_v5
@v5 = {}
API_V5.each do |service, methods|
service_item = DirectServiceV5.new(self, service, methods)
service_key = service_item.service_url
@v5[service_key] = service_item
self.class.send :define_method, service_key do @v5[service_key] end
end
end
end
end
```
Методы версии 4 записываются в свойство v4, методы версии 5, сгруппированные по отдельным сервисам, становятся методами класса клиента через уже знакомую нам конструкцию. Теперь, когда мы вызываем client.campaigns.get Ruby сначала выполнит client.campaigns(), а потом вызовет у полученного сервиса метод get.
Последняя срока конструктора нужна, чтобы класс можно было использовать в конструкции do… end.
Сразу после инициализации же выполняет (если это указано в настройках) start\_cache!, чтобы послать API команду на включение кэширования. Версия в настройках влияет только на это, из экземпляра класса можно вызывать методы обоих версий. Полученная дата будет доступна в свойстве cache\_timestamp.
А в свойстве units\_data будут лежать последние сведения по Units.
Также в проекте есть класс с настройками версии и исключения. С ними всё настолько понятно, что даже и сказать нечего. Класс с настройками версий и вовсе сгенерирован bundle вместе с проектом.
Ну а файле **direct.rb** нужно указать те классы, которые должны быть видны пользователю снаружи. В нашем случае это только класс клиента. Плюс версия и исключение (он они совсем служебные).
Компилируем и заливаем
----------------------
Чтобы cкомпилировать gem, можно следовать [мануалу с RubyGems.org](http://guides.rubygems.org/make-your-own-gem/) (там ничего сложного). Или применить [Mountable Engine из Rails](https://habrahabr.ru/post/216141/).
А потом загружаем на rubygems — вдруг этот gem может быть полезен не только нам.
Как получить token из Ruby on Rails
-----------------------------------
Войти из Rails в Yandec API и получить токен — дело очень простое для любого разработчика… если не в первый раз.
Как мы уже узнали, для доступа к Direct API требуется токен. Из [справки от Яндекса](https://oauth.yandex.ru/) следует, что перед нами — старый добрый OAuth2, которым пользуется куча сервисов, включая Twitter и Facebook.
Для Ruby есть классический gem [omniauth](https://github.com/omniauth/omniauth), от которого и наследуют реализации OAuth2 для различных сервисов. Уже реализован и [omniauth-yandex](https://github.com/evrone/omniauth-yandex). С ним мы и попытаемся разобраться.
Создадим новое rails приложение (добавлять в рабочие проекты будем после того, как научимся). Добавляем в Gemfile:
```
gem "omniauth-yandex"
```
И делаем bundle install.
А потом пользуемся любым мануалом по установке Omniauth-аутенфикации для rails. [Вот пример для twitter](https://www.sitepoint.com/rails-authentication-oauth-2-0-omniauth/). Переводить и пересказывать его, я думаю, не стоит — статья и так получилась огромная.
У меня описанный в статье пример заработал. Единственной поправкой было то, что я не стал писать в таблицу User дополнительные индексы, потому что их не поддерживает SQLite.
Правда, в статье не указано, где скрывается token. Но это совсем не секрет. В SessionController его можно будет получить через
```
request.env['omniauth.auth'].credentials.token
```
Только не забывайте — каждая такая аутенфикация генерирует token заново. И если вы потом попытаетесь использовать скрипты с прямым указанием token, то сервер будет говорить, что старый уже не подходит. Надо вернуться в настройки приложения Яндекса, снова указать отладочный callback URL (\_\_<https://oauth.yandex.ru/verification_code__>), а затем заново сгенерировать token.
А ещё лучше — создать для статичного токена отдельное приложение, чтобы отлаживать не мешал.
Ссылки
------
* [ya-api-direct на RubyGems](http://rubygems.org/gems/ya-api-direct/)
* [ya-api-direct на GitHub](http://github.com/rikkimongoose/ya-api-direct)
* [Cправки по Yandex OAuth](https://oauth.yandex.ru/)
* [Справка по Yandex Direct API](https://tech.yandex.ru/direct/)
* [Онлайн-курс по Yandex Direct API](https://yandex.ru/adv/edu/direct-api)
* [Настройка omniauth-twitter](https://www.sitepoint.com/rails-authentication-oauth-2-0-omniauth/)
* [omniauth-yandex](https://github.com/evrone/omniauth-yandex)
* [webmock](https://github.com/bblimke/webmock) | https://habr.com/ru/post/311512/ | null | ru | null |
# Клиент Caché ODBC в Linux
Несколько лет назад заказчик, крупный медицинский центр федерального значения, поручил нам разработать софт, обслуживающий информационные киоски. Внешне киоск напоминает платёжный терминал (только без купюроприёмника), его основная функция, как следует из названия, — предоставление пациентам различной информации, такой как расписание приёма врачей, услуги и их стоимость, и так далее.
По понятным причинам для киоска потребовалось разработать упрощённый интерфейс пользователя, который было решено реализовать как web-приложение. Имея в штате опытных web-программистов, уверенно владеющих php, решили (для скорости) поручить им его написание, организовав связь с базой данных нашей медицинской системы. Рассматривалось 3 варианта взаимодействия:
* ODBC
* JDBC
* web-сервисы.
Web-программисты предпочли ODBC как наиболее простой с их точки зрения вариант, и альфа-версия киоска довольно быстро увидела свет. Однако вскоре выяснилось (surprise!), что php-код должен работать не под Windows, как это было у разработчика, а под Linux, несмотря на то, что в те годы наша медицинская система эксплуатировалась заказчиком на платформе Windows 2008. Чтобы «подружить» всех членов триады (Linux – ODBC-драйвер Caché — php5) потребовались определённые усилия. Последовательность проделанных действий я зафиксировал в виде наброска к данной статье, которую и предлагаю вашему вниманию.
#### Установка драйвера ODBC
Это можно сделать несколькими способами, а именно, с помощью:
* пользовательской установку Caché for Linux, выбрав ODBC Client как опцию;
* клиентской установки (скрипт cinstall\_client, имеется в DVD-версии дистрибутива);
* отдельной установки (Stand-alone installation) клиента ODBC.
Ниже будет описан последний вариант как наиболее практичный, поскольку может быть выполнен как с .tar.gz-дистрибутива, так и с его полной DVD-версии, а также из дистрибутива ODBC-драйвера Caché, распространяемого в виде отдельного файла. Проверено в Ubuntu 9.10 и в Fedora 8 с ODBC-драйверами Caché 2008.1 и 2009.1.
Cмонтируйте dvd с дистрибутивами Caché для UNIX-ов и перейдите в каталог с дистрибутивами ODBC:
```
sudo mount /dev/dvd /media
```
Если ваш дистрибутив не на DVD, а в виде .tar.gz-файла (например, cache-2009.1.2.602-lnxrhx64.tar.gz), распакуйте его куда-нибудь. Дальнейшее не зависит от варианта дистрибутива. Создайте (где вам удобно) папку для установки драйвера. Обозначим её $folder.
```
mkdir $folder
```
Найдите в дистрибутиве драйвер под вашу платформу:
```
cd /media/dist/ODBC
```
Если у вас x86\_x64, выберите ODBC-lnxrhx64.tar.gz, если x86\_x32, то — ODBC-lnxrhx86.tar.gz. Скопируйте архив в выбранную вами папку $folder и распакуйте его в ней, после чего запустите инсталлятор. Установка пройдёт в ту же папку, вопросов не будет.
```
cd $folder
tar -xvf ODBC-lnxrhx86.tar.gz
./ODBCinstall
```
#### Настройка источников данных
Далее, перейдите в mgr
```
cd $folder/mgr
```
и отредактируйте файл cacheodbc.ini, изменив определения Driver, Host, Port (и, возможно, Password) в секциях описаний источников данных:
```
[Samples]
Driver = $folder/bin/libcacheodbc.so
Description = Cache ODBC driver
Host = IP-адрес или DNS-имя сервера Caché
Namespace = SAMPLES
UID = _SYSTEM
Password = SYS (если Caché установлена с минимальной безопасностью, то скорее всего, этот пароль подойдёт)
Port = TCP-порт суперсервера Caché (обычно 1972)
```
Для проверки драйвера и источника данных Samples выполните:
```
cd $folder/dev/odbc/samples/select
./select.sh # простейший select из таблицы Samples.Person
```
Здесь уместно небольшое замечание. После установки драйвер Caché ODBC for Linux предстаёт в двух ипостасях: libcacheodbc.so (8-бит) и libcacheodbciw.so (Unicode). В наших условиях как источник данных (установка Caché), так и клиент (php-приложение) были 8-битными (кодировка CP1251), поэтому далее речь пойдёт лишь о 8-битной версии драйвера.
#### Работа с источниками данных (DSN) Caché ODBC из apache2 / php5
##### Установка локализации CP1251
Результирующий набор, возвращаемый Caché ODBC, при использовании 8-битной версии драйвера всегда имеет кодировку CP1251 (вне зависимости от типа установки Caché — 8-бит (локализация RUW8) или Unicode (RUSW)). Нас это вполне устраивало, так как появления многоязычия в прикладных данных не ожидалось. Надо было лишь установить в Linux соответствующую локализацию. Например, в Ubuntu 9.10 это делается так:
```
sudo locale-gen ru_RU.CP1251
locale -a | grep 1251
```
в списке локализаций появятся:
```
ru_RU.cp1251
```
В RedHat-подобных дистрибутивах (проверено в Fedora Core 8, CentOS 5.x) локализация устанавливается так:
```
sudo localedef --no-archive -c -f CP1251 -i ru_RU ru_RU.CP1251
```
Проверка наличия ru\_RU.cp1251 выполняется аналогично:
```
locale -a | grep 1251
```
Далее, чтобы из php можно было обращаться к DSN, надо прописать их в ODBC-менеджере. Наиболее известны следующие два: iodbc и unixodbc. Первый более универсален, так как позволяет использовать оба варианта драйвера Caché ODBC: 8 бит и Unicode. Второй более широко распространён и проще в установке, но (в случае Caché) поддерживает только 8 бит. Это не явилось для нас дополнительным ограничением, поэтому за основу был принят unixodbc. Ниже — описание его установки в Ubuntu 9.10.
##### Установка менеджера ODBC unixodbc (в Ubuntu 9.10)
Методика позаимствована из [ru.php.net/manual/en/function.odbc-connect.php](http://ru.php.net/manual/en/function.odbc-connect.php). А именно, установите:
```
sudo apt-get install <имя-пакета>
```
следующие пакеты:
```
apache2
apache2-mpm-prefork
apache2-utils
apache2.2-common
libapache2-mod-php5
odbcinst1debian1
php5
php5-cli
php5-common
php5-odbc
unixodbc
```
после чего перезапустите apache:
```
sudo /etc/init.d/apache2 restart
```
##### Регистрация драйвера и DSN Caché ODBC в unixodbc
Вспомнив, что Caché ODBC был установлен в $folder, выполните:
```
cd $folder/dev/odbc/redist/unixodbc
```
Скопируйте odbcinst\_template.ini в odbcinst.ini и дважды пропишите в этом файле путь к драйверу ($folder/bin/libcacheodbc.so). Скопируйте odbc\_template.ini в odbc.ini и пропишите в этом файла IP, Port, Namespace, UID и Password, соответствующие источнику данных. Повторите для каждого DSN, если их несколько. Для тестирования имеет смысл создать источник Samples (его заготовка присутствует в odbc\_template.ini), используя те же параметры, что и в разделе «Настройка источников данных». Создайте также DSN, нацеленный на прикладную область (допустим, она называется QMS), добавив новую секцию в odbc.ini путем копирования секции [samples]. Назовите секцию так же, как называется область, и поменяйте — по отношению к Samples — всего один параметр:
```
[QMS]
...
Namespace = QMS
```
Все DSN могут быть описаны в одном файле odbc.ini.
Используемые значения Host, Namespace, Port, UID и Password должны соответствовать действительности, а именно, по этим реквизитам должны быть доступны области Caché, содержащие таблицы и/или хранимые процедуры. Способ проверки, понятное дело, зависит от вида хранимых данных. Если в вашей Caché сервис %Service\_Bindings допускает вход без аутентификации, можно оставить реквизиты UID и Password пустыми (обязательно оба этих поля). В некоторых версиях Сache в примере odbc\_template.ini задано неверное значение Password для суперпользователя \_system, отличное от действующего по умолчанию при выборе минимальной безопасности в Caché (подсказка: пароль зависит от регистра). Кроме того, администратор Caché мог изменить пароль. И наконец, сохранять логин/пароль в DSN небезопасно, так поступать рекомендуется лишь в ходе тестирования; в процессе эксплуатации более целесообразно «зашить» их в php-приложение и передавать серверу при установлении соединения через ODBC.
Далее зарегистрируйте драйвер и все имеющиеся DSN:
```
sudo odbcinst -i -d -f odbcinst.ini
sudo odbcinst -i -s -l -f odbc.ini
```
После регистрации в файлах /etc/odbc.ini и /etc/odbcinst.ini должны появиться соответствующие записи.
##### Тестирование в php
Если вы всё сделали правильно и описали источник данных SAMPLES, заработает пример $folder/dev/odbc/samples/php/sample.php, установленный вместе с драйвером Caché ODBC. Если вы захотите попробовать что-нибудь русское (ну и наконец приступить к тестированию вашей разработки), не забудьте вставить поближе к началу вашего php-кода установку текущей локализации CP1251:
```
echo setlocale(LC_ALL, 'ru_RU.CP1251', 'rus_RUS.CP1251', 'Russian_Russia.1251');
```
#### Заключение
Напоследок несколько слов относительно общей архитектуры решения (браузер в киоске — php-приложение — БД Caché). В нашем случае она упростила разделение труда между web-разработчиками и прикладными программистами Caché и облегчила жизнь web-разработчикам, сохранив максимально привычную и комфортную для них среду. При этом мы, конечно, понимали, что прямое взаимодействие (браузер на клиенте — прикладной код в Caché) должно быть более эффективно как с точки зрения производительности, так и с точки зрения простоты конфигурации. Это понимание с годами только усилилось, и нашло отражение при создании полнофункционального web-интерфейса с нашей медицинской системой.
Тем не менее, ODBC-доступ к Caché по-прежнему занимает определённую «экологическую нишу», поскольку:
* он отличается более высокой производительностью, чем многие другие методы доступа (например, SOAP);
* он позволяет обращаться к таблицам напрямую, без промежуточных хранимых процедур;
* это неплохой способ «формализовать отношения» в тех случаях, когда разработка специализированного внешнего интерфейса осуществляется сторонней командой. | https://habr.com/ru/post/156321/ | null | ru | null |
# Борьба с «плохими» URI, спамерами и php-шеллами — личный опыт
Полагаю, все веб-программисты проходят в той или иной степени одинаковый путь. Я основываюсь на своем личном опыте. Для меня в начале постижения этой науки создание сайта было на первом месте. Только по прошествии значительного времени я осознал, что сайты еще и вскрывают. Прочитав, как это делается, я удивился, на сколько просто по неопытности превратить свой сайт в «проходной двор» и стал уделять безопасности определенное внимание. По крайней мере я стал фильтровать входные параметры страниц.
На втором этапе я с удивлением обнаружил, что существуют такие звери, как PHP-shell. В этом мне помог Касперский, когда заблокировал доступ к моему столь любимому сайту. Следующим откровением было то, что вскрыть могут не только вас, но и хостинг. При этом шеллы появляются на вашем сайте с удивительной регулярностью, неизвестно откуда и делают, естественно, что хотят. Например, редактируют файлы **.htaccess** и закрывают их редактирование для всех, в том числе и для владельца.
Все эти откровения в свое время забрали огромное количество суббот и воскресений и потребовали перехода на рерайтинг урлов, создание развернутой системы анализа входных параметров на подозрительные слова и выражения (здесь я, кстати, потерпел некоторое фиаско), создание лога параметров, передающихся методом пост, системы оповещения о подозрительных событиях, происходящих на сайте, и, наконец, разрешения запуска только скриптов со специфическим префиксом в имени, чтобы никакой другой скрипт типа **template.php** или **wso2.php** не запускался.
Что же нужно иметь ввиду и что можно сделать для создания относительно безопасного сайта?
#### Стоит ли располагать файлы разных типов в отдельных папках?
Современный сайт, созданный на PHP, имеет обычно довольно разветвленную файловую структуру. В ней однозначно есть исполняемые скрипты, модули или классы, подключаемые инструкцией **include/require**, файлы **.css** и **.js**, страничный кэш. Вот этими файлами для простоты и ограничимся.
Я думаю на вопрос, заданный в подзаголовке, я отвечу утвердительно и это очень даже полезно. Так, например, подключаемые файлы PHP не предназначены для того, чтобы запрашивать их для обработки сервером и вывода в браузер. В папках подобного типа мы располагаем особый файл **.htaccess**, в котором запрещаем доступ кого-либо к чему-либо.
```
Deny from all
```
В папках с файлами **.css** и **.js** мы себе такого позволить не можем, но зато мы в этих папках можем ограничить доступ по типам, что тоже не плохо. Ниже приведен запрет на доступ к любым файлам кроме файлов с расширением **.js**
```
Deny from all
Allow from all
```
Стоит заметить, что по моему опыту такое ограничение практически не влияет на реальную безопасность сайта и является, так сказать, только одной галочкой в общем списке дел. Сам я этими методами не пользуюсь, и об этом будет разговор ниже. Но, с другой стороны, усилий для этого тоже требуется минимум, так что почему бы и нет? Опять же, если против вас будет действовать какой-то сумасшедший робот, то он будет переть как трактор и портить все подряд. Если вы будете знать, что в папке у вас лежат только файлы с определенными расширениями, то легче будет обнаружить вредоносного пришельца.
Лично я пошел немного дальше. У меня файлы **.css** и **.js** сжимаются и кешируются, поэтому и папки, где лежат исходники могут быть закрыты от всех подряд. Сами же запрашиваемые кэши лежат в довольно глубоко закопанной папке, куда робот может и не дойти. У меня, кстати говоря, и исполняемый скрипт на весь сайт всего один. Но об этом чуть позже.
#### Стоит ли называть папки нестандартным образом?
Вот, кстати, хороший метод реально повысить безопасность своего сайта. Дело в том, что вредоносный робот ищет на сайте папки с определенными названиями. Это же относится и к файлам. Поэтому как одна из мер повышения безопасности — это изменение имен папок и файлов на что-то нестандартное. Стоит придумать что-то свое и дать именам хотя бы префиксы. Префиксы однозначно помогут от роботов. Если хотите попробовать затруднить и ручной взлом, то советую пойти дальше и дать папкам и основным файлам имена собственные (Петя, Маша и т.д.). Не многие молодые хакеры будут разбираться, где что у вас лежит. Хотя у хакеров, занимающихся взломом от скуки, не известно, какая каша может быть в голове. Но шанс, определенно есть! Главное самому не запутаться. Тоже шанс немалый.
#### Файл **config.php**, в котором лежит пароль доступа к базе данных в открытом виде
Вот это то, чего я никак не могу понять. Есть файл, который все знают, как называется, и в котором в открытом виде лежит именно то, что нужно хакеру. Зачем это делается? Это, на мой взгляд, вредительство какое-то. Крайне рекомендую на всех своих сайтах зашифровать данные для доступа к базе данных и разместить их в совершенно нестандартно названном файле, закрытом от доступа по сети и доступного только для чтения. Конечно, надо поработать над оптимизацией скорости расшифровки, но это тоже вполне решаемо. По крайней мере XOR действует довольно быстро (ссылка на Шифр Вернама в конце статьи). Главное иметь ключ хорошей длины и получше его спрятать. Можно создать действительно запутанный и очень эффективный алгоритм расшифровки и заставить хакера провести на вашем сайте много часов, прежде чем им будет найден и ключ и алгоритм его использования. Вы же вовремя злонамеренную деятельность видите, благодаря вашей собственной системе логирования-оповещения, пресекаете деятельность злоумышленника и меняете ключи, пароли, явки и так далее. Поэтому скачивать ваши скрипты и разбираться с ними до потери сознания для хакера может оказаться непродуктивным.
#### Безопасность запускаемых скриптов php
Очень важная тема. В первую очередь скажу, что публичный хостинг действительно могут вскрыть и на вашем сайте откуда ни возьмись окажется файл с условным названием **template.php**. Предположим, что ваша замечательная система логирования и оповещения через какое-то время, например, через 10 минут, определит появление в такой-то папке такого-то нового файла и пришлет вам об этом письмо. Казалось бы замечательно! Но шелл может за 10 минут такого на сайте натворить, что сайт на несколько часов выйдет в аут. Проходили. Знаем, о чем говорим.
И этой крайне существенной уязвимостью безопасности грешат большинство движков. Сделайте для примера файл с любым названием, например **my\_template.php**, разместите в нем
```
php
echo 'hi!';
</code
```
Далее разместите его в корне своего сайта на **WordPress** и вызовите его (скрипт). И он скорее всего сработает! Покажет вам ваш привет!
Вот какая эволюция методов борьбы с этим злом происходила у меня. Но я не работаю на бесплатных (и платных) движках и мне легче!
Сначала я сделал такой Урл-рерайтинг, при котором запускаться могли только файлы с определенным префиксом. Работает это следующим образом. На вашем сайте сам собой, без всяких подозрительных вызовов появляется вредоносный файл без префикса. Вы остаетесь в неведении. Далее идет попытка доступа к этому свеже-подсаженному файлу. У него нет префикса, и он не запускается, а вы тут же, без задержки получаете об этом письмо. Заходите на сайт, видите шелл, блокируете IP, с которого он запрашивался, пишете письмо на хостинг и поднимаете всех сотрудников на уши. Все, как бы хорошо кончается. Ссылка на статью, в которой я в «высоко-художественной и одновременно развлекательной» форме описал проблему и пути решения я укажу в подвале.
Бывает подсадка шелла, проходящая по более интеллектуальному, но для нас более безопасному алгоритму. Известно, что логи доступа на хостингах хранятся ограниченное время, чаще всего неделю. Злоумышленник подсаживает вам на сайт постронний файл — скрипт шелла и оставляет его чуть больше чем на неделю. Логи, в которых была видна уязвимость, пропадают и вы не можете определить уязвимость, которая была использована. Но в нашем случае мы, в течение считанных минут, получаем оповещение о появлении чужака в файловой структуре нашего сайта, так что этот, казалось бы, изощренный метод подсадки нам более предпочтителен и желателен.
Описанная система прожила у меня не долго и была успешно заменена. В итоге я пришел к следующей схеме, которую на сегодняшний день считаю близкой к идеальной.
Мы удаляем из **.htaccess** все правила урл-рерайтинга, которые там были и оставляем только одно правило, которое любой файл отправляет на один разъединственный исполняемый скрипт вашего сайта. Он имеет особое, ни на что не похожее название, как минимум префикс. Этот скрипт по **REQUEST\_URI** разбирается, что же это пришло, делает всякие seo-действия по рерайтингу и решает, на какой скрипт передавать управление. Управление передается не рерайтингом, конечно, а путем подключения файла инструкцией **require**. В итоге доступ на вашем сайте разрешен всем, но выполняется всего один исполняемый php-скрипт. Все остальные скрипты лежат в отдельной папочке и защищены от запросов по сети и могут быть защищены инструкцией **Deny from all**. А могут и не быть.
Кстати, такая схема употребляется в некоторых движках. Но там всем управляет мега-скрипт **index.php** с 10 тысячами строк и более, и реализована эта схема вовсе не ради безопасности, а для того, чтобы было удобнее закрыть код от разворовывания.
Вот такое правило стоит у меня в **.htaccess**
```
RewriteCond %{REQUEST_URI} !^/sitemap\.xml$
RewriteCond %{REQUEST_URI} !^/favicon\.ico$
RewriteCond %{REQUEST_URI} !^/apple-touch-icon(?:\-precomposed)?\.png$
RewriteCond %{REQUEST_URI} !^/robots\.txt$
RewriteCond %{REQUEST_URI} !^/pref_dispatch\.php$
RewriteRule ^.*$ /pref_dispatch.php [L]
```
Обратите внимание, что пропускаем мы совершенно определенные файлы, которые у нас точно существуют, и на диспетчерский скрипт переводятся все запросы без исключения, а не одни только скрипты php. Кстати, можно и **robots.txt**, и **sitemap.xml** генерировать в диспетчере и отдавать, как скрипт. А можно и картинки…
##### Что происходит с урлом, который не проходит проверку в диспетчере?
Он записывается в "**лог плохих ури**". Этот лог я изредка просматриваю для того, чтобы определить, не запрещен ли у меня какой-либо нужный ури, и не нужно ли сделать переадресацию. Лог плохих ури зарекомендовал себя как один из самых полезных и занимательных инструментов в админке. Сразу видно кто ломится, куда ломится, и что, вообще, на сегодня интересно хакерам. Конечно, на первом месте стоит **wp-admin** и **wp-config**. Есть о чем задуматься любителям бесплатных движков.
##### Как сделать так, чтобы плохие ури собирались со всех папок, а не только с корня сайта?
В лог плохих ури попадают ури вида **/very-bad-uri-script.php** или **/very-bad-uri-folder/**. Но если ури имеет вид типа **/existent-folder/very-bad-uri-folder/**, этот ури в лог может и не попасть. При этом в лучшем случае в логе ошибок мы увидим строку типа **File does not exist: /existent-folder/very-bad-uri-folder/**
Если мы для папки **/existent-folder** отключили все для всех, то будет ошибка типа **client denied by server configuration**.
И то и другое не очень удобно. Дело в том, что вызов, попадающий в лог ошибок, уже не попадает в лог доступа, и мы не увидим никаких подробностей. Самое неприятное, что мы не получим никакого письма в случае подозрительной активности на сайте. Такая неприятность происходит из-за того, что в папке **/existent-folder** либо вообще отсутствует файл **.htaccess**, либо в нем не включен урл-рерайтинг. Для того, чтобы этого не происходило нам надо во-первых, разрешить доступ к этой папке всех, то есть стереть нашу строчку **Deny From All**, а во-вторых, включить урл-рерайтинг.
```
RewriteEngine on
RewriteBase /
RewriteRule ^.*$ /badurl/ [L]
```
Любой запрашиваемый файл сразу, прямиком отправляется в лог плохих ури со всеми возможными подробностями. Строчка об этом событии попадает в лог доступа и не попадает в лог ошибок. Мы получаем письмо от системы оповещения, но, конечно, если запрограммировали эту функциональность.
Вышеприведенный **.htaccess** подходит для замены функциональности "**Deny from all**". В случае, если нам надо что-то пропустить, например, скрипты js или таблицу стилей, то нужно либо разрешить запрос определенных типов файлов, либо, что лучше, задать скриптам особые имена или префиксы. Ну, или перечислить пропускаемые файлы явно. Но, боюсь, это уже слишком жестко в смысле продуктивности и программиста и сервера.
#### Атаки и блокирование вредоносных IP
Время от времени, но с удивительной регулярностью, на сайт происходят атаки. Среди этих атак есть такие, когда с определенного IP идут прозвоны страниц логина и регистрации пользователя, отправки писем через форму и приема объявлений. Это работают mail-сервера. Работают они чаще всего в паре с «чистыми» IP, которые не используются для атак, а используются только для прозвонов. Для определения сущности IP, занимающихся спамом, я сам использую и всячески пропагандирую сайт **projecthoneypot.org**.
Бороться с такими спаммерами оказалось крайне просто. Надо просто реализовать все эти формы аяксом и все. Одного только этого бывает уже вполне достаточно. Для пущей безопасности можно запретить вызов php-бэкенда, если он не идет с сайта.
Очень объемный трафик идет от сомнительных ботов. Почему сомнительных? Потому что я не знаю, полезны ли эти боты для сайта и зачем они ходят по моему сайту и звонят урлы, которые вышли из употребления много лет назад. Вообще, появление давным давно убитых урлов само по себе является компрометирующим действием для бота. Такие боты чаще всего не используют файл robots.txt или используют его в противоположном направлении, то есть для них существование списка запрещенных к просмотру адресов есть повод именно до них и ломиться. Тем не менее, эти боты честно метят себя в пользовательских агентах. Из таких я могу назвать **199.192.207.146** с агентом **```
Mozilla/5.0 (compatible; MJ12bot/v1.4.5; http://www.majestic12.co.uk/bot.php?+)
```** или **185.53.44.90** с агентом
**```
Mozilla/5.0 (compatible; XoviBot/2.0; +http://www.xovibot.net/)
```** IP в приведенных выше примерах реальные, но понятно, что у этих ботов не один IP адрес, а много.
Есть и боты, маскирующиеся под хорошие, но, похоже, такими не являющиеся. Вот, например, **176.31.182.56** с агентом **```
Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)
```** По действию этого IP на моем сайте у меня есть очень большие сомнения, что это действительно Googlebot.
Наконец, мне очень не нравится **bingbot**. Он крайне неаккуратный. Он обожает ломиться к сайту по несуществующим урлам. Все бы ничего, если не задумываться, где и в каких базах он эти урлы берет и почему не удаляет их из базы? Понятно, что этого зверя я не блокирую, несмотря на мое к нему отношение.
Но есть атаки не направленные явно на спам. Запросы могут сыпаться со скоростью несколько штук в секунду и представляют собой полную чушь. Часто испорченные и исковерканные запросы к самому сайту, а часто атаки на движки, из которых лидирует WP. Серия запросов обычно может быть от 100 до 200 штук в одной серии за сутки. Зачем ломиться до движков — понятно, наверное. Зачем пытаться добиться ответа сайта по исковерканным и часто вообще нечитаемым урлам мне не понятно. Но факт в том, что куча запросов с высокой скоростью замедляют и сам сайт и его соседей по хостингу и с ними стоит бороться.
Кстати, что такое «нечитаемый урл»? А вот что!
```
http://мой-сайт.ru/bulletin_board/ad_add/+++++++++++++++++++++++++++++++++++++Result:+%ED%E5+%ED%E0%F8%EB%EE%F1%FC+%F4%EE%F0%EC%FB+%E4%EB%FF+%F0%E0%E7%EC%E5%F9%E5%ED%E8%FF;+Result:+%ED%E5+%ED%E0%F8%EB%EE%F1%FC+%F4%EE%F0%EC%FB+%E4%EB%FF+%F0%E0%E7%EC%E5%F9%E5%ED%E8_cutted
```
*Пожалуйста, не пытайтесь реально зайти по этому урлу на мой сайт, ибо в этом случае ваш IP будет помечен опасным и он будет поражен в правах.*
Во-первых, урл имеет длину боле 255 знаков и его пришлось обрезать. Во-вторых, хоть все, что идет за словом «Result:» и декодируется (windows 1251), но все равно представляет собой чушь. Есть подозрение, что запрашивает этот урл **XoviBot/2.0**, причем в сравнительно больших количествах и всегда одинаковый.
Но как бороться? И стоит ли блокировать все подряд? Если с этим процессом трудно бороться, может быть его можно возглавить, или как-то по-другому к нему приспособиться?
Я, к сожалению, не знаю, каков круговорот плохих IP в природе, и могут ли плохие стать хорошими, а хорошие плохими. Поэтому я если и блокирую, то делаю это в ручном режиме. Если принадлежность IP из такой страны, где мой русскоязычный сайт скорее всего читать не будут, и деятельность слишком уж жесткая, я эти IP блокирую. Остальные оставляю.
В моей системе безопасности есть не только лог плохих ури, но и лог IP, когда либо вызвавших плохой ури. Спамовские, опасные, заблокированные и разблокированные IP, а также боты, учитываются в этом списке.
При заходе с заблокированного IP клиент попадает на специальную страницу, где ему предлагается нажать на кнопку и разблокировать IP. Кнопка аяксовая. Запись о блокировке автоматически меняется на «разблокированный IP». У меня сейчас порядка 20 заблокированных IP. Был ли хоть один из них разблокирован пользователем? Нет. Не был. Часто происходят заходы с уже заблокированных IP? Нет, исчезающе редко.
Для всех клиентов, приходящих с IP, которые как-либо помечены, никогда не производится дополнительная обработка их запросов. Для них не проверяется наличие обязательного обратного слэша, они не проверяются на список редиректов, для них не работает преобразование SEO адресов. Если запросы не являются полностью хорошими, то им тут же, без задержки, выводится краткое прощанье.
Но в последнее время я думаю о том, что можно усовершенствовать систему блокирования. Возможно, было бы полезно при обнаружении серии потока запросов с некоего IP, блокировать его на час. Боюсь только, что я уже так заоптимизировал схему обработки плохих ури, что блокировка IP и вывод ему стандартного прощанья примерно одинаковы по времени обработки.
#### Резюме
Выше описаны довольно простые действия, которые могут серьезно повысить степень защищенности любого сайта. У меня остается вопрос — почему же эти простейшие вещи не включены, кажется, ни в один движок? Ни в платный, ни в бесплатный?
#### Ссылки
* [Шифр Вернама, как пример легкореализуемого шифрования с абсолютной стойкостью](https://ru.wikipedia.org/wiki/%D0%A8%D0%B8%D1%84%D1%80_%D0%92%D0%B5%D1%80%D0%BD%D0%B0%D0%BC%D0%B0);
* [Почти детективная история по поиску php-шелла](http://php.belkin-labs.ru/articles/159/);
* [Антиспам проект projecthoneypot.org](http://www.projecthoneypot.org/home.php) | https://habr.com/ru/post/264017/ | null | ru | null |
# Мелкая питонячая радость #13: стойкие пароли, гибкие уведомления и вменяемые тесты API
Создатель Python и пенсионер Гвидо Ван Россум был вынужден снова выйти на работу, на этот раз в Майкрософт. Нет, Гвидо сделал это не потому, что на 15 000 рублей (200 долларов) пенсии ему тяжело жить — в MS он устроился от скуки: талантливому инженеру не сидится без дела. Желаю всем нам в старости быть как Гвидо и плавно перехожу к разбору трех весьма полезных штуковин из питонячего мира.
zxcvbn-python
-------------
Как обычно проверяют пароли на сложность на бэкенде? Так, как мы все видели не раз в своей жизни — “пароль должен содержать не менее восьми символов, одну цифру, один спецсимвол и имя любимого персонажа Достоевского”. Конечно, такие минимальные требования к надежности пароля помогают задержать взломщика, но не всегда.
Например, если пароль технически состоит из нужного числа символов, но эти символы — имя и фамилия или части логина. Или в качестве пароля использована популярная комбинация символов, которую можно встретить во многих парольных словарях и таблицах хешей.
Библиотека [zxcvbn-python](https://github.com/dwolfhub/zxcvbn-python) производит реалистичную оценку пароля на сложность.
Как мы видим, либа считает примерную скорость, с которой пароль можно вскрыть путем перебора хэшей и методом прямого перебора через форму логина. А еще мы видим рекомендации по улучшению стойкости пароля и результаты поиска частей паролей в словаре, используемом взломщиками.
```
from zxcvbn import zxcvbn
results = zxcvbn('JohnSmith123', user_inputs=['John', 'Smith'])
print(results)
```
```
{
'password': 'JohnSmith123',
'score': 2,
'guesses': 2567800,
'guesses_log10': 6.409561194521849,
'calc_time': datetime.timedelta(0, 0, 5204)
'feedback': {
'warning': '',
'suggestions': [
'Add another word or two. Uncommon words are better.',
"Capitalization doesn't help very much"
]
},
'crack_times_display': {
'offline_fast_hashing_1e10_per_second': 'less than a second'
'offline_slow_hashing_1e4_per_second': '4 minutes',
'online_no_throttling_10_per_second': '3 days',
'online_throttling_100_per_hour': '3 years',
},
'crack_times_seconds': {
'offline_fast_hashing_1e10_per_second': 0.00025678,
'offline_slow_hashing_1e4_per_second': 256.78
'online_no_throttling_10_per_second': 256780.0,
'online_throttling_100_per_hour': 92440800.0,
},
'sequence': [{
'matched_word': 'john',
'rank': 2,
'pattern': 'dictionary',
'reversed': False,
'token': 'John',
'l33t': False,
'uppercase_variations': 2,
'i': 0,
'guesses': 50,
'l33t_variations': 1,
'dictionary_name': 'male_names',
'base_guesses': 2,
'guesses_log10': 1.6989700043360185,
'j': 3
}, {
'matched_word': 'smith123',
'rank': 12789,
'pattern': 'dictionary',
'reversed': False,
'token': 'Smith123',
'l33t': False,
'uppercase_variations': 2,
'i': 4,
'guesses': 25578,
'l33t_variations': 1,
'dictionary_name': 'passwords',
'base_guesses': 12789,
'guesses_log10': 4.407866583030775,
'j': 11
}],
}
```
Ну и, конечно же, не забываем делать двухфакторку в своих проектах и блокируем аккаунт на Y минут после X неудачных попыток ввести пароль.
Notifiers
---------
“А давайте у нас в этом случае будет приходить уведомление админам на телефон и в Slack” — все разработчики слышали вариации этой фразы от своих менеджеров. Дальнейшее развитие событий зависит от квалификации, мотивации и навыков разработчика. Либо дело ограничивается однострочным вызовом SMTP сервера, либо скачивается какая-то либа для посылки сообщений куда надо, либо пишется ООП комбайн с расширениями возможности посылки уведомлений любым мыслимым способом (включая голубиную почту).
Самые рьяные и мотивированные разработчики в мире не только уже выбрали самый сложный третий способ (доставка чего угодно куда угодно), но и оформили питонячий пакет на github. Встречаем [notifiers](https://notifiers.readthedocs.io/en/latest/) — одна либа для доставки уведомлений сразу в кучу мест
* Email (SMTP)
* Gitter
* Gmail
* Hipchat
* Join
* Mailgun
* Pagerduty
* PopcornNotify
* Pushbullet
* Pushover
* SimplePush
* Slack (Webhooks)
* StatusPage
* Telegram
* Twilio
* Zulip
```
from notifiers import get_notifier
telegram = get_notifier('telegram')
telegram.notify(message='Hi!', token='TOKEN', chat_id=1234)
```
Еще можно встроиться в логгер:
```
import logging
from notifiers.logging import NotificationHandler
log = logging.getLogger(__name__)
defaults = {
'token': 'foo',
'user': 'bar'
}
hdlr = NotificationHandler('pushover', defaults=defaults)
hdlr.setLevel(logging.ERROR)
log.addHandler(hdlr)
log.error('And just like that, you get notified about all your errors!')
```
Tavern
------
Один менеджер скажет “тестирование” — миллионы разработчиков ему ответят “pytest”. Да, действительно, для многих программистов pytest стало синонимом слова “тестирование”. При этом абсолютно не важно, что и как мы тестируем — компоненты, интеграцию или поведение: этой либой можно заткнуть любую дырку.
Ничего ужасного в этом нет — pytest и правда позволяет это все делать. Берем эту либу, прикручиваем requests, пишем кучу всяких кейсов и операций с ответами и запросами к API — готово, мы получили комбайн по тестированию этого самого API.
Однако, при применении pytest для тестирования API код со временем начинает разрастаться, появляются обработчики заголовков, проверка ответов сервера, работа с куками и многие другие вещи. Те, кому приходилось поддерживать систему тестирования большого приложения на бэкенде, понимают, о чем идет речь.
Поэтому для тестирования API появился отдельный инструмент — [tavern](https://tavern.readthedocs.io/en/latest/basics.html).
Tavern позволяет описывать тесты API в декларативной форме в формате YAML. И в эти декларативные сценарии уже заложено все, что вам нужно — вызовы сервера, обработка разных кодов ответа, заголовков, проверка данных в ответах.Растет гибкость, читаемость тестов и реюзабельность сценариев тестирования — а что нам еще нужно?
```
test_name: Get some fake data from the JSON placeholder API
stages:
- name: Make sure we have the right ID
request:
url: https://jsonplaceholder.typicode.com/posts/1
method: GET
response:
status_code: 200
json:
id: 1
save:
json:
returned_id: id
```
На сегодня все, прошлые питонячие радости [смотрите по ссылке](https://habr.com/ru/search/?target_type=posts&q=%5B%D0%BC%D0%B5%D0%BB%D0%BA%D0%B0%D1%8F%20%D0%BF%D0%B8%D1%82%D0%BE%D0%BD%D1%8F%D1%87%D0%B0%D1%8F%20%D1%80%D0%B0%D0%B4%D0%BE%D1%81%D1%82%D1%8C%5D&order_by=date). | https://habr.com/ru/post/528046/ | null | ru | null |
# «20 тысяч IOPS на узел — хорошие показатели с учётом задержек в 5 мс». Для OLTP — нет
Поводом написать эту статью стал весьма достойный обзор [Как мы тестировали VMware vSAN...](https://habr.com/company/croc/blog/414125) компании КРОК. Обзор-то достойный, но в нем есть фраза, с которой я борюсь уже больше десятка лет. Админы СХД, виртуализаторы и интеграторы раз за разом повторяют: "Задержки в 5 мс — это отличный показатель". Даже цифра в 5 мс десять лет не меняется. Я это слышал вживую от весьма уважаемых админов уже не меньше десятка раз. От менее уважаемых — десятки, а уж сколько раз читал в интернете… Нет, нет, нет. Для OLTP нагрузок 5 мс, особенно так, как их обычно измеряют — это epic fail. Мне приходилось объяснять причины этого уже много раз, на этот раз я решил собрать свои мысли в переиспользуемую форму.
Сразу оговорюсь, что в упомянутой выше статье этих ошибок нет, скорее фраза сработала как триггер.
Типичное начало
---------------
Всё что описано в данной статье, верно для распространенных СУБД, используемых для типичной бизнесовой OLTP. Больше всего у меня опыт с MS SQL Server, но, как минимум, для PostgeSQL, Oracle и Sybase многие моменты и выводы также останутся верны.
Производительностью СУБД обычно недовольны все. Если в крупной системе есть СУБД — а она, внезапно, почти всегда есть — то эта СУБД и есть узкое место. Ну или сразу станет узким местом, если начать оптимизировать всё остальное. И вот, приходит заказчик и говорит человеческим голосом: "Помоги! Спаси! Заплатили $NNNNNNNN за сервера и СХД, а скорость не растет! Уж и администратор настраивал и вендор консультировал, а всё равно не шевелится." Если разработчики системы подходят под определение Лаврова (обойдёмся без точной цитаты), а специалисты эксплуатации и сопровождения "борются с инцидентами перезагрузкой сервера", то часто и проблема простая и незатейливая: отсутствуют индексы, кривые запросы, фатальные ошибки настройки (про которые в документации жирным написано **"так делать нельзя!!!"**), излишние блокировки, взаимоблокировки и прочая простая и понятная ерунда. Таких случаев много, большинство, но не все. Если система в сложности или нагрузке перешла некоторый невидимый предел, то она либо сдохнет от этих проблем, либо перейдёт на следующий уровень.
**Советы по диагностике SQL Server**IMHO, лучшим средством сейчас является [SQL Server First Responder Kit](https://github.com/BrentOzarULTD/SQL-Server-First-Responder-Kit), продвигаемый [Брентом Озаром](https://www.brentozar.com/). Этот инструмент развивается весьма активно. Еще есть достойный [набор](https://www.sqlskills.com/blogs/glenn/sql-server-diagnostic-information-queries-for-june-2018/) от [Гленна Берри](https://www.sqlskills.com/blogs/glenn/), он тоже не забросил свой проект. Оба набора по-своему прекрасны, чтение комментариев и запросов в первый раз открывает много нового. Я сам всегда начинаю осматриваться с `sys.dm_os_waitsats`, беглого взгляда на Error log и выяснения, есть ли хоть сколько-то работающая система резервного копирования.
На этом уровне уже сервер не стоит под столом директора, диски уже не внутри сервера, а в СХД, разработчики знают про индексы, а администраторы уже умеют PowerShell, и менеджеры ИТ начинают говорить умные слова типа SLA и RPO/RTO. Вот на этом уровне возникает интересная ситуация:
* СУБД является узким местом.
* Сервер вроде бы по всем показателям должен быть достаточен.
* Программно СУБД дальше улучшать можно, но сложно (либо переходить на более дорогие лицензии, либо переходить в ["красную зону кривой им. Шипилёва"](https://habr.com/company/jugru/blog/338732/) по оптимизации)
* Дисковая система куплена дорогая и, вроде даже как-то настроена.
Ан нет. Крокодил не ловится, не растет кокос, и производительность системы такая же или ниже чем на старом сервере. Смотрю в `sys.dm_os_waitsats` и вижу `WRITELOG`, `PAGEIOLATCH_SH` и `PAGEIOLATCH_EX` в топе, среднее время ожидания 5+ мс. Ну типично, чо: "Эй, админы и DBA, тут у вас дисковая система — bottleneck" и вот тут начинается старая песня про 5 мс:
* У нас 5 мс по SLA
* Да у нас полка 20000 IOPS тащит
* Нам вендор сказал, что все файлы БД можно на один раздел
* У нас виртуализация и гиперконвергентность и мы не можем выделять отдельные диски под БД
* По нашим данным утилизация сервера 5%
* Всё настроено по рекомендациям
* Вашим БД не нужна большая производительность, она не делает больше 300 IOPS (а у нас же полка на 20000 IOPS)
Кстати, всё вышесказанное не только про "свои" сервера, но и про облачные сервисы и виртуализацию. Там есть кучка своей специфики, но типичная клиническая картина примерно та же: в меру оптимизированная БД, неглупые сотрудники разработки и сопровождения, по процессору и памяти резерв есть, "выхлоп" от дальнейших вложений почти равен нулю.
Так вот. Эта вся песня про "5 мс" чушь и ерунда. Если вы сами такое говорите — читайте эту статью. А если вам такое говорят — готовьте аргументы. Раньше, когда я слышал эти слова, я злился, но я уже не злюсь. У меня, как у того горшка с петуньей из "Автостопом по галактике" только одна мысль: "Ну вот опять...".
Кто виноват?
------------
Почему БД такая медленная? Ну казалось бы, типичный сервер с 20-64 ядрами на частоте 2-3 ГГц способен выполнить 50-150 миллиардов простых операций, а максимальные (синтетические) тесты баз данных показывают на подобных машинах всего лишь 10000-50000 транзакций в секунду. Эй! Это ж от миллиона до десятка возможных миллионов операций на транзакцию. Это не просто много, это очуметь как много.
Такого оверхеда стоят [ACID](https://ru.wikipedia.org/wiki/ACID)-требования к транзакциям.
* **A**tomicity — либо вся транзакция выполнена, либо вся не выполнена.
* **C**onsistancy — на входе и на выходе из транзакции система в целостном состоянии
* **I**solation — транзакции не видят промежуточных состояний друг друга
* **D**urability — если уж транзакцию успешно завершили (закоммитили), то вне зависимости от обстоятельств внесенные изменения должны остаться в системе.
К слову, буква-в-букву эти требования не выполняются почти нигде и никогда, а в распределённых системах просто никогда (CAP-теорема мешает). Для нашей ситуации скорее всего дороже других стоит требование "D", это требование обеспечивается ключевым механизмом всех распространенных OLTP СУБД: WAL, write-ahead log (PostgeSQL), он же журнал транзакций (SQL Server), он же REDO log (Oracle). Вот он — камень на шее производительности, и он же фундамент Durability транзакций.
### Что такое WAL
Давайте ненадолго забудем про современные SSD, про крутые СХД. Пусть у нас есть сервер, в нем один или несколько дисков.
Любая транзакция, даже вставка одной записи, как минимум потенциально, а на самом деле почти всегда и реально — неатомарное действие. Нам почти всегда нужно изменить не только ту страницу, где лежит запись, но и страницы индексов, возможно, служебные страницы. При этом в одной транзакции одна и та же страница может поменяться много раз. Плюс у нас параллельно могут выполняться другие транзакции. Более того — соседние во времени транзакции постоянно "теребят" одни и те же страницы. Если мы будем дожидаться записи каждой страницы на диск перед продолжением действий, а именно это по сути требуется в Durability, то нам придётся записывать во много раз больше и ждать обязательного окончания каждой записи на энергонезависимый носитель. Никаких кешей, никакой перестановки операций в очереди, а иначе не будет целостности! Более того, нам как-то надо отмечать какие данные уже по фиксированным транзакциям, а какие — ещё нет (и какие были данные раньше). Для понимания — типичный одиночный жёсткий диск (HDD) в таком режиме даст 50-100 IOPS и это константа уже 20 лет. На одну даже маленькую транзакцию потребуется 5-10 операций записи. Ах, да, чтобы знать, что записывать — надо прочитать. Даже очень-очень высоконагруженные на запись OLTP системы читают в раза 3 больше чем пишут. Таким образом наша транзакция стоит 20-40 IO, а значит 0,2-0,8 секунд на диск.
2 транзакции в секунду. Маловато? Давайте попробуем раскидать по дискам? Ой, а нам надо всё равно дожидаться пока предыдущий запишется и параллельность в итоге отсутствует. Как быть? А давайте заведем файл-журнал в который будем последовательно записывать все операции записи в БД и отметки транзакций! Плюсы:
* Информация об операции может быть гораздо компактнее чем запись всей страницы (типичный размер страницы 8 КиБ, информация записываемая в журнал часто 0,5-1 КиБ).
* Вместо записи о том зафиксирована транзакция или нет прямо в страницу — достаточно меток о начале и фиксации транзакции в журнале.
* Страницы можно записывать не после каждой транзакции — ещё в несколько раз меньше. Процесс чтения/записи данных полностью "отвязан" от журнала.
* Главное. Если наш журнал положить на отдельный диск и писать записи последовательно, то за счет того, что не требуется постоянно перепозиционировать головки диска, даже бытовой HDD в таком режиме выжимает до 1000 IOPS, учитывая что мелкие транзакции "стоят" 2-4 записи в журнале, то можно выжать 200-400 TPS
* При сбое состояние файла данных можно восстановить по такому журналу, а при отмене транзакции по нему можно откатить изменения
Такой журнал и называется write-ahead log/transaction log/REDO log.
Ура! Супер! Было 2 транзакции в секунду, стало 300 — улучшили в 150 раз. А какой ценой? Как выясняется, цена значительна:
* Во всех распространенных СУБД запись в журнал строго последовательна. За запись в журнал отвечает один поток. У вас 100 процессоров? Круто. А в журнал всё равно будет писать один поток. Глубина очереди — ровно единица.
* Всё ещё — никаких кешей ОС, никаких перестановок операций. Требования durability остались. Операции write-through: пока диск не ответил "я записал, я точно-точно записал прямо на поверхность, а не в кеш" СУБД не продолжает работу.
* Если файл журнала положить на диск с данными, то почти все преимущества последовательной записи пропадут. Более того — по хорошему, если несколько баз на сервере, то и несколько дисков под журналы.
* Откат транзакций (по крайней мере в MS SQL Server) — прочитать журнал и восстановить по нему состояние. Это столько же или даже больше операций записи, сколько было операций записи в транзакции. Rollback — дорого!
Это объяснение очень упрощенное, "на пальцах". Для нашей темы этого хватит. WAL — ключевой, фундаментальный механизм обеспечения транзакционности, он обязательно write-through, доступ однопоточный только на последовательную запись, с точки зрения хранилища глубина очереди 1.
**Если вам интересна эта тема*** Совсем вводная статья [Как устроены базы данных](https://habr.com/company/oleg-bunin/blog/358984)
* Для SQL Server есть отличный цикл статей [Как перестать называть журнал транзакций SQL Server лог-файлом и прекратить борьбу за его размер.](http://sqlcmd.ru/trans_log_internals-part01.html)
* Интересно взглянуть немного с другой стороны, вот, например, расшифровка отличного доклада про in-memory СУБД [Tarantool](https://habr.com/company/oleg-bunin/blog/340062/)
* В каждой СУБД есть обширные разделы, поясняющие работу WAL.
Тему write-ahead logging в БД должен хотя бы в минимальном объёме знать каждый, кто так или иначе администрирует СУБД, или инфраструктуру СУБД, или разрабатывает базы данных.
### WAL и СХД
Производители СХД "с рождения" сталкиваются с СУБД. Именно для баз данных бизнес покупает эти безумно дорогие комплексы: от street price хранилищ Dell-EMC, HP, Hitachi, NetApp при верстке бюджета глаза наполняются слезами у большинства топ-менеджеров, если они, конечно, не получат процент от этой цены. Но тут есть инженерно-маркетинговый конфликт. Я его поясню на примере Dell-EMC, но только потому что помню, где у них документация.
Итак:
1. Журнал однопоточный, без очереди
2. Журнал write-through, то есть задержки (latency) "вечные" по сравнению с производительностью CPU
3. OLTP-нагрузки это много относительно небольших транзакций,
4. Большинство других нагрузок СУБД так или иначе параллелятся.
[Закон Амдала](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%BA%D0%BE%D0%BD_%D0%90%D0%BC%D0%B4%D0%B0%D0%BB%D0%B0) беспощадно говорит нам, что однопоточная низкопроизводительная нагрузка сделает бесполезными добавление процессоров, а производительность будет определяться именно журналом. Более того, в этот момент нам станет наплевать на производительность СХД в IOPS, а станет важным только latency.
Но не стоит сбрасывать со счетов другие дисковые операции — чтение и запись в файлы данных и в `tempdb`. Чтение — тоже "ждущая" операция. Пока страница данных не прочитана с диска в память, процессор её обрабатывать не может. Но для этих операций возможны большие очереди и перестановка операций в этой очереди: СУБД часто знает, какие страницы надо дозагрузить в память, какие сбросить на диск и ставит в очередь на чтение сразу много. Так как в этом сценарии важно, когда закончится последняя операция из пачки, то в этой нагрузке нам наоборот важнее IOPS, чем latency отдельной операции. Для понимания масштабов: операций чтения в типичной OLTP системе 85%-95%. Да-да-да, операций записи на порядок меньше.
Инженеры-разработчики СХД вендора плотно работают с вендорами СУБД, и отлично понимают все технические нюансы работы СУБД с дисковой подсистемой. Правильное планирование, разбиение и выделение дисковых ресурсов для СУБД — сложная и важная компетенция **администратора СХД**. У того же Dell-EMC даже базовые white-paper [H14621](https://www.emc.com/collateral/technical-documentation/h14621-microsoft-sql-server-best-practice.pdf) и [H12341](https://www.emc.com/collateral/white-papers/h12341-sqlserver-bp-wp.pdf) по рекомендациям разбиения для SQL Server — по сотне страниц. Эй! Это не детальная дока, это самый общий white-paper! Там есть ещё куча специфичных ([h15142](https://www.emc.com/collateral/white-papers/h15142-unity-ms-sql-wp.pdf), [h16389](https://www.emc.com/collateral/white-papers/h16389-unity-storage-with-microsoft-sql-server-wp.pdf)… там их тьма). Не отстают и "смежники" из VMware — [Architecting Microsoft SQL Server on VMware vSphere](https://www.vmware.com/content/dam/digitalmarketing/vmware/en/pdf/solutions/sql-server-on-vmware-best-practices-guide.pdf). Обратите внимание, это документы не только и не столько для DBA, сколько для админов инфраструктуры и СХД.
Ещё отмечу, что во всех этих документах нарезаются отдельные LUN для данных, для журналов и для базы `tempdb`. Да, где-то в свежих документах аккуратно говорят, что для All-Flash решений нет смысла отделять журналы на физически отдельные носители, но LUNы все ещё предлагают нарезать отдельно. Если данные и журналы свалить в один LUN, то с точки зрения ОС это будет одна очередь IO. И вот тут будет проблема. У операций с журналом latency станет сразу на порядок больше. А из-за того, что в очереди появятся неперемещаемые операции с журналом, просядет IOPS на файлах данных и `tempdb`. Это не "открытие века", это азбучная истина работы с БД. Она не устарела и не отменена с появлением All-Flash. Да, задержки на операции с SSD быстрее на порядок, чем на операции с HDD, но всё ещё на пару порядков медленнее операций с памятью. IO всё ещё узкое место СУБД.
И в технических документах правильно делается акцент, что в журналах транзакций не важно количество IOPS, а важно, чтобы latency была минимальной (в современных пишут, что менее 1 мс).
А маркетологам надо продавать. Гиперконвергентность! Виртуализация! Гибкость развертывания! Дедупликация! Простота настройки! Много-много IOPS! Красивые презентации, уверенный голос, строгие костюмы. Ну а как иначе продать решение с 6-7-значным ценником в долларах? За этим как-то забывается, что от СХД можно добиться либо latency, либо throughput, но не обоих сразу, что какая-нибудь лицензия на балансировщик нагрузки стоит как еще одна полка, что если интенсивная запись будет длиться больше часа, то оперативной памяти контроллеров не хватит и производительность просядет до "как будто кеша нет", что обучение сотрудников заказчика стоит еще 100000 рублей за первый курс, ну и подобные уловки…
### 5 мс
То ли наслушавшись-начитавшись маркетологов, то ли от лени, то ли ещё из-за каких-то тараканов, но почему-то часто админы СХД делают примерно так. Берем большую полку, всю её объединяем в что-то плоское, нарезаем на thin provisioned LUNs и раздаём по LUN на сервер. Или по два, потому что "системный раздел хорошо дедуплицируется". А когда, я вижу, что с дисковой подсистемой со стороны SQL ад-ад-ад, то начинается та самая песня, что "5 мс отличный показатель", что "100000 IOPS", "Ваша нагрузка на СХД менее 5%"
**НЕТ**.
* Для OLTP систем на разделе с WAL/журналами транзакций 5 мс это недопустимый показатель. На "почти-коммодити" железяке за цену в 1000 (прописью: в тысячу) раз дешевле нормальным показателем сейчас будет 0,1-0,3 мс. А завтра — 0,01 мс. Скорость, как у HDD 2008 года по цене целого подъезда квартир в Москве не нужна. Никакое "удобство обслуживания" этого не стоит.
* Вендор пишет, что журналы транзакций не требовательны к IOPS и их можно положить на HDD? Да, это так. Но для этого надо чтобы эти диски ни одна ~~зараза~~ задача кроме записи журналов СУБД не трогала. И чтобы СХД отвечала серверу, что данные записаны, сразу как данные легли в энергонезависимую память (это гораздо раньше, чем они будут записаны)
* "Тонкие" диски для реальных OLTP БД — зло.
* Для WAL абсолютно неинтересно сколько там можно выжать IOPS на глубине очереди 10 или 20. Там нет глубины.
* Для WAL абсолютно не показатель, что очередь IO в ОС "всего лишь около 1". Она не будет больше.
* Нет, DBA и разработчики БД не "дятлы криворукие, которые не могут нормально настроить, чтобы запись в WAL параллелилась" *(реальное мнение админа)*
* Логика любителей считать утилизацию "раз ваша система *нами криво настроенная в один раздел* не делает 10000 IOPS, значит её надо перенести с high-end массива на mid-range" — это неправильная логика.
* Если у 40-ядерного сервера загрузка процессора 2,5 процента, то это не значит, что ему нечем заняться, а, скорее всего, значит, что есть какая-то задача, которая блокирует все остальные.
Когда какая-нибудь загрузка данных на ноутбуке разработчика выполняется 5 минут, а на 40 ядерном сервере с 1 ТиБ RAM и СХД за полмиллиона долларов та же самая задача выполняется час, то даже у самых терпеливых заказчиков появятся вопросы обоснованности затрат.
| Средняя задержка на разделе с WAL | никогда не будет в секунду больше транзакций, чем: |
| --- | --- |
| 5 мс | 200 |
| 1 мс | 1000 |
| 0,5 мс | 2000 |
| 0,1 мс | 10000 |
| 0,05 мс | 20000 |
Что делать
----------
### Советы администраторам и DBA
Для OLTP перестаньте считать "утилизацию" и IOPS. Отдельно замечу — совсем не смотрите на IOPS с большой глубиной очереди: даже на разделах с данными большие очереди обычно короткий всплеск или что-то, что не влияет на реальную производительность OLTP.
Делить дисковое пространство на LUN — это не прихоть DBA. У базы данных есть несколько разных профилей нагрузки дисковой подсистемы. Как минимум можно выделить следующее:
* Работа с файлами данных. Обычно это чтение и запись случайными блоками по 8/64 КиБ. Чтений 80-95%. Очереди возникают: в периоды обслуживания, в периоды массовой загрузки, на неэффективных или массовых запросах и при checkpoint. На производительность влияет отзывчивость по чтению. Важно, чтобы выравнивание 8/64 КиБ блоков "всквозную" проходило через всю систему хранения.
* Работа с `tempdb` — то же самое, что и работа с файлами данных, но чтений обычно 40-75% и отзывчивость на запись может быть важной. В современных системах MS SQL эта БД может быть загруженной в несколько раз сильнее, чем БД с данными. В некластерной конфигурации СУБД этот раздел должен быть исключен из всяких СХД-шных репликаций. Его содержимое после перезагрузки сервиса всё равно будет уничтожено.
* Работа с архивными данными/DWH. Чтений близко к 100%. Размер одного блока чтения обычно 64 КиБ. Запросы читают много и подряд, поэтому очередь может скакать и до 1000 и больше.
* Работа с журналами транзакций. Чтение только для обслуживания (резервное копирование, репликация и т.п.), на производительность приложений влияет только запись. Запись блоками 0,5-64 КиБ. Без очереди, в один поток. Задержка критична для приложений.
* Резервное копирование и восстановление. С точки зрения БД это чтение большими блоками (часто 1 МиБ). Важно, что эта нагрузка может упереться в каналы/шины (и FC, и Ethernet) и в производительность процессоров СХД в некоторых случаях. Резервное копирование одного сервера может повлиять на производительность других серверов того же SAN/СХД.
* Работа с файлам приложения: это логи, default trace, бинарные файлы и т.п. Эта нагрузка редко бывает существенной и важна только при старте системы.
Есть и другие виды нагрузки, но они слегка экзотичны (например, может быть хранилище файлов, хранящихся в БД в виде каталога FileStream). У всех этих видов нагрузки разные, зачастую противоречащие требования к дискам. Если они все свалены на один раздел, то вы не только ухудшаете производительность, но очень важно, что лишаетесь возможности понять из-за чего система тормозит, а также лишаетесь возможности улучшить только ту часть которая требует улучшения без глобальных улучшений/апгрейдов СХД. Поэтому главная рекомендация:
**Ознакомьтесь с рекомендациями производителя СХД и СУБД, постарайтесь разобраться "почему они так советуют" и спроектируйте систему с учетом разных видов нагрузки. Разнесите принципиально разные виды нагрузки на разные разделы.**
Ну и до кучи
* Читайте не маркетинговый бред, а техническую документацию. Для Dell/EMC и SQL Server начните со ссылок в статье.
* Техническую документацию проверяйте замерами. Эти замеры сравнивать с неким "коммодити" примером (например, [на NUCах c SSD, как вариант, да](https://habr.com/company/croc/blog/342820/)). Работайте по циклу гипотеза-проверка-анализ, честно проверяя свои гипотезы.
* Администраторам СХД и ферм виртуализации **нужно** планировать развертывание вместе с DBA, если там будут сколько-то нагруженные БД (даже 200 транзакций в секунду).
* Если у вас используется геораспределённная синхронная кластеризация (МetroСlaster и его родня), посмотрите, не вносит ли он задержек, которые недопустимы. Эти кластеризации могут давать запросто +0,5 мс, и когда было 0,2, а с кластером стало 0,7 то производительность упадет до 3 раз.
* Проектировать надо понимая, что со временем ситуация изменится и что систему потребуется изменять. Если у вас сейчас раздел `tempdb` не нагружен, то, возможно, разработчики БД в следующей версии включат [RCSI](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/sql/snapshot-isolation-in-sql-server) и в 12 чаов ваша карета превратится в тыкву.
* Latency почти всегда важнее throughput. И это продолжает быть верным и в облачных технологиях, и в "гиперконвергентных системах", и виртуальных фермах. Если вы улучшаете throughput увеличивая latency, то скорее всего ошибаетесь. Такое делать можно только очень обоснованно.
### MS SQL Server
Если говорить про MS SQL, то на самом деле есть некоторое количество способов снизить нагрузку на bottleneck журнала транзакций, может кому-то поможет:
1. Часто я вижу рекомендацию не делать большие транзакции. Это правильно. Но транзакции не должны быть и слишком мелкими. 1000 транзакций подряд вставляющие по одной строке могут быть в 5-30 раз дольше одной транзакции с 1000 `INSERT`. И, да, напомню, что если вы не открыли транзакцию явно, то поведением по умолчанию будет "каждая команда — отдельная транзакция".
2. У `tempdb` журнал транзакций "не настоящий". У него есть кеширование. Поэтому, если вам нужны промежуточные вычисления, то не делайте их в постоянных таблицах.
3. Если нужно вставить много записей, то следует использовать BULK INSERT или другой вариант минимально протоколируемых операций. Минимально протоколируемыми могут быть только операции типа вставки записей и перестроения индекса, и только в моделях восстановления "Simple" и "Bulk logged". И, кстати, во всех остальных случаях разницы производительности между моделями Simple/Bulk logged и Full нет никакой. По массовой загрузке до сих пор самое полезное — [The Data Loading Performance Guide](https://docs.microsoft.com/en-us/previous-versions/sql/sql-server-2008/dd425070(v=sql.100)), но эта статья постепенно [устаревает](https://blogs.msdn.microsoft.com/sql_server_team/sql-server-2016-minimal-logging-and-impact-of-the-batchsize-in-bulk-load-operations/). На закуску (правда про ETL, а не OLTP) ещё одна статья почти десятилетней давности [We Loaded 1TB in 30 Minutes with SSIS, and So Can You](https://docs.microsoft.com/en-us/previous-versions/sql/sql-server-2008/dd537533(v=sql.100))
4. В свежих версиях SQL Server есть [Delayed Transaction Durability](https://docs.microsoft.com/en-us/sql/relational-databases/logs/control-transaction-durability?view=sql-server-2017) — режим, в котором можно получить производительность ценой надёжности.
5. В свежих версиях SQL Server есть [In-Memory OLTP](https://docs.microsoft.com/en-us/sql/relational-databases/in-memory-oltp/in-memory-oltp-in-memory-optimization?view=sql-server-2017). Технология с кучей ограничений, но при грамотном точечном применении может оказаться полезной.
6. Посмотрите, нет ли ненужных синхронных зеркалирований, ненужных синхронных AlwaysOn реплик.
\*\*\*
------
Вот и всё. Нет никой магии. 20000 IOPS с 5 мс latency и с очередью 4-16 ничего не говорит о производительности СХД для задач OLTP. Для OLTP надо правильно размечать СХД, правильно выбирать метрику производительности и уметь измерять её.
**PS: последнее замечание про SSD.**На горизонте есть очень интересный новый участник борьбы за производительность систем хранения для БД. Это Intel Optane. У нынешних SSD "красивые" цифры производительности начинаются от глубины очереди 4, что на самом деле не очень жизненно. Плюс эта производительность на запись обеспечивается некоторым объёмом оперативной памяти внутри SSD, и, если запись идёт достаточно интенсивно, то потом наступает существенная деградация производительности. А еще у SSD ограничен ресурс. Да, у современных серверных и топовых "гражданских" он достаточно [большой, но совсем не бесконечный](https://3dnews.ru/938764/page-2.html). И тут на сцене появляется Intel Optane: судя по тестам несерверных моделей ([раз](https://www.phoronix.com/scan.php?page=article&item=intel-optane-900p), [два](https://www.tomshardware.com/reviews/intel-optane-ssd-905p,5600.html) ) задержки на случайных операциях на очереди глубины 1 выходят на уровень около 20 микросекунд. Это по сути без кеширования, без деградации. SSD при таком же профиле начинают тупить до 100-300 мкс. Ресурс уже [сейчас](https://3dnews.ru/938764/page-2.html) выходит за типичный ресурс SSD.
Ну цена, да. Но потенциально эта железка открывает новые горизонты производительности OLTP "традиционной", не in-memory архитектуры без отказа от ACID. А с другой стороны latency 20 мкс заставляет задуматься о судьбе "обычных" СХД. На low-latency требованиях им будет очень тяжело конкурировать с Optane (*снова привет встроенным системам хранения?*).
Это всё очень круто и я надеюсь на успех (и подешевление) Optane.
**Благодарности**[eugeneb0](https://habr.com/users/eugeneb0/) и [apatyukov](https://habr.com/users/apatyukov/) за добрые советы и вычитку. | https://habr.com/ru/post/414269/ | null | ru | null |
# Языки, которые почти стали CSS
*Привет, Хабр! Предлагаю вашему вниманию перевод статьи [The Languages Which Almost Became CSS](https://eager.io/blog/the-languages-which-almost-were-css/) автора Zack Bloom про языки, которые могли бы стать CSS, сложись история немного иначе.*
> На протяжении всего прошлого года неисчерпаемым источником удовольствия для меня было то, что я постоянно общался с толпами (в буквальном смысле) людей, желавших (держитесь крепче) контролировать внешний вид своих документов так, как это можно тривиальным образом делать в TeX, Microsoft Word или любой другой среде обработки текстов. Я говорил всем им: "**Простите, но вам ничем не помочь**".
>
>
>
> — Марк Андриссен, [1994 год](http://1997.webhistory.org/www.lists/www-talk.1994q1/0648.html)
Когда в 1991 году Тим Бернерс-Ли объявил о создании HTML, способов стилизации страниц не существовало. Способ рендеринга тегов HTML определялся браузером и на него значительно влияли пользовательские настройки. Однако хорошей идеей казалось создание стандартного инструмента, позволяющего страницам «намекать» об их предпочтительном стилистическом рендеринге.
Но до появления CSS было ещё пять лет, и ещё десять лет до его полной реализации. Это был период напряжённой работы и инноваций, приведших к созданию множества конкурирующих способов стилизации, которые вполне могли превратиться в стандарт.
Хотя эти языки, очевидно, сегодня мало где используются, мне интересно поразмышлять над тем, каким бы мог стать мир. Ещё более удивительно то, что многие из этих языков имеют функции, которые разработчики с радостью использовали бы в CSS даже сегодня.
### Первый кандидат
В начале 1993 года браузер Mosaic не достиг даже версии 1.0, а все существовавшие браузеры работали только с HTML. Не было никакого способа указать стиль HTML, поэтому вы видели тег таким, каким его решил показывать браузер.
В июне того же года Роберт Райш внёс в список рассылки www-talk [предложение](http://1997.webhistory.org/www.lists/www-talk.1993q2/0445.html) по созданию «легко анализируемого формата для передачи стилистической информации вместе с веб-документами», который он назвал RRP.
```
@BODY fo(fa=he,si=18)
```
Вполне простительно, если вы не понимаете, что делает этот код. В эпоху до появления gzip, когда скорости подключения обычно не превышали 14,4 кбит/с, вполне логично было сделать содержимое этого нового формата как можно более компактным. Конкретно это правило выбирает в качестве семейства шрифтов (`fa`) Helvetica (`he`) и задаёт размер шрифта (`si`) в 18 пунктов.
Любопытно, что в предложении Райша отсутствовали единицы измерения, все числа интерпретировались на основании контекста (например, все размеры шрифтов задавались в пунктах). Это связано с тем, что RRP проектировался больше как «набор советов и рекомендаций рендереру», а не как спецификация. Это считалось необходимым, потому что одна и та же таблица стилей должна была работать и в обычных браузерах текстового режима (наподобие [Lynx](https://en.wikipedia.org/wiki/Lynx_(web_browser)), и в набиравших всё большую популярность графических браузерах.
*Скриншот браузера Lynx*
Интересно, что в RRP включён способ задания столбчатого расположения — этой возможности в CSS не было до 2011 года. Например, три столбца, каждый шириной в «80 единиц», выглядели бы так:
```
@P co(nu=3,wi=80)
```
Это немного сложно парсить, но, вероятно, не намного сложнее, чем `white-space: nowrap`.
Стоит заметить, что RRP не поддерживал никакой «каскадности», с которой мы сегодня ассоциируем таблицы стилей. Любой документ мог иметь единовременно не более одной активной таблицы стилей, что вполне логично в случае стилизации документов, хоть и непривычно для нас сегодня.
Марк Андриссен (создатель Mosaic, со временем ставшего самым популярным браузером) [знал](http://www.webhistory.org/www.lists/www-talk.1993q4/0266.html) о предложении RRP, но так никогда и не реализовал его в Mosaic. Вместо этого Mosaic почти сразу же двинулся по пути использования тегов HTML для стилизации (что довольно трагично), добавив такие теги, как и .
### Viola и войны прото-браузеров
>
> > «Тогда почему бы просто не реализовать одно из множества уже имеющихся предложений таблиц стилей. При правильной структуре это бы почти полностью решило проблему».
>
>
>
> Тогда бы мне пришлось сказать людям: «Так, вам нужно изучить *этот* язык, чтобы написать документ, а затем изучить *ещё один* язык, чтобы документ выглядел так, как вы хотите». О, они были бы просто в восторге.
>
>
>
> — Марк Андриссен, [1994 год](http://1997.webhistory.org/www.lists/www-talk.1994q1/0683.html)
Вопреки распространённому мнению, Mosaic не был первым графическим браузером. Ему предшествовал [ViolaWWW](https://en.wikipedia.org/wiki/ViolaWWW) — графический браузер, изначально написанный Пей-Юань Веем всего за четыре дня.
*Скриншот браузера Viola*
Пей-Юань создал [язык таблиц стилей](http://1997.webhistory.org/www.lists/www-talk.1993q4/0264.html), поддерживающий разновидность иерархической структуры, которая сегодня используется в CSS:
```
(BODY fontSize=normal
BGColor=white
FGColor=black
(H1 fontSize=largest
BGColor=red
FGColor=white)
)
```
В данном случае мы применяем цвета к телу документа (body) и, в частности, стилизуем `H1`, которые находятся внутри тела. Вместо повторяющихся селекторов для управления этой вложенностью PWP использовал систему скобок, заставляющую нас вспомнить о системах отступов, применяемых в языках наподобие Stylus и SASS, которые и сегодня предпочитают некоторые разработчики вместо CSS. Потенциально это делает синтаксис PWP по крайней мере в одном аспекте лучше, чем CSS, который со временем превратился в универсальный язык веба.
Также PWP примечателен тем, что в нём появился способ ссылаться на внешние таблицы стилей, который мы используем и сегодня:
К сожалению, ViolaWWW была написана в основном для работы с [X Window System](https://en.wikipedia.org/wiki/X_Window_System), которая была популярна только в Unix-системах. Когда Mosaic был портирован на Windows, он быстро поверг Viola в прах.
### Таблицы стилей до веба
> HTML — эта такая штука, которую сможет полюбить только специалист по вычислительным машинам. Да, он выражает внутреннюю структуру документа, но документы это не только структурированные текстовые базы данных; они оказывают визуальное воздействие. HTML совершенно уничтожает любую графическую креативность, которую может иметь разработчик документа.
>
>
>
> — Рой Смит, [1993 год](http://1997.webhistory.org/www.lists/www-talk.1993q3/0238.html)
Потребность в языке, способном выражать стиль документов, намного старше самого Интернета.
Как вы, возможно, знаете, известный нам HTML изначально был основан на доинтернетном языке под названием SGML. В 1987 году Министерство обороны США решило проверить, можно ли использовать SGML для упрощения хранения и передачи его огромных объёмов документации. Как и любому хорошему правительственному проекту, первым делом ему придумали название. Коллектив изначально назвали Computer-Aided Logistics Support team, затем Computer-aided Acquisition and Logistics Support team, и затем, наконец, Continuous Acquisition and Life-cycle Support initiative. В любом случае, инициалами оставались CALS.
Работавшая над CALS команда создала язык для стилизации документов SGML под названием FOSI. Она опубликовала [спецификацию](http://people.opera.com/howcome/2006/phd/archive/www.dt.navy.mil/tot-shi-sys/tec-inf-sys/cal-std/doc/28001C.pdf) языка, столько же подробную, сколь и непостижимую. В неё была включена любимая мной [самая бессмысленная инфографика](https://web.archive.org/web/20110709102010/http://people.opera.com/howcome/2006/phd/i/fosi.png), когда-либо существовавшая в вебе.
Одно не имеющее исключений правило Интернета гласит: всегда удаётся сделать больше, если в процессе работы можно доказать, что кто-то неправ. В 1993 году, спустя всего четыре дня после предложения Пей-Юаня, Стивен Хини [внёс предложение](http://1997.webhistory.org/www.lists/www-talk.1993q4/0295.html), что вместо «изобретения колеса» для стилизации веба лучше использовать версию FOSI.
Сам документ FOSI написан на SGML, что является довольно логичным ходом, учитывая знакомство веб-разработчиков с версией SGML под названием HTML. Пример документа выглядит вот так:
```
```
Возможно, вы не понимаете, что такое `docdesc` или `charlist`, как не понимали этого и члены `www-talk`. Единственная контекстная информация заключается в том, что `e-i-c` означает «element in context». Однако FOSI примечателен тем, что в нём впервые появилась единица измерения `em`, которая теперь стала предпочтительным способом задания размера в CSS.
Разразившийся конфликт языков на самом деле был столь же древним, как и само программирование. Это была битва функционального синтаксиса «в стиле lisp» с синтаксисом более декларативных языков. Сам Пей-Юань [описывал](http://1997.webhistory.org/www.lists/www-talk.1993q4/0297.html) свой синтаксис как «LISP-подобный», но появление на сцене истинного LISP-варианта было лишь вопросом времени.
### Тьюринг-полная таблица стилей
Несмотря на свою сложность, FOSI на самом деле воспринимался как [промежуточное решение](http://xml.coverpages.org/kennDSSSLInt.html) задачи форматирования документов. Долговременный план заключался в создании языка, основанного на языке функционального программирования Scheme, способного реализовать самые мощные преобразования документов, которые можно представить. Этот язык назвали DSSSL. Дадим слово одному из разработчиков языка Джону Босаку:
> Не стоит ошибочно относить DSSSL к категории скриптовых языков. Да, DSSSL Тьюринг-полный; да, это язык программирования. Но скриптовый язык (по крайней мере, в моей интерпретации термина) процедурен; а DSSSL с полной определённостью таковым не является. DSSSL полностью функционален и полностью свободен от побочных эффектов. В таблице стилей DSSSL никогда ничего не происходит. Таблица стилей — это одна огромная функция, значением которой является абстрактное, аппаратно-независимое, непроцедурное описание отформатированного документа, как спецификация (декларация, если пожелаете) отображаемых областей, передаваемое находящимся ниже процессам рендеринга.
В своём простейшем виде DSSSL и в самом деле довольно логичный язык стилизации:
```
(element H1
(make paragraph
font-size: 14pt
font-weight: 'bold))
```
Поскольку он был языком программирования, в нём можно было даже задавать функции:
```
(define (create-heading heading-font-size)
(make paragraph
font-size: heading-font-size
font-weight: 'bold))
(element h1 (create-heading 24pt))
(element h2 (create-heading 18pt))
```
И использовать при стилизации математические конструкции, например, чтобы сделать строки таблицы полосами:
```
(element TR
(if (= (modulo (child-number) 2)
0)
... ;even-row
...)) ;odd-row
```
Чтобы вы ещё больше завидовали, скажем, что DSSSL мог обрабатывать унаследованные значения как переменные и выполнять над ними математические операции:
```
(element H1
(make paragraph
font-size: (+ 4pt (inherited-font-size))))
```
К сожалению, DSSSL обладал смертельным изъяном, свойственным всем языкам в стиле Scheme: слишком большим количеством скобок. Кроме того, его спецификация была *чересчур полной* на момент окончательного выпуска, что отпугивало разработчиков браузеров. Спецификация DSSSL включала в себя более 210 отдельных стилизуемых свойств.
Дальнейшая работа разработчиков привела к созданию [XSL](https://en.wikipedia.org/wiki/XSL) — не менее запутанного, но гораздо более популярного языка преобразования документов.
### Почему таблица стилей победила
CSS не имеет родительских селекторов (способа стилизации родителя на основании содержащихся в нём дочерних элементов). Этот факт уже [давно](http://stackoverflow.com/questions/1014861/is-there-a-css-parent-selector) [мучает](http://stackoverflow.com/questions/45004/complex-css-selector-for-parent-of-active-child?lq=1) [пользователей](http://stackoverflow.com/questions/2000582/css-selector-for-foo-that-contains-bar?lq=1) [Stack](http://stackoverflow.com/questions/4220327/css-selector-element-with-a-given-child?lq=1) [Overflow](http://stackoverflow.com/questions/21252551/apply-style-to-parent-if-it-has-child-with-css?lq=1), но оказывается, для их отсутствия есть довольно веская причина. В первые годы развития Интернета считалось критически важным, чтобы страницу можно было отрендерить до полной загрузки документа. Другими словами, необходимо было иметь возможность отрендерить HTML начала страницы ещё до полной загрузки HTML конца страницы.
Наличие родительского селектора означало бы, что стили необходимо обновлять в процессе загрузки HTML-документа. Языки наподобие DSSSL полностью исключались, потому что они могут выполнять операции над самим документом, который не доступен полностью на момент начала рендеринга.
Первым, кто поднял эту проблему в марте 1995 года и [предложил](http://people.opera.com/howcome/2006/phd/archive/odur.let.rug.nl/~bert/stylesheets.html) для её решения работающий язык, стал Берт Бос. В его предложении также содержится ранняя версия эмотикона «смайлик» :-).
Сам язык по синтаксису был довольно «объектно-ориентированным»:
```
*LI.prebreak: 0.5
*LI.postbreak: 0.5
*OL.LI.label: 1
*OL*OL.LI.label: A
```
Символ `.` обозначал ближайшие дочерние элементы, а `*` — предков.
Язык Боса обладал ещё одним интересным свойством: можно было указывать, как работают элементы наподобие ссылок в самой таблице стилей:
```
*A.anchor: !HREF
```
В примере выше мы указали, что адресом перехода для элемента-ссылки является значение в его атрибуте `HREF`. Эта мысль о том, что поведение элементов наподобие ссылок должно быть контролируемым, была популярной во множестве других предложений. В эпоху до JavaScript не существовало способов контроля таких аспектов, поэтому казалось логичным включить их в эти предложения.
В одном [проекте](http://people.opera.com/howcome/2006/phd/archive/tigger.cc.uic.edu/~cmsmcq/style-primitives.html) функционального языка, предложенного в 1994 году джентльменом по имени С.М. Сперберг-Маккуин, то же поведение реализовано функционально:
```
(style a
(block #f) ; format as inline phrase
(color blue) ; in blue if you’ve got it
(click (follow (attval 'href))) ; and on click, follow url
```
В его языке также появилось ключевое слово `content` как способ управления содержимым HTML-элемента из таблицы стилей. Позже эта концепция была добавлена в CSS 2.1.
### Каким мог бы быть веб
Прежде чем рассказать о языке, который на самом деле стал CSS, стоит упомянуть ещё одно предложение языка, хотя бы по той причине, что он, в каком-то смысле был мечтой первых веб-разработчиков.
PSL96 был, как понятно из его названия, версией Presentation Specification Language 1996 года. По своей сути PSL выглядит как CSS:
```
H1 {
fontSize: 20;
}
```
Однако всё быстро становится намного интереснее. Например, можно было выражать позицию элемента не только в зависимости от заданного ему размера (`Width`), но и по истинному (`Actual Width`) размеру, в котором он рендерится в браузере:
```
LI {
VertPos: Top = LeftSib . Actual Bottom;
}
```
Из примера видно, что можно было также использовать в качестве ограничения левый одноуровневый элемент.
Также в стили можно было добавлять логические выражения. Вот пример стилизации только элементов-якорей, имеющих `href`:
```
A {
if (getAttribute(self, "href") != "") then
fgColor = "blue";
underlineNumber = 1;
endif
}
```
Такую стилизацию можно было расширять до всевозможных аспектов, для реализации которых мы сегодня используем классы:
```
LI {
if (ChildNum(Self) == round(NumChildren(Parent) / 2 + 1)) then
VertPos: Top = Parent.Top;
HorizPos: Left = LeftSib.Left + Self.Width;
else
VertPos: Top = LeftSib.Actual Bottom;
HorizPos: Left = LeftSib.Left;
endif
}
```
Поддержка подобной функциональности, вероятно, позволила бы наконец реализовать мечту об отделении контента от стиля. К сожалению, этот язык был слишком уж расширяемым, то есть существовала большая вероятность, что его реализации бы сильно отличались в разных браузерах. Кроме того, его опубликовали в серии статей научного мира, а не в списке рассылки www-talk, где происходил основной объём конструктивной работы. Его так никогда и не интегрировали ни в один популярный браузер.
### Призрак прошлого CSS
Язык, который мог непосредственно привести к созданию CSS (по крайней мере, судя по названию), назывался CHSS (Cascading HTML Style Sheets). Его [предложил](http://people.opera.com/howcome/2006/phd/archive/www.w3.org/People/howcome/p/cascade.html) в 1994 году Хокон Ли (Håkon W Lie).
Как и большинство хороших идей, первоначальное предложение было довольно безумным.
```
h1.font.size = 24pt 100%
h2.font.size = 20pt 40%
```
Обратите внимание на проценты в конце правил. Этот процент означает, какую величину «владения» текущая таблица стилей имеет над этим значением. Например, если в предыдущей таблице стилей для `h2` был задан размер шрифта `30pt` с `60%` «владения», а в этой таблице стилей для `h2` задан стиль `20px 40%`, то два значения можно скомбинировать на основании их процента владения и получить значение около `26pt`.
Вполне понятно, почему такое предложение было внесено именно в эпоху документных HTML-страниц: такой дизайн на основе компромиссов не нашёл бы понимания в нашем ориентированном на приложения мире. Как бы то ни было, в нём появилась фундаментальная идея о необходимости каскадной структуры таблиц стилей. Иными словами, идеи о том, что на одной странице необходима возможность применения нескольких таблиц стилей.
В своей исходной формулировке эта идея была общепризнана важной, потому что она давала конечному пользователю контроль над тем, что он видит. У оригинальной страницы могла быть одна таблица стилей, а у пользователя веба могла иметься собственная таблица, и их можно было бы комбинировать для рендеринга страницы. Поддержка множественных таблиц стилей рассматривалась как способ сохранения личной свободы в вебе, а не как способ поддержки разработчиков (которые по-прежнему кодировали каждую отдельную HTML-страницу вручную).
Пользователь мог бы даже иметь возможность управления степенью контроля, который он давал рекомендациям автора страницы; такое управление в предложении языка описывалась ASCII-схемой:
````
User Author
Font o-----x--------------o 64%
Color o-x------------------o 90%
Margin o-------------x------o 37%
Volume o---------x----------o 50%
````
Как и многие из подобных предположений, данный проект содержал в себе возможности, которые появились в CSS только спустя десятилетия, а то и вообще не появились. Например, в нём была возможность написания логических выражений на основании окружения пользователя:
```
AGE > 3d ? background.color = pale_yellow : background.color = white
DISPLAY_HEIGHT > 30cm ? http://NYT.com/style : http://LeMonde.fr/style
```
В довольно оптимистичном научно-фантастическом видении будущего считалось, что браузер будет знать, насколько релевантен для пользователя каждый элемент контента, позволяя отображать его в большем размере:
```
RELEVANCE > 80 ? h1.font.size *= 1.5
```
### Все мы знаем, что случилось потом
> Microsoft полностью привержен открытым стандартам, особенно в Интернете.
>
>
>
> — Джон Лудеман, [1994 год](http://1997.webhistory.org/www.lists/www-talk.1994q4/0003.html)
Хокон Ли продолжил работать над упрощением своего предложения, и совместно с Бертом Босом в декабре 1996 года опубликовал первую версию спецификации CSS. В конечном итоге он написал свою докторскую диссертацию о создании CSS, и [этот документ](http://people.opera.com/howcome/2006/phd/) чрезвычайно помог мне в написании статьи.
По сравнению со множеством других предложений, примечательным аспектом CSS была его простота. Его легко парсить, на нём легко писать и его легко читать. Как это часто бывало в истории Интернета, победила та технология, которую проще всего освоить новичку, а не та, которая оказалась самой мощной для специалистов.
Само по себе это является напоминанием о том, насколько случайной может быть инновация. Например, поддержка контекстуальных селекторов (`body ol li`) была добавлена только потому, что у Netscape уже был способ устранения границ из изображений, которые являлись гиперссылками, и казалось необходимым реализовать всё, на что способен популярный браузер. Сама функциональность вызвала значительную задержку в реализации CSS, потому что в то время при парсинге HTML большинство браузеров не хранило «стек» тегов. Это значило, что для полной поддержки CSS парсеры было необходимо переработать.
Из-за подобных проблем (и из-за повсеместного использования нестандартных HTML-тегов для задания стиля) CSS не был пригоден к использованию до 1997 года, и не поддерживался полностью ни одним браузером до марта 2000 года. Как вам скажет любой разработчик, поддержка браузерами была очень далека от соответствия стандартам и ситуация изменилась всего несколько лет назад, пятнадцать лет спустя после выпуска CSS.
### Финальный босс
> Если Netscape 4 игнорировал правила CSS, применяемые к элементу , и добавлял случайное количество пробелов к каждому структурному элементу на странице, и если IE4 реализовывал правильно, но халтурил с отступами, то какой именно CSS был безопасным? Некоторые разработчики решили вообще не писать CSS. Другие писали одну таблицу стилей, чтобы компенсировать изъяны IE4 и ещё одну таблицу, чтобы компенсировать недочёты Netscape 4.
>
>
>
> — Джеффри Зельдман
Internet Explorer 3 известен тем, что был выпущен с (довольно ужасной) поддержкой CSS. Было решено, что для возможности конкурировать в Netscape 4 тоже должна быть поддержка этого языка. Однако вместо того, чтобы удвоить усилия по реализации этого третьего языка (после HTML и JavaScript), было решено, что его нужно реализовать преобразованием CSS в JavaScript с последующим его исполнением. Хуже того — было решено, что этот промежуточный язык «JavaScript Style Sheet» должен быть [доступен веб-разработчикам](https://web.archive.org/web/19970709133056/http://home.netscape.com/comprod/products/communicator/guide.html).
Синтаксис представлял собой обычный JavaScript с добавлением API стилизации:
```
tags.H1.color = "blue";
tags.p.fontSize = "14pt";
with (tags.H3) {
color = "green";
}
classes.punk.all.color = "#00FF00"
ids.z098y.letterSpacing = "0.3em"
```
Можно было даже определять функции, значения которых вычислялись *при встрече с каждым вхождением тега*:
```
evaluate_style() {
if (color == "red"){
fontStyle = "italic";
} else {
fontWeight = "bold";
}
}
tag.UL.apply = evaluate_style();
```
Мысль о том, что нужно упростить разделительную линию между стилями и скриптами, довольно разумна, и сегодня она даже возрождается в [сообществе React](https://facebook.github.io/react/tips/inline-styles.html).
Сам JavaScript в то время был очень молодым языком, но благодаря реверс-инжинирингу его поддержка была добавлена уже в IE3 (в виде JScript). Гораздо более серьёзной проблемой было то, что сообщество в то время уже сплотилось вокруг CSS, а Netscape в то время рассматривался большинством представителей сообщества разработчиков стандартов как [нарушитель](https://lists.w3.org/Archives/Public/www-style/1996Jun/0068.html). Когда Netscape [предложил](https://www.w3.org/Submission/1996/1/WD-jsss-960822) JSSS комитету по стандартам, его пропустили мимо ушей. Три года спустя Netscape 6 отказался от поддержки JSSS и тот постепенно скончался.
### Что нас могло ждать
Благодаря [публичному порицанию](https://www.w3.org/Style/CSS/Test/CSS1/current/) со стороны W3C, Internet Explorer 5.5 был выпущен почти с полной поддержкой CSS1 в 2000 году. Разумеется, как мы теперь знаем, браузерные реализации CSS были ужасно забагованными и трудными в работе по крайней мере ещё в течение десятка лет. К счастью, сегодня ситуация значительно улучшилась, что наконец позволило реализовать мечту разработчиков о том, что можно написать код один раз и он будет функционировать в разных браузерах (почти) одинаково.
Лично я из всего этого сделал вывод о том, насколько произвольными и контекстными являлись решения, которые руководят нашими современными инструментами. Если CSS разрабатывался как способ, совместимый с ограничениями, актуальными в 1996 году, то, может быть, двадцать с лишним лет спустя это даёт нам разрешение делать всё немного иначе. | https://habr.com/ru/post/528942/ | null | ru | null |
# Мой опыт настройки роутера wl500gvp2 в качестве принт-сервера
Я являюсь счастливым обладателем [этого волшебного устройства](http://ru.asus.com/products.aspx?l1=29&l2=172&l3=743&l4=0&model=1712&modelmenu=1). Кроме своих основных функций этот роутер может служить принт-сервером и файлопомойкой благодаря наличию двух USB 2.0 портов.
До настройки файлопомойки у меня руки не дошли, а вот принт-сервер — это моя давняя мечта.
Прошивка у меня стоит [от Олега](http://oleg.wl500g.info/), версия 1.9.2.7-10. Принтер — Xerox 3120 (аналог Samsung 1510).
Небольшое отступление: в русских интернетах есть замечательный форум [wl500g.info](http://wl500g.info/), его ведёт тот самый Олег, от которого у меня стоит прошивка. Первым делом после покупки любого роутера от asus следует наведаться туда. Очень много интересного и полезного.
Вернёмся к нашим баранам.
Подключаем принтер к любому понравившемуся USB-порту роутера и смотрим в веб-интерфейсе раздел
> `Status & Log`
Принтер определился, это уже радует. [Пробуем настроить принтер без драйвера](http://oleg.wl500g.info/printing/).
Если заработало, то можно дальше не читать, а если нет, то можно попробовать следующее:
заходим с помощью `telnet` на роутер. В моём случае это
> `telnet 192.168.1.1`
Даём команду
> `p910nd -f -b /dev/usb/lp0`
Программа `p910nd` предназначена как раз для нашего случая: всё, что приходит на tcp-порт 9100, она пересылает на указанное устройство. Роутер настроен так, что считает, что принтер — это устройство
> `/dev/usb/lp0`
Не будем его разочаровывать.
После этого ставим драйвера принтера на машину, с которой собираемся печатать. Т.е. делаем всё, что написано [в этой инструкции](http://oleg.wl500g.info/printing/), кроме пункта 11. Драйвер принтера выбираем правильный.
После этого у меня всё заработало, чему я был несказанно рад! | https://habr.com/ru/post/44391/ | null | ru | null |
# Добавить системный вызов. Часть 4 и последняя
*```
- Что-то беспокоит меня Гондурас...
- Беспокоит? А ты его не чеши.
```*
В предыдущих частях обсуждения ([1-я](http://habrahabr.ru/post/267535/), [2-я](http://habrahabr.ru/post/267773/) и [3-я](http://habrahabr.ru/post/268145/)) мы рассматривали как, используя возможность поменять содержимое sys\_call\_table, **изменить** поведение того или иного системного вызова Linux. Сейчас мы продолжим эксперименты в сторону того, можно ли (и как) динамически **добавить** новый системный вызов в целях вашего программного проекта.
Мы не станем акцентироваться на вопросе «зачем?» — в программировании последнее дело спрашивать «зачем?», нужно спрашивать «как?»: если какая-то техника вам не близка — вы её просто не используйте (см. эпиграф). Но тем не мене, мы вернёмся коротко к этому к концу, в обсуждении.
Как это выглядит?
=================
При общей похожести на обсуждавшиеся ранее примеры подмены системного вызова, эта задача, при всём её сходстве, имеет некоторые отягчающие особенности:
* Размер оригинальной таблицы системных вызовов sys\_call\_table медленно но монотонно увеличивается от версии к версии ядра и существенно зависит от конкретной процессорной платформы.
* Константа, задающая размерность этой таблицы (известная в ядре как \_\_NR\_syscall\_max, или в некоторых новых версиях как \_\_NR\_syscalls), объявлена **препроцессорной** константой (макросом) периода компиляции, и неизвестна во время выполнения (по крайней мере, мне неизвестна).
* Пытаясь добавить собственную точку входа **в конец** таблицы, мы имеем существенные риск выйти за пределы области, выделенной таблице — этого делать нельзя!
Размер таблицы sys\_call\_table достаточно велик, и он меняется от версии к версии ядра (версия 3.13), вот его очень **грубая** оценка:
```
$ cat /proc/kallsyms | grep ' sys_' | grep T | wc -l
357
```
О версиях ядра в этой части обсуждения придётся упоминать постоянно: то, что определялось в заголовочном файле предыдущей версии, может к следующей версии определяться по-другому и совсем в другом месте (файле), а то и вовсе явно не определяться. Это обычная практика в кодах ядра. Но при всём том, все основные принципы и зависимости остаются неизменными от версии к версии.
Смягчает выше перечисленные ограничивающие обстоятельства то, что таблица системных вызовов **не плотная**, достаточно сильно **разреженная**, в ней есть не использующиеся позиции (**оставшиеся** от устаревших системных вызовов и не поддерживаемых в настоящее время). **Все** такие позиции заполнены одним адресом — указателем на функцию обработчика нереализованных вызовов sys\_ni\_syscall():
```
$ cat /proc/kallsyms | grep sys_ni_syscall
c045b9a8 T sys_ni_syscall
```
А сам системный вызов sys\_ni\_syscall() определён как-то так:
```
asmlinkage long sys_ni_syscall( void ) {
return -ENOSYS;
}
```
Следовательно, мы можем добавить свой новый обработчик системного вызова в **любую** неиспользуемую позицию таблицы sys\_call\_table. Обратим внимание на то, что в этих позициях находятся не устаревшие, неиспользуемые вызовы, а помещён именно вызов, единственным действием которого является возврат кода ошибки. Более того, разработчики ядра не имеют права повторно использовать эти позиции, иначе совершенно устаревшие приложение могло бы вызывать, того не подозревая, новый замещающий вызов.
Статически, текстуально в исходном коде, можно в деталях рассмотреть структуру таблицы sys\_call\_table (для выбранной платформы и версии). Для таких изучений мало пригоден сам исходный код как он представлен разработчиками, но, к счастью для наших целей, на сегодня существует весьма много ресурсов, визуализирующих код ядра средствами проекта LXR (Linux Kernel Cross Reference), например здесь или здесь (это позволяет сравнивать версии и с лёгкостью находить нужные идентификаторы). Я для примера покажу только те позиции sys\_call\_table ядра 3.0.26 архитектуры x86 которые содержат (файл ) ссылку на sys\_ni\_syscall (но к ядру 3.2 и далее этот файл исчезнет даже из дерева кодов… но принципы формирования таблицы останутся те же и вид её не изменится):
```
ENTRY(sys_call_table)
.long sys_restart_syscall /* 0 - old "setup()" system call, used for restarting */
.long sys_exit
...
.long sys_ni_syscall /* old break syscall holder */ //17
.long sys_ni_syscall /* old stty syscall holder */ //31
.long sys_ni_syscall /* old gtty syscall holder */ //32
.long sys_ni_syscall /* 35 - old ftime syscall holder */ //35
.long sys_ni_syscall /* old prof syscall holder */ //44
.long sys_ni_syscall /* old lock syscall holder */ //53
.long sys_ni_syscall /* old mpx syscall holder */ //56
.long sys_ni_syscall /* old ulimit syscall holder */ //58
.long sys_ni_syscall /* old profil syscall holder */ //98
.long sys_ni_syscall /* old "idle" system call */ //112
.long sys_ni_syscall /* old "create_module" */ //127
.long sys_ni_syscall /* 130: old "get_kernel_syms" */ //130
.long sys_ni_syscall /* reserved for afs_syscall */ //137
.long sys_ni_syscall /* Old sys_query_module */ //167
.long sys_ni_syscall /* reserved for streams1 */ //188
.long sys_ni_syscall /* reserved for streams2 */ //189
.long sys_ni_syscall /* reserved for TUX */ //222
.long sys_ni_syscall //223
.long sys_ni_syscall //251
.long sys_ni_syscall /* sys_vserver */ //273
.long sys_ni_syscall /* 285 */ /* available */ //285
...
.long sys_setns // 346
```
В листинге показаны только неиспользуемые позиции (за исключением начала и конца таблицы), комментарии оставлены из исходного кода, а последний комментарий, с номером позиции системного вызова, добавлен мной.
Видим, что для этой версии ядра таблица имеет 347 позиций системных вызовов, из которых 21 не задействованы. Анализу неиспользуемых позиций **в динамике**, не полагаясь на изменчивые коды ядра, и будет посвящён первый рассматриваемый модуль ядра:
```
static void **taddr, // адрес sys_call_table
*niaddr; // адрес sys_ni_syscall()
static int nsys = 0; // число системных вызовов в версии
#define SYS_NR_MAX 450
// SYS_NR_MAX - произвольно большое, больше длины sys_call_table
static int sys_length( void* data, const char* sym, struct module* mod, unsigned long addr ) {
int i;
if( ( strstr( sym, "sys_" ) != sym ) ||
( 0 == strcmp( "sys_call_table", sym ) ) ) return 0;
for( i = 0; i < SYS_NR_MAX; i++ ) {
if( taddr[ i ] == (void*)addr ) { // найден sys_* в sys_call_table
if( i > nsys ) nsys = i;
break;
}
}
return 0;
}
static void put_entries( void ) {
int i, ni = 0;
char buf[ 200 ] = "";
for( i = 0; i <= nsys; i++ )
if( taddr[ i ] == niaddr ) {
ni++;
sprintf( buf + strlen( buf ), "%03d, ", i );
}
LOG( "found %d unused entries: %s\n", ni, buf );
}
static int __init init_driver( void ) {
if( NULL == ( taddr = (void**)kallsyms_lookup_name( "sys_call_table" ) ) ) {
ERR( "sys_call_table not found!\n" );
return -EFAULT;
}
LOG( "sys_call_table address = %p\n", taddr );
if( NULL == ( niaddr = (void*)kallsyms_lookup_name( "sys_ni_syscall" ) ) ) {
ERR( "sys_ni_syscall found!\n" );
return -EFAULT;
}
LOG( "sys_ni_syscall address = %p\n", niaddr );
kallsyms_on_each_symbol( sys_length, NULL );
LOG( "sys_call_table length = %d\n", nsys + 1 );
put_entries();
return -EPERM;
}
module_init( init_driver );
```
Как и раньше, необязательные детали (такие как макрос LOG() и др.) не показаны, все они есть в полных прилагаемых файлах.
Можно было бы пойти проще (что тоже корректно) — для выяснения протяжённости sys\_call\_table просто пересчитать число символов ядра по маске sys\_\* и вычесть 1 (сам символ sys\_call\_table). Но мы идём избыточным путём:
* в цикле находится очередной символ по маске sys\_\*;
* его **позиция** разыскивается в sys\_call\_table (это дополнительная перестраховка, что это **системный** вызов);
* если эта позиция больше, чем найденные ранее для предыдущих символов, то на считается текущим номером **последнего** вызова (текущим размером sys\_call\_table);
Такая избыточная (но вовсе не необходимая) схема позволяет попутно уточнить **точный размер** таблицы системных вызовов для ваши архитектуры и версии ядра Linux:
```
$ uname -p
i686
$ uname -r
3.13.0-37-generic
$ sudo insmod nsys.ko
insmod: ERROR: could not insert module nsys.ko: Operation not permitted
$ dmesg | tail -n 4
[10751.601851] ! sys_call_table address = c1666140
[10751.602194] ! sys_ni_syscall address = c1075930
[10751.659769] ! sys_call_table length = 351
[10751.659779] ! found 27 unused entries: 017, 031, 032, 035, 044, 053, 056, 058, 098, 112, 127, 130, 137, 167, 169, 188, 189, 222, 223, 251, 273, 274, 275, 276, 285, 294, 317,
```
Итого, в этой версии 351 системных вызовов, из которых 27 не используются (почти 10% размера таблицы). Стабильность этого списка очень высока (сознательно для анализа кода была выбрана версия 3.0.26, а для исполнения в динамике версии 2.6.32 и 3.13, отстоящие друг от друга более чем на 4 года выпуска).
**Примечание:** Не отвлекаясь в сторону, отметим тем не менее вскользь, что написание модуля в подобной манере, который а). не предназначен для загрузки вообще, б). и в связи с этим сознательно возвращает не нулевой код завершения, в). а потому и вообще не имеет функции выгрузки (\_\_exit) — это прямой эквивалент пользовательского приложения (начинающегося от точки main()), но только выполняющегося в режиме супервизора, с максимальными привилегиями. Но это уже предмет для другого разговора…
Реализация нового системного вызова
===================================
Теперь мы готовы возвратиться к реализации сформулированной задачи: добавить новый системный вызов. Естественно, нам также понадобится и тестовое приложение пользовательского пространства использующее такой вызов. Номер нового вызова определён в общем заголовочном файле (syscall.h), для согласованности использования модулем и программой (там же и упоминавшиеся макросы LOG(), ERR() и другая мелочёвка):
```
// номер нового добавляемого системного вызова
#define __NR_own 223
// может быть взят любой, полученный при загрузке модуля nsys.ko
// для ядра 3.31 был получен ряд из 27 позиций:
// 017, 031, 032, 035, 044, 053, 056, 058, 098, 112,
// 127, 130, 137, 167, 169, 188, 189, 222, 223, 251,
// 273, 274, 275, 276, 285, 294, 317,
```
Проще и понятнее начать именно с пользовательского приложения, которое будет выполнять новый системный вызов. Здесь всё просто — проще не бывает:
```
static void do_own_call( char *str ) {
int n = syscall( __NR_own, str, strlen( str ) );
if( n == 0 ) LOG( "syscall return %d\n", n );
else {
ERR( "syscall error %d : %s\n", n, strerror( -n ) );
exit( n );
}
}
int main( int argc, char *argv[] ) {
if( 1 == argc ) do_own_call( "DEFAULT STRING" );
else
while( --argc > 0 ) do_own_call( argv[ argc ] );
return EXIT_SUCCESS;
};
```
Программа может делать один или серию (если указать несколько параметров в командной строке) системных вызовов и передаёт символьный параметр в вызов (подобно тому, как это делает, например sys\_write). А уже в коде модуля мы сможем видеть как эта строка копируется в пространство ядра. Но главным интересом здесь есть код возврата: успех или неудача выполнения системного вызова.
А вот и модуль, который «подхватывает» такой вызов со стороны ядра:
```
asmlinkage long (*old_sys_addr) ( void );
// системный вызов с двумя параметрами:
asmlinkage long new_sys_call ( const char __user *buf, size_t count ) {
static char buf_msg[ 80 ];
int res = copy_from_user( buf_msg, (void*)buf, count );
buf_msg[ count ] = '\0';
LOG( "accepted %d bytes: %s\n", count, buf_msg );
return res;
};
static void **taddr; // адрес таблицы sys_call_table
static int __init new_sys_init( void ) {
void *waddr;
if( NULL == ( taddr = (void**)kallsyms_lookup_name( "sys_call_table" ) ) ) {
ERR( "sys_call_table not found!\n" );
return -EFAULT;
}
old_sys_addr = (void*)taddr[ __NR_own ];
if( ( waddr = (void*)kallsyms_lookup_name( "sys_ni_syscall" ) ) != NULL )
LOG( "sys_ni_syscall address = %p\n", waddr );
else {
ERR( "sys_ni_syscall not found!\n" );
return -EFAULT;
}
if( old_sys_addr != waddr ) {
ERR( "not free slot!\n" );
return -EINVAL;
}
LOG( "old sys_call_table[%d] = %p\n", __NR_own, taddr[ __NR_own ] );
rw_enable();
taddr[ __NR_own ] = new_sys_call;
rw_disable();
LOG( "new sys_call_table[%d] = %p\n", __NR_own, taddr[ __NR_own ] );
return 0;
}
static void __exit new_sys_exit( void ) {
rw_enable();
taddr[ __NR_own ] = old_sys_addr;
rw_disable();
LOG( "restore sys_call_table[%d] = %p\n", __NR_own, taddr[ __NR_own ] );
return;
}
module_init( new_sys_init );
module_exit( new_sys_exit );
```
Здесь также делается двойная перестраховка — проверка соответствия адреса в заданной (\_\_NR\_own) позиции таблицы sys\_call\_table адресу неиспользуемых системных вызовов sys\_ni\_syscall.
И теперь оцениваем то, что у нас получилось:
```
$ ./syscall
syscall error -1 : Operation not permitted
$ echo $?
255
$ sudo insmod adds.ko
$ lsmod | head -n3
Module Size Used by
adds 12622 0
pci_stub 12550 1
$ dmesg | tail -n3
[15000.600618] ! sys_ni_syscall address = c1075930
[15000.600622] ! old sys_call_table[223] = c1075930
[15000.600623] ! new sys_call_table[223] = f87d9000
$ ./syscall new string for call
syscall return 0
syscall return 0
syscall return 0
syscall return 0
$ dmesg | tail -n4
[15070.680753] ! accepted 4 bytes: call
[15070.680799] ! accepted 3 bytes: for
[15070.680804] ! accepted 6 bytes: string
[15070.680807] ! accepted 3 bytes: new
$ ./syscall 'new string for call'
syscall return 0
$ dmesg | tail -n1
[15167.526452] ! accepted 19 bytes: new string for call
$ sudo rmmod adds
$ dmesg | tail -n1
[15199.917817] ! restore sys_call_table[223] = c1075930
$ ./syscall
syscall error -1 : Operation not permitted
```
После выгрузки модуля ядро более не в состоянии поддержать выполнение требуемого программе системного вызова!
Обсуждение
==========
Обсуждать тут, собственно, нечего — всё прозрачно показано примером. Но я вначале обещал высказать свои соображения зачем такое вообще может иметь применение (но ещё раз повторю своё твёрдое убеждение в том, что вопрос «зачем?» в программировании, в общем случае, бессмысленный). Показанный трюк предоставляет ещё один путь взаимодействия (двухстороннего) приложений с ядром. Да, конечно есть возможность сделать то же через /dev, /proc, или /sys … но каждый из этих способов тяжеловеснее, чем системный вызов, он вовлекает в работу большее число промежуточных механизмов ядра.
Когда представляется возможность использовать подобный механизм? Например, для асинхронных уведомлений приложения о некоторых событиях в ядре, когда отдельный поток приложения заблокирован на системном вызове до наступления ожидаемого события. Таким событием может быть, например, аппаратное прерывание (IRQ) от отлаживаемого нового устройства (в меру не быстрого). При таком подходе любые операции ввода-вывода с устройством можно реализовать из пространства пользователя, используя операции группы inb(), outb()…, или ioperm() и iopl(). Всё это вместе даёт возможность изучить работу и выписать код обмена с устройством в самых тонких деталях не выходя за пределы пространства пользователя, без рисков и сложностей, связанных с привилегированным режимом ядра. А дальше уже по обстоятельствам и по желанию: можно механически переписать код этого оттестированного драйвера в форме модуля, или оставить как он и есть в пользовательском пространстве.
**Примечание:** Замечание выше о низкой скорости устройств, которые только и можно отрабатывать подобным образом, тоже не следует принимать слишком близко к сердцу. По настоящему высокоскоростные устройства и внутри ядра Linux не работают по прерываниям, а используют циклический программный опрос. Как, например, все сетевые интерфейсы сетевого стека на аппаратном уровне … кто знает сетевую подсистему Linux тот поймёт о чём это я.
Я уже не говорю о разработчиках проприетарного железа и проектов, которые имеют такие же права на существование в природе, как и прочие. В их работах подобная техника может найти почву для применения.
И опять же, как ранее, архив кода можно взять [здесь](https://yadi.sk/d/JrOw3qsgjaf43) или [здесь](https://drive.google.com/file/d/0B__cqmYoRw_6U0xCeHctRnZFeDQ/view?usp=sharing)…
Эпилог
======
Поскольку это заключительная часть небольшого цикла о таком непривычном (неприличном?) обращении с системными вызовами Linux, то хотелось бы в два слова высказать в порядке общего итога рассказанного.
Когда приступаешь к написанию модулей ли ядра, или патчей к ядру, первоначально возникает ощущение скованности, ограниченности только теми возможностями, которые предоставляет плохо документированный API ядра, либо описаны в немногочисленных и давно устаревших книгах по типу «написание драйверов Linux». Но опыты, подобные описанным в этом цикле, и ещё множество иных подобных, подсказывают, что в модуле ядра вы имеете в доступе **все** (без исключения!) возможности пространства пользователя (запуск новых процессов и потоков, посылка сигналов UNIX др.). И плюс к этому недостижимые в пользовательском пространстве возможности, связанные с привилегированным (супервизор, кольцо 0) режимом защиты процессора (привилегированные команды, внутренние регистры процессора, реакция на прерывания).
Показать это — вот главная цель этого цикла статей, а вовсе не всего лишь частные задачи подмены или добавления системных вызовов. Программирование в режиме ядра должно создавать такое ощущение свободы, что здесь вы подобны богам и можете здесь делать всё. Но это же требует и адекватной степени ответственности… | https://habr.com/ru/post/268409/ | null | ru | null |
# Кэширование в Android, Telegram для групп, улучшение callback, multicast, showlist и другие нововведения
Достаточно крупное обновление исправляющее ошибки в андроид клиенте, улучшение безопасности получения ID пользователя, рассылка одного пуша на группу пользователей в канале, а также API для работы со списками пользователей.
Сегодня в рубрике:
1. Используем PushAll и Telegram при разработке в команде
2. Иконки сожрали мой трафик — помогите!
3. Почему я вижу лишь их кусок?
4. Эмоджи убийцы!
5. Как объединить тысячу итераций отправки уведомлений в одну (multicast)
6. ~~Воруем личные дан~~ Получаем список пользователей, подписанных на канал
7. Подписываемся на пуш уведомления ваших друзей (уязвимость)
8. Не ждем отправки всех уведомлений, выполняем все в фоне.
Опишу в стиле проблемы и её решения
Иконки уведомлений обрезались
=============================
Ко мне обращались с проблемой, что на Android 4.\* иконки обрезаются. Если точнее, на старых версих не было автоматической подгонки иконок.
**Решилось это просто:**
```
if(icon != null){
Resources res = getApplicationContext().getResources();
int height = (int) res.getDimension(android.R.dimen.notification_large_icon_height);
int width = (int) res.getDimension(android.R.dimen.notification_large_icon_width);
int realwidth=icon.getWidth();
int realheight=icon.getHeight();
if(realwidth>realheight){
height=height * realheight / realwidth;
}else{
width=width * realwidth / realheight;
}
icon=Bitmap.createScaledBitmap(icon, width, height, true);
}
```
Выше представлен алгоритм адаптивного изменения иконки под устройство. При том используется фильтрация, поэтому параллельно с этим мы еще и улучшили качество отображения иконок на более новых версиях Android.
Приложение скачивало по 100 МБ трафика в месяц в виде иконок
============================================================
Эту проблему уже заметил я, и я посчитал, что она очень серьезная. Также в неё можно включить такие проблемы:
1. Долгая доставка уведомления при загрузке картинки через нестабильное соединение
2. Отсутствие иконки при плохом соединении
3. Отсутствие иконки в режиме экономии энергии.
Про последнее хочу рассказать подробнее. Дело в том, что Android, в новых версиях, в режиме энергосбережения, отключает фоновую передачу всех не системных приложений. Это приводит к тому, что уведомление приходит, а вот иконку мы загрузить не можем.
**Решение: создать алгоритм кэширования.**
Сначала я долго бился над тем, чтобы алгоритм использовал стандартные средства кэша HTTP.
```
connection.setUseCaches(true);
```
Я нашел даже решение для переопределения алгоритма кэширования, т.к. стандартного не было, и оно вроде как работало, за одним исключением — в случае если сети нет — иконка все равно не загрузится. То есть Android блокировал именно все HTTP запросы, даже если идет проверка кэширования.
Тогда я написал свой метод, который проверяет наличие md5-имени файла в папке кэша. И если он есть, то использует его. Сеть вообще не используется. Это достаточно жесткое кэширование, то есть для смены изображения, нужно всегда менять его название, иначе будет загружаться старое.
```
public Bitmap getBitmapFromURL(String strURL) {
Bitmap myBitmap;
BitmapFactory.Options options = new BitmapFactory.Options();
options.inPreferredConfig = Bitmap.Config.RGB_565;
File file = new File(cacheDir, md5(strURL));
FileInputStream finput=null;
if (file.exists()) {
try {
finput = new FileInputStream(file);
myBitmap=BitmapFactory.decodeStream(finput, null, options);
finput.close();
return myBitmap;
} catch (IOException e){
return BitmapFactory.decodeResource(
getResources(), R.drawable.gcm_cloud, options);
}
}
try {
URL url = new URL(strURL);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
//connection.setUseCaches(true);
connection.setDoInput(true);
connection.connect();
if (connection.getContentLength() < 524288){
InputStream input = connection.getInputStream();
FileOutputStream output = new FileOutputStream(file);
int bufferSize = 1024;
byte[] buffer = new byte[bufferSize];
int len = 0;
while ((len = input.read(buffer)) != -1) {
output.write(buffer, 0, len);
}
output.close();
finput = new FileInputStream(file);
myBitmap = BitmapFactory.decodeStream(finput, null, options);
finput.close();
}else{
myBitmap=BitmapFactory.decodeResource(
getResources(), R.drawable.gcm_cloud, options);
}
return myBitmap;
} catch (IOException e) {
//e.printStackTrace();
return null;
}
}
public static final String md5(final String s) {
final String MD5 = "MD5";
try {
// Create MD5 Hash
MessageDigest digest = java.security.MessageDigest
.getInstance(MD5);
digest.update(s.getBytes());
byte messageDigest[] = digest.digest();
// Create Hex String
StringBuilder hexString = new StringBuilder();
for (byte aMessageDigest : messageDigest) {
String h = Integer.toHexString(0xFF & aMessageDigest);
while (h.length() < 2)
h = "0" + h;
hexString.append(h);
}
return hexString.toString();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return "";
}
```
Выше я описал итоговый алгоритм генерации битмапа из ссылки с проверкой кэша и MD5 функцию, которую нашел в сети. Думаю, код прост и в комментариях нет необходимости.
Также в алгоритме используется ограничение размера картинки в 512 килобайт.
Итог: при подписке на 20 каналов пользователь не грузит больше по 1-5 мегабайт в день. Также уведомления приходят намного быстрее, а иконки отображаются даже если сети нет, конечно же при условии, что канал не использует каждый раз новые иконки.
Любой мог внедрить callback ссылку на свой сайт и «привязать» свои устройства к чужим аккаунтам
===============================================================================================
Странно что мы не додумались до этого ранее, но это так. Мы добавили новые методы защиты.
Новый адрес такой: АДРЕС?pushalluserid=ID&time=UNIXTIME&sign=ПОДПИСЬ.
То есть в GET вам будет передан параметр «pushalluserid» с ID пользователя, а также параметры для проверки.
Для проверки подписи используйте md5($key.$pushalluserid.$time.$ipAddress).
Где ipAddress:
$ipAddress = $\_SERVER['REMOTE\_ADDR'];
Где $key — ключ вашего канала. Где $time — UNIXTIME.
Вы можете сами установить необходимый уровень проверки, к примеру после проверки времени и IP считать ключ валидным 1 минуту. Также следите за тем, чтобы время на вашем сервере было точное. При желании можно считать ссылку валидной вообще секунд 5.
Также остается работать обратная совместимость. То есть после введения этого метода безопасности ваши текущие приложения продолжают работать. Но вам нужно как можно быстрее реализовать защиту на своей стороне.
Как итог имеем проверку и безопасность, реализованную без дополнительных запросов. Главное признавать свои ошибки и вовремя их исправлять.
Почему уже целые сутки через RSS пушится один и тот же пост?!
=============================================================
В общем как то так, получилось даже зловеще немного.
Что случилось? Да вот что,
Тинькофф вставил эмоджи в пост. Тоже самое было еще с одним каналом. Так как на сервере стоит utf8\_unicode\_ci, а она трехбайтовая, то mysql рубил посты по эмоджи. У проблемы есть 2 решения, это использовать utf8mb4 или вырезать эмоджи.
Первое требует времени, применил второй костыль:
```
function removeEmoji($text) {
$clean_text = "";
// Match Emoticons
$regexEmoticons = '/[\x{1F600}-\x{1F64F}]/u';
$clean_text = preg_replace($regexEmoticons, '', $text);
// Match Miscellaneous Symbols and Pictographs
$regexSymbols = '/[\x{1F300}-\x{1F5FF}]/u';
$clean_text = preg_replace($regexSymbols, '', $clean_text);
// Match Transport And Map Symbols
$regexTransport = '/[\x{1F680}-\x{1F6FF}]/u';
$clean_text = preg_replace($regexTransport, '', $clean_text);
// Match Miscellaneous Symbols
$regexMisc = '/[\x{2600}-\x{26FF}]/u';
$clean_text = preg_replace($regexMisc, '', $clean_text);
// Match Dingbats
$regexDingbats = '/[\x{2700}-\x{27BF}]/u';
$clean_text = preg_replace($regexDingbats, '', $clean_text);
return $clean_text;
}
```
Не было возможности рассылать уведомления группе пользователей, только по одному
================================================================================
Эта проблема назревала уже давно. На данный момент один из каналов использует unicast для рассылки нескольким людям, у него объемы не такие крупные, а вот новому партнеру будет необходимо рассылать больше 10 тысяч уведомлений за раз, поэтому multicast встал в приоритет.
Особенности такие:
1. Фильтр — учитывается (в unicast нет, что позволяет уведомить пользователя сквозь фильтр)
2. За раз можно выбрать 1000 пользователей в массиве. (конечно, такие объемы надо пересылать через POST)
3. Вам не нужно делать дополнительное уведомление и пересылать все данные, пришлите lid (ID пуша в логе) и новые отправки закрепятся за ним, более того, вы должны это делать, иначе вам будет сложно отслеживать статистику и работать в дальнейшем с уведомлением
Также ниже опишу одновременно и возможность увести задачу в «фоновый» режим. То есть вам не нужно ждать, пока система отправить гуглу все данные, и поработает с телеграмом (что очень долго). Вы просто даете запрос и получаете ID пуша, с которым дальше работаете.
```
$ch = curl_init()
//цикл?
if($i==0)
$data=array(
"type" => "multicast",
"id" => "1",
"key" => "7db783637a21ed5a8af94513239dada7",
"text" => "Тестовое сообщение",
"title" => "Заголовок",
"background" => 1
); //первая итерация
else
$data=array(
"type" => "multicast",
"id" => "1",
"key" => "7db783637a21ed5a8af94513239dada7",
"lid" => $lid,
"background" => 1
); //остальные итерации
$data['uids']=json_encode(array_slice($alluids, $i*1000, 1000, true)); //отрезаем 1000 записей для передачи на сервер.
curl_setopt_array($ch, array(
CURLOPT_URL => "https://pushall.ru/api.php",
CURLOPT_POSTFIELDS => $data,
CURLOPT_SAFE_UPLOAD => true,
CURLOPT_RETURNTRANSFER => true
));
$return=curl_exec($ch); //получить ответ или ошибку
$lid=json_decode($return,true)['lid'];
//закрываем цикл
curl_close($ch);
```
Код выше позволяет.
1. 1. Выполнять задачи быстро, отправляя их в фон
2. 2. Отправлять несколько тысяч уведомлений с одним и тем же ID в цикле
3. 3. Использовать Keep-Alive для более быстрой коммуникации.
Background — доступен сегодня.
Multicast еще в разработке и тестируется, будет доступен через неделю.
Как получить списки пользователей?
==================================
Ранее, я описывал метод showlist. Теперь у него есть параметр — subtype=users
При использовании этого параметра, вы получаете список всех пользователей, а если добавить uid=ID пользователя, то можно выбрать и отдельного.
Вы получаете все данные, что и при просмотре списка через сайт.
Телеграм для групп, бизнеса и разработки
========================================
После добавления функции интеграции телеграма, мне очень многие писали с просьбами работы с группами.
Зачем это нужно?
* Оказывается есть интернет магазины, которые обсуждают заказы в общем чате и координируют действия. Им удобно, когда с их магазина сыпется уведомление в общий чат.
* Есть группы разработки, которые хотят получать в общий чат, коммиты, баги, обновления или пуши из их систем и далее уже в общем чате это обсуждать.
Вам нужно лишь добавить бота [@PushAllGrBot](https://telegram.me/PushAllGrBot) в общий чат, написать /getid и прописать полученный ID в настройках канала.
При этом ваши подписчики все также смогут получать уведомления на свои устройства параллельно с телеграмом.
Итоги, что нас ждет дальше?
===========================
Мы исправили много ошибок, сделали много новых функций и оптимизаций. Через неделю у нас намечается выход нативной iOS версии. Мы активно интегрируемся с новыми сайтами и сервисами, а также ждем в наш каталог множество добровольцев, которые смогут интегрировать систему самостоятельно.
Для пользователей скоро будут доступны новые составные фильтры, системы оценок и отзывов на каналы и многое другое. В приложениях будут возможности настройки звука уведомлений и вибрации.
Задавайте вопросы по новым функциям, предлагайте новые возможности, которые вам необходимы.
Удачного дня! | https://habr.com/ru/post/262571/ | null | ru | null |
# CoinRoad: Как мы сделали приложение на базе кастомных пушей в Android
Сегодня я хочу рассказать вам об интересном и в некотором смысле новом способе взаимодействия с пользователем – кастомных пушах в Android. Именно его мы использовали как основу своего мобильного приложения CoinRoad для отображения графиков и котировок криптовалют на биржах в режиме реального времени в виде обновляемых в фоне пушей, которые продолжают работать даже после закрытия приложения.
Основное преимущество такого подхода заключается в том, что каждый день мы получаем кучу уведомлений на свой телефон, а значит обращаем на них внимание, опуская шторку или видя их на экране блокировки. Однако временной интервал жизни таких пушей крайне мал, поскольку пуш обычно либо свайпается, либо по нему открывается более подробная информация в приложении и он все-равно удаляется.
Разумеется, есть уведомления, которые остаются висеть постоянно, как, например, музыкальный плеер. Но до сих пор такая механика еще не применялась для отображения торговой истории с бирж, когда каждая минута на счету и важно быть в курсе, не переключаясь постоянно между различными приложениями. Виджеты на рабочем столе не решают проблему – чтобы попасть на рабочий стол, нужно сначала свернуть активное приложение.
### Кастомные пуши
Android уже довольно давно предоставляет возможность создавать свои собственные варианты оформления пушей. Делается это через [RemoteViews](https://developer.android.com/reference/android/widget/RemoteViews), который, правда, ограничен в плане поддержки доступных для отображения элементов следующим списком:
Supported Views* [AnalogClock](https://developer.android.com/reference/android/widget/AnalogClock)
* [Button](https://developer.android.com/reference/android/widget/Button)
* [Chronometer](https://developer.android.com/reference/android/widget/Chronometer)
* [ImageButton](https://developer.android.com/reference/android/widget/ImageButton)
* [ImageView](https://developer.android.com/reference/android/widget/ImageView)
* [ProgressBar](https://developer.android.com/reference/android/widget/ProgressBar)
* [TextClock](https://developer.android.com/reference/android/widget/TextClock)
* [TextView](https://developer.android.com/reference/android/widget/TextView)
А поскольку для отображения графиков в пушах было решено использовать стороннюю [библиотеку](https://github.com/halfhp/androidplot), которая реализовывает свой собственный `View`, сразу же возникла сложность с ее интеграцией в пуш. Решение было найдено, однако оно является компромиссным и заключается в том, что содержимое графика поставляется как растровое изображение и выводится через `ImageView`. Но так как размеры пуша не маленькие, а содержимое получаемого изображения весит прилично, мы наткнулись на проблему с ограничением на размер буфера в 1mb и получили следующее исключение: [TransactionTooLargeException](https://developer.android.com/reference/android/os/TransactionTooLargeException).
Во время удаленного вызова фоновой процедуры аргументы и возвращаемое значение вызова передаются как `Parcel` объекты, хранящиеся в буфере транзакции `Binder`. Если аргументы или возвращаемое значение слишком велики, чтобы поместиться в буфере транзакции, вызов завершится ошибкой.
Для решения этой проблемы пришлось сжимать изображение до 500kb, что незначительно сказалось на качестве итоговых данных, но позволило добиться результата. Изображение включает в себя не только сам график, но и текущие ценовые котировки, название торговой пары и биржи. Вся отрисовка ведется средствами Canvas, что позволяет добиться хорошей производительности и низкого энергопотребления даже на слабых устройствах.
### Работа в фоне
Все добавленные пользователем пуши обновляются бесшумно с интервалом в одну минуту, не привлекая лишнего внимания, напоминая о себе звуковым сигналом только при добавлении или удалении пуша из приложения.
Для фоновой работы используется [WorkManager](https://developer.android.com/reference/androidx/work/WorkManager) в связке с [CoroutineWorker](%5Bhttps://developer.android.com/topic/libraries/architecture/workmanager/advanced/coroutineworker%5D(https://developer.android.com/topic/libraries/architecture/workmanager/advanced/coroutineworker))
Выбор в пользу WorkManager вместо Service был обусловлен желанием иметь гарантированную возможность работать в новых реалиях Doze mode (режим «отключки», в который переходят все устройства начиная с Marshmallow после некоторого времени обездвижения без зарядки) и не писать свой BroadcastReceiver для запуска сервиса при различных условиях.
WorkManager с версии `2.3.0-alpha02` добавляет поддержку длительно работающих процессов. В таких случаях WorkManager может подавать сигнал в ОС, что процесс должен оставаться активным, если это возможно пока работа выполняется. Под капотом WorkManager управляет и запускает `Foreground Service` от вашего имени для выполнения WorkRequest, а также отображает настраиваемое уведомление. А чтобы ничего не умирало, был написан обработчик ошибок, который может перезапустить WorkManager.
Однако стоит принять во внимание, что WorkManager пока еще находится в alpha-версии, так что будьте внимательны.
### Удаление пушей
Еще одной болью стало решение проблемы с удалением пушей, которые добавляются в фоновый процесс CoroutineWorker'а через метод
`setForeground(ForegroundInfo(..))`
Проблема заключалась в том, что невозможно отменить пуш, который ты добавил, для этого просто нет соответствующего метода. А вызов cancel у NotificationManager'а не приводил ни к какому результату, что [подтверждает](https://developer.android.com/reference/android/app/NotificationManager#cancel(int)) документация:
"If the notification does not currently represent a Service#startForeground(int, Notification), it will be removed from the UI and live notification listeners will be informed so they can remove the notification from their UIs."
Для решения этой проблемы было решено пересоздавать канал уведомлений всякий раз, когда пользователь решит изменить список валютных пар, которые он бы хотел видеть в пушах.
### Криптобиржи
На данный момент в приложение интегрированы две популярные криптобиржи с общим количество торговых пар, превышающих 1000. Это биржи Kraken и Hitbtc. В последующих обновлениях список поддерживаемых бирж будет расширен такими известными площадками как: Binance, Bitmex, Bitstamp, Kucoin, Poloniex, что почти полностью покроет основные потребности трейдеров и сделает мониторинг простым и удобным как никогда.
Если же говорить о нашей общей цели и миссии – мы хотим познакомить людей с миром криптовалют, сделать порог входа в эту тему как можно легче и показать всем, что это удобно, полезно и перспективно.
[**Скачать из Google Play**](https://play.google.com/store/apps/details?id=ru.mobileup.coinroad) | https://habr.com/ru/post/534260/ | null | ru | null |
# Человеческим языком про метрики 1: Потерянное введение
Однажды мне понадобилось внедрить метрики в сервисы своей команды. С самого начала я не понимал, что именно хочу получить: одно дело — прикрутить библиотеку и нарисовать графики, другое дело — показывать осмысленные данные.
Мне нужен был гайд, который сочетает эти две вещи: сначала «почему так принято», а затем — «как правильно делать». В результате такой гайд мне пришлось написать самому. Его цель — объяснить разработчикам с любым бэкграундом, что такое метрики, как правильно о них думать и осмысленно использовать. Сначала гайд жил во внутренней документации Точки, но я решил сделать его публичным — возможно, кому-то этот опыт будет полезен. Разбираться будем с [Prometheus](https://prometheus.io/) и [Grafana](https://grafana.com/). Если у вас другой стек — не страшно. Мы затронем и фундаментальные темы: например, перцентили, производные и кардинальность.
Гайд будет выходить как цикл статей. Сначала посмотрим на архитектуру: как собираются метрики и где хранятся. Дальше разберемся с типами метрик — они не так просты, как кажется. Потом придется немного отвлечься на математику (но только с инженерной точки зрения!). И, наконец, научимся писать запросы, но не просто так: сразу посмотрим на разные грабли и неочевидные моменты.
Какие статьи выйдут в цикле:
1. Потерянное введение
2. [Prometheus](https://habr.com/ru/company/tochka/blog/685636/)
3. [Перцентили для чайников](https://habr.com/ru/company/tochka/blog/690814/)
4. [PromQL](https://habr.com/ru/company/tochka/blog/693834/)
Прежде чем подключать библиотеки, поднимать сервера и писать запросы, давайте восстановим справедливость и **найдем** введение, которого мне не хватило при изучении метрик. В этой статье мы определимся, какую вообще решаем задачу, и почему решение такое непривычное.
### Здравый смысл
Вот захотели вы собирать разные метрики, «чтобы было видно все, что происходит в сервисах». Теперь задайте себе и команде важные вопросы:
* А как это вообще сделать?
* А что именно хочется увидеть в результате?
* Как решают эту задачу другие люди?
Чтобы не придумывать свой велосипед, можно изучить общепринятые подходы, найти готовый стек. Но там будет, что называется, *своя атмосфера*. И нет коллеги или гайда, которые бы объяснили, почему оно вообще так странно устроено.
Технически задача выглядит как-то так: в компании уже есть, например, Grafana (если нет, ее несложно поднять). Есть сотня способов собрать и передать туда данные, но сразу возникают вопросы: что мы хотим там отобразить? А почему нельзя это просто в SQL сложить? Зачем нужен этот ваш Prometheus, наконец?
> Для сложных технологий хорошо иметь не только инструкцию, но и правильный mindset, тогда все инструменты будут даваться легче.
>
>
Вот со всем этим и будем разбираться.
Вообще метрики — это неожиданно сложно: мы пытаемся разными инженерно-математическими фокусами сжать неудобный, большой массив данных до чего-то наглядного. В отличие от логов, которые просто пишутся «как есть» и наверняка уже используются в ваших сервисах. Кстати, **а почему бы не парсить логи** и на основании этого уже строить какие-то графики? Так, конечно, можно, и это нормально — до некоторого предела.
### Метрики vs логи
**Логи — это про точность**: мы собираем информацию на каждое событие. Если их агрегировать, можно увидеть общую картину и даже вытащить детали вплоть до единичного запроса. Но отправка логов на каждый чих плохо масштабируется.
Трафик логов зависит от трафика приложения: больше запросов, больше действий – и логов пропорционально больше. Часто они не структурированы, их сложно индексировать и парсить — для графиков нужно вытаскивать числа из текста. Ну и традиционно в логи пишется много лишнего, а значит обработка и агрегация будут страдать и отставать от реального времени.
**Метрики – это сразу общая картина** о состоянии приложения. Мы собираем не все детали, а только готовую выжимку: например, количество запросов к сервису. Картину мы получим, но в детали провалиться нельзя. Зато такой подход хорошо масштабируется и быстро работает. Можно моментально реагировать и рассылать алерты. Если нужны детали – думаем и добавляем по чуть-чуть.
Например, считаем количество запросов к разным endpoint-ам. Трафик метрик зависит от их количества и периодичности сбора/отправки их в хранилище. И, наконец, в метрики мы не пишем ничего лишнего, а, наоборот, стараемся писать как можно меньше. В следующих частях станет понятно, почему.
> Пишем все и потом думаем (ценой трафика и сложности обработки) vs думаем и пишем только, что надо (ценой потери деталей).
>
>
Если у вас не очень много сервисов, и вы не планируете масштабирование, то можно не усложнять и остановиться на парсинге логов. В популярном стеке ELK есть встроенные средства визуализации.
### Push vs Pull
Сбор метрик можно организовать двумя способами. У каждого есть свои плюсы и минусы. Чем глубже копать и чем больше масштабы, тем сложнее становится выбор — вплоть до холиваров.
**Push** – принцип такой же, как с логами или базой данных: произошло событие – пишем данные в хранилище. События можно отправлять пачками. Способ прост в реализации с точки зрения клиента.
**Pull** – наоборот: приложения хранят в памяти компактные данные вроде `обработано запросов: 25`. Кто-то периодически приходит и собирает их, например по HTTP. С точки зрения клиента pull сложнее реализовать, но проще отлаживать: у каждого приложения появляется endpoint, куда можно зайти браузером и увидеть, что происходит конкретно в этом приложении. Не нужно писать хитрые запросы, фильтровать данные по репликам и вообще иметь доступ в общее хранилище метрик. Кроме того, эта модель стимулирует разработчиков писать в метрики только то, что необходимо, а не все подряд.
Чтобы метрики не занимали лишнюю память приложения и быстро отдавались, мы вынуждены их агрегировать. Никто не хочет хранить в памяти подробности о каждом запросе, потому что эти данные очень быстро займут всю память. Приходится ограничиваться минимумом: например, вести счетчики запросов и ошибок. Это в итоге уменьшает нагрузку на инфраструктуру: ей нужно забрать и сохранить уже максимально сжатые данные, о которых уже подумали разработчики приложения.
Конечно, push тоже можно приготовить аналогичным образом, но там гораздо проще отправлять все подряд, а потом разбираться.
Мы выбрали pull: Prometheus на тот момент был построен в основном вокруг этой модели, и нам было проще выбрать решение с централизованным управлением.
### TSDB
Метрики нужно куда-то складывать и потом делать выборки. Эту задачу решают специализированные БД: Time Series Database.
Особенности TSDB – обработка временны́х рядов, то есть однотипных измерений во времени. БД этого типа оптимизируют хранение какого-то числа, которое записано через равные интервалы времени. Проще понять на примере: чтобы собирать ежедневную температуру воздуха, нам надо хранить что-то вроде `[(day1, t1), (day2, t2), ...]` и больше ничего.
Главное сейчас – понять вот эту особенность: TSDB нужны, чтобы сохранять **время** и **одно число**, привязанное к этому времени. Потом снова время и число, и так далее. Пока что обойдемся без конкретики и деталей реализации.
Специфика:
* реляционку умеют по минимуму: если SQL, то ограниченный, а то и вовсе его нет;
* типы хранимых данных урезаны;
* оптимизация на постоянную непрерывную запись.
Раз на SQL это все не похоже, то не обязательно поддерживать сложный язык запросов. Можно сделать свой, ~~упоротый~~ метрико-ориентированный простой язык.
> Когда-то мы использовали для метрик InfluxDB — у него как раз SQL-подобные запросы. Но на наших объемах он просто взорвался, и с high availability было плохо, поэтому от него отказались.
>
>
Для работы с TSDB существуют свои специализированные форматы данных, и они проще, чем SQL. [В следующей части](https://habr.com/ru/company/tochka/blog/685636/) мы разберемся, как готовить TSDB Prometheus: он устроен так, что **формат метрик и язык запросов — это практически одно и то же**, поэтому страдать придется всего один раз!
### Визуализация
Когда у нас появится БД для хранения метрик и способ доставки данных в нее, мы сможем писать запросы, но... Просто так смотреть на таблицы с числами неинтересно. Поэтому запросы к БД обычно делает Grafana: она парсит таблицы из ответов и рисует удобные графики. В ней уже можно настроить масштаб, покрасить и добавить прочие украшения. Но писать запросы все равно придется самостоятельно.
Дальше мы будем разбираться именно с запросами Prometheus, **без нюансов, которые добавляет Grafana.** Поэтому для начала она вообще не понадобится — у Prometheus есть простой web-интерфейс, который визуализирует результаты запросов. Его вполне хватит для обучения, тестов и отладки.
### Алерты
Самое полезное, что можно выжать из метрик и графиков – это **алерты**: нам не нужен живой человек, который постоянно следит за свободным местом на диске или за количеством ответов `HTTP 500`. Можно настроить автоматику, которая реагирует на выход графиков за допустимые границы и рассылает уведомления. Но, чтобы до этого добраться, придется сначала научиться собирать и хранить метрики, потом их запрашивать и отображать на графиках, и только потом уже расставлять алерты.
С алертами мы разбираться не будем, потому что концептуально тема уже не настолько сложная для понимания, как метрики, а архитектура решения будет очень сильно зависеть от специфики: кому-то нужна рассылка в мессенджере, кому-то телефонный бот.
---
Теперь должно быть более-менее понятно, из чего будет состоять решение для сбора метрик, и почему оно такое непривычное. [Дальше](https://habr.com/ru/company/tochka/blog/685636/) будем разбирать формат данных и язык запросов Prometheus. | https://habr.com/ru/post/683608/ | null | ru | null |
# «Божественный» код (GOD'S code)
«Божественный» код — громкий термин, который может показаться желтым заголовком, но всё же именно о таком коде будет идти речь: из каких частей он состоит и как его писать. Это история о моих стараниях сделать так, чтобы задачи не возвращались с code review с пометкой: «Всё хе\*ня — переделать».
У меня нет профильного образования, и учиться программированию приходилось на практике, через ошибки, ссадины и ушибы. Непрерывно работая над улучшением качества написанного кода, я вырабатывал некоторые правила, которым он должен соответствовать. Хочу ими поделиться.
GOD’S code — акроним из акронимов — код, написанный в соответствии с принципами Grasp, Object calisthenics, Demeter’s law и Solid. Кому-то они знакомы все, кто-то встречался лишь с некоторыми, но мы рассмотрим каждую составляющую акронима. Я не ставлю своей целью детально погрузиться в каждую группу правил, так как на просторах интернета они уже много раз освещались. Вместо этого предлагаю выжимку из собственного опыта.
GRASP
-----
Девять шаблонов для назначения ответственностей классам и объектам. Для удобства запоминания я разделяю их на две подгруппы:
1. В первую подгруппу можно выделить правила, позволяющие писать атомарные модули, которые хорошо тестируются и изменяются. Эти правила не столько про ответственность, а, скажем так, про свойства модулей: слабая связанность, сильное сцепление, полиморфизм, устойчивость к изменениям. Для себя я перекрываю эти правила SOLID’ом, об этом подробнее — в соответствующей части.
2. Вторая подгруппа — это уже более чёткие шаблоны, которые говорят нам о том, кто создаёт объекты («создатель» — собирательное название для фабричных паттернов), каким образом понизить связанность между модулями (используя паттерны «контроллер» и «посредник»), кому делегировать отдельные обязанности (информационный эксперт) и что делать, если я люблю DDD и одновременно low coupling (чистая выдумка).
Подробнее можно [почитать здесь](https://en.wikipedia.org/wiki/GRASP_(object-oriented_design)).
Объектная калистеника
---------------------
Набор правил оформления кода, очень похожих на свод законов codeStyle. Их также девять. Я расскажу о трёх, которые стараюсь соблюдать в повседневной работе (немного видоизменённых), об остальных можно почитать в [первоисточнике](https://williamdurand.fr/2013/06/03/object-calisthenics/).
1. Длина метода — не более 15 LOC, количество методов в классе — не более 15, количество классов в одном пространстве имён — не более 15. Суть в том, что длинные простыни кода очень сложно читать и понимать. К тому же, длинные классы и методы являются сигналом о нарушении SRP (об этом ниже).
2. Максимум один уровень вложенности на метод.
```
public function processItems(array items)
{
// 0
foreach (items as item) {
// 1
for (i = 0; i < 5; i++) {
// 2
… process item 5 times …
}
}
}
```
В этом примере пятикратную обработку `item` уместно вынести в отдельный метод.
```
public function processItems(array items)
{
// 0
foreach (items as item) {
// 1
this.processItem(item);
}
}
public function processItem(Item item)
{
// 0
for (i = 0; i < 5; i++) {
// 1
… process item 5 times …
}
}
```
Опять-таки, цель — иметь возможность понять, что делает метод, кинув на него один взгляд и не компилируя код в голове.
3. Не использовать `else` там, где он не нужен.
```
public function processSomeDto(SomeDtoClass dto)
{
if (predicat) {
throw new Exception(‘predicat is failed’);
} else {
return this.dtoProcessor.process(dto);
}
}
```
И брюки превращаются:
```
public function processSomeDto(SomeDtoClass dto)
{
if (predicat) {
throw new Exception(‘predicat is failed’);
}
return this.dtoProcessor.process(dto);
}
```
В результате приходится читать меньше кода, к тому же выпрямляем поток выполнения.
Закон Деметры
-------------
Жёсткая версия слабой связанности из GRASP’a. Накладывает ограничения на то, с кем может взаимодействовать текущий модуль.
Возьмём три объекта: А содержит B, В содержит С. Рассмотрим объект А. Метод А объекта А может иметь доступ только к методам и свойствам:
1. Самого объекта А.
2. Объекта, который передан в качестве параметра методу А.
3. Объекта В.
4. Объектов, которые **непосредственно** созданы внутри метода А.
И всё. Проще говоря, объект А взаимодействует только с непосредственными соседями. Взаимодействие типа `this.objectB.objectC.getSomeStuff()` является нарушением Закона Деметры, потому что из объекта А мы обращаемся к методу объекта С, который не является непосредственным соседом объекта А.
Есть пара интересных следствий. Во-первых, использование фабрик приводит к нарушению Закона Деметры. Посудите сами:
```
public function methodA()
{
spawnedObject = this.factory.spawn();
spawnedObject.performSomeStuff();
}
```
Равносильно:
```
public function methodA()
{
this.factory.spawn().performSomeStuff();
}
```
Для решения этой проблемы можно выделить некую обёртку, единственным назначением которой будет создание объекта с помощью фабрики и передача его на обработку куда-либо дальше.
```
public function methodA()
{
this.processor.process(this.factory.spawn());
}
```
Второе интересное следствие: DTO/Entity. Многим довольно часто приходится собирать или использовать контейнеры данных.
```
public function methodA(SomeDtoClass dto)
{
dto.getAddress().getCity();
}
```
Если следовать букве Закона Деметры, это будет нарушением, так как мы обратились к соседу соседа. Но на практике с контейнером данных допускают послабление, считая его как единое целое, и, соответственно, обращение к методу `getCity DTO Address` в нашем случае считается обращением к части контейнера `dto`.
Принципы SOLID
--------------
SRP, OCP, LSP, ISP, DIP — я лишь вкратце коснусь их, потому как в Википедии и на Хабре они описаны довольно подробно.
**SRP** — принцип единственной ответственности. Один программный модуль — одна задача, одна причина для изменения. Перекликается с High Cohesion из GRASP’a.
Пример: у нас есть контроллер, задача которого — быть связующим звеном между бизнес-логикой и представлением (MVC). Если мы засунем какую-либо часть бизнес-логики в контроллер, то автоматически нарушим SRP.
```
public function indexAction(RequestInterface request): ResponseInterface
{
requestDto = this.requestTransformer.transform(request);
responseDto = this.requestProcessor.process(requestDto);
return this.responseTransformer.transform(responseDto);
}
```
В данном примере контроллер не выполняет никакой бизнес-логики или логики преобразования, а делегирует её другим модулям, выполняя лишь одну функцию — быть связующим звеном. Нарушение данного принципа приведёт к тому, что при необходимости внесения изменений в одной функциональности, мы увеличиваем риски затронуть другую функциональность, расположенную по соседству, но которую менять мы совершенно не планировали.
**OCP** — принцип открытости-закрытости. Пишем код так, чтобы не приходилось его изменять, а лишь расширять.
Если в выполнении кода нужно сделать какую-либо развилку, то обычно используется if/switch. А если нужно добавить ещё одну ветку, то текущий код изменяется. И это нехорошо. Работает — не трогай. Добавляй новое и тестируй новое, а старое пусть себе работает.
Для решения подобной задачи имеет смысл создать некоторый resolver, который настраивается набором ветвей и выбирает нужную.
```
final сlass Resolver implements ResolverInterface
{
private mapping;
public function Resolver(array mapping)
{
this.mapping = mapping;
}
public function resolve(Item item)
{
return this.mapping[item.getType()].perform(item);
}
}
```
Не забудьте про обработку ошибок, её я опустил. Дам совет: если принять за правило, что все классы могут быть либо final, либо abstract, то следовать этому принципу будет гораздо проще.
**LSP** — принцип подстановки Барбары Лисков. Корнями уходит в контрактное программирование и говорит о том, как нам правильно строить наследование.
Постулаты таковы:
1. Производные классы не должны усиливать предусловия (не должны требовать большего от своих клиентов).
2. Производные классы не должны ослаблять постусловия (должны гарантировать, как минимум, то же, что и базовый класс).
3. Производные классы не должны нарушать инварианты базового класса (инварианты базового класса и наследников суммируются).
4. Производные классы не должны генерировать исключения, не описанные базовым классом (методы подкласса не могут генерировать никаких дополнительных исключений, кроме тех, которые сами являются подклассами исключений, генерируемых методами надкласса).
```
class ParentClass
{
public function someMethod(string param1)
{
// some logic
}
}
class ChildClass extends ParentClass
{
public function someMethod(string param1, string param2)
{
if (param1 == '') {
throw new ExtraException();
}
// some logic
}
}
```
В данном примере `someMethod` класса `ChildClass` требует большего от клиентов (`param2`), и к тому же предъявляет определённые требования к `param1`, которых не было в родительском классе. То есть нарушаются правила наследования, в результате мы не сможем без дополнительных ухищрений заменять использование `ParentClass` на `ChildClass`.
**ISP** — принцип разделения интерфейсов. Говорит о том, что не стоит засовывать все возможные методы в один интерфейс. Иными словами, если мы реализуем в классе интерфейс, и при этом часть методов обязательны к реализации, но нам они не нужны, — значит, стоит разделить этот интерфейс.
```
interface DuckInterface
{
public function swim(): void;
public function fly(): void;
}
class MallardDuck implements DuckInterface
{
public function swim(): void
{
// some logic
}
public function fly(): void
{
// some logic
}
}
class RubberDuck implements DuckInterface
{
public function swim(): void
{
// some logic
}
public function fly(): void
{
// can't fly :(
}
}
```
`RubberDuck` реализует интерфейс `DuckInterface`. Но, насколько мне известно, резиновые утки не летают, поэтому интерфейс `DuckInterface` имеет смысл разделить на два интерфейса `FlyableInterface` и `SwimableInterface`, и реализовывать уже их.
**DIP** — принцип инверсии зависимостей. Суть его в том, чтобы вынести все внешние зависимости за пределы модуля и завязаться на абстракции, а не подробности (то бишь на интерфейсы и абстрактные классы, а не конкретные классы). Одним из признаков нарушения этого принципа является наличие ключевого слова `new` в классе.
```
class DIPViolation
{
public function badMethod()
{
someService = new SomeService(445, 'second params');
// operations with someService
}
}
```
Когда мы инстанцируем какой-либо сервис непосредственно внутри нашего класса, то в будущем будем иметь большие проблемы с покрытием этого кода модульными тестами. Также мы увеличиваем связанность между классами. Пример выше следует отрефакторить следующим образом:
```
class DIP
{
private $service;
public function DIP(SomeServiceInterface $someService)
{
$this->someService = $someService;
}
public function goodMethod()
{
// operations with someService
}
}
```
Итак, в данной статье, я постарался собрать воедино правила, которыми руководствуюсь, чтобы писать более удобочитаемый и «ремонтопригодный» код. Надеюсь, вам понравилось это маленькое приключение в принципы хорошего кода. И когда в следующий раз вы услышите, что код, который вы написали, просто «божественен», вы будете знать, что именно это значит :) | https://habr.com/ru/post/414201/ | null | ru | null |
# Асинхронное программирование — тестирование событий
Иногда приходится писать тесты для событий, и делать это неудобно – очень быстро начинают плодиться дополнительные методы и поля. О том, как тестировать события в C# я и хочу рассказать.
Для начала пример. У меня есть API, который асинхронно скачивает веб-страницу. Чтобы получить страницу, я подписываюсь на событие[[1](#Reference1 "В данном случае я тестирую класс MicrosoftSubscription.Sync.WebDataProvider – это часть Syndicated Client Experiences SDK, фреймворка который использует всем известное приложение photoSuru.")] и тем самым создаю еще один метод, в котором собственно живут мои ассерты. Естественно, сам тестовый метод при этом приходится блокировать, т.к. иначе test runner просто выйдет из него, не дождавшись моего callback’а.
> `[TestFixture]
>
>
> public class MyTests
>
>
> {
>
>
> private ManualResetEvent waitHandle;
>
>
> [Test]
>
>
> public void TestAsyncPageDownloading()
>
>
> {
>
>
> waitHandle = new ManualResetEvent(false);
>
>
> ⋮
>
>
> wdp.GetWebDataCompleted += wdp\_GetWebDataCompleted;
>
>
> wdp.GetWebDataAsync(new Uri("http://nesteruk.org/blog"), new object());
>
>
> **waitHandle.WaitOne();** // ждём пока выполнятся assert'ы
>
> }
>
>
> void wdp\_GetWebDataCompleted(object sender, GetWebDataCompletedEventArgs e)
>
>
> {
>
>
> StreamReader sr = new StreamReader(e.Stream);
>
>
> string s = sr.ReadToEnd();
>
>
> // тест ниже будет вызван test runner'ом
>
> Assert.Contains(s, "Dmitri", "My webpage should have my name.");
>
>
> **waitHandle.Set();** // разблокировка теста
>
> }
>
>
> }`
К сожалению, такой подход не учитывает ситуацию в которой тест «зависает» и тем самым тормозит процесс тестирования. Для этого можно добавить тайм-аут для вызова `WaitOne()` но тогда мы должны также протестировать вероятность того, что callback вообще не будет вызван. Для этого нам придется добавить еще одну переменную типа `bool`. Вот что получится:
> `private bool callbackInvoked;
>
>
> ⋮
>
>
> [Test]
>
>
> public void TestAsyncPageDownloading()
>
>
> {
>
>
> waitHandle = new ManualResetEvent(false);
>
>
> wdp.GetWebDataCompleted += wdp\_GetWebDataCompleted;
>
>
> wdp.GetWebDataAsync(new Uri("http://nesteruk.org/blog"), new object());
>
>
> waitHandle.WaitOne(**5000**); // ждём максимум 5 секунд пока выполнятся assert'ы
>
> **Assert.IsTrue(callbackInvoked, "Callback method was never called");**
>
>
> }
>
>
> void wdp\_GetWebDataCompleted(object sender, GetWebDataCompletedEventArgs e)
>
>
> {
>
>
> **callbackInvoked = true;** // информируем всех что метод был вызван
>
> StreamReader sr = new StreamReader(e.Stream);
>
>
> string s = sr.ReadToEnd();
>
>
> // тест ниже будет вызван test runner'ом
>
> Assert.Contains(s, "Dmitri", "My webpage should have my name.");
>
>
> waitHandle.Set(); // разблокировка теста
>
> }`
Дабы избежать преумножения количества методов и переменных в нашей test fixture, было бы полезно вынести сам «асинхронный тестировщик» в отдельный класс, который можно было бы использовать в качестве менеджера.[[2](#Reference2 "Этот подход был предложен неким vansickle в комментариях на странице моего блога.")]
> `public class EventTester : IDisposable
>
>
> {
>
>
> private readonly ManualResetEvent waitHandle;
>
>
> private readonly Action postHocTests;
>
>
> private bool called;
>
>
> private IAsyncResult waitToken;
>
>
> public EventTester(Action postHocTests)
>
>
> {
>
>
> waitHandle = new ManualResetEvent(false);
>
>
> this.postHocTests = postHocTests;
>
>
> }
>
>
> public void Handler(SenderType sender, ArgumentType args)
>
>
> {
>
>
> waitHandle.Set();
>
>
> waitToken = postHocTests.BeginInvoke(sender, args, null, null);
>
>
> }
>
>
> public void Wait(int mullisecondsTimeout)
>
>
> {
>
>
> called = waitHandle.WaitOne(mullisecondsTimeout);
>
>
> }
>
>
> public void Dispose()
>
>
> {
>
>
> Assert.IsTrue(called, "The event was never handled");
>
>
> postHocTests.EndInvoke(waitToken);
>
>
> }
>
>
> }`
Что делает этот тестировщик? Во-первых он кэширует колбэк-метод, который нужно вызвать для post hoc-тестов. Далее, он предоставляет метод `Wait()`, который делегируется нашему `ManualResetEvent` и тем самым позволяет нам подождать сколько-то времени пока будет вызван обработчик события. Как только оно вызвано – мы тут же запускаем финальные тесты. А дальше – небольшой трюк – мы реализуем `IDisposable()` и в методе `Dispose()` проверяем, вызывался ли обработчик. Поскольку assert прерывает исполнение, последующий `EndInvoke()` будет вызван только в том случае, когда он уместен.
Что касается самого теста, то теперь он выглядит вот так:
> `[Test]
>
>
> public void BetterAsyncTest()
>
>
> {
>
>
> using (var eventTester = new EventTester<object, GetWebDataCompletedEventArgs>(
>
>
> (o, args) =>
>
>
> {
>
>
> StreamReader sr = new StreamReader(args.Stream);
>
>
> string s = sr.ReadToEnd();
>
>
> Assert.Contains(s, "Dmitri", "My webpage should have my name.");
>
>
> }))
>
>
> {
>
>
> wdp.GetWebDataCompleted += eventTester.Handler;
>
>
> wdp.GetWebDataAsync(new Uri("http://nesteruk.org/blog"), new object());
>
>
> eventTester.Wait(5000);
>
>
> }
>
>
> }`
Это конечно не самый читабельный тест в мире, но по крайней мере он не плодит дополнительные поля и методы в теле класса. Тестирование событий, ровно как и тестирование пар `BeginXxx()/EndXxx()` – задача простая, так как в ней всегда предсказуемо фигурируют два элемента – вызов и обработчик, начало и конец. ■
Заметки
1. [↑](#BackReference1 "Back to text") В данном случае я тестирую класс `MicrosoftSubscription.Sync.WebDataProvider` – это часть [Syndicated Client Experiences SDK](http://windowsclient.net/wpf/starter-kits/sce.aspx), фреймворка который использует всем известное приложение photoSuru.
2. [↑](#BackReference2 "Back to text") Этот подход был предложен неким vansickle в комментариях на [странице моего блога](http://nesteruk.org/blog/post/How-to-unit-test-asynchronous-operations.aspx). | https://habr.com/ru/post/71410/ | null | ru | null |
# Срезаем пики с RRD графиков на примере Munin
Любой linux администратор наверняка наблюдал аномальные пики на RRD графиках. Пики появляются вследствие нарушения процесса сбора отслеживаемой величины и портят картину на графике. Это нормальное явление для RRD.
На графике трафика пики могут появится после перезапуска сетевого интерфейса или после перезагрузки сервера, что по сути одно и тоже. В обоих случаях процесс подсчета будет прерван из-за остановки устройства.
При появлении пиков необходимо удалить аномальные значения из базы RRD, чтобы график снова стал информативен. Это можно сделать с помощью утилиты rrdtool:
а) в ручную
rrdtool dump -> xml (находим и удаляем пики) -> rrdtool restore
б) или запустив скрипт removespikes.pl, в нем происходит тоже самое, но без вашего участия.
Я использую removespikes.pl. Процесс срезания пиков занимает не более 1 минуты.
На моих серверах установлен мониторинг Munin, поэтому примеры приведены с использованием этого мониторинга. Метод будет работать с любым мониторингов на основе RRD.
Срезаем пики с графиков eth0 трафика
`## переключаем пользователя (подробнее см. «Подводные камни»)
su – munin
## утасновка скрипта removespikes.pl на сервере
wget oss.oetiker.ch/rrdtool/pub/contrib/removespikes-20080226-mkn.tar.gz
tar xvzf removespikes-20080226-mkn.tar.gz
rm removespikes-20080226-mkn.tar.gz
## Корректировка rrd файлов
## Указываем маску только тех файлов в которых необходимо срезать пики и не трогаем бекапы *.rrd.old при повторных запусках.
for f in `find ~/localdomain/ -name "localhost.localdomain-if_eth0*.rrd"`
do
## я использую removespikes.pl-orig.
## в removespikes.pl добавлен новый функционал и изменен метод среза пиков так, что можно запороть всю RRD базу. (подробнее см. «Подводные камни»)
~/removespikes/removespikes.pl-orig $f;
done;`
После запуска скрипта вы должны увидеть что-то вроде
`Chopping peak at
Chopping peak at`
Графики Munin eth0 traffic после removespikes.pl
#### Подводные камни
**Камень №1**
Внимание: запускайте скрипт removespikes.pl под пользователем вашего мониторинга или проверяйте права на rdd файлы созданные скриптом, иначе сбор данных станет не возможен!
На графике выше отмечен разрыв, который произошел, вследствие того что я запускал removespikes.pl из под root. Исправленные rrd файлы были созданы с владельцем root и munin не мог записывать в них данные.
**Камень №2**
В архиве removespikes-20080226-mkn.tar.gz две модификации скрипта: оригинальная (removespikes.pl-orig) и с доп. функциями (removespikes.pl).
Корректность работы removespikes.pl-orig неоднократно мною проверена на разных серверах.
А вот запустив removespikes.pl я получил неожиданный результат. График как утюгом разгладило :(.
В скрипте есть параметр removespikes.pl
# Threshhold for cutting. Exponents above it will be chopped – срезаются все точки выше этого значения.
my $THRESH=10000;, что соответствует примерно 140Мбит/с.
Мой трафик был больше 140 и попал под это ограничение.
Если у вас обычные 100Мбит/с то это ограничение не окажет влияния на конечный результат.
##### Заключение
Скрипт автоматически создает бекап файлы с именами \*.rrd.old, так что всегда можно вернутся к исходному состоянию. Главное правильно создать шаблон поиска файлов для прохода removespikes.pl в цикле for… in.
**UPD**
Проблема с пиками никогда не возникнет, если вместе с munin установить ethtool. С помощью этой утилиты munin определит максимальную скорость сетевого интерфейса и автоматически установит лимит.
Если на сервере нет ethtool то внизу станицы трафика (if\_eth0.html) вы увидите сообщение
*Traffic of the eth0 interface. Maximum speed is undeterminable (please install ethtool).*
После установки *apt-get install ethtool* сообщение изменится
*Traffic of the eth0 interface. Maximum speed is 1000000000 bits per second.*
##### Источники
[howto-remove-spikes-from-rrd-graphs](http://www.void.gr/kargig/blog/2006/01/15/howto-remove-spikes-from-rrd-graphs/)
[rrdtool doc](http://oss.oetiker.ch/rrdtool/doc/index.en.html/) | https://habr.com/ru/post/92406/ | null | ru | null |
# Никогда не «не делай» того, о чем пожалеешь или умный дом с CCU.IO
На хабре последнее время появляется много статей об автоматизации дома. Какие-то статьи с пространными размышлениями на тему умного дома, не несущие полезной нагрузки. Какие-то с конкретной реализацией на конкретном проприетарном железе, но им не хватает чего то для того, что бы быть установленными или запущенными в другом доме.
Хочу представить программную платформу автоматизации для дома на базе Node.js, которую можно скачать со всеми исходниками и установить прямо сейчас практически одним кликом (Windows) или одной командой (Linux/Debian).
У некоторых возникнет, вполне уместный вопрос: зачем мне (нам) рассказывать о своей системе?
Я вижу с какими «половинчатыми» решениями живут энтузиасты автоматизации домов и хочу предложить законченное решение для комплексного программного обеспечения автоматизации дома. От драйверов — до скриптов и визуализации. Все компоненты системы имеют лицензию либо MIT либо CC NC BY. Что значит, для не коммерческого использования абсолютно бесплатно, хотя система включает в себя 3 человека-«хобби»-лет разработки. Я сам инвестировал в систему 1 год разработки по 2 часа в день (каждый день, включая выходные).
Для понимания контекста можно прочитать первые три абзаца предыдущей [статьи](http://habrahabr.ru/post/149716/). Данная статья является продолжением.
##### Вступление
Представленная система — это уже третья итерация системы автоматизации в моем жилище.
Первая была: X10 + HTTP Requests,
вторая: HomeMatic + PHP/MySQL (про них можно почитать в предыдущем моём посте)
и вот третья: HomeMatic + NodeJS / JavaScript.
Разработка этой системы началась в январе 2013, хотя активный рост начался в мае 2013 и сейчас над системой регулярно (каждый день) работают 3 разработчика и рук на всё уже не хватает.
##### Лирическое отступление
**Можно не читать**Когда я созрел для следующего шага в написании веб интерфейса для умного дома, я уже знал, что будущая система должна уметь в любом случае:
— она должна быть легко изменяемой и дополняемой;
— желательно было не привлекать для проектирования дополнительный софт, а все проделать в браузере.
После написания виджетов для основных датчиков и исполнительных устройств нужно было оживить их реальными данными. Поискав в форумах и гугле подходящие платформы, наткнулся на 3 стоящие системы заточенные под мою актуальную систему автоматизации:
**1. Jarvis**
[www.nextex-medienagentur.de/jarvis-v2](http://www.nextex-medienagentur.de/jarvis-v2/) — (может упасть из-за нагрузки).
**2. HCS — Home Control Suite** (http://hcs.xenorate.com/)
**3. Dash UI**
**Jarvis** выглядит очень презентабельно. Человек, написавший этот интерфейс профессионально работает веб дизайнером. Но при более детальном изучении выяснилось, что это PHP+Apache+SQL, а главное, что положение+конфигурация всех объектов задана статически в HTML файле. А это мы уже проходили: при добавлении нового датчика нужно править HTML файл и потом муторно подгонять позиции и свойства объекта, через CSS или свойство style, т.к. визуальных средств проектирования для этой системы нет.
**Home Control Suite** написал тот же человек, что и основы моего прошлого интерфейса (<http://habrahabr.ru/post/149716/>). Он, видимо, тоже пришел к таким же заключениям, как и я, и уже год как работал над новой системой. Протестировав систему я понял, что это то что нужно, хотя настройки виджетов вызывали нарекания. Ничего, решил я: JS + PHP + SQL мы уже проходили и можно будет переписать или улучшить интерфейс до необходимого мне уровня.
**Dash UI** я протестировал тоже, но она была непрезентабельной и была на неизвестной мне платформе Node.js. На тот момент она разрабатывалась только 2 месяца, что тоже не внушало уверенности.
Попутно я выяснил, что разработчик HCS живет в моем городе. Какая удача, решил я: вот тут то мы сработаемся, тем более можно без труда встретиться и обсудить все offline. Хотя разработчик DashUI жил в соседнем городе, всё равно это было расстояние в 80 км и после работы уже просто так не встретишься.
Написав человеку с HCS о желании встретиться и о том, что не мог бы он выложить исходники куда нибудь на SVN, я получил ответ, что звонить не стОит, т.к. можно все обсудить по почте, а уж встречаться тем более смысла нет. Также он дал мне знать, что исходники я могу выложить сам, но он не обещает, что будет этим пользоваться. Хм…
Я написал человеку с DashUI и тут же получил письмо с ответом, что лучше всё обговорить по телефону, т.к. тема эта не простая. Мы прообсуждали час, потом у меня сел аккумулятор.
Плюсом также было то, что все исходники изначально лежали на гите и можно было следить с какой регулярностью происходят изменения.
Хорошо, решил я, думая про HCS: не хочешь, не надо.
И взялся за Dash UI.
###### Прошёл год.
CCU.IO + Dash UI активно разрабатывает команда из 3х человек с уже 200-300 пользователями. HCS разрабатывает по прежнему один и имеет от силы 10 пользователей (Должен признаться я сам потом переманил 3-х на Dash UI).
При поездке на конференцию по автоматизации, разработчик Dash UI вызвался подбросить меня и разработчика HCS до места проведения конференции. Благо мы все на неё собирались. По дороге туда и на конференции (мы, кстати, делали там доклад) и по дороге обратно человек, отказавший мне в кооперации, был вынужден слушать наши обсуждения, планы, проблемы, задачки пользователей — постоянно. После того как мы приехали с конференции обратно, он сказал: *«Ах как бы я хотел участвовать в проекте, как ваш. Жалко, что я тогда не позвонил...»*
Описание системы
----------------
Цитата из документации:
> CCU.IO это программа, написанная на Node.js и служащая для автоматизации различного домашнего (и не очень) оборудования.
>
> При помощи встроенного веб-сервера CCU.IO выступает платформой для визуализации и позволяет отображать события с использованием Socket.IO библиотеки. Нет постоянных запросов к серверу (no-polling), а сервер сам говорит, когда нужно обновить графический элемент. Ресурсоёмкий процесс постоянных запросов отпадает и таким образом уменьшается время реакции на события. Дополнительно CCU.IO выступает, как прокси между визуализацией и приборами. Не важно, сколько запущено копий визуализации, нагрузка на приборы всегда одинаково низкая.
>
>
>
> Можно подключать новое оборудование через, так называемые, драйверы. На данный момент существуют драйвера для Philips Hue, Sonos, IRTrans, подключение к базе данных MySQL, а также различных веб-сервисов (Погода, валюта, почта, pushover). Некоторые новые драйвера находятся в разработке или запланированы на ближайшее будущее.
>
>
>
> Интегрированный в CCU.IO механизм скриптов позволяет автоматизировать системы при помощи языка JavaScript. Все возможности среды Node.JS можно использовать и в скриптах (например доступ к дисковой системе, сетевые функции и т.д.) Также можно использовать огромное количество готовых библиотек через npm.
>
>
>
> CCU.IO это открытое программное обеспечение.
Взаимодействие компонентов можно представить таким образом:
Компоненты системы:
##### CCU.IO
1.CCU.IO — это ядро системы. Название CCU (Central Control Unit) пришло из HomeMatic, где CCU это центральный контроллер и gateway для связи по ethernet.
В данный момент ядро переписывается, что бы уйти от архитектуры HomeMatic и т. к. уже в сегодняшнем виде система поддерживает и другие системы автоматизации, то новая будет называться ioBroker.
Ядро написано на NodeJS/JavaScript и может быть запущено на почти любой платформе, для которой есть NodeJS бинарники. В настоящий момент высокая степень интеграции создана для Raspberry PI. Известно точно, что пользователи запустили систему на Windows, OSX, QNAP (ARM/Intell) Synology, Cubietrack, BananaPI, Odroid, Ubuntu (x86) und Debian.
CCU.IO является только связующим звеном между компонентами. Из него же происходит запуск драйверов (adapters) с указанными параметрами.
GitHub: <https://github.com/hobbyquaker/ccu.io/blob/master/doc/README-ru.md>
##### Драйвера
2. Драйвер или адаптер — это JavaScript файл, запускающийся в отдельном NodeJS процессе и обслуживающий одно устройство или службу. На данный момент созданы следующие драйвера:
| | |
| --- | --- |
| email | для отправки сообщений по электронной почте |
| pushover | для отправки сообщений на мобильные клиенты (http://pushover.net) |
| mysql | запись событий в базу данных |
| graphite | пересылка событий в graphite (http://graphite.wikidot.com/screen-shots). Группировка данных в мыслимых и немыслимых формах и их отображение в виде графиков. |
| ical | Google и Apple iCloud календари |
| geofency | поддержка Apple системы геолокации geofency |
| growl | сообщения на Apple Growl App |
| currency | курсы валют с европейского центрального банка. (Есть EUR-RUB и USD-RUB) |
| | |
| telnet | управление приборами по telnet протоколу |
| ping | пингует IP устройства в сети |
| | |
| lirc | для управления приборами и принятия команд по инфракрасному порту (требуется дополнительное железо) |
| irtrans | поддержка IRTrans инфракрасной системы (http://www.irtrans.de/en/) |
| | |
| hue | управление PhilipsHUE лампами |
| lgtv | управление LG телевизорами по сети |
| denon | управление DENON ресиверами |
| onkyo | управление ONKYO ресиверами |
| yamaha | управление YAMAHA ресиверами |
| sonos | управление SONOS системой звука |
| dream | управление DreamBOX спутниковыми ресиверами (http://ru.wikipedia.org/wiki/Dreambox) |
| owfs | One Wire File System (http://owfs.org/) — сбор данных с датчиков Dallas/Maxim по 1-Wire |
| B-control Energy Manager | мониториг расхода электроэнергии [www.b-control.com/energiemanagement.html](http://www.b-control.com/energiemanagement.html) (нет описания на английском) |
| all3418v2 — ALLNET ALL3418v2 / IP Thermometer LAN / WLAN | беспроводной термометр — [www.allnet.de/en/allnet-brand/pr](http://www.allnet.de/en/allnet-brand/pr)… r-lanwlan/ |
| homepilot | управление системой автоматизации Rademacher. |
| homematic | управление системой автоматизации HomeMatic (встроено в CCU.IO). |
| rego | мониторинг котлов Junkers TM75, IVT Rego 634 |
| megaD | поддержка [MegaD-328](http://www.ab-log.ru/smart-house/ethernet/megad-328). |
| | |
| rpi | мониторинг основных параметров (CPU, Mem, Temperature) RaspberryPI. Поддержка 1-Wire интерфейса и PiFace. |
| cubie | мониторинг основных параметров (CPU, Mem, Temperature, Battery) Cubietruck. |
| | |
| sayit | голосовые сообщения (text2speech или wav) на системе(Linux, Windows, OsX) или android планшете (через Home24 Mediaplayer — [play.google.com/store/apps/deta](https://play.google.com/store/apps/deta)… ayer&hl=ru). |
| textCommands | интерфейс для команд, заданных обычным текстом (Пример: Какая температура дома?) |
| | |
| owm | OpenWeatherMap (http://openweathermap.org/) — погода по всему миру |
| yr | погода с норвежского сервера [www.yr.no](http://www.yr.no/) |
| dwd | официальные предупреждения о штормах в Германии |
| | |
| fritzBox | отображение списка звонивших для fritzBox |
| speedport | отображение списка звонивших для speedport |
| | |
| sun\_and\_time | время захода и восхода солнца, а также праздничные дни для Германии |
| muell\_stuttgart | время вывоза мусора в Штутгарте |
Создать собственный драйвер со знаниями системы, для которой создается адаптер, не составляет труда. Конечно, знания JavaScript на много облегчат задачу.
Есть [демо драйвер](https://github.com/hobbyquaker/ccu.io/blob/master/adapter/gismeteo/gismeteo.js) с большим количеством объяснений из которого можно понять: как писать собственный драйвер.
##### Script Engine
3. Сценарии реакций на события (Собственно — автоматизация)
Script Engine тоже запускается в своем процессе, как драйвер и служит для выполнения пользовательских скриптов на JavaScript. Все скрипты лежащие в папке ccu.io/scripts будут запущены. Управление происходит следующим образом:
```
// Простые события
var swicthID = 79111; // Адрес кнопки
var actorID = 80187; // Адрес силового реле
// подписываемся на нажатие кнопки
on(swicthID, function (obj) {
// передаем состояние на реле
setState(actorID, obj.newState.value);
});
// Можно так. Значение из адреса 79111 при изменении запишется в устройство или переменную по адресу 80187
on(79111, 80187);
```
Вот пример посложнее:
```
var postboxTimer = null;
var postboxSensorID = 61555; // ID датчика на почтовом ящике
subscribe(postboxSensorID, function (obj) {
// Если таймер ещё не запущен
if (!postboxTimer) {
// Стартуем таймер на 30 секунд, что бы отбросить быстрые открытия/закрытия
postboxTimer = setTimeout(function () {
postboxTimer = null;
}, 30000);
// Увеличиваем счетчик
setState(postboxStateID, 1 + getState(postboxStateID ));
}
});
// При старте создаем собственную переменную в CCU.IO
setObject(postboxStateID , {
Name: "Postbox.State",
TypeName: "VARDP"
}, function () {
setState(postboxStateID , 0);
});
```
Описание функций можно взять на [git](https://github.com/hobbyquaker/ccu.io/blob/master/doc/README-ru.md#scriptengine).
Для SctiprEngine написана визуальная система создания скриптов ScriptGUI, где всё программирование происходит визуально.
[www.youtube.com/watch?v=xeBXTDaidbU&list=PLsNM5ZcvEidhmzZt\_mp8cDlAVPXPychU7](https://www.youtube.com/watch?v=xeBXTDaidbU&list=PLsNM5ZcvEidhmzZt_mp8cDlAVPXPychU7) — Внимание, видео на немецком.
В данный момент перевод идет полным ходом. Это снимок с незавершенным переводом, но кое что уже переведено.
##### Dash UI
4. Дополнение Dash UI (Читается Дэш-ЮАЙ) это система визуализации для умного дома.
Вот примеры интерфейсов созданных с помощью DashUI:
По адресу [DashUI.ccu.io](http://DashUI.ccu.io) их можно потыкать и посмотреть на скорость. Хочу заметить, что отображение графиков и таблиц не работает в оффлайн режиме, так что не удивляйтесь, если некоторые страницы окажутся пустыми.
Есть даже такие реализации(в стиле Star Trek):
Есть видео создания простенького интерфейса с чистого листа:
Вот ещё несколько видео:
[www.youtube.com/watch?v=viE5y8YmZo0&list=PLsNM5ZcvEidgGDCFnm23bub3Mj-ZU4Cp4](https://www.youtube.com/watch?v=viE5y8YmZo0&list=PLsNM5ZcvEidgGDCFnm23bub3Mj-ZU4Cp4) — Примеры
[www.youtube.com/watch?v=gS-O5OKjQhk](https://www.youtube.com/watch?v=gS-O5OKjQhk) — Голосовые сообщения на немецком
Открыть дверь по NFC тэгу:
Недостатки дополнения в том, что интерфейс не масштабируется автоматически под экран. Но с другой стороны можно нарисовать 2 интерфейса: для таблета / десктопа и для телефона. Как многие и делают.
GitHub: [github.com/hobbyquaker/DashUI](https://github.com/hobbyquaker/DashUI)
##### MobileUI
5. Дополнение MobileUI в данный момент называется Yet another home user interface — yahui. Но мне название режет ухо и мы скоро переименуем его в MobileUI.
Этот интерфейс выглядит в виде списка устройств. Можно назначить каждому устройству или комнате собственные картинки или переименовать. На этом конфигурация системы закончена.
Это дополнение (Add-on) использует jQuery Mobile и автоматически изменяется, в зависимости от устройства, где вызвана страница.
##### SlimUI
6. Интерфейс SlimUI — система веб визуализации на «Vanilla» Javasript для очень старых браузеров и слабых устройств. Никакие библиотеки (jQuery или подобные) не используются. Данные опрашиваются по таймеру (polling), а команды отдаются через RestAPI (SimpleAPI).
GitHub: [github.com/hobbyquaker/SlimUI](https://github.com/hobbyquaker/SlimUI)
##### SimpleAPI
7. SimpleAPI — Интерфейс основанный на HTTP-GET запросах вида:
```
http://ccu-io-host:ccu.io-port/api/get/950
```
где 950 — это индекс переменной из CCU.IO.
Ответ отдается в JSON формате или просто значение, как текст.
Управление выглядит вот так:
```
http://ccu-io-host:ccu.io-port/api/set/950/?value=1
http://ccu-io-host:ccu.io-port/api/set/Свет-кухня/LEVEL/?value=0.7
```
Используется для коммуникации CCU.IO с внешними программами, такими как Trigger или Tasker. Я, например, использую интерфейс для открытия замка двери по NFC тэгу, через Trigger.
Описание интерфейса можно взять на [git](https://github.com/hobbyquaker/ccu.io/blob/master/doc/README-ru.md#simpleapi).
##### CCU.IO-Highcharts
8. Дополнение CCU.IO-Highcharts.
Рисование графиков используя исторические данные, сохраненные CCU.IO.
GitHub: [github.com/hobbyquaker/CCU-IO-Highcharts](https://github.com/hobbyquaker/CCU-IO-Highcharts)
##### Дополнение CCU.IO-Eventlist
9. Дополнение CCU.IO-Eventlist.
Используется для отображения событий записанных CCU.IO
##### Graphite
10. Адаптер Graphite.
Мощный инструмент визуализации данных, созданный другой командой. Может складывать графики и производить манипуляции с данными. Например, посчитать: сколько времени за последний месяц горели лампы в зале.
Но я сам его не использую, т.к. для нормальной работы требуется что-то по-мощнее RaspberryPi, а еще из-за жуткой нехватки времени.
Эта система довольно объёмна и на мой взгляд требует отдельной статьи на хабре. Странно, что Graphite ещё ни кто не описал здесь.
[graphite.wikidot.com/screen-shots](http://graphite.wikidot.com/screen-shots)
[github.com/graphite-project/graphite-web](https://github.com/graphite-project/graphite-web)
#### Реальное применение
Конечно, CCU.IO установлена у меня дома.
Даже дважды: рабочая система на Odroid/Linux (она редко изменяется и обновляется) и тестовая система на RaspberryPi (перезагружается и изменяется по несколько раз за вечер)
Системы работают параллельно не мешая друг другу и обеспечивают высокую доступность (redundancy) сервиса.
Лично мной используются следующие дополнения и драйвера:
— **Dash UI** для визуализации на планшете и удаленного управления с телефона;
— **Highchart** для представления графиков температур и влажности в визуализации;
— **Eventlist** для отображения истории событий по одному датчику, например открытие/закрытие входной двери;
— **Script-Engine** для генерирования текстовых сообщений для pushover, и вообще для связывания событий с действиями на эти события;
— **HomeListener App** для управления голосом с таблета или телефона
— **ping** для определения присутствия ~~жены~~ членов семьи дома. По IP адресу мобильного телефона можно определить — дома человек или нет;
— **pushover** для текстовых сообщений на телефон: «Звонок в дверь», «Стирка закончена» или «Входная дверь открыта уже 10 минут. Надо проверить.»;
— **ccu** для управления светом, рольставнями и отоплением. Информация о температуре и влажности, в каждой комнате и на улице, тоже поступает через этот драйвер;
— **ical** для отображения запланированных событий и дней рождений на экране планшета;
— **sonos** в основном, для индикации состояния проигрывателя, т.к. с родного приложения управлять удобнее;
— **fritzbox** для получения списка звонков на домашний номер;
— **yahooWeather** для информации о погоде;
— **lgtv** для выключения телевизора при уходе из квартиры;
— **sayit** для голосовых сообщений на планшете;
— **rpi** для контролирования свободного места на RaspberryPi.
— **textCommands** как точка подключения HomeListener App
Но это далеко не полный список сервисов, которые можно было-бы задействовать. Из-за огромного количества времени, уходящего на поддержку и разработку CCU.IO, нет возможности поиграться и реализовать систему на полную.
Как говориться: сапожник без сапог :)
Вообще я управляю системой редко. Она просто тихо мониторит все события и отдает по-тихому команды на исполнение: отопление, свет по датчику движения, информирует сообщениями о происходящем дома.
#### Итог
При помощи CCU.IO можно соединить воедино все компоненты умного дома и управлять ими. Можно создать различные визуальные графические интерфейсы или управлять системой через HTTP вызовы.
Есть даже интеграция голосового интерфейса, правда google тогда будет знать о чем говорят дома. (Ведётся проверка возможности использования оффлайн распознавания)
##### Ссылки
* ccu.io — [http://ccu.io/ru](http://ccu.io/ru/) (Ещё не до конца переверден)
* ccu.io форум — [http://forum.iobroker.com](http://forum.iobroker.com/viewforum.php?f=4)
**P.S.**
Всегда завидовал аллизарам и компании, строчащим по 2 поста в день.
Написание 80-ти процентов этой статьи заняло 3 дня. Плюс 3 недели на доработку, дополнение и перевод документации.
При написании статьи были обнаружены следующие похожие проекты (некоторые были известны и до этого):
— [Node-RED](http://nodered.org/) — установленный локально IFTT (if than than that) Node.js проект. Недостатки: нет визуализации, хотя очень продуманный проект от инженеров IBM.
— [SmartVISU](http://smartvisu.de/) — красивая визуализация. Недостатки: заточен только под KNX устройства и компоновка/конфигурация виджетов только через конфигурационный текстовый файл.
— [MajorDoMo](http://smartliving.ru/) — визуализация и автоматизация. PHP и polling событий.
— [OpenHAB](http://www.openhab.org/) — сервер автоматизации на Java. Недостатки: рудиментарная визуализация
— [OpenRemote](http://www.openremote.com/) — ещё один сервер автоматизации на Java.
— [Freedomotic](http://www.freedomotic.com/) — новое open source программное обеспечение для автоматизации дома, распространяемое под лицензией GPL2, написанное на Java (что позволяет запускать его на Linux, Mac или Windows). Основная задача ПО — предоставить энтузиастам возможность самостоятельно создать систему умного дома, объединив самодельное оборудование или используя для этого готовые решения популярных архитектур. Также Freedomotic позволяет интегрировать умный дом с социальными сетями, интернет-сервисами и сторонними приложениями посредством развитого API.
— [Agocontrol](http://www.agocontrol.com/) — GNU GPL автоматизация на питоне
— [Ninja Blocks](http://shop.ninjablocks.com/pages/open-source) — автоматизация в облаке
— [Domoticz](http://www.domoticz.com) — автоматизация на C#
— [The Thing System](http://thethingsystem.com) — Отлично подходит для автоматизации, но нет визуализации.
и десятки других проектов. | https://habr.com/ru/post/227435/ | null | ru | null |
# Корутины в C++20 — что это и как с ними работать
*Прим. Wunder Fund: В статье описаны базовые подходы к работе с корутинами в 20м стандарте С++, на паре практических примеров разобраны шаблоны классов для промисов и фьючеров. По нашему скромному мнению, можно было бы реализовать и поизящнее. Приходите к нам работать, если имеете сильные мнения о корутинах хе-хе.*
Возникает такое ощущение, что тема реализации корутин в C++20 окутана серьёзной неопределённостью. Полагаю, это так из-за того, что в проекте технической спецификации C++20 сказано, что работа над механизмами корутин всё ещё ведётся, в результате в данный момент нельзя ожидать полной поддержки этих механизмов компиляторами и стандартной библиотекой. Множество проблем, вероятно, возникает из-за отсутствия официальной документации по работе с корутинами. Нам дали синтаксическую поддержку корутин в C++ (`co_yield` и `co_return`), но не всё то, что я счёл бы признаками их полной библиотечной поддержки. В стандартной библиотеке имеются хуки и базовый функционал поддержки корутин, но нам приходится самостоятельно встраивать всё это в наши собственные классы. Я ожидаю, что полная поддержка корутин-генераторов появится в C++23.
Спецификация C++20, очевидно, направлена на поддержку параллельных (или асинхронных) корутин с использованием `co_await`, что усложняет реализацию более простых синхронных корутин-генераторов. Среди требований к реализации наших корутин имеются сведения об использовании `Future` и `Promise`, что похоже на то, как при реализации асинхронных потоков используется [std::async](https://en.cppreference.com/w/cpp/thread/async).
Если вы — Python- или C#-разработчик и ожидаете увидеть в C++ простую механику работы с корутинами, то вас ждёт разочарование, так как фреймворк общего назначения C++20 недоработан. Учитывая это, можно отметить, что в интернете имеется множество публикаций, в состав кода, обсуждаемого в которых, входит шаблонный класс, поддерживающий корутины-генераторы. В этом материале вы найдёте шаблон корутины, применимый на практике, а также примеры кода. Всё это предваряется общими сведениями о корутинах.
### Что такое корутины?
Я впервые столкнулся с корутинами, увидев инструкцию `yield` в [CLU](https://en.wikipedia.org/wiki/CLU_(programming_language)). Корутины, наподобие генераторов в Python (и конструкции `yield return` в C#), определяются с использованием функционального синтаксиса, а доступ к ним организуется с применением синтаксических конструкций цикла `for`. Корутины описывались как взаимодействующие программы (но не как конкурентные программы), выполняющиеся в одном потоке. Существуют и другие разновидности корутин. Для того чтобы разобраться в том, чем отличаются друг от друга функции, генераторы и потоки, можно начать с [этой](https://en.wikipedia.org/wiki/Coroutine) статьи из Википедии.
В этом материале я уделяю основное внимание корутинам, выполняемым в контексте вызывающей стороны, применение которых позволяет двум различным блокам кода периодически передавать друг другу управление ходом выполнения программы.
Новая инструкция `co_yield` в C++20 позволяет одной программе предоставить фрагмент данных, и в то же время вернуть управление ходом выполнения программы вызывающей программе для обработки этих данных. В общем-то, это — всего лишь витиеватый способ сказать о том, что корутины в C++20 дают нам однопоточную реализацию паттерна продюсер/консьюмер ([producer/consumer](https://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem)).
Мы можем показать классический пример взаимодействия продюсера и консьюмера, связанный с применением корутин, подготовив следующую [UML-диаграмму последовательности](https://en.wikipedia.org/wiki/Sequence_diagram).
Корутина-генераторБлоки, олицетворяющие время, когда управление ходом выполнения программы находятся у той или иной сущности, показывают передачу управления от одной программе другой.
Когда управление ходом выполнения программы передаётся от одной программе другой — текущее состояние программы должно быть сохранено, а затем, когда выполнение программы возобновляется, должно быть восстановлено. В случае с консьюмером это происходит в рамках обычного механизма вызова функции, когда текущий кадр стека сохраняет состояние программы. В случае с продюсером (это — корутина) нужна дополнительная поддержка со стороны компилятора и системы выполнения кода. А именно, при возвращении консьюмеру некоего значения нужно сохранять кадр стека продюсера.
В спецификации C++20 сказано, что состояние корутины сохраняется в куче, то есть — корутины не подходят для встраиваемых систем, которые не используют динамическую память. Но в спецификации абсолютно чётко заявлено, что в конкретной реализации языка использование кучи может быть убрано при соблюдении следующих условий:
* Если время жизни корутины строго ограничено временем жизни вызывающей стороны.
* Если размер состояния корутины может быть определён во время компиляции кода.
На практике, в случае с простыми корутинами-генераторами, которым посвящён этот материал, подобные корутины соответствуют этим критериям, состояние таких корутин может быть сохранено в кадре стека вызывающей стороны. Исследование использования кучи в двух примерах, рассмотренных в этой статье, показывает, что и GCC-11, и Clang-12 (последние версии компиляторов на момент написания материала) используют для сохранения состояния корутин кучу. Учитывая то, что поддержка корутин в компиляторах появилась сравнительно недавно, и то, что она сейчас находится в процессе развития, вполне возможно, что в более поздних их версиях соответствующий код будет оптимизирован, или, возможно, появится поддержка опций компиляторов для включения или отключения сохранения состояния корутин в динамической памяти.
Для организации поддержки сохранения и восстановления состояния корутин мы должны предоставить системе вспомогательный класс, который интегрируется с механизмами поддержки корутин в стандартной библиотеке, описанными в заголовочном файле, подключаемом к коду с помощью конструкции `#include` . Именно в этой сфере сейчас и находится всё то, что вызывает сложности в реализации корутин.
#### Поддержка корутин в C++20
Для того чтобы приступить к разговору о корутинах — мы можем создать одну из них, выдающую фразу «Hello world!» в виде трёх отдельных объектов. Её код показан ниже (тут нам нужно подключить заголовочный файл ).
```
#include
X coroutine()
{
co\_yield "Hello ";
co\_yield "world";
co\_return "!";
}
```
Первое, на что тут можно обратить внимание, заключается в том, что это — не определение функции! Мы только что использовали синтаксис функции для определения блока кода, которому могут быть переданы аргументы при создании его экземпляра. У функции имелась бы инструкция `return` (или как в случае с void-функциями, подразумевалось бы, что значение явным образом не возвращается). А тут код выдаёт три отдельных значения. Обратите внимание на то, что воспользоваться инструкцией `return` в корутине нельзя.
Второй интересный момент заключается в том, что мы возвращаем какой-то неизвестный (на данный момент) объект типа `X`. Это — объект, который реализует корутину. Компилятор реорганизует наш блок кода для реализации механизмов корутин, предусматривающих сохранение и восстановление состояния, но сейчас ему нужна небольшая помощь от нас, которая выражается в написании вспомогательного класса `X`.
В блоке кода, представляющего корутину, мы используем `co_yield` для выдачи значения и сохранения состояния корутины, а `co_return` — для выдачи значения и выхода из корутины без сохранения её состояния.
Это предельно простой пример использования корутины, где обратиться к ней нужно в точности три раза — как показано в следующем примере:
```
auto x = coroutine();
std::cout << x.next();
std::cout << x.next();
std::cout << x.next();
std::cout << std::endl;
```
После того как мы потребили все значения, выданные корутиной, её работа завершается, она освобождает всю память, использованную для хранения её состояния.
В нашем примере у объекта корутины есть метод `next`, вызов которого приводит к выполнению следующих действий:
1. Приостановка выполнения текущего кода консьюмера.
2. Восстановление состояния корутины (продюсера).
3. Возобновление выполнения кода корутины с предыдущей инструкции, выдающей значение (или с начала блока кода).
4. Сохранение значения, полученного из следующей инструкции, выдающей значение.
5. Сохранение состояния корутины.
6. Восстановление состояния консьюмера.
7. Возобновление выполнения кода консьюмера путём передачи ему значения, сохранённого после выполнения соответствующей инструкции, выдающей значение.
Сейчас в стандартной библиотеке нет шаблона для нашего класса `X`. В результате нам нужно разобраться с тем, что сейчас имеется в стандартной библиотеке в плане поддержки корутин. Пример шаблонного класса показан ниже, там, где мы будем говорить о практическом применении корутин, а пока мы взглянем на базовый пример, код которого написан исключительно в учебных целях.
Для того чтобы написать собственный вспомогательный класс `X` для корутин, нам нужно обеспечить поддержку операций жизненного цикла корутины, предоставив реализации особых методов. Стандарт C++20 определяет требования к этим методам, используя концепции, ознакомиться с которыми можно [здесь](https://blog.feabhas.com/2018/12/a-brief-introduction-to-concepts-part-1/) и [здесь](https://blog.feabhas.com/2018/12/a-brief-introduction-to-concepts-part-2/). Для того чтобы тут мы не отвлекались от темы корутин, мы применим традиционный для C++ поход к описанию методов, наличие которых ожидается системой, в виде частей нашего класса.
Для использования корутин в C++20 нам нужно подготовить два взаимосвязанных вспомогательных класса:
* Класс для сохранения состояния корутины и для сохранения выданных данных. Обычно его называют `promise`.
* Класс для управления объектом корутины (`promise`). Это класс `X`, который, по традиции, называют `future`.
В объекте типа `Promise` нужно реализовать несколько методов жизненного цикла корутины. Пока мы сосредоточимся на поддержке выражений, выдающих значения, и не будем обращать внимания на методы, необходимые для управления состоянием корутины.
Так как наша корутина использует инструкцию `co_yield` со значением `const char*`, нам нужен метод со следующей сигнатурой:
```
std::suspend_always yield_value(const char* value);
```
Аргумент — это выдаваемый корутиной объект, возвращаемый тип сообщает системе выполнения кода о том, нужно ли сохранять состояние потока, что, в случае с однопоточной корутиной, мы всегда планируем делать, возвращая объект `std::suspend_always`. В данной ситуации есть возможность возврата объекта `std::suspend_never`, что допустимо при работе с асинхронными корутинами, но это ведёт к множеству сложностей, связанных с управлением приостановленными потоками и с возобновлением их работы. Мы не собираемся с этим связываться, работая над нашей простой синхронной корутиной.
Метод `yield_value` обязан сохранить свой аргумент, в результате он может быть возвращён вызывающей программе (консьюмеру). Вот как выглядит типичная реализация этого метода:
```
std::suspend_always yield_value(const char* value) {
this->value = value;
return {};
}
```
Если вы ещё не сталкивались с современной синтаксической конструкцией C++ `return {}`, то знайте, что её смысл заключается всего лишь в том, чтобы создать объект возвращаемого типа этого метода, конструируемый по умолчанию. Ещё тут можно было использовать `return` `std::suspend_always{}`.
Для поддержки инструкции `co_return`, которая выдаёт значение, но не сохраняет состояние, нам нужен второй метод жизненного цикла корутины:
```
void return_value(const char* value) {
this->value = std::move(value);
}
```
Вызов `co_return` завершает выполнение корутины, соответствующая функция жизненного цикла корутины имеет возвращаемый тип `void`, так как состояние корутины будет уничтожено.
Если не вдаваться в детали реализации класса `X`, можно показать, как компилятор может расширить код сущности-консьюмера, превратив его в набор встроенных последовательных операций, а после этого взглянуть на методы жизненного цикла. В следующем примере метод `promise` даёт доступ к объекту `Promise`, который сохраняет состояние корутины и выдаваемое ей значение. Метод `next` может получить сохранённое значение из объекта `Promise`:
```
auto x = coroutine();
x.promise().yield_value("Hello "); // сохраняется значение и состояние
std::cout << x.next();
x.promise().yield_value("world"); // сохраняется значение и состояние
std::cout << x.next();
x.promise().return_value("!"); // сохраняется значение, но не состояние
std::cout << x.next();
std::cout << std::endl;
```
Можно видеть, что компилятор преобразовал наш код, превратив два блока кода в один, представленный последовательным набором вызовов чередующихся методов.
Перед тем как мы разберём полноценный пример, в котором имеется весь необходимый шаблонный код для классов `Promise` и `Future`, нам нужно взглянуть на альтернативный способ написания кода корутин-генераторов:
```
X coroutine()
{
co_yield "Hello ";
co_yield "world";
co_yield "!";
// подразумеваемый вызов co_return;
}
```
При применении такого подхода мы используем `co_yield` для всех значений, не выделяя особым образом (с помощью `co_return`) последнюю операцию выдачи значения; мы просто позволяем блоку кода завершить работу. Компилятор сам добавит в нужное место инструкцию `co_return` для завершения работы корутины.
Для обработки инструкции `co_return` (без значения) нам нужна реализация особого метода жизненного цикла корутины `void return_void`:
```
void return_void() {
this->value = nullptr;
}
```
Класс `Promise` не может предоставить и метод `return_value`, и метод `return_void`, которые считаются взаимоисключающими.
В этом простейшем примере код консьюмера не меняется, так как он выполняет чтение в точности трёх значений. В более реалистичном примере, где чтение значений из корутин выполняется в цикле, нам нужно каким-то образом отметить конец потока данных. Тут используются указатели, в результате для завершения цикла может быть использован `nullptr`; в противном случае наиболее общим подходом можно назвать объект `std::optional`.
Наш новый консьюмер с возможностью остановки работы выглядит так:
```
auto x = coroutine();
while (const char* item = x.next()) {
std::cout << item;
}
std::cout << std::endl;
```
Мы могли бы описать цикл так:
```
while (auto item = x.next()) {
```
Но тут мы решили сохранить явное объявление типа, в результате из этого кода ясно то, как именно используется генератор.
Полная версия этого кода находится в файле `char_demo.cpp` в GitHub-репозитории [coroutines-blog](https://github.com/feabhas/coroutines-blog).
### Работа с корутинами
Корутины — это удобный механизм для реализации множества алгоритмов в виде отдельных блоков кода, а не в такой форме, когда соответствующий код собирают в одном месте, где реализации разных алгоритмов оказываются смешанными друг с другом.
В качестве примера рассмотрим встроенное устройство, которое наблюдает за некими значениями, например, за показателями температуры, и выводит эти значения на последовательный порт ([RS232](https://en.wikipedia.org/wiki/RS-232)), снабжая их отметкой времени. Это может быть время с момента загрузки устройства, или точное время, синхронизированное по сети.
Отметка времени и значение сохраняются в виде числа с плавающей запятой (каждое занимает 4 байта) и в двоичном виде сохраняются в виде потока байтов. Сделано это ради снижения сложности кода и размера обрабатываемых данных. Поток данных выглядит примерно так, как показано ниже (тут используется обратный ([little endian](https://en.wikipedia.org/wiki/Endianness)) порядок байтов).
Двоичный формат, используемый для хранения отметки времени и элемента данных
В нашем приложении, которое занимается сбором данных, нужно считывать этот поток и помещать данные в структуру, содержащую два значения с плавающей запятой, после чего — выводить эти значения на соответствующем устройстве, вроде некоего дисплея. А если показатель температуры превышает заданное пороговое значение — сообщение нужно снабдить предупреждением.
Общий алгоритм работы системы будет выглядеть так:
1. Чтение 4 байтов, необходимых для создания отметки времени.
2. Чтение 4 байтов, необходимых для создания элемента данных.
3. Создание структуры данных, содержащих оба значения, представленных числами с плавающей запятой.
4. Вывод значений из структуры данных.
5. Вывод предупреждения в том случае, если показатель температуры превысит заданное пороговое значение.
Теперь подумаем о том, что произойдёт в том случае, если поток данных прервётся в ходе передачи значений, представленных числами с плавающей запятой. В нашем коде имеется средство для обработки ошибки, связанной с окончанием потока, применяемое для каждой отдельной операции чтения данных (речь идёт о восьми самостоятельных операциях по чтению одного байта). Даже при разумном использовании функций этот код будет представлять собой сложный набор условий и инструкций, направленных на реконструкцию данных. Такой код непросто, хотя и интересно, писать и поддерживать.
При использовании корутин подобный код можно разбить на два блока:
1. Парсинг данных.
2. Вывод данных и, возможно, предупреждающего сообщения.
Мы на практике пойдём ещё дальше и разобьём первый блок на две части:
1. Разбор необработанного потока байтов и преобразование их в числа с плавающей запятой.
2. Сохранение отметки времени и показателя температуры в структуре.
### Шаблон Future для корутины
Первым шагом нашей работы будет создание шаблона для классов, о которых мы уже говорили, представляющих класс `Future` корутины и класс `Promise` для данных.
#### Класс Promise, хранящий данные
Вот — класс `Promise`, представляющий собой структуру, вложенную в класс `Future`:
```
template
class Future
{
class Promise
{
public:
using value\_type = std::optional;
Promise() = default;
std::suspend\_always initial\_suspend() { return {}; }
std::suspend\_always final\_suspend() noexcept { return {}; }
void unhandled\_exception() {
std::rethrow\_exception(std::move(std::current\_exception()));
}
std::suspend\_always yield\_value(T value) {
this->value = std::move(value);
return {};
}
void return\_void() {
this->value = std::nullopt;
}
inline Future get\_return\_object()
value\_type get\_value() {
return value;
}
private:
value\_type value{};
};
…
};
```
Структура `Promise` (которую мы объявили приватной для включающего её в себя класса `Future`) сохраняет отдельное значение данных в приватном объекте `std::optional` с методом доступа `get_value`. Используя объект `std::optiona`l мы можем воспользоваться `std::nullop` для проверки на завершение работы корутины после вызова метода `return_void`. Мы придерживаемся стиля метапрограммирования шаблонов C++, определяя признак типа `value_type`, что позволяет нам опрашивать класс для определения типа данных, лежащего в его основе.
Мы создаём конструктор, используемый по умолчанию и два метода жизненного цикла, необходимых для Promise-объекта корутины (`initial_suspend` и `final_suspend`), которые всегда приостанавливают работу корутины, чтобы мы могли бы работать в однопоточном режиме. Эти методы жизненного цикла необходимы, но это — лишь их стандартные реализации, которые не нуждаются в дальнейшем рассмотрении.
Ещё нам надо указать то, как фреймворк должен обрабатывать неперехваченные исключения. Вместо того чтобы отвлекаться на их обработку и создавать механизмы восстановления работы после возникновения ошибки, мы просто передаём исключение вызывающей стороне, которая должна принять решение о том, что с ними делать дальше.
Методы `yield_value` и `return_void`, о которых мы уже говорили, определены для того, чтобы копировать или перемещать выданное корутиной значение в хранилище `std::optional`, или для того, чтобы использовать `std::nullopt` для указания на завершение работы корутины. Обратите внимание на использование `std::move`. Это сделано для того, чтобы обеспечить поддержку семантики перемещения данных для аргументов функции, передаваемых по значению: это необходимо, например, если надо выдать `std::unique_ptr`.
Ещё один метод, который нужно подготовить, это — `get_return_object`. Он должен возвращать объект `Future` для данного объекта `Promise`. Так как мы пока не завершили определение класса `Future`, нам нужно реализовать этот метод после того, как будут готовы классы `Future` и `Promise`.
#### Класс Future — менеджер контекста корутины
Сам класс `Future` предоставляет нам конструктор/деструктор для управления составным объектом `Promise`, а так же — механизм для получения значений, выданных корутиной (метод `next`, о котором мы уже говорили):
```
template
class Future
{
struct Promise { … };
public:
using value\_type = T;
using promise\_type = Promise;
explicit Future(std::coroutine\_handle handle)
: handle (handle)
{}
~Future() {
if (handle) { handle.destroy(); }
}
// Promise::value\_type next() { … }
private:
std::coroutine\_handle handle;
};
```
В стандартной библиотеке имеется поддержка управления объектами `Promise` через шаблонный класс `std::coroutine_handle`, передаваемый в виде аргумента конструктору класса `Future`. Нам нужно сохранить этот объект `coroutine_handle` и обеспечить вызов его метода `destroy` при уничтожении объекта `Future`.
Стандартная библиотека предъявляет ещё одно требование для класса `Future`, в соответствии с которым мы должны определить вложенный тип `promise_type`, что позволит шаблонам стандартной библиотеки выяснять тип данных, лежащий в основе класса.
```
using promise_type = Promise;
```
В нашей реализации метода `next` необходимо обеспечить проверку того, что объект `Promise` всё ещё актуален, или вернуть пустой объект `std::optional`:
```
Promise::value_type next() {
if (handle) {
handle.resume();
return handle.promise().get_value();
}
else {
return {};
}
}
```
Вот что мы делаем для возврата значения, выданного корутиной:
* Мы просто проверяем, существует ли всё ещё корутина (её объект `handle` не был уничтожен).
* Мы вызываем метод `resume` объекта `coroutine_handle` для выполнения кода до следующей инструкции `co_yield`.
* Мы возвращаем значение, сохранённое методом `yield_value` объекта `Promise`: благодаря поддержке стандартной библиотеки будут обработаны операции восстановления и сохранения состояния корутины.
* Если корутин была уничтожена — мы возвращаем пустое значение (`std::nullopt`).
Теперь, когда определён класс `Future`, мы можем дополнить объект `Promise` необходимым методом `get_return_object`:
```
template
inline Future Future::Promise::get\_return\_object()
{
return Future{ std::coroutine\_handle::from\_promise(\*this) };
}
```
Тут мы используем метод [std::from\_promise](https://en.cppreference.com/w/cpp/coroutine/coroutine_handle/from_promise) для создания объекта `coroutine_handle`, который передаётся конструктору `Future`.
Как видите, перед нами — всего лишь стандартный код, [заготовка](https://en.wikipedia.org/wiki/Boilerplate_text) для создания классов `Future` и `Promise`.
Теперь, когда завершены подготовительные операции, этот шаблон может быть использован в применении к большинству типов данных и классов. Я сказал бы, что он применим ко всем классам, но всегда найдутся особые случаи, в которых воспользоваться им не получится.
### Корутина, занимающаяся сбором данных
Теперь можно сосредоточиться на нашей реальной задаче, которая заключается в организации сбора данных. Первый шаг работы заключается в написании корутины, занимающейся чтением данных из объекта `istream` и выдачей значений, представляющих собой числа с плавающей запятой:
```
Future read\_stream(std::istream& in)
{
int count{};
uint8\_t byte;
while (in >> byte) {
data = data << 8 | byte;
if (++count == 4) {
co\_yield reinterpret\_cast(&data);
data = 0;
count = 0;
}
}
}
```
Тут мы просто читаем блоки данных размером 4 байта и помещаем их в 32-битные слова, после чего используем приведение типов, интерпретируя соответствующую область памяти в виде числа с плавающей запятой для инструкции `co_yield`. Если поток данных завершается в ходе чтения 4-байтового слова, мы игнорируем частично прочитанное значение и завершаем работу корутины.
Мы можем подтвердить работоспособность этой корутины, просто выводя каждое float-значение, которое прочитано из стандартного потока ввода:
```
auto raw_data = read_stream(std::cin);
while (auto next = raw_data.next()) {
std::cout << *next << std::endl;
}
```
А, так как надо сохранить пары значений в структуре данных, можно воспользоваться второй корутиной, которая инкапсулирует соответствующий алгоритм:
```
struct DataPoint
{
float timestamp;
float data;
};
Future read\_data(std::istream& in)
{
std::optional first{};
auto raw\_data = read\_stream(in);
while (auto next = raw\_data.next()) {
if (first) {
co\_yield DataPoint{\*first, \*next};
first = std::nullopt;
}
else {
first = next;
}
}
}
```
И, опять же, если входной поток неожиданно завершается при чтении данных, относящихся к отметке времени или к элементу данных — мы отбрасываем неполные данные.
Последний шаг этого примера заключается в обработке значений, представляющих отметку времени и данные:
```
static constexpr float threshold{25.0};
int main()
{
std::cout << std::fixed << std::setprecision(2);
std::cout << "Time (ms) Data" << std::endl;
auto values = read_data(std::cin);
while (auto n = values.next()) {
std::cout << std::setw(8) << n->timestamp
<< std::setw(8) << n->data
<< (n->data > threshold ? " Threshold exceeded" : "")
<< std::endl;
}
return 0;
}
```
Этот код выражает то, как мы решили обрабатывать данные, а все тонкости преобразования байтов в значения с плавающей запятой и их записи в структуру данных, скрыты в соответствующей корутине.
Хочется надеяться, что теперь вы способны прочувствовать плюсы использования корутин для разделения различных аспектов реализации сложных алгоритмов на более простые блоки кода. Сейчас, пользуясь C++20, нужно выполнять массу действий, которые кажутся сложными или ненужными для достижения нашей цели и заключаются в создании классов `Future` и `Promise`. Но я тем не менее надеюсь, что в C++23 уже будет встроено нечто подобное этому шаблону, что позволит программистам уделять внимание написанию собственного кода, не отвлекаясь на создание вспомогательных механизмов.
Протестировать этот код можно, воспользовавшись простым Python-скриптом, например, таким, который показан ниже. Он, в частности, выдаёт четыре жёстко заданных в коде элемента данных:
```
import struct
import sys
start = 0.0
for ms, value in enumerate([20.1, 20.9, 20.8, 21.1]):
sys.stdout.buffer.write(struct.pack('>ff', start + ms*0.1, value))
```
Если скомпилированный исполняемый файл называется `datapoint_demo`, то мы можем воспользоваться следующим конвейером в командной строке Linux и убедиться в работоспособности корутин:
```
# Linux
python3 test_temp.py | ./datapoint_demo
```
В результате будет выведено следующее:
```
Time (ms) Data
0.00 20.10
0.10 20.90
0.20 20.80
0.30 21.10 Threshold exceeded
```
Полный вариант кода этого примера, представленный файлами `future.h` и `datapoint_demo.cpp`, можно найти [здесь](https://github.com/feabhas/coroutines-blog). Для того чтобы скомпилировать эти примеры с использованием GCC (версии 10 или выше), нужно воспользоваться `-std=c++20` и `-fcoroutines` в командной строке `g++`.
В следующем материале я планирую добавить в шаблонный класс `Future` поддержку итераторов, что позволит использовать корутину в цикле `for` или в виде входного итератора для неких библиотечных механизмов.
### Итоги
Корутины — это мощная техника программирования, позволяющая разделять различные аспекты реализаций сложных алгоритмов, описывая их в виде самостоятельных и достаточно простых блоков кода.
C++20, как Python и C#, использует функциональный синтаксис для определения кода корутин. Многие программисты поначалу находят это странным, так как это — всего лишь синтаксическая конструкция для описания инструкций, входящих в состав корутины.
Как мы видели, то, что сейчас нет простого стандартного шаблона для создания корутин-генераторов, усложняет жизнь тем, кто только собирается попробовать корутины. Сейчас применение корутин несколько напоминает сборку пазла, картинки-загадки, в условиях, когда тот, кто пазл собирает, не видел картинки, которая у него должна получиться. Поначалу такая задача выглядит пугающе сложной, но решить её вполне реально. Надеюсь, что шаблон `Future`, который мы тут рассмотрели, это и есть та картинка, глядя на которую вы сможете собирать собственные пазлы.
О, а приходите к нам работать? 😏Мы в [**wunderfund.io**](http://wunderfund.io/) занимаемся [высокочастотной алготорговлей](https://en.wikipedia.org/wiki/High-frequency_trading) с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.
[Присоединяйтесь к нашей команде.](http://wunderfund.io/#join_us) | https://habr.com/ru/post/582000/ | null | ru | null |
# HTML 5. Работа с Web SQL базой данных
В HTML 5 есть много новых возможностей, которые позволяют web разработчикам создавать более мощные и насыщенные приложения. К этим возможностям относятся и новые способы хранения данных на клиенте, такие как web storage(поддерживается в IE8) и web SQL database.
При этом если web storage ориентирован на хранение пар ключ-значение, то в случае с web SQL database у нас есть полноценный sqlite(во всех текущих реализациях применяется именно этот движок баз данных, что является проблемой при стандартизации).
Далее я расскажу, как работать с web SQL database. При этом примеры естественно будут на JavaScript. Кроме того, стоит отметить, что с поддержкой браузерами всего этого хозяйства дела обстоят, не очень хорошо, но всё постепенно меняется к лучшему и, скажем, в Opera 10.50 поддержка будет, а браузерах на движке WebKit она уже есть. Более подробно про то, какой браузер, что поддерживает можно узнать, пройдя по [ссылке](http://en.wikipedia.org/wiki/Comparison_of_layout_engines_(HTML5)).
Соединение с базой данных.
--------------------------
Подсоединиться к базе данных очень просто:
`db = openDatabase("ToDo", "0.1", "A list of to do items.", 200000);`
Данный код создаёт объект, представляющий БД, а если базы данных с таким именем не существует, то создаётся и она. При этом в аргументах указывается имя базы данных, версия, отображаемое имя и приблизительный размер. Кроме того важно отметить, что приблизительный размер не является ограничением. Реальный размер базы данных может изменяться.
Успешность подключения к БД можно оценить, проверив объект db на null:
`if(!db){alert("Failed to connect to database.");}`
Всегда предпринимайте данную проверку, даже если соединение с БД для данного пользователя уже производилось в прошлом, и было успешно. Могут измениться настройки безопасности, закончиться дисковое пространство (скажем, если пользователь использует смартфон) или фаза луны окажется неподходящей.
Выполнение запросов.
--------------------
Для выполнения запросов к БД предварительно надо создать транзакцию, вызвав функцию database.transaction(). У неё один аргумент, а именно другая JavaScript функция, принимающая объект транзакции и предпринимающая запросы к базе данных.
Собственно сам SQL запрос можно выполнить, вызвав функцию executeSql объекта транзакции. Она принимает 4 аргумента:
* строка SQL запроса
* массив параметров запроса (параметры подставляются на место вопросительных знаков в SQL запросе)
* функция, вызываемая при успешном выполнении запроса
* функция, вызываемая в случае возникновения ошибки выполнения запроса
Пример работы функции executeSql ниже:
`db.transaction(function(tx) {
tx.executeSql("SELECT COUNT(*) FROM ToDo", [], function(result){}, function(tx, error){});
});`
Давайте теперь изменим код так, чтобы при невозможности выборки из таблицы «ToDo»(которой пока не существует), данная таблица создавалась.
`db.transaction(function(tx) {
tx.executeSql("SELECT COUNT(*) FROM ToDo", [], function (result) { alert('dsfsdf') }, function (tx, error) {
tx.executeSql("CREATE TABLE ToDo (id REAL UNIQUE, label TEXT, timestamp REAL)", [], null, null);
})});`
Вставка данных.
---------------
Давайте вставим новую строку в таблицу «ToDo». Для знакомых с синтаксисом SQL пример, приведённый ниже, покажется очень знакомым:
`db.transaction(function(tx) {
tx.executeSql("INSERT INTO ToDo (label, timestamp) values(?, ?)", ["Купить iPad или HP Slate", new Date().getTime()], null, null);
});`
Первый знак вопроса в SQL запросе заменяется на «Купить iPad или HP Slate», а второй на метку времени. В итоге выполнен будет примерно такой запрос:
`INSERT INTO ToDo (label, timestamp) values ("Купить iPad или HP Slate", 1265925077487)`
Работа с результатами запросов.
-------------------------------
Результат выполнения запроса на выборку данных содержит набор строк, а каждая строка содержит значения столбцов таблицы для данной строки.
Вы можете получить доступ к какой-либо строке результата вызвав функцию result.rows.item(i), где i – индекс строки. Далее, для получения требуемого значения, нужно обратиться к конкретному столбцу по имени – result.rows.item(i)[ «label»].
Следующий пример выводит результат запроса к базе данных на страницу:
`db.transaction(function(tx) {
tx.executeSql("SELECT * FROM ToDo", [], function(tx, result) {
for(var i = 0; i < result.rows.length; i++) {
document.write('**' + result.rows.item(i)['label'] + '**
');
}}, null)});`
Заключение.
-----------
Использование web SQL database предоставляет мощные возможности, но не стоит увлекаться. Если задачу можно решить с помощью web storage, лучше использовать его.
Вы можете найти дополнительную информацию по данной теме в соответствующем разделе [сайта консорциуме w3c](http://dev.w3.org/html5/webdatabase/).
Также для web SQL database уже начали разрабатывать ORM библиотеки. Пример такой библиотеки [тут](http://zef.me/2774/persistence-js-an-asynchronous-javascript-orm-for-html5gears). | https://habr.com/ru/post/84654/ | null | ru | null |
# Хоткеи в приложенях Ruby on Rails
**Mousetrap** — javascript-библиотека, позволяющая легко и непринужденно добавлять хоткеи на сайты, появилась не так давно. Но уже успела полюбиться мне настолько, что я решил сделать ее добавление к проекту на Ruby on Rails простым и приятным. А именно, завернуть в ruby-библиотеку для рельсов. Так появился gem [**mousetrap-rails**](http://kugaevsky.github.com/mousetrap-rails/).
#### Подключение
Чтобы использовать библиотеку в проекте, добавьте в `Gemfile` вашего приложения строчку
```
gem 'mousetrap-rails'
```
и выполните
```
$ bundle install
```
После чего запустите генератор, который создаст coffescript-файл с примерами использования `keybindings.js.coffee` и подключит библиотеку в Asset Pipeline, добавив `//= require mousetrap` в js манифест приложения.
```
$ rails generate mousetrap:install
```
#### Использование
С помощью уже включенных в созданный файл javascript-функций вы можете из коробки использовать data-атрибуты (`data-keybinding`), чтобы создать навигацию по страницам.
Например, код вида
```
= link_to 'Homepage', root_path, data: { keybinding: 'h' }
```
позволит перейти на домашнюю страницу по нажатию на `'h'`
А этот — заставит переключить фокус на поле ввода `Username` по кнопке `'u'`
```
= text_field_tag 'Username', nil, data: { keybinding: 'u' }
```
Конечно, возможности библиотеки не ограничиваются только навигацией, вы можете вызвать любую javascript-функцию. Причем повесить ее вызов можно не только на одну кнопку, но и на целое клавиатурное комбо.
```
// одиночные кнопки
Mousetrap.bind '4', -> alert '4 pressed!'
Mousetrap.bind 'x', (-> alert 'x pressed!'), 'keyup'
// комбинации
Mousetrap.bind 'command+shift+k', ->
alert 'command+shift+k pressed!'
false
Mousetrap.bind ['command+k', 'ctrl+k'], ->
alert 'command+k or ctrl+k pressed!'
false
// последовательности нажатий
Mousetrap.bind 'g i', -> console.log 'g i sequence pressed!'
Mousetrap.bind '* a', -> console.log '* a sequence pressed!'
// мега-комбо
Mousetrap.bind 'up up down down left right left right b a enter', -> console.log 'You WIN!'
```
Подробнее о возможностях Mousetrap можно узнать на странице [проекта](http://craig.is/killing/mice).
#### В заключение
Mousetrap прекрасно справляется со своими обязанностями, и gem я собираюсь развивать дальше. Буду рад любому [конструктивному фидбэку](https://github.com/kugaevsky/mousetrap-rails/issues).
##### Ссылки (куда же без них)
* [mousetrap-rails gem on github](https://github.com/kugaevsky/mousetrap-rails)
* [mousetrap-rails gem on rubygems](https://rubygems.org/gems/mousetrap-rails)
* [mousetrap javascript library](http://craig.is/killing/mice)
© Photo by [macrj](http://www.flickr.com/photos/macrj/) | https://habr.com/ru/post/152057/ | null | ru | null |
# Использование фильтров из Box2D в Libgdx
В [прошлой](http://habrahabr.ru/post/162079/) статье рассматривалась работа с `ContactListener`. Вот только примеры, которые я использовал, были не совсем верно выбраны. В Box2D есть намного более удобные средства для фильтрации столкновений, а именно – фильтры. О них и напишу в этот раз.
Фильтры обрабатываются перед обработкой коллизий. То есть, если на уровне фильтров мы укажем, чтобы какие-то объекты не сталкивались, то в дальнейшем обработки коллизий между этими объектами не будет. В случае же с использование `ContactListener`, не будут срабатывать его методы для таких объектов. Оптимизация на лицо. А теперь поподробнее рассмотрим.
##### Категории и маски
Категории и маски – самый мощный способ для фильтрования столкновений, но также и самым сложный (для новичков). Идея состоит в том, чтобы определить категорию для типов объектов, и использовать маски для фильтрования столкновений между этими типами объектов. Для начала определим категории.
```
// 0000000000000001 in binary
final public static short CATEGORY_PLAYER = 0x0001;
// 0000000000000010 in binary
final public static short CATEGORY_BALOOM = 0x0002;
// 0000000000000100 in binary
final public static short CATEGORY_RUNNER = 0x0004;
// 0000000000001000 in binary
final public static short CATEGORY_SCENERY = 0x0008;
```
Затем зададим их нашим объектам.
```
//игроку
f.categoryBits = MyWorld.CATEGORY_PLAYER;
//блокам и платформе
f.categoryBits = MyWorld.CATEGORY_SCENERY;
//для Baloom'а
f.categoryBits = MyWorld.CATEGORY_BALOOM;
//для Runner'а
f.categoryBits = MyWorld.CATEGORY_RUNNER;
```
Вы должны были заметить, что нумерация 0×001, 0×002, 0×004 и 0×008. Почему? Дело в том, что категории и маски – битовые поля (закодированы в 16 битах). Это означает, что возможные категории являются степенью 2 (в десятичной системе счисления: 1, 2, 4, 8, 16, 32, 64, 128 …, или в шестнадцатеричном: 0×1, 0×2, 0×4, 0×8, 0×10, 0×20, 0×40, 0×80 …). 16 битов означают, что есть 16 возможных категорий от 0×0001 до 0×8000.
Теперь определим маски.
```
final public static short MASK_PLAYER = CATEGORY_RUNNER | CATEGORY_SCENERY; // или ~MASK_PLAYER
final public static short MASK_BALOOM = CATEGORY_SCENERY ;
final public static short MASK_RUNNER = CATEGORY_PLAYER | CATEGORY_SCENERY ;
final public static short MASK_SCENERY = -1;
```
Обычная булева алгебра с типичными операциями над числами. Стоит лишь остановиться на маске и категории для пейзажных объектов. Почему -1? -1 означает, что объект будет контактировать со всеми другими объектами. Если же надо, чтобы объект не контактировал ни с кем, то установите значение 0.
Затем маски зададим нашим объектам.
```
//игроку
f.maskBits = MyWorld.MASK_PLAYER;
//блокам и платформе
f.maskBits = MyWorld.MASK_SCENERY;
//для Baloom'а
f.maskBits = MyWorld.MASK_BALOOM;
//для Runner'а
f.maskBits = MyWorld.MASK_RUNNER;
```
Если кто-то не понял, по маскам и категориям куски из кода представлены. Целиком назначения фильтра приведу на всякий случай, как пример для игрока:
```
Filter f = new Filter();
f.categoryBits = MyWorld.CATEGORY_PLAYER;
f.maskBits = MyWorld.MASK_PLAYER;
playerSensorFixture.setFilterData(f);
playerPhysicsFixture.setFilterData(f);
```
В итоге игрок будет взаимодействовать только с пейзажными объектами и с Runner’ом. Ballom только с пейзажем. Runner с игроком и пейзажем.
##### Фильтрация на уровне групп
Вы можете работать с категориями и масками, но порой нет необходимости их использовать, считать битовые маски и т.д. Группы специально были придуманы, чтобы отключить/включить обработку коллизий для каких-то связанных объектов.
Для начала, добавим ещё одного игрока.
```
BodyDef def2 = new BodyDef();
def.type = BodyType.DynamicBody;
Body boxP2 = world.createBody(def2);
player2 = new Player(boxP2);
player2.getBody().setTransform(5.0f, 1.0f, 0);
player2.getBody().setFixedRotation(true);
```
В классе `Player` зададим группу.
```
Filter f = new Filter();
f.groupIndex = -1;
playerSensorFixture.setFilterData(f);
playerPhysicsFixture.setFilterData(f);
```
Так же необходимо задать группы для всех остальных объектов. Пускай для платформы groupIndex будет 3, а для блоков 2. В принципе, платформе и блокам можно группу не назначать, тогда будет установлено значение по умолчанию – 0. Теперь, если запустить игру, персонаж будет контактировать со всеми объектами кроме других персонажей.
Вы должны были обратить внимание на то, что индекс имеет отрицательное значение. **Если индекс положителен — объекты всегда контактируют, если отрицателен — никогда не контактируют**.
##### Исходники
Можете скачать исходники [отсюда](http://suvitruf.ru/2012/12/25/2812/#source). | https://habr.com/ru/post/163885/ | null | ru | null |
# Поиск RSS новостных сайтов
Покопался я ещё в своих старых и не очень проектах и нашёл одну интересную программку. Она ищет RSS ссылки новостных сайтов. Задача которая стояла — это найти как можно больше новостных RSS лент и собрать их всех в одну базу.
Когда встал вопрос о том как искать новостные сайты, пришла мысль о использовании сервиса news.google.com. От туда можно выдёргивать ссылки на новостные сайты, к тому же они постоянно добавляются и отсортированы по регионам, темам и т.д. Осталось пройтись по всем разделам news.google.com, выдернуть ссылки новостных сайтов, а затем найти все RSS каждого из них.
Сначала код. Он состоит из следующих файлов: main.cpp LinksReader.cpp LinksReader.h LinksReader.pro Sources.txt и файл который создастся автоматически и в котором сохранится результат RssLinks.txt. Вся логика содержится в файлах LinksReader.h и LinksReader.cpp, остальные файлы вспомогательные, для использования класса и компилирования проекта. Компилировал проект в с помощью компилятора g++, среда Qt creator, версия библиотек 5.1
LinksReader.h
```
#ifndef LINKSREADER_H
#define LINKSREADER_H
#include
#include
#include
#include
#include
class LinksReader: public QObject
{
Q\_OBJECT
private:
void loadSources();
void loadRssLinks();
void readPage(QString url);
void takeLinks();
void takeRssLinks();
void saveRssLinks();
QNetworkAccessManager mNAManager;
QString mPage;
QString mPageUrl;
QStringList mSources;
QStringList mLinks;
QStringList mRssLinks;
private slots:
void onReplyFinished(QNetworkReply \*pReply);
public:
LinksReader(QObject \*pParent = 0);
void run();
};
#endif
```
LinksReader.cpp
```
#include "LinksReader.h"
void LinksReader::loadSources()
{
QString fileName = "Sources.txt";
QFile file(fileName);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
{
qDebug() << "File " << fileName << " not found";
return;
}
QTextStream in(&file);
while(!in.atEnd())
mSources.push_back(in.readLine());
file.close();
qDebug() << mSources.size() << " sources loaded";
return;
}
void LinksReader::loadRssLinks()
{
QString fileName = "RssLinks.txt";
QFile file(fileName);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return;
QTextStream in(&file);
while(!in.atEnd())
mRssLinks.push_back(in.readLine());
file.close();
qDebug() << mRssLinks.size() << " rss links loaded";
return;
}
void LinksReader::readPage(QString url)
{
mPage = "";
mPageUrl = url;
mNAManager.get(QNetworkRequest(QUrl(url)));
QEventLoop loop;
QObject::connect(&mNAManager, SIGNAL(finished(QNetworkReply *)), &loop, SLOT(quit()));
loop.exec();
}
void LinksReader::takeLinks()
{
QStringList fullLinks;
QString links = "";
QString beginTN = "";
QString endTN = "";
QString tagContent = "";
int beginTP = 0;
int endTP = 0;
while(1)
{
beginTP = mPage.indexOf(beginTN);
endTP = mPage.indexOf(endTN);
if (beginTP == -1 || endTP == -1) break;
tagContent = mPage.mid(beginTP + beginTN.length(), endTP - beginTP - endTN.length() + 1);
links += tagContent;
mPage.remove(0, endTP + endTN.length());
}
fullLinks = links.split("http://");
fullLinks.removeFirst();
for(int i = 0; i < fullLinks.size(); i++)
{
fullLinks[i].remove(fullLinks[i].indexOf("/"), fullLinks[i].length());
mLinks.push_back(fullLinks[i]);
}
}
void LinksReader::takeRssLinks()
{
QString beginTN = " 0 && rssString[rssString.size() - 1] == '/')
rssString.remove(rssString.size() - 1, 1);
if (rssString.indexOf("http://") == -1)
rssString.push\_front(mPageUrl);
qDebug() << rssString;
mRssLinks.push\_back(rssString);
}
mPage.remove(0, endTP + endTN.length());
}
}
void LinksReader::saveRssLinks()
{
QFile file("RssLinks.txt");
file.open(QFile::ReadWrite);
QTextStream in(&file);
for(int i = 0; i < mRssLinks.size(); i++)
in << mRssLinks[i] << "\n";
file.close();
}
void LinksReader::onReplyFinished(QNetworkReply \*reply) {
mPage += reply->readAll();
}
LinksReader::LinksReader(QObject \*pParent): QObject(pParent) {
QObject::connect(&mNAManager, SIGNAL(finished(QNetworkReply \*)), this, SLOT(onReplyFinished(QNetworkReply \*)));
}
void LinksReader::run()
{
loadSources ();
loadRssLinks();
qDebug() << "Please wait...";
for(int i = 0; i < mSources.size(); i++)
{
readPage(mSources[i]);
takeLinks();
}
mLinks.removeDuplicates();
for(int i = 0; i < mLinks.size(); i++)
{
readPage("http://" + mLinks[i]);
takeRssLinks();
}
mRssLinks.removeDuplicates();
saveRssLinks();
qDebug() << "Finish";
}
```
main.cpp
```
#include
#include "LinksReader.h"
int main(int argc, char \*argv[])
{
QCoreApplication a(argc, argv);
LinksReader linksReader;
linksReader.run();
return a.exec();
}
```
LinksReader.pro
```
QT += core
QT += network
QT -= gui
TARGET = LinksReader
CONFIG += console
CONFIG -= app_bundle
TEMPLATE = app
SOURCES += main.cpp \
LinksReader.cpp
HEADERS += \
LinksReader.h
```
Sources.txt
```
http://news.google.com/news?ned=au&output=rss
http://news.google.com/news?ned=in&output=rss
http://news.google.com/news?ned=en_il&output=rss
http://news.google.com/news?ned=en_my&output=rss
http://news.google.com/news?ned=nz&output=rss
http://news.google.com/news?ned=en_pk&output=rss
http://news.google.com/news?ned=en_ph&output=rss
http://news.google.com/news?ned=en_sg&output=rss
http://news.google.com/news?ned=ar_me&output=rss
http://news.google.com/news?ned=ar_ae&output=rss
http://news.google.com/news?ned=ar_lb&output=rss
http://news.google.com/news?ned=ar_sa&output=rss
http://news.google.com/news?ned=cn&output=rss
http://news.google.com/news?ned=hk&output=rss
http://news.google.com/news?ned=hi_in&output=rss
http://news.google.com/news?ned=ta_in&output=rss
http://news.google.com/news?ned=ml_in&output=rss
http://news.google.com/news?ned=te_in&output=rss
http://news.google.com/news?ned=iw_il&output=rss
http://news.google.com/news?ned=jp&output=rss
http://news.google.com/news?ned=kr&output=rss
http://news.google.com/news?ned=tw&output=rss
http://news.google.com/news?ned=vi_vn&output=rss
http://news.google.com/news?ned=nl_be&output=rss
http://news.google.com/news?ned=fr_be&output=rss
http://news.google.com/news?ned=en_bw&output=rss
http://www.google.com/news?ned=cs_cz&output=rss
http://news.google.com/news?ned=de&output=rss
http://news.google.com/news?ned=es&output=rss
http://news.google.com/news?ned=en_et&output=rss
http://news.google.com/news?ned=fr&output=rss
http://news.google.com/news?ned=en_gh&output=rss
http://news.google.com/news?ned=en_ie&output=rss
http://news.google.com/news?ned=it&output=rss
http://news.google.com/news?ned=en_ke&output=rss
http://news.google.com/news?ned=hu_hu&output=rss
http://news.google.com/news?ned=fr_ma&output=rss
http://news.google.com/news?ned=en_na&output=rss
http://news.google.com/news?ned=nl_nl&output=rss
http://news.google.com/news?ned=en_ng&output=rss
http://news.google.com/news?ned=no_no&output=rss
http://news.google.com/news?ned=de_at&output=rss
http://news.google.com/news?ned=pl_pl&output=rss
http://news.google.com/news?ned=pt-PT_pt&output=rss
http://news.google.com/news?ned=de_ch&output=rss
http://news.google.com/news?ned=fr_sn&output=rss
http://news.google.com/news?ned=en_za&output=rss
http://news.google.com/news?ned=fr_ch&output=rss
http://news.google.com/news?ned=sv_se&output=rss
http://news.google.com/news?ned=en_tz&output=rss
http://news.google.com/news?ned=tr_tr&output=rss
http://news.google.com/news?ned=en_ug&output=rss
http://news.google.com/news?ned=uk&output=rss
http://news.google.com/news?ned=en_zw&output=rss
http://news.google.com/news?ned=ar_eg&output=rss
http://news.google.com/news?ned=el_gr&output=rss
http://news.google.com/news?ned=ru_ru&output=rss
http://news.google.com/news?ned=sr_rs&output=rss
http://news.google.com/news?ned=ru_ua&output=rss
http://news.google.com/news?ned=uk_ua&output=rss
http://news.google.com/news?ned=es_ar&output=rss
http://news.google.com/news?ned=pt-BR_br&output=rss
http://news.google.com/news?ned=ca&output=rss
http://news.google.com/news?ned=fr_ca&output=rss
http://news.google.com/news?ned=es_cl&output=rss
http://news.google.com/news?ned=es_co&output=rss
http://news.google.com/news?ned=es_cu&output=rss
http://news.google.com/news?ned=es_us&output=rss
http://news.google.com/news?ned=es_mx&output=rss
http://news.google.com/news?ned=es_pe&output=rss
http://news.google.com/news?ned=us&output=rss
http://news.google.com/news?ned=es_ve&output=rss
```
После запуска программы, создания объекта класса LinksReader и вызова его метода run происходит следующее:
1. Загружаются источники.
2. Загружаются все найденные за прошлые разы RSS ссылки (чтобы не искать каждый раз по новой, а пополнять уже имеющуюся базу RSS).
3. Проходим по всем источником, читаем разметку и выдёргиваем все ссылки которые в разметке помечены тегом .
4. Удаляем все повторяющиеся ссылки.
5. Проходим по всем найденным новостным сайтам, читаем разметку каждого из них и выдёргиваем значения всех RSS тегов этого сайта.
6. Удаляем все повторяющиеся RSS ссылки.
7. И наконец сохраняем результат в файл.
По стандарту все RSS ссылки сайта, должны быть помечены тегом `/>`, что намного облегчает поиск RSS.
Как видно программа достаточно проста, но хорошо делает своё дело. За один запуск находит 600-700 RSS лент. Повторные запуски увеличивают это количество, так-как в news.google.com постоянно добавляются ссылки на новые новостные сайты.
Не хотел подробно рассматривать каждую строку кода, думаю что он и так хорошо читается, даже не знающим Qt. Но, если есть непонятные места — спрашивайте и я с радостью помогу разобраться. Если есть замечания, критика — пишите.
[github](https://github.com/extenup/LinksReader/tree/master) | https://habr.com/ru/post/203210/ | null | ru | null |
# JSF + DynamicFaces = AJAX
##### Кратко о JSF
JSF — компонентный MVC фреймворк для веб-приложений на java. Основная его задача — упростить разработку интерфейса и связывание его с серверной частью. JSF содержит валидаторы и конвертеры, также вы можете добавить свои компоненты и изменять существующие.
О JSF подробнее [здесь](http://www.javaserverfaces.ru) (на русском) и [здесь](http://java.sun.com/javaee/javaserverfaces/) (на английском).
Так что же такое Dynamic Faces? Это библиотека для добавления динамики в jsf-приложения. Самое большое преимущество этой библиотеки в том, что DF не требует модифицировать компоненты или переписывать что-то в приложении, чтобы добавить Ajax.
##### Как добавить Dynamic Faces в приложение?
Добавляем в tag library
`<%@ taglib prefix="jsfExt"
uri="http://java.sun.com/jsf/extensions/dynafaces" %>`
Добавляем следующий тег в head тег нашей страницы для инициализации js-библиотек
В форме выставляем атрибут prependId в false
Итак, представим, что у нас есть страница с большим количеством jsf-контролов, при изменении одного из них нам нужно динамически обновлять какую-то область. Например, заказ автомобиля, все параметры комплектации влияют на цену. Меняем любую характеристику — сразу меняется цена.
##### Как это выглядит?
> <jsfExt:ajaxZone id=«zoneParams» execute=«zoneParams» render=«zonePrice»>
>
> Объем двигателя <h:selectOneMenu binding="#{ApplicationBean.components.engine}"/>
>
> Сиденья <h:selectOneRadio binding="#{ApplicationBean.components.seats}"/>
>
> jsfExt:ajaxZone>
>
> <jsfExt:ajaxZone id=«zonePrice»>
>
> Цена: <h:outputtext id=«price» value="#{ApplicationBean.price}"/>
>
> jsfExt:ajaxZone>
>
>
>
> \* This source code was highlighted with [Source Code Highlighter](http://source.virtser.net).
**zoneParams** — Область c характеристиками автомобиля, execute – область, в которой любые измененные значения отправляются на сервер, execute – область, которая будет перерисовываться.
**zonePrice** — Область с ценой
##### Другой способ:
Мы можем генерировать ajax-транзакцию по любому событию на любом компоненте.
Например:
> Введите текст:
>
> <h:inputText id=«inputText» valueChangeListener="#{ApplicationBean.valueChangeTxt}"
>
> value="#{ApplicationBean.textVal}"/>
>
>
>
> <h:commandButton value=«Ок»
>
> onclick=«fireTransaction(this); return false;»/>
>
>
>
> Ваш текст:
>
> <h:outputText id=«outputText» value="#{ApplicationBean.textVal}"/>
>
>
>
> \* This source code was highlighted with [Source Code Highlighter](http://source.virtser.net).
JavaScript:
> function fireTransaction(object)
>
> {
>
> DynaFaces.fireAjaxTransaction(object,
>
> {
>
> execute: 'inputText',
>
> render: 'outputText',
>
> inputs: 'inputText'
>
> });
>
> }\* This source code was highlighted with [Source Code Highlighter](http://source.virtser.net).
Теперь разберемся, что мы тут написали
У нас есть 3 jsf-компонента:
**inputText** — думаю, по названию понятно, какой html-тег скрывается за этим названием. Тег имеет атрибут valueChangeListener, который указывает на метод в ApplicationBean, который будет выполняться при смене значения, мы еще вспомним о нем позже. Value — указывает на свойство, где будет хранится значение, которые мы ввели.
**CommandButton** — кнопка, нажатие по которой собственно и генерирует jsf-транзакцию. Мы видим js-метод fireTransaction, рассмотрим его подробнее.
В качестве параметра передается html-object того компонента, который вызывает транзакцию, далее мы вызываем DynaFaces.
fireAjaxTransaction — это метод из библиотеки Dynamic Faces.
**execute** — id компонента, из которого берем значение
**render** — id компонента, который будет обновляться
**execute** — id компонента, который будет исполняться. Испольняется метод в valueChangeListener, о котором мы говорили раньше.
После вызова этой функции мы возвращаем false, это сделано для того, чтоб не сработало событие submit для формы и страница не перегрузилась.
**outputText** — обновляемое значение.
Вот и все, вводим текст, нажимаем на кнопку, текст отправляется на сервер и от туда же попадает опять в интерфейс, да еще и вызывается метод valueChangeTxt.
Вызов транзакции можно вешать на любые события.
Подробнее о Dynamic Faces можно почитать [здесь](http://jsf-extensions.dev.java.net/mvn/tutorial.html) | https://habr.com/ru/post/36927/ | null | ru | null |
# На вкус и цвет 2 – не RGB единым
Приветствую всех читателей. Попробуем продолжить нашу затею, начало которой [здесь](http://habrahabr.ru/post/254797/#first_unread).
Итак, мы имеем кастомную View с разноцветным кружочком, из которого теперь необходимо выдернуть выбранный пользователем цвет. Перед тем как окунуться в дебри расчетов давайте для начала организуем какие-нибудь маркеры-указатели выбранного цвета. Не будем усложнять и сделаем их в виде простых линий – стрелок. Для них нам понадобится новая Paint и размеры. Чтобы не повторяться в дальнейшем, давайте рассчитаем сразу все необходимые параметры. Я сознательно пишу кучу отдельных переменных для наглядности.
Наши объявления и методы приобретают вид:
```
// Константы, определяющие что именно мы устанавливаем в данный момент
protected static final int SET_COLOR = 0;
protected static final int SET_SATUR = 1;
protected static final int SET_ALPHA = 2;
// и флаг, который будет устанавливаться в одну из этих констант.
// (как-то непонятно я выразился)
private int mMode;
float cx;
float cy;
float rad_1; //
float rad_2; //
float rad_3; //
float r_centr; // радиусы наших окружностей
float r_sel_c; //
float r_sel_s; //
float r_sel_a; // границы полей выбора
// всякие краски
private Paint p_color = new Paint(Paint.ANTI_ALIAS_FLAG);
private Paint p_satur = new Paint(Paint.ANTI_ALIAS_FLAG);
private Paint p_alpha = new Paint(Paint.ANTI_ALIAS_FLAG);
private Paint p_white = new Paint(Paint.ANTI_ALIAS_FLAG);
private Paint p_handl = new Paint(Paint.ANTI_ALIAS_FLAG);
private Paint p_centr = new Paint(Paint.ANTI_ALIAS_FLAG);
private float deg_col; // углы поворота
private float deg_sat; // указателей - стрелок
private float deg_alp; // ********************
private float lc; //
private float lm; // отступы и выступы линий
private float lw; //
private void calcSizes() {
//
//
cx = size * 0.5f;
cy = cx;
lm = size * 0.043f;
lw = size * 0.035f;
rad_1 = size * 0.44f;
r_sel_c = size * 0.39f;
rad_2 = size * 0.34f;
r_sel_s = size * 0.29f;
rad_3 = size * 0.24f;
r_sel_a = size * 0.19f;
r_centr = size * 0.18f;
lc = size * 0.08f;
p_color.setStrokeWidth(lc);
p_satur.setStrokeWidth(lc);
p_alpha.setStrokeWidth(lc);
}
```
Для начала надо убедиться, что мы выбираем именно цвет на наружном кольце. Для этого к координатам расстояния от центра по горизонтали и по вертикали (в нашем коде это a и b в ACTION\_DOWN), добавляем еще одну – расстояние от центра по прямой. По всем законам геометрии обзовем ее «с». И тут же вычислим, вспомнив труды гражданина Пифагора:
```
float c = (float) Math.sqrt(a * a + b * b);
```
Теперь остается проверить, что место касания находится на наружном кольце, то есть с больше внутреннего радиуса кольца. Заодно, забегая вперед, выполним эти проверки для остальных еще не существующих колец. И выставим флаги. В конечном итоге:
```
case MotionEvent.ACTION_DOWN:
float a = Math.abs(event.getX() - cx);
float b = Math.abs(event.getY() - cy);
float c = (float) Math.sqrt(a * a + b * b);
if (c > r_sel_c) mode = SET_COLOR;
else if (c < r_sel_c && c > r_sel_s) mode = SET_SATUR;
else if (c < r_sel_s && c > r_sel_a) mode = SET_ALPHA;
else if (c < r_centr) listener.onDismiss(mColor, alpha);
break;
```
Заметьте – проверку расстояния от центра мы выполняем только в ACTION\_DOWN. То есть ткнув пальцем в наружное кольцо, мы можем потом сколько угодно елозить по нашей View даже за пределами зоны выбора цвета, меняться будет именно цвет. Пока мы не ткнем пальцем повторно и не сменим флаг mode.
Теперь в ACTION\_MOVE будем получать новые координаты и определять выбранный цвет, насыщенность или прозрачность. Чтобы не засорять onTouch вынесем математику в отдельные методы. Ну и вызов invalidate() я думаю лучше сюда же поместить. У нас получилось:
```
case MotionEvent.ACTION_MOVE:
float x = event.getX() - cx;
float y = event.getY() - cy;
switch (mMode) {
case SET_COLOR:
setColScale(getAngle(x, y));
break;
case SET_SATUR:
setSatScale(getAngle(x, y));
break;
case SET_ALPHA:
setAlphaScale(getAngle(x, y));
break;
}
invalidate();
break;
}
```
Методы типа два в одном. Рассмотрим подробнее. getAngle(x, y) – на основании координат определяем угол между положением пальца и центром View. Что-то типа такого:
```
protected float getAngle(float x, float y) {
float deg = 0;
if (x != 0) deg = y / x;
deg = (float) Math.toDegrees(Math.atan(deg));
if (x < 0) deg += 180;
else if (x > 0 && y < 0) deg += 360;
return deg;
}
```
На выходе получаем угол в градусах, который теперь необходимо как-то связать с цветом в этом секторе нашего градиента. На этом мысль зашла в тупик. Извращенческие идеи вычисления координат пикселов и анализа их цвета я как-то сразу отбросил. В голове вертелись слова пингвина из Мадагаскара – «Ковальски, предложите варианты…». В роли Ковальского выступил Гугл. И вот что он сказал.
Оказывается есть жизнь и на других планетах. И вместо такого родного и понятного ARGB там используют какой-то непонятный HSV. Что это за зверь такой? Например первая его буква? Вики заявляет, что это «Hue – цветовой тон… Варьируется в пределах 0 – 360…». Прикидываете, какое совпадение? А остальные буквы? S – Saturation – да это же наше второе кольцо! А V – Value – это яркость. И Андроид тут же предлагает нам пару функций:
```
Color.HSVToColor(int, float[]);
Color.colorToHSV(int, float[]);
```
Параметр int в первой функции – прозрачность, вспоминаем про наше третье кольцо. Во второй функции int это непосредственно цвет. И в обеих функциях float[] это массив из трех элементов, первый из которых соответственно буквам HSV и есть значение цвета палитры от 0 до 360. Жизнь, похоже, налаживается.
Объявляем массивы argb и hsv для хранения компонентов нашего цвета:
```
private int[] argb = new int[] { 255, 0, 0, 0};
private float[] hsv = new float[] {0, 1f, 1f};
```
И просто подставляем полученный ранее угол в градусах в качестве первого элемента массива.
```
protected void setColScale(float f) {
deg_col = f;
hsv[0] = f;
mColor = Color.HSVToColor(argb[0], hsv);
p_center.setColor(mColor);
}
```
Теперь у нас есть цвет, угол и полное право рисовать второе кольцо и стрелки. Вот код:
```
private void drawSaturGradient(Canvas c) {
SweepGradient s = null;
int[] sg = new int[] {
Color.HSVToColor(new float[] {deg_col, 1, 0}), Color.HSVToColor(new float[] {deg_col, 1, 1}), Color.HSVToColor(new float[] { hsv[0], 0, 1}), Color.HSVToColor(new float[] { hsv[0], 0, 0.5f}), Color.HSVToColor(new float[] {deg_col, 1, 0})
};
s = new SweepGradient(cx, cy, sg, null);
p_satur.setShader(s);
c.drawCircle(cx, cy, rad_2, p_satur);
}
```
Очень похоже на предыдущий код, тот же массив для шейдера, тот же градиент. Только теперь в нем 5 цветов, каждый из которых мы выдираем из HSV. Причем насыщенность и яркость задаем вручную от 0 до 1, а в первый (в смысле нулевой) элемент массива я почему-то засунул значение угла. Более правильно было бы видеть там имеющееся у нас значение hsv[0], но это ведь одна и та же величина. В качестве доказательства я даже переправил в двух местах. Так что не забываем, что deg\_col == hsv[0]. Ну угол мне первый под руку попался, простите.
Результат:
Думаю, всем понятно, что этот метод должен вызываться в onDraw(), как и следующие. Дада, мы вполне уже можем рисовать третье кольцо:
```
private void drawAlphaGradient(Canvas c) {
// три белых линии на черном фоне как бы помогают визуально
// оценить уровень прозрачности
c.drawCircle(cx, cy, rad_3 - lw, p_white);
c.drawCircle(cx, cy, rad_3, p_white);
c.drawCircle(cx, cy, rad_3 + lw, p_white);
// вытаскиваем компоненты RGB из нашего цвета
int ir = Color.red(mColor);
int ig = Color.green(mColor);
int ib = Color.blue(mColor);
// массив из двух цветов – наш и он же полностью прозрачный
int e = Color.argb(0, ir, ig, ib);
int[] mCol = new int[] {mColor, e};
// Это мы уже проходили
Shader sw = new SweepGradient(cx, cy, mCol, null);
p_alpha.setShader(sw);
c.drawCircle(cx, cy, rad_3, p_alpha);
}
```
И стрелочки:
```
private void drawLines(Canvas c) {
float d = deg_col;
c.rotate(d, cx, cy);
c.drawLine(cx + rad_1 + lm, cy, cx + rad_1 - lm, cy, p_handl);
c.rotate(-d, cx, cy);
d = deg_sat;
c.rotate(d, cx, cy);
c.drawLine(cx + rad_2 + lm, cy, cx + rad_2 - lm, cy, p_handl);
c.rotate(-d, cx, cy);
d = deg_alp;
c.rotate(d, cx, cy);
c.drawLine(cx + rad_3 + lm, cy, cx + rad_3 - lm, cy, p_handl);
c.rotate(-d, cx, cy);
}
```
У кого-нибудь возник вопрос – зачем в последнем методе локальная переменная d? Возможно, это признаки моей паранойи. Если использовать непосредственно глобальную переменную deg\_col или другие, за время отрисовки юзер может их изменить, водя пальцем по экрану. Понятное дело, что за те микросекунды отрисовки изменения будут ничтожными. Но тем не менее функции
```
c.rotate(deg_col, cx, cy);
```
и
```
c.rotate(-deg_col, cx, cy);
```
будут поворачивать Canvas на разную величину. И разница эта будет постепенно накапливаться.
Ну не забываем, конечно, задать свойства для наших Paint по вкусу. У меня это как-то так:
```
private void init(Context context) {
setFocusable(true);
p_color.setStyle(Style.STROKE);
p_satur.setStyle(Style.STROKE);
p_alpha.setStyle(Style.STROKE);
p_center.setStyle(Style.FILL_AND_STROKE);
p_white.setStrokeWidth(2);
p_white.setColor(Color.WHITE);
p_white.setStyle(Style.STROKE);
p_handl.setStrokeWidth(5);
p_handl.setColor(Color.WHITE);
p_handl.setStrokeCap(Cap.ROUND);
setOnTouchListener(this);
}
```
setFocusable(true) я пропустил в прошлой статье.
Возвращаемся к нашим OnTouch.
```
protected void setSatScale(float f) {
deg_sat = f;
if (f < 90) {
hsv[1] = 1;
hsv[2] = f / 90;
}
else if (f >= 90 && f < 180) {
hsv[1] = 1 - (f - 90) / 90;
hsv[2] = 1;
}
else {
hsv[1] = 0;
hsv[2] = 1 - (f - 180) / 180;
}
mColor = Color.HSVToColor(argb[0], hsv);
p_center.setColor(mColor);
}
protected void setAlphaScale(float f) {
deg_alp = f;
argb[0] = (int) (255 - f / 360 * 255);
mColor = Color.HSVToColor(argb[0], hsv);
alpha = (float) Color.alpha(mColor) / 255;
p_center.setColor(mColor);
}
```
Ну что, нам осталось как-то вывести полученный результат. Тут опять же дело вкуса и конкретного варианта использования. Кому-то удобнее значение в Preference писать, кому-то Intent слать во все стороны. Я предлагаю организовать нашему View интерфейс, как у настоящего взрослого и самостоятельного контрола. Значение цвета мы можем слать однократно по нажатию на центр круга, можем в реалтайме, по мере изменения цвета в OnTouch. Гулять так гулять, сделаем и то, и другое:
```
private OnColorChangeListener listener;
public interface OnColorChangeListener {
public void onDismiss(int val, float alpha);
public void onColorChanged(int val, float alpha);
}
public void setOnColorChangeListener(OnColorChangeListener l) {
this.listener = l;
}
```
```
В OnTouch:
case MotionEvent.ACTION_DOWN:
…
…
else if (c < r_centr) {
listener.onDismiss(mColor, alpha);
}
break;
case MotionEvent.ACTION_MOVE:
…
…
listener.onColorChanged(mColor, alpha);
break;
}
return true;
}
```
Надеюсь, ничего не забыл. А, да. Желательно иметь возможность передавать в наш ColorPicker текущее значение цвета. Добавляем:
```
public void setUsedColor(int color, float a) {
mColor = color;
Color.colorToHSV(mColor, hsv);
setColScale(hsv[0]);
float deg = 0;
if (hsv[1] == 1) deg = 90 * hsv[2];
else if (hsv[2] == 1) deg = 180 - 90 * hsv[1];
else if (hsv[1] == 0) deg = 360 - 180 * hsv[2];
setSatScale(deg);
setAlphaScale(360 - 360 * a);
}
```
P.S: Еще один нюанс выяснился при практическом использовании. Попытка применить полученный цвет к картинкам (в виде ColorFilter) не меняет их прозрачность. Или я что-то пропустил? Если да – надеюсь, меня поправят более опытные товарищи. Пришлось использовать метод setAlpha, предварительно получив значение прозрачности методом Color.alpha(mColor). Значение int 0-255, а setAlpha(int) в последнее время deprecated. Требуется float от 0 до 1 (типа setAlpha((float) Color.alpha(mColor) / 255));
Раз уж мы претендуем на универсальность нашего контрола, есть смысл засунуть эти вычисления в него. И выдавать прозрачность формата float 0-1. Можно отдельным методом в интерфейсе, можно вторым параметром дополнительно у цвету – дело вкуса. Добавил это в код.
Хотя для полной универсальности можно заставить его выдавать раздельно все компоненты – мало ли где понадобится. Не буду это сейчас реализовывать, думаю это не проблема даже для чайника.
Вот теперь все. | https://habr.com/ru/post/254895/ | null | ru | null |
# Погружение в службы Android
Перевод статьи ["Deep Dive into Android Services"](https://proandroiddev.com/deep-dive-into-android-services-4830b8c9a09) от Nazmul Idris. Я оставил оригинальное название автора, хотя это скорее не "погружение", а "знакомство". Думаю, текст будет полезен начинающим разработчикам. Статья отлично дополняет [офф. документацию по службам на Android](https://developer.android.com/guide/components/services.html). В статье разбираются особенности взаимодействия с запущенными и привязанными службами. Плюс статьи в том, что учитываются изменения в работе со службами в Android O. В переводе есть незначительные, по сравнению с оригиналом, изменения, добавленные для пущей ясности.
### Введение
Большинство современных android-приложений выполняют часть задач в фоне. Это означает, что задачи выполняются в фоновом потоке, а не в потоке пользовательского интерфейса (UI-поток).
Если вы создаете `Thread` (поток) или `Executor` (обертка управления потоками) в конкретной `Activity` своего приложения, то это может привести к непредсказуемым результатам. Например, во время простой смены ориентации экрана, ваша `Activity` создается заново и потокам, привязанным к старой `Activity`, некуда возвращать результат.
Чтобы справиться с этим вы могли бы использовать `AsyncTask`. Но что, если вашему приложению необходимо запустить этот фоновый поток не только из `Activity`, но и из нотификации (notification) или из другого компонента?
В этом случае служба (service) это подходящий компонент Android, который свяжет жизненный цикл потока со своим жизненным циклом, и таким образом не потеряет его.
Служба — это компонент android-приложения без видимого интерфейса, который запускается в основном потоке приложения. Служба должна быть объявлена в манифесте. Если вам необходимо чтобы служба работала в фоновом потоке, вы должны самостоятельно реализовать это.
Термины *фон* и *передний план* перегружены, и могут применяться к:
1. жизненному циклу компонентов Android
2. потокам
В этой статье, по умолчанию будем считать, что термины *фон* и *передний план* относятся к жизненному циклу. Но, когда будет идти речь о потоках, мы будем явно говорить *фоновый поток* или *поток переднего плана*.
Существует подкласс android-служб, называемый [`IntentService`](https://developer.android.com/training/run-background-service/create-service.html), который запускает задачи в фоновом потоке "из коробки". Но мы не будем говорить о таких службах в этой статье.
### Потоки, службы и жизненный цикл компонентов Android
Давайте сделаем шаг назад и посмотрим на более общую картину того, что должны делать службы. Ваш код, который работает в фоновом потоке, например `Thread` или `Executor`, на самом деле не связан с жизненным циклом какого-либо компонента Android. Если мы говорим об `Activity`, то она имеет конкретную точку запуска и остановки работы, основываясь на взаимодействии с пользователем. Однако эти точки начала и конца работы `Activity` не обязательно связаны с жизненным циклом `Thread` или `Executor`.
Ниже приведены пояснения к основным временн*ы*м моментам этой диаграммы Гантта. Детали этих моментов (и пояснения к ним) приведены в остальной части статьи.
Метод службы `onCreate()` вызывается в момент ее создания (путем запуска или привязки к ней).
Затем, через некоторое время, служба запускает `Thread` или `Executor`. Когда `Thread` завершает работу, он дает об этом знать службе, чтобы та могла вызвать метод `stopSelf()`. Это довольно распространенный шаблон реализации службы.
Код, который вы пишите в ваших `Thread` или `Executor`, должен сообщить службе о запуске или остановке фонового потока.
* Когда поток начинает работу, он должен установить начальное состояние сервиса путем вызова `startService()`
* Когда поток завершает работу, он должен вызвать `stopSelf()` у службы.
Метод службы `onDestroy()` вызывается системой только когда вы сообщили службе, что пришло время завершать работу. Служба не знает, что будет происходить в коде ваших `Thread` или `Executor` — это зона вашей ответственности. Таким образом, задача программиста сообщить службе о начале и о завершении работы.
Службы делятся на два вида: *запущенные* и *привязанные*. Кроме того, служба может быть запущенной и допускать привязку. Мы рассмотрим каждый из случаев:
1. Запущенная служба
2. Привязанная служба
3. Привязанная и запущенная служба одновременно
### Изменения в Android O
В Android O (API 26) произошли существенные изменения в регулировании фоновых служб системой. Одно из главных изменений в том, что запущенная служба, которая не в белом списке (в белый список помещаются службы, работа которых видна пользователю; подробнее смотри в [офф. документации](https://developer.android.com/about/versions/oreo/background.html#services)) или которая явно не сообщает пользователю о своей работе, не будет запускаться в фоновом потоке после закрытия `Activity`. Другими словами, вы должны создать уведомление (notification), к которому вы прикрепляете запущенную службу. И вы должны запускать службу с помощью нового метода [`startForegroundService()`](https://developer.android.com/reference/android/content/Context.html#startForegroundService(android.content.Intent)) (а не с помощью `startService()`). И, после создания службы, у вас есть пять секунд чтобы вызвать метод [`startForeground()`](https://goo.gl/T5R8hv) запущенной службы и показать видимое пользователю уведомление. Иначе система останавливает службу и показывает [ANR](https://developer.android.com/training/articles/perf-anr.html) ("приложение не отвечает"). Ниже мы разъясняем эти положения с помощью примеров кода.
### Запущенные службы
Запущенные службы начинают свою работу после вызова метода `startService(Intent)` в вашей `Activity` или службе. При этом `Intent` должен быть явным. Это означает, что вы должны явно указать в `Intent` имя класса запускаемой вами службы. Или, если вам важно допустить некоторую неопределенность в отношении того, какая служба запускается, вы можете предоставить фильтры намерений для ваших служб и исключить имя компонента из Intent, но затем вы должны установить пакет для намерения с помощью `setPackage()`, который обеспечивает достаточное устранение неоднозначности для целевой службы. Ниже мы приводим пример создания явного `Intent`:
```
public class MyIntentBuilder{
public static MyIntentBuilder getInstance(Context context) {
return new MyIntentBuilder(context);
}
public MyIntentBuilder(Context context) {
this.mContext = context;
}
public MyIntentBuilder setMessage(String message) {
this.mMessage = message;
return this;
}
public MyIntentBuilder setCommand(@Command int command) {
this.mCommandId = command;
return this;
}
public Intent build() {
Assert.assertNotNull("Context can not be null!", mContext);
Intent intent = new Intent(mContext, MyTileService.class);
if (mCommandId != Command.INVALID) {
intent.putExtra(KEY_COMMAND, mCommandId);
}
if (mMessage != null) {
intent.putExtra(KEY_MESSAGE, mMessage);
}
return intent;
}
}
```
Чтобы служба стала запущенной, вы должны вызвать `startService()` с явным намерением. Если вы не сделаете этого, тогда служба не перейдет в запущенное состояние. И, таким образом, она не сможет перейти на передний план, и `stopSelf()` на самом деле ничего не выполнит.
Итак, если вы не перевели службу в запущенное состояние, вы не сможете прикрепить ее к уведомлению. Это довольно важные вещи, о которых вы должны помнить, когда вам нужно перевести службу в запущенное состояние.
Служба может быть запущена несколько раз. Каждый раз, когда она запускается, вызывается `onStartCommand()`. Этому методу передается несколько параметров наряду с явным `Intent`. Даже если вы запускаете службу несколько раз, она вызывает `onCreate()` только однажды (конечно, если до этого служба уже не была привязана). Чтобы завершить работу, служба должна вызвать `stopSelf()`. После того, как служба будет остановлена (когда вы остановите ее), и если с ней ничего больше не связано, вызывается `onDestroy()`. Помните об этом, когда выделяете ресурсы для вашей запущенной службы.
### Intent
Для старта запущенной службы необходим `Intent`. Компонент Android, в котором стартует служба, на самом деле не хранит соединение с ней, и если ему необходимо что-то сообщить запущенной службе, он может запустить ее снова, используя другой `Intent`. Это главная разница между запущенной и привязанной службой. Привязанные службы со своей стороны реализуют шаблон *клиент-сервер*. Где клиент (компонент Android UI или другая служба) хранит соединение и может через него вызывать методы непосредственно у службы.
```
public class MyActivity extends Activity{
@TargetApi(Build.VERSION_CODES.O)
private void moveToStartedState() {
Intent intent = new MyIntentBuilder(this)
.setCommand(Command.START).build();
if (isPreAndroidO()) {
Log.d(TAG, "Running on Android N or lower");
startService(intent);
} else {
Log.d(TAG, "Running on Android O");
startForegroundService(intent);
}
}
}
```
Помните, что в Android O многое изменилось в отношении запущенных служб. Они больше не могут работать достаточно долго в фоне без механизма постоянного уведомления. И метод старта запущенной службы в фоне в Android O — это `startForegroundService(Intent)`.
### Передний план и механизм постоянного уведомления
Запущенная служба может работать на переднем плане. Опять же, термин *передний план* не относится к тому работает ли служба в фоновом потоке или в главном потоке. Но это означает, что система присвоит службе наивысший приоритет, и поэтому служба не является кандидатом для удаления системой в случае нехватки памяти. Помещать службу на передний план стоит только в том случае, когда это действительно необходимо для создания современного и отзывчивого приложения.
Примеры использования службами переднего плана:
1. Приложения, которые проигрывают медиа-файлы в фоне.
2. Приложения, которые обновляют данные о местоположении в фоне.
Когда запущенная служба помещается на передний план, она должна вывести на экран уведомление, явно сообщая пользователю, что служба работает. Это важно, потому что запущенная служба на переднем плане отделена от жизненного цикла UI-компонентов (за исключением, разумеется, самого постоянного уведомления). И нет другого способа сообщить пользователю о том, что на его телефоне что-то работает (и потенциально потребляет много ресурсов) кроме как вывести в UI постоянное уведомление.
Ниже пример старта запущенной службы на переднем плане:
```
public class MyActivity extends Activity{
private void commandStart() {
if (!mServiceIsStarted) {
moveToStartedState();
return;
}
if (mExecutor == null) {
// Start Executor task in Background Thread.
}
}
}
```
Вот код создания постоянного уведомления в версиях
**до Android O**
```
@TargetApi(25)
public static class PreO {
public static void createNotification(Service context) {
// Create Pending Intents.
PendingIntent piLaunchMainActivity =
getLaunchActivityPI(context);
PendingIntent piStopService = getStopServicePI(context);
// Action to stop the service.
NotificationCompat.Action stopAction =
new NotificationCompat.Action.Builder(
STOP_ACTION_ICON,
getNotificationStopActionText(context),
piStopService)
.build();
// Create a notification.
Notification mNotification =
new NotificationCompat.Builder(context)
.setContentTitle(getNotificationTitle(context))
.setContentText(getNotificationContent(context))
.setSmallIcon(SMALL_ICON)
.setContentIntent(piLaunchMainActivity)
.addAction(stopAction)
.setStyle(new NotificationCompat.BigTextStyle())
.build();
context.startForeground(
ONGOING_NOTIFICATION_ID, mNotification);
}
}
```
**в Android O, через NotificationChannel**
```
@TargetApi(26)
public static class O {
public static final String CHANNEL_ID =
String.valueOf(getRandomNumber());
public static void createNotification(Service context) {
String channelId = createChannel(context);
Notification notification =
buildNotification(context, channelId);
context.startForeground(
ONGOING_NOTIFICATION_ID, notification);
}
private static Notification buildNotification(
Service context, String channelId) {
// Create Pending Intents.
PendingIntent piLaunchMainActivity =
getLaunchActivityPI(context);
PendingIntent piStopService =
getStopServicePI(context);
// Action to stop the service.
Notification.Action stopAction =
new Notification.Action.Builder(
STOP_ACTION_ICON,
getNotificationStopActionText(context),
piStopService)
.build();
// Create a notification.
return new Notification.Builder(context, channelId)
.setContentTitle(getNotificationTitle(context))
.setContentText(getNotificationContent(context))
.setSmallIcon(SMALL_ICON)
.setContentIntent(piLaunchMainActivity)
.setActions(stopAction)
.setStyle(new Notification.BigTextStyle())
.build();
}
@NonNull
private static String createChannel(Service ctx) {
// Create a channel.
NotificationManager notificationManager =
(NotificationManager)
ctx.getSystemService(Context.NOTIFICATION_SERVICE);
CharSequence channelName = "Playback channel";
int importance = NotificationManager.IMPORTANCE_DEFAULT;
NotificationChannel notificationChannel =
new NotificationChannel(
CHANNEL_ID, channelName, importance);
notificationManager.createNotificationChannel(
notificationChannel);
return CHANNEL_ID;
}
}
```
Кроме того, вот [еще одна статья](https://medium.com/google-developers/migrating-mediastyle-notifications-to-support-android-o-29c7edeca9b7), в которой больше деталей о создании уведомлений в MediaStyle (поскольку для фонового проигрывания аудио-файлов нужны как уведомления, так и привязанные и запущенные службы)
### Остановка запущенных служб
Обратите внимание, что параметр `piStopService` типа `PendingIntent` (который передается в конструктор уведомления) фактически передает `Intent` с константой `Command.STOP` типа `Integer`. Помните, что `startService(Intent)` может вызываться несколько раз? Это пример такого поведения. Чтобы остановить службу мы запускаем `Intent` через `startService(Intent)` и далее обрабатываем этот `Intent` в методе `onStartCommand()` запущенной службы.
```
public class HandleNotifications{
private static PendingIntent getStopServicePI(Service context) {
PendingIntent piStopService;
{
Intent iStopService = new MyIntentBuilder(context)
.setCommand(Command.STOP).build();
piStopService = PendingIntent.getService(
context, getRandomNumber(), iStopService, 0);
}
return piStopService;
}
}
```
Это объясняет почему метод `onStartCommand()` должен уметь обрабатывать `Intent`ы. Используя этот механизм мы можем "сказать" службе, чтобы она остановила работу. Ниже код, который иллюстрирует эти возможности:
```
public class MyService extends Service{
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
boolean containsCommand = MyIntentBuilder
.containsCommand(intent);
d(TAG,
String.format(
"Service in [%s] state. cmdId: [%d]. startId: [%d]",
mServiceIsStarted ? "STARTED" : "NOT STARTED",
containsCommand ?
MyIntentBuilder.getCommand(intent) : "N/A",
startId));
mServiceIsStarted = true;
routeIntentToCommand(intent);
return START_NOT_STICKY;
}
private void routeIntentToCommand(Intent intent) {
if (intent != null) {
// process command
if (containsCommand(intent)) {
processCommand(MyIntentBuilder.getCommand(intent));
}
// process message
if (MyIntentBuilder.containsMessage(intent)) {
processMessage(MyIntentBuilder.getMessage(intent));
}
}
}
}
```
Если вы хотите завершить выполнение запущенной службы на переднем плане, вы должны вызвать `stopForeground(true)`. Этот метод также завершит работу постоянного уведомления. Однако, саму службу это не остановит. Для этого следует вызвать `stopSelf()`.
Чтобы остановить службу вы можете выполнить одно из следующих действий:
1. Как было показано выше, передайте `Intent` с дополнительным параметром в `startService()`, который затем будет обработан в `onStartCommand()` и фактически служба вызовет `stopSelf()`. И, если к службе не привязаны никакие другие компоненты, это вызовет `onDestroy()` и служба завершит свою работу.
2. Вы также можете создать явный `Intent` (указывая на класс службы) и передать его в метод `stopService()`, который вызовет `stopSelf()` и, затем, `onDestroy()` аналогично п.1.
Вот несколько примеров остановки службы из `Activity`:
```
public class MyActivity extends Activity{
void stopService1(){
stopService(new MyIntentBuilder(this).build());
}
void stopService2(){
startService(new MyIntentBuilder(this)
.setCommand(Command.STOP).build());
}
}
```
И вот код в вашей службе, который будет обрабатывать эти запросы (при условии, что ваша запущенная служба находится на переднем плане):
```
public class MyService extends Service{
private void stopCommand(){
stopForeground(true);
stopSelf();
}
}
```
### Привязанные службы
В отличие от запущенных служб, привязанные службы позволяют установить соединение между компонентом Android, привязанным к службе, и службой. Это соединение предоставляется реализацией интерфейса `IBinder`, который определяет методы для взаимодействия со службой. Простым примером этого может быть реализация привязанной службы в одном процессе с клиентом (т.е. в рамках вашего собственного приложения). В этом случае Java-объект, подкласс `Binder`, передается клиенту, который может использовать его для вызова методов службы.
В более сложных сценариях, когда необходимо, чтобы интерфейс службы был доступен для разных процессов, для предоставления клиенту интерфейса службы следует воспользоваться объектом `Messenger` (является ссылкой на объект `Handler`, который получает обратный вызов для каждого вызова от клиента), благодаря чему со службой можно взаимодействовать с помощью объектов `Message`. Объект `Messenger` фактически основан на [AIDL](https://developer.android.com/guide/components/aidl.html) (Android Interface Definition Language). `Messenger` создает очередь из всех запросов клиентов в рамках одного потока, поэтому служба одновременно получает только один запрос. Если необходимо, чтобы служба обрабатывала одновременно сразу несколько запросов, можно использовать AIDL напрямую.
Отличия между привязанной и запущенной службами:
1. У клиентского компонента нет соединения с запущенной службой. Он просто использует объекты `Intent` посредством `startService()` или `stopService()`, которые обрабатываются службой в методе `onStartCommand()`.
2. Когда клиентский компонент (`Activity`, `Fragment` или другая служба) соединяются с привязанной службой, они получают реализацию `IBinder`, посредством которой они могут вызывать методы у привязанной службы.
В любом случае, когда службе (привязанной или запущенной) необходимо отправлять сообщения привязанному клиенту, ей следует использовать что-то вроде [`LocalBroadcastManager`](https://developer.android.com/reference/android/support/v4/content/LocalBroadcastManager.html) (в том случае, если клиент и служба работают в одном процессе). Привязанные службы обычно не подключаются к привязанному клиентскому компоненту напрямую.
### bindService() и onCreate()
Для того, чтобы клиентский компонент стал привязанным к службе, необходимо вызвать `bindService()` с явным `Intent`, как и в случае с запущенной службой.
Пример:
```
public class MyActivity extends Activity{
void bind(){
bindService(
new MyIntentBuilder(this).build(),
mServiceConnection,
BIND_AUTO_CREATE);
}
}
```
`BIND_AUTO_CREATE` это наиболее часто встречающийся флаг в случае вызова `bindService()`. Существуют и другие флаги (например, `BIND_DEBUG_UNBIND` или `BIND_NOT_FOREGROUND`). В случае `BIND_AUTO_CREATE` у привязанной службы вызывается `onCreate()`, если служба до этого еще не была создана. Фактически это означает, что служба создается в момент первой привязки к ней.
Как только вызывается `bindService()`, службе необходимо реагировать на запрос клиента и предоставить ему экземпляр `IBinder`, посредством которого клиент сможет вызывать методы привязанной службы. В примере выше, это реализуется с помощью ссылки `mServiceConnection`. Это обратный вызов (callback) `ServiceConnection`, который привязанная служба будет использовать для уведомления клиента о завершении привязки. Он также позволит клиенту узнать о разрыве соединения со службой.
Другими словами, привязка выполняется асинхронно. `bindService()` возвращается сразу же и *не* возвращает клиенту объект `IBinder`. Для получения объекта `IBinder` клиенту необходимо создать экземпляр `ServiceConnection` и передать его в метод `bindService()`. Интерфейс `ServiceConnection` включает метод обратного вызова, который система использует для того, чтобы выдать объект `IBinder`.
Ниже приведен пример реализации `ServiceConnection`:
```
public class MyActivity extends Activity{
private ServiceConnection mServiceConnection =
new ServiceConnection(){
public void onServiceConnected(
ComponentName cName, IBinder service){
MyBinder binder = (MyService.MyBinder) service;
mService = binder.getService();
// Get a reference to the Bound Service object.
mServiceBound = true;
}
public void onServiceDisconnected(ComponentName cName){
mServiceBound= false;
}
};
}
```
### Привязка службы
Давайте посмотрим, что происходит на стороне привязанной службы, когда клиент вызывает `bindService(Intent)`.
В привязанной службе вы должны реализовать метод `onBind()`, для получения клиентом экземпляра `IBinder`. Метод 'onBind()' будет вызван только один раз, при первой привязке клиента. Для последующих клиентов, система выдаст такой же экземпляр `IBinder`:
```
public class MyService extends Service{
public IBinder onBind(Intent intent){
if (mBinder == null){
mBinder = new MyBinder();
}
return mBinder;
}
}
```
Объект `IBinder` обеспечивает программный интерфейс, с помощью которого клиенты могут взаимодействовать со службой. Как говорилось выше, самый простой способ реализации `IBinder` — это расширение класса `Binder`, экземпляр которого возвращается из метода `onBind()`:
```
public class MyService extends Service{
public class MyBinder extends android.os.Binder {
MyService getService(){
// Simply return a reference to this instance
//of the Service.
return MyService.this;
}
}
}
```
В примере выше, мы просто используем метод `getService()`, который просто возвращает Java-объект привязанной службы клиентскому компоненту. Ссылаясь на этот экземпляр `IBinder`, клиент может вызывать публичные методы у привязанной службы напрямую. Обратите внимание, что эти методы выполняются в клиентском потоке. И в случае `Activity` или `Fragment` эти методы будут выполняться в главном потоке. Поэтому стоит быть осторожным с методами в привязанной службе, которые могут блокировать поток или могут стать причиной ANR.
### Отвязка от службы и вызов onDestroy()
Чтобы отвязаться от привязанной службы, клиент просто вызывает `unbindService(mServiceConnection)`. Затем система вызовет `onUnbind()` в самой службе. И, если у привязанной службы больше нет клиентов, и также, если, служба не является запущенной службой, то система вызывает `onDestroy`.
Вот как выглядит вызов `unbindService()` в клиентском компоненте:
```
public class MyActivity extends Activity{
protected void onStop(){
if (mServiceBound){
unbindService(mServiceConnection);
mServiceBound = false;
}
}
}
```
В коде выше, метод `onStop()` в `Activity` переопределен для вызова `unbindService()`. В зависимости от требований UX к приложению ваш клиентский компонент может привязываться к службе и отвязываться от нее в методах `onStart()` и `onStop()` соответственно, или в любых других методах жизненного цикла клиентских компонентов на ваше усмотрение.
Вот пример как может выглядеть `onUnbind()` в коде привязанной службы:
```
public class MyService extends Service{
public boolean onUnbind(Intent i){
return false;
}
}
```
Обычно вы вернете `false`. Но, если вернуть `true`, то при привязке следующего клиента к службе вместо `onBind()` будет вызван метод `onRebind()`.
### Привязанные и запущенные службы одновременно
Бывают ситуации, когда вам могут пригодиться службы, которые являются запущенными и вместе с тем могут допускать привязку. В предыдущих разделах, мы показали особенности работы каждого из видов служб. И уже из этих особенностей можно понять, что создание привязанных и запущенных служб одновременно необходимо для реализации особого поведения в момент начала работы со службой и при завершении работы с ней.
Если служба не запущена, то клиент, который хочет привязаться к ней, вызовет `onCreate()` у службы. Если служба уже запущена, этот метод не вызывается. С другой стороны, если клиент отвязывается от службы и при этом служба не запущенная, то вызывается `onDestroy()` и служба уничтожается.
Вы можете запустить службу путем вызова метода startService(), вывести ее на передний план и показывать постоянное уведомление. Таким образом, вы реализуете все, что мы говорили о создании запущенных служб. Но кроме того, вы можете реализовать методы, которые позволят клиентам привязываться к службе, с помощью вызова метода `bindService()`. Особенность такой ''двойной" службы в том, что даже при отвязке всех клиентов, служба продолжает свою работу и выполняется до тех пор, пока сама не остановит себя с помощью метода `stopSelf()`, или до тех пор, пока другой компонент не вызовет метод `stopService()`.
### Переход в запущенное состояние
Поскольку клиент, привязываясь к службе, не переведет ее в запущенное состояние, то для привязанных и запущенных служб одновременно, требуется чтобы служба переходила в запущенное состояние самостоятельно. Вот, как можно это сделать с учетом Android O:
**много кода**
```
public class MyService extends Service{
private void commandStart() {
if (!mServiceIsStarted) {
moveToStartedState();
return;
}
if (mExecutor == null) {
mTimeRunning_sec = 0;
if (isPreAndroidO()) {
HandleNotifications.PreO.createNotification(this);
} else {
HandleNotifications.O.createNotification(this);
}
mExecutor = Executors
.newSingleThreadScheduledExecutor();
Runnable runnable =
new Runnable() {
@Override
public void run() {
recurringTask();
}
};
mExecutor.scheduleWithFixedDelay(
runnable, DELAY_INITIAL,
DELAY_RECURRING, DELAY_UNIT);
d(TAG, "commandStart: starting executor");
} else {
d(TAG, "commandStart: do nothing");
}
}
@TargetApi(Build.VERSION_CODES.O)
private void moveToStartedState() {
Intent intent = new MyIntentBuilder(this)
.setCommand(Command.START).build();
if (isPreAndroidO()) {
Log.d(TAG, "moveToStartedState: on N/lower");
startService(intent);
} else {
Log.d(TAG, "moveToStartedState: on O");
startForegroundService(intent);
}
}
@Override
public int onStartCommand(
Intent intent, int flags, int startId) {
boolean containsCommand = MyIntentBuilder
.containsCommand(intent);
d(TAG,
String.format(
"Service in [%s] state. id: [%d]. startId: [%d]",
mServiceIsStarted ? "STARTED" : "NOT STARTED",
containsCommand ?
MyIntentBuilder.getCommand(intent) : "N/A",
startId));
mServiceIsStarted = true;
routeIntentToCommand(intent);
return START_NOT_STICKY;
}
private void routeIntentToCommand(Intent intent) {
if (intent != null) {
// process command
if (containsCommand(intent)) {
processCommand(MyIntentBuilder.getCommand(intent));
}
// process message
if (MyIntentBuilder.containsMessage(intent)) {
processMessage(MyIntentBuilder.getMessage(intent));
}
}
}
private void processMessage(String message) {
try {
d(TAG, String.format("doMessage: message from client: '%s'", message));
} catch (Exception e) {
e(TAG, "processMessage: exception", e);
}
}
private void processCommand(int command) {
try {
switch (command) {
case Command.START:
commandStart();
break;
case Command.STOP:
commandStop();
break;
}
} catch (Exception e) {
e(TAG, "processCommand: exception", e);
}
}
/*...*/
}
```
В коде под спойлером:
1. Метод `commandStart()` может быть вызван клиентом, который привязывается к службе.
2. Или `commandStart()` вызывается через методы `startService()` или `startForegroundService()` (для Android O).
Но, перед фактическим исполнением работы, служба сначала переводит себя в запущенное состояние.
Итак, когда клиент привязывается к службе, вызывается `commandStart()`. Служба еще не запущена. Давайте посмотрим на код, и увидим, что случится:
1. Если служба привязывается к клиенту, то она не запущена (и в`mServiceStarted` содержится `false`)
2. В этом случае вызывается `moveToStarted()` и там создается явный `Intent` с Extras `Command.START`, и далее вызывается `startService()` или `startForegroundService()`.
3. Это приводит к вызову `onStartCommand()`, который опять вызывает `commandStart()`.
4. Но теперь в `commandStart()` значение переменной `mServiceIsStarted` равняется `true`, и поэтому метод `commandStart()` выполняет свое прямое предназначение, т.е. запускает полезную работу службы.
### Завершение работы службы и отвязывание
Если служба не в запущенном состоянии и клиентский компонент отвязывается от службы, то служба уничтожается и вызывается `onDestroy()`
Но если она в запущенном состоянии она не уничтожается. И она будет "убита", только если запущенное состояние будет остановлено (через вызов `stopService(Intent)` или вызов `startService(Intent)` c Extras в `Intent`, которые говорят о намерении остановить службу, например `Command.STOP`).
Вот диаграмма, в которой суммируются состояния службы и переходы между ними для запущенной и привязанной службы одновременно:
### Примеры
Реализацию большинства из того, о чем говорилось в статье, можно глянуть на [GitHub](https://github.com/r3bl-alliance/stay-awake-app).
Это небольшая утилита для Android O и N, которая держит телефон в активном состоянии, если он на зарядке. | https://habr.com/ru/post/349102/ | null | ru | null |
# Особенности работы с API Google Drive
Недавно нам нужно было сделать простое приложение для Google Drive. Приложение должно было формировать список пользователей, на которых расшарены документы в указанной папке с возможностью редактирования. Задача, в принципе, простая, поэтому недолго думая развернул болванку проекта на angularJS и начал кодить. Гугл, подумал я, это же большая компания, у него должен быть понятный и стабильный API и я сделаю это за пару дней.
Я был слишком наивен.
#### Авторизация
Приложение подразумевало отсутствие серверной части (только клиентский js), поэтому для авторизации и идентификации было решено использовать авторизацию гугла. Авторизация — это же просто! Но не тут-то было. Для идентификации пользователя между экранами приложения решил хранить объект авторизации, который возвращается методом gapi.auth.getToken(). Метод штатный, все как бы для этого и создано. Но при сериализации этого объекта постоянно возникала забавная ошибка «Permission denied to access property 'toJSON'». Ошибка «интуитивно» понятная, поэтому потратил на нее пол дня. Оказалось, что в объекте, который возвращает эта функция, есть циклическая ссылка на самого себя. Циклическая ссылка содержалась в переменной g-oauth-window. Поэтому простой код решил эту проблему:
```
var oAuthObj = gapi.auth.getToken();
oAuthObj['g-oauth-window'] = null;
$window.localStorage.setItem('googlerSession', JSON.stringify(oAuthObj));
```
Следующая проблема при клиентской авторизации — это возобновление клиентской сессии. Сессия аутентификации при использовании только клиентской аутентификации сохраняется на 1 час. Но как возобновить ее или продлить — не понятно. Мои танцы с бубном с повторной авторизацией и прочим шаманством не смогли мне помочь, поэтому до сих пор клиентская часть у меня авторизует пользователя на 1 час. Для удобства вывел в верхнее меню время, оставшееся до инвалидации сессии. В принципе, для этого инструмента 1 часа вполне хватает.
#### Работа с документами
И тут не обошлось без проблем. Первая незадача, с которой столкнулся — как получить внешнюю ссылку на документ? Если с обычными документами все хорошо — она берется из свойства alternateLink объекта файла, то с папкой какая-то магия. Любая папка возвращается в виде ссылки на странный интерфейс folderview, который я до этого никогда не видел. Гугление ни к чему не привело, поэтому пришлось исправлять это некрасивым кодом:
```
var fileLink = fileObject.alternateLink;
if (fileLink.indexOf("folderview") != -1) {
fileLink = fileLink.replace("folderview?id=", "#folders/");
fileLink = fileLink.replace("&usp=drivesdk", "");
fileLink = fileLink.replace("docs.google.com", "drive.google.com");
}
```
#### Права на документы
Весь массив владельцев документа я строил относительно userId, который отдает гугл. Я думал, он уникальный и дает полное понимание, что это один и тот же пользователь. Но это оказалось не так. Согласно документации drive.permissions.list, в качестве id возвращается идентификатор пользователя ([пруфлинк](https://developers.google.com/drive/v2/reference/permissions#resource)). Но в реальности оказалось, что это не тот идентификатор, который я ищу. Почему так — для меня до сих пор остается загадкой. Поэтому для идентификации и «узнавания» пользователя в списке владельцев я использовал email. Но это еще пол беды.
Такая путаница с идентификаторами приводит к другому забавному багу. Если текущий авторизованный пользователь является читателем документа, то permission.list не возвратит список прав доступа. Следовательно, чтобы показать, что я читатель — я использую информацию из userInfo текущего пользователя. А если этот же человек потом будет в permission.list другого файла, например, владелец документа, то у него будет совсем другой идентификатор. Это приводит к тому, что в списке пользователей текущий авторизованный пользователь может быть продублирован.
Вывод: идентификатору пользователя доверять нельзя, тк он может меняться. Для идентификации пользователя лучше использовать email, хотя, теоретически он может отсутствовать. Например, если документ расшарен на корпоративный домен, то в этом случае email не будет, так как он расшарен на всех пользователей, которые принадлежат этому домену.
Была еще пара мелочей, которые уже вылетели из головы. Например, в объекте с информацией о файле не было нескольких переменных описанных в документации. Честно говоря уже не помню каких, но это уже мелочи.
**P.S.** Что из этого всего получилось, можно наблюдать [здесь](http://googler.chililab.pro). Если есть идеи, как дополнить сервис, пишите в комментариях — реализую.
**P.P.S.** Если вы знаете красивое решение описанных в статье проблем, напишите в личку или в комментариях. Думаю, я не первый, кто столкнулся с этими проблемами. | https://habr.com/ru/post/241209/ | null | ru | null |
# Автоматизация go get — больше не нужно запоминать названия библиотек
Всем привет! Когда я начинал писать на Go, я стартовал и забрасывал с десяток мелких пет-проектов. Большинство из них использовали [fasthttp](https://github.com/valyala/fasthttp) и его [fasthttp/router](https://github.com/fasthttp/router). И пакет [testify](https://github.com/stretchr/testify) - обязательно. Позже пришло время творить уже бизнес-сервисы внутри своей компании, количество библиотек росло. И каждый раз, когда я создавал новый репозиторий, первое, что мне надо было сделать - добавить библиотеки, которые я буду использовать. Для этого использовался `go get`, ведь в руках у меня уже go 1.11 и нужно формировать `go.mod`. Обычно нужные библиотеки копируются из `go.mod` соседнего проекта. Но копипаст - не наш метод!
Да, я точно помню, в тот день я в очередной раз вспоминал как правильно пишется github.com/valyala/fasthttp и даже почти не ошибся - всего лишь пропустил букву t в слове github. И я понял, что пришло время автоматизации ... `go get`. Гугление похожего инструмента на тот момент ничего не дало, так что решил делать что-то своё. Инструмент назовём, скажем, `gost` - Go Start
Что хотелось в первую очередь:
1. Не хочу запоминать названия библиотек, хочу иметь для них синонимы.
2. Есть набор библиотек, которые ставятся сразу пачкой, бандлом - например fasthttp и роутер для него. Или gorm и его драйвер для PostgreSQL - такое хочется ставить одним синонимом.
3. Хочу указывать набор альясов в одной команде, пусть тащит их скопом. Например: `gost webserver gormpg prometheus cli`.
4. Конфигурировать хочу в YAML.
5. Не буду ничего велосипедить, моя задача вызывать `go get`.
6. Хочу иметь настройки по умолчанию, вшитые в бинарник.
7. Для тестирования и отладки хочу иметь режим soft launch - когда на самом деле утилита ничего не делает, а только покажет список команд, которые вызовет.
Будем делать всё максимально просто - есть конфиг (так как начинал уже во времена go 1.16, то это просто embedded YAML), в нем есть список альясов для библиотек и бандлов. Читаем командную строку, если находим альяс - подставляем его значение и запускаем обычный `go get`.
Если включить режим soft launch выглядеть это может, например, так:
```
gost mod webserver -s
Use soft Launch
/usr/local/go/bin/go get -u github.com/valyala/fasthttp
/usr/local/go/bin/go get -u github.com/fasthttp/router
/usr/local/go/bin/go get -u github.com/stretchr/testify
/usr/local/go/bin/go get -u github.com/satmaelstorm/envviper
/usr/local/go/bin/go mod download
```
Ок, у меня заработало и мне, в целом, всё нравится. Но есть же другие люди, им мои альясы, а тем более мои наборы библиотек (бандлы) могут не подходить. Надо дать возможность заменять зашитый конфиг внешним.
Сказано - сделано. В первой итерации почему-то в голову пришло заменять конфиг из командной строки:
```
gost mod --aliases=aliases.yaml webserver pgsql
```
Хм. Что-то тут не так. Это же неудобно! Каждый раз надо указывать этот параметр. Давайте определим переменную окружения, указывающую на нужный файл, который и будем читать при каждом запуске утилиты:
```
export GOST_ALIASES="/home/user/gost.aliases.yaml"
```
Вот теперь удобно.
Ну а что, если базовые настройки в целом устраивают, но хочется что-то перезаписать или добавить что-то своё? Тогда определим еще одну переменную окружения, которая укажет на файл с добавлениями\заменами относительно базовой конфигурации (как зашитой, так и переопределенной):
```
export GOST_ADD_ALIASES="/home/user/gost.aliases.yaml"
```
Теперь у нас есть всё, чтобы показать это другим разработчикам на Go, достаточно им выполнить у себя:
```
go install github.com/satmaelstorm/gost@latest
```
Репозиторий утилиты для интересующихся [тут](https://github.com/satmaelstorm/gost), в нем можно найти и [зашитый пример конфигурации альясов](https://github.com/satmaelstorm/gost/blob/master/app/gost.aliases.yaml). Там же чуть более подробный README - так как возможностей чуть-чуть больше, чем я описал. Например, я показывал вам саб-команду mod, а есть еще start.
P.S. Да, утилиту я сделал давно и давно ей пользуюсь. Только сейчас донес ее до сообщества. Готов к доработкам по запросам коллег. | https://habr.com/ru/post/713482/ | null | ru | null |
# OpenSceneGraph: Основы работы с текстурами
Введение
========
Мы уже рассматривали [пример](https://habr.com/ru/post/430212/), где раскрашивали квадрат во все цвета радуги. Тем не менее существует и другая технология, а именно применение к трехмерной геометрии так называемой *текстурной карты* или просто текстуры — растрового двухмерного изображения. При этом воздействие оказывается не на вершины геометрии, а изменяются данные всех пикселей, получаемых при растеризации сцены. Такой прием позволяет существенно увеличить реалистичность и детальность конечного изображения.
OSG поддерживает несколько текстурных атрибутов и режимов текстурирования. Но, перед тем как говорить о текстурах, поговорим о том, как в OSG оперируют с растровыми изображениями. Для работы с растровыми изображениями предусмотрен специальный класс — osg::Image, хранящий внутри себя данные изображения, предназначенных, в конечном итоге, для текстурирования объекта.
1. Представление данных растровых изображений. Класс osg::Image
===============================================================
Лучшим способом загрузки изображения с диска служит применение вызова osgDB::readImageFile(). Оно очень похож на уже набивший нам оскомину вызов osg::readNodeFile(). Если у нас есть битмэп с именем picture.bmp, то его загрузка будет выглядеть так
```
osg::ref_ptr image = osgDB::readImageFile("picture.bmp");
```
Если изображение загружено корректно, то указатель будет валидным, в противном случае функция возвратит NULL. После загрузки мы можем получить информацию об изображении, используя следующие публичные методы
1. t(), s() и r() — возвращают ширину, высоту и глубину изображения.
2. data() — возвращает указатель типа unsigned char\* на "сырые" данные изображения. Через данный указатель разработчик может непосредственно воздействовать на данные изображения. Получить представление о формате данных изображения можно, используя методы getPixalFormat() и getDataType(). Возвращаемые ими значения эквивалентны параметрам формата и типа функций OpenGL glTexImage\*(). Например, если картинка имеет формат пикселя GL\_RGB и тип данный GL\_UNSIGNED\_BYTE то используются три независимых элемента (беззнаковых байта) для представления RGB-компонент цвета
Можно создать новый объект изображения и выделить под него память
```
osg::ref_ptr image = new osg::Image;
image->allocateImage(s, t, r, GL\_RGB, GL\_UNSIGNED\_BYTE);
unsigned char \*ptr = image->data();
// Далее выполняем с буфером данных изображения любые операции
```
Здесь s, t, r — размеры изображения; GL\_RGB задает формат пикселя, а GL\_UNSIGNED\_BYTE — тип данных для описания одной цветовой компоненты. Внутренний буфер данных нужного размера выделяется в памяти и автоматически уничтожается, если на данное изображение нет ни одной ссылки.
Система плагинов OSG поддерживает загрузку чуть ли не всех популярных форматов изображений: \*.jpg, \*.bmp, \*.png, \*.tif и так далее. Этот список нетрудно расширить, написав собственный плагин, но это тема для отдельной беседы.
2. Основы текстурирования
=========================
Для наложения текстуры на трехмерную модель необходимо выполнить ряд шагов:
1. Задать геометрическому объекту текстурные координаты вершин (в среде трехмерных дизайнеров это называется UV-разверткой).
2. Создать объект атрибута текстуры для 1D, 2D, 3D или кубической текстуры.
3. Задать одно или несколько изображения для атрибута текстуры.
4. Прикрепить текстурный атрибут и режим к набору состояний, применяемому к отрисовываемому объекту.
OSG определяет класс osg::Texture, инкапсулирующий все виды текстур. От него наследуются подклассы osg::Texture1D, osg::Texture2D, osg::Texture3D и osg::TextureCubeMap, которые представляю различные техники текстурирования, принятые в OpenGL.
Наиболее употребимый метод класса osg::Texture это setImage(), задающий изображение, используемое в текстуре, например
```
osg::ref_ptr image = osgDB::readImageFile("picture.bmp");
osg::ref\_ptr texture = new osg::Texture2D;
texture->setImage(image.get());
```
или, можно передать объект изображения непосредственно в конструктор класса текстуры
```
osg::ref_ptr image = osgDB::readImageFile("picture.bmp");
osg::ref\_ptr texture = new osg::Texture2D(image.get());
```
Изображение можно получить обратно из объекта текстуры вызвав метод getImage().
Другим важным моментом является задание текстурных координат для каждой вершины в объекта osg::Geometry. Передача этих координат происходит через массив osg::Vec2Array и osg::Vec3Array вызовом метода setTexCoordArray().
После задания текстурных координат мы должны установить номер текстурного слота (юнит), так как OSG поддерживает наложение нескольких текстур на одну и ту же геометрию. При использовании одной текстуры номер юнита всегда равен 0. Например, следующий код иллюстрирует задание текстурных координат для юнита 0 геометрии
```
osf::ref_ptr texcoord = new osg::Vec2Array;
texcoord->push\_back( osg::Vec2(...) );
...
geom->setTexCoordArray(0, texcoord.get());
```
После этого мы можем добавить атрибут текстуры в набор состояний, автоматически включая соответствующий режим текстурирование (в нашем примере GL\_TEXTURE\_2D) и применить атрибут к геометрии или узлу, содержащему данную геометрию
```
geom->getOrCreateStateSet()->setTextureAttributeAndModes(texture.get());
```
Обращаем внимание на то, что OpenGL управляет данными изображения в графической памяти видеокарты, но объект osg::Image вместе с теми же данными располагается в системной памяти. В результате мы столкнемся с тем, что у нас хранятся два экземпляра одних и тех же данных, занимая память процесса. Если данное изображение не используется совместно несколькими атрибутами текстуры, его можно удалить из системной памяти сразу после того как OpenGL перенесет из в память видеоадаптера. Для включения этой функции класс osg::Texture предоставляет соответствующий метод
```
texture->setUnRefImageDataAfterApply( true );
```
3. Загружаем и применяем 2D-текстуру
====================================
Чаще всего используется техника 2D-текстурирования — накладывание двухмерного изображения (или изображений) на грани трехмерной поверхности. Рассмотрим простейший пример наложения одной текстуры на четырехугольный полигон
**Пример texture****main.h**
```
#ifndef MAIN_H
#define MAIN_H
#include
#include
#include
#include
#endif
```
**main.cpp**
```
#include "main.h"
int main(int argc, char *argv[])
{
(void) argc; (void) argv;
osg::ref_ptr vertices = new osg::Vec3Array;
vertices->push\_back( osg::Vec3(-0.5f, 0.0f, -0.5f) );
vertices->push\_back( osg::Vec3( 0.5f, 0.0f, -0.5f) );
vertices->push\_back( osg::Vec3( 0.5f, 0.0f, 0.5f) );
vertices->push\_back( osg::Vec3(-0.5f, 0.0f, 0.5f) );
osg::ref\_ptr normals = new osg::Vec3Array;
normals->push\_back( osg::Vec3(0.0f, -1.0f, 0.0f) );
osg::ref\_ptr texcoords = new osg::Vec2Array;
texcoords->push\_back( osg::Vec2(0.0f, 0.0f) );
texcoords->push\_back( osg::Vec2(0.0f, 1.0f) );
texcoords->push\_back( osg::Vec2(1.0f, 1.0f) );
texcoords->push\_back( osg::Vec2(1.0f, 0.0f) );
osg::ref\_ptr quad = new osg::Geometry;
quad->setVertexArray(vertices.get());
quad->setNormalArray(normals.get());
quad->setNormalBinding(osg::Geometry::BIND\_OVERALL);
quad->setTexCoordArray(0, texcoords.get());
quad->addPrimitiveSet( new osg::DrawArrays(GL\_QUADS, 0, 4) );
osg::ref\_ptr texture = new osg::Texture2D;
osg::ref\_ptr image = osgDB::readImageFile("../data/Images/lz.rgb");
texture->setImage(image.get());
osg::ref\_ptr root = new osg::Geode;
root->addDrawable(quad.get());
root->getOrCreateStateSet()->setTextureAttributeAndModes(0, texture.get());
osgViewer::Viewer viewer;
viewer.setSceneData(root.get());
return viewer.run();
}
```
Создаем массив вершин и нормалей к грани
```
osg::ref_ptr vertices = new osg::Vec3Array;
vertices->push\_back( osg::Vec3(-0.5f, 0.0f, -0.5f) );
vertices->push\_back( osg::Vec3( 0.5f, 0.0f, -0.5f) );
vertices->push\_back( osg::Vec3( 0.5f, 0.0f, 0.5f) );
vertices->push\_back( osg::Vec3(-0.5f, 0.0f, 0.5f) );
osg::ref\_ptr normals = new osg::Vec3Array;
normals->push\_back( osg::Vec3(0.0f, -1.0f, 0.0f) );
```
Создаем массив текстурных координат
```
osg::ref_ptr texcoords = new osg::Vec2Array;
texcoords->push\_back( osg::Vec2(0.0f, 0.0f) );
texcoords->push\_back( osg::Vec2(0.0f, 1.0f) );
texcoords->push\_back( osg::Vec2(1.0f, 1.0f) );
texcoords->push\_back( osg::Vec2(1.0f, 0.0f) );
```
Смысл заключается в том, что каждой вершине трехмерной модели соответствует точка на двухмерной текстуре, причем координаты точки на текстуре являются относительными — они нормируются к фактической ширине и высоте изображения. Мы хотим натянуть на квадрат всю загружаемую картинку, соответственно углам квадрата будут соответствовать точки текстуры (0, 0), (0, 1), (1, 1) и (1, 0). Порядок следования вершин в массиве вершин, должен совпадать с порядком текстурных вершин.
Далее создаем квадрат, присваивая геометрии массив вершин и массив нормалей
```
osg::ref_ptr quad = new osg::Geometry;
quad->setVertexArray(vertices.get());
quad->setNormalArray(normals.get());
quad->setNormalBinding(osg::Geometry::BIND\_OVERALL);
quad->setTexCoordArray(0, texcoords.get());
quad->addPrimitiveSet( new osg::DrawArrays(GL\_QUADS, 0, 4) );
```
Создаем объект текстуры и загружаем изображение, используемое для нее
```
osg::ref_ptr texture = new osg::Texture2D;
osg::ref\_ptr image = osgDB::readImageFile("../data/Images/lz.rgb");
texture->setImage(image.get());
```
Создаем корневой узел сцены и помещаем туда созданную нами геометрию
```
osg::ref_ptr root = new osg::Geode;
root->addDrawable(quad.get());
```
и, наконец, применяем атрибут текстуры к узлу, в который помещена геометрия
```
root->getOrCreateStateSet()->setTextureAttributeAndModes(0, texture.get());
```
Класс osg::Texture2D определяет, являются ли размеры изображения текстуры кратными степеням двойки (например 64х64 или 256х512) автоматически масштабируя неподходящие по размеру изображения, фактически применяя функцию gluScaleImage() OpenGL. Существует метод setResizeNonPowerOfTwoHint(), определяющий, нужно или нет изменять размер изображения. Некоторые видеокарты требуют кратность размера изображения степени двойки, в то время как класс osg::Texture2D поддерживает работу с произвольным размером текстуры.
Кое-что о режиме наложения текстур
==================================
Как мы уже говорили, текстурные координаты нормированы от 0 до 1. Точке (0, 0) соответствует левый верхний угол изображения, а точке (1, 1) — правый нижний. Что будет, если задать текстурные координаты больше единицы?
По-умолчанию, в OpenGL, как и в OSG текстура будет повторятся в направлении оси, значение текстурной координаты превысит единицу. Этот прием часто используют, например чтобы создать модель длинной кирпичной стены, использую небольшую текстуру, повторяя её наложение многократно как по ширине, так и по высоте.
Этим поведением можно управлять через метод setWrap() класса osg::Texture. В качестве первого параметра метод принимает идентификатор оси, к которой следует применить режим наложения, передаваемый в качестве второго параметра, например
```
// Повторять текстуру по оси s
texture->setWrap( osg::Texture::WRAP_S, osg::Texture::REPEAT );
// Повторять текстуру по оси r
texture->setWrap( osg::Texture::WRAP_R, osg::Texture::REPEAT );
```
Данный код явно указывает движку повторять текстуру по осям s и r, если значения текстурных координат превышают 1. Полный список режимом наложения текстур:
1. REPEAT — повторять текстуру.
2. MIRROR — повторять текстуру, отразив зеркально.
3. CLAMP\_TO\_EDGE — координаты, выходящие за пределы от 0 до 1 привязываются к соответствующему краю текстуры.
4. CLAMP\_TO\_BORDER — координаты, выходящие за пределы от 0 до 1 будут давать установленный пользователем цвет границы.
4. Рендеринг в текстуру
=======================
Техника рендеринга в текстуру позволяет разработчику создать текстуру, основанную на некоторой трехмерной подсцене или модели и применить её к поверхности на основной сцене. Подобную технологию часто называют "запеканием" текстуры.
Для динамического запекания текстуры необходимо выполнить три шага:
1. Создать объект текстуры для рендеринга в неё.
2. Отрендерить сцену в текстуру.
3. Использовать полученную текстуру по назначению.
Мы должны создать пустой текстурный объект. OSG позволяет создать пустую текстуру заданного размера. Метод setTextureSize() позволяет задавать ширину и высоту текстуры, а так же ещё глубину в качестве дополнительного параметра (для 3D-текстур).
Для выполнения рендеринга в текстуру её следует присоединить к объекту камеры путем вызова метода attach(), принимающего в качестве аргумента объект текстуры. Кроме того данный метод принимает аргумент, указывающий, какую часть буфера кадра следует рендерить в данную текстуру. Например, для передачи буфера цвета в текстуру следует выполнить следующий код
```
camera->attach( osg::Camera::COLOR_BUFFER, texture.get() );
```
К другим, доступным для рендеринга частям кадрового буфера, относятся буфер глубины DEPTH\_BUFFER, буфер трафарета STENCIL\_BUFFER дополнительные буферы цвета от COLOR\_BUFFER0 до COLOR\_BUFFER15. Наличие дополнительных буферов цвета и их количество определяется моделью видеокарты.
Кроме того, для камеры, выполняющей рендеринг в текстуру следует установить параметры матрицы проекции и вьюпорта, размер которого соотвествует размеру текстуры. Текстура будет обновляться в процессе прорисовки каждого кадра. Необходимо учитывать, что основная камера не должна использоваться для рендеринга в текстуру, так как она обеспечивает рендеринг основной сцены и вы просто получите черный экран. Это требование может не выполнятся только тогда, когда вы выполняете внеэкранный рендеринг.
5. Пример реализации рендеринга в текстуру
==========================================
Для демонстрации техники рендеринга в текстуру реализуем такую задачку: создадим квадрат, натянем на него квадратную же текстуру, а в текстуру выполним рендеринг анимированной сцены, конечно же с полюбившейся нам цессной. Программа, реализующая пример вышла достаточно объемной. Однако всё равно приведу её полный исходный текст.
**Пример texrender****main.h**
```
#ifndef MAIN_H
#define MAIN_H
#include
#include
#include
#include
#include
#include
#endif
```
**main.cpp**
```
#include "main.h"
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
osg::Geometry *createQuad(const osg::Vec3 &pos, float w, float h)
{
osg::ref_ptr vertices = new osg::Vec3Array;
vertices->push\_back( pos + osg::Vec3( w / 2, 0.0f, -h / 2) );
vertices->push\_back( pos + osg::Vec3( w / 2, 0.0f, h / 2) );
vertices->push\_back( pos + osg::Vec3(-w / 2, 0.0f, h / 2) );
vertices->push\_back( pos + osg::Vec3(-w / 2, 0.0f, -h / 2) );
osg::ref\_ptr normals = new osg::Vec3Array;
normals->push\_back(osg::Vec3(0.0f, -1.0f, 0.0f));
osg::ref\_ptr texcoords = new osg::Vec2Array;
texcoords->push\_back( osg::Vec2(1.0f, 1.0f) );
texcoords->push\_back( osg::Vec2(1.0f, 0.0f) );
texcoords->push\_back( osg::Vec2(0.0f, 0.0f) );
texcoords->push\_back( osg::Vec2(0.0f, 1.0f) );
osg::ref\_ptr quad = new osg::Geometry;
quad->setVertexArray(vertices.get());
quad->setNormalArray(normals.get());
quad->setNormalBinding(osg::Geometry::BIND\_OVERALL);
quad->setTexCoordArray(0, texcoords.get());
quad->addPrimitiveSet(new osg::DrawArrays(GL\_QUADS, 0, 4));
return quad.release();
}
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
int main(int argc, char \*argv[])
{
(void) argc; (void) argv;
osg::ref\_ptr sub\_model = osgDB::readNodeFile("../data/cessna.osg");
osg::ref\_ptr transform1 = new osg::MatrixTransform;
transform1->setMatrix(osg::Matrix::rotate(0.0, osg::Vec3(0.0f, 0.0f, 1.0f)));
transform1->addChild(sub\_model.get());
osg::ref\_ptr model = new osg::Geode;
model->addChild(createQuad(osg::Vec3(0.0f, 0.0f, 0.0f), 2.0f, 2.0f));
int tex\_widht = 1024;
int tex\_height = 1024;
osg::ref\_ptr texture = new osg::Texture2D;
texture->setTextureSize(tex\_widht, tex\_height);
texture->setInternalFormat(GL\_RGBA);
texture->setFilter(osg::Texture2D::MIN\_FILTER, osg::Texture2D::LINEAR);
texture->setFilter(osg::Texture2D::MAG\_FILTER, osg::Texture2D::LINEAR);
model->getOrCreateStateSet()->setTextureAttributeAndModes(0, texture.get());
osg::ref\_ptr camera = new osg::Camera;
camera->setViewport(0, 0, tex\_widht, tex\_height);
camera->setClearColor(osg::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
camera->setClearMask(GL\_COLOR\_BUFFER\_BIT | GL\_DEPTH\_BUFFER\_BIT);
camera->setRenderOrder(osg::Camera::PRE\_RENDER);
camera->setRenderTargetImplementation(osg::Camera::FRAME\_BUFFER\_OBJECT);
camera->attach(osg::Camera::COLOR\_BUFFER, texture.get());
camera->setReferenceFrame(osg::Camera::ABSOLUTE\_RF);
camera->addChild(transform1.get());
osg::ref\_ptr root = new osg::Group;
root->addChild(model.get());
root->addChild(camera.get());
osgViewer::Viewer viewer;
viewer.setSceneData(root.get());
viewer.setCameraManipulator(new osgGA::TrackballManipulator);
viewer.setUpViewOnSingleScreen(0);
camera->setProjectionMatrixAsPerspective(30.0, static\_cast(tex\_widht) / static\_cast(tex\_height), 0.1, 1000.0);
float dist = 100.0f;
float alpha = 10.0f \* 3.14f / 180.0f;
osg::Vec3 eye(0.0f, -dist \* cosf(alpha), dist \* sinf(alpha));
osg::Vec3 center(0.0f, 0.0f, 0.0f);
osg::Vec3 up(0.0f, 0.0f, -1.0f);
camera->setViewMatrixAsLookAt(eye, center, up);
float phi = 0.0f;
float delta = -0.01f;
while (!viewer.done())
{
transform1->setMatrix(osg::Matrix::rotate(static\_cast(phi), osg::Vec3(0.0f, 0.0f, 1.0f)));
viewer.frame();
phi += delta;
}
return 0;
}
```
Для создания квадрата напишем отдельную свободную функцию
```
osg::Geometry *createQuad(const osg::Vec3 &pos, float w, float h)
{
osg::ref_ptr vertices = new osg::Vec3Array;
vertices->push\_back( pos + osg::Vec3( w / 2, 0.0f, -h / 2) );
vertices->push\_back( pos + osg::Vec3( w / 2, 0.0f, h / 2) );
vertices->push\_back( pos + osg::Vec3(-w / 2, 0.0f, h / 2) );
vertices->push\_back( pos + osg::Vec3(-w / 2, 0.0f, -h / 2) );
osg::ref\_ptr normals = new osg::Vec3Array;
normals->push\_back(osg::Vec3(0.0f, -1.0f, 0.0f));
osg::ref\_ptr texcoords = new osg::Vec2Array;
texcoords->push\_back( osg::Vec2(1.0f, 1.0f) );
texcoords->push\_back( osg::Vec2(1.0f, 0.0f) );
texcoords->push\_back( osg::Vec2(0.0f, 0.0f) );
texcoords->push\_back( osg::Vec2(0.0f, 1.0f) );
osg::ref\_ptr quad = new osg::Geometry;
quad->setVertexArray(vertices.get());
quad->setNormalArray(normals.get());
quad->setNormalBinding(osg::Geometry::BIND\_OVERALL);
quad->setTexCoordArray(0, texcoords.get());
quad->addPrimitiveSet(new osg::DrawArrays(GL\_QUADS, 0, 4));
return quad.release();
}
```
Функция принимает на вход позицию центра квадрата и его геометрические размеры. Далее создается массив вершин, массив нормалей и текстурных координат, после чего созданная геометрия возвращается из функции.
В теле основной программы загрузим модельку цессны
```
osg::ref_ptr sub\_model = osgDB::readNodeFile("../data/cessna.osg");
```
Для того чтобы анимировать эту модель, создадим и инициализируем трансформацию поворота вокруг оси Z
```
osg::ref_ptr transform1 = new osg::MatrixTransform;
transform1->setMatrix(osg::Matrix::rotate(0.0, osg::Vec3(0.0f, 0.0f, 1.0f)));
transform1->addChild(sub\_model.get());
```
Теперь создадим модель для основной сцены — квадрат на который будем выполнять рендеринг
```
osg::ref_ptr model = new osg::Geode;
model->addChild(createQuad(osg::Vec3(0.0f, 0.0f, 0.0f), 2.0f, 2.0f));
```
Создаем пустую текстуру для квадрата размером 1024х1024 пикселя с форматом пикселя RGBA (32-битный трехкомпонентный цвет с альфа-каналом)
```
int tex_widht = 1024;
int tex_height = 1024;
osg::ref_ptr texture = new osg::Texture2D;
texture->setTextureSize(tex\_widht, tex\_height);
texture->setInternalFormat(GL\_RGBA);
texture->setFilter(osg::Texture2D::MIN\_FILTER, osg::Texture2D::LINEAR);
texture->setFilter(osg::Texture2D::MAG\_FILTER, osg::Texture2D::LINEAR);
```
Применяем эту текстуру к модели квадрата
```
model->getOrCreateStateSet()->setTextureAttributeAndModes(0, texture.get());
```
Затем создаем камеру, которая будет запекать текстуру
```
osg::ref_ptr camera = new osg::Camera;
camera->setViewport(0, 0, tex\_widht, tex\_height);
camera->setClearColor(osg::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
camera->setClearMask(GL\_COLOR\_BUFFER\_BIT | GL\_DEPTH\_BUFFER\_BIT);
```
Вьюпорт камеры по размеру совпадает с размером текстуры. Кроме того не забываем задать цвет фона при очистке экрана и маску очистки, указывая очищать как буфер цвета, так и буфер глубины. Далее настраиваем камеру на рендеринг в текстуру
```
camera->setRenderOrder(osg::Camera::PRE_RENDER);
camera->setRenderTargetImplementation(osg::Camera::FRAME_BUFFER_OBJECT);
camera->attach(osg::Camera::COLOR_BUFFER, texture.get());
```
Порядок рендеринга PRE\_RENDER указывает на то, что рендеринг этой камерой выполняется до рендеринга в основную сцену. В качестве цели рендеренга указываем FBO и прикрепляем к камере нашу текстуру. Теперь настраиваем камеру на работу в абсолютной системе координат, а в качестве сцены задаем наше поддерево, которое мы желаем рендерить в текстуру: трансформация поворота с прикрепленной к ней моделькой цессны
```
camera->setReferenceFrame(osg::Camera::ABSOLUTE_RF);
camera->addChild(transform1.get());
```
Создаем корневой групповой узел, добавляя в него основную модель (квадрат) и камеру обрабатывающую текстуру
```
osg::ref_ptr root = new osg::Group;
root->addChild(model.get());
root->addChild(camera.get());
```
Создаем и настраиваем вьювер
```
osgViewer::Viewer viewer;
viewer.setSceneData(root.get());
viewer.setCameraManipulator(new osgGA::TrackballManipulator);
viewer.setUpViewOnSingleScreen(0);
```
Настраиваем матрицу проекции для камеры — перспективная проекция через параметры пирамиды отсечения
```
camera->setProjectionMatrixAsPerspective(30.0, static_cast(tex\_widht) / static\_cast(tex\_height), 0.1, 1000.0);
```
Настраиваем матрицу вида, задающую положение камеры в пространстве по отношению к началу координат подсцены с цессной
```
float dist = 100.0f;
float alpha = 10.0f * 3.14f / 180.0f;
osg::Vec3 eye(0.0f, -dist * cosf(alpha), dist * sinf(alpha));
osg::Vec3 center(0.0f, 0.0f, 0.0f);
osg::Vec3 up(0.0f, 0.0f, -1.0f);
camera->setViewMatrixAsLookAt(eye, center, up);
```
Наконец, анимируем и отображаем сцену, меняя угол поворота самолета вокруг оси Z на каждом кадре
```
float phi = 0.0f;
float delta = -0.01f;
while (!viewer.done())
{
transform1->setMatrix(osg::Matrix::rotate(static_cast(phi), osg::Vec3(0.0f, 0.0f, 1.0f)));
viewer.frame();
phi += delta;
}
```
В итоге мы получаем довольно интересную картинку
В данном примере мы реализовали некоторую анимацию сцены, но следует помнить о том, что разворачивание цикла run() и изменение параметров рендеринга перед или после отрисовки кадра является небезопасным занятием с точки зрения организации доступа к данным разных потоках. Поскольку OSG использует многопоточный рендеринг, то существуют и штатные механизмы встраивания собственных действий в процесс рендеринга, обеспечивающие потокобезопасный доступ к данным.
6. Сохранение результата рендеринга в файл
==========================================
OSG поддерживает возможность прикрепить к камере объект osg::Image и сохранить содержимое буфера кадра в буфер данных изображения. После этого возможно сохранить эти данные на диск используя функцию osg::writeImageFile()
```
osg::ref_ptr image = new osg::Image;
image->allocateImage( width, height, 1, GL\_RGBA, GL\_UNSIGNED\_BYTE );
camera->attach( osg::Camera::COLOR\_BUFFER, image.get() );
...
osgDB::writeImageFile( \*image, "saved\_image.bmp" );
```
Заключение
==========
Возможно, материал изложенный в статье покажется тривиальным. Однако, в неё излагаются самые основы работы с текстурами в OpenSceneGraph, на которых базируются более сложные приемы работы с этим движком, о которых мы обязательно поговорим в будущем.
*[Продолжение следует...](https://habr.com/ru/post/437688/)* | https://habr.com/ru/post/437624/ | null | ru | null |
# Как npm стал самым популярным пакетным менеджером в мире
Со [вступительной речью](https://www.youtube.com/watch?v=mY3DyBT55do) на конференции [Node.js Interactive](http://events.linuxfoundation.org/events/node-interactive) выступила Эшли Уильямс (Ashley Williams, она же [@ag\_dubs](https://twitter.com/ag_dubs)), менеджер сообщества разработчиков и контента в [npm](https://www.npmjs.com/). Она рассказала о текущем состоянии дел в компании и рассказала, как фирма зарабатывает деньги. На самом деле npm — это коммерческая компания, которая получает прибыль от предоставления [корпоративных услуг](https://www.npmjs.com/enterprise). Этого дохода достаточно, чтобы поддерживать деятельность в качестве нормальной компании, платить зарплату персоналу (сейчас в компании 23 сотрудника), и ещё остаётся на поддержку бесплатного репозитория пакетов npm.
Немного статистики. За последние 28 дней пользователи npm установили 18 млрд пакетов. Для установки этих пакетов им потребовалось скачать 6 млрд пакетов из репозитория. Примерно две трети установок обошлись без скачивания пакетов, а были выполнены из кэша. Вот как выглядит график количества скачиваний за 28 дней, с 2013 года.
На бурный рост npm указывает и количество опубликованных в репозитории пакетов в неделю. На графике — статистика за последние два года. Если в начале 2015 года в репозитории публиковалось менее 12 500 пакетов в неделю, то самая последняя статистика в январе 2017 года — 39 692 пакета.
Почти 40 000 пакетов всего за одну неделю.
Далее — статистика по новым пакетам (тоже еженедельная) за два года. Из неё исключены обновления старых пакетов.
На графике обращают на себя четыре потрясающих пика в первой половине 2016 года и один провал в декабре 2015 года. Эшли Уильямс затруднилась объяснить, чем объясняются эти аномалии: «Наверное, многие разработчики были взбудоражены в то время», — предположила она с улыбкой.
Всего за одну последнюю неделю в репозиторий загрузили 4685 новых пакетов.
Кроме статистики по пакетам, интересно посмотреть на то, как растёт сообщество open source через призму репозитория npm. Каждую неделю примерно 160 человек публикуют в npm свой первый пакет — без учёта новых версий пакетов, а именно свой первый пакет. Настолько увеличивается сообщество open source, ведь с большой долей вероятности это их первые пакеты в жизни.
Всего в репозитории npm сейчас насчитывается 102 460 активных «издателей» (авторов пакетов). Это тоже немалое количество.
Ниже статистика по количеству новых регистраций пользователей.
На сегодняшний день в npm зарегистрировано 314 582 пользователя. Как понятно из предыдущих цифр, примерно каждый третий зарегистрированный пользователь является активным издателем и автором пакета или нескольких пакетов.
Сотрудница npm не обошла вниманием скандальную историю с пакетом `left-pad` — 11 строками кода, «[которые поломали интернет](https://habrahabr.ru/post/280039/)».
Напомним, в марте 2016 года Веб-разработчик Азер Кочулу (Azer Koçulu), автор более 250 модулей для Node.js, попал в неприятную ситуацию. Он получил письмо от юриста компании Kik (мессенджер) с требованием отозвать модуль с аналогичным названием kik из npm. Программист отказался, тогда юрист обратился напрямую в компанию npm, и она сменила владельца kik без разрешения автора. Разработчик со злости решил отозвать все свои модули — более 250 штук. К сожалению, среди них оказался и [left-pad](https://github.com/azer/left-pad/blob/master/index.js) — маленький модуль из 11 строк кода на JavaScript. Несмотря на простоту модуля, в тысячах приложений менеджер npm теперь не мог установить зависимости между пакетами.
Эшли Уильямс сказала, что компания осознала всю серьёзность проблемы и принесла свои глубочайшие извинения, а буквально через неделю после той истории подготовила новые правила снятия пакетов из репозитория. По [новым правилам](https://habrahabr.ru/post/280546/), вы имеете право снять пакет только в течение 24 часов. После этого времени отзыв допускается только с разрешения администрации. Служба поддержки проверит, не ломает ли этот модуль какие-нибудь зависимости в других пакетах. Если ломает, то отзыв запрещают. В этом случае управление или отдадут другому разработчику, или постараются связаться с автором того пакета, где есть лишняя зависимость.
Новая политика npm и история с `left-pad` вызвала живой отклик сообщества — на Github в комментариях отметились тысячи авторов, которые высказали своё мнение об этом. Многие авторы захотели удалить свои пакеты.
В ответ компания внедрила новую политику отказа от прав на пакеты (dissociate and deprecate), чтобы авторы могли оставить пакет, просто убрав своё имя из реестра для пакета, который больше не хотят поддерживать.
Таким образом была решена проблема с ломкой зависимостей между тысячами пакетами во всей экосистеме npm в случае удаления какого-то одного модуля. «Теперь реестр неуязвим», — подвела итог Эшли Уильямс. Катастрофы по примеру `left-pad` больше не произойдёт. Компания также подчёркивает высокий процент аптайма реестра (статистика в реальном времени показывается на [ping.npmjs.com](http://ping.npmjs.com/)) и высокую производительность npm, которая в несколько раз превосходит производительность, например, git.
При пустом кэше npm примерно на 75% быстрее git.
Популярность JavaScript объясняет быстрый рост реестра npm и тот факт, что к настоящему времени npm ещё в 2014 году стал самым популярным пакетным менеджером в мире. Сейчас по количеству пакетов он более чем вдвое превосходит ближайший пакетный менеджер Maven Central (Java).
Несмотря на статус крупнейшего пакетного менеджера в мире, npm ещё видит перспективы для роста. В конце концов, в мире примерно 18 миллионов программистов, а 85% из них пишут на JavaScript (в каком-то смысле хотя бы частично). Это означает, что в мире примерно 15 миллионов разработчиков на JavaScript. Сейчас не более 50% из них используют npm (около 5,7 млн пользователей), так что перспективы для роста есть.
Исследование показало, что 80% пользователей npm занимаются разработкой фронтеда, 60% — разработкой бэкенда. Изучение вопроса показало также, что люди используют npm для совершенно невероятных вещей, для которых он не был рассчитан и которые не приходили в голову создателям сервиса. | https://habr.com/ru/post/319724/ | null | ru | null |
# Категории программных тестов
 *Перевод был сделан как ответ на некоторые комментарии к переводу [Настройка IDE для автоматического запуска тестов](http://habrahabr.ru/blogs/testing/64737/). Прочитав статью и посмотрев наглядные примеры, вы сможете прочувствовать разницу между разнообразными видами тестов, что, в свою очередь, поможет вам грамотно составлять тесты и не перемешивать их в одной куче. Каждый тест хорош в нужном месте и в нужное время!
— mazurov*
Вы порой слышите о маленьких/средних/больших/модульных/интеграционных/функциональных/сценарных тестах, но сколько из нас знают что это означает? В данной статье мой взгляд на виды тестов.
#### Модульные/Маленькие
Начнем с модульных тестов. Лучшее определение, которое я нашел — это тесты, которые выполняются очень быстро (менее 1 миллисекунды) и в случае, когда они не проходят, нам не нужен дебагер для выявления места, где произошла ошибка. Само определение делает ограничение на то, какими должны быть тесты. Например, ваши тесты не должны выполнять никаких операций ввода/вывода (I/O) — это одно из условий выполнения теста менее 1 миллисекунды. Ограничение в 1 миллисекунду очень важно, поскольку вы желаете запускать ВСЕ (тысячи) ваши модульные тесты каждый раз, когда вы изменяете что-либо, желательно [при каждом сохранении файла](http://habrahabr.ru/blogs/testing/64737/). Я могу терпеть только 2 секунды и в течение этих двух секунд я хочу, чтобы все мои тесты выполнились и ничего не сломалось. Это очень здорово, когда можно просто нажать ctrl+z несколько раз для отмены недавних изменений и исправить «красный» тест. Немедленная обратная связь вызывает привычку как у наркомана. Отсутствие потребности в дебагере подразумевает, что область теста локализована (отсюда и название теста — модульный (unit), тест одного класса, например).
Цель модульных тестов проверить условную логику в вашем коде — ваши if'ы и циклы. Это те места, где рождаются большинство багов (смотри [теорию багов](http://misko.hevery.com/2008/11/17/unified-theory-of-bugs/)). Вот почему, в случае если вы не делаете другого тестирования, модульные тесты лучшее средство, чтобы выявить простые ошибки в самом начале. Если вы имеете код пропущенный через модульные тесты, то вам будет проще тестировать на более высоких уровнях, описанных ниже.
[KeyedMultiStackTest.java](http://code.google.com/p/testability-explorer/source/browse/trunk/core/src/test/java/com/google/test/metric/collection/KeyedMultiStackTest.java) — это пример хорошего модульного теста из [Обозревателя тестируемости](http://code.google.com/p/testability-explorer). Почувствуйте, как каждый тест рассказывает нам историю. Это не testMethodA, testMethodB,... — это скорее похоже на сценарий. Заметьте, как вначале идут обычные тесты, к которым вы возможно привыкли, но ближе к концу файла тесты выглядят немного незнакомо. Это объясняется тем, что это тесты на пограничные случаи, которые я обнаружил уже позже. Забавная вещь с тестируемым классом в [KeyMultiStack.java](http://code.google.com/p/testability-explorer/source/browse/trunk/core/src/main/java/com/google/test/metric/collection/KeyedMultiStack.java) в том, что я переписывал его три раза. Я не мог заставить его работать на всех тестах. Один из тестов всегда ломался до тех пор, пока я не понял, что алгоритм содержит существенный недостаток. К тому времени у меня была почти работающая программа и это был ключевой класс для процесса анализа байт-кода. Как вы будете себя чувствовать, когда надо похоронить что-то столь фундаментальное в системе и переписать это с нуля? У меня ушло два дня на переработку до того момента, пока успешно не прошли все тесты. После этого все приложение осталось работоспособным. Это то, что называется — «Ага! момент» — момент, когда вы осознаете насколько хороши модульные тесты.
Должен ли каждый класс иметь соответствующий модульный тест? В общем-то, нет. Многие классы тестируются не напрямую, а через тестирование чего-то еще. Обычно простые объекты-значения (value objects) не имеет модульных тестов. Но не путайте неимение тестов и неполное покрытие тестами. Все классы/методы должны быть протестированы (test coverage). Если вы тест-инфицированны (TDD), то это у вас в крови.
#### Средние/Функциональные
Итак, с помощью модульных тестов вы удостоверились, что каждый класс по отдельности выполняет то, что нужно. Но как вам узнать, что они также хорошо будут работать вместе? Для этого нам нужно объединить связанные классы так, как это будет в рабочей версии программы и проверить основные пути их взаимодействия. Задача состоит не в проверке работают ли if'ы или циклы, а в контроле контрактов между интерфейсами классов. Хорошим примером функционального теста является [MetricComputerTest.java](http://code.google.com/p/testability-explorer/source/browse/trunk/core/src/test/java/com/google/test/metric/MetricComputerTest.java). Заметьте, что входными данными для каждого теста является внутренний класс в тестируемом файле и выходом является ClassConst.java. Для получения выхода несколько классов взаимодействуют между собой: парсинг байт-кода, анализ путей выполнения и вычисление стоимости выполнения до того момента пока окончательная стоимость не будет принята.
Многие из классов тестируются дважды. Один раз с помощью модульных тестов, описанных выше, и второй раз через функциональные тесты. Если вы уберете модульные тесты, то я все равно глубоко уверен, что функциональные тесты обнаружат те изменения, которые поломали код, но я не буду уверен в какую часть кода надо будет залезть, чтобы исправить поломку, поскольку это может быть в любом классе, задействованном в тесте. Когда функциональный тест не проходит, а модульные тесты выполняются успешно, то мне порой приходится вооружаться дебагером. После того как проблемное место будет обнаружено, я добавляю модульный тест, которой поможет мне 1) доказать, что я понимаю, в чем заключается баг и 2) предотвратить повторное появление бага. Подобные модульные тесты объясняют появление странных тестов в конце [KeyedMultiStackTest.java](http://code.google.com/p/testability-explorer/source/browse/trunk/core/src/test/java/com/google/test/metric/collection/KeyedMultiStackTest.java). Это вещи, о которых я не задумывался при первоначальном написании тестов, но которые необходимо было включить после многих часов отладки и обнаружения источника ошибок в классе из [KeyedMultiStack.java](http://code.google.com/p/testability-explorer/source/browse/trunk/core/src/main/java/com/google/test/metric/collection/KeyedMultiStack.java).
Вычисление метрик является лишь небольшой частью того, что делает Обозреватель тестируемости. Существуют еще функции, которые следует протестировать. Вы можете думать о функциональных тестах, как о тестах связанных классов, которые формируют единую сущность для всего приложения. Вот некоторые из подобных сущностей в Обозревателе: парсинг байт-кода java, парсинг кода java, парсинг кода с++, высисление метрик, 3 разных вида отчетов и движок для советов. Все они соответствуют уникальному набору классов, которые взаимодействуют между собой и нуждаются в совместном тестировании. Чаще всего подобные наборы не зависят друг от друга.
#### Большие/Приемочные/Сценарные
Что мы еще должны протестировать, кроме if'ов, циклов и взаимодействия интерфейсов. Существует еще один класс возможных ошибок. Вы можете неверно объединить компоненты системы. Например, можно передать null вместо отчета, неправильно указать путь к jar-файлу для парсинга и т.д. Это не логические баги, а баги связывания. К счастью, баги связывания легко воспроизводимы и обычно сопровождаются появлением exception'а. Примером приемочного теста является [TestabilityRunnerTest.java](http://code.google.com/p/testability-explorer/source/browse/trunk/core/src/test/java/com/google/test/metric/TestabilityRunnerTest.java). Посмотрите как тесты проверяют работу всего приложения и имеют не так уж много assert-проверок. Нам их много и не нужно — мы до этого уже убедились, что все функции работают и нам надо только проверить те немногие места связки компонентов.
`---------------------------
translated.by/you/software-testing-categorization/into-ru/trans
Оригинал (английский): Software Testing Categorization (http://googletesting.blogspot.com/2009/07/software-testing-categorization.html)
Перевод: © mazurov (Alexander MAZUROV).`
**UPD1**: Новый перевод из серии про тестирование: [Моя объединенная теория багов](http://habrahabr.ru/blogs/testing/65062/) | https://habr.com/ru/post/64874/ | null | ru | null |
# UNIX-way и генератор заданий по архитектуре компьютерных сетей
Прошлой зимой на нашей любимой кафедре произошло одно замечательное событие — курс проектирования компьютерных сетей был переформирован, в результате чего вместо одного семестра практических занятий образовались два семестра занятий лабораторных. С одной стороны, оба изменения — и качественное, и количественное — означали, что студенты получат больше времени на освоение предмета, а также занятия будут индивидуальными, а не групповыми — думать, вполне вероятно, придётся всем, а не «ядру» группы в четыре-пять человек. С другой стороны, это означало, что придётся разрабатывать эти самые индивидуальные задания, да так, чтобы они были все отличались друг от друга.
Именно тогда-то и появилась мысль написать автоматический генератор заданий. Про генератор одного из заданий я и расскажу ниже.
Задание заключалось в том, чтобы построить и настроить необходимую конфигурацию сети в Cisco Packet Tracer. Соответственно, к формирователю заданий предъявлялись следующие требования:
* максимальное количество узлов в сети — 8;
* максимальное количество линков, выходящих из узла — 3;
* максимальное количество линков в сети — 12.
#### Немного скучных технических деталей
Сам генератор состоит из генератора собственно графа сети, генератора непересекающихся диапазонов адресов, и генератора визуализации.
Для написания генераторов графа сети и диапазонов решено было использовать язык Tcl, совершенно незаслуженно сейчас пользующийся сравнительно небольшой популярностью. Визуализацию мы делали с использованием [Graphviz](http://graphviz.org), а итоговый документ формировался при помощи LaTeX.
Граф сети, как легко видеть, можно легко представить в виде древовидной структуры, в которой каждый узел сети может упоминаться более одного раза. Возник вопрос: а как эффективно хранить саму древовидную структуру? После нескольких попыток использовать разные подходы был сделан выбор в пользу вложенных словарей.
Как известно, в Tcl практически любой объект представим в виде текстовой строки. Не являются исключением и словари. Словарь в Tcl — список, содержащий пары «ключ» — «значение», а любой список, в свою очередь может быть записан в виде строки, в которой элементы списка разделены пробелами. Такая структура немного напоминает JSON, но имеет несколько более простую структуру.
Таким образом, использовать словарь как список связей между узлами сети: ключом является номер узла, а значение представляет собой список узлов, с которыми данный узел связан. Каждый из элементов, в свою очередь, также является словарём, в котором по умолчанию содержится один элемент, в котором ключ — номер узла, а значение пусто. Вышесказанное можно проиллюстрировать следующим образом:
Соответствующий словарь будет выглядеть так:
```
0 {
1 2
3 4
5 6
7 {
8 2
3 {}
}
}
```
Преимуществом такой структуры является возможность выборки по пути к элементу: вызов
```
[dict get $tree 0 7 8]
```
позволяет «заглянуть» в список связей узла 8.
Собственно, имея средства хранения структуры сети, построение самой сети уже не было проблемой — в соответствии с показаниями генератора случайных чисел производилось добавление новых узлов с одновременной проверкой условий.
К слову, о генераторах. В первом приближении скрипт давал очень странные результаты, после чего я решил просмотреть результаты нескольких вызовов генератора случайных чисел. Когда я получил нечто вроде: `2 9 0 1 5 7 7 7 4 7 7 7...`, мне пришлось слегка модифицировать процедуру `getrandom`, чтобы она не возвращала одинаковые значения подряд. Вероятно, знатоки генераторов случайных чисел закидают меня чем-нибудь, но такой подход в данном применении себя оправдал.
Ещё одним преимуществом выбранного способа хранения графа была простота проведения проверки на наличие всех узлов в сети — из текстового представления графа выбрасывались все скобки, в результате чего граф превращался в плоский список, после чего удалением повторяющихся элементов (`[lsort -uniq]`) из него легко получить список всех узлов графа.
Когда сеть сгенерирована, всё тот же скрипт на Tcl сохраняет граф в формате Graphviz dot, который преобразуется в EPS, пригодный для «скармливания» LaTeX'у. При выводе графа в dot в явном виде задаётся шрифт CMR12, чтобы в итоговом документе не было разнообразия шрифтовых гарнитур. Здесь, однако, кроется одна досадная неожиданность: в созданный таким образом EPS'е, естественно, не будут внедрены шрифты, но при итоговой сборке документа в выходной файл будут включены только те символы, которые используются LaTeX'ом. Поэтому для корректного отображения надписей пришлось в этот самый LaTeX'овый исходник добавить стоящую за полями бумаги букву «N».
Для сборки документа используется традиционный «конвейер» из LaTeX, dvips и ps2pdf.
«Дирижирует оркестром» небольшой Makefile, вызывающий скрипты, а также вышеназванные инструменты.
#### Что получилось в итоге
После нескольких минут работы генератор выдал двухмегабайтный PDF, содержащий 1000 заданий по одному заданию на страницу. Задания выглядели примерно так:
Предполагалось, что номер задания будет соответствовать последней цифре номера группы и номеру студента в группе. На практике же групп было более чем в два раза меньше, чем было сотен заданий, а студентов в каждой группе было далеко не 100, так что нехватки заданий в ближайшие пару лет у студентов не будет.
Кроме того, к заданиям прилагалась страничка с напутствием, а также пожеланием осознать, зачем же нужна динамическая маршрутизация :)
Реакция студентов на тысячестраничный PDF была примерно: «Эээ?!» Одно из предложений студентов меня повеселило: «А если я напишу программу, которая разбирает конфигурацию сети из этого PDF, а потом генерирует конфигурацию для Cisco, это будет засчитано?»
Генератор, который я выше описал, замечательно служит примером того, как можно, стыкуя различные программы между собой, получать желаемый результат без мучительного изобретения велосипедов. Конечно, немного повелосипедить пришлось, но всё было бы гораздо хуже, не будь в моём распоряжении таких замечательных инструментов, как TeXLive, Graphviz, а также моих любимых скриптовых языков.
В общем-то, это всё, что мне хотелось рассказать. Спасибо за внимание.
P. S. Интересующиеся могут найти исходные коды проекта по адресу: <http://bitbucket.org/andrew_shadoura/netgen>. | https://habr.com/ru/post/131949/ | null | ru | null |
# Чем Linux HugePages важны для серверов баз данных?
Часто пользователи рассказывают нам о сбое базы данных по вине Out Of Memory Killer. Он завершает процессы PostgreSQL и остается причиной большинства отказов этой БД. Память на хост-компьютере может закончиться по нескольким причинам, наиболее распространенные из них:
1. Плохо настроена память на хост-компьютере.
2. Ограничения глобальной переменной work\_mem. Например, если у вас 32Гб RAM и work\_mem=1Гб, то больше 32 соединений вы никогда не запустите. Каждое соединение PostgreSQL будет выделять этот размер памяти.
3. Большое количество подключений. Даже неактивное соединение может занимать значительный объем памяти.
4. Другие программы тоже потребляют ресурсы, потому что для каждой из них этот компьютер является хостом.
Меня зовут Jobin Augustine, я работаю в Percona старшим инженером службы поддержки. Более 20-лет был консультантом, архитектором, администратором и инструктором по PostgreSQL, Oracle и другим технологиям баз данных. Поговорим о том, как можно защититься от OOM с помощью HugePages. Разберем насколько они важны и почему нужны.
Когда-то мы помогали настраивать хост-компьютеры и базы данных своим клиентам, то никогда не тратили время на объяснения. Не рассказывали им, что и почему делаем. Мой друг и коллега [Fernando Laudares Camargos](https://www.percona.com/blog/author/fernando-laudares/) уже не раз обращал на это мое внимание. Поэтому я решил написать эту статью, чтобы сразу для всех объяснить суть проблемы на проверяемом и повторяемом случае. Это удобно, тем более если вы захотите провести свое собственное тестирование.
Условия теста
-------------
* 40 ядер ЦП (80 vCPU) и 192 ГБ физической памяти.
* 80 подключений, я не стал перегружать сервер слишком большим количеством подключений, поэтому для теста использовал только 80, что соответствует нормальным условиям нагрузки.
* Transparent HugePages (THP) отключены.
За прошедшие годы в **Transparent HugePages (THP)** было внесено множество улучшений, которые позволяют приложениям использовать HugePages без модификации кода. THP часто рассматривается как замена обычным HugePages для универсальной рабочей нагрузки. Однако **использование THP в системах баз данных не рекомендуется**, так как оно может привести к фрагментации памяти и увеличенному времени ответа. Это не специфическая проблема PostgreSQL, она затрагивает все системы баз данных. Например:
* [Oracle рекомендует отключать TPH](https://docs.oracle.com/en/database/oracle/oracle-database/19/ladbi/disabling-transparent-hugepages.html#GUID-02E9147D-D565-4AF8-B12A-8E6E9F74BEEA).
* [MongoDB рекомендует отключать THP](https://docs.mongodb.com/manual/tutorial/transparent-huge-pages/).
* [THP вызывает снижение производительности PostgreSQL](https://www.postgresql.org/docs/current/runtime-config-resource.html) у пользователей некоторых версий Linux.
Я не хочу уходить от темы и ударяться в объяснения, почему THP лучше не использовать для сервера базы данных, кто хочет разобраться, может почитать информацию по ссылкам. Мы же вернемся к условиям теста.
Чтобы обеспечить относительно постоянное соединение, такое же, как у хабов со стороны приложения (или даже у хабов внешнего соединения), используем pgBouncer со следующей конфигурацией:
```
[databases]
sbtest2 = host=localhost port=5432 dbname=sbtest2
[pgbouncer]
listen_port = 6432
listen_addr = *
auth_type = md5
auth_file = /etc/pgbouncer/userlist.txt
logfile = /tmp/pgbouncer.log
pidfile = /tmp/pgbouncer.pid
admin_users = postgres
default_pool_size=100
min_pool_size=80
server_lifetime=432000
```
*Чтобы поддерживать постоянное соединение от хаба к PostgreSQL у параметра* `server_lifetime` *указано большое значение.*
Вслед за PostgreSQL, вносим изменения в параметры для имитации общих настроек клиентской среды:
```
logging_collector = 'on'
max_connections = '1000'
work_mem = '32MB'
checkpoint_timeout = '30min'
checkpoint_completion_target = '0.92'
shared_buffers = '138GB'
shared_preload_libraries = 'pg_stat_statements'
```
Тестовая нагрузка создается с помощью sysbench:
`sysbench /usr/share/sysbench/oltp_point_select.lua --db-driver=pgsql --pgsql-host=localhost --pgsql-port=6432 --pgsql-db=sbtest2 --pgsql-user=postgres --pgsql-password=vagrant --threads=80 --report-interval=1 --tables=100 --table-size=37000000 prepare`
А затем запускаем:
`sysbench /usr/share/sysbench/oltp_point_select.lua --db-driver=pgsql --pgsql-host=localhost --pgsql-port=6432 --pgsql-db=sbtest2 --pgsql-user=postgres --pgsql-password=vagrant --threads=80 --report-interval=1 --time=86400 --tables=80 --table-size=37000000 run`
На первом этапе подготовки, на сервер ложится нагрузка write, а на втором — только read. Я не буду объяснять теорию и концепции, лежащие в основе HugePages, а лишь сосредоточусь на анализе последствий его использования. Если хотите разобраться в деталях, можете посмотреть статьи: [Five-Level Page Tables](https://lwn.net/Articles/717293/) и [Measuring the Memory Overhead of a Postgres Connection](https://blog.anarazel.de/2020/10/07/measuring-the-memory-overhead-of-a-postgres-connection/).
Ход тестирования
----------------
Мы решили измерять потребление памяти с помощью утилиты `Linux free`. При использовании обычного пула страниц памяти, потребление началось с очень низкого значения. Но по ходу проведения теста оно начало расти. На скриншоте видно, что со временем «доступная» память расходуется быстрее.
Ближе к концу теста уже видно высокую swap-активность. Она более наглядно фиксируется в выходных данных `vmstat`:
Информация из `/proc/meminfo` показывает, что размер таблицы Total Page с первоначальных **45 Мб** вырос до более чем **25 Гб**:
Это не просто потеря памяти, а огромное потребление ресурсов, влияющее на общее выполнение программ и работоспособность операционной системы. Мы видим, что потери состоят из **суммы записей нижнего уровня PageTable** с 80процессами PostgreSQL.
Подтвердить эти данные, можно проверив каждый процесс PostgreSQL:
Если мы возьмем полученное значение 314240 Кб и умножим на 80 соединений, то как раз получим наш примерный общий размер PageTable — **25 Гб**. Поскольку наш синтетический тест передает почти одинаковую рабочую нагрузку через все соединения, у всех отдельных процессов почти одинаковые значения, очень близкие к зафиксированному выше.
Поскольку PostgreSQL использует Linux shared memory, нет смысла сосредотачиваться на Rss (Resident set size). Поэтому используем следующую строку для проверки **Pss** (Proportional set size):
`for PID in $(pgrep "postgres|postmaster") ; do awk '/Pss/ {PSS+=$2} END{getline cmd < "/proc/'$PID'/cmdline"; sub("\0", " ", cmd);printf "%.0f --> %s (%s)\n", PSS, cmd, '$PID'}' /proc/$PID/smaps ; done|sort -n`
PostgreSQL запускает по процессу на каждое соединение, плюс несколько фоновых. Поэтому без информации **Pss** сложно понять, как память распределяется по процессам.
В типичной системе баз данных со значительной нагрузкой DML, фоновые процессы PostgreSQL, такие как Checkpointer, Background Writer или рабочие процессы Autovaccum, будут касаться большего количества страниц в shared memory. Соответствующий Pss для этих процессов будет выше, чем для активных процессов.
Так становится понятнее, что Checkpointer, Background worker или даже Postmaster часто становятся целью OOM Killer потому, что используют больше памяти, чем другие процессы.После нескольких часов активности, отдельный сеанс затронул больше страниц shared memory. Как следствие, значения Pss для каждого процесса были перераспределены. Потребление памяти checpointer-ом снизилось, а другие сеансы поделили память приблизительно поровну.
Тем не менее, Checkpointer сохранил наибольшую долю. Такая схема нагрузки характерна для нагрузочного теста, при котором основная нагрузка приходится на CheckPointer и Background Writer.
Включение HugePages
-------------------
HugePage (hugetlbfs) изначально появился в Linux Kernel в 2002 году для удовлетворения требований систем баз данных, которым необходимо обращаться к большому объему памяти. Но оказался очень актуален для целей разработки и используется до сих пор. Например, в данном случае помогает сократить расход памяти.
Его можно использовать вместо раздутых таблиц страниц, достаточно выяснить, сколько памяти должно быть выделено для HugePages. Для этого проверим VmPeak процесса postmaster. Например, если PID процесса postmaster — 4537, то:
`grep ^VmPeak /proc/4357/status`
Получаем необходимый объем памяти в Кб:
`VmPeak: 148392404 kB`
В HugePages все это должно преобразоваться в страницы размером 2 Мб:
```
postgres=# select 148392404/1024/2;
?column?
----------
72457
(1 row)
```
Укажите это значение в `/etc/sysctl.conf` для `vm.nr_hugepages`, например: `vm.nr_hugepages = 72457`
Теперь закройте экземпляр PostgreSQL и выполните `sysctl -p`
Проверим, создано ли запрошенное количество huge pages:
```
grep ^Huge /proc/meminfo
HugePages_Total: 72457
HugePages_Free: 72457
HugePages_Rsvd: 0
HugePages_Surp: 0
Hugepagesize: 2048 kB
Hugetlb: 148391936 kB
```
Запустив PostgreSQL на этом этапе, мы увидим, что HugePages\_Rsvd выделен.
```
$ grep ^Huge /proc/meminfo
HugePages_Total: 72457
HugePages_Free: 70919
HugePages_Rsvd: 70833
HugePages_Surp: 0
Hugepagesize: 2048 kB
Hugetlb: 148391936 kB
```
Если все идет как надо, на этом этапе я бы убедился, что PostgreSQL всегда использует HugePages. Потому, что уж лучше иметь сбой при запуске PostgreSQL, чем проблемы позже.
`postgres=# ALTER SYSTEM SET huge_pages = on;`
**Обратите внимание**, что приведенное выше изменение требует перезапуска экземпляра PostgreSQL.
Тесты с включенными HugePages
-----------------------------
HugePages создаются заранее, еще до запуска PostgreSQL. Он просто выделяет и использует их. Так что мы не заметим изменения вывода утилиты `Linux free` до и после запуска. PostgreSQL загружает shared memory в HugePages, если они уже доступны. `Shared_buffers`, принадлежащие PostgreSQL, занимают больший объем shared memory.
Первый вывод `free -h` на скриншоте генерируется до запуска PostgreSQL, а второй — после. Я провел такой же тест, как до включения HugePages, он длился несколько часов, и изменений почти не было. Единственное, что произошло, после нескольких часов работы началось смещение «свободной» памяти в кэш файловой системы, что соответствовало нашим ожиданиям и целям. Общая «доступная» память оставалась практически неизменной, как видно на следующем скриншоте.
Общий размер таблиц страниц тоже остался прежним:
При этом разница в расходе памяти была колоссальной. Всего **61 Мб** при включенном HugePages, вместо **25 Гб без него**. Pss за сеанс также значительно сократился:
Самое большое преимущество HugePages заключалось в том, что CheckPointer и Background Writer больше не забирали несколько Гб ОЗУ.
Вместо этого они потребляли лишь несколько Мб. А это значит, что они больше не были целью OOM Killer.
Выводы
------
Мы убедились, что благодаря HugePages фоновые процессы PostgreSQL не забирали на себя большой объем shared memory. Поэтому они переставали быть первоочередной целью OOM Killers и связанных с этим сбоев. Такие улучшения могут спасти систему, если она находится на грани OOM. Но гарантировать, что это позволит навсегда защитить базу данных от всех условий OOM — все же нельзя.
Нам удалось снизить общее потребление памяти. Если без HugePages доступная память на сервере была полностью исчерпана и началась подкачка, то после его включения в доступном кэше файловой системы Linux остались 38-39 Гб.
Существуют и другие преимущества использования HugePages. Они никогда не выгружаются на диск. Когда общие буферы PostgreSQL находятся в HugePages, они обеспечивают более стабильную и предсказуемую производительность.
Linux использует метод многоуровневой таблицы страниц. HugePages реализованы с использованием прямых указателей на страницы из промежуточного слоя (огромная страница размером 2 Мб находится непосредственно на уровне PMD, без промежуточной страницы PTE). Преобразование адресов значительно упрощается. А это часто встречающаяся операция на сервере базы данных с большим объемом памяти.
> 28-29 апреля в Москве впервые пройдет [**TestDriven Conf 2022**](https://clck.ru/dsGjW) — профессиональная конференция для senior тестировщиков и QA-инженеров. Она будет посвящена всем вопросам автоматизации в тестировании и рядом.
>
> [Расписание](https://clck.ru/dsGjk) и [тезисы докладов](https://clck.ru/dsGjy) уже на сайте. И можно [забронировать билеты](https://clck.ru/dsGkH) по выгодной цене — чем ближе к конференции, тем будет дороже.
>
> | https://habr.com/ru/post/655887/ | null | ru | null |
# Одержимость производительностью или опыт профилирования в виртуальной среде
Давайте будем откровенны: неэффективно работающее приложение у большинства разработчиков вызывает дискомфорт. Подчас погоня за производительностью имеет почти спортивную природу, не связанную с прямыми обязанностями. На хабре, как и в жизни многих из нас, найдется немало [впечатляющих примеров](http://habrahabr.ru/post/110395/) побед над [неэффективностью разного толка](http://habrahabr.ru/post/106684/). В общем, хороший разработчик не понаслышке знаком с инструментами и техниками профилирования. В этой же статья я хотел бы рассмотреть процесс профилирования в виртуальной среде Parallels Desktop 9 для Mac и VMWare Fusion 5. Под катом ждут тесткейсы, разбор полетов и внутренности гипервизора в самом брутальном виде.
#### Кому понадобилось запускать профилировщик внутри виртуальной машины?
Это самый первый вопрос, который может возникнуть при прочтении этой статьи. Безусловно, при помощи нехитрых приспособлений можно буханку белого (или черного) хлеба превратить в троллейбус … но кому, в самом деле, может понадобиться запускать профайлинг внутри виртуальной машины? Самое время вспомнить о счастливых обладателях Mac'ов, которым по долгу службы приходится разрабатывать под Windows или Linux. Mac OS, безусловно, в таком случае не станет помехой разработчику: на машине стоит VMWareFusion, а внутри виртуальной машины с Windows – Visual Studio, так что в принципе разработка идет, и проблем нет. Ровно до тех пор, пока не встает вопрос профилировки приложений. Я думаю, вы знакомы с циклом статей от Intel об оптимизации на основе данных, собранных профилировщиком Intel VTune Amplifier ([вот одна из них](http://habrahabr.ru/company/intel/blog/143446/), например), а если нет, то сейчас самое время. Итак вооружившись VTune'ом, установленным внутри виртуальной машины, приступим к профилированию.
#### Профилирование в виртуальной машине
Итак, в виртуальной машине установлен VTune Amplifier, и решено проанализировать компонент, на предмет оптимальности работы с памятью. Запущен анализ, и вуаля:
Никаких результатов. Причиной этому является то, что профилировщик в своей работе опирается на набор аппаратных счетчиков производительности, также известный, как Performance Monitoring Unit. Каждый из счетчиков может быть настроен на некоторое событие процессора (например, тик процессора или промах кэша), при возникновении которого он увеличивается на единицу. Уникальной особенностью сбора показателей производительности при помощи счетчиков в сравнении с программным инструментированием является полнота информации. Вы находите не только часто исполняемый код, но и код, вызывающий, например, частые промахи кэша. Значение счетчиков можно узнавать непрерывным опросом, а можно настроить генерацию прерывания по превышению счетчиком некоторого порогового значения. Последнее более популярно среди профилировщиков и упрощенная схема работы зачастую выглядит так (на рисунке у нас работа на одноядерном процессоре, и на начальный момент времени исполняется профилировщик):
Получив прерывание на переполнении счетчика, мы будем знать, что с момента установки счетчика произошло 0xFF событий. После чего мы прикапываем Instruction Pointer профилируемого приложения, на котором произошло прерывание, и считаем, что инструкция, на которую указывает этот самый IP, вызвал 0xFF событий. Так мы и собираем статистику.
Обман! От взгляда внимательного читателя не ускользнул тот факт, что события вызваны далеко не только этой единственной инструкцией, а всем блоком, который был на исполнении между двумя прерываниями. Но тем не менее результаты профилирования не теряют свою актуальность по двум основным причинам: количество событий между двумя прерываниями выбирается достаточно малым, чтобы получать адекватную статистику, и результаты всегда можно улучшить, увеличив выборку (дольше профилируем – точнее результаты). Помимо того существует технология Precise Event Based Sampling, позволяющая собирать точную статистику по некоторым событиям.
Внутри же виртуальной машины к счетчикам обратиться не удается, так как, очевидно, доступ к ним должен быть эмулирован (если мы дадим доступ к ним напрямую, то гостевая и хостовая операционные системы буду перетирать данные друг друга, и профайлинга не выйдет). Получив ошибку, описанную выше, делаем вывод: PMU не виртуализирован в VMWare Fusion. На этом бы можно было и закончить статью, но…
#### Виртуализация PMU в VMWare Fusion 5
… если вы являетесь счастливым обладателем VMWareFusion 5, то в настройках CPU можно выставить галочку “Virtualize CPU Performance Counters”, после чего профилировщик сможет работать внутри виртуальной машины, опираясь на эмулированные счетчики производительности.
Рассмотрим компонент, который будет проанализирован при помощи профилировщика внутри ВМ. Он представляет собой следующее: структура данных типа tSharedData, над которой два потока совместно производят некоторые операции. Для синхронизации использованы два семафора, и потоки по очереди пишут в разделяемые данные. В то же время работает третий поток, который вычитывает значение Time Stamp Counter, и передает его в упомянутую выше структуру.
Код двух рабочих потоков (nThreadNum определяет номер потока):
```
DWORD WINAPI Thread(LPVOID lpParameter)
{
tThreadParam* pParams = (tThreadParam*)lpParameter;
tSharedData* pData = pParams->pSharedData;
while( pData->nIsWorking )
{
if( pParams->nThreadNum == 1 )
{
// First Thread
pData->nLastThread = nCurrent;
ReleaseSemaphore( pData->hSecondThreadSemaphore,1,NULL );
WaitForSingleObject( pData->hFirstThreadSemaphore, INFINITE );
}else{
//Second thread
WaitForSingleObject( pData->hSecondThreadSemaphore, INFINITE );
pData->nLastThread = nCurrent;
ReleaseSemaphore( pData->hFirstThreadSemaphore,1,NULL );
}
}
return 0;
}
```
Код третьего потока:
```
DWORD WINAPI TimeThread(LPVOID lpParameter)
{
tSharedData* pData = (tSharedData*)lpParameter;
while( pData->nIsWorkingCacheAligned ) // О да, мы знаем о кешах так что данные этого потока
{ // разместили на безопасном расстоянии от данных первых двух
pData->nCurrentTime = __rdtsc();
}
return 0;
}
```
В общем, достаточно синтетический пример, но на нем можно достаточно наглядно увидеть эффекты, возникающие при профилировке в виртуализированной среде. Проводим анализ в течение 20 секунд, и получаем:
Второй столбец в этой таблице – количество тиков процессора, затраченных на исполнение функций из первого столбца. Но нам интереснее следующие два столбца: MEM\_LOAD\_UOPS\_LLC\_HIT\_RETIRED.XSNP\_HIT(M) — количество выполненных(RETIRED) операций(OUPS) загрузки(LOAD) данных(MEM), которые оказались (HIT) в LLC (M) модифицированными (Далее под промахами кеша подразумеваются промахи первых двух уровней кешей). И мы видим следующий результат: оба потока примерно одинаково бодро вызывают процесс синхронизации кэшей разных ядер последнего уровня, тем самым вызывая проблемы с производительностью. В принципе, результат ожидаемый: все три потока постоянно обращаются к разделяемой памяти, так что синхронизация кэшей вещь неизбежная, если данные не были грамотно выровнены. Остается только, глубоко вдохнув, приступить к оптимизации. И все-таки мы проводили профилирование в виртуализированной среде, а я вполне могу проверить результаты, исследовав этот код уже на реальной машине, на которой работала VMware Workstation. И результаты…
… отличаются кардинально. Как видим, поток, который читал значения TSC, вызвал мизерное количество загрузок LLC данных (и модифицированных, и не модифицированных), по сравнению с первыми двумя потоками. Так что внутри виртуальной машины мы намерили сбивающие с толку данные. Встает закономерный вопрос:
#### Что не так с виртуализацией PMU?
Наберите побольше воздуха в грудь: чтобы ответить на этот вопрос нам придется немного окунуться в детали работы виртуальных машин, а конкретно – виртуальных машин, использующих средства аппаратной виртуализации на примере Intel Virtualization Technology или VT-x. Эта технология добавляет еще один режим работы процессора – non-root моде. При работе в этом режиме обращение к оборудованию/системным ресурсам (такими как таблица страничных преобразований или прерываний) вызывает переключение в специально установленный обработчик, исполняющийся в «обычном», root режиме на нулевом кольце. Компонент виртуалки, содержащий этот обработчик, обычно называется монитором виртуальной машины. Фишка в том, что технология VT-x позволяет конфигурировать, будет ли гостевой системе дан прямой доступ к ресурсу или же этот доступ будет эмулирован. Например, пусть гость читает настоящий time-stamp counter, но ни в коем случае не дадим ему копаться в таблице страничных преобразований, а заведем ему его собственную (shadow) – пусть в ней ковыряется.
Итак, виртуализация PMU – это в основном виртуализация внушительного числа счетчиков, которые мы либо эмулируем, либо отдаем в полное пользование гостю (аккуратно сохраняя контекст родной (хостовой) ОС). Если учесть, что первое — это много однотипного кода, помноженное на неэффективность частного переключения root/non-root (каждое обращение к счетчику будет вызывать вмешательство монитора ВМ), то выбор разработчиков виртуальных машин очевиден – пускай гость владеет счетчиками беспрепятственно. Так и сделали сначала в KVM, но профилирование гостевого TCP стека дало непредвиденно скудное в процентном соотношении время работы с оборудованием. Ибо работа шла в мониторе, вне профилируемого гостя, который не имел доступа к железу. И тогда их головы посетила светлая идея: а что если мы будем учитывать еще и события, произошедшие в мониторе? Сказано – сделано. Теперь операции по работе с оборудованием утяжелились.
НО!
При этом утяжеление вызвано не учетом накладных расходов от оборудования, а учетом дополнительной нагрузки от виртуализации, которая в общем случае плохо коррелирует с нагрузкой от оборудования. Так что от реальности мы оказались даже дальше, хотя в некоторых случаях результаты профилирования и выглядят «правдоподобнее». О движении мысли разработчиков можно почитать [здесь](https://www.usenix.org/legacy/event/hotcloud10/tech/full_papers/Du.pdf).
Подобные вопросы касательно виртуализации PMU терзали и разработчиков VMWare Fusion 5. Они слегка изменили концепцию виртуализации: все события были разделены на «неспекулятивные» (такие как количество исполненных инструкций, количество ветвлений и другие метрики, имеющие «детерминистическую» природу: сколько в коде инструкций или условных переходов — столько их и будет насчитано), и «спекулятивные» (такие, как промахи кешей и неправильно предсказанные ветвления). При этом «спекулятивные» события подсчитывались с учетом нагрузки гипервизора, а «неспекулятивные» — без (более полное описание концепции [здесь](http://labs.vmware.com/academic/publications/virtualizing-performance-counters)). Понять такую логику нетрудно: когда в коде функции только 20 инструкций, а замеры показывают, что 220 (из-за того что учтена еще работа монитора виртуальных машин), то, как не сложно догадаться, такие результаты могут сбить с толку. Но при этом, измеряя «спекулятивные» метрики, мы все еще можем встретить результаты замеров, на которые не стоит опираться при оптимизации, как мы увидели выше.
Теперь мы можем ответить на вопрос, откуда такая разница в результатах. Функция по вычитыванию времени вызывает инструкцию RDTSC, которая эмулируется, и имеет непростую логику работы (timekeeping в виртуальных машинах вообще больная тема для разработчиков гипервизоров). Отсюда и масса промахов кэша: на вызове RDTSC происходит куда больше работы, чем ожидается.
#### Parallels Desktop 9
Безусловно, наше погружение в мир гипервизоров было бы неполным, если за рамками рассмотрения останется виртуальная машина Parallels Desktop 9. В этой виртуальной машине также была добавлена возможность доступа к PMU из гостевой системы, но подход к виртуализации был выбран несколько другой: события подсчитываются только в контексте гостевой системы- все влияние монитора на результаты замеров сведено к минимуму. Попробуем провести профилирование внутри этой виртуальной машины и сравним результаты.
Как видим, результаты сильнее коррелируют с результатами на реальном оборудовании, чем в VMWareFusion. (Поток, вычитывающий время, вызывает мизерное количество промахов кеша). Характер соотношение между количеством событий, произошедших в каждом из потоков, сохраняется. Может смутить нулевое количество пойманных промахов кеша в TimeThread в виртуальной машине, но это означает лишь то, что промахов кэша произошло порядка 2000 – именно таким выставлено пороговое значение для срабатывания счетчика промахов кеша. Но в целом характерные эффекты мы наблюдаем и в дальнейшем можем проводить оптимизацию, опираясь на найденные значения.
Тем не менее остается важный вопрос: так как быть с тем, что часть нагрузки, связанной с виртуализированными операциями, выпадает из статистики? Безусловно, это неприятный эффект, но стоит заметить следующее: 99% времени виртуальная машина работает без вмешательства монитора, то есть потеря части статистики часто для нас будет почти незаметна. Но главное, что такой подход более предсказуем, чем в случае с Fuison: если мы нашли ряд эффектов в нашем коде, то они проявятся и на реальном железе, в отличие от виртуальной машины VMWare, в которой можно обнаружить эффекты, которые не смогут быть воспроизведены на реальном оборудовании.
#### Резюме
Тот, кто дочитал статью до этого момента, воистину силен духом. За рамками обсуждения остались многие другие эффекты, возникающие при попытке профилирования в виртуальном окружении, но целью этой статьи является описания ключевых различий в профилировании в разных средах, зная о которых можно избежать некоторых проблем с интерпретацией результатов замеров производительности. Подытожим:
— Закон дырявых абстракций все так же актуален, и стоит быть вдвойне сосредоточенным, работая в виртуальном окружении.
— Если профилирование в виртуализированном окружении единственный возможный подход к анализу производительности, то следует быть начеку — операции по работе со временем и оборудованием могут выдавать серьезные артефакты в результатах при замерах влияния аппаратных эффектов.
— В целом же, в виртуальной машине можно собрать показательную статистику, опираясь на которую можно оптимизировать приложения.
Всем спасибо за внимание! | https://habr.com/ru/post/192176/ | null | ru | null |
# Разбор базового решения для задачи привязки аэроснимков к местности с Цифрового Прорыва
ruDALL-E Kandinsky уже знает как привязывать аэроснимки к местности, а Вы?Привет, Хабр!
Это последняя из трех статей, в которых я (автор канала [Зайцем по ХаХатонам](https://t.me/hahatons)) рассказываю о задачах [Всеросийского чемпионата Цифрового Прорыва](https://hacks-ai.ru/championships/758453), объясняю базовые решения (baseline) и даю советы, которые помогут подняться выше по рейтингу. В данной статье будет рассмотрен кейс от МФТИ по привязке аэроснимков к местности.
Данная статья является особенной, так как она содержит исправленный бейзлайн, который изначально не работал. Сейчас же приведенное ниже решение дает результат на 9 место в лидерборде!
Спойлер: в конце статьи есть советы для улучшения базового решения.
Цифровой Прорыв
---------------
Думаю, все и так знают, что такое [Цифровой Прорыв](https://hacks-ai.ru). Однако, напомню, что в этом году основной тематикой стал искусственный интеллект. И сезон этого года в самом разгаре!
Хоть часть мероприятий уже прошла, впереди участников ждет ещё 19 региональных чемпионатов, 5 окружных хакатонов и 3 всероссийских чемпионата. Советую присоединиться ко мне и другим участникам, чтобы не упустить возможность выиграть денежные призы и крутые путешествия, а также набраться опыта на самых разных задачах.
Введение
--------
В современном мире огромное количество задач решается с помощью спутниковых фотографий и аэрофотоснимков. Зачастую от скорости и качества интерпретации этих данных зависит то, как быстро выявляются пожары, наводнения и другие чрезвычайные ситуации. Технологии машинного зрения только начинают применяться в решении такого рода задач, однако потребность в их использовании постоянно растет.
Решение данной задачи позволит оперативно привязывать изображения к географическим координатам, что в дальнейшем может ускорить геодезические работы, поможет оперативно искать пропавших людей, контролировать вырубку лесов. И это только краткий список того, где требуется привязка аэрофотоснимков к местности.
Участникам чемпионата будет предложено найти местоположение и ориентацию снимка на крайне большом изображении по высоте и ширине с географической привязкой к местности.
Условие задачи
--------------
Цель задачи — необходимо найти местоположение и ориентацию снимка на подложке.
Для лучшего понимания контекста задачи участникам стоит ознакомиться со следующими терминами:
* *Подложка*— крайне большое изображение по высоте и ширине с географической привязкой к местности, т.е. координаты каждого пикселя известны или их можно вычислить. Как правило, на изображении размещена большая площадь земли (квадратные километры и более)
* *Аэрофотоснимок*— изображение со спутника или беспилотного летательного аппарата, направление камеры при фотографировании смотрело вертикально вниз. Имеет существенно меньшее разрешение в сравнении с подложкой. По сути фотография, сделанная на обычный фотоаппарат. Главная особенность в том, что аэрофотоснимок сделан в отличное от подложки время, время года, или даже в совершенно другой год или на разной высоте.
* *Перекрытие*— положение изображений, при котором одна и та же площадь местности видна на двух и более аэрофотоснимках. Взаимное ориентирование разновременных снимков разного разрешения подразумевает под собой сопоставление снимков и получение их географической привязки за счет ручного сопоставления оператором с картой.
### Данные
В качестве данных выступают аэрофотоснимки фиксированного размера:
* *train/img* — папка, содержащая 800 фотографий тренировочного набора;
* *train/json* — папка с данными в формате json со следующими значениями
+ *left top*— координата левого верхнего угла фотографии относительно подложки;
+ *right top*— координата правого верхнего угла;
+ *left bottom*— координата левого нижнего угла;
+ *right bottom*— координата правого нижнего угла;
+ *angle*— угол поворота.
* *test/* — папка, содержащая 400 фотографий для предсказания;
* *original.tiff* — подложка с расширением 10496 x 10496:
### На что стоит обратить внимание
Снимки сделаны в разные временные промежутки и при различных погодных условиях. Например, часть поверхности может быть скрыта за облаками. Стоит также заметить, что фотографий для обучения мало, расширить набор для обучения можно за счет самостоятельной нарезки фотографий с подложки.
### Метрика
Для такой специфичной задачи разработана своя метрика, которая определяет разницу между предсказанным центром, углом поворота фотографии и их оригинальными значениями.
Формула расчета метрики
(позже была скорректирована, так как 10 градусов
или 350 градусов это ошибка в 10 градусов, а не в 350)Подробно о решении
------------------
### Методология решения
В базовом решении предложено решить задачу, как регрессии. Таргетными значениями данном случае выступают 4 координаты и угол поворота изображения относительно оригинального.
Схема решения будет следующей:
1. Установка и импорт всех библиотек
2. Предобработка данных
3. Создание загрузчиков (DataLoader) для подачи данных в модель
4. Вспомогательные функции для обучения модели
5. Создание и обучение модели
6. Тестирование полученного решения
### Какие библиотеки нам нужны
Начнем с импорта всех необходимых библиотек. В качестве фреймворка для обучения нейросети выбран *torch*.
```
# Общие библиотеки
import pandas as pd
import numpy as np
import glob
from tqdm import tqdm
import os
from sklearn.model_selection import train_test_split
import json
from math import sin, cos
# Для создания и обучения модели
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset
from torchvision import datasets, models, transforms
# Для работы с изображениями
import cv2
from PIL import Image
# Для визуализации
import matplotlib.pyplot as plt
from IPython.display import clear_output
```
### Преобразование начального датасета
На данном этапе данные, хранящиеся в json файлах, преобразовываются в pandas-датафрейм.
```
json_dir = "/content/json/"
data_df = pd.DataFrame({'id': [], "left_top_x": [], 'left_top_y': [], "right_bottom_x": [], 'right_bottom_y': [], 'angle': []})
json_true = []
for _, _, files in os.walk(json_dir):
for x in files:
if x.endswith(".json"):
data = json.load(open(json_dir + x))
new_row = {'id':x.split(".")[0]+".img", 'left_top_x':data["left_top"][0], 'left_top_y':data["left_top"][1], 'right_bottom_x': data["right_bottom"][0], "right_bottom_y": data["right_bottom"][1], 'angle': data["angle"]}
data_df = data_df.append(new_row, ignore_index=True)
data_df.head(5)
```
Преобразованный датасет### Загрузчик данных
Для эффективного обучения нейросети данные нужно подавать в виде батчей. Батч хранит в себе несколько экземпляров данных. К примеру, в базовом решении параметр *batch\_size* равен 16, то есть каждый батч, подаваемый в модель содержит в себе 16 экземпляра данных. Ниже представлен один из вариантов реализации подобного загрузчика данных.
Сначала напишем класс, в котором данные непосредственно загружаются и приводятся в нужный формат.
```
class ImageDataset(Dataset):
def __init__(self, data_df, transform=None):
self.data_df = data_df
self.transform = transform
def __getitem__(self, idx):
# достаем имя изображения и ее лейбл
image_name, labels = self.data_df.iloc[idx]['id'], [self.data_df.iloc[idx]['left_top_x']/10496,
self.data_df.iloc[idx]['left_top_y']/10496,
self.data_df.iloc[idx]['right_bottom_x']/10496,
self.data_df.iloc[idx]['right_bottom_y']/10496,
self.data_df.iloc[idx]['angle']/360]
# читаем картинку. read the image
image = cv2.imread(f"/content/train/{image_name}")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image = Image.fromarray(image)
# преобразуем, если нужно. transform it, if necessary
if self.transform:
image = self.transform(image)
return image, torch.tensor(labels).float()
def __len__(self):
return len(self.data_df)
```
Далее зададим аугментации, которые будут использоваться при обучении модели.
```
train_transform = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
valid_transform = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
```
Посмотрим на количество данных и разделим их на тренировочную и валидационную части.
```
from os import listdir
print("Обучающей выборки " ,len(listdir("/content/train")))
print("Тестовой выборки " ,len(listdir("/content/test")))
Обучающей выборки 800
Тестовой выборки 400
```
```
# разделим датасет на трейн и валидацию, чтобы смотреть на качество
train_df, valid_df = train_test_split(data_df, test_size=0.2, random_state=43)
```
Каждую из выборок подадим в ранее созданный класс. После чего обернем это в другой класс, уже существующий в библиотеке *torch - DataLoader*.
```
train_dataset = ImageDataset(train_df, train_transform)
valid_dataset = ImageDataset(valid_df, valid_transform)
```
```
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=16,
shuffle=True,
pin_memory=True,
num_workers=2)
valid_loader = torch.utils.data.DataLoader(dataset=valid_dataset,
batch_size=16,
# shuffle=True,
pin_memory=True,
num_workers=2)
```
### Вспомогательные функции
Для обучения модели нам понадобятся функции расчета метрики, построения графика обучения и непосредственно обучения.
Ниже приведена функция рассчета метрики. Важное замечание - метрика для лидерборда рассчитывается исправленной метрикой, что именно исправлено можно прочитать в разделе "Метрика".
```
def compute_metric(data_true, data_pred, outImageW = 10496, outImageH = 10496):
x_center_true = np.array((data_true[0] + data_true[2])/2).astype(int)
y_center_true = np.array((data_true[1] + data_true[3])/2).astype(int)
x_metr = x_center_true - np.array((data_pred[0] + data_pred[2])/2).astype(int)
y_metr = y_center_true - np.array((data_pred[1] + data_pred[3])/2).astype(int)
metr = 1 - 0.7 * (abs(x_metr)/outImageH + abs(y_metr)/outImageW)/2 + 0.3 *abs(data_pred[4] - data_true[4])/359
return metr
```
Функция визуализации графиков обучения.
```
def plot_history(train_history, val_history, title='loss'):
plt.figure()
plt.title('{}'.format(title))
plt.plot(train_history, label='train', zorder=1)
points = np.array(val_history)
steps = list(range(0, len(train_history) + 1, int(len(train_history) / len(val_history))))[1:]
plt.scatter(steps, val_history, marker='+', s=180, c='orange', label='val', zorder=2)
plt.xlabel('train steps')
plt.legend(loc='best')
plt.grid()
plt.show()
```
Процесс обучения модели написан вручную без готовых функций (таких как TrainEpoch). Это дает более четкий контроль процесса обучения и возможность его кастомизировать.
```
def train(res_model, criterion, optimizer, train_dataloader, test_dataloader, NUM_EPOCH=15):
train_loss_log = []
val_loss_log = []
train_acc_log = []
val_acc_log = []
for epoch in tqdm(range(NUM_EPOCH)):
model.train()
train_loss = 0.
train_size = 0
train_pred = []
for imgs, labels in train_dataloader:
optimizer.zero_grad()
imgs = imgs.cuda()
labels = labels.cuda()
y_pred = model(imgs)
loss = criterion(y_pred, labels)
loss.backward()
train_loss += loss.item()
train_size += y_pred.size(0)
train_loss_log.append((loss.data.cpu().detach().numpy() / y_pred.size(0)) * 100)
y_pred[:, :4] = y_pred[:, :4] * 10496
y_pred[:, -1] = y_pred[:, -1] * 360
labels[:, :4] = labels[:, :4] * 10496
labels[:, -1] = labels[:, -1] * 360
for label, pr in zip(labels, y_pred):
train_pred.append(compute_metric(label.cpu().detach().numpy(), pr.cpu().detach().numpy()))
optimizer.step()
train_acc_log.append(train_pred)
val_loss = 0.
val_size = 0
val_pred = []
model.eval()
with torch.no_grad():
for imgs, labels in test_dataloader:
imgs = imgs.cuda()
labels = labels.cuda()
pred = model(imgs)
loss = criterion(pred, labels)
pred[:, :4] = pred[:, :4] * 10496
pred[:, -1] = pred[:, -1] * 360
labels[:, :4] = labels[:, :4] * 10496
labels[:, -1] = labels[:, -1] * 360
val_loss += loss.item()
val_size += pred.size(0)
for label, pr in zip(labels, pred):
val_pred.append(compute_metric(label.cpu().detach().numpy(), pr.cpu().detach().numpy()))
val_loss_log.append((val_loss / val_size)*100)
val_acc_log.append(val_pred)
clear_output()
plot_history(train_loss_log, val_loss_log, 'loss')
print('Train loss:', (train_loss / train_size)*100)
print('Val loss:', (val_loss / val_size)*100)
print('Train metric:', (np.mean(train_pred)))
print('Val metric:', (np.mean(val_pred)))
return train_loss_log, train_acc_log, val_loss_log, val_acc_log
```
### Обучение модели
В качестве модели используем *resnet50*, предобученный на датасете *imagenet* с выходным слоем размером 5, так как мы хотим предсказывать 5 параметров. Функцией потерь же будет MSELoss, используемый в задачах регрессии.
```
torch.cuda.empty_cache()
# Подргружаем модель
model = models.resnet50(pretrained=True)
model.fc = nn.Linear(2048, 5)
model = model.cuda()
criterion = torch.nn.MSELoss()
optimizer = torch.optim.Adam(model.fc.parameters(), lr=0.001)
```
Запустим обучение и понаблюдаем за изменением лоссов.
```
train_loss_log, train_acc_log, val_loss_log, val_acc_log = train(model,
criterion,
optimizer,
train_loader,
valid_loader,
15)
```
Логи обучения модели### Проверка модели
Посчитаем метрику на датасете для валидации. Получаем метрику 0.98. Однако, не стоит забывать о том, что обучались мы на небольшом наборе данных и итоговая метрика на лидерборде может отличаться.
```
total_metric = []
for imgs, labels in valid_loader:
imgs = imgs.cuda()
labels = labels.cpu().detach().numpy()
pred = model(imgs)
pred = pred.cpu().detach().numpy()
pred[:, :4] = pred[:, :4] * 10496
pred[:, -1] = pred[:, -1] * 360
labels[:, :4] = labels[:, :4] * 10496
labels[:, -1] = labels[:, -1] * 360
for label, pr in zip(labels, pred):
total_metric.append(compute_metric(label, pr))
total_metric = np.mean(total_metric)
print('Valid metric:', total_metric)
Valid metric: 0.9801261833663446
```
### Создадим предсказания на тестовом наборе данных
Для начала нужно написать класс для загрузки тестовых данных, аналогичный тому, что написан для тренировочных.
```
class TestImageDataset(Dataset):
def __init__(self, files, transform=None):
self.files = files
self.transform = transform
def __getitem__(self, idx):
image_name = self.files[idx]
# читаем картинку. read the image
image = cv2.imread(f"/content/test/{image_name}")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image = Image.fromarray(image)
# преобразуем, если нужно. transform it, if necessary
if self.transform:
image = self.transform(image)
return image
def __len__(self):
return len(self.files)
```
Далее собираем названия всех тестовых файлов и объявляем даталоадер с размером батча 16, так как тестовых картинок 400, а 400%16==0.
```
test_images_dir = '/content/test/'
for _, _, test_files in os.walk(test_images_dir):
break
test_dataset = TestImageDataset(test_files, valid_transform)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=16,
# shuffle=True,
pin_memory=True,
num_workers=2
)
```
Собираем предсказания в список.
```
indexes = [x.split('.')[0] for x in test_files]
preds = []
for imgs in test_loader:
imgs = imgs.cuda()
pred = model(imgs)
pred = pred.cpu().detach().numpy()
pred[:, :4] = np.clip(pred[:, :4] * 10496, 0, 10496)
pred[:, -1] = np.clip(pred[:, -1] * 360, 0, 360)
preds.extend(list(pred))
```
Записываем полученные предсказания в нужный для сабмита формат. После чего можно сжать все .json-файлы в архив и загрузить его на платформу.
```
sub_dir = "/content/submission/"
if not os.path.exists(sub_dir):
os.makedirs(sub_dir)
json_true = []
for indx, pred in zip(indexes, preds):
pred = [int(x) for x in pred]
left_top = [pred[0], pred[1]]
right_top = [pred[2], pred[1]]
left_bottom = [pred[0], pred[3]]
right_bottom = [pred[2], pred[3]]
res = {
'left_top': left_top,
'right_top': right_top,
'left_bottom': left_bottom,
'right_bottom': right_bottom,
'angle': pred[4]
}
with open(sub_dir+indx+'.json', 'w') as f:
json.dump(res, f)
```
Пример того, что содержит в себе каждый .json-файл.
```
{
"left_top": [7000, 4000],
"right_top": [6000, 4000],
"left_bottom": [7000, 3000],
"right_bottom": [6000, 3000],
"angle": 178
}
```
Рекомендации по улучшению решения
---------------------------------
* Первым вариантом улучшения решения является увеличения количества эпох и дообучение модели.
* Также можно попробовать изменить архитектуру модели на более сложную.
* Попробовать создать ансамбль моделей и применить метод TTA (Test Time Augmentation).
* Поменять размер входных изображений и изучить возможность улучшить используемые аугментации.
* Расширить датасет из предоставленной подложки или из сторонних ресурсов.
* Поразмышлять над иными подходами к решению задачи - не регрессии.
Итоги
-----
Кейс весьма интересен за счет нестандартной постановки задачи. Есть простор для экспериментов над подходами. А если вам удастся подобрать эффективный подход, то еще и сможете получить денежный приз до 250 тысяч рублей!
Все интересующие вас вопросе вы можете задать в [канале Зайцем по ХаХатонам](https://t.me/hahatons).
Всем удачи на чемпионатах и хакатонах! | https://habr.com/ru/post/676080/ | null | ru | null |
# Автоматизируем тестирование на проникновение с apt2
20 сентября состоялся очередной [релиз](https://www.kali.org/news/kali-linux-2017-2-release/) популярного дистрибутива для проведения тестирования на проникновение Kali Linux 2017.2. Среди нововведений мы получили возможность установить из репозитория несколько новых инструментов. В данном тексте мы рассмотрим фреймворк apt2 или Automated Penetration Testing Toolkit.
Установка и настройка
---------------------
После обновления дистрибутива до версии 2017.2 можно приступать к установке фреймворка.
Напомню, что обновиться до последней версии Kali Linux можно при помощи следующих команд
```
apt-get update
apt-get upgrade
apt-get dist-upgrade
```
Установка происходит стандартно
```
apt-get install apt2
```
Далее рекомендую провести базовую настройку.
Изучив [официальный github проекта](https://github.com/MooseDojo/apt2) становится ясно, что он интегрируется с Metasploit Framework.
Для интеграции с Metasploit нужно запустить его RPC сервис.
Делается это следующим образом
```
msfconsole
load msgrpc
```
Вы должны получить случайно сгенерированный пароль. Запомните его.
Можно посмотреть на структуру конфигурационного файла в каталоге /usr/share/apt2
Нас интересует файл default.cfg
В блоке [metasploit] указываем наш пароль
```
[metasploit]
msfhost=127.0.0.1
msfport=55552
msfuser=msf
msfpass=kqVbTlmr
msfexploitdelay=20
```
Далее вы можете добавить дополнительные ключи для nmap или изменить подсеть. По умолчанию используется SYN сканирование (-sS) и флаг (-A), что указывает Nmap провести определение версий сервисов, типа и версии ОС, выполнить безопасные NSE скрипты и traceroute. В некоторых случаях будет нелишним добавить ключ -Pn, если вы не импортируете в apt2 результат сканирования nmap.
```
[nmap]
scan_target=192.168.1.0/24
scan_type=S
scan_port_range=1-1024
scan_flags=-A
```
По умолчанию используется 20 потоков. Это значение можно не менять без необходимости.
```
[threading]
max_modulethreads=20
```
Есть настройка для Reponder. Если Вы используете нестандартную конфигурацию, нужно отредактировать блоки [responder] и [default\_tool\_paths]. Я задам responder\_timeout=30, так как не хочу тратить время на этот модуль.
Далее идет блок [searching]
```
[searching]
file_search_patterns=*.bat,*.sh,*passwd*,*password*,*Pass*,*.conf,*.cnf,*.cfg,*.config
```
Здесь можно задать маски файлов, которые нас интересуют, если мы получим доступ, например, к NFS ресурсу. Можно добавить что-то свое или не менять.
Также фреймворк позволяет использовать API Shodan. Ключи задаются в отдельном блоке и по умолчанию закомментированы. Я не буду их использовать, так как моя целевая машина находится в локальной сети. Напомню, что процесс получения API ключей для каждого сервиса индивидуален и не всегда бесплатен. API ключ для Shodan можно получить бесплатно после регистрации на [сайте](https://www.shodan.io/).
```
[apikeys]
#apt2_shodan_apikey=CHANGEME
#apt2_linkedin_apikey=CHANGEME
```
Запуск
------
При запуске с ключом -h мы получаем список доступных ключей
Разберем некоторые из них
**SAFE\_LEVEL** может принимать значения от 1 до 5 и указывает apt2 насколько безопасные модули разрешено запускать. Самые безопасный режим — 5. По умолчанию используется 4.
**EXCLUDE\_TYPES** позволяет исключить определенные типы модулей из списка.
**--target** задает цели, либо вы можете использовать ключ **-f**, чтобы загрузить в apt2 XML файл с результатами сканирования nmap. Напомню, что сохранить результат работы nmap в XML можно при помощи ключа -oX.
и ключ **--listmodules** покажет доступные модули. Давайте посмотрим на этот список
```
apt2 --listmodules
```
Получаем список с указанием имени модуля, его типа (используется для EXCLUDE\_TYPES), Safety Level и описания. Модули с Safety Level ниже, чем указано ключом -s выполнены не будут, о чем будет дополнительно сказано в выводе apt2 при запуске.
Давайте запустим apt2 с максимальным уровнем риска против машины 192.168.1.4, на которой работает Ubuntu.
```
apt2 -v -v -s 1 -b --target 192.168.1.4
```
Нас предупреждают, что модули, требующие API ключи не будут выполнены и начнется сканирование
Далее начнут запускаться модули
Посмотреть, что смог собрать apt2 можно в директории /root/.apt2/proofs
Здесь вы можете просмотреть результат работы каждого модуля. В моем случае фреймворк не обнаружил ничего стоящего.
Запустим еще одно сканирование в отношении Windows машины 192.168.1.7 и не будем выполнять сканирование nmap через apt2, а загрузим XML файл.
```
nmap -n -Pn -A -oX scan1 192.168.1.7
apt2 -s 1 -b -v -v -f scan1
```
Здесь уже запускаются другие модули, например модуль для тестирования на уязвимость к [ms08-067](https://technet.microsoft.com/ru-ru/library/security/ms08-067.aspx?f=255&MSPPError=-2147217396).
Если сервер уязвим, об этом будет сказано в логе
```
[!] VULN [ms08-067] Found on [192.168.1.7]
```
и уязвимость будет проэксплуатирована через сервис Metasploit RPC автоматически и мы получим сессию
Далее через сессию уже будут выполнены другие модули.
И в конце работы программы будет создан отчет о проделанной работе
```
firefox /root/.apt2/reports/reportGenHTML_flcgfsqhji.html
```
Если вы хотите написать свои модули для apt2, можно изучить имеющиеся в директории /usr/share/apt2/modules и сделать собственные по аналогии. Сам фреймворк написан на python и модули к нему, соответственно, тоже. | https://habr.com/ru/post/338460/ | null | ru | null |
# Рецепт полезного код-ревью от разработчика из Яндекса
Привет. Меня зовут Сергей, последние пять лет я работаю в Яндексе. За это время участвовал в разработке одиннадцати проектов. Писал код на JavaScript, Python и C++. Некоторые проекты делал в одиночку, другие разрабатывал в группе из восьми человек. Но в каждой команде, на всех проектах, вне зависимости от языка программирования я использовал код-ревью.
С помощью код-ревью я постоянно узнаю что-то новое. Иногда, глядя на чужой код, хочется воскликнуть: "А что, так тоже можно?". В чужом коде я нахожу интересные приёмы и беру их себе на вооружение. Много новых знаний черпаю из комментариев к моему коду. Для меня стало открытием, что люди любят делиться своим опытом. Даже когда я разрабатываю проект в одиночку, то прошу ребят из другой команды посмотреть мои пулреквесты. Это мотивирует писать красивый и понятный код.
Но так было не всегда. Когда-то ревью было для меня наказанием. Я мог неделю с вдохновением писать код, вкладывая в него все силы. Отправлял пулреквест, трижды пинговал ревьювера, а в ответ получал сухое "вроде ок" или, что ещё хуже, десятки комментариев не по существу.
Мне на ревью приходили пулы из пяти тысяч строк. Я часами пытался разобраться в коде, по сотне раз скроллил от функции к тесту и обратно. Писал десятки бесполезных комментариев о пропущенной точке с запятой. Всё это жутко меня раздражало. Часто откладывал ревью на потом, и у меня накапливались десятки непросмотренных пулов.
Если вы чувствовали это на себе, значит, статья для вас. Сегодня я расскажу о приёмах и инструментах, которые использую каждый день на протяжении пяти лет ежедневного код-ревью.
«До ревью». Советы автору
-------------------------
Представьте, что решение задачи – это приготовление блюда. Вы работаете в команде, поэтому вам нужно не просто приготовить, а ещё и научить этому других поваров. Не достаточно показать им результат, нужно записать рецепт.
### Коммиты
Каждый шаг рецепта – это коммит: разбили два яйца – закоммитили, добавили стакан молока – закоммитили, насыпали двести граммов муки – снова закоммитили.
В каждом коммите я выражаю одну простую мысль. Это может быть реализация метода модели или компонент в вёрстке. Так ревьюверу будет проще меня понять. Я не сваливаю на него всю задачу, которую невозможно проглотить за раз, а рассказываю о решении по кусочкам.
Любой рефакторинг выношу в отдельный коммит. Зачастую рефакторинг носит чисто технический характер, например, переименование метода. Ревьюверу не нужно вчитываться в каждую строчку такого изменения. Он пробежит глазами "по диагонали" и сможет уделить больше времени более важному коду.
Крошите, разбивайте, измельчайте свой код на маленькие коммиты. Это позволит ревьюверу лучше разобраться в вашем коде. Ничего страшного, если вы переборщите с декомпозицией. Два коммита легко объединить в один. Гораздо сложнее разделить большой коммит на несколько маленьких. "Нарезанные овощи" легко получить перемешивая "нарезанные помидоры" и "измельчённый лук". Но чтобы получить из тарелки салата все ингредиенты по частям, нужно потратить намного больше времени.
После коммита я сразу пушу изменения на гитхаб. Это пару раз выручало меня, когда случались "кофейные неприятности" с ноутбуком.
### Описание коммитов
Когда я пишу email, то заполняю заголовок и содержимое письма. Заголовок — короткое и ёмкое название, тело письма — развёрнутое, подробное описание с картинками и ссылками. Такой же подход применяю к описанию коммитов.
Я давно отказался от коммитов командой `git commit -m 'fix1'`. Вместо этого выполняю команду `git commit`, которая открывает текстовый редактор. В первой строке указываю короткое и ёмкое описание коммита (как в заголовке письма). После пробельной строки раскрываю детали реализации (подобно содержимому емэйла).
Не люблю рецепты, где пишут "добавьте щепотку соли" или "выпекайте до готовности". Щепотка у каждого своя, а глядя на курочку в фольге я не могу определить её готовность. В описании коммитов стараюсь избавляться от всех неоднозначностей. При помощи ASCII-графики описываю тестовый пример. Если решению предшествовало обсуждение, где мы рисовали схемы на доске или в блокноте, то прикладываю к описанию ссылку на фотографию.
[](https://habrastorage.org/webt/bn/iq/xt/bniqxtq5v58if9-t5ukumhionny.png)
*(пример описания коммита с использованием ASCII-графики)*
[](https://habrastorage.org/webt/2b/v7/fo/2bv7foifebsx6r0ovpwszxmptea.png)
*(пример описания пулреквеста с заголовком и телом. Для редактирования комментария я использовал консольный редактор vim)*
[](https://habrastorage.org/webt/qe/yg/on/qeygonts-ty_x6sdrd6vnbsz21m.png)
*(пример отображения коммита с описанием на GitHub. По стрелкам в правом верхнем углу можно перемещаться между коммитами)*
### Самопроверка
Перед подачей блюда повар снимает пробу, выкладывает на красивую тарелку, добавляет украшение. Мы будем делать это тремя командами:
```
git status
git diff comments.js
git add comments.js
```
Я выполняю их столько раз, сколько файлов изменил. Намеренно не делаю `git add .`, чтобы посмотреть каждый файл по отдельности. Так я проверяю самого себя, смотрю на свой код свежим взглядом.
### Проверка кодстайла
Не представляю свою жизнь без линтера. Это инструмент, который автоматически проверяет соответствие кода выбранному стилю. Для JavaScript я использую [ESlint](https://eslint.org). Можно сравнить линтер с роботом R2-D2 из "Звёздных воин", который ходит по коду и приводит его в порядок. Места, которые он не может исправить сам, подчеркивает красным.
С моим любимым [WebStorm](https://www.jetbrains.com/webstorm/) этот линтер работает "из коробки". Я вижу и исправляю проблему сразу, как только написал код, а не оставляю эту работу на потом. Перед коммитом линтер запускается автоматически при помощи [husky](https://www.npmjs.com/package/husky).
Код после линтера приятно смотреть. Я избавляю ревьювера от необходимости писать десятки бесполезных комментариев о пропущенном пробеле. Всё внимание будет сконцентрировано на действительно важных вещах.
[](https://habrastorage.org/webt/df/rh/9q/dfrh9qgh_zhwdnkug-lx89wvbi4.png)
*(пример запуска линтера на коммит)*
### Описание пулреквеста
Если коммит – это шаг рецепта, то пулреквест – это рецепт целиком. Когда все шаги описаны хорошо, то написать рецепт не составит труда. Можно создать описание пулреквеста командой `git log --pretty='%h: %B' --first-parent --no-merges --reverse`.
[](https://habrastorage.org/webt/vb/ta/l0/vbtal0q7g7-ogijuipzs4xscbcc.png)
*(пример выполнения команды `git log --pretty='%h: %B' --first-parent --no-merges --reverse`)*
[](https://habrastorage.org/webt/5h/ea/cx/5heacxtzwgoomptgspjrhfrsjba.png)
*(пример описания пулреквеста текстом, если скопировать результат вывода предыдущей команды)*
Хеши коммитов становятся ссылками, по которым может ориентироваться ревьювер. Они остаются рабочими, даже если объединить все коммиты в один. Подробнее про объединения поговорим дальше.
Пулреквест готов! Но не спешите закрывать задачу, самое интересное ещё впереди.
«Во время ревью». Советы ревьюверу
----------------------------------
Давайте ненадолго отвлечемся от создания пулреквеста и представим себя на месте ревьювера – человека, которому прислали код на проверку.
### Ревью архитектуры
Перед тем как смотреть код, я стараюсь понять какую задачу решает автор. Читаю описание пулреквеста, перехожу по ссылкам в ишью, изучаю схемы и фотографии. Иногда, ошибка кроется в постановке задачи. Хороший ревьювер оценивает идею, а не выступает в роли "продвинутого линтера".
В любой непонятной ситуации задаю вопрос. Даже если он кажется мне глупым или банальным. Таким вопросом я могу натолкнуть автора на правильную мысль.
### Задача ревьювера – показать альтернативы
В некоторых случаях я не согласен с предложенным решением. Это нормально! У каждого программиста своё мнение. Если код автора объективно хороший, то я не пытаюсь переубедить его. Максимум высказываю предложение, подкрепляя его ссылками, бенчмарками или картинками. Это позволяет вести конструктивный диалог, а не переходить на личности.
### Единый стиль
Код автора может выглядеть не оптимальным на первый взгляд. Он написан так, как принято делать в проекте. В таком случае лучше оставить вариант автора.
Разберёмся на примере. Автор написал функцию суммирования массива чисел таким образом:
```
function sum(arr) {
return arr.reduce(function (res, i) {
return res + i;
}, 0);
}
sum([1, 2, 3]); // 6
```
Такой код можно переписать компактнее, используя стрелочные функции:
```
const sum = arr => arr.reduce((res, i) => res + i);
```
Но проект начинали тогда, когда ещё не было стрелочных функций. Если написать компактное решение, то код перестанет быть единообразным, в нём станет сложно разбираться. Либо оставляем вариант автора, либо переписываем все функции на стрелочные. Главное – сохранить единый стиль.
### Offline
Иногда, мне на ревью приходит очень большой и сложный пулреквест. Автор старался две недели, а мне предстоит осознать полёт его мысли и вникнуть в каждую строчку за несколько часов. Одному мне не справиться.
В таком случае я прошу автора об offline-ревью. Ставлю рядом складной стульчик (кстати, не используйте мягкий: рискуете тем, что ревью затянется надолго), сажу автора возле себя и прошу рассказать его о решении.
Эффективность такого подхода невысокая. Во-первых, тратится время двух разработчиков. Во-вторых, легко начать злоупотреблять этой практикой: слишком велик соблазн не думать самостоятельно над кодом автора (пусть придёт и расскажет). В-третьих, я погружаюсь в ход мыслей автора, невольно принимая его за правильный — так я не вырабатываю свою точку зрения.
Опасная практика, но порой без неё не обойтись. Применяйте offline-ревью с осторожностью.
«После ревью». Советы автору
----------------------------
Вернёмся к пулреквесту, который я готовил в первой части статьи. Ревьювер написал комментарии. Наступает этап правок и обсуждений.
### Диалог
Если я согласен с замечанием, то исправляю его и пишу в комментарии что исправил. Ревьюверу будет приятно увидеть, что я прислушался к нему, а я сразу вижу какие замечания поправил, а какие нет. Если не согласен, то задаю ревьюверу вопросы: почему он так считает? правильно ли он понял мою мысль? чем он может подкрепить свою точку зрения? Стараюсь завязать конструктивный диалог, в ходе которого мы докопаемся до истины.
Я отвечаю на комментарии во вкладке с файлами. Так ревьювер получит одно письмо со всеми отметками и вопросами, а не по письму на каждый комментарий.
[](https://habrastorage.org/webt/vm/67/5q/vm675qgzqdowizpv1pbq2og1brm.png)
*(пример ответа на ревью: комментируйте на вкладке с файлами и благодарите ревьювера в конце)*
В конце обязательно благодарю ревьювера. Он потратил своё время на то, чтобы вникнуть в мой код и сделать его лучше. Разве это не заслуживает приятных слов? В следующий раз этот человек возьмётся за мой пулреквест с бо'льшим энтузиазмом, потому что видит важность своих советов и уважение с моей стороны.
### История коммитов
Разделение на микрокоммиты помогает на код-ревью. Для истории такое разделение избыточно. До этого я старался разделять код на коммиты так, чтобы каждый коммит описывал шаг рецепта. Настало время объединить коммиты пулреквеста в один, чтобы получить готовое блюдо, которым будет легко оперировать при сервировке стола.
Объединить коммиты можно командой `git rebase --interactive master`. Напомню, что я работаю в фичебранче `FEATURE-1`, а `master` — это название основной ветки. После выполнения команды откроется текстовый редактор, в котором первый коммит оставляю без изменений, а у второго и последующих заменяю `pick` на `squash`. Так содержимое второго и последующих коммитов добавляется в первый.
[](https://habrastorage.org/webt/zn/-o/cd/zn-ocd9rr5pc-4hbi8ihcijpbrk.png)
*(пример ребейза, в котором четыре последние коммита сливаются в один)*
После этого нужно запушить изменение с флагом `--force`. Я преписал историю, и на удалённом сервере возник конфликт локальной версии и ранее известной. Командой `git push origin FEATURE-1 --force` я сообщаю серверу, что локальную версию изменений нужно считать правильной. Все готово для того, чтобы влить изменения.
Можно обойти трудности описанные выше используя новые возможности интерфейса GitHub. Для этого перед мержем выбираем пункт "Squash and merge".
[](https://habrastorage.org/webt/cf/ko/kd/cfkokdyijagikc3exwpz29a-ucy.png)
*(пример объединения коммитов при мерже через интерфейс GitHub)*
После приготовления блюда повар убирает своё рабочее место, моет ножи и вытирает стол. Я сделаю то же самое с веткой `FEATURE-1`. Удаляю локальную версию командами:
```
git checkout master
git pull origin master
git branch -D FEATURE-1
```
[](https://habrastorage.org/webt/xz/xz/mp/xzxzmpod7oc74i1s-9rhmon4neq.png)
*(Серверную версию ветки можно удалить по кнопке сразу после мержа пулреквеста.)*
Заключение
----------
В заключение, ещё раз коротко о командах, которые я использую:
```
# Создаю и переключаюсь на фичебранч
git checkout -b FEATURE-1
# Отсматриваю изменения
git status
git diff src/controllers/v1/comments.js
git add src/controllers/v1/comments.js
# Создаю и пушу коммит
git commit
git push origin FEATURE-1
# Готовлю описание к пулреквесту
git log --pretty='%h: %B' --first-parent --no-merges --reverse
# Исправляю историю после ревью
git rebase --interactive master
git push origin FEATURE-1 --force
# Удаляю фичебранч
git checkout master
git pull origin master
git branch -D FEATURE-1
```
Вопросы
-------
**Что делать, если нужно внести правки в старый коммит, который я уже сделал?**
Две команды:
```
# Добавляем файлы, которые нужно прикрепить к последнему коммиту
git add comment.js
# Прикрепляем к последнему коммиту
git commit --amend
```
Если правки нужно внести в более ранний коммит, то есть два варианта. Самый простой — сделать новый коммит и объединить его со старым. Вариант посложнее — выполняя команду `git rebase --interactive master`, нужно перенести строчку с новым коммитом под старый и заменить `pick` на `squash`.
[](https://habrastorage.org/webt/4_/fp/18/4_fp18ud6cqizygvlkx7yhdaa2w.png)
Если в рабочей директории нет изменений, то вы можете сразу выполнить `git rebase --interactive master` и заменить `pick` на `edit` возле того коммита, в который нужно внести исправления.
**Я увлёкся и написал много кода, но, к счастью, хорошо понимаю, как его разбить по коммитам.
Что делать?**
Нет проблем, если разные файлы попадают в разные коммиты. Чуть сложнее становится, когда один файл нужно разбить на несколько коммитов. Для этого подходит частичное добавление. Сделать это можно командой `git add --patch test/comment-test.js`
[](https://habrastorage.org/webt/tk/za/ad/tkzaadxqne4olber3pbk_snzcgy.png)
**Как ты советовал, я разделил весь код на маленькие коммиты. В том числе коммиты, в которых есть правки к другим коммитам. Как прибраться?**
При выполнении команды `git rebase --interactive master` первым делом нужно определить порядок коммитов. Выстраивайте строки с коммитами в нужном вам порядке. Строки с ненужными коммитами удаляем. Если нужно объединить несколько коммитов, то у первого оставляем отметку `pick`, остальным заменяем `pick` на `squash`.
**Как приложить ссылку на фотографию?**
Копируем картинку в буфер обмена и вставляем в любое поле ввода на гитхабе. В комментарии к issue, коммиту или в поле описания пулреквеста. Спустя несколько секунд получим ссылку на картинку.
**Как сделать качественную фотографию маркерной доски или рисунка в блокноте?**
Я установил на сотовый телефон программу [Office Lens](https://itunes.apple.com/ru/app/office-lens/id975925059?mt=8). Она вычищает лишний мусор с фотографии, кропает, убирает искривления и позволяет быстро пошарить картинку в любой чатик.
**Уместен ли юмор в комментариях?**
Если по делу и без злоупотребления. В общем, всё как в жизни.
[](https://habrastorage.org/webt/pb/lv/bu/pblvbutg5w5_j38suo9orhtc9co.png) | https://habr.com/ru/post/422143/ | null | ru | null |
# Как рендерится кадр Middle Earth: Shadow of Mordor
[Middle Earth: Shadow of Mordor](https://en.wikipedia.org/wiki/Middle-earth:_Shadow_of_Mordor) была выпущена в 2014 году. Сама игра стала большим сюрпризом, и то, что она была спин-оффом сюжетной линии вселенной «Властелина кольца» оказалось довольно неожиданным. Игра обрела большой успех, и на момент написания статьи компания [Monolith](https://en.wikipedia.org/wiki/Monolith_Productions) уже выпустила сиквел — Shadow of War. Графика игры очень красива, особенно учитывая то, что она была выпущена для разных поколений консолей, в том числе Xbox 360 и PS3. Версия для PC довольно хорошо отполирована, содержит дополнительные графические опции и пакеты текстур высокого разрешения, полностью раскрывающие потенциал игры.
В игре используется относительно новый отложенный рендерер DX11. Я воспользовался [Renderdoc](https://github.com/baldurk/renderdoc), чтобы глубоко изучить приёмы рендеринга игры. При работе использовались максимально возможные параметры графики (ultra) и были включены все возможные «примочки», такие как независимая от порядка прозрачность, тесселяция, окклюзия в экранном пространстве и различные motion blur.
Кадр
----
Вот кадр, который мы будем анализировать. Игрок находится на деревянных подмостках в регионе Удун. В Shadow of Mordor используются механики, схожие с механиками таких игр, как Assassin’s Creed, где можно взбираться по зданиям и башням, а потом наслаждаться с крыш окружающим цифровым пейзажем.
Предварительный проход глубин
-----------------------------
Приблизительно 140 первых вызовов отрисовки выполняют быстрый предварительный проход для рендеринга самых крупных элементов рельефа и зданий в буфер глубин. Большинство объектов не попадают в этот предварительный проход, но он помогает, когда в игре очень большое количество вызовов отрисовки и можно смотреть далеко вдаль. Интересно, что персонаж, который всегда находится в центре экрана и занимает приличную долю экранного пространства, в этот проход не попадает. Как и во многих других играх с открытым миром, движок использует обратные значения z. Такая техника привязывает ближнюю плоскость к значению 1.0, а дальнюю — к значению 0.0 для повышения точности на больших расстояниях и предотвращения z-конфликтов. Подробнее о точности z-буфера можно прочитать [здесь](https://developer.nvidia.com/content/depth-precision-visualized).
#### G-буфер
Сразу после этого начинается проход G-буфера, выполняемый примерно за 2700 вызовов отрисовки. Если вы читали мой [предыдущий анализ Castlevania: Lords of Shadow 2](http://www.elopezr.com/castlevania-lords-of-shadow-2-graphics-study/) или изучали другие подобные статьи, то этот проход должен быть вам знаком. Свойство поверхностей записываются в набор буферов, которые затем считываются в проходах расчёта освещения для вычисления реакций поверхностей на свет. В Shadow of Mordor используется классический отложенный рендерер, но для достижения этой цели применяется относительно малое количество render targets G-буфера (3). Для сравнения: Unreal Engine в этом проходе использует 5-6 буферов. G-буфер имеет следующую схему:
##### Буфер нормалей
| | | | |
| --- | --- | --- | --- |
| **R** | **G** | **B** | **A** |
| **Normal.x** | **Normal.y** | **Normal.z** | **ID** |
Буфер нормалей хранит нормали в мировом пространстве в формате «8 бит на канал». Этого едва хватает, а иногда не хватает вовсе для описания плавно варьирующихся плоских поверхностей. Если приглядеться внимательно, это можно заметить в некоторых лужах в игре. Альфа-канал используется в качестве ID, помечающего различные типы объектов. Например, я выяснил, что 255 относится к персонажу, 128 — к анимированной части флага, а небо помечено ID 1, потому что позже эти идентификаторы используются для его фильтрации на этапе добавления (небо получает собственный радиальный bloom).
*В оригинале статьи эти и многие другие изображения анимированы для большей наглядности, так что рекомендую туда заглянуть.*
##### Буфер Albedo
| | | | |
| --- | --- | --- | --- |
| **R** | **G** | **B** | **A** |
| **Albedo.r** | **Albedo.g** | **Albedo.b** | **Cavity Occlusion** |
Буфер albedo хранит все три компонента albedo и маломасштабный occlusion (иногда называемый cavity occlusion), который применяется для затенения небольших деталей, которого нельзя достичь картой теней или постобработкой в экранном пространстве. В основном он используется для декоративных целей, например, прорех и складок на одежде, небольших трещин в дереве, небольших узоров на одежде Талиона и т.д.
При обработке врагов в шейдере albedo учитывает текстуру крови (интересно, что Талион никогда не получает видимых ран). Текстура крови является входными данными для этапа рендеринга одежды и тела врагов, но она задаёт не цвет крови, который является входными данными в буфере констант, а определяет множители/уровни крови для управления отображаемого количества крови. Также для масштабирования эффекта используется ориентация нормалей, позволяя контролировать направление брызг крови. Затем albedo по сути оттеняется яркостью полученных врагом ран, взятой из соответствующего места карты крови, а также модифицирует другие свойства, такие как specular, для получения убедительного эффекта крови. Мне не удалось найти часть кадра, в которой происходит рендеринг карты, но я предполагаю, что они записываются прямо в начале кадра, когда происходит воздействие меча, а затем используется здесь.
##### Specular-буфер
| | | | |
| --- | --- | --- | --- |
| **R** | **G** | **B** | **A** |
| **Roughness** | **Specular Intensity** | **Fresnel** | **Subsurface Scattering Factor** |
Specular-буфер содержит другие свойства поверхностей, которые можно ожидать увидеть в играх, такие как roughness (это не совсем roughness (шероховатость), а отмасштабированная степень specular, но её можно интерпретировать таким образом), specular intensity (яркость зеркального отражения), которая масштабирует albedo для получения верного цвета specular, reflectivity factor (коэффициент отражаемости) (обычно называемый в литературе F0, потому что он является входными данными для френелевского зеркального реагирования) и компонент subsurface scattering (подповерхностного рассеяния). Последний компонент используется для освещения просвечивающих материалов, таких как тонкая ткань, растения и кожа. Если позже мы погрузимся в изучение шейдера освещения, то обнаружим, что здесь используется вариация [нормализованная модель specular по Блинну-Фонгу](https://seblagarde.wordpress.com/2011/08/17/hello-world/).
##### Отложенные декали
Как мы увидели выше, Shadow of Mordor довольно подробно отображает следы крови на раненных персонажах. Когда Талион взмахивает мечом, окружение тоже получает свою долю тёмной орочьей крови. Однако для окружений используется другая техника — [отложенные декали](https://mtnphil.wordpress.com/2014/05/24/decals-deferred-rendering/). Эта техника состоит из проецирования набора плоских текстур на поверхность того, что было отрендерено ранее. Таким образом содержимое G-буфера заменяется этим новым содержимым перед выполнением прохода освещения. В случае крови достаточно просто кровавых брызг, и при рендеринге множества декалей по очереди быстро создаётся довольно мрачный ландшафт.
Последнее, что рендерится в проходе G-буфера — это небо, текстура неба очень высокого разрешения (8192×2048) в формате HDR BC6H. Мне пришлось выполнить небольшую тональную коррекцию, потому что в HDR все цвета слишком тёмные.
### Tessellation
Очень интересная «фишка» игры (если она включена) — это тесселяция. Она используется для множества разных вещей, от рельефа до рендеринга персонажа (а также пропсов и объектов персонажа). Здесь тесселяция не подразделяет низкополигональный меш, а создаёт полигоны из облака точек, применяя необходимую степень подразделения, зависящую от критериев уровня детализации, например, от расстояния до камеры. Интересным примером является плащ Талиона, который передаётся в GPU как облако точек (после симуляции физики), а шейдер тесселяции воссоздаёт полигоны.
### Независящая от порядка прозрачность
Одна из первых вещей, поразивших меня своей странностью — это проход обработки волос, потому что он выполняет очень сложный специальный шейдер. В опциях графики упоминается опция OIT (Order-Independent Transparency) для волос, то есть это должна быть она. Сначала она выполняет вывод в отдельный буфер и подсчитывает общее количество накладывающихся друг на друга прозрачных пикселей, одновременно сохраняя свойства в «глубинную» структуру, похожую на G-буфер. Позже другой шейдер сортирует отдельные отдельные фрагменты согласно их глубине. Похоже, что стрелы тоже рендерятся таким образом (наверно, их оперению требуется правильная сортировка). Это очень малозаметный эффект, не добавляющий особых графических отличий, но всё равно это интересная деталь. Вот простой пример: изображение выше отображает количество накладывающихся друг на друга фрагментов (чем краснее, тем больше фрагментов). Обычная прозрачность по-прежнему сортируется в ЦП и рендерится как традиционная альфа. В проход OIT попадают только отдельные сущности.
### Тени Мордора
В SoM есть множество источников теней. Кроме традиционных карт теней динамических источников освещения SoM использует двухканальное ambient occlusion в экранном пространстве, микромасштабное occlusion, создаваемое почти для всех объектов в игре, и текстура окклюзии, похожая на карту высот с видом сверху.
##### Окклюзия в экранном пространстве
Первый проход рендерит с помощью G-буфера ambient и specular occlusion в экранном пространстве. Сам шейдер — это огромный развёрнутый цикл, сэмплирующий и полноразмерную карту глубин, и предварительно уменьшенную усреднённую карту глубин, ища соседние сэмплы в заданном паттерне. Он использует квадратную текстуру 4×4 для выбора псевдослучайных векторов в поисках источников окклюзии. Он рендерит буфер шумной окклюзии, который затем сглаживается простым размытием в два прохода. Самая интересная особенность здесь в том, что есть два разных канала окклюзии: один из них применяется как specular occlusion, а другой как diffuse occlusion. В стандартных реализациях SSAO вычисляется один канал, который применяется ко всему запечённому освещению. Здесь также считывается карта SSAO для передачи в проход направленного освещения, где и применяется.
##### Карты теней
Следующее событие — рендеринг карты теней. Так как действие игры в основном происходит на открытых пространствах, бОльшая часть света и теней берётся от основного направленного света. Здесь используется техника [каскадных карт теней](https://msdn.microsoft.com/en-us/library/windows/desktop/ee416307(v=vs.85).aspx) (вариацией которого является [параллельные разделённые карты теней](http://http.developer.nvidia.com/GPUGems3/gpugems3_ch10.html)), достаточно стандартная техника наложения теней на дальних расстояниях, которая состоит из рендеринга той же сцены с одной точки зрения источника освещения для разных областей пространства. Обычно карты теней вдали от области охвата камеры или находятся на больших расстояниях, или имеют меньшее разрешение, чем предыдущие, по сути снижая разрешение в областях, в которых детали всё равно не требуются из-за того, что геометрия расположена слишком далеко. В этой сцене игра рендерит три каскада теней 4096×4096 (на самом деле в игре есть место для четырёх). Верхний каскад очень близко к Талиону, а нижний включает в себя горы и объекты очень далеко от камеры. При работе с тенями игра использует тот же трюк с обратной координатой z, что и в карте глубин.\
##### Буфер теней
Следующий этап — создание буфера теней. Это одноканальная текстура, на основании информации окклюзии от предыдущих карт теней кодирующая коэффициент затенения в интервале [0, 1]. Для создания плавности вокруг краёв карта теней сэмплируется 4 раза с помощью состояния специального билинейного сэмплера, который получает 4 сэмпла и сравнивает их с заданным значением (это называется [Percentage Close Filtering](http://http.developer.nvidia.com/GPUGems/gpugems_ch11.html)). Получение нескольких сэмплов и усреднение их результатов часто называется [Percentage Closer Soft Shadows](http://developer.download.nvidia.com/shaderlibrary/docs/shadow_PCSS.pdf). В дополнение к считыванию карты теней также сэмплируется последний компонент specular-буфера (то есть коэффициент подповерхностного рассеяния), который умножается на «коэффициент растекания света» (light bleed factor). Похоже, что это нужно, чтобы устранить затенение от этих объектов, чтобы через них проходило чуть больше света.
##### Текстура направленных проекций
Ещё одним источником света и теней является текстура с видом сверху, сэмплируемая направленным источником освещения. Это оттенок цвета, добавляемый к цвету источника направленного освещения, плюс влияние глобального затенения, которое применяется к направленному освещению. Кажется, некоторые из них созданы вручную поверх автоматически сгенерированной карты освещения уровня с видом сверху. Похоже, что края теней для статической геометрии подправлены вручную (возможно, чтобы избежать конфликтов с настоящей картой теней), а некоторые части кажутся тоже немного подкрашенными вручную. Вероятно, задача этой текстуры — малозатратное добавление крупномасштабного ambient occlusion и лёгкой имитаций global illumination в дополнение к направленному освещению. На изображениях ниже показаны оттенок, окклюзия и произведение обоих факторов, что даёт нам представление о том, как выглядит окончательная цветовая маска.
Результат всех проходов освещения сохраняются в render target формата R11G11B10F. Вот, как приблизительно выглядит результат. Я выполнил тональную коррекцию результатов, чтобы сделать нагляднее влияние направленного освещения на уровень.
Все далёкие горы (не показанные на изображении выше) тоже освещаются направленным светом, но они выделены как отдельный случай, чтобы можно было лучше контролировать освещение. Некоторые отмасштабированы, но находящиеся дальше на самом деле являются плоскими текстурами (impostors) с умно созданными картами нормалей и albedo. У них есть особые источники направленного освещения, влияющие только на горы.
### Статическое освещение
Shadow of Mordor использует очень требовательную к памяти реализацию статического освещения, в которой применяются очень большие объёмные текстуры. На изображении ниже показаны три статические текстуры объёма освещения, использованные для диффузного освещения части этой области. Каждая из них — это огромная сжатая текстура 512x512x128 BC6H, то есть они занимают 32 МБ на текстуру или 96 МБ в целом (мы ведь играем с максимальными настройками качества). Текстура цвета обозначает входящую в воксель интенсивность. Две другие обозначают силу или величину этой интенсивности вдоль всех шести направлений xyz и -xyz, а нормаль используется для выбора трёх компонентов (положительных или отрицательных xyz, тех, которые наиболее совпадают с нормалью). Построив этот вектор, мы берём его векторное произведение на квадрат нормали, и это становится коэффициентом масштабирования для интенсивности. Формула выглядит так:
Объёмы статического освещения (Static Light Volumes) также рендерят кубическую карту для specular lighting, которое вероятно захватывается в центре SLV. Довольно интересно то, что текстуры объёма хранят значения HDR сжатыми в BC6H, а кубические карты хранятся в формате BC3 (DXT5), который не может хранить значения с плавающей запятой. Чтобы компенсировать это ограничение, альфа-канал сохраняет яркость, которая затем масштабируется от 1-10. Это немного странное решение и для меня оно скорее выглядит как легаси-реализация. Не забывайте, что игра была выпущена и для консолей предыдущего поколения, которые не поддерживают новые форматы текстур HDR.
На кадрах ниже показаны результаты «до и после» с учётом воздействия среднего изображения. Для визуализации я выполнил тональную коррекцию.
### Атмосферный туман
В Shadow of Mordor есть система погоды и времени суток, благодаря которой при прохождении игры в Мордоре светит солнце или льёт дождь. Этой системой управляет сумма компонентов, и одним из самых важных является туман. Shadow of Mordor использует довольно простую, но физически обоснованную модель атмосферного тумана, в том числе и однократное рассеяние [Рэлея](https://www.youtube.com/watch?v=twSg2zbjjnA), а также рассеяние сферической частицей (Mie scattering).
Оно начинается с вычисления позиции камеры относительно [центра Земли](https://en.wikipedia.org/wiki/Earth_radius). Несколько тригонометрических формул позволяют определить, где в атмосфере находится камера, где находится пиксель, и какое расстояние прошёл луч в атмосфере при заданной максимальной высоте атмосферы. В нашем случае для атмосферы задана высота в 65000 метров над поверхностью планеты. С учётом этой информации применяются коэффициенты Рэлея и сферической частицы для вычисления и типов плотностей частиц тумана, и его цветов. Эти плотности затеняют уже затенённые пиксели, рассеивая свет, попадающий в камеру от затенённой поверхности, и вносит свой вклад в туман. При симуляции такого рассеяния учитывается яркость и направление солнца.
### Выдержка и тональная коррекция
При вычислении выдержки используется достаточно стандартный подход: последовательное снижение разрешения буфера яркости, вычисленного из основного буфера HDR-цвета, в цепочку текстур, каждая из которых в два раза меньше предыдущей текстуры, начиная с текстуры размером в 1/3 от основного буфера кадра. При этом снижении разрешения берутся 4 сэмпла, усредняющих значения соседних пикселей, то есть после сведения всех средних значений в единый тексел окончательный результат становится средней яркостью. После того, как текстура достигнет размера 16×9 текселов, запускается compute-шейдер, суммирующий все оставшиеся текселы. Это значение сразу же считывается в проходе тональной коррекции для изменения значений яркости.
При тональной коррекции используется вариант оператор Рейнхарда, оптимизированную формулу которого можно найти [здесь](http://filmicworlds.com/blog/filmic-tonemapping-operators/) и [здесь](http://duikerresearch.com/2015/09/filmic-tonemapping-for-real-time-rendering/). В коде на hlsl это будет выглядеть следующим образом:
```
float3 hdrColor = tex2D(HDRTexture, uv.xy);
hdrColor *= exposureValue; // This was calculated by the compute shader in the luminance downsampling pass
float3 x = max(0.0, hdrColor - 0.004);
float3 finalColor = (x * (6.2 * x + 0.5)) / (x * (6.2 * x + 1.7) + 0.06);
```
Если мы построим график этой кривой, то увидим, что этот оператор отбрасывает 10% белых значений даже при входном значении 2.0, в то же время принудительно оставляя небольшую часть нижнего интервала полностью чёрной. Это создаёт ненасыщенную, тёмную картинку.
### Этап альфы
Этап альфы немного необычен, потому что он рендерит объекты непосредственно в LDR-буфер. Другие игры рендерят их и в HDR-буфер, чтобы они могли участвовать в проходе выдержки. Как бы то ни было, ранее вычисленная текстура яркости ограничивается всеми освещёнными альфой объектами (в некоторых случаях, например, у испускающих свет объектов, выдержка вычисляется с помощью констант шейдера, а не поиска по текстуре), а потому выдержка применяется при отрисовке автоматически, а не выполняется в постобработке. Очень специфический случай использования в игре альфы — это переход в режим призрака (в нём поверх персонажа игрока рендерится призрак Келебримбора, выковавшего во вселенной LOTR кольца всевластья; таким образом игра показывает, что он всегда рядом, хоть и невидим). Игра передаёт в меши обоих персонажей несколько параметров, которые управляют непрозрачностью и позволяют игре частично затенить Талиона и постепенно показать Келебримора. Другие объекты в игре в режиме призрака тоже рендерят призрачные версии поверх непрозрачных объектов, например врагов и башен. Вот другая сцена с переходом в призрачный мир.
### Дождь
В основном кадре, который мы исследовали, дождя нет, но погода — это такая важная часть игры, что я хотел бы его здесь упомянуть. Он генерируется и симулируется в GPU, и рендерится прямо в конце этапа альфы. Запускается compute-шейдер, выполняющий симуляцию и записывающий позиции в буфер. Эти позиции берутся другим шейдером, который с помощью instanced indirect call рендерит столько экземпляров квадов, сколько позиций было вычислено в предыдущем проходе. Вершинный шейдер имеет простой квад, который при необходимости деформируется и поворачивается к камере. Чтобы дождь не проникал сквозь поверхности, вершинный шейдер также считывает карты высот из вида сверху, что позволяет отклонять все капли ниже перекрывающей поверхности. Эта карта высот рендерится прямо в начале кадра. Тот же вершинный шейдер сообщает пиксельному шейдеру, откуда брать сэмпл из текстуры капли; если капля близко к поверхности, он выбирает область текстуры, содержащую анимацию брызг. Кроме того, капли дождя выполняют в пиксельном шейдере вычисления тумана для безупречного смешения с остальной частью сцены. Вот скриншот с той же точки зрения в дождливый день.
Когда активирован эффект дождя, specular-буфер глобально модифицируется для создания мокрых поверхностей, а волны дождя рендерятся в буфер нормалей. Анимация тайлится, поэтому используется только один кадр зацикленной анимации. Показанный ниже буфер нормалей модифицирован, чтобы показать волны, отрендеренные в буфер.
### Lens Flares и Bloom
После завершения рендеринга альфы поверх рендерятся блики объектива (lens flares). Серия смещённых квадов рендерится, начиная с точки, откуда поступает направленный свет (в нашем случае — солнца). Сразу после этого выполняется проход bloom. Это довольно стандартная техника, которая состоит из серии уменьшенных в размерах и размытых текстур, содержащих пиксели, яркость которых превышает определённый порог. Используется два прохода bloom, общий с гауссовым размытием для всей сцены и особое радиальное размытие, применяемое только к небу. Радиальное размытие — это одна из операций, в которых используется специальный ID из G-буфера карт нормалей, потому что учитываются только пиксели неба. В качестве бонуса это размытие сэмплирует карту глубин и может создавать малозатратные [сумеречные лучи](https://en.wikipedia.org/wiki/Crepuscular_rays). Так как на этом этапе мы работаем с LDR-буфером, значение порога bloom отличается от значения из HDR-ковейера (значения выше порога, обычно равного 1.0, приводят к вычислению), и это означает, что величина получаемого из него bloom немного ограничена. В любом случае, это идёт игре на пользу и вот результаты. В показанных ниже изображениях цвета mip-текстуры bloom выглядят немного странно, потому что каждый пиксель масштабируется на яркость, содержащуюся в альфа-канале. Эта яркость была вычислена ранее, на этапе тональной коррекции. В финальном композитинге bloom вычисляется как **bloom.rgb · bloom.a · bloomScale**.
### Antialiasing + Depth of Field
Об этих двух операциях особо сказать нечего, используются стандартные для отрасли подходы. Простой прохода антиалиасинга FXAA выполняется сразу после композитинга bloom с LDR-изображением, а глубина резкости выполняется непосредственно за ним. Для глубины резкости игра рендерит две уменьшенных размытых версии финального буфера. Затем используется глубина пикселя для смешения размытого и нормального изображений, что даёт эффект расфокусировки. Ради наглядности в этом захвате я преувеличил эффект глубины резкости. В игре есть встроенный режим скриншотов, позволяющий с лёгкостью настраивать эти условия.
### Motion Blur
Motion blur состоит из двух проходов. Сначала в полноэкранный буфер скоростей передаются данные из предыдущей и текущей ориентации камеры. При этом два канала текстуры заполняются скоростью в экранном пространстве. Теперь в канале r содержится величина изменения пикселя в горизонтальном направлении экрана, а в канале g — в вертикальном. Именно так получаются радиальные полосы при перемещении камеры. Персонаж рендерится заново, на этот раз заполняя и синий канал на основе его текущей и предыдущей поз, как и в случае с камерой. Синий канал используется для разметки того, должен ли рендериться пероснаж. Альфа-канал тоже заполняется постоянным значением (0.0598), но я не исследовал ни его значения, ни его целей. Разрешение буфера скоростей снижается до очень маленькой текстуры усреднением относительно широким соседством скоростей в исходной текстуре. В последнем проходе это даёт каждому пикселю примерное представление о том, каким будет радиус размытия в настоящем проходе размытия.
Затем проход размытия считывает обе текстуры скоростей, карту глубин, исходный цветовой буфер и текстуру шума. Последняя используется для сокрытия эффекта зеркального изображения, которое может возникать при таком виде размытия с большим радиусом. Затем несколько раз выполняется сэмплирование буфера изображения в направлении, указываемом буфером скоростей, усредняются цвета, что приводит к размытию изображения в направлении векторов движения. Также этот эффект масштабируется в соответсвии с частотой кадров, с которой работает игра. Для этого захвата мне пришлось ограничить игру 30fps, потому что при 60fps и выше это едва заметно.
### Цветокоррекция
Финальный проход цветокоррекции выполняется с помощью «цветовых кубов». Цветовой куб — это 3D-текстура, rgb-компоненты которой привязываются к координатам xyz текстуры. Эти координаты xyz содержат цвет, которым мы должны заменить исходный цвет. В нашем случае таблица поиска (LUT) является нейтральной (т.е. координаты и цвет содержат одинаковое значение), поэтому я модифицировал ту же сцену с помощью пресетов, которые игра предоставляет в редакторе камеры.
### Финальный кадр
После завершения создания основного кадра в отдельном буфере рендерится UI. Это гарантирует, что вне зависимости от выбранного для заднего буфера размера UI всегда будет рендерится чётким и красивым в нативном размере окна, в то время как игра может изменять разрешение, если это нужно для обеспечения скорости. В конце обе текстуры смешиваются вместе на основании данных альфа-канала UI, а затем рендерятся в финальный буфер кадра, который готов к отображению на экране.
Надеюсь, вам понравился мой анализ. Хочу поблагодарить [Адриана Корреже](http://www.adriancourreges.com/) за потрясающую работу, которая вдохновила меня на изучение графики, а также коллектив студии [Monolith](https://www.lith.com/) за эту поистине незабываемую игру. | https://habr.com/ru/post/430518/ | null | ru | null |
# RxJava. Убираем магию
Я долго боялся использовать RxJava в production. Её назначение и принцип работы оставались для меня загадкой. Чтение исходного кода не добавляло ясности, а статьи только путали. Под катом попытка ответить на вопросы: «Какие задачи эта технология решает лучше аналогов?» и «Как это работает?» с помощью аналогий с классической Java и простых метафор.
Применение
==========
RxJava отлично заменяет *Streams API* из Java 8 на более ранних версиях Java. Так как Android Java 8 поддерживается далеко не с 4.0, Rx будет оптимальным решением. В статье RxJava рассматривается именно с этого ракурса, так как, по-моему, он наиболее понятный и по-настоящему реактивное приложение под Android с помощью чистой Rx реализовать сложно.
Emitter
=======
Всем нам знаком паттерн Iterator.
```
interface Iterator {
T next();
boolean hasNext();
}
```
За интерфейсом скрывается какой-нибудь источник данных, причём совершенно не важно, какой. Iterator полностью скрывает все детали реализации, предоставляя всего два метода:
***next*** — получить следующий элемент
***hasNext*** — узнать, есть ли ещё данные в источнике
У этого паттерна есть одна особенность: потребитель запрашивает данные и ждёт («зависает»), пока источник не выдаст их. Поэтому в качестве источника обычно выступает конечная, часто заранее сформированная коллекция.
Проведём небольшой рефакторинг.
```
interface Iterator {
T getNext();
boolean isComplete();
}
```
Думаю, вы уже поняли, к чему я. Интерфейс Emitter из RxJava *(для потребителей он дублируется в Observer (Subscriber в RxJava 1))*:
```
interface Emitter {
void onNext(T value);
void onComplete();
void onError(Throwable error);
}
```
Он похож на Iterator, но работает в обратную сторону: *источник сообщает потребителю о том, что появились новые данные.*
Это позволяет разрешить все проблемы с многопоточностью на стороне источника и, например, если вы проектируете UI, то вы сможете ***рассчитывать*** на то, что весь код, отвечающий за графический интерфейс — последовательный. Невероятно удобно. Прощайте, каллбэки! Скучать не буду.
*Аналогия с Iterator взята из [[1]](https://www.youtube.com/watch?v=sTSQlYX5DU0)*
Sources
=======
Теперь немного о самих источниках. Они бывают множества типов: Observable, Single, Maybe… И все они похожи на капусту *(и монады, но это не так важно)*.
Потому что создав один источник, можно заворачивать его в другой источник, который можно ещё раз завернуть в ещё один источник и так до OutOfMemory. *(Но так как обычный источник весит меньше 100 байт, скорее, пока заряд не кончится.)*
Давайте завернём в источник ответ на тот самый вопрос.
```
Observable.just(42)
```
Как мы знаем, получение ответа — довольно долгая операция. Поэтому завернём в источник, который выполнит вычисления в специальном потоке:
```
Observable.just(42)
.subscribeOn(computation())
```
А ещё мы хотим, чтобы приложение не упало при ответе. Заворачиваем в источник, который вернёт ответ в главном потоке:
```
Observable.just(42)
.subscribeOn(computation())
.observeOn(mainThread())
```
И, наконец, запускаем:
```
Observable.just(42)
.subscribeOn(computation())
.observeOn(mainThread())
.subscribe(new DisposableObserver() {
@Override
public void onNext(Integer answer) {
System.out.print(answer);
}
@Override public void onComplete() {}
@Override public void onError(Throwable e) {}
});
```
В консоль вывелся ответ, но что же произошло?
Метод *subscribe* определён в *Observable*. Он делает проверки и подготовку, а затем вызывает метод *subscribeActual*, который уже по-разному определён для разных источников.
В нашем случае метод *subscribe* вызвал метод *subscribeActual* у ObservableObserveOn, который вызывает метод subscribe завёрнутого в него источника, уточнив, в какой поток нужно вернуть результат.
В ObservableObserveOn лежит ObservableSubscribeOn. Его *subscribeActual* запускает *subscribe* завёрнутого в заданном потоке.
И, наконец, в ObservableSubscribeOn завёрнут ObservableJust, который просто выдаёт в onNext своё значение.
Естественно, просто с числом не интересно. Поэтому вот источник, который получает список товаров и узнаёт для них цены. Цены можно получать только по 20 штук (у InAppBilling API такое же ограничение).
→ [github.com/a-dminator/rx-products-and-prices](https://github.com/a-dminator/rx-products-and-prices)
*Этот пример создан для демонстрации принципа работы, а не для использования в реальных проектах.*
В RxJava огромное количество разных реализаций источников. Все они работают по одному принципу, а детали отлично описаны в документации. Поэтому не буду останавливаться на них.
Операции
========
Все операции над источниками делятся на 2 типа:
— **Не терминальные** возвращают новый источник, который завернул исходный
— **Терминальные** исполняют цепочку и получают данные *(subscribe, map...)*
И да, ничего не исполнится, пока не будет выполнена терминальная операция. Цепочка может сколько угодно лежать в памяти, не делая вообще ничего. И это хорошо, потому что если мы не получаем данные, то зачем их производить? *(Ленивые вычисления без Haskell в комплекте!).*
*По аналогии со Streams API из [[2]](https://www.youtube.com/watch?v=O8oN4KSZEXE)*
Dispose *(Unsubscribe в RxJava 1)*
==================================
Исполнение цепочки можно прервать. Делается это вызовом dispose() у DisposableObserver *(unsubscribe() у Subscriber в RxJava 1)*.
После этого RxJava прекратит исполнение цепочек, отпишет всех Observer'ов и вызовет iterrupt() у потоков, которые больше не нужны.
Так же можно узнать, не прервано ли исполнение из источников. Для этого у Emitter есть метод isDispose() *(isUnsubscribe() для RxJava 1)*.
У этого есть логичная, но неприятная особенность: так как Observer отвечает за обработку ошибок, теперь все ошибки крашат приложение. Я пока не нашёл решения, о котором готов написать.
Заключение
==========
RxJava:
— Позволяет легко компоновать запросы к сети, базе данных и т.д; организуя их асинхронное выполнение. Это означает, что ваши пользователи получат более быстрое и отзывчивое приложение.
— Не содержит в себе никакой магии. Только составление и исполнение цепочек источников.
— (Для меня) Решает больше проблем, чем создаёт!
Всем спасибо.
[1] [Видео](https://www.youtube.com/watch?v=sTSQlYX5DU0)
[2] [Видео](https://www.youtube.com/watch?v=O8oN4KSZEXE) | https://habr.com/ru/post/317928/ | null | ru | null |
# Истории успеха Kubernetes в production. Часть 3: GitHub
Продолжаем рассказывать об успешных примерах использования Kubernetes в production. Новый кейс — совсем свежий. Подробная информация о нём появилась только вчера. А что ещё более значимо, речь пойдёт про крупный онлайн-сервис, с которым наверняка так или иначе работает каждый читатель хабры, — GitHub.
Первые сведения
---------------
О том, что GitHub занимается внедрением Kubernetes в своём production, стало впервые [публично известно](https://www.nixp.ru/news/14136.html) месяц назад из [Twitter-аккаунта](https://twitter.com/AaronBBrown777/status/884920896422633474) SRE-инженера компании Aaron Brown. Тогда он кратко сообщил:
> Hey [@kelseyhightower](https://twitter.com/kelseyhightower), if you're surfing GitHub today, you might find it interesting that all your web bits come thru Kubernetes as of today.
>
> — Aaron Brown (@AaronBBrown777) [July 11, 2017](https://twitter.com/AaronBBrown777/status/884920896422633474)
То есть: «если вы ходите по страницам GitHub сегодня, то вас может заинтересовать тот факт, что с этого дня весь веб-контент отдаётся с помощью Kubernetes». В последующих ответах уточнялось, что трафик на Docker-контейнеры, управляемые Kubernetes, был переключён для веб-фронтенда и сервиса Gist, а приложения API находились в процессе миграции. Контейнеризация в GitHub затронула только stateless-приложения, потому что дела со stateful-продуктами обстоят сложнее и «[для обслуживания] MySQL, Redis и Git у нас [в GitHub] уже налажена обширная автоматизация». Выбор в пользу Kubernetes был назван оптимальным для сотрудников GitHub с примечанием, что «Mesos/Nomad ни хуже ни лучше — они просто другие».
Информации было мало, но инженеры GitHub обещали рассказать о подробностях в скором времени. И вот вчера Jesse Newland, старший SRE в компании, опубликовал долгожданную заметку «[Kubernetes at GitHub](https://githubengineering.com/kubernetes-at-github/)», а буквально за 8 часов до этой публикации на хабре уже упомянутый Aaron Brown выступал на запоздалом праздновании 2-летия Kubernetes в Apprenda с соответствующим докладом:
*Цитата из доклада Аарона: «„Мечтаю проводить больше времени за настройкой хостов“, — никакой инженер, никогда»*
Зачем вообще Kubernetes в GitHub?
---------------------------------
До недавних событий основное приложение GitHub, написанное на Ruby on Rails, мало менялось за последние 8 лет с его создания:
* На серверах с Ubuntu, конфигурируемых с помощью Puppet, менеджер процессов God запускал веб-сервер Unicorn.
* Для деплоя использовался Capistrano, который подключался по SSH к каждому фронтенд-серверу, обновлял код и перезапускал процессы.
* Когда пиковая нагрузка превышала имеющиеся мощности, SRE-инженеры добавляли новые фронтенд-серверы, используя в своём рабочем процессе gPanel, IPMI, iPXE, Puppet Facter и PXE-образ Ubuntu *(подробнее об этом можно почитать [здесь](https://githubengineering.com/githubs-metal-cloud/))*.
По мере роста GitHub (сотрудников, количества возможностей и сервисов, пользовательских запросов) возникали сложности, а в частности:
* некоторым командам требовалось «извлекать» из больших сервисов малую часть их функциональности для отдельного запуска/деплоя;
* рост числа сервисов приводил к необходимости поддержки множества схожих конфигураций для десятков приложений (больше времени уходило на поддержку серверов и provisioning);
* деплой новых сервисов (в зависимости от их сложности) занимал дни, недели или даже месяцы.
> Со временем стало очевидно, что такой подход не обеспечивает наших инженеров гибкостью, которая была необходима для создания сервиса мирового уровня. Нашим инженерам была нужна платформа самообслуживания, которую они могли бы использовать для экспериментирования с новыми сервисами, их деплоя и масштабирования. Кроме того, было нужно, чтобы эта же платформа удовлетворяла требованиям основного приложения на Ruby on Rails, чтобы инженеры и/или роботы могли реагировать на изменения в нагрузке, выделяя дополнительные вычислительные ресурсы за секунды, а не часы, дни или более долгие сроки.
Инженеры и разработчики начали совместный проект по решению этих проблем, который привёл к изучению и сравнению существующих платформ оркестровки контейнеров. Оценивая Kubernetes, они выделили несколько преимуществ:
1. активное Open Source-сообщество, поддерживающее проект;
2. позитивный опыт первого запуска (на первый деплой приложения в маленьком кластере потребовалось всего несколько часов);
3. обширная информация об опыте авторов Kubernetes, который привёл их к имеющейся архитектуре.
Деплой с Kubernetes
-------------------
Для организации деплоя основного Ruby-приложения GitHub с использованием инфраструктуры на базе Kubernetes была создана так называемая «оценочная лаборатория» (Review Lab). Она состояла из следующих проектов:
1. Кластер Kubernetes, запущенный в облаке AWS VPC и управляемый с помощью Terraform и kops.
2. Набор интеграционных тестов на Bash, выполняющих проверки на вр*е*менных кластерах Kubernetes, которые активно использовались в начале проекта.
3. `Dockerfile` для приложения.
4. Улучшения у внутренней платформы непрерывной интеграции (CI) для поддержки сборки контейнеров и их публикации в реестре.
5. YAML-представления 50+ ресурсов, используемых в Kubernetes.
6. Улучшения во внутреннем приложении для деплоя для «проброса» ресурсов Kubernetes из репозитория в пространство имён Kubernetes и создания секретов Kubernetes (из внутреннего хранилища).
7. Сервис на базе HAProxy and consul-template для перенаправления трафика из подов с Unicorn в существующие сервисы.
8. Сервис, пересылающий аварийные события из Kubernetes во внутреннюю систему учёта ошибок.
9. Сервис kube-me, который совместим с chatops-rpc и предоставляет пользователям чата ограниченный доступ к командам kubectl.
Итог — интерфейс на базе чата для развёртывания приложения GitHub по любому pull request:
Реализация лаборатории зарекомендовала себя отлично, и к началу июня весь деплой GitHub перешёл на новую схему.
Kubernetes для инфраструктуры
-----------------------------
Следующим этапом внедрения Kubernetes стало построение очень требовательной к производительности и надёжности инфраструктуры для главного сервиса компании в production — github.com.
Базовая инфраструктура GitHub — так называемое [metal cloud](https://githubengineering.com/githubs-metal-cloud/) (облако, запущенное на физических серверах в собственных дата-центрах). Разумеется, Kubernetes требовалось запускать с учётом имеющейся специфики. Для этого инженеры компании снова реализовали ряд вспомогательных проектов:
1. В качестве сетевого провайдера выбрали Calico, который «из коробки предоставлял необходимую функциональность для быстрого развёртывания кластера в режиме `ipip`».
2. Многократное («не менее дюжины раз») чтение [Kubernetes the hard way](https://github.com/kelseyhightower/kubernetes-the-hard-way) помогло собрать несколько вручную обслуживаемых серверов во временный кластер Kubernetes, который с успехом прошёл интеграционные тесты, использовавшиеся для имевшихся кластеров на базе AWS.
3. Создание небольшой утилиты, генерирующей CA и конфигурацию для каждого кластера в формате, распознаваемым используемым Puppet и системами хранения секретов.
4. Puppet'изация конфигурации двух ролей (Kubernetes node и Kubernetes apiserver).
5. Создание сервиса (на языке Go), собирающего логи контейнеров, добавляющего к каждой строке метаданные в формате ключ-значение и отправляющего их в syslog для хоста.
6. Добавление поддержки Kubernetes NodePort Services в сервисе балансировки нагрузки ([GLB](https://www.nixp.ru/news/13786.html)).
Итог — кластер Kubernetes на железных серверах, который проходил внутренние тесты и менее чем через неделю начал использоваться для миграции с AWS. После создания дополнительных подобных кластеров инженеры GitHub запустили копию боевого github.com на Kubernetes и (с помощью GLB) предложили своим сотрудникам кнопку для переключения между оригинальной инсталляцией приложения и версией в Kubernetes. Архитектура сервисов выглядела следующим образом:
После исправления обнаруженных сотрудниками проблем началось постепенное переключение пользовательского трафика на новые кластеры: сначала по 100 запросов в секунду, а затем — 10 % всех запросов на github.com и api.github.com.
Переходить от 10 % до 100% трафика не спешили. Тесты с частичной нагрузкой показали неожиданные результаты: отказ одного узла Kubernetes apiserver оказывал негативное влияние на доступность имеющихся ресурсов в целом — причина, «по всей видимости», оказалась связана со взаимодействием между разными клиентами, подключающимися к apiserver (calico-agent, kubelet, kube-proxy, kube-controller-manager), и особенностями поведения внутреннего балансировщика нагрузки во время падения узла apiserver. Поэтому в GitHub решили запускать основное приложение на нескольких кластерах в разных местах и перенаправлять запросы с проблемных кластеров на рабочие.
К середине июля этого года 100% production-трафика GitHub было перенаправлено на инфраструктуру на базе Kubernetes.
Одна из оставшихся проблем, со слов инженера компании, заключается в том, что иногда во время сильных нагрузок на некоторых узлах Kubernetes возникает kernel panic, после чего они перезагружаются. Хотя внешне для пользователей это никак не заметно, у SRE-команды высокий приоритет на выяснение причин такого поведения и их устранения, а в тесты, проверяющие отказоустойчивость, уже был специально добавлен вызов kernel panic (через `echo c > /proc/sysrq-trigger`). Несмотря на это, авторы в целом довольны полученным опытом и собираются провести больше миграций на подобную архитектуру, а также начать эксперименты с запуском stateful-сервисов в Kubernetes.
Другие статьи из цикла
----------------------
* «[Истории успеха Kubernetes в production. Часть 1: **4200 подов и TessMaster у eBay**](https://habrahabr.ru/company/flant/blog/334140/)».
* «[Истории успеха Kubernetes в production. Часть 2: **Concur и SAP**](https://habrahabr.ru/company/flant/blog/334770/)».
* «[Истории успеха Kubernetes в production. Часть 4: **SoundCloud (авторы Prometheus)**](https://habrahabr.ru/company/flant/blog/339724/)».
* «[Истории успеха Kubernetes в production. Часть 5: **цифровой банк Monzo**](https://habrahabr.ru/company/flant/blog/342412/)».
* «[Истории успеха Kubernetes в production. Часть 6: **BlaBlaCar**](https://habrahabr.ru/company/flant/blog/345780/)».
* «[Истории успеха Kubernetes в production. Часть 7: **BlackRock**](https://habrahabr.ru/company/flant/blog/347098/)».
* «[Истории успеха Kubernetes в production. Часть 8: **Huawei**](https://habrahabr.ru/company/flant/blog/349940/)».
* «[Истории успеха Kubernetes в production. Часть 9: **ЦЕРН и 210 кластеров K8s**](https://habr.com/company/flant/blog/349940/)».
* «[Истории успеха Kubernetes в production. Часть 10: **Reddit**](https://habr.com/ru/company/flant/blog/441754/)». | https://habr.com/ru/post/335814/ | null | ru | null |
# Деплой php+MySQL на heroku
Всем доброго времени суток. Хочу поделиться с вами своим опытом развертывания php+mysql приложения на сервисе [heroku](http://www.heroku.com). Если вы первый раз о таком слышите, вам [сюда](https://ru.wikipedia.org/wiki/Heroku).
#### Поехали
Итак, представим, что у нас есть уже готовое php+mysql приложение. Для начала регистрируемся [здесь](https://id.heroku.com/signup). На почту придет письмо с подтверждением регистрации. Далее переходим по ссылке, вводим пароль и подтверждение, жмем save. Первый этап пройден, идем дальше.
После успешной регистрации сервис предлагает нам скачать клиент. Естественно, для каждой ОСи свой вариант установки. Далее будем рассматривать пример для UNIX.
Пишем в консоли:
```
wget -qO- https://toolbelt.heroku.com/install.sh | sh
```
С установкой не должно возникнуть проблем. Также нам необходим установленный и настроенный git, об этом я писать не буду, на просторах интернета полно информации об этом.
После установки нужно войти в приложение:
```
$ heroku login
```
Вводим email и пароль. Приложение должно вас авторизовать и автоматически загрузить ваш публичный ssh ключ. Если этого не произошло, заходим в свой аккаунт (https://dashboard.heroku.com/account) и добавляем публичный ssh:
Чтобы посмотреть публичный ssh, пишем в консоли:
```
$ cat ~/.ssh/id_rsa.pub
```
Ключи также можно добавить с помощью команды:
```
$ heroku keys:add
```
Итак, все готово для того, чтобы создать свое первое «heroku приложение». Заходим в директорию, где хранится наше приложение, и пишем в консоли:
```
$ heroku create
```
В результате вы должны увидеть что-то похоже на это:
Далее делаем push нашего приложения в heroku master:
```
$ git push heroku master
```
После чего пишем в консоли:
```
$ heroku open
```
Наш сайт откроется в браузере. Если бы мы не юзали mysql, то на этом все бы и закончилось, но нам придется еще чуть попотеть. Скорее всего, на экране полезли ошибки о том, что невозможно соединиться с mysql. Также ошибки можно посмотреть, открыв логи:
```
$ heroku logs
```
Для работы с mysql будем использовать аддон [ClearDB](https://devcenter.heroku.com/articles/cleardb). Чтобы его установить, для начала необходимо заполнить данные о вашей кредитной карте на странице [dashboard.heroku.com/account](https://dashboard.heroku.com/account):
Если этого не сделать, при установке ClearDB вы будете видеть ошибку:
`Adding cleardb:ignite on dry-taiga-2649... failed
! Please verify your account to install this add-on
! For more information, see devcenter.heroku.com/categories/billing
! Verify now at heroku.com/verify`
Ниже команда для установки ClearDB:
```
$ heroku addons:add cleardb:ignite
```
в
ClearDB установлен, теперь посмотрим доступы к базе данных:
```
$ heroku config
```
Получим результат в виде:
`CLEARDB_DATABASE_URL:mysql://USER:PASSWORD@HOSTNAME/DBASENAME?reconnect=true`
Используя полученные доступы через любой удобный MySQL клиент заливаем дамп БД на сервер.
Доступы к базе в php можно получить следующим образом:
```
$url=parse_url(getenv("CLEARDB_DATABASE_URL"));
$server = $url["host"];
$username = $url["user"];
$password = $url["pass"];
$db = substr($url["path"],1);
mysqli_connect($server, $username, $password);
mysqli_select_db($db);
```
Чтобы каждый раз не менять конфиг для локального сайта и heroku, можно добавить проверку:
```
if ($_SERVER['SERVER_NAME'] == "thawing-island-242342379.herokuapp.com") {
$url = parse_url(getenv("CLEARDB_DATABASE_URL"));
$host = $url["host"];
$username = $url["user"];
$password = $url["pass"];
$dbname = substr($url["path"], 1);
} else {
$host = 'localhost';
$dbname = 'db';
$username = 'user';
$password = '123';
}
```
Было бы правильней это сделать через APPLICATION\_ENV, но я не нашел информации о том, как это сделать. Если кто-то в курсе — напишите.
Почти все готово. Осталось добавить в корень файл composer.json:
```
{
"require": {
"ext-mysql": "*"
}
}
```
Если такой уже есть, нужно просто дописать `"ext-mysql": "*"`
Пишем в консоли:
```
$ git add .
$ git commit -am "added db credentials"
$ git push heroku master
$ heroku open
```
Открывается браузер, видим рабочий сайт.
Буду рад если этот «мануал» кому то поможет.
Всем спасибо з а внимание. | https://habr.com/ru/post/236211/ | null | ru | null |
# Магия IBDesignable или расширяем функциональность Interface Builder в Xcode
Interface Builder в Xcode с некоторого времени экономит мне много времени в работе по стандартному лайауту элементов интерфейса и иногда помогает в задаче прототипирования. С версии 6 в Xcode добавили возможность рендера кастомных вьюшек, помеченных атрибутом IBDesignable, а также отображение в билдере полей класса, помеченных атрибутом IBInspectable.
С версии Xcode 7 этой фичей стало более-менее возможно пользоваться, поэтому мне захотелось проверить её возможности.
Почитать про IBDesignable/IBInspectable можно [тут](https://developer.apple.com/library/ios/recipes/xcode_help-IB_objects_media/Chapters/CreatingaLiveViewofaCustomObject.html) и [тут](http://nshipster.com/ibinspectable-ibdesignable/).
#### Стандартный кейс
Давайте создадим кастомную кнопку с возможностью настраивать цвет, толщину и радиус скругления border, причем чтобы все эти параметры можно было контролировать через Interface Builder.
```
@IBDesignable class BorderedButton : UIButton {
/// Толщина границы
@IBInspectable var borderWidth: CGFloat {
set { layer.borderWidth = newValue }
get { return layer.borderWidth }
}
/// Цвет границы
@IBInspectable var borderColor: UIColor? {
set { layer.borderColor = newValue?.CGColor }
get { return layer.borderColor?.UIColor }
}
/// Радиус границы
@IBInspectable var cornerRadius: CGFloat {
set { layer.cornerRadius = newValue }
get { return layer.cornerRadius }
}
}
extension CGColor {
private var UIColor: UIKit.UIColor {
return UIKit.UIColor(CGColor: self)
}
}
```
Все работает, билдер обновляет рендер при изменении параметров.
Но ведь такие параметры наверное могут быть не только у нашего класса кнопки, а у любых других кнопок. Почему бы не сделать расширение базового класса UIButton.
```
extension UIButton {
/// Радиус гараницы
@IBInspectable var cornerRadius: CGFloat {
set { layer.cornerRadius = newValue }
get { return layer.cornerRadius }
}
/// Толщина границы
@IBInspectable var borderWidth: CGFloat {
set { layer.borderWidth = newValue }
get { return layer.borderWidth }
}
/// Цвет границы
@IBInspectable var borderColor: UIColor? {
set { layer.borderColor = newValue?.CGColor }
get { return layer.borderColor?.UIColor }
}
}
```
Сотрём IBInspectable поля класса кастомной кнопки, так как они уже прописаны в расширении. В результате класс останется пустым.
```
@IBDesignable class BorderedButton : UIButton {}
```
Добавим еще одну кнопку рядом с нашей кастомной кнопкой, но не будем назначать ей класса (будет стандартный UIButton).
Как видно из результата, Interface Builder сохранил возможность ввода IBInspectable полей даже у базового класса UIButton, однако не рендерит его, так как он не помечен атрибутом IBDesignable.
#### Расширяем дальше
Похожим образом можно расширить базовый класс UIView.
```
extension UIView {
/// Радиус гараницы
@IBInspectable var cornerRadius: CGFloat {
set { layer.cornerRadius = newValue }
get { return layer.cornerRadius }
}
/// Толщина границы
@IBInspectable var borderWidth: CGFloat {
set { layer.borderWidth = newValue }
get { return layer.borderWidth }
}
/// Цвет границы
@IBInspectable var borderColor: UIColor? {
set { layer.borderColor = newValue?.CGColor }
get { return layer.borderColor?.UIColor }
}
/// Смещение тени
@IBInspectable var shadowOffset: CGSize {
set { layer.shadowOffset = newValue }
get { return layer.shadowOffset }
}
/// Прозрачность тени
@IBInspectable var shadowOpacity: Float {
set { layer.shadowOpacity = newValue }
get { return layer.shadowOpacity }
}
/// Радиус блура тени
@IBInspectable var shadowRadius: CGFloat {
set { layer.shadowRadius = newValue }
get { return layer.shadowRadius }
}
/// Цвет тени
@IBInspectable var shadowColor: UIColor? {
set { layer.shadowColor = newValue?.CGColor }
get { return layer.shadowColor?.UIColor }
}
/// Отсекание по границе
@IBInspectable var _clipsToBounds: Bool {
set { clipsToBounds = newValue }
get { return clipsToBounds }
}
}
```
Теперь параметрами слоя любой вьюшки можно управлять через билдер. Для возможности live-рендера только одно условие — у вьюшки в билдере должен быть указан кастомные класс с атрибутом IBDesignable.
#### Нестандартный кейс
Допустим, у нас в приложении есть светлая и темная темы. Попробуем стилизовать кнопки с помощью перечисления.
```
/// Стиль кнопки
enum ButtonStyle: String {
/// Светлый стиль
case Light = "light"
/// Темный стиль
case Dark = "dark"
/// Оттенок
var tintColor: UIColor {
switch self {
case .Light: return UIColor.blackColor()
case .Dark: return UIColor.lightGrayColor()
}
}
/// Цвет границы
var borderColor: UIColor { return tintColor }
/// Цвет фона
var backgroundColor: UIColor { return UIColor.clearColor() }
/// Толщина границы
var borderWidth: CGFloat { return 1 }
/// Радиус границы
var cornerRadius: CGFloat { return 4 }
}
```
Напишем соответствующее расширение для класса UIButton, которое позволяет выбирать и применять стили к кнопкам:
```
extension UIButton {
/// Стиль кнопки
@IBInspectable var style: String? {
set { setupWithStyleNamed(newValue) }
get { return nil }
}
/// Применение стиля по его строковому названию
private func setupWithStyleNamed(named: String?){
if let styleName = named, style = ButtonStyle(rawValue: styleName) {
setupWithStyle(style)
}
}
/// Применение стиля по его идентификатору
func setupWithStyle(style: ButtonStyle){
backgroundColor = style.backgroundColor
tintColor = style.tintColor
borderColor = style.borderColor
borderWidth = style.borderWidth
cornerRadius = style.cornerRadius
}
}
```
Теперь добавляем а билдере еще две кнопки, и в новом поле Style прописываем стили «dark» и «light» соответственно.
Теперь мы можем применять стили к кнопкам одним полем в билдере и наблюдать их реальное отображение. Если ограничится только первым, то нам даже не придется создавать свой IBDesignable класс (который по сути пустой). Ничто не мешает добавить еще несколько стилей, а также расширить тип стиля и сделать динамический выбор применяемых значений в зависимости от класса вьюшки.
#### Резюме
В статье я не пытался преподнести новый способ стилизации элементов интерфейса. Однако, возможно, данный подход подтолкнет кого-нибудь на другое оригинальное применение данной фичи.
Исходники можно найти на [гите](https://github.com/danteteam/InterfaceBuilderExtension). | https://habr.com/ru/post/274687/ | null | ru | null |
# Hg Init: Часть 5. Процесс слияния
Это пятая часть из серии **Hg Init: Учебное пособие по Mercurial** от Джоэля Спольски ([Joel Spolsky](http://www.joelonsoftware.com/)). Предыдущие части:
* [«Переобучение для пользователей Subversion»](http://habrahabr.ru/blogs/development_tools/108443/)
* [«Основы Mercurial»](http://habrahabr.ru/blogs/development_tools/108658/)
* [«Привыкаем работать в команде»](http://habrahabr.ru/blogs/development_tools/108904/)
* [«Исправляем ошибки»](http://habrahabr.ru/blogs/development_tools/109074/)
Иногда при слияниях возникают конфликты. Обычно их легко разрешить. В любом случае их надо разрешить, или у вас будет несколько «голов». А кому это нужно?
#### Часть 5. Процесс слияния
Обеспечение слаженной работы нескольких людей над одним и тем же кодом — это важная функция системы контроля версий.
Представьте что и Роза, и я хотим внести изменения в рецепт гуакамоле. Роза работает над качеством авокадо. Перед тем как начать, она обновляет свой рабочий каталог, вытягивая свежие изменения из центрального репозитория.
Теперь небольшая правка:
Она фиксирует изменения и проталкивает их в центральный репозиторий:
В это же время я делаю изменение в другой части файла:
Я могу сделать коммит, но не могу протолкнуть изменения в центральный репозиторий.
Это, пожалуй, наименее полезное сообщение об ошибке в Mercurial. Лучше было бы так:
Так я и поступлю:
Хотите узнать, что за изменения только что были получены? Для этого есть удобный способ — команда `hg log -P .`
Ну точно, это те изменения, что сделала Роза. И что там с моим репозиторием сейчас?
У моего репозитория «несколько голов». По сути, мой репозиторий выглядит так:
Видите две головы? Они появились, потому что Роза сделала свои изменения, работая с седьмым набором изменений, и я тоже сделал свои изменения, работая с тем же набором. Так что теперь требуется слияние (merge). [Редактор подсказывает, что нельзя использовать пассивный залог] *Я должен сделать слияние.*
Команда слияния, `hg merge`, взяла две головы и объединила их. После этого она поместила результат в мой рабочий каталог. Она не закоммитила его. Это дает мне шанс проверить, что результат слияния корректен:
Похоже на правду: авокадо сорта Хасс и [перчики халапеньо](http://ru.wikipedia.org/wiki/%D0%A5%D0%B0%D0%BB%D0%B0%D0%BF%D0%B5%D0%BD%D1%8C%D0%BE). Так что я сделаю коммит и протолкну изменения на сервер.
Я проталкиваю два набора изменений: мои изменения про халапеньо и результат слияния, который тоже является набором изменений.
Обратите внимание на то, что в наших изменениях не было конфликтов, потому что Роза и я работали над разными частями рецепта. Потому слияние было супер-пупер простым. Это наиболее частая ситуация, потому что в большинстве организаций разные программисты работают над разными частями кода.
Иногда бывают странные организации, в которых никто не готов стукнуть кулаком по столу и все-таки разделить зоны ответственности. Это может спровоцировать неожиданное и часто необъяснимое чувство грусти среди программистов. Эту ситуацию непросто распознать. Но есть симптомы: программисты закрываются в туалетах, программисты закрываются в серверных, высокая текучесть кадров, звуки сдавленных рыданий в помещении, а также неожиданное повреждение барабанных перепонок из-за многократных выстрелов штурмовой винтовки.
НО, даже в самых замечательных организациях с наилучшим руководством конфликты при слиянии иногда случаются, и Mercurial потребует от того, кто делает слияние, разрешить конфликт. Давайте посмотрим как это делается.
Для начала… я хочу чтобы Роза была в курсе моих изменений про халапеньо:
Сейчас мы увидим что случается когда у вас на-сто-я-щий конфликт: мы оба немного накосячим с ингредиентами.
Я добавил банан:
И первым зафиксировал изменения:
А Роза, господи прости, добавила МАНГО в ТОМ ЖЕ МЕСТЕ рецепта.
«Зрелый молодой» манго, я не шучу.
В этот раз я первым зафиксировал изменения, так что теперь Розе придется заниматься слиянием. Ха-ха!
И вдруг, обнаруживается конфликт и выскакивает окошко какой-то программы для разрешения конфликтов со столь страшным интерфейсом, что только матери этой программы он может нравиться. Но программа обычно достаточно неплохо делает то, для чего предназначена, надо только разобраться как она работает. Наиболее распространенной программой для разрешения конфликтов в наше время является KDiff3, так что Роза увидит следующее:
В программе KDiff3 у вас есть четыре панели. Верхняя левая — это оригинальный файл. Верхняя средняя показывает Розе ее версию файла. Верхняя правая показывает Розе мою версию. Нижняя панель — это редактор, в котором Роза собирает итоговый файл по мере разрешения конфликтов.
Разрешать конфликты достаточно просто. Нужно пройтись по всем конфликтам и выбрать каким образом разрешить каждый из них. Роза сошла с ума и решила, что бананово-манговая гуакамоле не так уж плоха:
Кстати, я говорил вам, что Роза, похоже, кое с кем встречается? Как-то раз ее видели уходящей с работы с парнем, который выглядел примерно как [Деннис Франц](http://ru.wikipedia.org/wiki/%D0%A4%D1%80%D0%B0%D0%BD%D1%86,_%D0%94%D0%B5%D0%BD%D0%BD%D0%B8%D1%81). В таком прекрасном настроении как тогда ее давненько не видели.
Роза сохраняет изменения и закрывает KDiff3.
И конфликт разрешен.
Вот что вам стоит запомнить: вы не обязаны проводить слияние, подстраиваясь под чье-либо расписание. Вы можете выполнять `hg pull` когда угодно и, если не хочется сразу же разрешать конфликты, то можете свободно продолжать работать и счастливо коммитить до тех пор, пока не найдете время заняться слиянием.
##### Проверь себя
Вот то, что вы должны уметь делать после прочтения данной части:
1. Работать с кодом совместно с другими людьми.
2. Получать их изменения.
3. Проталкивать свои изменения.
4. Разрешать конфликты, которые время от времени случаются.
5. Диагностировать некоторые виды программерской меланхолии.
Заключительная часть здесь:
[Hg Init: Часть 6. Архитектура репозиториев](http://habrahabr.ru/blogs/development_tools/109428/) | https://habr.com/ru/post/109203/ | null | ru | null |
# Как написать и поместить на сайт фотобанк на > 100 000 картин
Допустим, у вас есть >100'000 изображений, которые надо рассортировать и удобно выложить в веб для массового просмотра. Это может быть что угодно — галерея всего созданного человечеством искусства (в задаче которую я делал), или исторический фотоархив города Москвы, или кадры из кинофильмов, или общий архив фотографий с отдыха от крупного турагентства, или веб-сайт стоковых иллюстраций и фотографий, или архив изображений при крупном СМИ за много лет — в котором надо навести порядок, организовать навигацию и доступ сотрудников из внутренней сети.
Я расскажу, как это целесообразно запрограммировать.
### Ключевые слова и их наследование
Современный подход, используемый всеми фотобанками и галереями — снабжение иллюстраций набором тегов (ключевых слов). Я развил этот подход в двух направлениях: (1) теги могут иметь наследование (пользователь искал ягоды — нашел картину с тегом «черешня»), и (2) теги могут крепиться на уровне не одиночных иллюстраций, а каталогов.
Недостаток такого подхода с тегами — вы осуществляете поиск на основе ключевых слов, игнорируя сюжет картины. Дракон, убитый девушкой, и дракон, убивший девушку — это два разных сюжета, но один и тот же для список слов: Дракон, Девушка, Смерть, и Победитель (если имела место битва). Подход на основе ключевых слов не позволит получить выборку по запросу «Мёртвый дракон», в которую не входило бы изображение дракона — победителя над убитым врагом.
Основные теги — те, что видны пользователю в алфавитном справочнике. Дополнительные теги — те, что доступны пользователю только по вводу им вручную названий этих тегов в тексте поисковой строки. Оптимальным считаю количество тэгов: основных = 1/75, дополнительных = 1/195, от количества изображений.
Множественное число (всадники, горы и т.д.) тегов обозначайте в именах файлов как <имя тега>! (т.е. восклицательный знак). Вам потребуется словарь, как теги могут называться — множественное число, женский/мужской род, слова-синонимы, неверные написания.
Словарь тегов держите в 4х файлах: Marks.csv — основные теги, Other.csv — дополнительные теги, Wrong.csv — неверные написания, синонимы, названия тегов во множественном числе, Artists.csv — авторы. В файлах Marks.csv и Other.csv после идентификатора тегов и основного названия на русском языке, следует **перечисление родительских тегов (т.е. наследование)**.
Marks.csv
```
Arwen;Арвен (Властелин Колец);Person,Girl,Elf,LordOfTheRings
ThorinOakenshield;Торин Дубощит;Person,Male,Beard,LordOfTheRings
```
Здесь написано, что Арвен — персона, девушка, эльф, персонаж «Властелин колец»; Торин Дубощит — персона, мужчина, носит бороду, персонаж «Властелин колец». Соответственно, при поиске пользователем по запросу «Властелин колец», все изображения Арвен и Торина будут найдены. При поиске «борода» — в числе прочего, будет Торин. При поиске «Торин» — он тоже будет найден, так как это сокращённое написание есть во Wrong.csv.
### Структура папок
Если на 100 000 изображений наложить выборку «показать девушек» или «показать солнце», то количество результатов будет чрезмерно велико. Но такого не произойдёт, если изображения будут разбиты на папки. Например, в корневой директории есть папка Драконы, внутри неё папка Жёлтые, внутри неё папка Девушки (т.е. изображения, на которых есть девушки), и внутри неё (по всем подпапкам) 200 изображений. В этом случае, в результаты поиска выйдет не эти 200 изображений, а папка, их содержащая. Это лучше и пользователю.
Здесь, правда, существует проблема близкородственных связей. Практически всегда короли на изображениях имеют короны, но не во всех случаях. Допустим, есть папка Короли, и в ней 3000 изображений, из них 2500 — в коронах. Здесь, в отношении короны — простой подход показать папку не работает.
Оптимальным считаю количество папок = 1/28 от количества изображений
Как вы понимаете, если файл уже лежит в папке Драконы/Желтые/Девушки, то именно эти теги в имя файла добавлять не надо, в имя файла добавляйте только те идентификаторы тегов, которые не следуют из места его хранения.
### Мультиязычность, иконки, тексты, виртуальные подпапки
Внутри каждой папки создан файл \_.jpg размером 200 (ширина) \* 280 (высота) — это иконка папки при её просмотре (текст выводится поверх неё), как при находжении пользователя в вышестоящей папке, так и при просморте пользователем результатов поиска (если найдена эта папка). Такое же разрешение и у иконок ключевых слов.
Также, во многих папках создан файл \_.txt, состоящий из таких строк:
Artefact\\_.txt (фрагмент)
```
Миелофон=Mielofon
Мьёльнир=Mjolnir
Палантир=Palantir
Перчатка Таноса=ThanosGlove
Склянки=Glass-Potion
by-DavisonCarvalho=*
TheWitcher/Wolf-Head-Logo|Амулет Ведьмака
DisneyPrincess/Moana/HeartOfTeFiti|Сердце Те Фити
SuperHeroes/Hellraiser/HellraiserBox|Шкатулка Лемаршана
-m|Artefact
```
Здесь мы видим виды записей:
1. Склянки=Glass-Potion — псевдонимы для подпапок. На иллюстрации, приведённой выше, видим что для папки Japan псевдоним не был записан, и при просмотре папки она без перевода на русский. Два тега — Glass и Potion (Стекло и Зелье) — переведены одним словом.
2. by-DavisonCarvalho=\* — псевдоним не требуется
3. SuperHeroes/Hellraiser/HellraiserBox|Шкатулка Лемаршана — виртуальная подпапка. Находящаяся в другом каталоге подпапка, также, будет отображаться здесь, под заданным именем.
4. -m|Artefact — папка олицетворяет тег «Артефакт». Если к этому тегу привязан текст, он будет написан под иллюстрациями.
### Размер на диске
Сейчас 111'000 изображений занимают на диске 65GB. И это при том, что во многих случаях из них приходится делать более тяжёлый png формат:
* Если изображение с полями (и никакой штрих или предмет изображения не заходит на них), поля надо убрать в paint-е.
* Если изображение с чужими вотермарками фотогалерей а-ля пикабу, вотермарки убираются в фотошопе.
* Если оно в формате .webp, приходится просто пересохранять в .png, иначе моя программа не сможет сделать миниатюры (да, я знаю, можно было дописать код).
* Если формат не .png, .jpg, .gif. Я против излишнего разнообразия форматов.
### Структура сайта — файлы и папки
index.php — запущенный без параметров, выводит корневую папку галереи, алфавит и поисковую строку. По клику на подпапку в корневой папке — переходит на неё. По клику на букве алфавита — переходит на основные теги, начинающиеся на эту букву. При вводе в поисковую строку текста, переходит на тег, опознанный по этому тексту.
i.php — инструмент просмотра одного выбранного изображения. Позволяет перейти к тегам из списка, которым это изображение соответствует.
img — корневая папка веб-галереи
m — папка со сгенерированными миниатюрами всех изображений. Миниатюры имеют высоту 200, ширина в соответствии с пропорциями изображения. Структура папки m повторяет структуру папки img. Папка m создаётся программно перед выкладыванием каждой версии галереи.
Tags — для каждого ключевого слова, содержит файл с результатом его поиска в каталогах.
Marks — виды файлов:
1. Для каждого ключевого слова, содержит файл его миниатюры
2. Для большинства ключевых слов, содержит файл с их текстовым описанием или тематическую историю, анекдот
3. Для некоторых ключевых слов, содержит один или несколько html-текстовых тематических рассказов
4. Также, в этой папке хранятся файлы типа <код буквы>.txt — упорядоченные по алфавиту списки ключевых слов по каждой букве русского алфавита
### Порядок выгрузки новой версии галереи на сайт
Специально написанная (используя Delphi и библиотеку Graphics32) программа делает следующее:
1. Проверка папки галереи — проверяется отсутствие лишних символов, правильность и отсутствие избыточности в тегах файлов (в т.ч. с учётом их иерархии), отсутствие среди имён файлов синонимов и ошибочных написаний ключевых слов (используя Wrong.csv), корректность файлов \_.txt, наличие миниатюр для папок, отсутствие файлов с неверными именами.
2. Пересоздание миниатюр для всех изображений. На этом этапе часто выясняется, что некоторые файлы имеют неверное расширение: .jpg вместо .png и т.д.
3. Генерация результатов поиска по каждому ключевому слову. Проверка наличия миниатюр для основных ключевых слов. Особый порядок для ключевых слов — исключений, по которым надо выдавать специально прописанную подборку.
4. Генерация списков ключевых слов для букв русского алфавита.
Затем, и папка галереи, и эти материалы выкладываются на сервер.
Движок веб-галереи не использует СУБД.
### Хостинг
Хостинг я использую [Avahost](https://secure.avahost.ru/aff.php?aff=14053), 100GB на диске стоят 500 рублей в месяц. Как несложно заметить, при размере коллекции 65GB, + миниатюры и прочее, и размере хостинга 100GB, обновление не бывает бесшовным. Не достаточно места чтобы сначала полностью новую версию выгрузить и на неё затем перейти бесшовно, возникает неизбежный интервал неработоспособности сайта длиной в несколько часов. Обновления я сейчас делаю раз в месяц.
Файлы отправляются на хостинг в виде архивов. Использующаяся сейчас на всех хостингах система cPanel умеет распаковывать только архивы zip. Желательно использовать файлы длиной до 2.5GB, иначе после завершения выгрузки файла в папку через веб-интерфейс cPanel, полоска прогресса выгрузки (изначальный цвет — синий) может стать не зелёной, а красной. В чём разница я не понял (файл вроде бы даже в этом случае выгружается нормально), но я в этом случае перевыкладываю. Для некоторых папок это приводит к тому, что папки приходится делить на несколько отдельных архивов zip.
Ранее я пытался создать хостинг дома, купил на авито б/у нетбук за 2000 рублей. Настроил, всё работает. Проходит пара суток — не работает. Перезагружаю — без толку. Потом, опять заработало, потом опять нет. Сменил нетбук (купил другой, более мощный, тоже на Авито, за 3000 рублей) и стал использовать другой софт — то же самое. Сменил трёх провайдеров (Севен скай > Акадо > МГТС) — то же самое. Короче, оборудование стоящее у провайдеров обрубает видимо домашний хостинг, причём сами провайдеры об этом и не знают. Или какие другие причины. Идите к хостерам, не делайте дома хостинга. Инди хостинг отстой. Даже примитивный маршрутизатор для взаимодействия сетевых игр лучше сваять на php и положить на хостинг чем держать дома или в офисе, и ждать что сломается без разумных причин.
### Хозяйке на заметку (про хостинг)
Кроме техно-характеристик (из которых действительно нужно только одна — количество гигабайт, всё остальное — числа у всех по своей шкале, я пришёл к тому что характеристики лучше у авахост), есть такой параметр — абуз-устойчивость. «abuse» — жалоба. Причём причина для жалобы может возникнуть на ровном месте, например [у студии Артемия Лебедева](https://tema.livejournal.com/3294030.html). Поэтому нормальный хостинг имеет параметр абузоустойчивость, устойчивость к жалобам. (Не путать со специальными хостингами, где можно размещать вообще что угодно, хоть фишинг страницу сбербанка с приглашением войти в личный кабинет — это отдельные конторы, я них не разбираюсь).
### Монетизация
Допустим, что вы — крупное СМИ, и решили значительную часть имеющих у вас (накопленных за десятки лет) фотографий сделать публичными. Например, используя описанную выше технологию. Как можно с этого зарабатывать (кроме брендирования наложением вотемарков на фотографии, а также их продажи)? Ну, если вы СМИ то вы знаете, расскажу для остальных.
Большинство схем монетизации даёт вам по 10 копеек со среднего посетителя сайта в день (включая как посетивших сайт один раз, так и посетивших несколько раз в день). Аналогично даёт автору сайта и РСЯ (рекламная сеть Яндекса). Чтобы зарабатывать больше, нужно вовлекать людей в религиозные секты или продавать чудо-талисманы, я такого не делаю. Агрегаторы подобных реклам легко найти в сети, они платят за достижение результатов (человек купил пылесос Кирби или стал членом секты). Причём, что обидно: я этого не делаю, зато Яндекс то и дело гонит через мой сайт подобное. В итоге людям всё равно подчас продают туфту задорого (через Яндекс), только я с этого получаю в 6 — 10 раз меньше.
У многих моих знакомых людей по умолчанию стоит адблок или что-то подобное и реклама Яндекса не видна. Причём сами они этого не ставили. Почему так — не знаю.
Яндекс позволяет вывести сумму по достижении 3000 рублей.
Также, владелец сайта может зарегистрироваться в miralinks.ru и размещать статьи. Адрес статьи и ссылки на неё надо размещать вечно, т.е. предусмотрите заранее чтобы их размещение не было слишком токсично. Допустимо, чтобы новые статьи вытесняли прежние в следующие страницы истории.
Можно продавать размещение баннеров, и иное сообразно смыслу ресурса.
### Где можно увидеть данную технологию в действии (какой проект я делаю)?
Я делаю сайт [corchaosis.ru](https://corchaosis.ru) — некий аналог вики для графики.
Почему пока не получилось его раскрутить (как я думаю):
— Людям нужно только средство совершения достижений.
Если даже люди идут в картинную галерею смотреть картины, им всё равно важно материальное достижение. Я посетил Третьяковскую галерею. Я посмотрел «Лебединое озеро».
Если веб-ресурс не приближает человека к материальным достижениям, то на него не заходят.
Сами люди могут думать другое, что им нравятся картины. Это не важно. Если мы что-то делаем в отношении людей, мы должны быть «сложнее» людей. Понимать и осознавать больше. Если лиса ест кур и мышей, то лиса должна быть и совершеннее, чем курицы. Из уровня представлений курицы, нельзя достичь результатов лисы.
— Людям нужно интерактивное.
ВЕБ 1.0 мертв.
Если вы не можете предложить интерактивности, то вы никому не нужны.
Вас не смотрят. Это снова о достижении результатов. Кобвой не идёт в джунгли ради туризма, он идёт в джунгли, чтобы основать собственное ранчо. Пока у сайта нет инструментов чтобы создать своё ранчо (портфолио и т.д.), джунгли ковбоям неинтересны.
### Где взять готовый движок
В принципе я описал всё необходимое, чтобы его сделать. Можно написать мне.
Локальный exe файл написан на Delphi+Graphics32, серверная часть это два файла .php. | https://habr.com/ru/post/509604/ | null | ru | null |
# Параллельные запросы в PostgreSQL
В современных ЦП очень много ядер. Годами приложения посылали запросы в базы данных параллельно. Если это отчетный запрос ко множеству строк в таблице, он выполняется быстрее, когда задействует несколько ЦП, и в PostgreSQL это возможно, начиная с версии 9.6.
Понадобилось 3 года, чтобы реализовать функцию параллельных запросов — пришлось переписать код на разных этапах выполнения запросов. В PostgreSQL 9.6 появилась инфраструктура для дальнейшего улучшения кода. В последующих версиях и другие типы запросов выполняются параллельно.
### Ограничения
* Не включайте параллельное выполнение, если все ядра уже заняты, иначе другие запросы будут тормозить.
* Самое главное, параллельная обработка с высокими значениями WORK\_MEM задействует много памяти — каждое хэш-соединение или сортировка занимают память в объеме work\_mem.
* Запросы OLTP с низкой задержкой невозможно ускорить параллельным выполнением. А если запрос возвращает одну строку, параллельная обработка его только замедлит.
* Разработчики любят использовать бенчмарк TPC-H. Может, у вас есть похожие запросы для идеального параллельного выполнения.
* Только запросы SELECT без предикатной блокировки выполняются параллельно.
* Иногда правильная индексация лучше последовательного сканирования таблицы в параллельном режиме.
* Приостановка запросов и курсоры не поддерживаются.
* Оконные функции и агрегатные функции упорядоченных наборов не параллельны.
* Вы ничего не выигрываете в рабочей нагрузке ввода-вывода.
* Параллельных алгоритмов сортировки не бывает. Но запросы с сортировками могут выполняться параллельно в некоторых аспектах.
* Замените CTE (WITH …) на вложенный SELECT, чтобы включить параллельную обработку.
* Обертки сторонних данных пока не поддерживают параллельную обработку (а могли бы!)
* FULL OUTER JOIN не поддерживается.
* max\_rows отключает параллельную обработку.
* Если в запросе есть функция, не помеченная как PARALLEL SAFE, он будет однопоточным.
* Уровень изоляции транзакции SERIALIZABLE отключает параллельную обработку.
### Тестовая среда
Разработчики PostgreSQL попытались урезать время отклика запросов бенчмарка TPC-H. Загрузите бенчмарк и [адаптируйте его к PostgreSQL](https://github.com/tvondra/pg_tpch). Это неофициальное использование бенчмарка TPC-H — не для сравнения баз данных или оборудования.
1. Загрузите TPC-H\_Tools\_v2.17.3.zip (или версию поновее) [с офсайта TPC](http://www.tpc.org/tpc_documents_current_versions/current_specifications.asp).
2. Переименуйте makefile.suite в Makefile и измените, как описано здесь: <https://github.com/tvondra/pg_tpch>. Скомпилируйте код командой make.
3. Сгенерируйте данные: `./dbgen -s 10` создает базу данных на 23 ГБ. Этого хватит, чтобы увидеть разницу в производительности параллельных и непараллельных запросов.
4. Конвертируйте файлы `tbl` в `csv с for` и `sed`.
5. Клонируйте репозиторий `pg_tpch` и скопируйте файлы `csv` в `pg_tpch/dss/data`.
6. Создайте запросы командой `qgen`.
7. Загрузите данные в базу командой `./tpch.sh`.
### Параллельное последовательное сканирование
Оно может быть быстрее не из-за параллельного чтения, а потому что данные разбросаны по многим ядрам ЦП. В современных ОС файлы данных PostgreSQL хорошо кэшируются. С упреждающим чтением можно получить из хранилища блок больше, чем запрашивает демон PG. Поэтому производительность запроса не ограничена вводом-выводом диска. Он потребляет циклы ЦП, чтобы:
* читать строки по одной со страниц таблицы;
* сравнивать значения строк и условия `WHERE`.
Выполним простой запрос `select`:
```
tpch=# explain analyze select l_quantity as sum_qty from lineitem where l_shipdate <= date '1998-12-01' - interval '105' day;
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------
Seq Scan on lineitem (cost=0.00..1964772.00 rows=58856235 width=5) (actual time=0.014..16951.669 rows=58839715 loops=1)
Filter: (l_shipdate <= '1998-08-18 00:00:00'::timestamp without time zone)
Rows Removed by Filter: 1146337
Planning Time: 0.203 ms
Execution Time: 19035.100 ms
```
Последовательный скан дает слишком много строк без агрегации, так что запрос выполняется одним ядром ЦП.
Если добавить `SUM()`, видно, что два рабочих процесса помогут ускорить запрос:
```
explain analyze select sum(l_quantity) as sum_qty from lineitem where l_shipdate <= date '1998-12-01' - interval '105' day;
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------
Finalize Aggregate (cost=1589702.14..1589702.15 rows=1 width=32) (actual time=8553.365..8553.365 rows=1 loops=1)
-> Gather (cost=1589701.91..1589702.12 rows=2 width=32) (actual time=8553.241..8555.067 rows=3 loops=1)
Workers Planned: 2
Workers Launched: 2
-> Partial Aggregate (cost=1588701.91..1588701.92 rows=1 width=32) (actual time=8547.546..8547.546 rows=1 loops=3)
-> Parallel Seq Scan on lineitem (cost=0.00..1527393.33 rows=24523431 width=5) (actual time=0.038..5998.417 rows=19613238 loops=3)
Filter: (l_shipdate <= '1998-08-18 00:00:00'::timestamp without time zone)
Rows Removed by Filter: 382112
Planning Time: 0.241 ms
Execution Time: 8555.131 ms
```
### Параллельная агрегация
Нода "Parallel Seq Scan" производит строки для частичной агрегации. Нода "Partial Aggregate" урезает эти строки с помощью `SUM()`. В конце счетчик SUM из каждого рабочего процесса собирается нодой "Gather".
Итоговый результат рассчитывается нодой "Finalize Aggregate". Если у вас свои функции агрегации, не забудьте пометить их как "parallel safe".
### Количество рабочих процессов
Количество рабочих процессов можно увеличить без перезапуска сервера:
```
alter system set max_parallel_workers_per_gather=4;
select * from pg_reload_conf();
```
Теперь мы видим 4 воркера в выводе explain:
```
tpch=# explain analyze select sum(l_quantity) as sum_qty from lineitem where l_shipdate <= date '1998-12-01' - interval '105' day;
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------
Finalize Aggregate (cost=1440213.58..1440213.59 rows=1 width=32) (actual time=5152.072..5152.072 rows=1 loops=1)
-> Gather (cost=1440213.15..1440213.56 rows=4 width=32) (actual time=5151.807..5153.900 rows=5 loops=1)
Workers Planned: 4
Workers Launched: 4
-> Partial Aggregate (cost=1439213.15..1439213.16 rows=1 width=32) (actual time=5147.238..5147.239 rows=1 loops=5)
-> Parallel Seq Scan on lineitem (cost=0.00..1402428.00 rows=14714059 width=5) (actual time=0.037..3601.882 rows=11767943 loops=5)
Filter: (l_shipdate <= '1998-08-18 00:00:00'::timestamp without time zone)
Rows Removed by Filter: 229267
Planning Time: 0.218 ms
Execution Time: 5153.967 ms
```
Что здесь происходит? Рабочих процессов стало в 2 раза больше, а запрос стал всего в 1,6599 раз быстрее. Расчеты интересные. У нас было 2 рабочих процесса и 1 лидер. После изменения стало 4+1.
Наше максимальное ускорение от параллельной обработки: 5/3 = 1,66(6) раз.
Как это работает?
-----------------
### Процессы
Выполнение запроса всегда начинается с лидирующего процесса. Лидер делает все непараллельное и часть параллельной обработки. Другие процессы, выполняющие те же запросы, называются рабочими процессами. Параллельная обработка использует инфраструктуру [динамических фоновых рабочих процессов](https://www.postgresql.org/docs/11/bgworker.html) (с версии 9.4). Раз другие части PostgreSQL используют процессы, а не потоки, запрос с 3 рабочими процессами мог быть в 4 раза быстрее традиционной обработки.
### Взаимодействие
Рабочие процессы общаются с лидером через очередь сообщений (на основе общей памяти). У каждого процесса 2 очереди: для ошибок и для кортежей.
### Сколько нужно рабочих процессов?
Минимальное ограничение задает параметр [`max_parallel_workers_per_gather`](https://www.postgresql.org/docs/11/runtime-config-resource.html#GUC-MAX-PARALLEL-WORKERS-PER-GATHER). Потом исполнитель запросов берет рабочие процессы из пула, ограниченного параметром [`max_parallel_workers size`](https://www.postgresql.org/docs/11/runtime-config-resource.html#GUC-MAX-WORKER-PROCESSES). Последнее ограничение — это [`max_worker_processes`](https://www.postgresql.org/docs/11/runtime-config-resource.html#GUC-MAX-WORKER-PROCESSES), то есть общее число фоновых процессов.
Если не удалось выделить рабочий процесс, обработка будет однопроцессной.
Планировщик запросов может сократить рабочие процессы в зависимости от размера таблицы или индекса. Для этого есть параметры [`min_parallel_table_scan_size`](https://www.postgresql.org/docs/current/runtime-config-query.html#GUC-MIN-PARALLEL-TABLE-SCAN-SIZE) и [`min_parallel_index_scan_size`](https://www.postgresql.org/docs/current/runtime-config-query.html#GUC-MIN-PARALLEL-INDEX-SCAN-SIZE).
```
set min_parallel_table_scan_size='8MB'
8MB table => 1 worker
24MB table => 2 workers
72MB table => 3 workers
x => log(x / min_parallel_table_scan_size) / log(3) + 1 worker
```
Каждый раз, когда таблица в 3 раза больше, чем `min_parallel_(index|table)_scan_size`, Postgres добавляет рабочий процесс. Количество рабочих процессов не основано на затратах. Круговая зависимость затрудняет сложные реализации. Вместо этого планировщик использует простые правила.
На практике эти правила не всегда годятся для продакшена, так что можно изменить количество рабочих процессов для конкретной таблицы: ALTER TABLE … SET (`parallel_workers = N`).
### Почему параллельная обработка не используется?
Кроме длинного списка ограничений есть еще проверки затрат:
[`parallel_setup_cost`](https://www.postgresql.org/docs/current/runtime-config-query.html#GUC-PARALLEL-SETUP-COST) — чтобы обойтись без параллельной обработки коротких запросов. Этот параметр прикидывает время на подготовку памяти, запуск процесса и начальный обмен данными.
[`parallel_tuple_cost`](https://www.postgresql.org/docs/current/runtime-config-query.html#GUC-PARALLEL-TUPLE-COST): общение лидера с рабочими может затягиваться пропорционально количеству кортежей от рабочих процессов. Этот параметр считает затраты на обмен данными.
### Соединения вложенных циклов — Nested Loop Join
```
PostgreSQL 9.6+ может выполнять вложенные циклы параллельно — это простая операция.
explain (costs off) select c_custkey, count(o_orderkey)
from customer left outer join orders on
c_custkey = o_custkey and o_comment not like '%special%deposits%'
group by c_custkey;
QUERY PLAN
--------------------------------------------------------------------------------------
Finalize GroupAggregate
Group Key: customer.c_custkey
-> Gather Merge
Workers Planned: 4
-> Partial GroupAggregate
Group Key: customer.c_custkey
-> Nested Loop Left Join
-> Parallel Index Only Scan using customer_pkey on customer
-> Index Scan using idx_orders_custkey on orders
Index Cond: (customer.c_custkey = o_custkey)
Filter: ((o_comment)::text !~~ '%special%deposits%'::text)
```
Сбор происходит на последнем этапе, так что Nested Loop Left Join — это параллельная операция. Parallel Index Only Scan появился только в версии 10. Он работает аналогично параллельному последовательному сканированию. Условие `c_custkey = o_custkey` считывает один порядок для каждой клиентской строки. Так что оно не параллельно.
### Хэш-соединение — Hash Join
Каждый рабочий процесс создает свою хэш-таблицу до PostgreSQL 11. И если этих процессов больше четырех, производительность не повысится. В новой версии хэш-таблица общая. Каждый рабочий процесс может использовать WORK\_MEM, чтобы создать хэш-таблицу.
```
select
l_shipmode,
sum(case
when o_orderpriority = '1-URGENT'
or o_orderpriority = '2-HIGH'
then 1
else 0
end) as high_line_count,
sum(case
when o_orderpriority <> '1-URGENT'
and o_orderpriority <> '2-HIGH'
then 1
else 0
end) as low_line_count
from
orders,
lineitem
where
o_orderkey = l_orderkey
and l_shipmode in ('MAIL', 'AIR')
and l_commitdate < l_receiptdate
and l_shipdate < l_commitdate
and l_receiptdate >= date '1996-01-01'
and l_receiptdate < date '1996-01-01' + interval '1' year
group by
l_shipmode
order by
l_shipmode
LIMIT 1;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=1964755.66..1964961.44 rows=1 width=27) (actual time=7579.592..7922.997 rows=1 loops=1)
-> Finalize GroupAggregate (cost=1964755.66..1966196.11 rows=7 width=27) (actual time=7579.590..7579.591 rows=1 loops=1)
Group Key: lineitem.l_shipmode
-> Gather Merge (cost=1964755.66..1966195.83 rows=28 width=27) (actual time=7559.593..7922.319 rows=6 loops=1)
Workers Planned: 4
Workers Launched: 4
-> Partial GroupAggregate (cost=1963755.61..1965192.44 rows=7 width=27) (actual time=7548.103..7564.592 rows=2 loops=5)
Group Key: lineitem.l_shipmode
-> Sort (cost=1963755.61..1963935.20 rows=71838 width=27) (actual time=7530.280..7539.688 rows=62519 loops=5)
Sort Key: lineitem.l_shipmode
Sort Method: external merge Disk: 2304kB
Worker 0: Sort Method: external merge Disk: 2064kB
Worker 1: Sort Method: external merge Disk: 2384kB
Worker 2: Sort Method: external merge Disk: 2264kB
Worker 3: Sort Method: external merge Disk: 2336kB
-> Parallel Hash Join (cost=382571.01..1957960.99 rows=71838 width=27) (actual time=7036.917..7499.692 rows=62519 loops=5)
Hash Cond: (lineitem.l_orderkey = orders.o_orderkey)
-> Parallel Seq Scan on lineitem (cost=0.00..1552386.40 rows=71838 width=19) (actual time=0.583..4901.063 rows=62519 loops=5)
Filter: ((l_shipmode = ANY ('{MAIL,AIR}'::bpchar[])) AND (l_commitdate < l_receiptdate) AND (l_shipdate < l_commitdate) AND (l_receiptdate >= '1996-01-01'::date) AND (l_receiptdate < '1997-01-01 00:00:00'::timestamp without time zone))
Rows Removed by Filter: 11934691
-> Parallel Hash (cost=313722.45..313722.45 rows=3750045 width=20) (actual time=2011.518..2011.518 rows=3000000 loops=5)
Buckets: 65536 Batches: 256 Memory Usage: 3840kB
-> Parallel Seq Scan on orders (cost=0.00..313722.45 rows=3750045 width=20) (actual time=0.029..995.948 rows=3000000 loops=5)
Planning Time: 0.977 ms
Execution Time: 7923.770 ms
```
Запрос 12 из TPC-H наглядно показывает параллельное хэш-соединение. Каждый рабочий процесс участвует в создании общей хэш-таблицы.
### Соединение слиянием — Merge Join
Соединение слиянием непараллельно по своей природе. Не переживайте, если это последний этап запроса, — он все равно может выполняться параллельно.
```
-- Query 2 from TPC-H
explain (costs off) select s_acctbal, s_name, n_name, p_partkey, p_mfgr, s_address, s_phone, s_comment
from part, supplier, partsupp, nation, region
where
p_partkey = ps_partkey
and s_suppkey = ps_suppkey
and p_size = 36
and p_type like '%BRASS'
and s_nationkey = n_nationkey
and n_regionkey = r_regionkey
and r_name = 'AMERICA'
and ps_supplycost = (
select
min(ps_supplycost)
from partsupp, supplier, nation, region
where
p_partkey = ps_partkey
and s_suppkey = ps_suppkey
and s_nationkey = n_nationkey
and n_regionkey = r_regionkey
and r_name = 'AMERICA'
)
order by s_acctbal desc, n_name, s_name, p_partkey
LIMIT 100;
QUERY PLAN
----------------------------------------------------------------------------------------------------------
Limit
-> Sort
Sort Key: supplier.s_acctbal DESC, nation.n_name, supplier.s_name, part.p_partkey
-> Merge Join
Merge Cond: (part.p_partkey = partsupp.ps_partkey)
Join Filter: (partsupp.ps_supplycost = (SubPlan 1))
-> Gather Merge
Workers Planned: 4
-> Parallel Index Scan using **part\_pkey** on part
Filter: (((p_type)::text ~~ '%BRASS'::text) AND (p_size = 36))
-> Materialize
-> Sort
Sort Key: partsupp.ps_partkey
-> Nested Loop
-> Nested Loop
Join Filter: (nation.n_regionkey = region.r_regionkey)
-> Seq Scan on region
Filter: (r_name = 'AMERICA'::bpchar)
-> Hash Join
Hash Cond: (supplier.s_nationkey = nation.n_nationkey)
-> Seq Scan on supplier
-> Hash
-> Seq Scan on nation
-> Index Scan using idx_partsupp_suppkey on partsupp
Index Cond: (ps_suppkey = supplier.s_suppkey)
SubPlan 1
-> Aggregate
-> Nested Loop
Join Filter: (nation_1.n_regionkey = region_1.r_regionkey)
-> Seq Scan on region region_1
Filter: (r_name = 'AMERICA'::bpchar)
-> Nested Loop
-> Nested Loop
-> Index Scan using idx_partsupp_partkey on partsupp partsupp_1
Index Cond: (part.p_partkey = ps_partkey)
-> Index Scan using supplier_pkey on supplier supplier_1
Index Cond: (s_suppkey = partsupp_1.ps_suppkey)
-> Index Scan using nation_pkey on nation nation_1
Index Cond: (n_nationkey = supplier_1.s_nationkey)
```
Нода "Merge Join" находится над "Gather Merge". Так что слияние не использует параллельную обработку. Но нода "Parallel Index Scan" все равно помогает с сегментом `part_pkey`.
### Соединение по секциям
В PostgreSQL 11 [соединение по секциям](http://ashutoshpg.blogspot.com/2017/12/partition-wise-joins-divide-and-conquer.html) отключено по умолчанию: у него очень затратное планирование. Таблицы со схожим секционированием можно соединять секция за секцией. Так Postgres будет использовать хэш-таблицы поменьше. Каждое соединение секций может быть параллельным.
```
tpch=# set enable_partitionwise_join=t;
tpch=# explain (costs off) select * from prt1 t1, prt2 t2
where t1.a = t2.b and t1.b = 0 and t2.b between 0 and 10000;
QUERY PLAN
---------------------------------------------------
Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Seq Scan on prt2_p1 t2
Filter: ((b >= 0) AND (b <= 10000))
-> Hash
-> Seq Scan on prt1_p1 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
-> Seq Scan on prt2_p2 t2_1
Filter: ((b >= 0) AND (b <= 10000))
-> Hash
-> Seq Scan on prt1_p2 t1_1
Filter: (b = 0)
tpch=# set parallel_setup_cost = 1;
tpch=# set parallel_tuple_cost = 0.01;
tpch=# explain (costs off) select * from prt1 t1, prt2 t2
where t1.a = t2.b and t1.b = 0 and t2.b between 0 and 10000;
QUERY PLAN
-----------------------------------------------------------
Gather
Workers Planned: 4
-> Parallel Append
-> Parallel Hash Join
Hash Cond: (t2_1.b = t1_1.a)
-> Parallel Seq Scan on prt2_p2 t2_1
Filter: ((b >= 0) AND (b <= 10000))
-> Parallel Hash
-> Parallel Seq Scan on prt1_p2 t1_1
Filter: (b = 0)
-> Parallel Hash Join
Hash Cond: (t2.b = t1.a)
-> Parallel Seq Scan on prt2_p1 t2
Filter: ((b >= 0) AND (b <= 10000))
-> Parallel Hash
-> Parallel Seq Scan on prt1_p1 t1
Filter: (b = 0)
```
Главное, соединение по секциям бывает параллельным, только если эти секции достаточно большие.
### Параллельное дополнение — Parallel Append
[Parallel Append](https://www.postgresql.org/docs/11/parallel-plans.html#PARALLEL-APPEND) может использоваться вместо разных блоков в разных рабочих процессах. Обычно это бывает с запросами UNION ALL. Недостаток — меньше параллелизма, ведь каждый рабочий процесс обрабатывает только 1 запрос.
Здесь запущено 2 рабочих процесса, хотя включено 4.
```
tpch=# explain (costs off) select sum(l_quantity) as sum_qty from lineitem where l_shipdate <= date '1998-12-01' - interval '105' day union all select sum(l_quantity) as sum_qty from lineitem where l_shipdate <= date '2000-12-01' - interval '105' day;
QUERY PLAN
------------------------------------------------------------------------------------------------
Gather
Workers Planned: 2
-> Parallel Append
-> Aggregate
-> Seq Scan on lineitem
Filter: (l_shipdate <= '2000-08-18 00:00:00'::timestamp without time zone)
-> Aggregate
-> Seq Scan on lineitem lineitem_1
Filter: (l_shipdate <= '1998-08-18 00:00:00'::timestamp without time zone)
```
### Самые важные переменные
* WORK\_MEM ограничивает объем памяти для каждого процесса, не только для запросов: work\_mem *процессы* соединения = очень много памяти.
* [`max_parallel_workers_per_gather`](https://www.postgresql.org/docs/11/runtime-config-resource.html#GUC-MAX-PARALLEL-WORKERS-PER-GATHER) — сколько рабочих процессов исполняющая программа будет использовать для параллельной обработки из плана.
* [`max_worker_processes`](https://www.postgresql.org/docs/11/runtime-config-resource.html#GUC-MAX-WORKER-PROCESSES) — подстраивает общее число рабочих процессов под число ядер ЦП на сервере.
* [`max_parallel_workers`](https://www.postgresql.org/docs/11/runtime-config-resource.html#GUC-MAX-WORKER-PROCESSES) — то же, но для параллельных рабочих процессов.
### Итоги
Начиная с версии 9.6 параллельная обработка может серьезно улучшить производительность сложных запросов, которые сканируют много строк или индексов. В PostgreSQL 10 параллельная обработка включена по умолчанию. Не забывайте отключать ее на серверах с большой рабочей нагрузкой OLTP. Последовательные сканы или сканы индексов потребляют очень много ресурсов. Если вы не выполняете отчет по всему набору данных, запросы можно сделать производительнее, просто добавив недостающие индексы или используя правильное секционирование.
### Ссылки
* <https://www.postgresql.org/docs/11/how-parallel-query-works.html>
* <https://www.postgresql.org/docs/11/parallel-plans.html>
* <http://ashutoshpg.blogspot.com/2017/12/partition-wise-joins-divide-and-conquer.html>
* <http://rhaas.blogspot.com/2016/04/postgresql-96-with-parallel-query-vs.html>
* <http://amitkapila16.blogspot.com/2015/11/parallel-sequential-scans-in-play.html>
* <https://write-skew.blogspot.com/2018/01/parallel-hash-for-postgresql.html>
* <http://rhaas.blogspot.com/2017/03/parallel-query-v2.html>
* <https://blog.2ndquadrant.com/parallel-monster-benchmark/>
* <https://blog.2ndquadrant.com/parallel-aggregate/>
* <https://www.depesz.com/2018/02/12/waiting-for-postgresql-11-support-parallel-btree-index-builds/>
* [Параллелизм в PostgreSQL 11](https://youtu.be/jWIOZzezbb8) | https://habr.com/ru/post/446706/ | null | ru | null |
# Создание небольшого API на Deno
В этом посте я хотел бы рассказать и показать процесс создания небольшого API с помощью Deno. Deno — новейшая среда для запуска Javascript и Typescript, разработанная создателем Node.js — Райаном Далем.
**Наши цели**:
* Разработать API, которое будет работать с данными пользователей
* Предоставить возможность использовать методы GET, POST, PUT и DELETE
* Сохранять и обновлять данные пользователей в локальный JSON файл
* Воспользоваться фреймворком для ускорения разработки
Единственное, что нам потребуется установить — Deno. Deno поддерживает Typescript прямо из коробки. Для этого примера я использовал Deno версии 0.22 и этот код может не заработать на дальнейших версиях.
Версию установленного Deno можно узнать командой *deno version* в терминале.
### Структура программы
```
handlers
middlewares
models
services
config.ts
index.ts
routing.ts
```
Как вы могли заметить, выглядит это как небольшое web приложение на Node.js.
* *handlers* — содержит обработчики маршрутов
* *middlewares* — содержит в себе функции, которые будут запущены при каждом запросе
* *models* — содержит в себе обозначение моделей, в нашем случае это только интерфейс пользователя
* *services* — содержит… сервисы!
* *config.ts* — конфигурационный файл приложения
* *index.ts* — входная точка для нашего приложения
* *routing.ts* — содержит маршруты API
### Выбор фреймворка
Существует много великолепных фреймворков для Node.js. Один из самых популярных — **Express**. Также есть современная версия Express’a — **Koa**. К сожалению, Deno не поддерживает библиотеки Node.js и выбор гораздо меньше, но существует фреймворк для Deno, который создан на основе Koa — **Oak**. Мы воспользуемся им для нашего небольшого проекта. Если вы никогда не использовали Koa, не переживайте, он многим похож на Express.
### Создание входной точки приложения
*index.ts*
```
import { Application } from "https://deno.land/x/oak/mod.ts";
import { APP_HOST, APP_PORT } from "./config.ts";
import router from "./routing.ts";
import notFound from "./handlers/notFound.ts";
import errorMiddleware from "./middlewares/error.ts";
const app = new Application();
app.use(errorMiddleware);
app.use(router.routes());
app.use(router.allowedMethods());
app.use(notFound);
console.log(`Listening on ${APP_PORT}...`);
await app.listen(`${APP_HOST}:${APP_PORT}`);
```
В первой строчке мы используем одну из главных фишек Deno — импортирование модулей прямо из интернета. После этого нет ничего необычного: создаем приложение, добавляем middleware, маршруты и, наконец, запускаем сервер. Все также, как и в случае использования Express или Koa.
### Создание конфигурации
*config.ts*
```
const env = Deno.env();
export const APP_HOST = env.APP_HOST || "127.0.0.1";
export const APP_PORT = env.APP_PORT || 4000;
export const DB_PATH = env.DB_PATH || "./db/users.json";
```
Наш файл конфигурации. Настройки переносятся из среды запуска, но мы также добавим дефолтные значение. Функция *Deno.env()* является аналогом *process.env* в Node.js.
### Добавление модели пользователя
*models/user.ts*
```
export interface User {
id: string;
name: string;
role: string;
jiraAdmin: boolean;
added: Date;
}
```
### Создание файла с маршрутами
*routing.ts*
```
import { Router } from "https://deno.land/x/oak/mod.ts";
import getUsers from "./handlers/getUsers.ts";
import getUserDetails from "./handlers/getUserDetails.ts";
import createUser from "./handlers/createUser.ts";
import updateUser from "./handlers/updateUser.ts";
import deleteUser from "./handlers/deleteUser.ts";
const router = new Router();
router
.get("/users", getUsers)
.get("/users/:id", getUserDetails)
.post("/users", createUser)
.put("/users/:id", updateUser)
.delete("/users/:id", deleteUser);
export default router;
```
Опять же, ничего необычного. Мы создали маршрутизатор и добавили несколько маршрутов в него. Выглядит практически так, как будто вы скопировали код из Express приложения, не так ли?
### Обработка событий для маршрутов
*handlers/getUsers.ts*
```
import { getUsers } from "../services/users.ts";
export default async ({ response }) => {
response.body = await getUsers();
};
```
Возвращает всех пользователей. Если вы никогда не использовали Koa, то разъясню. Объект *response* является аналогом *res* в Express. Объект *res* в Express имеет пару методов вроде *json* или *send*, которые служат для отправки ответа. В Oak и Koa нам нужно установить значение, которое мы хотим вернуть в свойство *response.body*.
*handlers/getUserDetails.ts*
```
import { getUser } from "../services/users.ts";
export default async ({ params, response }) => {
const userId = params.id;
if (!userId) {
response.status = 400;
response.body = { msg: "Invalid user id" };
return;
}
const foundUser = await getUser(userId);
if (!foundUser) {
response.status = 404;
response.body = { msg: `User with ID ${userId} not found` };
return;
}
response.body = foundUser;
};
```
Тут тоже все легко. Обработчик возвращает пользователя с нужным Id.
*handlers/createUser.ts*
```
import { createUser } from "../services/users.ts";
export default async ({ request, response }) => {
if (!request.hasBody) {
response.status = 400;
response.body = { msg: "Invalid user data" };
return;
}
const {
value: { name, role, jiraAdmin }
} = await request.body();
if (!name || !role) {
response.status = 422;
response.body = { msg: "Incorrect user data. Name and role are required" };
return;
}
const userId = await createUser({ name, role, jiraAdmin });
response.body = { msg: "User created", userId };
};
```
Этот обработчик отвечает за создание пользователя.
*handlers/updateUser.ts*
```
import { updateUser } from "../services/users.ts";
export default async ({ params, request, response }) => {
const userId = params.id;
if (!userId) {
response.status = 400;
response.body = { msg: "Invalid user id" };
return;
}
if (!request.hasBody) {
response.status = 400;
response.body = { msg: "Invalid user data" };
return;
}
const {
value: { name, role, jiraAdmin }
} = await request.body();
await updateUser(userId, { name, role, jiraAdmin });
response.body = { msg: "User updated" };
};
```
Обработчик проверяет существует ли пользователь с указанным ID и обновляет данные пользователей.
*handlers/deleteUser.ts*
```
import { deleteUser, getUser } from "../services/users.ts";
export default async ({ params, response }) => {
const userId = params.id;
if (!userId) {
response.status = 400;
response.body = { msg: "Invalid user id" };
return;
}
const foundUser = await getUser(userId);
if (!foundUser) {
response.status = 404;
response.body = { msg: `User with ID ${userId} not found` };
return;
}
await deleteUser(userId);
response.body = { msg: "User deleted" };
};
```
Отвечает за удаление пользователя.
Также желательно обрабатывать запросы на несуществующие маршруты и возвращать сообщение с ошибкой.
*handlers/notFound.ts*
```
export default ({ response }) => {
response.status = 404;
response.body = { msg: "Not Found" };
};
```
### Добавление сервисов
Перед созданием сервисов, которые будут работать с данными пользователей, нам нужно сделать два небольших вспомогательных сервиса.
*services/createId.ts*
```
import { v4 as uuid } from "https://deno.land/std/uuid/mod.ts";
export default () => uuid.generate();
```
Каждый новый пользователь будет получать уникальный id. Воспользуемся модулем uuid из стандартной библиотеки Deno для генерации случайного числа.
*services/db.ts*
```
import { DB_PATH } from "../config.ts";
import { User } from "../models/user.ts";
export const fetchData = async (): Promise => {
const data = await Deno.readFile(DB\_PATH);
const decoder = new TextDecoder();
const decodedData = decoder.decode(data);
return JSON.parse(decodedData);
};
export const persistData = async (data): Promise => {
const encoder = new TextEncoder();
await Deno.writeFile(DB\_PATH, encoder.encode(JSON.stringify(data)));
};
```
Этот сервис будет помогать взаимодействовать с JSON файлом, в котором будут храниться данные пользователей.
Чтобы получить всех пользователей, прочитаем содержимого файла. Функция readFile возвращает объект типа *Uint8Array*, которые перед тем как занести в JSON файл, нужно преобразовать в тип *String*.
На и наконец, основной сервис для работы с данными пользователей.
*services/users.ts*
```
import { fetchData, persistData } from "./db.ts";
import { User } from "../models/user.ts";
import createId from "../services/createId.ts";
type UserData = Pick;
export const getUsers = async (): Promise => {
const users = await fetchData();
// sort by name
return users.sort((a, b) => a.name.localeCompare(b.name));
};
export const getUser = async (userId: string): Promise => {
const users = await fetchData();
return users.find(({ id }) => id === userId);
};
export const createUser = async (userData: UserData): Promise => {
const users = await fetchData();
const newUser: User = {
id: createId(),
name: String(userData.name),
role: String(userData.role),
jiraAdmin: "jiraAdmin" in userData ? Boolean(userData.jiraAdmin) : false,
added: new Date()
};
await persistData([...users, newUser]);
return newUser.id;
};
export const updateUser = async (
userId: string,
userData: UserData
): Promise => {
const user = await getUser(userId);
if (!user) {
throw new Error("User not found");
}
const updatedUser = {
...user,
name: userData.name !== undefined ? String(userData.name) : user.name,
role: userData.role !== undefined ? String(userData.role) : user.role,
jiraAdmin:
userData.jiraAdmin !== undefined
? Boolean(userData.jiraAdmin)
: user.jiraAdmin
};
const users = await fetchData();
const filteredUsers = users.filter(user => user.id !== userId);
persistData([...filteredUsers, updatedUser]);
};
export const deleteUser = async (userId: string): Promise => {
const users = await getUsers();
const filteredUsers = users.filter(user => user.id !== userId);
persistData(filteredUsers);
};
```
Здесь много кода, но это чистый Typescript.
### Обработка ошибок
Что может быть хуже, чем то, что случится в случае ошибки сервиса, работающего с данными пользователей? Вся программа может крашнуться. Для избежания подобного сценария, можно воспользоваться конструкцией try/catch в каждом обработчике. Но существует более изящное решение — добавим middleware перед каждым маршрутом и предотвратим все неожиданные ошибки, которые могут возникнуть.
*middlewares/error.ts*
```
export default async ({ response }, next) => {
try {
await next();
} catch (err) {
response.status = 500;
response.body = { msg: err.message };
}
};
```
Перед тем, как запустить саму программу, нам нужно добавить данные для запуска.
*db/users.json*
```
[
{
"id": "1",
"name": "Daniel",
"role": "Software Architect",
"jiraAdmin": true,
"added": "2017-10-15"
},
{
"id": "2",
"name": "Markus",
"role": "Frontend Engineer",
"jiraAdmin": false,
"added": "2018-09-01"
}
]
```
Вот и все! Теперь можно попробовать запустить наше приложение:
`deno -A index.ts`
Флаг “А” обозначает, что программе не нужно давать каких-либо отдельных разрешений. Не забывайте, что использовать этот флаг небезопасно в продакшене.
Скорее всего, вы увидите много строчек с загрузкой (Download) и компиляцией (Compile). В конце концов должна появиться заветная строчка:
`Listening on 4000`
### Подведем итоги
**Какими инструментами мы воспользовались?**
1. Глобальный объект **Deno** для чтения/записи файлов
2. **uuid** из стандартной библиотеки Deno для создание уникального id
3. **oak** — third-party фреймворк, вдохновленный Koa для Node.js
4. Чистый Typescript, объекты TextEncode или JSON, входящие в Javascript
### В чем же отличие от Node.js?
* Отсутствие необходимости в установке и настройки компилятора для Typescript или других инструментов вроде ts-node. Можно просто запустить программу командой *deno index.ts*
* Включение всех сторонних модулей прямо в код без необходимости предварительной установки
* Отсутствие package.json и package-lock.json
* Отсутствие node\_modules в коренной директории нашей программы. Все загруженные файлы расположены в глобальном кэше
При необходимости, исходный код вы можете найти по [ссылке](https://github.com/kryz81/deno-api-example). | https://habr.com/ru/post/487806/ | null | ru | null |
# RSS-лента по почте
Есть одна важная для меня RSS-лента. И хочется оперативно узнавать о “новых новостях” в ней. К сожалению, почтовой рассылки этот новостной сервер не предоставляет. Для чтения RSS я привык пользоваться Web-сервисом Google Reader, а он, несмотря на своё происхождение и родственные связи с Gmail, такой возможности тоже не даёт. И его мобильный клиент никак не оповещает о появлении новостей в лентах. Может и слава Богу – некоторые фиды очень плодовиты – но ведь бывают случаи когда это полезно. Вот как я выкрутился.
Чуть погуглив, я нашел довольно простое решение. Замечательный сервис автоматизации – [ifttt.com](https://ifttt.com/) (If This Then That). Сервис позволяет создавать правила по принципу «если–то» и поддерживает тьму социальных сетей и других сервисов. В частности, можно создать правило, что при появлении новости в определенном фиде, будет отправляться письмо на такой-то ящик. Вроде бы то что надо, но несколько моментов не давали покоя. Какие недостатки я тут вижу:
1. В Google Reader необходимо создать ленту, которой на практике пользоваться не придётся. Ведь если я буду получать почту о новых событиях, зачем мне тогда этот фид в клиенте?
2. Значит, в этой ленте будут скапливаться непрочитанные новости. Чисти их ещё чтоб не маячили...
3. Для ленты придётся специально создать папку, чтобы ifttt мог эту ленту идентифицировать. Это уже особенность работы ifttt с сервисом Google Reader.
4. Для того, чтобы пользоваться ifttt, придётся в нем зарегистрироваться. Очередная учетная запись, сколько ж можно?
Что бы придумать? Определенно, нужно серверное решение. И тут на помощь приходит Корпорация Добра, вся такая в белом, если опять не закроет какой-нибудь сервис. Я вспомнил про Google Apps Script и Google Диск. Решение очень простое. Создаем таблицу на Goolge Диск и добавляем в неё вот такой сценарий (меню “Инструменты” => “Редактор скриптов...”):
```
function onTimer() {
var sheet = SpreadsheetApp.getActiveSheet();
var maxPubDate = new Date(sheet.getRange(1, 1).getValue());
var txt = UrlFetchApp.fetch("http://habrahabr.ru/rss/best/").getContentText();
var doc = Xml.parse(txt, false);
var channel = doc.getElement().getElement("channel");
var mailBody = "";
var items = channel.getElements("item")
var curMaxPubDate = maxPubDate;
var hasNews = false;
for (var i in items) {
var pubDate = new Date(items[i].getElement("pubDate").getText());
if (pubDate > maxPubDate) {
if (pubDate > curMaxPubDate) {
curMaxPubDate = pubDate
}
hasNews = true;
mailBody += "\nЗаголовок: " + items[i].getElement("title").getText();
mailBody += "\nСсылка: " + items[i].getElement("link").getText();
mailBody += "\nДата публикации: " + pubDate;
mailBody += "\n";
}
}
if (hasNews) {
GmailApp.sendEmail("xxxxxxxx@gmail.com", "Новости Хабра!", mailBody);
sheet.getRange(1, 1).setValue(curMaxPubDate);
}
}
```
Да, надо не забыть вписать в ячейку A1 какую-нибудь древнюю дату, “30.01.2002 13:00:00”, как вариант. Затем устанавливаем скрипт на запуск, например, каждые 10 минут. Для этого в редакторе сценариев выбираем пункт меню “Ресурсы” => “Триггеры текущего проекта...” и добавляем “динамический минутный таймер”.
Скрипт получает содержимое ленты, парсит, отбирает новости, дата публикации которых превышает дату из ячейки A1, и отправляет их мне по почте. Под занавес ставит в A1 самую большую дату, какую нашёл.
В угоду простоте и лаконичности, в скрипте не хватает парсинга протокола Atom. Ну и в таблицу стоит добавить список наблюдаемых фидов, но это уже дело техники.
Получается, мне не понадобились RSS-клиенты, серверы автоматизации и дополнительные учётки. Только моя Гугловская. На всякий случай подчеркну – описанное выше, вовсе не замена RSS-клиентам. Это всего лишь вариант оповещения по почте о новостях в одной-двух любимых лентах.
К своему стыду, должен признать, что это первый раз, когда мне пришло в голову использовать Google Apps Script. А вам приходилось применять Google Apps Script? Если это не секрет, поделитесь, пожалуйста, опытом в комментариях – для каких задач?
**UPD:**
Я добавил парсинг протокола Atom и наблюдение за несколькими фидами. Подробности [у меня в блоге](http://dmitrydzz-hobby.blogspot.ru/2013/02/rss.html). | https://habr.com/ru/post/168569/ | null | ru | null |
# Защита от DDoS атаки на уровне веб-приложений
Как известно DDoS атаки на сайт бывают разной интенсивности, имеет значение количество хостов участвующих в атаке, количество сетевых пакетов и объем передаваемых данных. В самых тяжелых случаях отбить атаку возможно только применяя специализированное оборудование и сервисы.
Если же объем атаки меньше пропускной способности сетевого оборудования и вычислительных мощностей сервера (пула серверов) обслуживающих сайт, то можно попробовать “заглушить” атаку не прибегая к сторонним сервисам, а именно включить программный фильтр трафика поступающего на сайт. Этот фильтр будет отсеивать трафик ботов участвующих в атаке, при этом пропуская легитимный трафик “живых” посетителей сайта.
Схема программного фильтра от DDoS атак на сайт
-----------------------------------------------
Фильтр основан на том, что боты участвующие в DDoS атаках не способны выполнить JavaScript код, соответственно боты не пройдут дальше стоп-страницы фильтра, чем существенно разгрузят фронтенд/бекэнд и базу данных сайта. Т.к. на обработку каждого GET/POST запроса DDoS атаки потребуется выполнить не более 20 строк кода в бэкенде сайта и выдать страницу-заглушку объемом менее 2Кб данных.
1. Фильтр вызываем первой строкой веб-приложения, до вызова всего остального кода приложения. Так можно максимально разгрузить “железо” сервера и уменьшить объем отдаваемого трафика в сторону ботов.
2. Если посетитель попадает под условия фильтра, то выдаем посетителю специальную страницу-заглушку. На странице,
* Сообщаем о причинах выдачи специальной страницы вместо запрошенной
* Устанавливаем специальную куку в броузере пользователя посредством JavaScript.
* Выполняем JavaScript код перенаправления на исходную страницу.
3. Если у посетителя установлена специальная кука, то фильтр прозрачно пропускает посетителя на запрошенную страницу сайта.
4. Если IP адрес посетителя принадлежит автономной системе из списка исключений, то трафик так же прозрачно пропускаем. Это условие необходимо для исключения фильтрации ботов поисковых систем.
Проект фильтра на [github.com](https://github.com/CleanTalk/anti-ddos-lite).
Синтетические тесты фильтра
---------------------------
Тестировали утилитой ab от Apache Foundation на главной странице боевого сайта, предварительно сняв нагрузку с одной из нод.
Результаты с отключенным фильтром,
```
ab -c 100 -n 1000 https://cleantalk.org/
Total transferred: 27615000 bytes
HTML transferred: 27148000 bytes
Requests per second: 40.75 [#/sec] (mean)
Time per request: 2454.211 [ms] (mean)
Time per request: 24.542 [ms] (mean, across all concurrent requests)
Transfer rate: 1098.84 [Kbytes/sec] received
```
Теперь тоже самое с включенным фильтром,
```
Total transferred: 2921000 bytes
HTML transferred: 2783000 bytes
Requests per second: 294.70 [#/sec] (mean)
Time per request: 339.332 [ms] (mean)
Time per request: 3.393 [ms] (mean, across all concurrent requests)
Transfer rate: 840.63 [Kbytes/sec] received
```
Как видно из результатов тестирования, включение фильтра позволяет обработать веб-серверу почти на порядок больше запросов чем без фильтра. Естественно речь идет только о запросах, от посетителей без поддержки JavaScript.
Применение фильтра на практике, история спасения сайта от одной небольшой DDoS атаки
------------------------------------------------------------------------------------
Периодически мы сталкиваемся с DDoS атаками на наш собственный, корпоративный сайт <https://cleantalk.org>. Собственно во время крайней из атак мы и применили фильтр от DDoS на уровне веб-приложений сайта.
### Начало атаки
Атака началась в 18:10 UTC+5 18 Января 2018 года, атаковали GET запросами на URL <https://cleantalk.org/blacklists>. На сетевых интерфейсах Front-end серверов появились дополнительные 1000-1200 кбит/секунду входящего трафика, т.е. получили нагрузку 150/секунду GET запросов к каждому серверу, что выше штатной нагрузки в 5 раз. Как следствие резко вырос Load average серверов Front-end и серверов баз данных. В результате сайт начал выдавать ошибку 502 по причине отсутствия свободных процессов php-fpm.
### Анализ атаки
Потратив некоторое время на изучение логов, стало понятно что это именно DDoS атака, т.к.,
* 5/6 запросов приходились на один и тот же URL.
* Отсутствовала ярко выраженная группа IP адресов создающая нагрузку на URL из пункта 1.
* CPU фронтенд серверов был загружен на порядок выше, чем всплеск нагрузки на сетевых интерфейсах.
Соответственно было решено включить фильтр посетителей сайта по алгоритму описанному выше, дополнительно включив в него проверку входящего трафика по нашей [БД черных списков](https://cleantalk.org/blacklists), тем самым уменьшив вероятность выдачи стоп-страницы легитимным посетителям сайта.
### Включение фильтра
Потратив еще некоторое время на подготовку фильтра, в 19:15-19:20 он был включен.
Спустя несколько минут получили первые положительные результаты, сначала Load average вернулся к норме, затем упала нагрузка на сетевых интерфейсах. Спустя несколько часов атака повторилась дважды, но ее последствия были практически незаметны, фронтенды отработали без ошибок 502.
Заключение
----------
В итоге, применением простейшего кода JavaScript мы решил задачу фильтрации трафика от ботов, тем самым погасили DDoS атаку и вернули показатели доступности сайта к штатному состоянию.
Честно говоря, этот алгоритм фильтрации ботов был придуман не в день атаки описанной выше. Еще несколько лет назад реализовали дополнительную функцию SpamFireWall к нашему Антиспам сервису, SpamFireWall используют более чем 10 тысяч веб-сайтов и о нем есть отдельная [статья](https://habrahabr.ru/company/cleantalk/blog/301424/).
SpamFireWall был разработан прежде всего для борьбы со спам-ботами, но так как списки спам-ботов пересекаются со списками прочих ботов, используемых для сомнительных целей, то применение SFW вполне эффективно в том числе и для купирования небольших DDoS атак на сайт.
О сервисе CleanTalk
-------------------
[CleanTalk](https://cleantalk.org) это облачный сервис защиты веб-сайтов от спамботов. CleanTalk использует методы защиты, которые незаметны для посетителей веб-сайта. Это позволяет отказаться от методов защиты, которые требуют от пользователя доказать, что он человек (captcha, вопрос-ответ и др.). | https://habr.com/ru/post/354374/ | null | ru | null |
# Удивительное рядом, или команда ddate в Linux / Unix
Стоит лишь случайно дважды нажать клавишу, и попадаешь в новый удивительный мир. Так, сегодня я ввёл "*ddate*" вместо "*date*" в консоли и обнаружил массу интересного. Оказалось, *ddate* выводит текущую дату по «Дискордианскому календарю».
«WTF?», скажет кто-то, чем в точности повторит мою реакцию. Краткий ответ примерно таков: Дискордианский календарь используется поклонниками Дискордианизма. А Дискордианизм (Дискордиа́нство) — [согласно русской Википедии](http://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%81%D0%BA%D0%BE%D1%80%D0%B4%D0%B8%D0%B0%D0%BD%D0%B8%D0%B7%D0%BC) — «пародия на религию или религия, маскирующаяся под пародию. В отличие от традиционных религий, проповедующих гармонию, дискордианизм обожествляет хаос. Главным божеством дискордианизма является Эрис, древнегреческая богиня раздора, подбросившая яблоко раздора на свадебном пиру у Пелея. Основополагающая книга — Principia Discordia (1958 или 1959), написана Омаром Хайямом Равенхурстом (Керри Торнли) и Малаклипсом Младшим (Грег Хилл).».
Более подробная информация есть в Английском варианте: [по календарю](http://en.wikipedia.org/wiki/Discordian_Date) и [по самой религии](http://en.wikipedia.org/wiki/Discordianism). Вообще занятно — например, следующее: «в Дискордианском календаре 5 73-дневных сезона: Хаос, Разлад, Замешательство, Бюрократия и Последствия».
Подробная информация по запуску и формату даты самой команды, естественно, в *man ddate*, оттуда приведу лишь примеры использования:
`% ddate
Sweetmorn, Bureaucracy 42, 3161 YOLD
% ddate +'Today is %{%A, the %e of %B%}, %Y. %N%nCelebrate %H'
Today is Sweetmorn, the 42nd of Bureaucracy, 3161.
% ddate +"It's %{%A, the %e of %B%}, %Y. %N%nCelebrate %H" 26 9 1995
It's Prickle-Prickle, the 50th of Bureaucracy, 3161.
Celebrate Bureflux
% ddate +"Today's %{%A, the %e of %B%}, %Y. %N%nCelebrate %H" 29 2 1996
Today's St. Tib's Day, 3162.`
P.S.: ничего лучшего (в плане дислокации) чем «Linux для всех» не придумал. | https://habr.com/ru/post/99696/ | null | ru | null |
# WinPhone: пути к совершенству
*Внимание!*
Более свежие и прогрессивные материалы по *MVVM* паттерну представлены в статье [Context Model Pattern via Aero Framework](http://habrahabr.ru/post/251347/) и подробно разобраны в [следующем цикле статей](http://habrahabr.ru/users/makeman/topics/)
В этой статье я расскажу о том, как сделать не сложный, но интерактивный и функциональный графический редактор-рисовалку под Windows Phone. Думаю, даже опытные разработчики смогут найти для себя что-то интересное и новое. Уникальной фишкой редактора будет история, которую можно в буквальном смысле отматывать на нужный момент с помощью ползунка-слайдера. И да, в завершение мы нарисуем радугу! Поехали…
Конечно же, я подготовил [качественный пример](https://vent.codeplex.com/).
**Расширения разметки (markup extensions)**
Когда я только начал разрабатывать на WinPhone, практически сразу был разочарован целым рядом ограничений этой платформы. Например, оказалось, что здесь даже нет привычных расширений разметки, как в WPF или Silverlight. Ведь, например, для локализации или картинок намного красивее писать следующий код в xaml:
```
```
«Как же так?! Ведь настолько удобная штука», — подумал я и на досуге решил исследовать этот вопрос детальнее, и не зря.
Покопавшись дизассемблером от решарпера в библиотечных классах, я вдруг заметил, что класс Binding не помечен атрибутом sealed. А что если унаследоваться от него, мелькнуло в голове? Попробвал, и получилось!
```
public abstract class MarkupExtension : Binding, IValueConverter
{
protected MarkupExtension()
{
Source = Converter = this;
}
protected MarkupExtension(object source) // set Source to null for using DataContext
{
Source = source;
Converter = this;
}
protected MarkupExtension(RelativeSource relativeSource)
{
RelativeSource = relativeSource;
Converter = this;
}
public abstract object Convert(object value, Type targetType, object parameter, CultureInfo culture);
public virtual object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
throw new NotImplementedException();
}
}
```
Вот такой базовый класс вышел. А дальше пример реализации расширения для локализации.
```
public class Localizing : MarkupExtension
{
public static readonly LocalizingManager Manager = new LocalizingManager();
public Localizing()
{
Source = Manager;
Path = new PropertyPath("Source");
}
public string Key { get; set; }
public override string ToString()
{
return Convert(Manager.Source, null, Key, Thread.CurrentThread.CurrentCulture) as string ??
string.Empty;
}
public override object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
var key = Key;
var resourceManager = value as ResourceManager;
if (resourceManager == null || string.IsNullOrEmpty(key)) return ":" + key + ":";
var localizedValue = resourceManager.GetString(key);
return localizedValue ?? ":" + key + ":";
}
}
public class LocalizingManager : INotifyPropertyChanged
{
private ResourceManager _source;
public ResourceManager Source
{
get { return _source; }
set
{
_source = value;
PropertyChanged(this, new PropertyChangedEventArgs("Source"));
}
}
public event PropertyChangedEventHandler PropertyChanged = (sender, args) => { };
}
```
Теперь и на WinPhone можно писать
```
```
К сожалению, от префикса f: избавиться не удалось из-за ограничений платформы, также обязательно указывать имя свойства Key, но и это уже лучше, чем стандартная запись
```
```
Кстати, наша реализация поддерживает горячую смену языка во время работы приложения, что называется налету. Используя базовый класс MarkupExtension можно сделать гораздо больше интересных вещей. Рекомендую для этого посмотреть примеры кода.
Предостерегу от возможного подводного камня. Если вы используете конструктор MarkupExtension(RelativeSource relativeSource), то в метод Convert в параметре value придёт контрол, к которому осуществляется привязка. С контролом вы можете делать всё, что угодно, но если будете хранить на него жёсткую ссылку, то может возникнуть ситуация с утечкой памяти (например, если расширение связано со статическим экземпляром класса, то будет удерживаться от сборки мусора часть интерфейса, даже в том случае, когда представление закрыто и не нужно). Поэтому используйте для подобных целей ленивые ссылки (WeakReferences).
**Разделяемые команды (shared commands)**
С командами в WinPhone дела обстоят не очень хорошо, их нужно реализовывать самому. Причём, тут тоже нужно быть осторожным, поскольку контрол подписывается на событие CanExecuteChanged, и если эту подписку неграмотно реализовать, то можно получить всё те же утечки памяти. Я и сам не обращал внимания на данный нюанс, но мне указал на него мой товарищ и отличный разработчик Юрий Калинов, за что хочу поблагодарить его. Почитать об этой проблеме можно [тут](http://stackoverflow.com/questions/12919288/icommand-binding-causing-ui-memory-leak-in-wpf-application).
То ли дело в WPF существует прекрасный механизм RoutedCommands и CommandBindings. В [предыдущей статье](http://habrahabr.ru/post/208326/) я рассказал, как его можно красиво использовать. А что если реализовать на WinPhone нечто подобное? Посвятив вечер этой задачей, я-таки достиг некоторово результата и реализовал концепцию разделяемых команд (shared commands). Они не маршрутизируются по визуальному дереву, но для задач приложения подходят как нельзя лучше. Сразу отсылаю читателя к примеру, чтобы увидеть их реализацию, здесь же расскажу, как ими пользоваться. Всё просто и удобно, во вью модели пишем как-то так
```
this[SharedCommands.Back].CanExecute += (sender, args) => args.CanExecute = TouchIndex > 0;
this[SharedCommands.Next].CanExecute += (sender, args) => args.CanExecute = TouchIndex < _toches.Count;
this[SharedCommands.Back].Executed += (sender, args) => TouchIndex--;
this[SharedCommands.Next].Executed += (sender, args) => TouchIndex++;
```
А на представлении примерно следующее
```
```
**Лямбда-выражения**
Нотифиация свойств вью-модели посредством лямбда-выражений это классика
```
public Tool Tool
{
get { return Get(() => Tool); }
set { Set(() => Tool, value); }
}
```
Ещё очень удобно перегрузить индексатор
```
this[() => Background].PropertyChanged += (sender, args) =>
{
Canvas.Children.Clear();
Canvas.Background = Background;
_toches.GetRange(0, TouchIndex).ForEach(Canvas.Children.Add);
};
```
Если у кого-то ещё остаются опасения насчёт скорости работы таких конструкций, то смею их развеять — всё работает быстро. Помню, однажды кто-то выложил на хабре дизассемблированные исходники клиентской версии скайпа для WinPhone, а затем эти исходники оперативно убрали, но я успел их скачать и подсмотреть, как там устроены вью-модели. Это не показатель, конечно, но как раз-таки в них применялись лямбда-выражения для нотификации свойств. Думаю, что скайп делали умные люди из Майкрасофт, поэтому некоторое доверие к ним есть. А исходники скайпа потом были удалены с компьютера ;)
**Рисование**
Мы подошли к самому интересному – рисованию. Как его лучше всего организовать с учётом мобильности платформы? На мой взгляд, проще и логичнее всего будет воспользоваться стандартными средствами, а именно использовать примитивы Canvas, Polyline и тому подобные. Почему рекомендую именно их, а не велосипед на основе, например, WritableBitmap, да потому что для рендеринга интерфейса используется графическое ядро либо SIMD инструкции процессора, но если мы будем делать рисование руками, то просто переложим нагрузку на обычные инструкции процессора, что снизит производительность и значительно усложнит разработку.
Суть механизма в следующем. У нас есть холст (`Canvas`), который отображается на интерфейсе, а любые прикосновения к нему мы интерпретируем как мазки определённой кистью. Для каждого мазка создаётся примитив, а затем он добавляется в коллекцию `Canvas.Children`. Но что если у нас будет тысяча таких мазков, отразится ли это на производительности? Да, отразится существенно, поэтому нужно хотя бы временами делать растеризацию изображения, то есть очищать `Canvas.Children` и устанавливать в Canvas.Background тот рисунок, который получился на данный момент. Выглядит это примерно так
```
var raster = new WriteableBitmap(Canvas, null);
Canvas.Background = new ImageBrush
{
AlignmentX = AlignmentX.Left,
AlignmentY = AlignmentY.Top,
Stretch = Stretch.None,
ImageSource = raster,
};
Canvas.Children.Clear();
```
Растеризация в примере происходит каждый раз перед добавлением нового примитива, но как же нам тогда организовать историю, ведь при растеризации она утрачивается? Здесь тоже ничего сложного – всего лишь сохраним изначальный Background холста, который был до начала рисования, и заведём коллекцию ``List _toches для хранения всех прикосновений. Когда нам нужно отмотать историю на определённый момент, мы просто восстанавливаем первоначальнвй фон у холста и переносим нужное число элементов из _toches` в `Canvas.Children`, при этом элементы не удаляются из коллекции `_toches`.
В приложении рисование реализовано двумя способами: на основе Polyline и свойства OpacityMask у Canvas. Второй способ мне подсказал талантливый программист Ярошевич Юрий, за что говорю ему спасибо.
Интерес представляет также логика работы стёрки (вода). Рассказывать о ней сейчас не буду, но самые пытливые могут сами изучить этот вопрос.
**Радуга**
Как и обещал, рассказываю о рисовании палитры цветов, которую можно применять для выбора кисти. Всё, что нам нужно, это радужная кисть.
```
```
Пожалуй, на этом всё – изучайте пример, в нём можно найти намного больше, чем я рассказал здесь. Для лучшего понимания кода рекомендую прочитать статью [MVVM: новый взгляд](http://habrahabr.ru/post/208326/). Программу я тестировал на эмуляторе, поэтому не гарантирую, что на реальных устройствах всё будет работать корректно, однако серьёзных трудностей возникнуть не должно.
Всем мир!
P.S. По непонятным для меня причинам довольно много людей минусуют статью. Если вы всё же решили поставить минус, то, пожалуйста, оставьте комментарий с описанием того, что не понравилось. Это поможет исправить ошибки и улучшить статью.` | https://habr.com/ru/post/210778/ | null | ru | null |
# Как реализовать загрузку изображений в список в отдельном потоке на Android
По просьбам трудящихся, статья о методе загрузки изображений в список в отдельном потоке на Android.
#### Задача:
Реализовать механизм загрузки изображений из Интернета и отображения их в списке. При этом загрузка изображений должна быть реализована в отдельном потоке, во избежания «зависания» UI приложения.
#### Реализация:
Для реализации поставленной задачи использованы стандартный виджет ListView и адаптер — ArrayAdapter. Для работы с изображениями создан helper-класс ImageManager, который имеет два метода downloadImage() и fetchImage(). Первый загружает изображений из Интернета. Второй — вызывает загрузку изображений в отдельном потоке и устанавливает результат в ImageView.
#### Пример испольования:
Реализацию поставленной задачи будем расматривать на примере моего проекта. И на его код я буду ссылаться в статье.
Исходники: [fileshare.in.ua/3053597](http://fileshare.in.ua/3053597)
APK: [fileshare.in.ua/3053596](http://fileshare.in.ua/3053596)
#### Описание реализации:
Давайте рассмотрим поподробнее каждый из методов ImageManager'а:
> `1. package com.rudenko.android.ListIconFetching;
> 2.
> 3. import java.io.BufferedInputStream;
> 4. import java.io.IOException;
> 5. import java.net.HttpURLConnection;
> 6. import java.net.MalformedURLException;
> 7. import java.net.URL;
> 8.
> 9. import android.graphics.Bitmap;
> 10. import android.graphics.BitmapFactory;
> 11. import android.os.Handler;
> 12. import android.os.Message;
> 13. import android.util.Log;
> 14. import android.widget.ImageView;
> 15.
> 16. public class ImageManager {
> 17. private final static String TAG = "ImageManager";
> 18.
> 19. /\*\* Private constructor prevents instantiation from other classes \*/
> 20. private ImageManager () {}
> 21.
> 22. public static void fetchImage(final String iUrl, final ImageView iView) {
> 23. if ( iUrl == null || iView == null )
> 24. return;
> 25.
> 26. final Handler handler = new Handler() {
> 27. @Override
> 28. public void handleMessage(Message message) {
> 29. final Bitmap image = (Bitmap) message.obj;
> 30. iView.setImageBitmap(image);
> 31. }
> 32. };
> 33.
> 34. final Thread thread = new Thread() {
> 35. @Override
> 36. public void run() {
> 37. final Bitmap image = downloadImage(iUrl);
> 38. if ( image != null ) {
> 39. Log.v(TAG, "Got image by URL: " + iUrl);
> 40. final Message message = handler.obtainMessage(1, image);
> 41. handler.sendMessage(message);
> 42. }
> 43. }
> 44. };
> 45. iView.setImageResource(R.drawable.icon);
> 46. thread.setPriority(3);
> 47. thread.start();
> 48. }
> 49.
> 50. public static Bitmap downloadImage(String iUrl) {
> 51. Bitmap bitmap = null;
> 52. HttpURLConnection conn = null;
> 53. BufferedInputStream buf\_stream = null;
> 54. try {
> 55. Log.v(TAG, "Starting loading image by URL: " + iUrl);
> 56. conn = (HttpURLConnection) new URL(iUrl).openConnection();
> 57. conn.setDoInput(true);
> 58. conn.setRequestProperty("Connection", "Keep-Alive");
> 59. conn.connect();
> 60. buf\_stream = new BufferedInputStream(conn.getInputStream(), 8192);
> 61. bitmap = BitmapFactory.decodeStream(buf\_stream);
> 62. buf\_stream.close();
> 63. conn.disconnect();
> 64. buf\_stream = null;
> 65. conn = null;
> 66. } catch (MalformedURLException ex) {
> 67. Log.e(TAG, "Url parsing was failed: " + iUrl);
> 68. } catch (IOException ex) {
> 69. Log.d(TAG, iUrl + " does not exists");
> 70. } catch (OutOfMemoryError e) {
> 71. Log.w(TAG, "Out of memory!!!");
> 72. return null;
> 73. } finally {
> 74. if ( buf\_stream != null )
> 75. try { buf\_stream.close(); } catch (IOException ex) {}
> 76. if ( conn != null )
> 77. conn.disconnect();
> 78. }
> 79. return bitmap;
> 80. }
> 81. }
> \* This source code was highlighted with Source Code Highlighter.`
##### Метод fetchImage():
`public static void fetchImage(final String iUrl, final ImageView iView);`
###### Входные параметры:
iUrl — URL к изображению для загрузки
iView — ссылка на виджет ImageView, которому будет назначено изображение после загрузки.
Оба параметра являются обязательными.
###### Результат:
Функция не возвращает ничего.
###### Краткое описание:
Функция создает поток для загрузки изображения. На время загрузки во входной ImageView устанавливается стандартное изображение. После завершения загрузки, изображение входного ImageView обновляется загруженным.
Несколько слов о потоке: в строке 46 происходит понижение приоритета потока. Это сделано для того, что бы данный поток не забирал ресурсы необходимые для корректной работы приложения.
##### Метод downloadImage():
`public static Bitmap downloadImage(String iUrl);`
###### Входные параметры:
iUrl — URL к изображению для загрузки
###### Результат:
Изображение загруженное из интернета, либо Null — если операция не была выполнена успешно.
###### Краткое описание:
В функции создается соединение с сервером, где находится изображение. Происходит получение входного потока, который далее передается в BitmapFactory для создания изображения.
##### Как использовать ImageManager:
Рассмотрим на примере к статье. В методе FetchImageAdapter.getView(), для подгрузки изображений в ImageView строки списка, используется следующая строка:
`ImageManager.fetchImage(android.image, holder.ib\_logo);`
где android.image — URL к изображению, а holder.ib\_logo — ImageView строки списка.
#### Заключение:
Данный механизм подходит для загрузки изображения из Интернета в параллельном потоке, для любого виджета ImageView Android. Т. е. данный механизм можно использовать не только для конкретно поставленной задачи.
P. S. пользуйтесь на здоровья. | https://habr.com/ru/post/78747/ | null | ru | null |
# Реализация union типов в Java
При разработке кода иногда нужно чтобы объект в определенный момент содержал значения одного типа или значения другого типа. Языки программирования, которые поддерживают концепцию объединений, позволяют в определенный момент сохранять текущее значение в одной области памяти.
Например, в языках С/С++ можно написать вот так.
```
union value {
int i;
float f;
};
union value v;
v.i = 5; /* v.f - undefined behaivor */
```
При этом если мы установили значение одному полю, то считывание значения другого поля будет будет иметь неопределеное поведения.
Для упрощения работы с union типамы в С++17 был добавлен класс std::variant.
```
std::variant v { 5 };
std::cout << "int value: " << std::get(v) << std::endl;
```
Язык Java не поддерживает union типы. Как альтернативу, можно реализовать дата-класс с двумя полями определенных типов с сеттерами и геттерами. Но хотелось чтобы значение сохранялось в одном поле, а не в двух.
Как известно типу Object можно сохранить значение одного типа, а потом переприсвоить значения другого типа. И это можно использовать для реализации класса, наподобие к классу std::variant.
Поскольку в языке Java нельзя указать переменное число типов в дженерике, то для определенного количества типов нужна специализация класса(Union2, Union3 и тд.). Напишим основной класс Union и базовые его операции.
```
public abstract class Union {
private Union() {}
public abstract void set(T value);
public abstract T get(Class clazz);
public abstract boolean isActive(Class clazz);
public abstract Class getActive();
}
```
Для создания объектов класса будем использовать фабричные методы. В зависимости от количества типов будет возращаться конкретная специализация класса.
```
public static Union2 of(Class firstClass, Class secondClass) {
return new Union2<>(firstClass, secondClass);
}
public static Union3 of(Class firstClass, Class secondClass, Class thirdClass) {
return new Union3<>(firstClass, secondClass, thirdClass);
}
```
Конкретная специализация union класса будет сохранять определенное количество типов и одно поле Object. В случае если мы указывает не корректный тип, то получим ошибку.
```
private static class Union2 extends Union {
private final Class firstClass;
private final Class secondClass;
private Object value;
private Union2(Class firstClass, Class secondClass) {
this.firstClass = firstClass;
this.secondClass = secondClass;
}
@Override
public void set(T value) {
if (value.getClass() == firstClass || value.getClass() == secondClass) {
this.value = value;
} else {
throw new UnionException("Incorrect type: " + value.getClass().getName() +
"\n" + "Union two types: [" + firstClass.getName() + ", " +
secondClass.getName() + "]");
}
}
@Override
public T get(Class clazz) {
if (clazz == firstClass || clazz == secondClass) {
return (T) value;
} else {
throw new UnionException("Incorrect type: " + value.getClass().getName() +
"\n" + "Union two types: [" + firstClass.getName() + ", " +
secondClass.getName() + "]");
}
}
@Override
public boolean isActive(Class clazz) {
return value.getClass() == clazz;
}
@Override
public Class getActive() {
return (Class) value.getClass();
}
}
private static class Union3 extends Union {
private final Class firstClass;
private final Class secondClass;
private final Class thirdClass;
private Object value;
private Union3(Class firstClass, Class secondClass, Class thirdClass) {
this.firstClass = firstClass;
this.secondClass = secondClass;
this.thirdClass = thirdClass;
}
@Override
public void set(T value) {
if (value.getClass() == firstClass || value.getClass() == secondClass ||
value.getClass() == thirdClass) {
this.value = value;
} else {
throw new UnionException("Incorrect type: " + value.getClass().getName() +
"\n" + "Union three types: [" + firstClass.getName() + ", " +
secondClass.getName() + ", " + thirdClass.getName() + "]");
}
}
@Override
public T get(Class clazz) {
if (clazz == firstClass || clazz == secondClass ||
value.getClass() == thirdClass) {
return (T) value;
} else {
throw new UnionException("Incorrect type: " + value.getClass().getName() +
"\n" + "Union three types: [" + firstClass.getName() + ", " +
secondClass.getName() + ", " + thirdClass.getName() + "]");
}
}
@Override
public boolean isActive(Class clazz) {
return value.getClass() == clazz;
}
@Override
public Class getActive() {
return (Class) value.getClass();
}
}
```
А теперь посмотрим на примере как можно использовать этот класс. Как можно заметить не работает с конкретными специализации Union, что делает код проще.
```
Union triUnion = Union.of(Integer.class, String.class, Float.class);
triUnion.set(15f);
assertEquals(triUnion.getActive(), Float.class);
assertTrue(triUnion.isActive(Float.class));
triUnion.set("Dot");
assertEquals(triUnion.getActive(), String.class);
assertTrue(triUnion.isActive(String.class));
triUnion.set(10);
assertEquals(triUnion.getActive(), Integer.class);
assertTrue(triUnion.isActive(Integer.class));
```
Также для проверки текущего значения можно написать простой визитер.
```
Union biUnion = Union.of(Integer.class, String.class);
biUnion.set("Line");
Union triUnion = Union.of(Integer.class, String.class, Float.class);
triUnion.set(15f);
matches(biUnion,
Integer.class, i -> System.out.println("bi-union number: " + i),
String.class, s -> System.out.println("bi-union string: " + s)
);
matches(triUnion,
Integer.class, i -> System.out.println("tri-union int: " + i),
String.class, s -> System.out.println("tri-union string: " + s),
Float.class, f -> System.out.println("tri-union float: " + f)
);
```
```
public static void matches(V value,
Class firstClazz, Consumer firstConsumer,
Class secondClazz, Consumer secondConsumer) {
Class valueClass = value.getClass();
if (firstClazz == valueClass) {
firstConsumer.accept((T1) value);
} else if (secondClazz == valueClass) {
secondConsumer.accept((T2) value);
}
}
public static void matches(Union value,
Class firstClazz, Purchaser firstConsumer,
Class secondClazz, Purchaser secondConsumer,
Class thirdClazz, Purchaser thirdConsumer) {
Class valueClass = value.getActive();
if (firstClazz == valueClass) {
firstConsumer.obtain(value.get(firstClazz));
} else if (secondClazz == valueClass) {
secondConsumer.obtain(value.get(secondClazz));
} else if (thirdClazz == valueClass) {
thirdConsumer.obtain(value.get(thirdClazz));
}
}
```
Подводя итоги, можно сказать что в языке Java можно реализовать на уровне библиотеки поддержку union типов. Но как недостаток, для каждого количества типов нужна своя специализиация union класса и дополнительно сохранять все типы.
Полный исходной код класса можно посмотреть на github: [code](https://github.com/klappdev/jpml/blob/master/src/org/kl/util/Union.java) | https://habr.com/ru/post/465097/ | null | ru | null |
# Многозначное шифрование с использованием хеш-функций
В последнее время приходится все больше задумываться о сохранности анонимности и безопасности относительно прав на информационную собственность. В этой заметке я предложу довольно интересное решение относительно шифрования, позволяющего сохранить несколько различных объектов в одном контейнере с разными мастер-ключами, и гарантирующее отсутствие «следов» других сущностей при получении какой-либо одной. Более того, в силу конструктивных особенностей алгоритма — даже наличие расшифрованной сущности можно всегда списать на «случайность» (то есть, нет никаких средств проверить, были ли изначально зашифрованы эти данные или нет). Кроме того, алгоритм имеет чрезвычайную стойкость к атакам «подбора ключа». Правда у метода есть и существенный недостаток — катастрофически низкая скорость работы, но в ряде особенных случаев он все равно может быть полезен.
Ядро метода — математический объект под названием [хеш-функция](http://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%85%D0%B5%D1%88-%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F). В качестве небольшого ликбеза рекомендую изучить также и мою [предыдущую заметку](http://habrahabr.ru/post/82941/).
Существует ряд довольно занятных заблуждений о хеш-функциях:
* Хеш-функцию легко обратить. Якобы существует некая программа md5decrypt, которая восстанавливает результат md5crypt;
* Хеш-функции вроде MD5 уже давно сломаны, т.к. получить коллизию на заданную строку — плевое дело;
* Хеш-функции являются алгоритмом шифрования.
Все это — очевидно ерунда. Криптографические хеш-функции по определению сложны для обращения, и для используемых ныне методов (MD5, SHA) никто обратного не доказал. Коллизии мы научились строить только в самом общем виде, генерируя разные строки s1, s2, такие что f(s1) = f(s2). А шифрованием хеширование не является, хотя бы потому, что отсутствует понятие ключей шифрования.
Но иногда «ерунда» может помочь сконструировать интересное решение, попробуем на секунду представить, что вышеизложенные тезисы справедливы. Даже не так, построим объект, для которого они будут выполняться.
Пусть R(key, message) = первые N бит md5(key + message), где N — не очень велико, скажем равно 40. И тут начинается интересное!
Во-первых, при заданном ключе key, мы без труда можем строить большое количество разных сообщений, дающих нужное значение функции. Перебрать порядка 2^40 различных строк — задача посильная обычному «домашнему» компьютеру. Если мы имеем заданное значение X, которое является результатом применения функции R мы без труда найдем и прообраз.
То есть, пусть X = R('test\_key', 'msg') = 5B7AF38712
Забываем про сообщение 'msg', имеем только хеш-значение 5B7AF38712 и исходный ключ 'test\_key', запускаем перебор, и через некоторое время получаем строку 'msg' в качестве прообраза!
Но что, если мы не знаем и ключа ('test\_key') а знаем только хеш-значение? Тогда мы можем построить *бесконечное* количество пар ключ-сообщение, дающие наше значение X.
Некоторые из этих пар даже будут выглядеть осмысленно, что бы это ни значило. Более того, одной из таких пар будет главный вопрос жизни вселенной и всего такого (в некоторой формулировке) и [ответ на него](http://ru.wikipedia.org/wiki/%D0%9E%D1%82%D0%B2%D0%B5%D1%82_%D0%BD%D0%B0_%D0%B3%D0%BB%D0%B0%D0%B2%D0%BD%D1%8B%D0%B9_%D0%B2%D0%BE%D0%BF%D1%80%D0%BE%D1%81_%D0%B6%D0%B8%D0%B7%D0%BD%D0%B8,_%D0%B2%D1%81%D0%B5%D0%BB%D0%B5%D0%BD%D0%BD%D0%BE%D0%B9_%D0%B8_%D0%B2%D1%81%D0%B5%D0%B3%D0%BE_%D1%82%D0%B0%D0%BA%D0%BE%D0%B3%D0%BE).
Почему так? Просто потому, что множество входных значений (то есть ключей и сообщений) бесконечно, а функция R обладает конечным количеством возможных значений, каждое из которых (очень грубо говоря) имеет равные шансы на появление.
Теперь, думаю, идея процесса понятна — отправляя человеку '5B7AF38712', он, зная ключ ('test\_key'), быстрее всего получит сообщение ('msg') (но пока нет гарантий этого, нужно заметить). А, не зная, — любой мусор.
#### Магия
Теперь мы хотим научиться кодировать сообщения так, чтобы адресат смог расшифровать их правильно с определенными гарантиями. А еще, мы довольно хитры, и хотим чтобы та же посылка могла быть расшифрована с другим ключом как другое заданное сообщение.
То есть, на входе: key1, message1 и key2, message2.
Причем crypt(key1,message1,key2,message2) = X,
и decrypt(X,key1) = message1, а decrypt(X,key2) = message2.
Здесь нам придется «модернизировать» функцию R, мы построим целый набор функций:
Rm(key,msg) = первые N бит md5(key + строка(m) + msg),
где строка(m) — любое однозначное представление числа m как строки (например десятичная запись).
Индекс m — специальное «контрольное значение», которое мы будем варьировать при шифровании сообщений (то есть, оно выбирается нашим алгоритмом).
Прежде чем рассказать, как оно выбирается, я предложу процедуру расшифровки, благо она довольно проста:
decrypt(X,key) = значение msg, такое, что R(key,msg) == X, при наименьшем m.
В итеративной форме можно записать так (псевдокод):
```
string decrypt(X, key)
{
for (int m = 0; m < MAX_INT; m++)
for (string msg in generate_all_strings(MAX_STRING_LENGTH) )
if (first_N_bytes( md5( key + m.ToString() + msg) ) == X) // R()
return msg;
}
```
Здесь появляется новый параметр *MAX\_STRING\_LENGTH*, отвечающий за максимальную длину строки, которую мы можем получить перебором. Его имеет смысл ограничивать адекватной производительностью перебора, например, если исходное сообщение было 'hello, Habrahabr', то непосредственно строки для шифрования придется разбить на более короткие последовательности, например 'hell', 'o, H', 'abra', 'habr' и к каждой из них примерить функцию encrypt, не забывая, про [альтернацию ключа](http://en.wikipedia.org/wiki/Key_derivation_function).
Коллизию для первых 40 бит получить несложно, и эта функция гарантированно вернет какое-либо значение. Задача функции «шифрования» обеспечить возврат нужного значения.
Но ведь это тоже можно сделать перебором:
```
string encrypt(key, msg)
{
for (int m = 0; m < MAX_INT; m++)
{
string X = first_N_bytes( md5( key + m.ToString() + msg) ); // R()
if (decrypt(X, key) == msg)
return X;
}
}
```
Таким образом, мы обеспечиваем уверенность в верной расшифровке ее моделированием с различными параметрами. Если алгоритм расшифровки не меняется, то это гарантия корректности, и заметьте — никаких контрольных сумм, валидаторов, прочих вещей, позволяющих «выдать» факт правильной расшифровки!
Изначально я говорил про возможность шифрования сразу двух сообщений, что по сути сейчас становится самоочевидным фактом:
```
string encrypt(key, msg, key2, msg2)
{
for (int m = 0; m < MAX_INT; m++)
{
string X = first_N_bytes( md5( key + m.ToString() + msg) ); // R()
if (decrypt(X, key) == msg && decrypt(X, key2) == msg2)
return X;
}
}
```
Однако здесь есть есть некоторые подводные камни — при фиксированном диапазоне «контрольных значений» (m) — такой функции Rm может не существовать, и придется расширять диапазон. А расширение диапазона снижает скорость алгоритма. В общем случае диапазон для значения m должен быть больше, чем разрядность хеш-функции R, так что мы можем просто ее уменьшить (что я и сделал в тестовом прототипе). Но при сильно уменьшенном диапазоне выходных значений таких m тоже может просто не существовать.
В целом при реализации прототипа я остановился на двухбайтном усечении. Кроме того, для частичного решения вопроса производительности (я быстро набросал прототип на C#, а «местные» провайдеры криптографии просто ужасно медлительны! Практически в 50000 раз медленнее, чем реализация на GPU, которую я постараюсь выполнить чуть позже) я оставил возможность использовать только буквы диапазона a-z. В таком «печальном» виде это уже работает. Вводим две пары ключ-значение, жмем «Encrypt2» и получаем через некоторое время хеш-код. С первым ключом он быстро расшифровывается в первое сообщение:
Со вторым, соответственно, во второе:
Заметьте, все тот же encrypted text. Ну а с неправильным ключом — в странное сообщение (но где гарантии, что не оно было исходным?):
Скачать прототип можно отсюда: [dl.dropbox.com/u/243445/md5h/HashCode.7z](https://dl.dropbox.com/u/243445/md5h/HashCode.7z)
В нем довольно много нелепых ограничений, но для возмущенных, напомню, что это просто иллюстрация идеи. А над хорошим приложением при условии актуальности идеи можно будет и подумать. | https://habr.com/ru/post/147857/ | null | ru | null |
# Solidity: комментарии
Комментарии используются для того, чтобы объяснить что делает код. [Роберт С. Мартин](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%80%D1%82%D0%B8%D0%BD,_%D0%A0%D0%BE%D0%B1%D0%B5%D1%80%D1%82_(%D0%B8%D0%BD%D0%B6%D0%B5%D0%BD%D0%B5%D1%80)) ("дядюшка" Боб) утверждает, что «правильное использование комментариев должно компенсировать нашу неспособность выразить что-то в коде». Поэтому комментарии делают исходный код более понятным для человека.
Почему комментарии так важны, когда дело доходит до Solidity? Потому что они помогают разобраться в работе вашего смарт контракта не только разработчикам, но и конечным пользователям.
Как писать комментарии в Solidity?
----------------------------------
Для того, чтобы написать однострочный комментарий, можно использовать `//`
```
// This is a single line comment
```
Для многострочных используется `/*` в комбинации с `*/`
```
/*
This is a
multi-line comment
*/
```
Документация Solidity [гласит](https://docs.soliditylang.org/en/v0.8.11/layout-of-source-files.html):
> Однострочный комментарий завершается любым знаком конца строки Unicode (LF, VF, FF, CR, NEL, LS или PS) в кодировке utf-8. Знак конца строки по-прежнему является частью кода, который идет после комментария. Поэтому, если он не является символом ascii (т.е. NEL, LS и PS), это приведет к ошибке парсера.
>
>
Разные типы комментариев в Solidity
-----------------------------------
В Solidity есть два основных типа комментариев: обычные и комментарии *NatSpec*. Так, например, в Remix IDE их можно узнать по разным цветам (зеленый используется для обычных комментариев, а синий для комментариев *NatSpec*).
Что такое комментарии NatSpec?
------------------------------
Контракты Solidity имеют специальную форму комментариев, которые составляют основу формата спецификации естественного языка Ethereum([Ethereum Natural Language Specification Format](https://github.com/ethereum/wiki/wiki/Ethereum-Natural-Specification-Format)), также известного как *NatSpec*. *NatSpec* разрабатывается и распространяется командой Ethereum.
Формат комментариев *NatSpec* соответствует стилю нотации [Doxygen](https://www.doxygen.nl/manual/docblocks.html):
* Для однострочных комментариев используется `///`
* Для многострочных комментариев используется `/**` в сочетании с `*/`
* Комментарии используется перед объявлением `function`, `contract`, `library`, interface, `function` и `constructor`
```
/// This is a Natspec single line comment
/**
This is a
Natspec multi-line
comment block
*/
```
> **Важно!** Комментарии NatSpec неприменимы для переменных. Даже, если они объявлены публично и, следовательно, влияют на ABI. [Подробности](https://github.com/ethereum/solidity/issues/3418)
>
>
Использование тегов Doxygen вместе с NatSpec
--------------------------------------------
Для максимальной пользы, в работе с *NatSpec* стоит использовать теги Doxygen.
> **Doxygen** — [генератор документации](https://en.wikipedia.org/wiki/Documentation_generator) программного обеспечения. Документация создается с помощью анализа комментариев в коде.
>
>
Фрагмент кода ниже (из [документации](https://solidity.readthedocs.io/en/v0.5.7/layout-of-source-files.html#comments) Solidity) показывает, как используются эти теги. Теги Doxygen начинаются с @ и используются для того, чтобы, например, объяснить:
1. Заголовок контракта(в более понятном для человека виде)
2. Что делает функция `rectangle`
3. За что отвечают параметры `w` и `h`(ширина и высота прямоугольника)
4. Что вернет функция: `s`(площадь) и `p`(периметр)
```
pragma solidity >=0.4.0 <0.7.0;
/** @title Shape calculator. */
contract ShapeCalculator {
/** @dev Calculates a rectangle's surface and perimeter.
* @param w Width of the rectangle.
* @param h Height of the rectangle.
* @return s The calculated surface.
* @return p The calculated perimeter.
*/
function rectangle(uint w, uint h) public pure returns (uint s, uint p) {
s = w * h;
p = 2 * (w + h);
}
}
```
Вы можете использовать Doxygen с комментариями *NatSpec* в качестве инструмента для создания документации. Однако имейте в виду, что в Solidity доступны только 6 тегов Doxygen:
Все эти теги опциональны, но их использование имеет следующие преимущества:
* Позволяет документировать функции, конструкторы, контракты, библиотеки и интерфейсы
* [Предоставляют](https://docs.soliditylang.org/en/v0.5.8/metadata.html#usage-for-automatic-interface-generation-and-natspec) данные для пользовательского интерфейса (отображают текст подтверждения, который показывается пользователям, когда они пытаются вызвать функцию).
> *Примечание*: В настоящее время NatSpec интерпретирует теги только в том случае, если они применены к **external** или **public** значениям. Вы по-прежнему можете использовать их для своих internal и private функций, но они не будут анализироваться.
>
>
Важно помнить про два основных тега:
* `@notice`: информация о том, что делает функция, которая показывается пользователю во время исполнения
* `@dev`: документация для разработчиков
Если не используются никакие теги(например, используется только `///`), то все сообщение применяется с тегом `@notice`
Тег `@notice`, пожалуй, является самым главным тегом в *NatSpec*. Он предназначен для тех, кто никогда не видел исходный код. Поэтому следует избегать информации о деталях реализации кода.
Вот еще один пример использования тегов Doxygen в смарт-контракте *SimpleStorage* из [документации Solidity](https://docs.soliditylang.org/en/v0.5.7/introduction-to-smart-contracts.html#a-simple-smart-contract):
```
pragma solidity >=0.4.0 <0.7.0;
/// @author The Solidity Team
/// @title A simple storage example
contract SimpleStorage {
uint storedData;
/// Store `x`.
/// @param x the new value to store
/// @dev stores the number in the state variable `storedData`
function set(uint x) public {
storedData = x;
}
/// Return the stored value.
/// @dev retrieves the value of the state variable `storedData`
/// @return the stored value
function get() public view returns (uint) {
return storedData;
}
}
```
Теги `@param` и `@return` имеют следующую спецификацию:
* После `@param` должно идти имя переменной, которая использовалась в функции
* После `@return` должно идти имя или тип переменной, которую возвращает функция
Если ваша функция возвращает несколько значений, то следует использовать `@return` для каждого значения отдельно(аналогично с `@param`).
Хорошим примером контракта Solidity, который элегантно использует комментарии NatSpec с Doxygen, является библиотека [Buffer от Oraclize](https://github.com/provable-things/ethereum-api/blob/ff29c6771a589b148ef01c0634b707e54793e7f6/oraclizeAPI_0.4.25.sol#L115-L121) (созданная и используемая ими для своего API). Вы можете увидеть, насколько хорошо задокументированы функции `append` и `appendInt` с помощью тега `@dev`, который точно объясняет, что именно делает каждая функция. Наконец, теги `@param` и `@return` помогают понять, как ведет себя функция.
Создание документации с NatSpec: введение
-----------------------------------------
> Компилятор Solidity автоматически создает файл JSON(метаданные контракта), который содержит информацию о скомпилированном контракте. Вы можете использовать этот файл для запроса версии компилятора, используемых источников, документации ABI и NatSpec для более безопасного взаимодействия с контрактом и проверки его исходного кода. [Подробнее](https://docs.soliditylang.org/en/v0.8.11/metadata.html#:~:text=The%20Solidity%20compiler%20automatically%20generates,and%20verify%20its%20source%20code.)
>
>
Другими словами, этот JSON файл включает версию компилятора, ABI, а также документацию *NatSpec*. Документация пользователя и разработчика *NatSpec* появится в конце файла метаданных, в разделе `output` (прямо под ABI):
```
{
version: "1",
language: "Solidity",.
compiler: {
...
},
sources:
{
...
},
settings:
{
...
},
output:
{
abi: [ ... ],
userdoc: [ ... ],
devdoc: [ ... ],
}
}
```
Компилятор Solidity `solc` может создать документацию двух типов (в формате JSON) после компиляции вашего смарт-контракта:
1. *Документация для разработчиков***:** `solc --devdoc my_contract.sol`
2. *Пользовательская документация:* `solc --userdoc my_contract.sol`
### Создание документации с NatSpec: подготовка
Теперь, давайте посмотрим как компилятор Solidity создает документацию нашего смарт-контракта. Для этого вам нужен компилятор `solc` ([инструкция по установке](https://geth.ethereum.org/docs/dapp/native-bindings)). После установки, откройте свой терминал и следуйте приведенным ниже инструкциям:
1. Создайте новую папку(например, NatSpec) и пройдите в нее: `$ mkdir Natspec && cd Natspec`
2. Создайте новый Solidity файл: `$ nano natspec.sol`
3. Вставьте код ниже:
```
pragma solidity ^0.5.0;
/// @title A Geometry triangle simulator
/// @author Jean Cavallera
/// @notice Use this contract for only the most basic simulation
/// @dev Contract under development to enable floating point
contract Geometry {
struct Triangle {
uint side_a;
uint side_b;
uint hypothenuse;
}
/// @notice Math function to calculate square root
/// @dev Not working with decimal numbers
/// @param x The number to calculate the square root of
/// @return y The square root of x
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
/// @notice Calculate the hypothenuse length based on x and y
/// @dev Not working as it returns integers and not float
/// @param _a Side 1
/// @param _b Side 2
/// @return uint the hypothenuse length
function calculateHypothenuse(uint _a, uint _b) public pure returns (uint) {
return sqrt((_a * _a) + (_b * _b));
}
Triangle public my_triangle;
/// @author Jean Cavallera
/// @notice Enter the two legs of your right angle triangle
/// @dev This function modifies the state of the variable `my_triangle` and use `calculateHypothenuse()` function
/// @param _a Side 1
/// @param _b Side 2
/// @return string return to user a custom success message
function createTriangle(uint _a, uint _b) public returns (string memory) {
my_triangle = Triangle ({
side_a: _a,
side_b: _b,
hypothenuse: calculateHypothenuse(_a, _b)
});
return "new triangle created";
}
}
```
#### Создание документации с NatSpec: документация разработчика
Введите следующую команду:
```
solc — devdoc natspec.sol
```
У вас должно получиться что-то такое:
```
{
"author" : "Jean Cavallera",
"details" : "All function calls are currently implemented without side effects",
"methods" :
{
"calculateHypothenuse(uint256,uint256)" :
{
"details" : "Not working as it returns integers and not float",
"params" :
{
"_a" : "Side 1",
"_b" : "Side 2"
},
"return" : "uint the hypothenuse length"
},
"createTriangle(uint256,uint256)" :
{
"author" : "Jean Cavallera",
"details" : "This function modifies the state of the variable `my_triangle` and use `calculateHypothenuse()` function",
"params" :
{
"_a" : "Side 1",
"_b" : "Side 2"
},
"return" : "string return to user a custom success message"
}
},
"title" : "A Geometry triangle simulator"
}
```
Давайте более подробно посмотрим на этот файл:
* ключи представляют собой Doxygen теги, которые мы использовали до этого: `@title`, `@autor`, `@param` и `@return` . Единственная разница заключается в значении ключа details, которые берется из тега `@dev`.
* значения ключей соответствуют описанию тегов из NetSpec комментариев.
Есть еще две важные вещи, которые касаются раздела *devdoc* в ABI:
* функция включает типы передаваемых аргументов(пример: `"createTriangle(uint256,uint256)"`)
* показываются только public функции. Так, например, private функция `sqrt(uint x)` отсутствует в итоговом файле.
> NatSpec формирует документацию только для **public** и **external** функций
>
>
Мы упоминали об этом ранее. Вот что указано в документации Solidity:
> ([документация Solidity](https://github.com/ethereum/solidity/blob/develop/docs/natspec-format.rst)): NatSpec в настоящее время интерпретирует теги только в том случае, если они применяются к **external** или **public** функциям. Вы по-прежнему можете использовать аналогичные комментарии для своих internal и private функций, но они не будут анализироваться.
>
>
#### Создание документации с NatSpec: пользовательская документация
Выполните следующую команду:
```
solc --userdoc natspec.sol
```
Вы должны получить что-то такое:
```
{
"methods" :
{
"calculateHypothenuse(uint256,uint256)" :
{
"notice" : "Calculate the hypothenuse length based on x and y"
},
"createTriangle(uint256,uint256)" :
{
"notice" : "Create a new right angle triangle using two right angle sides and calculate the hypothenuse dynamically"
}
},
"notice" : "Use this contract for only the most basic simulation"
}
```
Как мы видим, у нас все еще есть имя функции с ее параметрами, а также тег `@notice` как для контрактов, так и для функций.
Пример: документация разработчика в Remix
-----------------------------------------
Использовать Doxygen теги особенно удобно, если вы работаете с Remix.
Новая версия Remix содержит плагины, расширяющие его основную функциональность. Очень полезной функцией является "Documentation File Generator in Markdown". Она создает генерацию контракта в формате Markdown на основе NetSpec комментариев.
1. Откройте Remix. Кликните по кнопке "*Plugin Manager".*
2. Найдите "*Solidity Documentation Generator"* и активируйте плагин.
3. Новая иконка появится в левой части интерфейса. Нажмите на нее и выберите контракт, для которого вы хотите создать документацию.
Плагин сгенерирует документацию в формате Markdown. Это выглядит примерно так:
Пример: пользовательская документация для отображения сообщения в UI
--------------------------------------------------------------------
Кошелек может использовать пользовательскую документацию *NatSpec* для отображения подтверждающего сообщения пользователю всякий раз, когда он взаимодействует с контрактом, вместе с запросом авторизации для подписи транзакции.
Пример: динамические сообщения
------------------------------
```
/// @notice Send `(valueInmGAV / 1000).fixed(0,3)` GAV from the account of
/// `message.caller.address()` to an account accessible only by `to.address()`
function send(address to, uint256 valueInmGAV) {
...
}
```
Если пользователь (например, с адрессом `0x2334`) попытается вызвать эту функцию с `to = 0x0` и `valueInmGAV=4.135`, то он увидит:
> *Send 4.135 GAV from the account of 0.2334 to an account accessible only by 0x0*
>
>
Код, заключенный в обратные кавычки, будет выполняться в среде EVM Javascript, которая имеет доступ к `message` и всем параметрам функциии. Поэтому вы можете использовать любое выражение `Javascript/Paperscript` для создания кастомных сообщений.
Atom плагин для авто-генерации NatSpec комментариев
---------------------------------------------------
[NodeFactory.io](http://NodeFactory.io) разработали Atom плагин — [solidity-comments](https://atom.io/packages/solidity-comments). Он содержит базовые функции для создания всей шаблонной документации для вашего смарт-контракта Solidity. Его можно использовать с помощью нажатия следующей комбинации клавиш: `Ctrl + Alt + G`.
Например, допустим у вас есть такой код:
```
pragma solidity 0.4.24;
contract SomeContract {
function test(uint _param1, uint _param2) external {
require(_param1 == 1 && _param2 == 2);
}
}
```
Нажмите `Ctrl + Alt + G` и вы получите:
```
pragma solidity 0.4.24;
/// @title SomeContract
/// @notice
/// @dev
contract SomeContract {
/// @notice
/// @dev
/// @param _param1
/// @param _param2
/// @return
function test(uint _param1, uint _param2) external {
require(_param1 == 1 && _param2 == 2);
}
}
```
Осталось только заполнить пустые теги.
Ссылки
------
1. [Разница между /\* и /\*\*](https://ethereum.stackexchange.com/questions/42316/difference-between-and-commenting-contracts)
2. [Ethereum Wiki](https://github.com/ethereum/wiki/wiki/Ethereum-Natural-Specification-Format) | https://habr.com/ru/post/655403/ | null | ru | null |
# Cloud-based WebRTC streaming on DigitalOcean
Popular cloud hosting DigitalOcean has recently launched its new marketplace selling preconfigured images that can help to quickly deploy an application server. It’s much like AWS, but DO is for those already using this provider’s services. Let’s see how to deploy a simple server for WebRTC streaming with a DO account for a $10/month fee based on Flashphoner WebCallServer and how such a server can be of use.
Deployment
----------
Enter the DO account, choose the Flashphoner WebCallServer image in Marketplace and press "Create Flashphoner Web Call Server Droplet".
Choose the server performance and the pricing plan. DO will automatically offer a mid-segment product, but we are interested in the minimum price.
Choose the datacenter location region, for example, Frankfurt.
Choose the authentication type, for example, one-time password.
Specify the number of servers (we are interested in one server for now) and name the server. This name will be registered among other locations in /etc/hostname.
Press "Create droplet"
As soon as the server is created, it will start automatically. Now we can connect to it through SSH, and modify the password if one-time password has been chosen as authentication method. A short description of Flashphoner WebCallServer with links to documentation will be displayed in the console.
"This Is a Test. Can You See Me?"
---------------------------------
By the time Flashphoner WebCallServer is started, it is in full ready-to-work mode, a 30-day trial license is activated automatically. Web interface is used to test the key functions. We will just check the publication and WebRTC stream playback.
Open in the browser the page <https://droplet_ip:8444/admin/>. The server is shipped with self-signed certificate by default; therefore we will need to confirm security exception. The certificates can be replaced later with your own. Enter the username and password (*demo* by default).
Choose the Two-Way Streaming example in the sidebar, press "Connect", then "Publish". To play the stream press "Play".
For a Handful of Dollars
------------------------
What can a $10/month server do as hardware platform for WebRTC streaming? Let’s see what Digital Ocean offers in terms of processor
```
lscpu
```
and memory
```
free -h
```
By running load tests on the server, we can see that the server performance capabilities are not so small.
As an example, we are going to publish one stream sample and see how many users will be able to publish this stream simultaneously not exceeding 90% of the processor resources:
| Resolution | Bitrate, Kbps | Number of publications | Number of viewers |
| --- | --- | --- | --- |
| 360p | 1300 | 1 | 70 |
| 480p | 1800 | 1 | 70 |
| 720p | 3000 | 1 | 50 |
With several simultaneous publications the maximum number of processed streams remains the same; when 7 streams are published, up to 10 viewers are able to subscribe to each.
Suppose we need to transcode the stream on the server in order to reduce the resolution or align the FPS. To do this, we are going to check the maximum number of publications:
| Resolution | Bitrate, Kbps | Number of streams |
| --- | --- | --- |
| 360p | 1300 | 5 |
| 480p | 1800 | 3 |
| 720p | 3000 | 2 |
In this manner, the server with the lowest price on DO with the parameters 1 CPU core, 2 Gb RAM, 2 TB traffic is suitable not only for testing WebRTC streaming but also for small projects. For example, it is possible to
* deliver a stream via WebRTC from an IP camera in order to ensure basic in-house video surveillance;
* organize a webinar for a small company staff;
* deploy your own internet-radio (audio streams require less processor resources).
Besides, this server can be viewed as reference platform for scaling estimation. This is what we will deal with further on.
"I Deserve More!"
-----------------
For the most part, the rules are quite simple: there’s no such thing as too many cores as well as too much memory. Depending on the intended number of users, DO configuration recommendations will be the following:
| Number of users | vCPUs | RAM, Gb | Traffic, TB | Use case |
| --- | --- | --- | --- | --- |
| up to 200 | 4 | 8 | 5 | Video surveillance system |
| up to 500 | 8 | 16 | 6 | Webinars |
| up to 1000 | 16 | 64 | 9 | Video chat |
| up to 2000 | 20 | 96 | 10 | HD video streaming |
If further increase in number of users is planned, we will need to deploy the CDN projecting 1 Edge server per 2000 users. Suppose we need to deliver an HD video, the intended number of viewers is 10000. In this case, 2 Origin servers for publishing and 5 Edge servers for viewing will be required.
Setup example:
* Origin 1
```
cdn_enabled=true
cdn_ip=origin1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=origin
```
* Origin 2
```
cdn_enabled=true
cdn_ip=origin2.flashponer.com
cdn_point_of_entry=origin1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=origin
```
* Edge 1 — Edge 5 (here we change only the server address in the `cdn_ip` parameter)
```
cdn_enabled=true
cdn_ip=edge1.flashphoner.com
cdn_point_of_entry=origin1.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=edge
```
CDN can also be of use if the users are geographically dispersed. For example, our target audiences are based in Europe and America.
Setup example:
* Origin EU
```
cdn_enabled=true
cdn_ip=origin_eu.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=origin
cdn_groups=EU
```
* Origin US
```
cdn_enabled=true
cdn_ip=origin_us.flashponer.com
cdn_point_of_entry=origin_eu.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=origin
cdn_groups=US
```
* Edge 1 EU
```
cdn_enabled=true
cdn_ip=edge1_eu.flashphoner.com
cdn_point_of_entry=origin_eu.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=edge
cdn_groups=EU
```
* Edge 1 US
```
cdn_enabled=true
cdn_ip=edge1_us.flashphoner.com
cdn_point_of_entry=origin_eu.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=edge
cdn_groups=US
```
The bigger the number of viewers is, the more diverse the devices for playback and the channels to these devices are. To provide good broadcast quality to various devices, it will most likely be needed to transcode the video, which can be imposed on special Transcoder servers.
Setup example:
* Origin
```
cdn_enabled=true
cdn_ip=origin.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=origin
cdn_groups=default
```
* Transcoder EU
```
cdn_enabled=true
cdn_ip=transcoder_eu.flashponer.com
cdn_point_of_entry=origin.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=transcoder
cdn_groups=EU
```
* Edge 1 EU
```
cdn_enabled=true
cdn_ip=edge1_eu.flashphoner.com
cdn_point_of_entry=origin.flashponer.com
cdn_nodes_resolve_ip=false
cdn_role=edge
cdn_groups=EU
```
As we have found during the test, the number of processor cores is essential for the purposes of transcoding. The most suitable configuration in CPU-optimized configuration line is the most expensive one — 32 vCPU, 64 Gb RAM. At the same time the prices for CPU configurations similar in quantity and with bigger memory in other lines can be significantly higher. Unfortunately, one does not get to save money on transcoders: as the video is encoded frame by frame, there has to be enough memory space for all the images and enough processors for processing all the streams.
During CDN deployment, the simultaneous creation of several servers with the same configuration will come in useful. However, in the case of geographically dispersed CDN same-type Edge and Transcoder servers will need to be hosted in different data centers.
Conclusion
----------
To conclude, we have deployed and tested a small server for low latency WebRTC video streaming on Digital Ocean and have found that a server with minimum configuration is a good fit not only for testing but also for small projects. We have obtained the scaling data depending on the intended number of viewers and have touched upon the subject of CDN deployment, which as such deserves to be discussed in a separate article. To be continued, please stay with us.
Related links
-------------
[Flashphoner WebCallServer image in DigitalOcean Marketplace](https://flashphoner.com/web-call-server-on-digital-ocean-marketplace) — image of Web Call Server in DigitalOcean.
[CDN for low latency WebRTC streaming](https://flashphoner.com/cdn-for-low-latency-webrtc-streaming) — Web Call Server-based content delivery network. | https://habr.com/ru/post/476554/ | null | en | null |
# Получить выписку ЕГРН из Росреестра с помощью python, минуя api
### Не первое знакомство с порталом Росреестра
Любой юрист когда-либо обращался с запросом в Росреестр (Федеральная служба государственной регистрации, кадастра и картографии). Времена, когда для запроса надо было бежать в отделение Росреестра и подавать запрос на бумаге уходят в прошлое. Росреестр запустил несколько онлайн сервисов, которые можно использовать не выходя из дома. К этим сервисам относится и запрос выписки из Единого государственного реестра недвижимости. Официальный [сайт](https://rosreestr.ru/site/) для начала работы.
Всем, кто уже успел поработать с сайтом, известно, что для получения выписки из ЕГРН, в которой будет содержаться информация не только об общих характеристиках объекта, но и о правообладателе данного объекта, необходимо зайти в личный кабинет Росреестра.
Возможно, это удобный способ получения одной или нескольких выписок. Однако, что делать, если необходим пакет выписок ЕГРН? Допустим, вы работаете с недвижимостью или владеете рядом объектов, общее число которых более 10. По общему правилу получать выписку из ЕГРН надо не реже 1 раза в год, чтобы успеть вовремя отреагировать в юридической плоскости на нежелательные изменения в Росреестре, если они возникнут помимо вашей воли.
Можно вручную подавать запросы через личный кабинет, а можно использовать api Росреестра. Первый вариант крайне утомителен. Помимо того, что сам онлайн сервис Росреестра работает весьма неторопливо с постоянными зависаниями, так еще обычному пользователю предлагается при подаче каждого запроса вводить целый арсенал полей по объекту. Вот, например, запрос по земельному участку:
То есть, чтобы узнать сведения об объекте и получить по нему выписку, физ. лицу надо уже знать все характеристики объекта! И каждый раз при запросе сведений необходимо заполнять все поля. Что сказать, очень неудобно. Спасибо, что хотя бы предусмотрели, что земельный участок может измеряться в квадратных миллиметрах.
Второй вариант получения выписок из ЕГРН – api Росреестра. Api — это набор программных инструкций, по которому ваша программная часть и часть Росреестра обмениваются сведениями без вашего участия. Удобная вещь, если все работает правильно. И можно было бы закончить.
Однако, если посмотреть на страницу, где Росреестр объясняет как внедрить удобное api, становится не по себе.
Документ с описанием размещен здесь — [rosreestr.ru/wps/portal/cc\_ib\_documents?documentId=1521](https://rosreestr.ru/wps/portal/cc_ib_documents?documentId=1521)
Занимает всего лишь 19 страниц, но написан техническим языком и говорит о том, что без цифровой подписи нам не обойтись. Вообщем, долго, непонятно и неудобно. Пойдем более коротким путем.
При работе с подвисающим сайтом Росреестра нам понадобится понимание такого инструмента Python как ожидания. Самый подходящий инструмент для работы с этим сайтом, по крайнем мере на текущем этапе развития данного сервиса Росреестра.
Когда страница медленно прогружается загружена в браузере, элементы на этой странице могут появляться с различными временными интервалами (или не появляться вообще). Это затрудняет поиск элементов, периодически возникает исключение ElementNotVisibleException или NoSuchElement. Используя ожидания, мы можем решить эту проблему.
Ожидание дает некий временной интервал между произведенными действиями — поиске элемента или любой другой операции с элементом.
Так как мы используем в работе модуль selenium, то будем работать с тем, что он предлагает. Selenium предоставляет два типа ожиданий — неявное (implicit) и явное (explicit).
Явное ожидание — это код, которым вы определяете, какое условие должно произойти для того, чтобы дальнейший код исполнился. Ранее мы использовали time.sleep(), которое устанавливает точное время ожидания. Но этот вариант не совсем удачен. Минус его в том, что, если не угадать со временем простоя (sleep) программа вылетит. Существуют более удобные методы, которые помогут написать код, ожидающий ровно столько, сколько необходимо.
### Пишем программу для работы с онлайн Росреестром
Перейдем к нашей программе.
Суть ее заключается в том, чтобы заходя на сайт Росреестра, она авторизовалась через личный кабинет физ. лица и далее начала самостоятельно подавать запросы на выписки из ЕГРН. Данные для запросов наша программа будет получить из файла Excel (куда же без него). Один нюанс. На сайте Росреестра при подаче запроса есть поле с адресом объекта. С ним возникнут сложности, так как адреса в Росреестр заведены особым способом. Придется это учесть в работе программы.
Приступим.
Перед началом работы подготовим таблицу excel с исходными данными в следующем формате:
Номер-наименование правообладателя-адрес объекта недвижимости- тип объекта- кадастровый номер- площадь. При запросе нам понадобятся все поля таблицы кроме «номер» и «наименование правообладателя».
Теперь создадим новый файл python – rosreestr.py. И импортируем необходимые модули:
```
import webbrowser,time
from selenium import webdriver
import csv
from selenium.webdriver.common.keys import Keys
from selenium.common.exceptions import NoSuchElementException
import openpyxl
```
Открываем файл excel c данными по объектам недвижимости:
```
wb = openpyxl.load_workbook('activ2.xlsx')
sheet=wb.get_active_sheet()
```
Заходим на сайт Росреестра. Так как уже сам вход на сайт может идти с задержками, надо поставить ожидание:
```
browser = webdriver.Firefox()
browser.get ('https://rosreestr.ru/')
time.sleep(5)
```
Здесь можно оставить просто time.sleep 5 секунд. Но лучше, используя ожидания, написать так:
```
browser.implicitly_wait(40)
```
Теперь нам надо дождаться появления кнопки зайти в личный кабинет и нажать на нее:
```
act = browser.find_element_by_css_selector('#top_panel > a:nth-child(4)')
act.click()
```
Так как регистрация в личном кабинете производится через портал Госуслуги, то сайт перебрасывает на Госуслуги и это происходит также с задержкой, учтем это:
```
browser.implicitly_wait(40)
act = browser.find_element_by_id('mobileOrEmail')
act.click()
```
Теперь программа за нас авторизуется на сайте Госуслуги, введя логин и пароль (вместо логина и пароля надо вписать свои данные):
```
i=0
for i in 'логин@mail.ru':
act.send_keys(i)
time.sleep (0.1)
act = browser.find_element_by_id('password')
act.click()
i=0
for i in 'пароль':
act.send_keys(i)
time.sleep (0.1)
act = browser.find_element_by_id('loginByPwdButton')
act.click()
```
После того, как программа нажала кнопку войти, перед авторизацией может возникнуть вот такое окно:
Здесь надо выбрать CSS-селектор физ. лица. Помните как это делать? Правой мыши на значке Частное лицо…- исследовать элемент:
И скопировать CSS-селектор:
Внесем его в нашу программу:
```
act = browser.find_element_by_css_selector('tr.not-border:nth-child(1) > td:nth-child(2) > div:nth-child(2)')
act.click()
```
Теперь, когда мы залогинились, браузер перекинет нас с сайта Госуслуги на сайт Росреестра. Там наша программа должна кликнуть по пункту «Запрос о предоставлении сведений об объектах недвижимости и(или) их правообладателях»:
Внесем соответствующий код:
```
act = browser.find_element_by_css_selector('div.services-item:nth-child(5) > div:nth-child(1) > span:nth-child(2)')
act.click()
act = browser.find_element_by_css_selector('div.services-item:nth-child(5) > table:nth-child(2) > tbody:nth-child(1) > tr:nth-child(2) > td:nth-child(2) > a:nth-child(1)')
act.click()
```
Мы попали на стартовую страницу подачи запроса, где от нас ждут прохождения 5 шагов:
Чтобы перейти на второй шаг, надо поставить галочку на странице и нажать далее. Обозначим это в коде:
```
act = browser.find_element_by_class_name('PGU-LabelIcon')
act.click()
act = browser.find_element_by_css_selector('#__nextStep')
act.click()
```
Мы на 2-м шаге сайта Росреестр. Здесь надо заполнить поле категория заявителя, все остальные данные подтягиваются из Госуслуги автоматически. Потом нажать «Далее»:
В коде это выглядит так:
```
act = browser.find_element_by_css_selector('#Form7\.step2\.specialDeclarantKind\.code > div:nth-child(2) > div:nth-child(1)')
act.click()
act = browser.find_element_by_css_selector('.opened > div:nth-child(3) > div:nth-child(1) > div:nth-child(2)')
act.click()
act = browser.find_element_by_css_selector('#__nextStep')
act.click()
```
Если мы запустим нашу программу, то, скорее всего, получим ошибку:
Обработаем данную ошибку так:
```
try:
act = browser.find_element_by_class_name('PGU-LabelIcon')
except:
browser.refresh()
time.sleep (40)
act = browser.find_element_by_class_name('PGU-LabelIcon')
```
Теперь, если возникнет ситуация, при которой страница не прогрузится, программа обновит браузер и заново попытается нажать на нужную иконку. К сожалению, здесь ожидания не работают, и приходится использовать старый, проверенный time.sleep().
Мы на третьем шаге и он самый трудоемкий:
Надо заполнить все поля со знаком «\*».
Начнем с ввода объекта:
```
n=1
i=sheet['B'+str(n)].value
#i=input("введите. 1-для земли.2-здание.3-помещение.4-сооружение.5-не завершенное: ")
if i=='Земельный участок':
#1-земля
act = browser.find_element_by_css_selector('#Form7\.step3\.objectsList\.panel1180\.objectTypeCode > div:nth-child(2) > div:nth-child(1)')
act.click()
act = browser.find_element_by_css_selector('.opened > div:nth-child(3) > div:nth-child(1) > div:nth-child(2)')
act.click()
#площадь объекта
act = browser.find_element_by_css_selector('#Form7\.step3\.objectsList\.panel1180\.area > div:nth-child(1) > div:nth-child(4) > div:nth-child(1) > div:nth-child(2) > input:nth-child(1)')
act.click()
for i in str(sheet['E'+str(n)].value):
act.send_keys(i)
time.sleep (0.1)
act = browser.find_element_by_css_selector('#Form7\.step3\.objectsList\.panel1180\.area\.unit > div:nth-child(2) > div:nth-child(1)')
act.click()
act = browser.find_element_by_css_selector('.opened > div:nth-child(3) > div:nth-child(1) > div:nth-child(2)')
act.click()
elif i=='Здание':
#2-здание
act = browser.find_element_by_css_selector('#Form7\.step3\.objectsList\.panel1180\.objectTypeCode > div:nth-child(2) > div:nth-child(1)')
act.click()
act = browser.find_element_by_css_selector('.opened > div:nth-child(3) > div:nth-child(1) > div:nth-child(3)')
act.click()
act = browser.find_element_by_css_selector('#Form7\.step3\.objectsList\.panel1180\.objectPurposeCode > div:nth-child(2) > div:nth-child(1)')
act.click()
act = browser.find_element_by_css_selector('.opened > div:nth-child(3) > div:nth-child(1) > div:nth-child(2)')
act.click()
elif i=='Помещение':
#3-помещение
act = browser.find_element_by_css_selector('#Form7\.step3\.objectsList\.panel1180\.objectTypeCode > div:nth-child(2) > div:nth-child(1)')
act.click()
act = browser.find_element_by_css_selector('.opened > div:nth-child(3) > div:nth-child(1) > div:nth-child(4)')
act.click()
act = browser.find_element_by_css_selector('#Form7\.step3\.objectsList\.panel1180\.roomPurposeCode > div:nth-child(2) > div:nth-child(1)')
act.click()
act = browser.find_element_by_css_selector('.opened > div:nth-child(3) > div:nth-child(1) > div:nth-child(3)')
act.click()
elif i=='Сооружение':
#4-сооружение
act = browser.find_element_by_css_selector('#Form7\.step3\.objectsList\.panel1180\.objectTypeCode > div:nth-child(2) > div:nth-child(1)')
act.click()
act = browser.find_element_by_css_selector('.opened > div:nth-child(3) > div:nth-child(1) > div:nth-child(5)')
act.click()
elif i=='Не завершенное':
#5-не завершенное
act = browser.find_element_by_css_selector('#Form7\.step3\.objectsList\.panel1180\.objectTypeCode > div:nth-child(2) > div:nth-child(1)')
act.click()
act = browser.find_element_by_css_selector('.opened > div:nth-child(3) > div:nth-child(1) > div:nth-child(6)')
act.click()
```
Здесь мы начинаем с ячейки в excel, где у нас написано наименование объекта. Если в ячейке например занесено «Земельный участок», то программа выбираем по css-селектором соответствующий пункт. Все также происходит с другими видами объектов в ячейке – программа их обрабатывает.
Далее программа нажимаем по css-селекторам кадастрового номера, вида выписки и адреса объектов, эти селекторы одинаковы для всех объектов:
```
#кадастровый номер - цикл по excel таблице
act = browser.find_element_by_css_selector('#Form7\.step3\.objectsList\.panel1180 > div:nth-child(1) > div:nth-child(4) > div:nth-child(6) > div:nth-child(2) > input:nth-child(1)')
act.click()
for i in sheet['C'+str(n)].value:
act.send_keys(i)
time.sleep (0.1)
time.sleep(2)
#вид выписки
act = browser.find_element_by_css_selector('#Form7\.step3\.extractDataRequestType1 > div:nth-child(2) > div:nth-child(1)')
act.click()
act = browser.find_element_by_css_selector('.opened > div:nth-child(3) > div:nth-child(1) > div:nth-child(2)')
act.click()
# адрес объекта
act = browser.find_element_by_css_selector('#Form7\.step3\.objectsList\.panel1180\.addressesList\[0\]\.address > div:nth-child(2) > div:nth-child(2) > a:nth-child(1) > span:nth-child(1)')
act.click()
act = browser.find_element_by_css_selector('.fias_input_search')
act.click()
```
Теперь надо вбить адрес:
```
for i in sheet['D'+str(n)].value:
act.send_keys(i)
time.sleep (0.1)
print(sheet['D'+str(n)].value)
i=input("нажмите eneter в интерпретаторе или поправьте адрес вручную на сайте и далее нажмите enter: ")
act = browser.find_element_by_css_selector('a.button-custom:nth-child(2)')
act.click()
```
Адрес берется из столбца С таблицы excel. Здесь сделана пауза в виде оживания действий пользователя. Это связано с тем, что адрес в Росреестре может отличаться от того, адреса, которым вы располагаете и скорее всего так и есть. Поэтому программа, внеся адрес из таблицы на сайт, будет ожидать, что пользователь нажмет enter в интерпретаторе, чтобы продолжить далее.
Оставшиеся шаги на портале Росреестра наименее примечательны, там программа просто кликает по кнопкам на портале «Далее» и отправляет запрос уже в Росреестр:
```
#кнопка Далее
act = browser.find_element_by_css_selector('#__nextStep > span:nth-child(1)')
act.click()
#страница с паспортными данными, поэтому просто кнопка Далее
act = browser.find_element_by_css_selector('#__nextStep > span:nth-child(1)')
act.click()
time.sleep (1)
#последняя страница, просто кнопка Далее
act = browser.find_element_by_css_selector('#__nextStep > span:nth-child(1)')
act.click()
```
В конце программы добавим обновление браузера:
```
browser.refresh()
time.sleep (2)
```
Если программа отработала корректно, то осталось только запустить цикл по всем ячейкам с объектами в нашем excel файле. Для этого с в начале блока перед `i=sheet['B'+str(n)].value` добавим:
```
while True:
if n<36:
```
а в конце: `n+=1`, где n-количество объектов недвижимости в таблице excel.
Полностью текст, программы можно будет посмотреть [здесь](https://yadi.sk/d/c9x8zz9KLybHOQ). | https://habr.com/ru/post/460040/ | null | ru | null |
# Кросс-вмный (CLR/JVM) код на Python
Это узкоспециализированная короткая заметка про то, как я запинывал write once, run everywhere тесты для библиотеки, портированной с C# на Java, при помощи Python.
Смысл в следующем: есть большая, толстая и красивая библиотека, которая была по коммерческим соображениям портирована с C# на Java. API осталось почти одинаковым, naming conventions естественно сменились при переходе на другой язык. Нам нужно было написать толстую пачку тестов, проверяющих, что клон библиотеки работает идентично оригиналу (тесты на регрессии, иными словами). Для этого сравнивались результаты работы кода библиотек (некие бинарники и xml-метаданные). Тесты были нетривиальные, их было много, и что самое неприятное — они постоянно дописывались с одного конца командой из четырех человек. Некоторое время я старательно портировал их на Java, затем плюнул и предложил команде писать тесты на языке, который сразу можно было бы выполнять на CLR (со старой библиотекой) и на JVM (с клоном). Оказалось, они и сами уже некоторое время думали про Python, и вот как это получилось.
##### 1. Basics
Ну, о примитивном. На CLR я код запускаю IronPython-ом, на JVM — Jython-ом соответственно. Из приятного — Jython сам предоставляет загружаемым Java-классам вместо геттеров-сеттеров механизм пропертей. Почему это приятно? Потому что при портировании на Java шарповые проперти естественно были заменены геттерами-сеттерами.
##### 2. Где я?
Полезно знать, поверх какого рантайма мы сейчас выполняемся. Тут все просто.
```
isDotNet = sys.version.find('IronPython') > -1
```
##### 3. Подключение нужных библиотек
В IronPython и Jython это делается по разному (с помощью библиотечки clr в IronPython, и просто добавлением в path в Jython), да и конвенция именования модулей разная, так что унифицируем:
```
def cpUseLibrary(lib_path, library):
if isDotNet:
sys.path.append(lib_path)
import clr
clr.AddReference('OurProduct20.' + library)
else:
sys.path.append(lib_path + '\\java_libs\\ourproduct20.' + library.lower() + '.jar')
```
Используется это в рабочем коде следующим тупым образом:
```
cpUseLibrary(path_to_bins, 'Core')
cpUseLibrary(path_to_bins, 'Formats.Common')
```
##### 4. Загрузка нужных классов.
Вот тут небольшая проблема. Вообще и тот, и другой интерпретаторы позволяют тупо делать import из нужных namespace-ов / пакаджей, но нам-то нужна динамическая конструкция, учитывая, опять же, разные конвенции именования пакетов.
```
def cpImport(module, clazz, globs = globals()):
# load class
mname = '';
if isDotNet:
mname = 'OurProduct.' + module
else:
mname = 'com.ourcompany.ourproduct.' + module.lower()
pckg = __import__(mname, globals(), locals(), [clazz], -1)
aliased_class = getattr(pckg, clazz)
globs[clazz] = aliased_class
```
Смысл в использовании \_\_import\_\_(), как питоновского внутреннего механизма импорта из модулей. Собственно, запись «import from откуда-то что-то» в \_\_import\_\_() в конечном итоге и разворачивается. Текущая проблема, которую не дошли пока руки решить — это необходимость передавать globals() каждый раз в такой импорт (из-за того, что все кроссплатформенные методы вынесены в отдельный модуль). Выглядит это следующим образом:
```
cpImport('Core', 'OurProductLicense', globals())
cpImport('Formats', 'OurProductCommonFormats', globals())
```
Не очень красиво, но опять же, работает унифицированно на обоих рантаймах.
##### 5. Решение проблемы конвенции именования
Разница в именовании методов очень простая: в C# они с заглавной начинаются, в Java — со строчной. Вот чем удобны современные скриптовые языки, так это возможностью метапрограммирования. Не лисп, наверное, но все равно. Руби тут был бы еще сподручнее, но и так неплохо. Дописываем cpImport():
```
aliased_class = getattr(pckg, clazz)
# add uppercased aliases for its lowercased methods (unless there's already an uppercased method with the same name)
original_methods = aliased_class.__dict__.copy()
for name, method in original_methods.iteritems():
if name[0:1] in string.uppercase:
continue
newname = name[0:1].upper() + name[1:]
if hasattr(aliased_class, newname):
continue
setattr(aliased_class, newname, method)
globs[clazz] = aliased_class
```
Смысл тут в использовании setattr() для прописывания алиаса на метод. Фактически, всем методам, начинающимся со строчной буквы, мы прямо в классе создаем алиас, начинающийся с заглавной.
Как это выглядит в целом. Файлик test.py:
```
from cptest import isDotNet, cpUseLibrary, cpImport
cpUseLibrary('Core')
cpUseLibrary('Formats.Common')
cpImport('Core', 'OurProductLicense', globals())
cpImport('Formats', 'OurProductCommonFormats', globals())
OurProductLicense.SetProductID(".NET Product ID" if isDotNet else "JavaProductID")
OurProductCommonFormats.Initialize();
```
Выполняется простым ipy test.py / jython test.py из одного скрипта без танцев с бубном. Что приятно.
##### P.S. Возможные проблемы
Ну, они довольно очевидны. Нам повезло, наши разработчики в процессе портирования достаточно скурпулезно придерживались одной конвенции именования и портирования имен. Поэтому библиотеки, методы и прочее, действительно просто вызывать так, как описано выше. Иначе пришлось бы составлять некую табличку исключений, и учитывать ее в методе cpImport(). Но в целом описанный подход мне очень понравился и выглядит живым решением такой вот редко, наверное, встречающейся проблемы. | https://habr.com/ru/post/148473/ | null | ru | null |
# Советы по работе с Gradle для Android-разработчиков
Всем привет! Я пишу приложения под Android, в мире которого система сборки Gradle является стандартом де-факто. Я решил поделиться некоторыми советами по работе с системой с теми, у кого нет чёткого понимания, как правильно структурировать свои проекты и писать build-скрипты.
Часто разработчики используют Gradle по наитию и не изучают целенаправленно, потому что не всегда хватает ресурсов на инфраструктурные задачи. А если возникают какие-либо проблемы, то просто копируют готовые куски build-скриптов из ответов на Stack Overflow. Во многом проблема кроется в сложности и чрезмерной гибкости Gradle, а также в отсутствии описания лучших практик в официальной документации.
Поработав больше пяти лет на аутсорсе, я видел много проектов разной сложности. И на всех этих проектах build-скрипты писались по-разному, где-то встречались не очень удачные решения. Я провел небольшую ретроспективу и резюмировал свой опыт в виде разных советов по использованию Gradle и рассказал их на одном из наших внутренних митапов. В статье я перевел эти советы в текст.
Небольшой оффтоп для тех, кому совсем ничего не понятно в Gradle-скриптах
=========================================================================
Я заметил, что в Android-сообществе встречаются люди, которые могут годами разрабатывать приложения, но при этом не понимать, как работает Gradle. И достаточно продолжительное время и я был одним из них. Но однажды всё же решил, что гораздо проще потратить время на системное изучение Gradle, чем постоянно натыкаться на непонятные проблемы.
А так как лучший способ изучить что-то — это попытаться рассказать об этом другим людям, то я подготовил [рассказ об основах использования Gradle в контексте Android-разработки](https://www.youtube.com/watch?v=WOBok2u-SL8) специально для тех, кто совсем не разбирается в теме. Так что, возможно, этот митап вам поможет.
*Теперь к советам.*
#1 Не редактируйте Gradle-скрипты через IDE
===========================================
Android studio умеет генерировать стартовый проект с базовой структурой и готовыми build-скриптами, а также удалять и добавлять модули в существующем проекте. А при редактировании Gradle-скриптов IDE нам заботливо подсказывает, что можно вносить изменения в скрипты через графический интерфейс в меню "File -> Project structure...". И в начале своей карьеры я вполне успешно пользовался этим инструментом. Но у него есть существенный недостаток: **IDE не запускает честную фазу конфигурации Gradle и не смотрит на то, что формируется в памяти при сборке, а всего лишь пытается как-то парсить build-скрипты**. Зачастую этот инструмент не распознает то, что было написано вручную, что, на мой взгляд, перечеркивает его пользу.
Мой совет: лучше не редактировать скрипты через IDE, а использовать редактор кода.
#2 Обращайте внимание на соглашение по именованию модулей
=========================================================
В Gradle имя проекта (модуля) берется из соответствующего поля `name` в объекте `Project` или названия директории, в которой он лежит. В своей практике я видел разные стили именования модулей, например, в camel- или snake- кейсе: `MyAwesomeModule`, `my_awesome_module`. Но есть ли какие-то устоявшиеся соглашения об именах модулей? Кажется, официальная документация Gradle ничего нам об этом не говорит. Но нужно принять во внимание тот факт, что **проекты Gradle при публикации в Maven будут соответствовать один к одному модулям Maven**. И у Maven есть соглашение, что слова в названиях модулей должны разделяться через символ `-`. То есть правильнее будет такое название модуля: `my-awesome-module`.
#3 Что выбрать: Kotlin vs Groovy
================================
Изначально в Gradle для DSL использовался язык Groovy, но впоследствии была добавлена возможность писать build-скрипты на Kotlin. Возникает вопрос: что же сейчас использовать? И однозначного ответа на него пока что нет.
Лично я за использование Kotlin, так как не очень хочу только лишь ради build-системы изучать ещё один язык — Groovy. Наверно, для всего Android сообщества DSL на Kotlin существенно понижает порог вхождения в Gradle. Кроме того, у build-скриптов на Kotlin лучше поддержка в IDE с автокомплитом, но, тем не менее, она все еще далека от идеала.
В качестве минуса Kotlin я бы выделил то, что могут встретиться какие-то старые плагины, которые изначально были заточены только под Groovy, и для их подключения придется потратить больше времени.
Если у вас старый большой проект с build-скриптами на Groovy, то могу посоветовать частично попробовать какие-то скрипты перевести на Kotlin, если вам понравится, то можно будет постепенно делать рефакторинг и переписывать все скрипты на Kotlin, не обязательно делать это единовременно.
#4 Как прописывать зависимости в многомодульных проектах
========================================================
Возьмем небольшой пример проекта со следующей структурой:
Основной модуль, из которого собирается apk, зависит от feature-модулей, а также в нём прописаны какие-то внешние зависимости. feature-модули, в свою очередь, содержат транзитивные зависимости, которые могут пересекаться с зависимостями в других модулях.
В чем проблема такого проекта? Здесь будет тяжело глобально обновлять зависимости в каждом из файлов. Очень легко забыть поднять версию в одном из скриптов, и тогда возникнут конфликты. По умолчанию Gradle умеет разрешать такие конфликты, выбирая максимальную версию, так что, скорее всего, сборка будет успешной (поведение можно менять через [resolution strategy](https://docs.gradle.org/current/dsl/org.gradle.api.artifacts.ResolutionStrategy.html)).
Но, конечно же, сознательно допускать конфликты версий не стоит, и для решения этой проблемы есть официальный способ, описанный в [документации Gradle](https://docs.gradle.org/current/userguide/platforms.html), использование которого я никогда не встречал на практике. Вместо него сообщество придумало достаточно простой трюк: прописывать строки с зависимостями где-то глобально и обращаться к ним из build-скриптов. Тут я хочу рассмотреть эти способы чуть подробнее.
Java platform plugin
--------------------
Разработчики Gradle предлагают для описания зависимостей создать отдельный специальный модуль, где будут описаны только зависимости с конкретными версиями. К этому модулю надо применить [java platform plugin](https://docs.gradle.org/current/userguide/java_platform_plugin.html). Далее подключаем этот модуль в остальные модули и при указании каких-то внешних зависимостей не пишем конкретную версию:
Такие platform-проекты можно даже публиковать на внешние maven репозитории и переиспользовать. В качестве минуса подхода можно назвать то, что при мажорных обновлениях библиотек часто меняются не только версии, но и названия модулей, и тогда все равно придется вносить изменения сразу в нескольких скриптах.
Перейду к общепринятым в сообществе способам описания зависимостей.
Описание зависимостей в extra properties
----------------------------------------
Достаточно часто можно увидеть практику, когда строки с зависимостями хранят в extra properties корневого проекта, по сути это словарь, доступный всем дочерним модулям. Пример использования можно встретить в некоторых [библиотеках от Google](https://github.com/material-components/material-components-android).
В корневом проекте описываем зависимости. Вот кусок build-скрипта из библиотеки Google, где зависимость возвращается функцией `compatibility`:
```
ext {
compileSdkVersion = 29
minSdkVersion = 14
targetSdkVersion = 29
androidXVersions = [
annotation: '1.0.1',
appCompat: '1.1.0'
// ...
]
}
/**
* Return the module dependency for the given compatibility library name.
*/
def compatibility(name) {
switch (name) {
case "annotation":
return "androidx.annotation:annotation:${androidXVersions.annotation}"
case "appcompat":
return "androidx.appcompat:appcompat:${androidXVersions.appCompat}"
```
И обращаемся к ним из дочерних модулей:
```
dependencies {
api compatibility("annotation")
api compatibility("appcompat")
api compatibility("cardview")
api compatibility("coordinatorlayout")
api compatibility("constraintlayout")
api compatibility("core")
api compatibility("dynamicanimation")
// ...
}
```
Описание зависимостей в скриптовом плагине
------------------------------------------
Описанный способ с extra properties можно немного модифицировать и вынести описание зависимостей в [скриптовый плагин](https://docs.gradle.org/current/userguide/plugins.html#sec:script_plugins), чтобы не засорять корневой проект. А уже скриптовый плагин можно применить или к корневому, или ко всем дочерним проектам сразу (через `allprojects {}`), или к отдельным. Такой способ я тоже встречал.
Описание зависимостей в buildSrc
--------------------------------
В [buildSrc](https://docs.gradle.org/current/userguide/organizing_gradle_projects.html#sec:build_sources) можно писать любой код, который будет компилироваться и добавляться в classpath build-скриптов. В последнее время стало популярно использовать buildSrc для описания там зависимостей. Например, в библиотеке [Insetter](https://github.com/chrisbanes/insetter) Chris Banes так и делает.
Все, что нужно, — это добавить синглтон со строками в buildSrc, и он станет виден всем модулям в проекте:
```
object Versions {
const val minSdk = 23
const val compileSdk = 29
const val kotlin = "1.4.20"
const val kotlinCoroutines = "1.4.0"
const val okHttp = "4.9.0"
const val retrofit = "2.9.0"
const val moshi = "1.11.0"
}
object Dependencies {
object Kotlin {
const val stdlib = "org.jetbrains.kotlin:kotlin-stdlib:${Versions.kotlin}"
const val reflect = “org.jetbrains.kotlin:kotlin-reflect:${Versions.kotlin}"
}
object Google {
const val materialComponents = "com.google.android.material:material:1.2.1"
const val googleAuth = "com.google.android.gms:play-services-auth:18.1.0"
const val location = "com.google.android.gms:play-services-location:17.1.0"
const val tasks = "com.google.android.gms:play-services-tasks:17.2.0"
}
}
```
Использовать buildSrc для зависимостей очень удобно, так как будут статические проверки и автокомплит в IDE:
Но у этого решения есть один недостаток: любое изменение в buildSrc будет инвалидировать весь кэш сборки, что может быть несущественно для средних и маленьких проектов, но выливаться в серьезные проблемы для больших команд.
Композитные сборки
------------------
Можно достичь похожего результата со статическими проверками и автокомплитом, используя [композитные сборки](https://docs.gradle.org/current/userguide/composite_builds.html), при этом избавившись от проблемы инвалидации всего кэша. Я расскажу про него лишь кратко, а подробный гайд по миграции с buildSrc можно прочитать в [статье из блога Badoo](https://habr.com/ru/company/badoo/blog/514094/) или [статье от Josef Raska](https://proandroiddev.com/stop-using-gradle-buildsrc-use-composite-builds-instead-3c38ac7a2ab3).
В композитных сборках мы создаем так называемые «включенные сборки» (included build), в которых можно писать плагины и подключать их в своих модулях. Включенные сборки описываются в файле `settings.gradle`.
Если мы хотим всего лишь подсунуть в classpath build-скриптов строки с зависимостями, то достаточно создать пустой плагин, а рядом с ним положить тот же файл с зависимостями, который мы использовали раньше в buildSrc:
```
// Build скрипт включенной сборки
// ./dependencies/build.gradle.kts
plugins {
`kotlin-dsl`
}
repositories {
jcenter()
google()
}
gradlePlugin {
plugins {
register("dependencies") {
id = "dependencies"
implementationClass = “com.rmr.dependencies.DependenciesPlugin”
}
}
}
```
```
// Плагин из включенной сборки
// ./dependencies/src/main/kotlin/com/rmr/depenendencies/DependenciesPlugin.kt
package com.rmr.dependencies
import org.gradle.api.Plugin
import org.gradle.api.Project
class DependenciesPlugin : Plugin {
override fun apply(target: Project) {
// Do nothing, just load dependencies to classpath
}
}
```
Все, что осталось сделать, — применить плагин к корневому проекту:
```
plugins { id("dependencies") }
```
И мы получим практически тот же результат, как и с использованием buildSrc.
Выглядит так, что **способ с композитными сборками самый подходящий и его можно сразу начинать использовать со старта проекта**.
#5 Как обновлять зависимости
============================
В любом активном проекте надо постоянно следить за обновлением библиотек. IDE умеет подсвечивать для каждого модуля, описанного в блоке `dependencies {}`, наличие новых стабильных версий в репозиториях:
Но этот инструмент работает только для зависимостей, описанных строковыми литералами в build-скриптах, а если мы попытаемся использовать способ с композитными сборками, buildSrc или extra properties, то IDE перестанет нам помогать. Кроме того, визуально просматривать build-скрипты в модулях, для того чтобы сделать обновление библиотек, на мой взгляд, не очень удобно.
Но есть решение — использовать [gradle-versions-plugin](https://github.com/ben-manes/gradle-versions-plugin). Для этого просто применяем плагин к корневому проекту и регистрируем task для проверки новых версий зависимостей. Этот task надо настроить, передав ему лямбду для определения нестабильных версий:
```
fun isNonStable(version: String): Boolean {
val stableKeyword = listOf("RELEASE", "FINAL", "GA").any { version.toUpperCase().contains(it) }
val regex = "^[0-9,.v-]+(-r)?$".toRegex()
val isStable = stableKeyword || regex.matches(version)
return isStable.not()
}
tasks.withType {
rejectVersionIf {
isNonStable(candidate.version) && !isNonStable(currentVersion)
}
}
```
Теперь запуск команды `./gradlew dependencyUpdates` выведет список зависимостей, для которых есть новые версии:
```
The following dependencies have later milestone versions:
- androidx.constraintlayout:constraintlayout [2.0.1 -> 2.0.4]
http://tools.android.com
- androidx.core:core-ktx [1.5.0-alpha05 -> 1.5.0-beta03]
https://developer.android.com/jetpack/androidx/releases/core#1.5.0-beta03
- androidx.fragment:fragment-ktx [1.3.0-beta02 -> 1.3.1]
https://developer.android.com/jetpack/androidx/releases/fragment#1.3.1
- androidx.lifecycle:lifecycle-runtime-ktx [2.2.0 -> 2.3.0]
https://developer.android.com/jetpack/androidx/releases/lifecycle#2.3.0
- com.github.ben-manes:gradle-versions-plugin [0.36.0 -> 0.38.0]
- com.github.ben-manes.versions:com.github.ben-manes.versions.gradle.plugin [0.36.0 -> 0.38.0]
- com.github.bumptech.glide:glide [4.11.0 -> 4.12.0]
https://github.com/bumptech/glide
```
#6 Старайтесь не использовать feature-флаги в build config
==========================================================
Во многих проектах release, debug и другие сборки отличаются по функциональности. Например, в отладочных сборках могут быть включены какие-то логи, мониторинг сетевого трафика через прокси, debug menu для смены окружений и т.д. И часто для реализации такого используют флаги, прописанные в build config, например:
```
android {
buildTypes {
getByName("debug") {
buildConfigField("Boolean", "ENABLE_DEBUG_SCREEN", "true")
}
getByName("release") {
buildConfigField("Boolean", "ENABLE_DEBUG_SCREEN", "false")
}
}
}
```
А дальше такие флаги используются в коде приложения:
```
if (BuildConfig.ENABLE_DEBUG_SCREEN) {
} else {
}
```
И у такого решения есть недостатки. Довольно легко перепутать значения флагов и ветки if/else: `if (enabled) {} else {}` или `if (disabled) {} else {}`. Именно так однажды, во время рефакторинга, я случайно отправил в релиз то, что должно было включаться только в сборках для QA-отдела (думаю, у многих были похожие истории). Тогда проблему обнаружили оперативно, мы перевыпустили сборку в маркет. Кроме того, недостижимый код может быть скомпилирован и попасть в релиз (здесь я не буду рассуждать о том, что «мертвый» код может вырезаться из итогового приложения). Ну и многим известно, что любые операторы ветвления лучше заменять полиморфизмом. И в Gradle есть статический полиморфизм.
Вместо флагов можно использовать разные source set для различных build variant ("src/**release**/java ...", "src/**debug**/java ..."). А если такой код хочется вынести в отдельные модули, то можно использовать специальные конфигурации: `debugImplementation`, `releaseImplementation` и т.д. Тогда мы сможем написать код с одним и тем же интерфейсом, но разной реализацией для различных типов сборок.
Например, мы можем выделить debug menu в отдельный модуль и подключать его только для debug и QA-сборок:
```
dependencies {
val qaImplementation by configurations
debugImplementation(project(":feature-debug-screen"))
qaImplementation(project(":feature-debug-screen"))
}
```
А stub реализацию для релизной сборки можно реализовать через source set.
#7 Несколько слов про базовую структуру проекта
===============================================
Совет немного не по теме, но я решил добавить его как часть своего опыта, так как модуляризация напрямую связана с Gradle.
Если для крупных проектов модуляризация кажется вполне очевидным решением, то не совсем понятно, как стоит поступать при старте небольших проектов или когда невозможно предсказать дальнейшее развитие кодовой базы продукта. Нужно ли выделять какие-то модули или достаточно начать с монолита? Я бы, помимо app модуля с основным приложением, всегда выделял как минимум два отдельных модуля:
* **UI kit: стили, кастомные элементы управления, виджеты и т.д.** Обычно элементы управления на всех экранах приложения делаются консистентно в одном стиле (а возможно, у вас целая дизайн-система), и если в какой-то момент захочется выделить feature-модуль, то он также будет опираться на единый UI kit. Заранее подготовленный модуль с элементами управления и стилями упростит задачу и не потребует значительного рефакторинга приложения.
* **Common / utils**: все утилитные классы и любые решения, которые не только потребуются в нескольких модулях, но и могут даже копироваться из проекта в проект. Особенно в контексте аутсорса такой модуль будет удобным при старте новых проектов. При вынесении классов в отдельный модуль, а не пакет, можно быть уверенным, что в его коде не окажется каких-либо бизнес сущностей конкретного приложения. Потенциально такой модуль может стать полноценной библиотекой, опубликованной в репозиторий.
#8 Не забывайте про matchingFallbacks
=====================================
Часто, помимо `debug` и `release`, мы создаем и другие типы сборок, например, `qa` для тестов. И при создании модулей в приложении необязательно их прописывать в каждом build-скрипте. Достаточно при создании своего build type указать в модуле основного приложения те build type, которые следует выбирать при отсутствии каких-то конкретных:
```
android {
buildTypes {
create("qa") {
setMatchingFallbacks("debug", "release") // если не найдется qa, то искать сначала debug, затем release
}
}
}
```
#9 Убирайте ненужные build variant
==================================
Build variant формируются из всех возможных сочетаний product flavor и build type. Возьмем небольшой синтетический пример: создадим три build type – `debug` (отладочная сборка), `release` (сборка в маркет) и `qa` (сборка для тестирования), а во flavor вынесем разные сервера, на которые может смотреть сборка, – `production` и `staging` (тестовое окружение). Возможные build variant будут выглядеть так:
Очевидно, что сборка в маркет, которая будет смотреть на тестовое окружение, совершенно бессмысленна и не нужна (`stagingRelease`). И чтобы исключить ее, можно добавить variant filter:
```
android {
variantFilter {
if (name == "stagingRelease") {
setIgnore(true)
}
}
}
```
#10 В некоторых модулях, завязанных на Android Framework, можно не использовать Android Gradle Plugin
=====================================================================================================
Если какой-то из ваших модулей завязан на классы из Android Framework, то вовсе не обязательно сразу применять к нему Android Gradle Plugin и писать там файл манифеста. Модули с AGP — более тяжеловесные, чем чистые java/kotlin модули, так как при сборке будут объединяться манифесты, ресурсы и т.д. Когда вам всего лишь требуется для компиляции модуля что-то вроде классов `Activity`, `Context` и т.д., то можно просто добавить Android Framework как зависимость:
```
dependencies {
compileOnly("com.google.android:android:4.1.1.4")
}
```
#11 Как написать Gradle-плагин для CI на примере gitlab
=======================================================
Настройка CI — отдельная большая тема, которая потянет на целую увесистую статью. Но я решил немного коснуться её и рассказать, как при помощи написания Gradle-плагина настроить версионирование сборок. Возможно, этот совет поможет тем, кто только поднимает CI, но не знает, как лучше это сделать.
Задача — сделать так, чтобы в сборках на CI `versionCode` ставился автоматически и представлял из себя последовательные номера 1, 2, 3 и т.д. Я встречал в своей практике, когда в качестве `versionCode` брался CI job id или каким-то образом использовался timestamp. В таких случаях `versionCode` с каждой новой версией повышался и был уникальным, но семантически такие версии выглядели достаточно странно.
Основная идея проста — нужно хранить номер будущего релиза где-то во внешнем источнике, куда имеет доступ только сборка, выполняемая на CI. А после каждой успешной публикации нужно инкрементировать этот номер и перезаписывать (нам важно, чтобы сборка не просто успешно выполнилась, но и полученные артефакты распространились для тестировщиков). Стоит оговориться, что такое решение не позволит корректно делать одновременно несколько сборок. Всю эту логику достаточно просто оформить в Gradle-плагин. Как мы уже выяснили, плагины лучше писать, используя композитные сборки.
В случае использования Gitlab CI подставляемый `versionCode` можно хранить в переменной окружения Gitlab. В его API есть [метод](https://docs.gitlab.com/ee/api/project_level_variables.html#update-variable) для обновления переменных окружения: `PUT /projects/:id/variables/:key`. Для авторизации используем или [project access token](https://docs.gitlab.com/ee/user/project/settings/project_access_tokens.html), или [personal access token](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html) для старых версий gitlab.
Расписал добавление такого плагина по шагам, чтобы показать, насколько это просто.
### Шаг 1: в настройках проекта на gitlab создать переменные окружения
Нам понадобятся переменные `VERSION_CODE_NEXT` для хранения номера версии и токен для доступа к API gitlab:
### Шаг 2: создать композитную сборку
Добавим в корне проекта директорию `./includedBuilds/ci`, а в ней файл `build.gradle.kts`:
```
plugins {
`kotlin-dsl`
}
kotlinDslPluginOptions {
experimentalWarning.set(false)
}
repositories {
jcenter()
google()
}
dependencies {
implementation("com.squareup.okhttp3:okhttp:4.9.0")
}
gradlePlugin {
plugins {
register("gitlab-ci") {
id = "gitlab-ci"
implementationClass = "com.redmadrobot.app.ci.CIPlugin" // Этот плагин создадим в следующих шагах
}
}
}
```
Рядом создадим пустой файл `./includedBuilds/ci/settings.gradle.kts`, если этого не сделать, то у вас сломается clean проекта.
В корневом проекте в файл `settings.gradle.kts` добавим строку `includeBuild("includedBuilds/ci")`.
### Шаг 3: написать плагин
Так будет выглядеть метод для получения `versionCode`, его можно будет использовать в build-скрипте (можно добавить в любой файл: при применении плагина код будет скомпилирован и добавлен в classpath build-скрипта):
```
const val GITLAB_VARIABLE_NEXT_VERSION = "VERSION_CODE_NEXT"
private const val DEFAULT_VERSION_CODE = 1
fun getVersionCode(): Int = if (isRunningOnCi()) {
getNextVersionCode()
} else {
DEFAULT_VERSION_CODE
}
private fun isRunningOnCi(): Boolean = System.getenv()["CI"] != null
private fun getNextVersionCode(): Int {
return System.getenv()[GITLAB_VARIABLE_NEXT_VERSION]?.toInt()
?: error("$GITLAB_VARIABLE_NEXT_VERSION must be specified")
}
```
Примерно так можно написать метод для обновления переменной на gitlab:
```
fun updateGitlabVariable(variable: String, value: String) {
val projectId = System.getenv()["CI_PROJECT_ID"]
val accessToken = System.getenv()["TOKEN_FOR_GITLAB_API"]
val client = OkHttpClient()
val body = MultipartBody.Builder()
.setType(MultipartBody.FORM)
.addFormDataPart("value", value)
.build()
val request = Request.Builder()
.header("PRIVATE-TOKEN", accessToken)
.url("https://gitlab.com/api/v4/projects/$projectId/variables/$variable")
.method("PUT", body)
.build()
client.newCall(request).execute().use { response ->
if (!response.isSuccessful) throw IOException("Couldn't update variable”)
}
}
```
Далее пишем task, который при выполнении будет инкрементировать версию:
```
open class IncrementVersionCode : DefaultTask() {
@TaskAction
fun action() {
val nextVersionCode = getDistributionVersionCode() + 1
updateGitlabVariable(
GITLAB_VARIABLE_NEXT_VERSION,
nextVersionCode.toString()
)
}
}
```
И напишем плагин, который добавит task в проект:
```
package com.redmadrobot.app.ci
import org.gradle.api.Plugin
import org.gradle.api.Project
class CIPlugin : Plugin {
override fun apply(target: Project) {
target.tasks.register("incrementVersionCode", IncrementVersionCode::class.java)
}
}
```
### Шаг 4: подключить плагин
В build-скрипте проекта, из которого собирается apk, добавим следующие строки:
```
plugins {
id("gitlab-ci")
}
android {
defaultConfig {
versionCode = com.redmadrobot.app.ci.getVersionCode()
}
}
project.afterEvaluate {
tasks["incrementVersionCode"].mustRunAfter( // Обновление должно происходить только после публикации сборки в Firebase App Distribution
tasks["appDistributionUploadRelease"],
tasks["appDistributionUploadQa"]
)
}
```
Теперь команда `./gradlew assembleRelease appDistributionUploadRelease incrementVersionCode` будет делать новую сборку, публиковать ее и инкрементировать версию. Остается добавить эту команду на нужный триггер в ваш скрипт в `.gitlab-ci.yml`.
В заключение
============
Думаю, что у многих есть свои best practices по работе с Gradle, которыми вы бы могли поделиться с сообществом. Или что-то описанное в этой статье можно сделать лучше. Так что буду рад увидеть ваши советы в комментариях.
Что ещё посмотреть
==================
Мне очень помогли доклады про работу с Gradle, которые делал Степан Гончаров в разные годы. Ссылки на них, если кому-то интересна эта тема:
* [Gradle pipeline optimisation: Beyond basics](https://www.youtube.com/watch?v=ez3mQoMZUBY);
* [Gradle от A до Я](https://www.youtube.com/watch?v=Yft6h7JkWo0&t=0s);
* [Абсолютная модуляризация](https://www.youtube.com/watch?v=oAQlKiF91Ks).
И в формате дискуссии: [Разбор доклада Степана Гончарова «Gradle от А до Я»](https://www.youtube.com/watch?v=CbEqv1vXtOc) | https://habr.com/ru/post/544630/ | null | ru | null |
# Временное решение для блокировки рекламы
Для себя временно решил использовать некэширующий веб-прокси [Privoxy](http://www.privoxy.org) — очень простая настройка, работоспособен под всеми системами, позволяет расширять фильтры, и слету рубит рекламу на Хабре (да, мне стыдно :-) ).
Установил не совсем дефолтно — поставил на Linux машине для дополнительной секьюрности: собственно, у меня на столе виндовая машина (для Аутлука и офиса) и под столом — линуксовая (основная рабочая). Ну вот на Убунту-то я и поставил его (хотя он прекрасно будет работать и под Windows):
> `sudo apt-get install privoxy`
Единственное изменение которое мне потребовалось — это изменить адрес по умолчанию, на котором «слушает» прокси — с 127.0.0.1 на имя хоста моей машины. После этого я прописал в настройках Хрома (Settings -> Under the hood -> Proxy settings) мой линуксовый хост и порт, и рекламы я больше не вижу.
Хотя, конечно, AdBlock лучше — Хром он просто не дает показывать картинки и флешки, а AdBlock целиком или вырезает, так, что даже белого прямоугольника не остается — надеюсь, что подобное решение не заставит себя ждать.
P.S. А конфигурируется прокси с веб-интерфейса — по смешному адресу [p.p](http://p.p) или «полному» — [config.privoxy.org](http://config.privoxy.org) — который он «перепиливает» на локальный (или отправляет вас на страницу «Privoxy has not been set up properly» если что-то не заработало и браузер ходит не через прокси).
P.P.S. Перенес в соответствующий блог. | https://habr.com/ru/post/38941/ | null | ru | null |
# Кластеризуем миллионы планов PostgreSQL
Как найти самые "горячие" запросы на вашем PostgreSQL-сервере? Поискать их в логе и проанализировать план или воспользоваться расширением [pg\_stat\_statements](https://postgrespro.ru/docs/postgresql/12/pgstatstatements).
А если в лог попадает миллион запросов за сутки?.. Тогда любое значение лимита `pg_stat_statements.max` окажется недостаточно велико, чтобы собрать правдивую статистику. Так давайте собирать эту статистику прямо с планов!
Но для некоторых [сервисов СБИС](https://sbis.ru/all_services) нам в ["Тензоре"](https://tensor.ru/) производительность запросов к базе настолько важна, что `auto_explain.log_min_duration` приходится выставлять в **единицы миллисекунд** - и вот они, миллионы планов... Как не потеряться в них?
От планов - к шаблонам
----------------------
Давайте сначала проведем небольшой эксперимент на таблице с сильно неоднородными данными:
```
CREATE TABLE tst AS
SELECT
*
, CASE
WHEN r < 0.9 THEN 0
WHEN r < 0.99 THEN 1
WHEN r < 0.999 THEN 2
WHEN r < 0.9999 THEN 3
END v
FROM
(
SELECT
i
, random() r
FROM
generate_series(1, 1e4) i
) T;
CREATE INDEX ON tst(v);
ANALYZE tst;
```
Посмотрим на план одного и того же запроса при `v = 0`:
```
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
SELECT
*
FROM
tst
WHERE
v = 0;
```
```
Seq Scan on tst (actual time=0.023..1.236 rows=9034 loops=1)
Filter: (v = 0)
Rows Removed by Filter: 966
Buffers: shared hit=64
```
... `v = 1`:
```
Bitmap Heap Scan on tst (actual time=0.074..0.286 rows=876 loops=1)
Recheck Cond: (v = 1)
Heap Blocks: exact=64
Buffers: shared hit=69
-> Bitmap Index Scan on tst_v_idx (actual time=0.058..0.058 rows=876 loops=1)
Index Cond: (v = 1)
Buffers: shared hit=5
```
... `v = 2`:
```
Bitmap Heap Scan on tst (actual time=0.047..0.106 rows=83 loops=1)
Recheck Cond: (v = 2)
Heap Blocks: exact=45
Buffers: shared hit=47
-> Bitmap Index Scan on tst_v_idx (actual time=0.031..0.031 rows=83 loops=1)
Index Cond: (v = 2)
Buffers: shared hit=2
```
и `v = 3`, наконец:
```
Index Scan using tst_v_idx on tst (actual time=0.020..0.026 rows=6 loops=1)
Index Cond: (v = 3)
Buffers: shared hit=8
```
Если очистить каждый из этих планов от "переменной" информации вроде количества прочитанных данных или времени обработки, останется только **"шаблон" плана** - текстовое представление алгоритма выполнения запроса:
```
-- v = 0
Seq Scan on tst
```
```
-- v = 1, v = 2
Bitmap Heap Scan on tst
-> Bitmap Index Scan on tst_v_idx
```
```
-- v = 3
Index Scan using tst_v_idx on tst
```
Ровно это делает и [наш сервис визуализации планов](https://explain.tensor.ru/), когда помогает вам анализировать запрос:
Такая методика позволяет миллионы планов превращать в сотни шаблонов.
От шаблонов - к моделям
-----------------------
Но подождите, у нас был **один и тот же запрос** "на входе", а "на выходе" мы получили аж **3 разных шаблона**! И если мы будем смотреть сводную статистику по "топовым" шаблонам, то наверняка упустим этот запрос, ведь его показатели будут "размазаны" по нескольким записям.
Но ведь, во всех шаблонах мы видим, что производилось сканирование таблицы `tst`, только разными способами: `Seq Scan`, `Bitmap Scan` и `Index Scan` - и это лишь одна из причин "разбегания" шаблонов, а их много больше:
* порядок и вид соединения таблиц (`Nested Loop`, `Hash Semi Join`, `Merge Join`, ...)
* наличие/отсутствие/несовпадение алиасов у одних и тех же таблиц
* разные виды чтений (`Index Only Scan` / `Index Scan` / `Bitmap Index Scan`) по индексам одной и той же таблицы
* использование параллелизации при извлечении данных (`Seq Scan` vs `Parallel Seq Scan`)
* наличие/отсутствие вспомогательной сортировки / группировки / уникализации для `WindowAgg`
* сработка и порядок триггеров, особенно условных
Давайте попробуем получить из шаблона некоторую **модель плана**, в которую попадали бы (с большой вероятностью) все планы от одного запроса:
* сохраняем общую структуру плана (`CTE / InitPlan / SubPlan / Append`)
* объединяем разные операции над таблицей в `Scan Table`
* вместо множества вложенных `Join/Loop`-узлов, включая сортировки и хэширование, оставляем один `Join` со отсортированным списком участвующих таблиц
* дополнительные узлы обработки данных вроде сортировки, группировки и уникализации превращаем в общий узел `Process`
И если все эти преобразования провести над нашими шаблонами, мы получим для них единую модель:
```
Scan Table tst
```
Ее можно увидеть [на соответствующей вкладке](https://explain.tensor.ru/archive/explain/940af12543268372e8dc426cc516080d:0:2021-09-13#domain) анализа плана. При этом план с достаточно сложной структурой:
... может превратиться во вполне компактное представление:
```
Process
InitPlan 1
-> Process
-> Scan Table "request-statuses"
InitPlan 2
-> Process
-> Scan Table "request-statuses"
-> Join
-> Scan Table "request-statuses"
-> Scan Table "task-tracker-times"
-> Scan Table requests
-> Scan Table tasks
```
Сотни шаблонов уже превращаются в десятки моделей.
Кластерный анализ планов
------------------------
Но сами модели могут все-таки немного отличаться друг от друга для "родственных" запросов. Что-то вроде этого:
```
-> Scan Table tst | A
-> InitPlan 1 | B
-> Scan Values | B
```
```
-> Scan Table tst | A
SubPlan 1 | C
-> Scan Table tst | C
```
Как определить метрику "похожести" двух моделей? Можно, конечно, подключить какую-то зубодробительную математику, нейронные сети, суперкомпьютеры...
А можно подойти алгоритмически и выделить у обеих моделей построчно общий префикс `A` . Тогда полные модели `B` и `C` можно считать его потомками и собрать так иерархию представления для всех моделей сервера.
Теперь просто визуализируем размер узла в такой иерархии пропорционально общей статистике модели, и поиск нужной иголки в этом стоге сена уже не будет представлять большой проблемы:
 | https://habr.com/ru/post/577646/ | null | ru | null |
# Темы приложений для Xamarin.Forms
Все основные ОС теперь поддерживают темные и светлые темы приложений, и появился Xamarin.Forms 4.7, чтобы упростить добавление этой фичи в ваши приложения. Фактически, если вы ничего не сделаете, ваши приложения Xamarin.Forms будут соответствовать предпочтениям ОС пользователя. Зачем останавливаться на достигнутом? Вы также можете настроить светлые и темные цвета, используемые в пользовательском интерфейсе вашего приложения, и даже предоставить пользователю возможность самостоятельно управлять темой своего приложения. Давайте начнем с самого начала.
Цвета платформы по умолчанию
----------------------------
Когда вы не устанавливаете стили или цвета, ваш пользовательский интерфейс по умолчанию будет соответствовать теме, нативной для платформы, на которой работает приложение. Например, посмотрите, как выглядит этот новый шаблон «Пустое приложение» на iOS:
```
```
Когда вы переключаете симулятор iOS между темным и светлым режимами (CMD + SHFT + A), вы можете видеть изменение фона ContentPage с белого на черный и текста с черного на белый. Это цвета платформы по умолчанию. Сравните это с заголовком, который остается синим, и текстом заголовка, который остается белым. Это явные цвета, установленные в коде.
Берем под контроль черный
-------------------------
Чтобы теперь управлять цветами для темного и светлого заголовка и текста, вы можете заменить статические цвета на привязку AppThemeBinding, которая будет реагировать во время выполнения на настройки темы ОС. Сначала включите эту функцию, добавив флаг к вашему App.xaml.cs:
```
public App()
{
Device.SetFlags(new string[]{ "AppTheme_Experimental" });
InitializeComponent();
}
```
Обновление только заголовка, это выглядит так:
```
```
Вы можете, конечно, изменить стили, как здесь:
```
<Setter Property="BackgroundColor" Value="{AppThemeBinding Dark=#1d1d1d, Light=#2196F3}"/>
<Setter Property="Padding" Value="36,48,36,36"/>
<Setter Property="CornerRadius" Value="0"/>
<Setter Property="TextColor" Value="{AppThemeBinding Dark=#F1F1F1, Light=White}"/>
<Setter Property="HorizontalTextAlignment" Value="Center"/>
<Setter Property="FontSize" Value="36"/>
```
И если вы хотите использовать предопределенные стили цвета, это может выглядеть так:
```
#1d1d1d
#1d1d1d
``` | https://habr.com/ru/post/511642/ | null | ru | null |
# Unity Auto Registration
#### Unity Auto Registration
Unity Auto Registration расширяет возможности Unity контейнера, предоставляя fluent interface для автоматической регистрации типов по установленным правилам. Используя всего несколько строк кода вы можете отсканировать указанную сборку и зарегистрировать все соответствующие указанным правилам типы.
В качестве правил вы можете использовать предикаты (Predicate), лямбда выражения и вызовы методов. If хелпер предоставляет все типовые варианты для описания условий.
Ниже представлен пример конфигурации с помощью Unity Auto Registration:
> `1. var container = new UnityContainer();
> 2.
> 3. container
> 4. .ConfigureAutoRegistration()
> 5. .LoadAssemblyFrom("Plugin.dll")
> 6. .IncludeAllLoadedAssemblies()
> 7. .ExcludeSystemAssemblies()
> 8. .ExcludeAssemblies(a => a.GetName().FullName.Contains("Test"))
> 9. .Include(If.Implements, Then.Register().UsingPerCallMode())
> 10. .Include(If.ImplementsITypeName, Then.Register().WithTypeName())
> 11. .Include(If.Implements, Then.Register().WithName("Sample"))
> 12. .Include(If.Implements,
> 13. Then.Register().AsSingleInterfaceOfType().UsingPerCallMode())
> 14. .Include(If.DecoratedWith,
> 15. Then.Register()
> 16. .AsInterface()
> 17. .WithTypeName()
> 18. .UsingLifetime())
> 19. .Exclude(t => t.Name.Contains("Trace"))
> 20. .ApplyAutoRegistration();`
#### Ресурсы
Скачать стафф можно на <http://autoregistration.codeplex.com/> | https://habr.com/ru/post/74757/ | null | ru | null |
# Пишем на картинках
В течение последнего времени что-то часто стали мелькать статьи про обработку изображений на php. Скругленные края уже были, тени были, мокрый пол был, еще куча всего было.
А вот надписей вроде еще не было. Значит будут. :-)
Представляю вашему вниманию не большой, но в тоже время достаточно богатый возможностями класс (на основе GD) написания текста на картинках TrueType-шрифтами.
Код класса:
-----------
> `php<br/
>
>
> class ttfTextOnImage
>
> {
>
> // Качество jpg по-умолчанияю
>
> public $jpegQuality = 100;
>
>
>
> // Каталог шрифтов
>
> public $ttfFontDir = 'ttf';
>
>
>
> private $ttfFont = false;
>
> private $ttfFontSize = false;
>
>
>
> private $hImage = false;
>
> private $hColor = false;
>
>
>
> public function \_\_construct($imagePath)
>
> {
>
> if (!is\_file($imagePath) || !list(,,$type) = @getimagesize($imagePath)) return false;
>
>
>
> switch ($type)
>
> {
>
> case 1: $this->hImage = @imagecreatefromgif($imagePath); break;
>
> case 2: $this->hImage = @imagecreatefromjpeg($imagePath); break;
>
> case 3: $this->hImage = @imagecreatefrompng($imagePath); break;
>
> default: $this->hImage = false;
>
> }
>
> }
>
>
>
> public function \_\_destruct()
>
> {
>
> if ($this->hImage) imagedestroy($this->hImage);
>
> }
>
>
>
> /\*\*
>
> \* Устанавливает шрифт
>
> \*
>
> \*/
>
> public function setFont($font, $size = 14, $color = false, $alpha = false)
>
> {
>
> if (!is\_file($font) && !is\_file($font = $this->ttfFontDir.'/'.$font))
>
> return false;
>
>
>
> $this->ttfFont = $font;
>
> $this->ttfFontSize = $size;
>
>
>
> if ($color) $this->setColor($color, $alpha);
>
> }
>
>
>
> /\*\*
>
> \* Пишет текст
>
> \*
>
> \*/
>
> public function writeText ($x, $y, $text, $angle = 0)
>
> {
>
> if (!$this->ttfFont || !$this->hImage || !$this->hColor) return false;
>
>
>
> imagettftext(
>
> $this->hImage,
>
> $this->ttfFontSize, $angle, $x, $y + $this->ttfFontSize,
>
> $this->hColor, $this->ttfFont, $text);
>
> }
>
>
>
> /\*\*
>
> \* Форматирует текст (согласно текущему установленному шрифту),
>
> \* что бы он не вылезал за рамки ($bWidth, $bHeight)
>
> \* Убирает слишком длинные слова
>
> \*/
>
> public function textFormat($bWidth, $bHeight, $text)
>
> {
>
> // Если в строке есть длинные слова, разбиваем их на более короткие
>
> // Разбиваем текст по строкам
>
>
>
> $strings = explode("\n",
>
> preg\_replace('!([^\s]{24})[^\s]!su', '\\1 ',
>
> str\_replace(array("\r", "\t"),array("\n", ' '), $text)));
>
>
>
> $textOut = array(0 => '');
>
> $i = 0;
>
>
>
> foreach ($strings as $str)
>
> {
>
> // Уничтожаем совокупности пробелов, разбиваем по словам
>
> $words = array\_filter(explode(' ', $str));
>
>
>
> foreach ($words as $word)
>
> {
>
> // Какие параметры у текста в строке?
>
> $sizes = imagettfbbox($this->ttfFontSize, 0, $this->ttfFont, $textOut[$i].$word.' ');
>
>
>
> // Если размер линии превышает заданный, принудительно
>
> // перескакиваем на следующую строку
>
> // Иначе пишем на этой же строке
>
> if ($sizes[2] > $bWidth) $textOut[++$i] = $word.' '; else $textOut[$i].= $word.' ';
>
>
>
> // Если вышли за границы текста по вертикали, то заканчиваем
>
> if ($i\*$this->ttfFontSize >= $bHeight) break(2);
>
> }
>
>
>
> // "Естественный" переход на новую строку
>
> $textOut[++$i] = ''; if ($i\*$this->ttfFontSize >= $bHeight) break;
>
> }
>
>
>
> return implode ("\n", $textOut);
>
> }
>
>
>
> /\*\*
>
> \* Устанваливет цвет вида #34dc12
>
> \*
>
> \*/
>
> public function setColor($color, $alpha = false)
>
> {
>
> if (!$this->hImage) return false;
>
>
>
> list($r, $g, $b) = array\_map('hexdec', str\_split(ltrim($color, '#'), 2));
>
>
>
> return $alpha === false ?
>
> $this->hColor = imagecolorallocate($this->hImage, $r+1, $g+1, $b+1) :
>
> $this->hColor = imagecolorallocatealpha($this->hImage, $r+1, $g+1, $b+1, $alpha);
>
> }
>
>
>
> /\*\*
>
> \* Выводит картинку в файл. Тип вывода определяется из расширения.
>
> \*
>
> \*/
>
> public function output ($target, $replace = true)
>
> {
>
> if (is\_file ($target) && !$replace) return false;
>
>
>
> $ext = strtolower(substr($target, strrpos($target, ".") + 1));
>
>
>
> switch ($ext)
>
> {
>
> case "gif":
>
> imagegif ($this->hImage, $target);
>
> break;
>
>
>
> case "jpg" :
>
> case "jpeg":
>
> imagejpeg($this->hImage, $target, $this->jpegQuality);
>
> break;
>
>
>
> case "png":
>
> imagepng($this->hImage, $target);
>
> break;
>
>
>
> default: return false;
>
> }
>
> return true;
>
> }
>
> }
>
> ?>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Что он умеет, думаю разобраться не сложно, тем более что комментарии есть. Теперь пример использования:
> `// Берем какую-нибудь картинку
>
> $ttfImg = new ttfTextOnImage('images/hlwn.jpg');
>
>
>
> // Пишем шрифтом Scrawn размером 64 пункта бордовым цветом с 80%-ой прозрачностью
>
> $ttfImg->setFont('files/fonts/scra.ttf', 64, "#800000", 80);
>
> $ttfImg->writeText(40, 570, "Happy halloween!");
>
>
>
> // Шрифтом Constantin размером 15 пунктов оранжевым цветом с 90%-ой прозрачностью
>
> $ttfImg->setFont('files/fonts/constan.ttf', 15, "#ff8200", 90);
>
>
>
> // Хотим написать много, поэтому сначала отформатируем наш текст
>
> $message = $ttfImg->textFormat(400, 500,
>
> "Хеллоуин (англ. Halloween) — преимущественно американский праздник, празднуется в ночь с 31 октября на 1 ноября.
>
>
>
> Также упоминается как «канун Дня всех святых». Праздник корнями уходит к старинному кельтскому празднеству Самайн.");
>
>
>
> // Пишем (чуть-чуть наклоним)
>
> $ttfImg->writeText(40, 100, $message, 5);
>
>
>
> // и вывод в файл
>
> $ttfImg->output('images/postcard.jpg');
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Ну собственно и результат:
Ну и на последок возможности применения:
1. Написать что-нибудь на картинке (подпись свою например)
2. Делать «гламурные заголовки» — когда некоторые тексты делаются красивыми картинками (в вордпрессе такое есть вроде)
3. CAPТCHA (просто нужно взять совершенно е\*\*нутый шрифт)
Пользуйтесь на здоровье!
*PS: Расчитано на кодировку UTF-8* | https://habr.com/ru/post/43744/ | null | ru | null |
# Поиск пути через NavMesh на ActionScript – CrossBridge-порт Recast Navigation
В этой статье я расскажу об опыте переноса C++ кода на ActionScript с помощью [FlasCC](http://www.adobe.com/devnet-docs/flascc/README.html) компилятора и покажу, как с его помощью мне удалось портировать довольно большой объем полезного кода, решающего задачу поиска пути. В конце будет демо и ссылка на репозиторий с кодом. А пока пара слов о том, с чего вообще все началось.
Я работаю над индипроектом. Это шутер с видом сверху (похоже на Crimsonland). Пишу проект на AS3. Игровое пространство непрерывно (не по клеточкам) и основано на физическом движке Nape. Непроходимые участки (стены) описываются набором выпуклых многоугольников. Возникает задача навигации агентов (монстров) по такой карте.
Какие вообще существуют идеи для решения такой задачи?
1. Пространство можно разбить на клетки и свести ее к задаче поиска пути на клетчатом поле. Для этого уже существуют готовые решения на Флеше. Но такой вариант мне не понравился тем, что он принуждает агента двигаться всегда из некоторой клетки в некоторую соседнюю. Еще это решение никак не учитывает размер агента, который может быть разным.
2. Можно построить граф проходимости. Если агент не может дойти до цели по прямой, то алгоритм находит ближайшие к агенту цели, пару узлов графа и строит между ними маршрут по графу. Такой подход я реализовал в своем проекте в качестве временного. Устроен он был так: в редакторе уровней задавались узлы (вэйпоинты), без указания связей. Во время загрузки уровня система определяла прямую проходимость между всевозможными парами узлов и таким образом задавала связи между ними. Это решение какое-то время меня устраивало, но вскоре стали раздражать некоторые недостатки:
— Размер агентов все еще никак не учитывался. Было бы здорово, чтобы на основе проходимости для агентов разного размера можно было строить ситуации в игре.
— Узлы приходится задавать в редакторе вручную. Неприятно, что вообще к этой теме приходится постоянно возвращаться. А от того как хорошо расставлены узлы зависит качество маршрутов.
— Маршруты получаются не оптимальными. Часто стала возникать ситуация, когда агент сначала идет «от цели» к ближайшему узлу и только от него начинает следование, т.к. других узлов в прямой проходимости не было.
— Агенты никак не учитывают существование друг друга. При движении толпы монстров, линейность их перемещения очень заметна и выглядит не реалистично.
3. Еще один подход – navigation mesh. Идея такая: проходимая область карты покрывается набором выпуклых многоугольников, примыкающих друг к другу. Внутри каждого многоугольника агент может перемещаться свободно. Это очень хорошее решение для моего случая, я стал искать, какие существуют инструменты на Флеше. Оказалось, что ничего в общем-то и нет. Но есть на C++. Набор инструментов называется [Recast Navigation](https://github.com/memononen/recastnavigation) – это довольно серьезная вещь и в ней есть абсолютно все необходимое. Справедливости ради отмечу, что на Гитхабе есть портированная через Алхимию демка Рекаста, но это лишь демка, использовать которую повторно не получится.
И тогда я понял, что мне это надо. Я стал думать, как мне перенести это на AS3. Отходя немного в сторону скажу, что до использования физического движка Nape, я пробовал использовать Box2D, который на Флеше есть в двух вариантах: переписанный на AS3 и портированный с помощью Алхимии. Переписанный на AS3 вариант обладал тем недостатком, что каждое изменение, будь то исправленная ошибка или новый функционал, требовал ручного перенесения соответствующего кода во Флеш-версию движка. В какой-то момент его просто забросили. А вот порт через Алхимию мне в принципе понравился. Кроме просто набора функций, повторяющих API оригинального движка, автор добавил набор AS3 классов-оберток для соответствующих классов и структур в C++. Таким образом, API во Флеш-версии скрывал от разработчика необходимость следить за передачей указатей, оперируя просто классами-обертками.
Решил портировать все через [CrossBridge](http://adobe-flash.github.io/crossbridge/) (бывш. Алхимия). CrossBridge — это среда, основанная на Cygwin, в которой имеется свой gcc компилятор. Компилятор называется FlasCC и на выходе он выдает ActionScript-байткод. Общий ход работы такой: Каждому методу в C++ сопоставляется метод в AS3, который максимально точно повторяет прототип C++ функции. Набор таких функций компилируется с помощью FlasCC в swc. Далее эта swc подключается к проекту, в котором создается другая swc с финальным API (с документацией), скрывающим от AS3-разработчика указатели, аллокейт памяти и т.д.
Как и оригинальный код, данный порт я решил сделать открытым. Весь код находится вот тут: [github.com/Rokannon/Crossbridge-Recast-Navigation](https://github.com/Rokannon/Crossbridge-Recast-Navigation)
Репозиторий с оригинальным кодом на C++ добавил в качестве подмодуля.
Небольшое демо того, что получилось, вы можете посмотреть тут:
[work.rokannon.com/navmesh\_demo](http://work.rokannon.com/navmesh_demo)
В панели справа необходимо выбрать исходный меш, описывающий геометрию уровня. Далее надо прокрутить панель вниз, нажать «Build» и подождать немного пока построится NavMesh. В панели слева есть два инструмента, демонстрирующие возможности тулсета: поиск пути и навигация толпы агентов.
Перенесены еще не все функции, но очень многие. Так что кодом уже можно пользоваться. Подписывайтесь на репозиторий, чтобы следить за обновлениями.
На этом официальная часть закончена. Спасибо за внимание. Если у кого-то возникли какие-то вопросы – спрашивайте.
Ну а далее, для тех, кому интересны тонкости реализации, я расписал приемы, которые использовал при портировании C++ кода в AS3.
#### Простейший пример
```
#include
// Функция, которую требуется портировать в AS3.
float testFunc(x:float, y:float)
{
return x + y;
}
void \_testFunc() \_\_attribute\_\_((used,
annotate("as3sig:public function internal\_testFunc(x:Number, y:Number):Number"),
annotate("as3package:ctest")));
void \_testFunc()
{
float x;
AS3\_GetScalarFromVar(x, x); // Первый аргумент это Си-переменная, второй - AS3.
float y;
AS3\_GetScalarFromVar(y, y);
AS3\_Return(x + y);
}
```
Запустив CrossBridge, такой код можно скомпилировать:
```
/cygdrive/c/Crossbridge_1.0.1/sdk/usr/bin/g++ "main.cpp" -emit-swc=ctest -o "out.swc"
```
В результате в получившейся swc будет функция internal\_testFunc(x:Number, y:Number):Number, выполняющая то же, что и testFunc в С++. Абсолютно все функции портированы по такому шаблону. Приставка internal\_ выбрана специально, т.к. полностью скрыть этот метод из финальной swc не получится.
#### Структуры
Данный класс используется в качестве базового для классов-оберток структур:
```
package ctest
{
use namespace c_internal;
public class CBase
{
c_internal var ptr:int;
public function alloc():Boolean
{
return false;
}
public function free():void
{
CModule.free(ptr);
}
}
}
```
На что здесь имеет смысл обратить внимание? Класс-обертка хранит адрес структуры или класса, который оборачивает. В AS3 нет указателей. Вместо них используется просто int. Переменная ptr должна быть доступна везде, кроме финального API, поэтому она скрыта специальным кастомным неймспейсом c\_internal.
Рассмотрим вот такую структуру в C++:
```
struct MyStruct
{
int x,
int y
};
```
Такой структуре в качестве класса-обертки будет соответствовать:
```
package ctest
{
use namespace c_internal;
public class MyStruct extends CBase
{
c_internal static var SIZE:int = 0;
c_internal static const OFFSET_X:int = offset(4);
c_internal static const OFFSET_Y:int = offset(4);
private static function offset(size:int):int
{
return (SIZE += size) - size;
}
public function get x():int
{
return CModule.read32(ptr + OFFSET_X);
}
public function set x(value:int):void
{
CModule.write32(ptr + OFFSET_X, value);
}
public function get y():int
{
return CModule.read32(ptr + OFFSET_Y);
}
public function set y(value:int):void
{
CModule.write32(ptr + OFFSET_Y, value);
}
public override function alloc():Boolean
{
ptr = CModule.alloc(SIZE);
return ptr != 0;
}
}
}
```
Здесь небольшой трикс позволяет в удобной форме посчитать отступы всех полей и в качестве бонуса получить размер структуры. Но есть один питфол, связанный с [memory alignment](http://www.geeksforgeeks.org/structure-member-alignment-padding-and-data-packing/): Грубо говоря, если данные не помещаются полностью в одно слово (4 байт), то их отступ должен быть кратен 4 байт. Например, структура:
```
struct ExampleStruct
{
char x,
char y,
int z
}
```
Расположится по байтам так: `X Y 0 0 Z Z Z Z`. И `sizeof(ExampleStruct)` равен 8, а не 6 байт.
#### Функции с указателями в аргументах
```
#include
void addNum(MyStruct\* s, int n)
{
s->x += n;
s->y += n;
}
void \_addNum() \_\_attribute\_\_((used,
annotate("as3sig:public function internal\_addNum(s\_ptr:int, n:int):void"),
annotate("as3package:ctest")));
void \_testFunc()
{
MyStruct\* s;
AS3\_GetScalarFromVar(s, s\_ptr);
int n;
AS3\_GetScalarFromVar(n, n);
addNum(s, n);
}
```
Чтобы скрыть от разработчика необходимость прокидывать указатель, в финальном API будет такая функция:
```
package ctest
{
use namespace c_internal;
public function addNum(s:MyStruct, n:int):void
{
internal_addNum(s.ptr, n);
}
}
```
#### Функции возвращающие указатель
```
#include
MyStruct\* sum(MyStruct\* s1, MyStruct\* s2)
{
s1->x += s2->x;
s1->y += s2->y;
return s1;
}
void \_sum() \_\_attribute\_\_((used,
annotate("as3sig:public function internal\_sum(s1\_ptr:int, s2\_ptr:int):int"),
annotate("as3package:ctest")));
void \_testFunc()
{
MyStruct\* s1;
AS3\_GetScalarFromVar(s1, s1\_ptr);
MyStruct\* s2;
AS3\_GetScalarFromVar(s2, s2\_ptr);
AS3\_Return(sum(s1, s2));
}
```
Поскольку обертка не хранит в себе никаких данных об оборачиваемой структуре\классе кроме адреса, удобно добавить ее в качестве необязательного аргумента в API-метод:
```
package ctest
{
use namespace c_internal;
public function sum(s1:MyStruct, s2:MyStruct, resultMyStruct:MyStruct = null):MyStruct
{
if (resultMyStruct == null)
{
resultMyStruct = new MyStruct();
}
resultMyStruct.ptr = internal(s1.ptr, s2.ptr);
return resultMyStruct;
}
}
```
Аналогичный прием используется для обращения к элементам массива. | https://habr.com/ru/post/233631/ | null | ru | null |
# Android Studio. Kotlin. Подключение Google календаря через Content Provider
Безысходность и отчаяние я испытывал много дней подряд, пытаясь "подключить" Google календарь к своему приложению. Так долго и так тяжело, как тогда, я не буксовал ни над одной фичей... Я сделал это! Прошло более двух месяцев, пока я и мои почти 200 активных пользователей не протестировали этот функционал в полной мере. Теперь я готов поделиться своим опытом, ибо в сети на русском языке (да и на английском тоже) я не нашел удовлетворяющее меня описание того, как работать с Google календарем через Content Provider.
Постановка задачи
-----------------
Я работаю над приложением "Учет клиентов для самозанятых". Мне необходимо было реализовать в нем возможность планирования встреч с клиентами. Я сразу остановил свой выбор на Google календаре, т.к. в своей профессиональной деятельности активно им пользуюсь. Более того, мне была важна возможность общего доступа к календарю и его синхронизация с облачным сервисом Google. Супруга у меня тоже самозанятая и нам очень удобно планировать нашу семейную жизнь, поделившись друг с другом доступами для чтения к календарю каждого.
Самое простое решение, когда необходим Google календарь - воспользоваться Интентом, с помощью которого можно запускать стандартное приложение Календарь, чтобы добавлять новые события. Мне это решение не подходило по нескольким причинам. Во-первых, помимо добавления событий, мне так же нужно их читать и редактировать. Во-вторых, мое приложение работало со своей локальной Базой Данных, содержащей конфиденциальную информацию (самозанятые коллеги психологи меня поймут), которую не хотелось бы выносить за пределы приложения. И тогда необходимо решать, как локальные данные синхронизировать с данными Google календаря. Вызовом стандартного приложения Календаря не обойтись.
Приложение должно само добавлять, редактировать и читать данные из Google календаря. Синхронизировать его с облаком, если это необходимо. Для этого Google предлагает воспользоваться контент провайдером (Content Provider). Излагать подробно теорию не буду, ибо я не профи, а любитель. Прошу заранее прощение за возможные неточности в изложении и косяки в коде. По мере необходимости буду давать ссылки на статьи, из которых сам черпал информацию.
Решение задачи
--------------
Я так понимаю, что доступ к Google календарю в смартфоне похож на доступ к Базе Данных. Точнее, сам Календарь и все, что в нем есть по сути хранится в таблицах, как данные в БД. При помощи Контент провайдера (Content Provider) можно осуществлять запросы в БД Календаря: сохранять, изменять или удалять данные - события, календари, напоминания... Подробнее можете ознакомиться с работой Контент провайдера по ссылке: <https://developer.android.com/guide/topics/providers/content-provider-basics>
### 1. Получаем доступ к Календарю
Как во многом, что находится вне приложения, сначала необходимо получить к этому доступ. Получение доступа состоит из двух частей:
#### 1.1. Указываем в манифесте необходимость доступа
```
```
Я на всякий случай запрашиваю доступ и на чтение, и на запись, хотя первое, возможно, делать и не обязательно.
#### 1.2. Просим пользователя разрешить доступ
Все функции, отвечающие за интеграцию приложения с Google календарем, я упаковал в отдельный класс CalManager, однако доступ у пользователя запрашиваю из MainActivity, т.к. возвращаемый пользователем ответ (ActivityResultCallback), я так понимаю, принимать и обрабатывать возможно только в ней.
```
private val calendarPermission = registerForActivityResult(
ActivityResultContracts.RequestMultiplePermissions()
) { map ->
if (
map[Manifest.permission.WRITE_CALENDAR] == true &&
map[Manifest.permission.READ_CALENDAR] == true
)
initCalendar()
else showAskWhyDialog()
}
private fun initCalendar() {
calManager = CalManager(this)
if(!calManager.checkPermission())
calendarPermission.launch(arrayOf(
Manifest.permission.WRITE_CALENDAR,
Manifest.permission.READ_CALENDAR
))
}
```
Для получения доступа я использую RequestMultiplePermissions контракт, который пришел на замену устаревшего onRequestPermissionsResult. Подробнее о нем можно прочесть здесь: <https://developer.android.com/training/permissions/requesting>
Если кратко, то сначала инициализирую переменную calendarPermission, с помощью которой регистрирую запрос разрешений к Календарю и определяю Callback, который выполнится, когда пользователь отреагирует на просьбу дать доступ. Если разрешения получены, то запускаю функцию initCalendar(), иначе спрашиваю у пользователя "В чем дело, неужели сложно разрешить мне элементарную вещь? :)" - showAskWhyDialog()
Мое приложение без доступа к Календарю не работает, поэтому в функции initCalendar() проверяю доступ и опять его запрашиваю. Функция calManager.checkPermission(), описанная в классе CalManager, выглядит следующим образом:
```
fun checkPermission(): Boolean {
return ContextCompat.checkSelfPermission(
context, Manifest.permission.WRITE_CALENDAR
) == PackageManager.PERMISSION_GRANTED
}
```
Не спрашивайте меня, почему я запрашиваю разрешения на чтение и запись в Календаре, а проверяю только запись... :)
#### 1.3. Настойчиво просим дать доступ к Календарю
Почему-то мой аппарат при попытке приложения запросить доступ повторно, если ранее пользователь отклонил запрос, игнорирует его, как-будто он поставил галочку "Больше не показывать", хотя ее нет в диалоговом окне. Поэтому, если пользователь сразу не дал доступ, то в диалоговом окне я доходчиво ему объясняю, в чем он не прав и направляю его в настройки смартфона, чтобы он дал доступ вручную.
```
private fun showAskWhyDialog() {
val builder = AlertDialog.Builder(this)
builder.setTitle(getString(R.string.cal_permission_deny_title))
.setMessage(R.string.cal_permission_deny_message)
.setCancelable(false)
.setPositiveButton(getText(R.string.cal_permission_deny_yes)) { dialog, id ->
// открываем настройки приложения, чтобы пользователь дал разрешение вручную
val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
val uri = Uri.fromParts("package", this.packageName, null)
intent.data = uri
getPermissionManually.launch(intent)
}
.setNegativeButton(getText(R.string.cal_permission_deny_no)) { dialog, id ->
finish()
}
val dlg = builder.create()
dlg.show()
}
```
А так выглядит переменная getPermissionManually, отвечающая за callBack:
```
private val getPermissionManually = registerForActivityResult(
ActivityResultContracts.StartActivityForResult()
) {
initCalendar()
}
```
Бесконечный цикл - пока не дашь доступ, дальше не пройдешь! No pasaran! :)
### 2. Выбираем или создаем календарь, в котором будем сохранять события
Далее я буду описывать функции, содержащиеся в классе CalManager, отвечающие в моем приложении за работу Календаря. В первую очередь необходимо выбрать или создать календарь.
#### 2.1. Получаем список доступных на смартфоне календарей
```
class ListCalendars {
var id : Long = 0
var name = ""
var accountName = ""
var accountType = ""
}
fun getCalendars(): ArrayList {
val calList = ArrayList()
if (checkPermission()) {
val projection = arrayOf(
Calendars.\_ID,
Calendars.NAME,
Calendars.ACCOUNT\_NAME,
Calendars.ACCOUNT\_TYPE
)
val selection = "${Calendars.CALENDAR\_ACCESS\_LEVEL} = ${Calendars.CAL\_ACCESS\_OWNER}"
val cursor: Cursor? = context.contentResolver.query(
Calendars.CONTENT\_URI,
projection,
selection,
null,
Calendars.\_ID + " ASC"
)
if (cursor != null) while (cursor.moveToNext()){
val calendar = ListCalendars()
calendar.id = cursor.getLong(0)
calendar.name = cursor.getStringOrNull(1) ?: ""
calendar.accountName = cursor.getString(2)
calendar.accountType = cursor.getString(3)
calList.add(calendar)
}
cursor?.close()
}
return calList
}
```
В каждой функции, на всякий случай, я проверяю, есть ли доступ к календарю. Не уверен, что это необходимо, но возможен такой вариант, когда пользователь даст доступ, а потом его попросит обратно, тогда приложение "вылетит" с ошибкой. Случай маловероятный, но лучше перестраховаться.
Как видите, получение списка календарей один в один похоже на запрос к Базе Данных. В переменной projection указываем нужные нам имена полей таблицы со списком календарей. В selection - описываем условие, указав только те календари, в которых пользователь считается полноправным владельцем. Потом осуществляем запрос (contentResolver.query) и берем результат из переменной cursor, сохраняя для каждого календаря его имя, аккаунт, тип аккаунта и id. На выходе имеем список календарей calList.
#### 2.2. Указываем календарь, в зависимости от размера списка
```
fun setCalendar(calList: ArrayList){
// определяем календарь
when (calList.size) {
1 -> {
setCalendarId(calList[0].id)
accountType = calList[0].accountType
accountName = calList[0].accountName
setCalendarVisibilityAndSync()
Toast.makeText(context, context.resources.getString(R.string.cal\_set\_lonely),
Toast.LENGTH\_LONG).show()
}
0 -> {
val newCalUri = createCalendar()
if (newCalUri != null) {
setCalendarId(ContentUris.parseId(newCalUri))
accountName = "customer\_accounting"
accountType = CalendarContract.ACCOUNT\_TYPE\_LOCAL
Toast.makeText(context, context.resources.getString(R.string.cal\_create\_success),
Toast.LENGTH\_LONG).show()
}
else Toast.makeText(context, context.resources.getString(R.string.cal\_create\_error),
Toast.LENGTH\_LONG).show()
}
else -> {
var isLocalCalendarExist = false
calList.forEach {
if (it.accountName == "customer\_accounting") isLocalCalendarExist = true
}
if (!isLocalCalendarExist) createCalendar()
chooseCalendar(calList)
}
}
}
```
Если календарь в списке один, то его и выбираем. Если нет ни одного календаря, то создаем новый. Если календарей больше одного, то проверяем, создан ли локальный календарь "customer\_accounting", создаем его, если нет и даем пользователю выбрать календарь. Назначение функции setCalendarVisibilityAndSync() я поясню далее.
Тут необходимо сказать, что в приложении можно создавать только локальный календарь. Его нельзя синхронизировать с облаком и просматривать события из него на разных устройствах. Подробнее о том, как работать с Google Календарем через свое приложение можно прочесть здесь: <https://developer.android.com/guide/topics/providers/calendar-provider>
#### 2.3. Создаем календарь, если это необходимо
```
fun createCalendar(): Uri? {
if (checkPermission()) {
val values = ContentValues().apply {
put(Calendars.ACCOUNT_NAME, "customer_accounting")
put(Calendars.ACCOUNT_TYPE, CalendarContract.ACCOUNT_TYPE_LOCAL)
put(Calendars.NAME, context.resources.getString(R.string.cal_local_name_calendar))
put(Calendars.CALENDAR_DISPLAY_NAME, context.resources.getString(R.string.cal_local_name_calendar))
put(Calendars.CALENDAR_COLOR, -0x10000)
put(Calendars.CALENDAR_ACCESS_LEVEL, Calendars.CAL_ACCESS_OWNER)
put(Calendars.OWNER_ACCOUNT, "customer_accounting")
put(Calendars.CALENDAR_TIME_ZONE, TimeZone.getDefault().id)
put(Calendars.SYNC_EVENTS, 1)
put(Calendars.VISIBLE, 1)
}
val builder: Uri.Builder = Calendars.CONTENT_URI.buildUpon()
builder.appendQueryParameter(Calendars.ACCOUNT_NAME, "customer_accounting")
builder.appendQueryParameter(
Calendars.ACCOUNT_TYPE,
CalendarContract.ACCOUNT_TYPE_LOCAL
)
builder.appendQueryParameter(CalendarContract.CALLER_IS_SYNCADAPTER, "true")
return context.contentResolver.insert(builder.build(), values)
} else return null
}
```
Не сразу я понял, что в поле CALENDAR\_TIME\_ZONE необходимо указывать не название Зоны в строке, а ее id числом. В остальном новый календарь добавляется, как новая строка в таблицу календарей. Единственное, на что стоит обратить внимание, - это переменная builder. Она, я так понимаю, отвечает за построение Uri - пути, по которому находится необходимое место для записи в таблицу календарей. При ее настройке я указываю дополнительный параметр CALLER\_IS\_SYNCADAPTER - true. Дело в том, что доступ к Календарю можно получить двумя способами: "как приложение" или "как адаптер синхронизации". У второго способа - возможностей больше и... (спойлер) без него у меня не получилось редактировать повторяющиеся события. Но об этом - далее. Подробнее про "адаптер синхронизации" - здесь: <https://developer.android.com/guide/topics/providers/calendar-provider#sync-adapter>
#### 2.4. Даем пользователю возможность выбрать календарь
```
private fun chooseCalendar(calList: ArrayList) {
// создаем массив названий календарей и заполняем его
var calendarNames : Array = emptyArray()
var calIndex = 0
calList.forEachIndexed { index, calendar ->
val subtitle = if (calendar.accountType == "LOCAL")
context.resources.getString(R.string.cal\_local\_message) else calendar.accountName
val name = calendar.name.ifEmpty { context.resources.getString(R.string.cal\_without\_name) }
val title = "$name\n($subtitle)"
calendarNames += title
if (calendar.id == calendarId) calIndex = index
}
val builder = AlertDialog.Builder(context)
builder.setTitle(context.resources.getString(R.string.cal\_choose\_cal))
.setCancelable(false)
.setSingleChoiceItems(calendarNames, calIndex) { dialog, index ->
calIndex = index
}
.setPositiveButton(context.resources.getText(R.string.OK)) { dialog, id ->
setCalendarId(calList[calIndex].id)
accountName = calList[calIndex].accountName
accountType = calList[calIndex].accountType
setCalendarVisibilityAndSync()
Toast.makeText(context,
"${context.resources.getString(R.string.cal\_chosen\_cal)} ${calendarNames[calIndex]}",
Toast.LENGTH\_LONG).show()
}
val dlg = builder.create()
dlg.show()
}
```
Для предоставления выбора я использую стандартное диалоговое окно AlertDialog. Перед его показом пользователю, создаю массив имен календарей calendarNames и указываю в переменной calIndex - индекс выбранного ранее календаря. Обратите внимание, что при выборе календаря помимо его id я еще в обязательном порядке сохраняю имя календаря, accountName и accountType. Эти поля необходимы для работы "адаптера синхронизации" (наберитесь терпения - об этом чуть дальше).
### 3. CRUD-операции с событиями Google календаря
Для новичков, типа меня поясню, что CRUD - это Create, Read, Update, Delete. Но в данном случае вместо Create идет Insert. С нее и начнем.
#### 3.1. Добавление нового события в Календарь
```
suspend fun insertEvent(
title: String,
_start: Long,
duration: Long,
_rrule: String = "",
until: String = ""): Long? = withContext(Dispatchers.IO) {
return@withContext if (checkPermission()) {
val timeZone = TimeZone.getDefault().id
val rrule = _rrule + until
val start = if (duration != 0L) _start else getAllDayStart(_start)
val end = if (duration != 0L) start + duration else start + 24 * 60 * 60 * 1000
val event = ContentValues().apply {
put(Events.CALENDAR_ID, calendarId) // ID календаря
put(Events.TITLE, title) // Название события
put(Events.DESCRIPTION, context.resources.getString(R.string.cal_local_name_calendar)) // указание принадлежности приложению
put(Events.EVENT_TIMEZONE, timeZone)
put(Events.EVENT_LOCATION, "")
put(Events.DTSTART, start) // время начала
put(Events.STATUS, Events.STATUS_CONFIRMED)
if (duration == 0L) put(Events.ALL_DAY, 1)
if (rrule.isNotEmpty()) {
put(Events.RRULE, rrule) // повторяемость
put(Events.DURATION, "P${duration/1000}S") // продолжительность
} else {
put(Events.DTEND, end) // время окончания
}
}
val eventUri = asSyncAdapter(Events.CONTENT_URI)
val uri = context.contentResolver.insert(eventUri, event)
syncCalendar()
uri?.lastPathSegment?.toLongOrNull()
} else null
}
fun getAllDayStart(_start: Long) : Long {
val cal = Calendar.getInstance()
cal.timeInMillis = _start
val cal2 = Calendar.getInstance()
cal2.clear()
cal2.timeZone = TimeZone.getTimeZone("UTC")
cal2.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH))
return cal2.timeInMillis
}
```
Все операции с Календарем лучше осуществлять в "фоновом" (асинхронном) режиме, чтобы интерфейс приложения не подтормаживал. Google рекомендует для этого использовать AsyncQueryHandler (подробнее см. [https://developer.android.com/reference/android/ content/AsyncQueryHandler](https://developer.android.com/reference/android/content/AsyncQueryHandler)). Я не стал, уж очень мне показался он чересчур замысловатым. Запускаю функции работы с Календарем при помощи Корутин (<https://developer.android.com/kotlin/coroutines>) в параллельном потоке. Я привык так работать с Базой Данных.
Повторять то, что уже написано о добавлении событий в статье "Calendar provider overview" (<https://developer.android.com/guide/topics/providers/calendar-provider>) не буду. Расскажу лишь о тех "граблях", на которые наступал я сам, когда писал и отлаживал код и своих "фишках".
1. **timeZone** - как и при добавлении календаря, так и при добавлении события - id типа Int, а не String, будьте внимательны!
2. **rrule**, который отвечает за правила повторяемости события, в моем случае, удобнее было разбить на две части: непосредственно правило и указание, до каких пор работает повторяемость. Это удобно впоследствии, когда повторяющиеся события будут редактироваться.
3. **start и end**. Мне показалось удобным для тех записей в календаре, которым пользователь не указывает длительность (duration), создавать события целого дня. Тогда необходимо изменять им начало и конец, указывая полночь заданного дня и полночь + 24 часа. Ну и поле Events.ALL\_DAY устанавливать в 1.
4. **Events.DESCRIPTION**. Это единственное поле в записи события в календаре, где можно, как я понял, сохранить некий текст, указывающий принадлежность события моему приложению. У меня это - "Учет клиентов" (название приложения).
5. **rrule.isNotEmpty()**. Черным по белому написано: если указываете повторяемость события в rrule, то вместо end - duration! Но кто подробно читает мануал? Точно не я. Будьте внимательны!
Объяснение концовки кода про функции asSyncAdapter() и syncCalendar() пока опускаю. Продолжаю держать интригу. Ибо для меня эта "жара" стоила 2 недель пота и слез! Две недели, Карл!!!
#### 3.2. Изменение существующего события
```
suspend fun updateEvent(
eventId: Long,
title: String,
_start: Long,
duration: Long,
_rrule: String = "",
until: String = ""): Boolean = withContext(Dispatchers.IO){
return@withContext if(checkPermission()) {
val rrule = _rrule + until
val start = if (duration != 0L) _start else getAllDayStart(_start)
val end = if (duration != 0L) start + duration else start + 24 * 60 * 60 * 1000
val event = ContentValues().apply {
if (title.isNotEmpty()) put(Events.TITLE, title) // Название события - Имя клиента?
if (start != 0L) put(Events.DTSTART, start) // время начала
put(Events.ALL_DAY, if (duration == 0L) 1 else 0)
if (rrule.isNotEmpty()) {
put(Events.RRULE, rrule) // повторяемость
if (duration != 0L) put(Events.DURATION, "P${duration/1000}S") // продолжительность
} else {
put(Events.DTEND, end) // время окончания
}
}
val eventUri = Events.CONTENT_URI
val row = context.contentResolver.update(
eventUri,
event,
"${Events._ID} = $eventId",
null
)
syncCalendar()
row == 1
} else false
}
```
Не спрашивайте меня, почему в случае **update** в отличие от **insert** я не использую "адаптер синхронизации". Может быть, с ним хуже работало, а может, я его убрал по каким-то для меня самого не ведомым причинам. Не знаю. Мне до сих пор не очень понятно, как он работает, но без него никак... В моем случае - никак! Подробнее расскажу ниже. А пока, вроде бы, пояснять в коде больше нечего. Изменяем событие по единственному условию - "${Events.\_ID} = $eventId" посему должна измениться лишь одна строка таблицы, т.е. успешный исход изменений - row == 1 (true).
#### 3.3. Удаление события из Календаря
```
suspend fun deleteEvent(eventId: Long): Boolean = withContext(
Dispatchers.IO) {
return@withContext if (checkPermission()) {
//val eventUri = asSyncAdapter(Events.CONTENT_URI)
val eventUri = Events.CONTENT_URI
val row = context.contentResolver.delete(
eventUri,
"${Events._ID} = $eventId",
null
)
syncCalendar()
row == 1
} else false
}
```
Здесь также, как и в случае **update**, я не использую "адаптер синхронизации". Знатоки, подскажите в комментариях, как поступать правильно? Где его использовать, а где - нет, я, видимо, определял опытным путем. Про функцию syncCalendar() я напишу ниже.
#### 3.4. Чтение событий Календаря
```
class ListEvents {
var eventId : Long = 0
var newEventId : Long = 0
var title = ""
var start : Long = 0
var begin : Long = 0
var end : Long = 0
var duration : Long = 0
var rrule = ""
}
suspend fun readEventsListOfDay(
day: LocalDate): ArrayList = withContext(
Dispatchers.IO) {
val dataList = ArrayList()
if (checkPermission()) {
val calDate = Calendar.getInstance()
calDate.timeZone = TimeZone.getDefault()
calDate.set(day.year, day.monthValue - 1, day.dayOfMonth, 0, 0, 0)
val start = calDate.timeInMillis
calDate.add(Calendar.HOUR, 24)
val end = calDate.timeInMillis
val titleCol = CalendarContract.Instances.TITLE
val startCol = CalendarContract.Instances.DTSTART
val endCol = CalendarContract.Instances.END
val idCol = CalendarContract.Instances.EVENT\_ID
val beginCol = CalendarContract.Instances.BEGIN
val rruleCol = CalendarContract.Instances.RRULE
val projection = arrayOf(titleCol, startCol, endCol, idCol, beginCol, rruleCol)
val selection = "${Events.DELETED} != 1 " + // исключаем удаленные события
"AND ${Events.DESCRIPTION} = '${context.resources.getString(R.string.cal\_local\_name\_calendar)}' " + // выбираем только те события, которые созданы приложением
"AND ${Events.CALENDAR\_ID} = $calendarId " +
"AND $beginCol > $start "
val order = "$beginCol ASC"
val eventsUriBuilder = CalendarContract.Instances.CONTENT\_URI
.buildUpon()
ContentUris.appendId(eventsUriBuilder, start)
ContentUris.appendId(eventsUriBuilder, end)
val eventsUri = eventsUriBuilder.build()
val cursor = context.contentResolver.query(
eventsUri,
projection,
selection,
null,
order
)
if (cursor != null) while (cursor.moveToNext()) {
val item = ListEvents()
item.eventId = cursor.getLongOrNull(cursor.getColumnIndex(idCol)) ?: 0
item.title = cursor.getStringOrNull(cursor.getColumnIndex(titleCol)).orEmpty()
item.begin = cursor.getLongOrNull(cursor.getColumnIndex(beginCol)) ?: 0
item.start = cursor.getLongOrNull(cursor.getColumnIndex(startCol)) ?: 0
item.end = cursor.getLongOrNull(cursor.getColumnIndex(endCol)) ?: 0
item.rrule = cursor.getStringOrNull(cursor.getColumnIndex(rruleCol)).orEmpty()
dataList.add(item)
}
cursor?.close()
}
return@withContext dataList
}
```
Здесь уже плавно перехожу к описанию самого сложного для моего понимания - к работе с повторяющимися событиями (**reccurent events**). С ними я намаялся больше всего! Особенно в свете того, что в моем приложении мне необходимо было синхронизировать работу внутренней Базы Данных и Календаря.
Все события, как одиночные, так и повторяющиеся, записываются в таблицу **Events**. Для указания повторяемости события, как вы уже поняли, используются поля **rrule** и **duration**. А для того, чтобы прочитать события в некотором интервале времени, с учетом их повторяемости, делается запрос в таблицу **Instances**. В переменной **eventsUriBuilder** как раз указывается интервал времени (от **start** до **end**), из которого выбираются все входящие в него события.
Обратите внимание, что в таблице **Instances** у событий несколько иные поля. **BEGIN** и **END** - начало и конец отдельного события из серии повторяющихся событий или начало и конец одиночного события. **EVENT\_ID** - id исходного события, которое задает серию повторяющихся событий или id одиночного события. **DTSTART** - начало первого события серии или начало одиночного события. В случае одиночного события **DTSTART = BEGIN**.
В остальном, как видите, чтение событий из Календаря ничем не отличается от запроса из Базы Данных. В **projection** даем массив необходимых нам полей. В **selection** - формулируем условия. Подробнее можете прочесть здесь: [https://developer.android.com/guide/topics/ providers/calendar-provider#instances](https://developer.android.com/guide/topics/providers/calendar-provider#instances)
### 4. Повторяющиеся события в Календаре
Начинается "моя боль". Добавлять повторяющиеся событие не сложнее, чем одиночные. Как читать данные из таблицы Instances, где отображаются события из серии повторяющихся, входящих в заданный интервал, разобрался довольно быстро. Но редактирование и удаление - боль, боль, боль...
Сначала я пытался указывать исключения в поле EXRULE или EXDATE - ничего хорошего из этого не получалось. Я так и не понял, для чего оно нужно, если не работает! Потом для того, чтобы удалить одно событие из серии повторяющихся или изменить его, я добавлял новое событие в таблицу исключений - эпик фэйл! Работало это крайне плохо. События редактировались или удалялись, но потом появлялись вновь, как будто в смартфоне "кто-то" проводит ревизию и все возвращает на свои места. При этом, если добавить новое повторяющееся событие, подождать приличное время и только потом его редактировать или удалять, то все работает нормально.
После двух недель мытарств и хождения по мукам (гугля все, что удавалось найти в интернете), я понял, что дело в синхронизации. Нельзя редактировать или удалять одно событие из серии повторяющихся, пока они не будут синхронизированы с облаком. Посему я задался этим вопросом и понял, что необходимо подключать приложение к Календарю, "как адаптер синхронизации" и синхронизировать календарь вручную сразу после добавления нового события.
#### 4.1. Адаптер синхронизации и синхронизация Календаря
```
private fun setCalendarVisibilityAndSync() {
val values = ContentValues()
values.put(Calendars.SYNC_EVENTS, 1)
values.put(Calendars.VISIBLE, 1)
val uri = asSyncAdapter(ContentUris.withAppendedId(Calendars.CONTENT_URI, calendarId!!))
context.contentResolver.update(uri, values, null, null)
}
private fun asSyncAdapter(uri: Uri): Uri {
return uri.buildUpon()
.appendQueryParameter(CalendarContract.CALLER_IS_SYNCADAPTER, "true")
.appendQueryParameter(Calendars.ACCOUNT_NAME, accountName)
.appendQueryParameter(Calendars.ACCOUNT_TYPE, accountType).build()
}
private fun syncCalendar() {
val account = Account(accountName, accountType)
val extras = Bundle()
extras.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true)
val authority = Calendars.CONTENT_URI.authority
ContentResolver.requestSync(account, authority, extras)
}
```
Функцию setCalendarVisibilityAndSync() в обязательном порядке запускаю для того Календаря, в который собираюсь сохранять сообщения. Она "включает" Календарю поля SYNC\_EVENTS и VISIBLE.
Функция asSyncAdapter() добавляет к Uri параметры ACCOUNT\_NAME, ACCOUNT\_TYPE и указывает CALLER\_IS\_SYNCADAPTER - true.
Функция syncCalendar() запускает синхронизацию Календаря. Ее я запускаю каждый раз, сразу после внесения в календарь изменений. Тогда и только тогда не возникает ошибок при редактировании и удалении повторяющихся событий.
#### 4.2. Редактирование или удаление одного из серии повторяющихся событий
```
suspend fun deleteOneRecurrentEvent(eventId: Long, begin: Long): Long? = withContext(
Dispatchers.IO) {
return@withContext updateRecurrentEvent(eventId, begin)
}
private suspend fun updateRecurrentEvent(
eventId: Long,
begin: Long,
newDate: Long = 0L): Long? = withContext(Dispatchers.IO) {
return@withContext if (checkPermission()) {
val event = ContentValues().apply {
put(Events.ORIGINAL_INSTANCE_TIME, begin)
if (newDate == 0L) put(Events.STATUS, Events.STATUS_CANCELED)
else put(Events.DTSTART, newDate)
}
val eventUri = ContentUris.withAppendedId(CONTENT_EXCEPTION_URI, eventId)
//val eventUri = asSyncAdapter(ContentUris.withAppendedId(CONTENT_EXCEPTION_URI, eventId))
val uri = context.contentResolver.insert(eventUri, event)
syncCalendar()
uri?.lastPathSegment?.toLongOrNull()
} else null
}
```
Для того, чтобы изменить одно событие из серии повторяющихся, необходимо в таблицу исключений (CONTENT\_EXCEPTION\_URI) добавить новое событие. В нем обязательно необходимо указать поле ORIGINAL\_INSTANCE\_TIME - начало того события серии, которое хотим изменить. Если я хочу не изменить, а удалить его, то вместо параметра newDate указываю - ноль. Тогда добавляемому событию в таблице исключений, указываю статус - STATUS\_CANCELED.
Опытным путем обнаружено, что добавлять новое событие в таблицу исключений лучше не используя "адаптер синхронизации", но в обязательном порядке сразу после добавления необходимо синхронизировать календарь - syncCalendar().
#### 4.3. Удаление всех последующих повторяющихся событий серии
```
suspend fun deleteAllRecurrentEvents(
eventId: Long,
begin: Long,
start: Long,
duration: Long,
rrule: String): Boolean = withContext(Dispatchers.IO) {
return@withContext if (checkPermission()) {
val until = fHelper.dateTimeFormatter(
context.resources,
begin - 23*60*60*1000,
Const.RFC5545
)
updateEvent(eventId, "", start, duration, rrule, until)
} else false
}
```
В моем приложении нет возможности изменять все последующий события серии, только удалять. По сути, удаление некоторого события серии заключается в изменении исходного события (updateEvent). Я добавляю в правило повторения ограничение его действия через until. Функция dateTimeFormatter форматирует дату события в форме RFC5545 - *YYYYMMDD*T*HHMMSS*Z. Подробнее здесь: <https://datatracker.ietf.org/doc/html/rfc5545#section-3.8.5.2>
Итоги
-----
Очень может быть, код у меня получился не идеальный. Однозначно, я не до конца понимаю, как оно работает. Но практика показывает, что все с ним в порядке. Буду рад прочесть ваши комментарии. И надеюсь, этот гайд будет кому-нибудь полезен. Я ничего подобного в сети не нашел. | https://habr.com/ru/post/664876/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.