text
stringlengths 20
1.01M
| url
stringlengths 14
1.25k
| dump
stringlengths 9
15
⌀ | lang
stringclasses 4
values | source
stringclasses 4
values |
|---|---|---|---|---|
# Запись WebRTC видеопотока с веб-камеры браузера с буксировкой на Amazon S3
**Amazon S3** — это файловое облачное хранилище, которое используют такие известные сервисы как Dropbox, Trello и миллионы других проектов. Несмотря на сбой 28 февраля 2017 года, в результате которого кое-где перестали работать даже холодильники, S3 остается, пожалуй, самым популярным распределенным хранилищем, в котором пользователи и бизнес хранят фотки, видео, бэкапы и другой полезный контент.
**Web Call Server** — это медиасервер с поддержкой технологии WebRTC и записи видеопотоков из браузеров и мобильных устройств. HTML страница в браузере или мобильное приложение может захватить видеопоток с веб-камеры и отправить на сервер для дальнейшей ретрансляции и записи.
В этой статье мы расскажем как записать видеопоток со страницы браузера Google Chrome с последующей отправкой mp4-файла в хранилище Amazon S3.
Подготовка хранилища S3
-----------------------
C хранилищем S3 все получилось довольно быстро, т.к. Был готовый AWS аккаунт. Для того чтобы начать работать с хранилищем, создаем **Bucket** — это виртуальная папка-путь, в которую будут складываться файлы.
Заходим в S3 и жмем **Create Bucket**
Выбираем регион EU (Frankfurt) и одного юзера (самого себя) с правами на read и write.
Далее предлагается включить разные опции. Но нам требовалась простая запись. Поэтому все опции оставили в состоянии **Disabled**.
Далее нужно определиться с правами доступа. Их тоже оставляем по-умолчанию.
Готово. Осталось все проверить и нажать **Next**.
Таким образом, за 4 шага мы сделали облачное хранилище S3, в которое можно лить фотографии, бэкапы, и многое другое.
Запись видеопотока из браузера
------------------------------
Видеопоток транслируется на сервер с **HTML / JavaScript** страницы и записывается на сервере в формате **mp4**.
На скриншоте происходит соединение с сервером по протоколу wss (Websockets SSL) и далее WebRTC видеопоток отправляется на сервер и показывает статус PUBLISHING.
Если нажать кнопку **Stop**, то трансляция потока прекратится, а на сервере будет записан mp4-файл, который можно тут же скачать по ссылке **Download recorded stream**
Скачанный файл можно проиграть в обычном плеере. Например **VLC**.
Его также можно найти на сервере в папке **/usr/local/FlashphonerWebCallServer/records**
Тестируем выгрузку на S3
------------------------
Для начала научимся заливать файлы в S3 обычным **bash-скриптом**. В дальнейшем вы можете выбрать более удобный способ и использовать специальные утилиты от AWS.
Погуглив мы нашли два скрипта для загрузки файлов на Amazon S3: [первый](https://gist.github.com/chrismdp/6c6b6c825b07f680e710) и [второй](https://raw.githubusercontent.com/wachtelbauer/linux-shell-scripts/master/S3-AWS4-Upload.sh).
C первым возникли проблемы, а именно:
**The authorization mechanism you have provided is not supported. Please use AWS4-HMAC-SHA256.**
Второй скрипт решает проблему аутентификации, поэтому остановились на нем. Скрипт пришлось совсем немного модифицировать и его модифицированная версия находится [здесь](https://flashphoner.com/downloads/examples/upload-file-to-amazon-s3-AWS4-HMAC-SHA256.tar.gz).
Модифицированный скрипт работает так:
```
./S3-AWS4-Upload.sh /tmp/11/hellos3.txt
```
Т.е. просто отправляет указанный файл в хранилище.
**Небольшие правки, которые были сделаны:**
1. Принимаем путь к файлу в качестве аргумента
```
FILE_TO_UPLOAD=$1
STARTS_WITH=$(basename $FILE_TO_UPLOAD)
```
2. Обозначаем рабочую папку и берем ACCESS KEY и SECRET KEY из этой папки
```
WORK_DIR=/tmp/11
AWS_SECRET_KEY=$(cat $WORK_DIR/AWS_SECRET_KEY)
AWS_ACCESS_KEY=$(cat $WORK_DIR/AWS_ACCESS_KEY)
```
3. Отодвигаем дату подальше в будущее
```
EXPIRE="2018-01-01T00:00:00.000Z"
```
4. Добавляем в путь регион .$REQUEST\_REGION
```
-F "file=@"$FILE_TO_UPLOAD http://$BUCKET.s3.$REQUEST_REGION.amazonaws.com/
```
Таким образом, в нашей рабочей папке сейчас хранится 4 файла, два из которых ключи, и файл **hellos3.txt** для тестовой отправки.
/tmp/11
├── AWS\_ACCESS\_KEY
├── AWS\_SECRET\_KEY
├── hellos3.txt
└── S3-AWS4-Upload.sh
Ключи можно сгенерировать в меню Account — **My Security Credentials**
Сами ключи выглядят так:
**Access Key ID:**
BPIAI3TGFDI3ZPTABBIA
**Secret Access Key:**
RPnmmrUf5FOPs2as4XghOMfsbkatqSdUO16Um91r
В результате успешной работы скрипта, получаем файл hellos3.txt загруженным на S3. Отсюда можно его уже можно скачать, раздать, и т.д.
В результате мы успешно протестировали выгрузку файла на S3 обычным bash-скриптом и можем отправить на S3 любой файл, если у нас есть его полный путь.
Дергаем hook и отправляем записанный видеопоток на Amazon S3
------------------------------------------------------------
После нажатия кнопки Stop, происходит остановка отправки потока на сервер и на сервере создается файл mp4.
Далее сервер вызывает bash-скрипт **on\_record\_hook.sh** и передает этому скрипту путь к файлу **вторым параметром**.
```
/usr/local/FlashphonerWebCallServer/bin/on_record_hook.sh
```
Поменяем скрипт так, чтобы он **отправлял записанный файл на Amazon S3** и писал сообщение в лог для отладки:
```
STREAM_NAME=$1
FILE_PATH=$2
cd /tmp/11
./S3-AWS4-Upload.sh $FILE_PATH &&
echo "Record complete. Sent to S3. $FILE_PATH" >> /tmp/log.txt
```
В результате к списку файлов добавляется **mp4-файл**, который можно скачать, теперь уже с S3 и посмотреть.
Минимальный HTML / JS код для записи видеопотока
------------------------------------------------
На HTML странице главный элемент — это окно захвата видео **localVideo**. Это простой div-блок, в котором отображается видео, захваченное с веб-камеры.
Страница **stream-recording.html**
```
The streamer
============
```
Скрипт **stream-recording.js** состоит из 48 строк.
```
var localVideo;
var stream;
function init(){
Flashphoner.init();
localVideo = document.getElementById("localVideo");
}
function stop(){
stream.stop();
}
function start() {
Flashphoner.createSession({urlServer: "wss://wcs5-eu.flashphoner.com:8443"}).on(Flashphoner.constants.SESSION_STATUS.ESTABLISHED, function (session) {
//session connected, start streaming
startStreaming(session);
}).on(Flashphoner.constants.SESSION_STATUS.DISCONNECTED, function () {
setStatus("DISCONNECTED");
}).on(Flashphoner.constants.SESSION_STATUS.FAILED, function () {
setStatus("FAILED");
});
}
function startStreaming(session) {
stream = session.createStream({
name: "stream222",
display: localVideo,
cacheLocalResources: true,
receiveVideo: false,
receiveAudio: false,
record: true
});
stream.on(Flashphoner.constants.STREAM_STATUS.PUBLISHING, function (publishStream) {
setStatus(Flashphoner.constants.STREAM_STATUS.PUBLISHING);
}).on(Flashphoner.constants.STREAM_STATUS.UNPUBLISHED, function (stream) {
setStatus(Flashphoner.constants.STREAM_STATUS.UNPUBLISHED + " " + stream.getRecordInfo());
}).on(Flashphoner.constants.STREAM_STATUS.FAILED, function () {
setStatus(Flashphoner.constants.STREAM_STATUS.FAILED);
});
stream.publish();
}
function setStatus(status) {
document.getElementById("status").innerHTML = status;
}
```
В скрипте устанавливается соединение с сервером и начинается захват с веб-камеры и публикация потока на сервер по кнопке **Start**. По кнопке **Stop** поток завершает публикацию и отображается имя записанного файла.
1) Устанавливаем соединение с сервером с помощью **Flashphoner.createSession()**
```
Flashphoner.createSession({urlServer: "wss://wcs5-eu.flashphoner.com:8443"});
```
2. Создаем видеопоток с функцией записи: **record: true** и отправляем видеопоток на сервер методом **stream.publish()**
```
session.createStream({
name: "stream222",
display: localVideo,
cacheLocalResources: true,
receiveVideo: false,
receiveAudio: false,
record: true
}).publish();
```
3. Отображаем имя mp4-файла на окончание трансляции и статус UNPUBLISHED
```
stream.on(Flashphoner.constants.STREAM_STATUS.UNPUBLISHED, function (stream) {
setStatus(Flashphoner.constants.STREAM_STATUS.UNPUBLISHED + " " + stream.getRecordInfo());
});
```
Итого для успешного стриминга и записи видеопотока необходимо три файла:
* stream-recording.html
* stream-recording.js
* flashphoner.js
Скрипты можно скачать [здесь](https://flashphoner.com/downloads/examples/stream-recording-0.5.18.1977-5.0.2174.zip).
Файл flashphoner.js можно найти в составе [Web SDK](https://flashphoner.com/wcs-web-sdk) для WCS.
Тестируем код записи видеопотока
--------------------------------
Процесс записи в браузере Google Chrome со страницы **stream-recording.html** выглядит так:
После остановки видеопотока получаем имя записанного файла в формате mp4.
Этот файл доступен на сервере в папке **/usr/local/FlashphonerWebCallServer/records**
Кроме того, если мы правильно оформили скрипт **on\_record\_hook.sh**, то этот же файл будет выгружен в **Amazon S3**.
Таким образом, мы создали хранилище в Amazon S3, протестировали простой bash скрипт для загрузки файлов в хранилище и написали HTML + JS код, который захватывает видеопоток с веб-камеры и записывает на сервер с последующей передачей в S3.
Ссылки
------
[Amazon S3](https://aws.amazon.com/ru/s3/) — облачное хранилище файлов
[S3-AWS4-Upload.sh](https://raw.githubusercontent.com/wachtelbauer/linux-shell-scripts/master/S3-AWS4-Upload.sh) — исходный bash-скрипт для загрузки файла в хранилище
[S3 full](https://flashphoner.com/downloads/examples/upload-file-to-amazon-s3-AWS4-HMAC-SHA256.tar.gz) — полный набор модифицированных файлов для выгрузки в Amazon S3.
[Stream recording](https://flashphoner.com/downloads/examples/stream-recording-0.5.18.1977-5.0.2174.zip) — html и js скрипты для трансляции на сервер и записи из браузера.
[Web SDK](https://flashphoner.com/wcs-web-sdk) — набор скриптов js для работы с видеопотоками. Содержит flashphoner.js, который используется в примере.
[Web Call Server](https://flashphoner.com) — WebRTC медиасервер с поддержкой записи видеопотоков из браузера. | https://habr.com/ru/post/326720/ | null | ru | null |
# «Правильное» ограничение скорости в Nginx. Миф или реальность?
Вот уже много лет пользователей Nginx мучает один и тот же вопрос: «Как можно ограничить скорость в целом для IP адреса независимо от числа сессий (соединений)? Почему Nginx этого не умеет? Почему разработчики Nginx так упорно не хотят реализовать этот простой функционал?» И ответить мне им нечего, о чём думают разработчики Nginx — не понятно и известно, наверное, только господу богу.
Бороться с этим можно по разному, кто-то использует скрипты на подобие [htb.init](http://habrahabr.ru/post/88624/), кто-то пишет скрипты шейпинга самостоятельно и [делится удачным опытом на Хабре](http://habrahabr.ru/post/119611/), а некоторые и вовсе [используют PHP](http://habrahabr.ru/post/51442/) для ограничения скорости отдачи файлов. Только представьте себе, каким будет оверхед и расход памяти, при использовании PHP в подобных целях.
На данный момент Nginx не умеет ограничивать скорость для IP и делает это только в рамках отдельных сессий. Что это означает? Если администратор установил в конфиге ограничение скорости в 100 Кбайт/сек, то создав 10 соединений с сервером можно получить скорость в 1 Мбайт/сек, что никак не вписывается в планы администратора. Достичь желаемого средствами самого Nginx можно лишь установив лимит, например
```
http {
limit_conn_zone $binary_remote_addr zone=perip:10m;
server {
location /download/ {
limit_conn perip 1;
}
}
}
```
который не даст создать более 1-го соединения с отдельно взятого IP адреса. Однако на практике использование такого ограничения на сервере имеет мало смысла, ведь за одним IP адресом могут скрываться тысячи пользователей, а при нестабильном сетевом подключении пользователь вообще рискует не получить доступ к файлу.
Но, как оказалось, не всё так мрачно и выход из ситуации есть. Это простой маленький модуль от **yaoweibin** под названием [nginx\_limit\_speed\_module](https://github.com/yaoweibin/nginx_limit_speed_module). Давайте рассмотрим как работает этот модуль:
```
http {
limit_speed_zone one $binary_remote_addr 10m;
server {
location /download/ {
limit_speed one 100k;
}
}
}
```
Директива limit\_speed задаёт суммарную скорость для всех подключений с одного IP адреса. Например, если установлен лимит скорости в 100 Кбайт/сек, а пользователь при этом качает файл в 10 потоков, то скорость скачивания для каждого отдельно взятого потока составит 10 Кбайт/сек (100k/10). Заметьте, это без всяких танцев с шейпингом в Linux и извращений с использованием PHP. Удобно, просто и понятно. На мой взгляд именно так и должно быть, но почему-то этого до сих порт нет в Nginx «из коробки» за что мне хотелось бы кинуть большой такой камешек в огород Nginx.
Для сборки Nginx с этим замечательным модулем достаточно добавить в параметры ./configure такую запись:
`--add-module=/путь до папки с модулем/nginx_limit_speed_module`
Например:
`./configure --prefix=/etc/nginx --sbin-path=/usr/sbin/nginx --conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --pid-path=/var/run/nginx.pid --lock-path=/var/run/nginx.lock --http-client-body-temp-path=/var/cache/nginx/client_temp --http-proxy-temp-path=/var/cache/nginx/proxy_temp --http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp --http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp --http-scgi-temp-path=/var/cache/nginx/scgi_temp --user=nginx --group=nginx --with-http_ssl_module --with-http_realip_module --with-http_addition_module --with-http_sub_module --with-http_dav_module --with-http_flv_module --with-http_mp4_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_random_index_module --with-http_secure_link_module --with-http_stub_status_module --with-http_auth_request_module --with-file-aio --with-ipv6 --with-http_spdy_module --add-module=/root/nginx_limit_speed_module --with-cc-opt='-O2 -g -pipe -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector --param=ssp-buffer-size=4 -m64 -mtune=generic'`
Подробно останавливаться на сборке Nginx я не буду, на этому тему уже написано немало статей. В качестве краткого руководства по сборке можно использовать [эту инструкцию](http://goo.gl/8PbvpK).
Страница модуля на GitHub: <https://github.com/yaoweibin/nginx_limit_speed_module> | https://habr.com/ru/post/226975/ | null | ru | null |
# Пошаговый запуск программы в Linux x86, или как добраться до main()?
[](https://habr.com/ru/company/ruvds/blog/588102/)
Статья предназначена для тех, кто хочет понять процесс загрузки программ в Linux. В частности, здесь пойдет речь о динамической загрузке файлов ELF x86. На основе изложенной информации вы сможете лучше понять, как устранять проблемы, возникающие в программе еще до запуска `main`.
Весь этот материал является актуальным, но кое-какие моменты в нем были опущены, так как к основной цели отношения не имеют. Кроме того, если вы выполняете линковку статически, то некоторые нюансы будут отличаться. Все эти детали я разбирать не стану, но к завершению вы будете знать достаточно, чтобы разобраться самостоятельно.
Вот предстоящий нам маршрут:
*Схема получена с помощью dot-фильтра, используемого для рисования направленных графов*
К концу статьи вам все это станет понятно.
### Как мы попадаем в main?
Мы соберем простейшую программу Си с пустой функцией`main`, а затем рассмотрим ее дизассемблированную версию, чтобы понять весь путь запуска. В ходе этого процесса вы увидите, что первым делом выполняется линкуемая с каждой программой функция `_start`, которая в конечном итоге приводит к выполнению `main`.
```
int
main()
{
}
```
Если хотите, можете сохранить копию этой программы как `prog1.c` и повторять за мной. Первым делом я выполню ее сборку:
```
gcc -ggdb -o prog1 prog1.c
```
Прежде, чем переходить к отладке последующей версии этой программы (`prog2`) в `gdb`, мы ее дизассемблируем и узнаем некоторые детали о процессе запуска. Я покажу вам вывод `objdump -d prog1`, но не в порядке фактического вывода, а в порядке его выполнения. (В идеале вам следует сделать это самим. Например, сохранить копию с помощью `objdump -d prog1 >prog1.dump`, чтобы потом просмотреть ее в привычном редакторе).
### Для начала разберемся, как мы попадаем в \_start
При запуске программы оболочка или GUI вызывают `execve()`, которая выполняет системный вызов `execve()`. Если вы хотите побольше узнать об этом системном вызове, то просто введите в оболочке `man execve`. Он находится в разделе 2 мануала вместе со всеми остальными системными вызовами. Если кратко, то он настраивает стек и передает в него `argc`, `argv` и `envp`.
Дескрипторы файлов `0`, `1` и `2` (`stdin`, `stdout`, `stderr`) остаются со значениями, установленными для них оболочкой. Загрузчик проделывает много работы, настраивая релокации и, как мы увидим позднее, вызывая пре-инициализаторы. Когда все готово, управление передается программе через вызов `_start()`.
Вот соответствующий раздел `objdump -d prog1`:
```
080482e0 <_start>:
80482e0: 31 ed xor %ebp,%ebp
80482e2: 5e pop %esi
80482e3: 89 e1 mov %esp,%ecx
80482e5: 83 e4 f0 and $0xfffffff0,%esp
80482e8: 50 push %eax
80482e9: 54 push %esp
80482ea: 52 push %edx
80482eb: 68 00 84 04 08 push $0x8048400
80482f0: 68 a0 83 04 08 push $0x80483a0
80482f5: 51 push %ecx
80482f6: 56 push %esi
80482f7: 68 94 83 04 08 push $0x8048394
80482fc: e8 c3 ff ff ff call 80482c4 <__libc_start_main@plt>
8048301: f4 hlt
```
Операция XOR элемента с самим собой устанавливает этот элемент на нуль. Поэтому `xor %ebp,%ebp` устанавливает `%ebp` на нуль. Это предполагается спецификацией ABI (Application Binary Interface) для обозначения внешнего фрейма.
Далее мы извлекаем верхний элемент стека. Здесь у нас на входе `argc`, `argv` и `envp`, значит операция извлечения отправляет `argc` в `%esi`. Мы планируем просто сохранить его и вскоре вернуть обратно в стек. Так как `argc` мы извлекли, `%esp` теперь указывает на `argv`. Операция `mov` помещает `argv` в `%ecx`, не перемещая указатель стека.
Теперь мы выполняем для указателя стека операцию `and` с маской, которая обнуляет нижние четыре бита. В зависимости от того, где находился указатель, он переместится ниже на величину от 0 до 15 байт, что приведет к выравниванию кратно 16 байтам. За счет подобного выравнивания элементов стека повышается эффективность обработки памяти и кэша. В частности, это необходимо для SSE (Streaming SIMD Extensions), инструкций, способных одновременно обрабатывать вектора с плавающей точкой одинарной точности.
В конкретно этом случае `%esp` на входе в `_start` имел значение `0xbffff770`. После того, как мы извлекли `argc`, `%esp` стал `0xbffff774`, то есть сместился на более высокий адрес (добавление элементов в стек ведет к перемещению по памяти вниз, а их извлечение – вверх). После выполнения `and` значение указателя стека вновь стало `0xbffff770`.
### Далее устанавливаем значения для вызова \_\_libc\_start\_main
Теперь мы начинаем передавать в стек аргументы для `_libc_start_main`. Первый, `%eax`, является мусором, который передается только потому, что в стек мы собираемся поместить 7 элементов, а для 16-байтового выравнивания требуется 8-й. Использоваться он не будет. Сама функция `_libc_start_main` линкуется из `glibc`. В дереве исходного кода `glibc` она находится в файле `csu/libc-start.c`. Определяется `_libc_start_main` так:
```
int __libc_start_main( int (*main) (int, char * *, char * *),
int argc, char * * ubp_av,
void (*init) (void),
void (*fini) (void),
void (*rtld_fini) (void),
void (* stack_end));
```
Итак, мы ожидаем, что `_start` передаст обозначенные аргументы в стек в обратном порядке до вызова `_libc_start_main`.
*Содержимое стека перед вызовом `__libc_start_main`*
`__libc_csu_fini` линкуется в наш код из `glibc` и находится в файле `csu/elf-init.c` дерева исходного кода. Это деструктор нашей программы на уровне Си, и чуть позже я разберу его подробно.
Так, а где переменные среды?
----------------------------
```
void __libc_init_first(int argc, char *arg0, ...)
{
char **argv = &arg0, **envp = &argv[argc + 1];
__environ = envp;
__libc_init (argc, argv, envp);
}
```
Вы заметили, что мы не получили из стека `envp`, указатель на наши переменные среды? Среди аргументов `_libc_start_main` его тоже нет. Но мы знаем, что `main` называется `int main(int argc, char** argv, char** envp)`, так в чем же дело?
Что ж, `_libc_start_main` вызывает `_libc_init_first`, которая с помощью секретной внутренней информации находит переменные среды сразу после завершающего нуля вектора аргументов, после чего устанавливает глобальную переменную `_environ`, которую `_libc_start_main` при необходимости использует впоследствии, в том числе в вызовах `main`.
После установки `envp` функция `_libc_start_main` использует тот же трюк и…вуаля! Сразу за завершающим нулем в конце массива `envp` находится очередной вектор, а именно вспомогательный вектор ELF, который загрузчик использует для передачи процессу определенной информации. Для просмотра его содержимого достаточно просто установить перед запуском программы переменную среды `LD_SHOW_AUXV=1`. Вот результат для нашей `prog1`:
```
$ LD_SHOW_AUXV=1 ./prog1
AT_SYSINFO: 0xe62414
AT_SYSINFO_EHDR: 0xe62000
AT_HWCAP: fpu vme de pse tsc msr pae mce cx8 apic
mtrr pge mca cmov pat pse36 clflush dts
acpi mmx fxsr sse sse2 ss ht tm pbe
AT_PAGESZ: 4096
AT_CLKTCK: 100
AT_PHDR: 0x8048034
AT_PHENT: 32
AT_PHNUM: 8
AT_BASE: 0x686000
AT_FLAGS: 0x0
AT_ENTRY: 0x80482e0
AT_UID: 1002
AT_EUID: 1002
AT_GID: 1000
AT_EGID: 1000
AT_SECURE: 0
AT_RANDOM: 0xbff09acb
AT_EXECFN: ./prog1
AT_PLATFORM: i686
```
Разве не интересно? Тут полно всяческой информации.
* Здесь мы видим `AT_ENTRY`, представляющую адрес `_start`, где находится наш `userid`, действующий `userid` и `groupid`.
* Очевидно, что используется платформа `686`, а частота `times()` равна `100` тактов/с.
* `AT_PHDR` указывает расположение ELF-заголовка программы, в котором хранится информация о нахождении всех сегментов этой программы в памяти, а также о записях релокаций и всем остальном, что нужно знать загрузчику.
* `AT_PHENT` – это просто количество байт в записи заголовка.
Сейчас мы не станем разбирать все это подробно, поскольку для эффективной отладки программы нам не нужен такой объем информации о загрузке файла.
### \_\_libc\_start\_main в общем
На этом я закончу разбор деталей `_libc_start_main` и лишь добавлю, что в общем он:
* Реализует функционал безопасности с помощью вызовов`setuid` и `stgid`;
* Запускает потоковую обработку;
* Регистрирует аргументы `fini` (для нашей программы) и аргументы `rtld_fini` (для загрузчика среды выполнения), которые запустит `at_exit` для выполнения процедур очистки программы и загрузчика.
* Вызывает аргумент `init`;
* Вызывает `main` с передаваемыми ей аргументами `argc` и `argv`, а также аргументом `global_environ`, о чем я писал выше;
* Вызывает `exit` с возвращаемым `main` значением.
### Вызов аргумента init
Аргумент `init` для `_libc_start_main` устанавливается на `_libc_csu_init`, который также линкуется в наш код. Он компилируется из программы Си, расположенной в файле `csu/elf-init.c` дерева исходного кода `glibc`, и линкуется в нашу программу. Его код Си похож на (но содержит намного больше `#ifdef`)…
Конструктор нашей программы
---------------------------
```
void
__libc_csu_init (int argc, char **argv, char **envp)
{
_init ();
const size_t size = __init_array_end - __init_array_start;
for (size_t i = 0; i < size; i++)
(*__init_array_start [i]) (argc, argv, envp);
}
```
`_libc_csu_init` для нашей программы очень важен, так как конструирует ее исполняемый файл. Я уже слышу, как вы говорите: «Это же не C++!». Все верно, но принцип конструкторов и деструкторов не принадлежит к C++ и предшествовал этому языку.
Наш исполняемый файл и любой другой его аналог получает на уровне Си конструктор `_libc_csu_init` и деструктор `_libc_csu_fini`. Внутри конструктора, как вы увидите далее, исполняемый файл ищет глобальные конструкторы уровня Си и вызывает любой, который найдет. В программе Си они также могут присутствовать, и в ходе статьи я это продемонстрирую. Хотя, если для вас будет удобнее, можете называть их инициализаторы и финализаторы. Вот код ассемблера, сгенерированный для `_libc_csu_init`:
```
080483a0 <__libc_csu_init>:
80483a0: 55 push %ebp
80483a1: 89 e5 mov %esp,%ebp
80483a3: 57 push %edi
80483a4: 56 push %esi
80483a5: 53 push %ebx
80483a6: e8 5a 00 00 00 call 8048405 <__i686.get_pc_thunk.bx>
80483ab: 81 c3 49 1c 00 00 add $0x1c49,%ebx
80483b1: 83 ec 1c sub $0x1c,%esp
80483b4: e8 bb fe ff ff call 8048274 <_init>
80483b9: 8d bb 20 ff ff ff lea -0xe0(%ebx),%edi
80483bf: 8d 83 20 ff ff ff lea -0xe0(%ebx),%eax
80483c5: 29 c7 sub %eax,%edi
80483c7: c1 ff 02 sar $0x2,%edi
80483ca: 85 ff test %edi,%edi
80483cc: 74 24 je 80483f2 <__libc_csu_init+0x52>
80483ce: 31 f6 xor %esi,%esi
80483d0: 8b 45 10 mov 0x10(%ebp),%eax
80483d3: 89 44 24 08 mov %eax,0x8(%esp)
80483d7: 8b 45 0c mov 0xc(%ebp),%eax
80483da: 89 44 24 04 mov %eax,0x4(%esp)
80483de: 8b 45 08 mov 0x8(%ebp),%eax
80483e1: 89 04 24 mov %eax,(%esp)
80483e4: ff 94 b3 20 ff ff ff call *-0xe0(%ebx,%esi,4)
80483eb: 83 c6 01 add $0x1,%esi
80483ee: 39 fe cmp %edi,%esi
80483f0: 72 de jb 80483d0 <__libc_csu_init+0x30>
80483f2: 83 c4 1c add $0x1c,%esp
80483f5: 5b pop %ebx
80483f6: 5e pop %esi
80483f7: 5f pop %edi
80483f8: 5d pop %ebp
80483f9: c3 ret
```
### Что такое thunk?
Говорить здесь особо не о чем, но я подумал, что вы захотите это увидеть. Функция `get_pc_thunk` весьма интересна. Она вызывается для настройки позиционно-независимого кода. Чтобы все сработало, указатель базы должен иметь адрес `GLOBAL_OFFSET_TABLE`. Соответствующий код выглядел так:
```
__get_pc_thunk_bx:
movel (%esp),%ebx
return
```
```
push %ebx
call __get_pc_thunk_bx
add $_GLOBAL_OFFSET_TABLE_,%ebx
```
Посмотрим на происходящее подробнее. Вызов `_get_pc_thunk_bx`, как и любой другой, помещает в стек адрес следующей функции, чтобы при возвращении выполнение продолжилось с очередной инструкции. В данном случае нам нужен тот самый адрес. Значит, в `_get_pc_thunk_bx` мы копируем адрес возврата из стека в `%ebx`. Когда происходит возврат, очередная инструкция прибавляет к нему `_GLOBAL_OFFSET_TABLE_`, разрешаясь в разницу между текущим адресом и глобальной таблицей смещений, используемую позиционно-независимым кодом.
В этой таблице хранится набор указателей на данные, к которым мы хотим обратиться, и нам лишь нужно знать их смещения. При этом загрузчик сам фиксирует для нас нужный адрес. Для обращения к процедурам существует аналогичная таблица. Было бы поистине утомительно программировать подобным образом в ассемблере, но можно просто написать нужный код на Си/С++ и передать аргумент `-pic` компилятору, который сделает это автомагически.
Встречая данный код в ассемблере, вы можете сделать вывод, что исходник был скомпилирован с флагом `-pic`.
### Но что это за цикл?
Цикл из `_libc_csu_init` мы рассмотрим сразу после вызова `init()`, который фактически вызывает `_init`. Пока же просто имейте ввиду, что он вызывает для нашей программы любые инициализаторы уровня Си.
### Вызов \_init
Хорошо. Загрузчик передал управление `_start`, которая вызвала `_libc_start_main`, которая вызвала `_libc_csu_init`, которая теперь вызывает `_init`:
```
08048274 <_init>:
8048274: 55 push %ebp
8048275: 89 e5 mov %esp,%ebp
8048277: 53 push %ebx
8048278: 83 ec 04 sub $0x4,%esp
804827b: e8 00 00 00 00 call 8048280 <_init+0xc>
8048280: 5b pop %ebx
8048281: 81 c3 74 1d 00 00 add $0x1d74,%ebx (.got.plt)
8048287: 8b 93 fc ff ff ff mov -0x4(%ebx),%edx
804828d: 85 d2 test %edx,%edx
804828f: 74 05 je 8048296 <_init+0x22>
8048291: e8 1e 00 00 00 call 80482b4 <__gmon_start__@plt>
8048296: e8 d5 00 00 00 call 8048370
804829b: e8 70 01 00 00 call 8048410 <\_\_do\_global\_ctors\_aux>
80482a0: 58 pop %eax
80482a1: 5b pop %ebx
80482a2: c9 leave
80482a3: c3 ret
```
### Начинается она с регулярного соглашения о вызовах Си
Если вы хотите побольше узнать об этом соглашении, почитайте [Basic Assembler Debugging with GDB](http://dbp-consulting.com/tutorials/debugging/basicAsmDebuggingGDB.html). Если коротко, то мы сохраняем указатель базы вызывающего компонента в стеке и направляем указатель базы на верхушку стека, после чего резервируем место для своего рода 4-байтовой локальной переменной.
Интересен здесь первый вызов. Его задача во многом аналогична вызову `get_pc_thunk`, который мы видели ранее. Если посмотреть внимательно, то он направлен к следующему по порядку адресу. Это переносит нас к очередному адресу, как если бы мы просто продолжили, но при этом в качестве побочного эффекта данный адрес оказывается в стеке. Он помещается в `%ebx`, а затем используется для установки доступа к глобальной таблице доступа.
### Покажи мне свой профиль
Далее мы захватываем адрес `gmon_start`. Если он равен нулю, то мы его просто проскакиваем. В противном случае он вызывается для запуска профилирования. В этом случае происходит запуск процедуры для начала профилирования и вызов `at_exit`, чтобы по завершению сработала другая процедура и записала `gmon.out`.
### Вызов frame\_dummy
В любом из случаев дальше мы вызываем `frame_dummy`. Вообще нам нужно вызвать `_register_frame_info`, а `frame_dummy` просто устанавливает для этой функции аргументы. Конечная цель – настроить разворачивание стековых фреймов для обработки исключений. Это интересно, но к нашему разбору не относится, и в данном случае все равно не используется.
### Переходим к конструкторам!
В завершении мы вызываем `_do_global_ctors_aux`. Если у вас сложности с программой, которые возникают до запуска `main`, то искать, возможно, нужно именно здесь. Конечно, сюда помещаются конструкторы для глобальных объектов С++, но кроме них тут могут находиться и другие компоненты.
### Создадим пример
Теперь давайте изменим `prog1`, создав `prog2`. Самая интересная часть – это `__attribute__ ((constructor))`, который сообщает `gcc`, что компоновщик должен поместить соответствующий указатель в таблицу, используемую `_do_global_ctors_aux`. Как видите, наш фиктивный конструктор выполняется. (компилятор заполняет `_FUNCTION_` именем функции. Это магия `gcc`).
```
#include
void \_\_attribute\_\_ ((constructor)) a\_constructor() {
printf("%s\n", \_\_FUNCTION\_\_);
}
int
main()
{
printf("%s\n",\_\_FUNCTION\_\_);
}
```
```
$ ./prog2
a_constructor
main
$
```
### \_init в prog2 практически не изменяется
Чуть позже мы подключим к процессу `gdb` и разберем эту программу. Ну а пока же рассмотрим ее `_init`.
```
08048290 <_init>:
8048290: 55 push %ebp
8048291: 89 e5 mov %esp,%ebp
8048293: 53 push %ebx
8048294: 83 ec 04 sub $0x4,%esp
8048297: e8 00 00 00 00 call 804829c <_init+0xc>
804829c: 5b pop %ebx
804829d: 81 c3 58 1d 00 00 add $0x1d58,%ebx
80482a3: 8b 93 fc ff ff ff mov -0x4(%ebx),%edx
80482a9: 85 d2 test %edx,%edx
80482ab: 74 05 je 80482b2 <_init+0x22>
80482ad: e8 1e 00 00 00 call 80482d0 <__gmon_start__@plt>
80482b2: e8 d9 00 00 00 call 8048390
80482b7: e8 94 01 00 00 call 8048450 <\_\_do\_global\_ctors\_aux>
80482bc: 58 pop %eax
80482bd: 5b pop %ebx
80482be: c9 leave
80482bf: c3 ret
```
Как видите, адреса немного отличаются от `prog1`. Похоже, дополнительный элемент данных сместил все на 28 байт. Итак, здесь у нас имена двух функций, `a_constructor` (14 байт с завершающим нулем) и `main` (5 байт с завершающим нулем), а также две форматирующих строки `%s\n` (2\*4 байта с символом переноса строки и завершающим нулем).
Итого получается 14+5+4+4 = 27. Хмм…одного не хватает. Хотя это просто предположение, проверять я не стал. Позже мы все равно сделаем остановку на вызове `_do_global_ctors_aux`, сделаем один шаг и проанализируем происходящее.
### А вот и код, который будет вызван
Чисто в качестве подсказки приведу код для `_do_global_ctors_aux`, взятый из файла `gcc/crtstuff.c` исходного кода `gcc`.
```
__do_global_ctors_aux (void)
{
func_ptr *p;
for (p = __CTOR_END__ - 1; *p != (func_ptr) -1; p--)
(*p) ();
}
```
Как видите, он инициализирует `p` из глобальной переменной `_CTOR_END_` и вычитает из нее `1`. Напомню, что это арифметика указателей, а указатель указывает на функцию, значит в данном случае `-1` приводит к смещению на один указатель функции назад или на 4 байта. Мы также увидим это в ассемблере.
Несмотря на то, что указатель не имеет значения `-1` (приведение к указателю), мы вызовем функцию, на которую указываем, после чего снова переведем указатель функции назад. Очевидно, что таблица начинается с `-1`, после чего идет некоторое количество (возможно даже 0) указателей функции.
### То же самое в ассемблере
Вот код ассемблера, соответствующий полученному из `objdump -d` результату. Прежде, чем переходить к трассировке с помощью отладчика, мы внимательно по нему пройдемся, чтобы вам было понятнее.
```
08048450 <__do_global_ctors_aux>:
8048450: 55 push %ebp
8048451: 89 e5 mov %esp,%ebp
8048453: 53 push %ebx
8048454: 83 ec 04 sub $0x4,%esp
8048457: a1 14 9f 04 08 mov 0x8049f14,%eax
804845c: 83 f8 ff cmp $0xffffffff,%eax
804845f: 74 13 je 8048474 <__do_global_ctors_aux+0x24>
8048461: bb 14 9f 04 08 mov $0x8049f14,%ebx
8048466: 66 90 xchg %ax,%ax
8048468: 83 eb 04 sub $0x4,%ebx
804846b: ff d0 call *%eax
804846d: 8b 03 mov (%ebx),%eax
804846f: 83 f8 ff cmp $0xffffffff,%eax
8048472: 75 f4 jne 8048468 <__do_global_ctors_aux+0x18>
8048474: 83 c4 04 add $0x4,%esp
8048477: 5b pop %ebx
8048478: 5d pop %ebp
8048479: c3 ret
```
### Сначала пролог
Здесь у нас типичный пролог с добавлением резервирования `%ebx`, так как мы собираемся использовать его в функции. Помимо этого, мы резервируем место для указателя `p`. Вы заметите, что несмотря на резервирование под него места в стеке, хранить мы его там не будем. Вместо этого `p` будет размещаться в `%ebx`, а `*p` в `%eax`.
### Далее подготовка к циклу
Похоже, произошла оптимизация. Вместо загрузки `_CTOR_END_` с последующим вычитанием из него `1` и разыменовыванием мы переходим далее и загружаем `*(__CTOR_END__ - 1)`, который представляет непосредственное значение `0x8049f14`. Его значение мы помещаем в `%eax` (помните, что инструкция `$0x8049f14` означала бы помещение этого значения, а ее вариант без `$` — помещение содержимого этого адреса).
Следом мы сравниваем это первое значение с `-1`, и если они равны, то заканчиваем и переходим к адресу `0x8049f14`, где очищаем стек, извлекая все сохраненные в нем элементы и делая возврат.
Предполагая, что в таблице функций есть хотя бы один элемент, мы также перемещаем непосредственное значение `$8049f14` в `%ebx`, который является нашим указателем функции `f`, после чего выполняем `xchg %ax,%ax`.
Что это вообще такое? Эта команда используется в качестве NOP (No OPeration) в 16- и 32-битных x86. По факту она ничего не делает. В нашем случае ее задача в том, чтобы цикл (верхняя его часть – это вычитание на следующей строке) начинался не с `8048466`, а с `8048468`. Смысл здесь в выравнивании начала цикла с 4-байтовой границей, в результате чего весь цикл с большей вероятностью впишется в одну строку кэша, не разбиваясь на две. Это все ускорит.
### И вот мы у вершины цикла
Далее мы вычитаем `4` из `%ebx`, подготавливаясь к очередному циклу, вызываем функцию, адрес которой получили в `%eax`, перемещаем следующий указатель функции в `%eax` и сравниваем его с `-1`. Если они не равны, возвращаемся к операции вычитания и повторяем цикл.
### Эпилог
В противном случае мы достигаем эпилога функции и возвращаемся к `_init`, которая сразу достигает своего эпилога и возвращается к `_libc_csu_init_`, о котором вы уже наверняка забыли. Здесь все еще остается один цикл для завершения, но сначала…
Как я и обещал, мы займемся отладкой `prog2`.
Напомню, что `gdb` всегда показывает очередную строку или инструкцию, которая будет выполнена.
```
$ !gdb
gdb prog2
Reading symbols from /home/patrick/src/asm/prog2...done.
(gdb) set disassemble-next-line on
(gdb) b *0x80482b7
Breakpoint 1 at 0x80482b7
```
Мы запустили программу в отладчике, включили `disassemble-next-line`, чтобы он всегда показывал очередную строку в дизассемблированном виде, и установили точку останова на строку в `_init`, где будем вызывать `_do_global_ctors_aux`.
```
(gdb) r
Starting program: /home/patrick/src/asm/prog2
Breakpoint 1, 0x080482b7 in _init ()
=> 0x080482b7 <_init+39>: e8 94 01 00 00 call 0x8048450 <__do_global_ctors_aux>
(gdb) si
0x08048450 in __do_global_ctors_aux ()
=> 0x08048450 <__do_global_ctors_aux+0>: 55 push %ebp
```
Здесь я ввел `r`, чтобы запустить программу и достичь точки останова. Очередной командой для `gdb` стала `si`, инструкция шага, указывающая отладчику шагнуть на одну инструкцию вперед.
Теперь мы вошли в `_do_global_ctors_aux`. Далее вы заметите моменты, когда я будто бы не ввожу команды для `gdb`, хотя это не так. Дело в том, что при нажатии Ввода отладчик повторяет последнюю инструкцию. То есть, если я нажму Ввод сейчас, то еще раз выполню `si`.
```
(gdb)
0x08048451 in __do_global_ctors_aux ()
=> 0x08048451 <__do_global_ctors_aux+1>: 89 e5 mov %esp,%ebp
(gdb)
0x08048453 in __do_global_ctors_aux ()
=> 0x08048453 <__do_global_ctors_aux+3>: 53 push %ebx
(gdb)
0x08048454 in __do_global_ctors_aux ()
=> 0x08048454 <__do_global_ctors_aux+4>: 83 ec 04 sub $0x4,%esp
(gdb)
0x08048457 in __do_global_ctors_aux ()
```
Хорошо, с прологом мы закончили, пришло время реального кода.
```
(gdb)
=> 0x08048457 <__do_global_ctors_aux+7>: a1 14 9f 04 08 mov 0x8049f14,%eax
(gdb)
0x0804845c in __do_global_ctors_aux ()
=> 0x0804845c <__do_global_ctors_aux+12>: 83 f8 ff cmp $0xffffffff,%eax
(gdb) p/x $eax
$1 = 0x80483b4
```
После загрузки указателя мне стало любопытно, и я ввел `p/x $eax`, то есть попросил `gdb` вывести hex-содержимое регистра `%eax`. Это не `-1`, значит можно предположить, что цикл мы проходим.
Теперь, поскольку последней командой был вывод, я не могу повторить `si` нажатием Ввода, и мне придется ее ввести.
```
(gdb) si
0x0804845f in __do_global_ctors_aux ()
=> 0x0804845f <__do_global_ctors_aux+15>: 74 13 je 0x8048474 <__do_global_ctors_aux+36>
(gdb)
0x08048461 in __do_global_ctors_aux ()
=> 0x08048461 <__do_global_ctors_aux+17>: bb 14 9f 04 08 mov $0x8049f14,%ebx
(gdb)
0x08048466 in __do_global_ctors_aux ()
=> 0x08048466 <__do_global_ctors_aux+22>: 66 90 xchg %ax,%ax
(gdb)
0x08048468 in __do_global_ctors_aux ()
=> 0x08048468 <__do_global_ctors_aux+24>: 83 eb 04 sub $0x4,%ebx
(gdb)
0x0804846b in __do_global_ctors_aux ()
=> 0x0804846b <__do_global_ctors_aux+27>: ff d0 call *%eax
(gdb)
a_constructor () at prog2.c:3
3 void __attribute__ ((constructor)) a_constructor() {
=> 0x080483b4 : 55 push %ebp
0x080483b5 : 89 e5 mov %esp,%ebp
0x080483b7 : 83 ec 18 sub $0x18,%esp
```
Вот здесь очень интересно. Мы шагнули в вызов и теперь находимся в функции `a_constructor`. Поскольку у `gdb` есть для нее исходный код, он показывает исходник Си для следующей строки. А так как я включил `disassemble-next-line`, он также покажет нам соответствующий код ассемблера.
В данном случае это пролог функции, и мы получаем все его три строки. Разве не интересно? Далее я переключусь на команду `n` (next), потому что скоро покажется `printf`. Первая `n` пропустит пролог, вторая `printf`, а третья эпилог. Если вас когда-нибудь интересовало, почему при пошаговом продвижении с помощью `gdb` нужно делать дополнительный шаг в начале и конце функции, то теперь вы знаете почему.
```
(gdb) n
4 printf("%s\n", __FUNCTION__);
=> 0x080483ba : c7 04 24 a5 84 04 08 movl $0x80484a5,(%esp)
0x080483c1 : e8 2a ff ff ff call 0x80482f0
```
Мы переместили адрес строки `a_constructor` в стек в качестве аргумента для `printf`, но он вызывает puts, поскольку компилятор догадался, что нас интересует только `puts`.
```
(gdb) n
a_constructor
5 }
=> 0x080483c6 : c9 leave
0x080483c7 : c3 ret
```
Раз мы трассируем программу, то она, естественно, выполняется, в связи с чем выше мы видим вывод `a_constructor`. Закрывающая скобка `}` соответствует эпилогу, поэтому он выводится сейчас. К слову отмечу, если вам не знакома инструкция `leave`, то выполняет она то же, что и:
```
movl %ebp, %esp
popl %ebp
```
Очередной шаг выводит нас из функции с возвращением ее результата. Здесь мне потребуется снова переключиться на `si`.
```
(gdb) n
0x0804846d in __do_global_ctors_aux ()
=> 0x0804846d <__do_global_ctors_aux+29>: 8b 03 mov (%ebx),%eax
(gdb) si
0x0804846f in __do_global_ctors_aux ()
=> 0x0804846f <__do_global_ctors_aux+31>: 83 f8 ff cmp $0xffffffff,%eax
(gdb)
0x08048472 in __do_global_ctors_aux ()
=> 0x08048472 <__do_global_ctors_aux+34>: 75 f4 jne 0x8048468 <__do_global_ctors_aux+24>
(gdb) p/x $eax
$2 = 0xffffffff
```
Мне снова стало интересно, и я решил еще раз проверить значение указателя функции. На этот раз он равен `-1`, значит из цикла мы выходим.
```
(gdb) si
0x08048474 in __do_global_ctors_aux ()
=> 0x08048474 <__do_global_ctors_aux+36>: 83 c4 04 add $0x4,%esp
(gdb)
0x08048477 in __do_global_ctors_aux ()
=> 0x08048477 <__do_global_ctors_aux+39>: 5b pop %ebx
(gdb)
0x08048478 in __do_global_ctors_aux ()
=> 0x08048478 <__do_global_ctors_aux+40>: 5d pop %ebp
(gdb)
0x08048479 in __do_global_ctors_aux ()
=> 0x08048479 <__do_global_ctors_aux+41>: c3 ret
(gdb)
0x080482bc in _init ()
=> 0x080482bc <_init+44>: 58 pop %eax
```
Заметьте, что мы снова вернулись в `_init`.
```
(gdb)
0x080482bd in _init ()
=> 0x080482bd <_init+45>: 5b pop %ebx
(gdb)
0x080482be in _init ()
=> 0x080482be <_init+46>: c9 leave
(gdb)
0x080482bf in _init ()
=> 0x080482bf <_init+47>: c3 ret
(gdb)
0x080483f9 in __libc_csu_init ()
=> 0x080483f9 <__libc_csu_init+25>: 8d bb 1c ff ff ff lea -0xe4(%ebx),%edi
(gdb) q
A debugging session is active.
Inferior 1 [process 17368] will be killed.
Quit anyway? (y or n) y
$
```
Обратите внимание, что мы перепрыгнули обратно к `_libc_csu_init`, и здесь я ввел `q` для выхода из `gdb`. Вот и вся отладка, которую я обещал.
Теперь, когда мы вернулись в `_libc_csu_init_`, нужно разобраться еще с одним циклом, через который я уже не буду шагать, а просто его проговорю.
### Возвращаемся в \_\_libc\_csu\_init\_\_
Поскольку мы итак провели немало времени за работой с циклом в ассемблере, а ассемблерный код для этого конструктора еще более утомителен, то я оставлю эту задачу для тех, кому она будет интересна. Просто напомню, как он выглядит в Си:
```
void
__libc_csu_init (int argc, char **argv, char **envp)
{
_init ();
const size_t size = __init_array_end - __init_array_start;
for (size_t i = 0; i < size; i++)
(*__init_array_start [i]) (argc, argv, envp);
}
```
### Еще один цикл вызова функции
Что такое массив `_init_`? Я уж думал, вы и не спросите. На этом этапе вы также можете выполнять код. Поскольку идет он сразу после возвращения из `_init`, которая запускала наши конструкторы, то содержимое этого массива будет выполняться после завершения конструкторов. Вы можете сообщить компилятору, что хотите выполнить на этом этапе функцию, которая в результате получит те же аргументы, что и `main`.
```
void init(int argc, char **argv, char **envp) {
printf("%s\n", __FUNCTION__);
}
__attribute__((section(".init_array"))) typeof(init) *__init = init;
```
Мы пока этого делать не будем, потому что есть и другие подобные моменты. Давайте просто вернем результат из `_lib_csu_init`. Помните, куда это нас приведет?
### Мы вернемся аж к \_\_libc\_start\_main\_\_
Теперь он вызывает наш `main`, а результат передает в `exit()`.
`exit()` выполняет функции, зарегистрированные с помощью `at_exit` в порядке их добавления. Затем она выполняет очередной цикл функций, на этот раз из массива `fini`. Далее она выполняет еще один цикл функций, теперь уже деструкторов. (В реальности она находится во вложенном цикле и работает с массивом списков функций, но поверьте мне, завершаются они именно в этом порядке). Вот смотрите.
### Эта программа, hooks.c, связывает все воедино
```
#include
void preinit(int argc, char \*\*argv, char \*\*envp) {
printf("%s\n", \_\_FUNCTION\_\_);
}
void init(int argc, char \*\*argv, char \*\*envp) {
printf("%s\n", \_\_FUNCTION\_\_);
}
void fini() {
printf("%s\n", \_\_FUNCTION\_\_);
}
\_\_attribute\_\_((section(".init\_array"))) typeof(init) \*\_\_init = init;
\_\_attribute\_\_((section(".preinit\_array"))) typeof(preinit) \*\_\_preinit = preinit;
\_\_attribute\_\_((section(".fini\_array"))) typeof(fini) \*\_\_fini = fini;
void \_\_attribute\_\_ ((constructor)) constructor() {
printf("%s\n", \_\_FUNCTION\_\_);
}
void \_\_attribute\_\_ ((destructor)) destructor() {
printf("%s\n", \_\_FUNCTION\_\_);
}
void my\_atexit() {
printf("%s\n", \_\_FUNCTION\_\_);
}
void my\_atexit2() {
printf("%s\n", \_\_FUNCTION\_\_);
}
int main() {
atexit(my\_atexit);
atexit(my\_atexit2);
}
```
Если собрать и выполнить эту программу (я зову ее `hook.c`), то выводом будет:
```
$ ./hooks
preinit
constructor
init
my_atexit2
my_atexit
fini
destructor
$
```
Конец
-----
Еще раз продемонстрирую вам весь путь, который мы прошли, только теперь он должен быть вам уже более понятен.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=poshagovyj_razbor_zapuska_programmy_v_linux) | https://habr.com/ru/post/588102/ | null | ru | null |
# Пять лет Rust
В этом бардаке, который сейчас происходит в мире, легко забыть, что прошло уже пять лет с выпуска 1.0 в 2015 году! Rust за эти пять лет сильно изменился, так что мы хотели бы вспомнить о работе всех участников сообщества, начиная с момента стабилизации языка.
Напомним, если кто забыл: Rust — это язык программирования общего назначения, который обладает средствами, позволяющими строить надёжное и эффективное программное обеспечение. Rust может быть использован в любой области: от ядра вашей операционной системы до вашего следующего web-приложения. Этот язык полностью построен участниками открытого многоликого сообщества, в основном волонтёрами, кто щедро делился своим временем и знаниями для того, чтобы помочь сделать Rust таким, какой он есть сейчас.
Основные изменения с версии 1.0
-------------------------------
#### 2015
**[1.2](https://blog.rust-lang.org/2015/08/06/Rust-1.2.html) — Параллельная кодогенерация:** уменьшение времени компиляции всегда являлось главной темой в каждом выпуске Rust, и сейчас трудно представить, что когда-то был короткий период времени, когда Rust вообще не имел параллельной кодогенерации.
**[1.3](https://blog.rust-lang.org/2015/09/17/Rust-1.3.html) — The Rustonomicon:** наш первый выпуск фантастической книги "The Rustonomicon", книги, которая исследует тёмную сторону языка Rust, Unsafe Rust и смежные темы. Она стала прекрасным источником сведений для любого, кто хочет изучить и понять самые трудные аспекты языка.
**[1.4](https://blog.rust-lang.org/2015/10/29/Rust-1.4.html) — Поддержка Windows MSVC уровня 1:** продвижение платформы на уровень поддержки 1 принесло нативную поддержку 64-битной Windows с инструментарием Microsoft Visual C++ (MSVC). До 1.4 вам нужно было устанавливать MinGW (порт окружения GNU под Windows) чтобы использовать и компилировать ваши программы на Rust. Поддержка Windows стала одним из самых больших улучшений Rust за эти пять лет. Лишь недавно Microsoft [анонсировала публичный пре-релиз официальной поддержки Rust для WinRT API!](https://blogs.windows.com/windowsdeveloper/2020/04/30/rust-winrt-public-preview/) И наконец, сейчас стало значительно легче строить высококачественные и кроссплатформенные приложения, нежели это было когда-либо ранее.
**[1.5](https://blog.rust-lang.org/2015/12/10/Rust-1.5.html) — Cargo Install:** добавлена поддержка возможности сборки исполняемых файлов с помощью компилятора Rust вместе с поддержкой предустановленных дополнений cargo породило целую экосистему приложений, утилит и инструментов для разработчиков, которые сообщество обожает и от которых зависит. Cargo теперь поддерживает довольно много команд, которые сначала были просто плагинами, сделанными участниками сообщества и выложенными на crates.io!
#### 2016
**[1.6](https://blog.rust-lang.org/2016/01/21/Rust-1.6.html) — Libcore:** `libcore` — это подмножество стандартной библиотеки, содержащее только API, которое не требует функций выделения памяти или функций уровня операционной системы. Стабилизация `libcore` позволила компилировать Rust без выделения памяти или зависимости от операционной системы, что стало одним из первых основных шагов к поддержке Rust для разработки встраиваемых систем.
**[1.10](https://blog.rust-lang.org/2016/07/07/Rust-1.10.html) — Динамические библиотеки с C ABI:** крейт типа `cdylib` компилируется в динамическую библиотеку с C-интерфейсом, что позволяет встраивать проекты Rust в любую систему, которая поддерживает ABI языка C. Некоторые из самых больших историй успеха Rust среди пользователей — это возможность написать небольшую критическую часть системы на Rust и легко интегрировать в большую кодовую базу. И теперь это стало проще, чем когда-либо.
**[1.12](https://blog.rust-lang.org/2016/09/29/Rust-1.12.html) — Cargo Workspaces:** позволяют организовать несколько проектов Rust и совместно использовать один и тот же lock-файл. Рабочие пространства были неоценимы при создании крупных многоуровневых проектов.
**[1.13](https://blog.rust-lang.org/2016/11/10/Rust-1.13.html) — Оператор `Try`:** первым основным синтаксическим изменением был оператор `?` или оператор "Try". Он позволяет легко распространять ошибку по стеку вызовов. Раньше вам приходилось использовать макрос `try!`, который требовал оборачивать всё выражение каждый раз, когда вы сталкивались с `Result`, теперь вместо этого можно легко связать методы с помощью `?`.
```
try!(try!(expression).method()); // Было
expression?.method()?; // Стало
```
**[1.14](https://blog.rust-lang.org/2016/12/22/Rust-1.14.html) — Rustup 1.0:** Rustup — это менеджер инструментальных средств. Он позволяет беспрепятственно использовать любую версию Rust или любой его инструментарий. То, что начиналось как скромный скрипт, стало тем, что персонал по эксплуатации нежно называет *"химера"*. Возможность обеспечить первоклассное управление версиями компилятора в Linux, macOS, Windows и десятке целевых платформ была мифом ещё пять лет назад.
#### 2017
**[1.15](https://blog.rust-lang.org/2017/02/02/Rust-1.15.html) — Процедурные макросы вывода типажей:** макросы вывода типажей позволяют создавать мощные, обширные и строго типизированные API без часто повторяющегося кода. Это была первая стабильная версия Rust с которой стало можно использовать макросы из библиотек `serde` или `diesel`.
**[1.17](https://blog.rust-lang.org/2017/04/27/Rust-1.17.html) — Rustbuild:** одним из самых больших улучшений для наших контрибьюторов в разработке языка стал переход от начальной системы сборки на основе `make` на использование Cargo. Благодаря этому участникам и новичкам `rust-lang/rust` стало намного проще создавать и вносить свой вклад в проект.
**[1.20](https://blog.rust-lang.org/2017/08/31/Rust-1.20.html) — Ассоциированные константы:** ранее константы могли быть связаны только с модулем. В 1.20 мы стабилизировали ассоциативные константы для структур, перечислений и, что важно, для типажей. Это упростило добавление богатых наборов предустановленных значений в типы вашего API, таких как общие IP-адреса или использующиеся числовые константы.
#### 2018
**[1.24](https://blog.rust-lang.org/2018/02/15/Rust-1.24.html) — Инкрементальная компиляция:** до версии 1.24, когда вы вносили изменения в библиотеку, компилятору приходилось перекомпилировать весь код. Теперь он стал намного умнее в плане кэширования, насколько это было возможно, и ему нужно только заново перегенерировать изменения.
**[1.26](https://blog.rust-lang.org/2018/05/10/Rust-1.26.html) — `impl Trait`:** добавление `impl Trait` дало вам выразительные динамические API с преимуществами и производительностью
статической диспетчеризации.
**[1.28](https://blog.rust-lang.org/2018/08/02/Rust-1.28.html) — Глобальные аллокаторы:** ранее вы были ограничены использованием аллокатора, предоставленного Rust. Теперь с помощью API глобального аллокатора можно выбрать аллокатор, который соответствует вашим потребностям. Это был важный шаг в создании библиотеки `alloc`, другого подмножества стандартной библиотеки, содержащей только те её части, для которых требуется аллокатор, например `Vec` или `String`. Теперь стало проще, чем когда-либо, переиспользовать части стандартной библиотеки на различных системах.
**[1.31](https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html) — 2018 редакция:** выпуск 2018 редакции стал нашим самым большим выпуском языка после версии 1.0, добавив изменения синтаксиса и улучшения в код на Rust, написанного полностью обратно совместимым образом. Это позволяет библиотекам, созданным с разными редакциями, беспрепятственно работать вместе.
* **Нелексические времена жизни (NLL)**: огромное улучшение в анализаторе заимствований Rust, позволяющее ему принимать более проверяемый безопасный код.
* **Улучшения в системе модулей**: большие улучшения UX в объявлении и использовании модулей.
* **Константные функции**: константные функции позволяют запускать и вычислять код Rust во время компиляции.
* **Rustfmt 1.0**: новый инструмент форматирования кода, созданный специально для Rust.
* **Clippy 1.0**: анализатор Rust для поиска распространённых ошибок. Clippy значительно упрощает проверку того, что ваш код не только безопасен, но и корректен.
* **Rustfix**: со всеми изменениями синтаксиса мы знали, что хотим предоставить инструментарий, позволяющий сделать переход максимально простым. Теперь, когда требуются изменения в синтаксисе Rust, можно просто выполнить команду `cargo fix` для решения проблем, связанной с изменениями синтаксиса.
#### 2019
**[1.34](https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html) — Альтернативный реестр крейтов:** поскольку Rust всё больше и больше используется в производстве, возникает большая потребность в возможности размещении и использовании проектов в приватных пространствах. Вместе с этим в Cargo всегда разрешены зависимости из git-репозиториев. С помощью альтернативных реестров ваша организация может легко создать и делиться своим собственным реестром крейтов, которые можно использовать в ваших проектах, как если бы они были на crates.io.
**[1.39](https://blog.rust-lang.org/2019/11/07/Rust-1.39.0.html) — Async/Await:** стабилизация ключевых слов `async`/`await` для обработки `Future` была одной из главных вех в превращении асинхронного программирования в "объект первого класса" Rust. Уже через шесть месяцев после его выпуска, асинхронное программирование превратилось в разнообразную и производительную экосистему.
#### 2020
**[1.42](https://blog.rust-lang.org/2020/03/12/Rust-1.42.html) — Шаблоны срезов:** хотя это было и не самое большое изменение, добавление шаблона `..` (остальное) был долгожданной функцией, которая значительно улучшает выразительность сопоставления образцов для срезов.
Диагностики и ошибки
--------------------
Одна вещь, которую мы не упомянули, это то насколько улучшены сообщения об ошибках и диагностика в Rust с 1.0. Глядя на старые сообщения об ошибках кажется, что это теперь другой язык.
Мы выделили несколько примеров, которые лучше всего демонстрируют насколько мы улучшили сообщения об ошибках. Теперь они показывают пользователям, где они допустили ошибки, и помогают понять почему код не работает, а также подсказывают, как можно их исправить.
##### Первый пример (Типажи)
```
use std::io::Write;
fn trait_obj(w: &Write) {
generic(w);
}
fn generic(\_w: &W) {}
```
**Сообщение об ошибке в 1.2.0**
```
Compiling error-messages v0.1.0 (file:///Users/usr/src/rust/error-messages)
src/lib.rs:6:5: 6:12 error: the trait `core::marker::Sized` is not implemented for the type `std::io::Write` [E0277]
src/lib.rs:6 generic(w);
^~~~~~~
src/lib.rs:6:5: 6:12 note: `std::io::Write` does not have a constant size known at compile-time
src/lib.rs:6 generic(w);
^~~~~~~
error: aborting due to previous error
Could not compile `error-messages`.
To learn more, run the command again with --verbose.
```
**Сообщение об ошибке в 1.43.0**
```
Compiling error-messages v0.1.0 (/Users/ep/src/rust/error-messages)
error[E0277]: the size for values of type `dyn std::io::Write` cannot be known at compilation time
--> src/lib.rs:6:13
|
6 | generic(w);
| ^ doesn't have a size known at compile-time
...
9 | fn generic(\_w: &W) {}
| ------- - - help: consider relaxing the implicit `Sized` restriction: `+ ?Sized`
| |
| required by this bound in `generic`
|
= help: the trait `std::marker::Sized` is not implemented for `dyn std::io::Write`
= note: to learn more, visit
error: aborting due to previous error
For more information about this error, try `rustc --explain E0277`.
error: could not compile `error-messages`.
To learn more, run the command again with --verbose.
```
##### Второй пример (помощь)
```
fn main() {
let s = "".to_owned();
println!("{:?}", s.find("".to_owned()));
}
```
**Сообщение об ошибке в 1.2.0**
```
Compiling error-messages v0.1.0 (file:///Users/ep/src/rust/error-messages)
src/lib.rs:3:24: 3:43 error: the trait `core::ops::FnMut<(char,)>` is not implemented for the type `collections::string::String` [E0277]
src/lib.rs:3 println!("{:?}", s.find("".to_owned()));
^~~~~~~~~~~~~~~~~~~
note: in expansion of format_args!
:2:25: 2:56 note: expansion site
:1:1: 2:62 note: in expansion of print!
:3:1: 3:54 note: expansion site
:1:1: 3:58 note: in expansion of println!
src/lib.rs:3:5: 3:45 note: expansion site
src/lib.rs:3:24: 3:43 error: the trait `core::ops::FnOnce<(char,)>` is not implemented for the type `collections::string::String` [E0277]
src/lib.rs:3 println!("{:?}", s.find("".to\_owned()));
^~~~~~~~~~~~~~~~~~~
note: in expansion of format\_args!
:2:25: 2:56 note: expansion site
:1:1: 2:62 note: in expansion of print!
:3:1: 3:54 note: expansion site
:1:1: 3:58 note: in expansion of println!
src/lib.rs:3:5: 3:45 note: expansion site
error: aborting due to 2 previous errors
Could not compile `error-messages`.
To learn more, run the command again with --verbose.
```
**Сообщение об ошибке в 1.43.0**
```
Compiling error-messages v0.1.0 (/Users/ep/src/rust/error-messages)
error[E0277]: expected a `std::ops::FnMut<(char,)>` closure, found `std::string::String`
--> src/lib.rs:3:29
|
3 | println!("{:?}", s.find("".to_owned()));
| ^^^^^^^^^^^^^
| |
| expected an implementor of trait `std::str::pattern::Pattern<'_>`
| help: consider borrowing here: `&"".to_owned()`
|
= note: the trait bound `std::string::String: std::str::pattern::Pattern<'_>` is not satisfied
= note: required because of the requirements on the impl of `std::str::pattern::Pattern<'_>` for `std::string::String`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0277`.
error: could not compile `error-messages`.
To learn more, run the command again with --verbose.
```
##### Третий пример (Проверка заимствований)
```
fn main() {
let mut x = 7;
let y = &mut x;
println!("{} {}", x, y);
}
```
**Сообщение об ошибке в 1.2.0**
```
Compiling error-messages v0.1.0 (file:///Users/ep/src/rust/error-messages)
src/lib.rs:5:23: 5:24 error: cannot borrow `x` as immutable because it is also borrowed as mutable
src/lib.rs:5 println!("{} {}", x, y);
^
note: in expansion of format_args!
:2:25: 2:56 note: expansion site
:1:1: 2:62 note: in expansion of print!
:3:1: 3:54 note: expansion site
:1:1: 3:58 note: in expansion of println!
src/lib.rs:5:5: 5:29 note: expansion site
src/lib.rs:3:18: 3:19 note: previous borrow of `x` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `x` until the borrow ends
src/lib.rs:3 let y = &mut x;
^
src/lib.rs:6:2: 6:2 note: previous borrow ends here
src/lib.rs:1 fn main() {
src/lib.rs:2 let mut x = 7;
src/lib.rs:3 let y = &mut x;
src/lib.rs:4
src/lib.rs:5 println!("{} {}", x, y);
src/lib.rs:6 }
^
error: aborting due to previous error
Could not compile `error-messages`.
To learn more, run the command again with --verbose.
```
**Сообщение об ошибке в 1.43.0**
```
Compiling error-messages v0.1.0 (/Users/ep/src/rust/error-messages)
error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
--> src/lib.rs:5:23
|
3 | let y = &mut x;
| ------ mutable borrow occurs here
4 |
5 | println!("{} {}", x, y);
| ^ - mutable borrow later used here
| |
| immutable borrow occurs here
error: aborting due to previous error
For more information about this error, try `rustc --explain E0502`.
error: could not compile `error-messages`.
To learn more, run the command again with --verbose.
```
Цитаты от участников команд
---------------------------
Конечно, мы не можем охватить все произошедшие изменения. Поэтому мы обратились к некоторым из наших команд и спросили, какими изменениями они больше всего гордятся:
> Для rustdoc значительными изменениями были:
>
> * автоматически сгенерированная документация для автоматических реализованных типажей,
> * сам поиск и его оптимизации (последним является преобразование метаданных в JSON),
> * возможность более точного тестирования документационных блоков "compile\_fail, should\_panic, allow\_fail",
> * тесты документации теперь генерируются как отдельные двоичные файлы.
>
>
>
>
>
> — Guillaume Gomez ([rustdoc](https://www.rust-lang.org/governance/teams/rustdoc))
>
>
>
> Rust теперь имеет базовую поддержку IDE! Я полагаю, что между IntelliJ Rust,
>
> RLS и rust-analyzer большинство пользователей должны получить «не ужасный» опыт
>
> для своего редактора. Пять лет назад под «написанием Rust» подразумевалось
>
> использование старой школы Vim/Emacs.
>
>
>
> — Алексей Кладов ([IDEs and editors](https://www.rust-lang.org/governance/teams/ides))
>
>
>
> Для меня это было бы следующим: добавление первоклассной поддержки популярных
>
> встроенных архитектур и усилия по созданию экосистемы, позволяющей сделать
>
> разработку микроконтроллеров с помощью Rust лёгкой, безопасной и в то же время
>
> увлекательной.
>
>
>
> — Daniel Egger ([Embedded WG](https://www.rust-lang.org/governance/wgs/embedded))
>
>
>
> Команда релизов работала только с начала 2018 года, но даже за это время
>
> мы получили ~ 40000 коммитов только в `rust-lang/rust` без каких-либо существенных
>
> регрессий в стабильной версии.
>
> Учитывая, как быстро мы улучшаем компилятор и стандартные библиотеки, я думаю, что
>
> это действительно впечатляет (хотя, конечно, команда релизов здесь не является
>
> единственным участником). В целом, я обнаружил, что команда релизов проделала
>
> отличную работу по управлению масштабированием для увеличения трафика на
>
> трекерах, публикуемых PR и т. д.
>
>
>
> — Mark Rousskov ([Release](https://www.rust-lang.org/governance/teams/release))
>
>
>
> За последние 3 года нам удалось превратить интерпретатор [Miri](https://github.com/rust-lang/miri)
>
> из экспериментального в практический инструмент для изучения дизайна языка и
>
> поиска ошибок в реальном коде, отличное сочетание теории и практики
>
> проектирования языков. С теоретической точки зрения у нас есть
>
> [Stacked Borrows](https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md),
>
> на данный момент наиболее конкретное предложение для модели псевдонимов Rust.
>
> С практической точки зрения, хотя изначально мы проверяли только несколько
>
> ключевых библиотек в Miri, мы недавно увидели большое количество людей,
>
> использующих Miri для [поиска и исправления ошибок](https://github.com/rust-lang/miri/#bugs-found-by-miri) в своих
>
> собственных крейтах, зависимостях и аналогичное понимание среди участников,
>
> улучшающих Miri, например, добавив поддержку доступа к файловой системе,
>
> раскручивания стека и многопоточности.
>
>
>
> — Ralf Jung ([Miri](https://www.rust-lang.org/governance/teams/compiler#miri))
>
>
>
> Если бы мне пришлось выбрать одну вещь, которой я больше всего горжусь,
>
> это была работа над NLL. Это не только потому, что я думаю, что это сильно
>
> повлияло на удобство использования Rust, но и потому, что мы реализовали его,
>
> сформировав рабочую группу NLL. Эта рабочая группа привлекла много замечательных
>
> участников, многие из которых до сих пор работают над компилятором. Открытый
>
> исходный код в лучшем виде!
>
>
>
> — Niko Matsakis ([Language](https://www.rust-lang.org/governance/teams/lang))
Сообщество
----------
Поскольку язык изменился и сильно вырос за последние пять лет, изменилось и его сообщество. На Rust было написано очень много замечательных проектов, и присутствие Rust в промышленной разработке выросло в геометрической прогрессии. Мы хотим поделиться статистикой о том, насколько вырос Rust.
* Rust четыре года подряд признавался [«Самым любимым языком программирования»](https://insights.stackoverflow.com/survey/2019#most-loved-dreaded-and-wanted) по опросам разработчиков Stack Overflow, проводимых в последние года, начиная с версии 1.0.
* Только в этом году мы обработали более 2,25 петабайта (1PB = 1000 ТБ) различных версий компилятора, инструментария и документации!
* В то же время мы обработали более 170 ТБ пакетов для примерно 1,8 миллиарда запросов на crates.io, удвоив ежемесячный трафик по сравнению с прошлым годом.
* Когда Rust версии 1.0 был выпущен, можно было подсчитать количество компаний, которые использовали его в промышленной разработке. Сегодня его используют сотни технологических компаний, а некоторые из крупнейших технологических компаний, таких как Apple, Amazon, Dropbox, Facebook, Google и Microsoft, решили использовать Rust в своих проектах для надёжности и производительности.
Заключение
----------
Очевидно, что мы не смогли охватить все изменения или улучшения в Rust, которые произошли с 2015 года. Какими были ваши любимые изменения или новые любимые проекты Rust? Не стесняйтесь размещать свой ответ и обсуждение на [нашем форуме Discourse](https://users.rust-lang.org/t/five-years-of-rust/42661).
Наконец, мы хотели бы поблагодарить всех кто внёс свой вклад в Rust, независимо от того, добавили ли вы новую функцию или исправили опечатку, ваша работа сделала Rust удивительным сегодня. Мы не можем дождаться, чтобы увидеть как Rust и его сообщество будут продолжать расти и меняться, и посмотреть, что вы все будете строить с Rust в ближайшее десятилетие!
От переводчиков и участников сообщества
---------------------------------------
> Я помню свои первые впечатления, когда я сделал какой-то простой алгоритм на Rust, скомпилировал и попытался запустить. Что такое? Ничего не произошло? Я попытался ещё раз нажать ENTER на этот исполняемый файл, и вроде снова ничего не произошло… Нажатие Ctrl+O выявило собственно "проблему" — код отрабатывал настолько быстро, что я даже не успевал заметить моргание панелей MC
>
> Это было настолько свежим впечатлением после других, более тяжеловесных платформ, что я тут же полез скачивать и изучать Rust Book.
>
> С тех пор прошла целая куча времени, и видно, как платформа (а язык Rust теперь смело можно называть не просто языком, а платформой) растёт и матереет, для меня наиболее значимым изменением оказались NLL, я прямо ощутил, насколько легче стало делать алгоритмический код, включающий в себя, как правило, множество изменяемых структур данных. И нельзя не отметить также насколько улучшился Rust плагин для моей любимой среды программирования Intellij Idea.
>
> За эти 5 лет я стал участником русскоязычного Rust сообщества и Rust стал моим профессиональным инструментом. Мой путь в Rust был довольно долог и тернист, но сейчас у меня нет ощущения, что мне хочется переходить куда-то ещё. Так что пока я поработаю на Rust-е
>
>
>
> — [nlinker](https://habr.com/ru/users/nlinker/) (Translation Team)
>
>
>
> О Rust узнал в январе 2017 года.
>
> Очень скоро нашел перевод книг на русский язык.
>
> Стал читать и помогать с переводом.
>
> На то время проделанная работа по переводам была значительной.
>
>
>
> Были переведены почти полностью
>
> * Rust book first edition
> * Rust by example
> * Rustonomicon.
>
>
>
>
>
> Главной сложностью было следить за оригиналом и делать синхронизацию с нашей версий.
>
> Но мы преодолели эти сложности.
>
>
>
> За прошедший год мы полностью перевели Rust by example, Rust book second edition, Async book
>
>
>
> Для меня одно из открытий в Rust стало, то что отладчиком за 3 года пользовался менее 5 раз. Такая выразительная система типов в этом языке.
>
>
>
> — [andreevlex](https://habr.com/ru/users/andreevlex/) (Участник команды [rust-lang-ru](https://github.com/rust-lang-ru))
---
С любыми вопросами по языку Rust вам смогут помочь в [русскоязычном Телеграм-чате](https://t.me/rustlang_ru) или же в аналогичном [чате для новичковых вопросов](https://t.me/rust_beginners_ru).
Данную статью совместными усилиями перевели [andreevlex](https://habr.com/ru/users/andreevlex/), [funkill](https://habr.com/ru/users/funkill/), [nlinker](https://habr.com/ru/users/nlinker/), [l4l](https://habr.com/ru/users/l4l/), [Hirrolot](https://habr.com/ru/users/hirrolot/), [P0lunin](https://habr.com/ru/users/p0lunin/) и [blandger](https://habr.com/ru/users/blandger/). | https://habr.com/ru/post/502046/ | null | ru | null |
# Линейная алгебра для разработчиков игр
Эта статья является переводом цикла из четырёх статей «Linear algebra for game developers», написанных David Rosen и посвящённых линейной алгебре и её применению в разработке игр. С оригинальными статьями можно ознакомиться тут: [часть 1](http://blog.wolfire.com/2009/07/linear-algebra-for-game-developers-part-1/), [часть 2](http://blog.wolfire.com/2009/07/linear-algebra-for-game-developers-part-2/), [часть 3](http://blog.wolfire.com/2010/07/Linear-algebra-for-game-developers-part-3) и [часть 4](http://blog.wolfire.com/2010/07/Linear-algebra-for-game-developers-part-4). Я не стал публиковать переводы отдельными топиками, а объединил все статьи в одну. Думаю, что так будет удобнее воспринимать материал и работать с ним. Итак приступим.
#### Зачем нам линейная алгебра?
Одним из направлений в линейной алгебре является изучение векторов. Если в вашей игре применяется позиционирование экранных кнопок, работа с камерой и её направлением, скоростями объектов, то вам придётся иметь дело с векторами. Чем лучше вы понимаете линейную алгебру, тем больший контроль вы получаете над поведением векторов и, следовательно, над вашей игрой.
#### Что такое вектор?
В играх вектора используются для хранения местоположений, направлений и скоростей. Ниже приведён пример двухмерного вектора:
Вектор местоположения (также называемый «радиус-вектором») показывает, что человек стоит в двух метрах восточнее и в одном метре к северу от исходной точки. Вектор скорости показывает, что за единицу времени самолёт перемещается на три километра вверх и на два — влево. Вектор направления говорит нам о том, что пистолет направлен вправо.
Как вы можете заметить, вектор сам по себе всего лишь набор цифр, который обретает тот или иной смысл в зависимости от контекста. К примеру, вектор (1, 0) может быть как направлением для оружия, как показано на картинке, так и координатами строения в одну милю к востоку от вашей текущей позиции. Или скоростью улитки, которая двигается вправо со скоростью в 1 милю в час (*прим. переводчика: довольно быстро для улитки, 44 сантиметра в секунду*).
Важно отслеживать единицы измерения. Допустим у нас есть вектор V (3,5,2). Это мало что говорит нам. Три чего, пять чего? В нашей игре [Overgrowth](http://www.wolfire.com/overgrowth) расстояния указываются в метрах, а скорости в метрах в секунду. Первое число в этом векторе — это направление на восток, второе — направление вверх, третье — направление на север. Отрицательные числа обозначают противоположные направления, на запад, вниз и на юг. Местоположение, определяемое вектором V (3,5,2), находится в трёх метрах к востоку, в пяти метрах вверху и в двух метрах к северу, как показано на картинке ниже.
Итак, мы изучили основы работы с векторами. Теперь узнаем как вектора использовать.
#### Сложение векторов
Чтобы сложить вектора, нам надо просто сложить каждую их составляющую друг с другом. Например:
(0, 1, 4) + (3, -2, 5) = (0+3, 1-2, 4+5) = (3, -1, 9)
Зачем нам нужно складывать вектора? Наиболее часто сложение векторов в играх применяется для физического интегрирования. Любой физический объект будет иметь вектора для местоположения, скорости и ускорения. Для каждого кадра (обычно это одна шестидесятая часть секунды), мы должны интегрировать два вектора: добавить скорость к местоположению и ускорение к скорости.
Давайте рассмотрим пример с прыжками [Марио](http://mario.nintendo.com/). Он начинает с позиции (0, 0). В момент начала прыжка его скорость (1, 3), он быстро двигается вверх и вправо. Его ускорение равно (0, -1), так как гравитация тянет его вниз. На картинке показано, как выглядит его прыжок, разбитый на семь кадров. Чёрным текстом показана его скорость в каждом фрейме.
Давайте рассмотрим первые кадры поподробнее, чтобы понять как всё происходит.
Для первого кадра, мы добавляем скорость Марио (1, 3) к его местоположению (0, 0) и получаем его новые координаты (1, 3). Затем мы складываем ускорение (0, -1) с его скоростью (1, 3) и получаем новое значение скорости Марио (1, 2).
Делаем то-же самое для второго кадра. Добавляем скорость (1, 2) к местоположению (1, 3) и получаем координаты (2, 5). Затем добавляем ускорение (0, -1) к его скорости (1, 2) и получаем новую скорость (1, 1).
Обычно игрок контролирует ускорение игрового персонажа с помощью клавиатуры или геймпада, а игра, в свою очередь, рассчитывает новые значения для скоростей и местоположения, используя физическое сложение (через сложение векторов). Это та-же задача, которая решается в [интегральном исчислении](http://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%B8%D1%81%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5), просто мы его сильно упрощаем для нашей игры. Я заметил, что мне намного проще внимательно слушать лекции по интегральному исчислению, думая о практическом его применении, которое мы только что описали.
#### Вычитание векторов
Вычитание рассчитывается по тому-же принципу что и сложение — вычитаем соответствующие компоненты векторов. Вычитание векторов удобно для получения вектора, который показывает из одного местоположения на другое. Например, пусть игрок находится по координатам (1, 2) с лазерным ружьём, а вражеский робот находится по координатам (4, 3). Чтобы определить вектор движения лазерного луча, который поразит робота, нам надо вычесть местоположение игрока из местоположения робота. Получаем:
(4, 3) — (1, 2) = (4-1, 3-2) = (3, 1).
#### Умножение вектора на скаляр
Когда мы говорим о векторах, мы называем отдельные числа скалярами. Например (3, 4) — вектор, а 5 — это скаляр. В играх, часто бывает нужно умножить вектор на число (скаляр). Например, моделируя простое сопротивление воздуха путём умножения скорости игрока на 0.9 в каждом кадре. Чтобы сделать это, нам надо умножить каждый компонент вектора на скаляр. Если скорость игрока (10, 20), то новая скорость будет:
0.9\*(10, 20) = (0.9 \* 10, 0.9 \* 20) = (9, 18).
#### Длина вектора
Если у нас есть корабль с вектором скорости V (4, 3), нам также понадобится узнать как быстро он двигается, чтобы посчитать потребность в экранном пространстве или сколько потребуется топлива. Чтобы сделать это, нам понадобится найти длину (модуль) вектора V. Длина вектора обозначается вертикальными линиями, в нашем случае длина вектора V будет обозначаться как |V|.
Мы можем представить V как прямоугольный треугольник со сторонами 4 и 3 и, применяя теорему Пифагора, получить гипотенузу из выражения: x2 + y2 = h2
В нашем случае — длину вектора H с компонентами (x, y) мы получаем из квадратного корня: sqrt(x2 + y2).
Итак, скорость нашего корабля равна:
|V| = sqrt(42 + 32) = sqrt(25) = 5
Этот подход используется и для трёхмерных векторов. Длина вектора с компонентами (x, y, z) рассчитывается как sqrt(x2 + y2 + z2)
#### Расстояние
Если игрок P находится в точке (3, 3), а взрыв произошёл в точке E по координатам (1, 2), нам надо определить расстояние между игроком и взрывом, чтобы рассчитать степень ущерба, нанесённого игроку. Это легко сделать, комбинируя две вышеописанных операции: вычитание векторов и их длину.
Мы вычитаем P — E, чтобы получить вектор между ними. А затем определяем длину этого вектора, что и даёт нам искомое расстояние. Порядок следования операндов тут не имеет значения, |E — P| даст тот-же самый результат.
Расстояние = |P — E| = |(3, 3) — (1, 2)| = |(2, 1)| = sqrt(22+12) = sqrt(5) = 2.23
#### Нормализация
Когда мы имеем дело с направлениями (в отличие от местоположений и скоростей), важно, чтобы вектор направления имел длину, равную единице. Это сильно упрощает нам жизнь. Например, допустим орудие развёрнуто в направлении (1, 0) и выстреливает снаряд со скоростью 20 метров в секунду. Каков в данном случае вектор скорости для выпущенного снаряда?
Так как вектор направления имеет длину равную единице, мы умножаем направление на скорость снаряда и получаем вектор скорости (20, 0). Если-же вектор направления имеет отличную от единицы длину, мы не сможем сделать этого. Снаряд будет либо слишком быстрым, либо слишком медленным.
Вектор с длиной равной единице называется «нормализованным». Как сделать вектор нормализованным? Довольно просто. Мы делим каждый компонент вектора на его длину. Если, к примеру, мы хотим нормализовать вектор V с компонентами (3, 4), мы просто делим каждый компонент на его длину, то есть на 5, и получаем (3/5, 4/5). Теперь, с помощью теоремы Пифагора, мы убедимся в том, что его длина равна единице:
(3/5)2 + (4/5)2 = 9/25 + 16/25 = 25/25 = 1
#### Скалярное произведение векторов
Что такое скалярное произведение (записывается как •)? Чтобы рассчитать скалярное произведение двух векторов, мы должны умножить их компоненты, а затем сложить полученные результаты вместе
(a1, a2) • (b1, b2) = a1b1 + a2b2
Например: (3, 2) • (1, 4) = 3\*1 + 2\*4 = 11. На первый взгляд это кажется бесполезным, но посмотрим внимательнее на это:
Здесь мы можем увидеть, что если вектора указывают в одном направлении, то их скалярное произведение больше нуля. Когда они перпендикулярны друг другу, то скалярное произведение равно нулю. И когда они указывают в противоположных направлениях, их скалярное произведение меньше нуля.
В основном, с помощью скалярного произведения векторов можно рассчитать, сколько их указывает в одном направлении. И хоть это лишь малая часть возможностей скалярного произведения, но уже очень для нас полезная.
Допустим у нас есть стражник, расположенный в G(1, 3) смотрящий в направлении D(1,1), с углом обзора 180 градусов. Главный герой игры подсматривает за ним с позиции H(3, 2). Как определить, находится-ли главный герой в поле зрения стражника или нет? Сделаем это путём скалярного произведения векторов D и V (вектора, направленного от стражника к главному герою). Мы получим следующее:
V = H — G = (3, 2) — (1, 3) = (3-1, 2-3) = (2, -1)
D•V = (1, 1) • (2, -1) = 1\*2 + 1\*-1 = 2-1 = 1
Так как единица больше нуля, то главный герой находится в поле зрения стражника.
Мы уже знаем, что скалярное произведение имеет отношение к определению направления векторов. А каково его более точное определение? Математическое выражение скалярного произведения векторов выглядит так:
A•B = |A||B|cosΘ
Где Θ (произносится как «theta») — угол между векторами A и B.
Это позволяет нам найти Θ (угол) с помощью выражения:
Θ = acos([AB] / [|A||B|])
Как я говорил ранее, нормализация векторов упрощает нашу жизнь. И если A и B нормализованы, то выражение упрощается следующим образом:
Θ = acos(AB)
Давайте опять рассмотрим сценарий со стражником. Пусть теперь угол обзора стражника будет равен 120 градусам. Получим нормализованные вектора для направления взгляда стражника (D') и для направления от стражника к главному герою (V'). Затем определим угол между ними. Если угол более 60 градусов (половина от угла обзора), то главный герой находится вне поля зрения стражника.
D' = D / |D| = (1, 1) / sqrt(12 + 12) = (1, 1) / sqrt(2) = (0.71, 0.71)
V' = V / |V| = (2, -1) / sqrt(22 + (-1)2) = (2,-1) / sqrt(5) = (0.89, -0.45)
Θ = acos(D'V') = acos(0.71\*0.89 + 0.71\*(-0.45)) = acos(0.31) = 72
Угол между центром поля зрения стражника и местоположением главного героя составляет 72 градуса, следовательно стражник его не видит.
Понимаю, что это выглядит довольно сложно, но это потому, что мы всё делаем вручную. В программе это всё довольно просто. Ниже показано как я сделал это в нашей игре [Overgrowth](http://www.wolfire.com/overgrowth) с помощью написанных мной С++ библиотек для работы с векторами:
```
//Инициализируем вектора
vec2 guard_pos = vec2(1,3);
vec2 guard_facing = vec2(1,1);
vec2 hero_pos = vec2(3,2);
//Рассчитываем нормализованные вектора
vec2 guard_facing_n = normalize(guard_facing);
vec2 guard_to_hero = normalize(hero_pos - guard_pos);
//Рассчитываем угол
float angle = acos(dot(guard_facing_n, guard_to_hero));
```
#### Векторное произведение
Допустим у нас есть корабль с пушками, которые стреляют в правую и в левую стороны по курсу. Допустим, что лодка расположена вдоль вектора направления (2, 1). В каких направлениях теперь стреляют пушки?
Это довольно просто в двухмерной графике. Чтобы повернуть направление на 90 градусов по часовой стрелке, достаточно поменять местами компоненты вектора, а затем поменять знак второму компоненту.
(a, b) превращается в (b, -a). Следовательно у корабля, расположенного вдоль вектора (2, 1), пушки справа по борту будут стрелять в направлении (1, -2), а пушки с левого борта, будут стрелять в противоположном направлении. Меняем знаки у компонент вектора и получаем (-1, 2).
А что если мы хотим рассчитать это всё для трехмерной графики? Рассмотрим пример с кораблём.
У нас есть вектор мачты M, направленной прямо вверх (0, 1, 0) и направление ветра: север-северо-восток W (1, 0, 2). И мы хотим вычислить вектор направления паруса S, чтобы наилучшим образом «поймать ветер».
Для решения этой задачи мы используем векторное произведение: S = M x W.
Векторное произведение A(a1,a2,a3) и B(b1,b2,b3) будет равно:
(a2b3-a3b2, a3b1-a1b3, a1b2-a2b1)
Подставим теперь нужные нам значения:
S = MxW = (0, 1, 0) x (1, 0, 2) = ([1\*2 — 0\*0], [0\*1 — 0\*2], [0\*0 — 1\*1]) = (2, 0, -1)
Для расчётов вручную довольно сложно, но для графических и игровых приложений я рекомендую написать функцию, подобную той, что указана ниже и не вдаваться более в детали подобных расчётов.
```
vec3 cross(vec3 a, vec3 b) {
vec3 result;
result[0] = a[1] * b[2] - a[2] * b[1];
result[1] = a[2] * b[0] - a[0] * b[2];
result[2] = a[0] * b[1] - a[1] * b[0];
return result;
}
```
Векторное произведение часто используется в играх, чтобы рассчитать нормали к поверхностям. Направления, в которых «смотрит» та или иная поверхность. Например, рассмотрим треугольник с векторами вершин A, B и С. Как мы найдем направление в котором «смотрит» треугольник, то есть направление перпендикулярное его плоскости? Это кажется сложным, но у нас есть инструмент для решения этой задачи.
Используем вычитание, для определения направления из A в С (C — A), пусть это будет «грань 1» (Edge 1) и направление из A в B (B — A), пусть это будет «грань 2» (Edge 2). А затем применим векторное произведение, чтобы найти вектор, перпендикулярный им обоим, то есть перпендикулярный плоскости треугольника, также называемый «нормалью к плоскости».
Вот так это выглядит в коде:
```
vec3 GetTriangleNormal(vec3 a, vec3 b, vec3 c) {
vec3 edge1 = b-a;
vec3 edge2 = c-a;
vec3 normal = cross(edge1,edge2);
return normal;
}
```
В играх основное выражение освещённости записывается как N • L, где N — это нормаль к освещаемой поверхности, а L — это нормализованный вектор направления света. В результате поверхность выглядит яркой, когда на неё прямо падает свет, и тёмной, когда этого не происходит.
Теперь перейдем к рассмотрению такого важного для разработчиков игр понятия, как «матрица преобразований» (transformation matrix).
Для начала изучим «строительные блоки» матрицы преобразований.
#### Базисный вектор
Допустим мы пишем игру [Asteroids](http://ru.wikipedia.org/wiki/Asteroids) на очень старом «железе» и нам нужен простой двухмерный космический корабль, который может свободно вращаться в своей плоскости. Модель корабля выглядит так:
Как нам рисовать корабль, когда игрок поворачивает его на произвольный градус, скажем 49 градусов против часовой стрелки. Используя тригонометрию, мы можем написать функцию двухмерного поворота, которая принимает координаты точки и угол поворота, и возвращает координаты смещённой точки:
```
vec2 rotate(vec2 point, float angle){
vec2 rotated_point;
rotated_point.x = point.x * cos(angle) - point.y * sin(angle);
rotated_point.y = point.x * sin(angle) + point.y * cos(angle);
return rotated_point;
}
```
Применяя эту функцию ко всем трём точкам, мы получим следующую картину:
Операции с синусами и косинусами работают довольно медленно, но так как мы делаем расчёты лишь для трёх точек, это будет нормально работать даже на старом «железе» (*прим. переводчика: в случаях, когда предполагается интенсивное использование тригонометрических функций, для ускорения вычислений, в памяти организуют таблицы значений для каждой функции и рассчитывают их во время запуска приложения. Затем при вычислении той или иной тригонометрической функции просто производится обращение к таблице*).
Пусть теперь наш корабль выглядит вот так:
Теперь старый подход будет слишком медленным, так как надо будет поворачивать довольно большое количество точек. Одно из элегантных решений данной проблемы будет звучать так — «Что если вместо поворота каждой точки модели корабля, мы повернём координатную решётку нашей модели?»
Как это работает? Давайте посмотрим внимательнее, что собой представляют координаты.
Когда мы говорим о точке с координатами (3, 2), мы говорим, что её местоположение находится в трех шагах от точки отсчёта по координатной оси X, и двух шагах от точки отсчёта по координатной оси Y.
По-умолчанию координатные оси расположены так: вектор координатной оси X (1, 0), вектор координатной оси Y (0, 1). И мы получим расположение: 3(1, 0) + 2(0, 1). Но координатные оси не обязательно должны быть в таком положении. Если мы повернём координатные оси, в это-же время мы повернём все точки в координатной решётке.
Чтобы получить повернутые оси X и Y мы применим тригонометрические функции, о которых говорили выше. Если мы поворачиваем на 49 градусов, то новая координатная ось X будет получена путём поворота вектора (0, 1) на 49 градусов, а новая координатная ось Y будет получена путём поворота вектора (0, 1) на 49 градусов. Итак вектор новой оси X у нас будет равен (0.66, 0.75), а вектор новой оси Y будет (-0.75, 0.66). Сделаем это вручную для нашей простой модели из трёх точек, чтобы убедиться, что это работает так, как нужно:
Координаты верхней точки (0, 2), что означает, что её новое местоположение находится в 0 на новой (повёрнутой) оси X и 2 на новой оси Y:
0\*(0.66,0.75) + 2\*(-0.75, 0.66) = (-1.5, 1.3)
Нижняя левая точка (-1, -1), что означает, что её новое местоположение находится в -1 на повернутой оси X, и -1 на повернутой оси Y:
-1\*(0.66,0.75) + -1\*(-0.75, 0.66) = (0.1, -1.4)
Нижняя правая точка (1, -1), что означает её новое местоположение находится в 1 на повернутой оси X, и -1 на повернутой оси Y
1\*(0.66,0.75) + -1\*(-0.75, 0.66) = (1.4, 0.1)
Мы показали, как координаты корабля отображаются в другой координатной сетке с повернутыми осями (или «базисными векторами»). Это удобно в нашем случае, так как избавляет нас от необходимости применять тригонометрические преобразования к каждой из точек модели корабля.
Каждый раз, когда мы изменяем базисные вектора (1, 0) и (0, 1) на (a, b) и (c, d), то новая координата точки (x, y) может быть найдена с помощью выражения:
x(a,b) + y(c,d)
Обычно базисные вектора равны (1, 0) и (0, 1) и мы просто получаем x(1, 0) + y(0, 1) = (x, y), и нет необходимости заботиться об этом дальше. Однако, важно помнить, что мы можем использовать и другие базисные вектора, когда нам это нужно.
#### Матрицы
Матрицы похожи на двухмерные вектора. Например, типичная 2x2 матрица, может выглядеть так:
```
[a c
b d]
```
Когда вы умножаете матрицу на вектор, вы суммируете скалярное произведение каждой строки с вектором, на который происходит умножение. Например, если мы умножаем вышеприведённую матрицу на вектор (x, y), то мы получаем:
(a,c)•(x,y) + (b,d)•(x,y)
Будучи записанным по-другому, это выражение выглядит так:
x(a,b) + y(c,d)
Выглядит знакомо, не так-ли? Это в точности такое-же выражение, которые мы использовали для смены базисных векторов. Это означает, что умножая 2x2 матрицу на двухмерный вектор, мы тем самым меняем базисные вектора. Например, если мы вставим стандартные базисные вектора в (1, 0) и (0, 1) в колонки матрицы, то мы получим:
```
[1 0
0 1]
```
Это единичная матрица, которая не даёт эффекта, который мы можем ожидать от нейтральных базисных векторов, которые мы указали. Если-же мы повернём базисные вектора на 49-градусов, то мы получим:
```
[0.66 -0.75
0.75 0.66]
```
Эта матрица будет поворачивать двухмерный вектор на 49 градусов против часовой стрелки. Мы можем сделать код нашей игры Asteriods более элегантным, используя матрицы вроде этой. Например, функция поворота нашего корабля может выглядеть так:
```
void RotateShip(float degrees){
Matrix2x2 R = GetRotationMatrix(degrees);
for(int i=0; i
```
Однако, наш код будет ещё более элегантным, если мы сможем также включить в эту матрицу перемещение корабля в пространстве. Тогда у нас будет единая структура данных, которая будет заключать в себе и применять информацию об ориентации объекта и его местоположении в пространстве.
К счастью есть способ добиться этого, хоть это и выглядит не очень элегантно. Если мы хотим переместиться с помощью вектора (e, f), мы лишь включаем его в нашу матрицу преобразования:
```
[a c e
b d f
0 0 1]
```
И добавляем дополнительную единицу в конец каждого вектора, определяющего местоположение объекта, например так:
[x y 1]
Теперь, когда мы перемножаем их, мы получаем:
(a, c, e) • (x, y, 1) + (b, d, f) • (x, y, 1) + (0, 0, 1) • (x, y, 1)
Что, в свою очередь, может быть записано как:
x(a, b) + y(c, d) + (e, f)
Теперь у нас есть полный механизм трансформации, заключённый в одной матрице. Это важно, если не принимать в расчёт элегантность кода, так как с ней мы теперь можем использовать все стандартные манипуляции с матрицами. Например перемножить матрицы, чтобы добавить нужный эффект, или мы можем инвертировать матрицу, чтобы получить прямо противоположное положение объекта.
#### Трехмерные матрицы
Матрицы в трехмерном пространстве работают так-же как и в двухмерном. Я приводил примеры с двухмерными векторами и матрицами, так как их просто отобразить с помощью дисплея, показывающего двухмерную картинку. Нам просто надо определить три колонки для базисных векторов, вместо двух. Если базисные вектора это (a,b,c), (d,e,f) and (g,h,i) то наша матрица будет выглядеть так:
```
[a d g
b e h
c f i]
```
Если нам нужно перемещение (j,k,l), то мы добавляем дополнительную колонку и строку, как говорили раньше:
```
[a d g j
b e h k
c f i l
0 0 0 1]
```
И добавляем единицу [1] в вектор, как здесь:
[x y z 1]
#### Вращение в двухмерном пространстве
Так как в нашем случае у нас только одна ось вращения (расположенная на дисплее), единственное, что нам надо знать, это угол. Я говорил об этом ранее, упоминая, что мы можем применять тригонометрические функции для реализации функции двухмерного вращения наподобие этой:
```
vec2 rotate(vec2 point, float angle){
vec2 rotated_point;
rotated_point.x = point.x * cos(angle) - point.y * sin(angle);
rotated_point.y = point.x * sin(angle) + point.y * cos(angle);
return rotated_point;
}
```
Более элегантно это можно выразить в матричной форме. Чтобы определить матрицу, мы можем применить эту функцию к осям (1, 0) и (0, 1) для угла Θ, а затем включить полученные оси в колонки нашей матрицы. Итак, начнём с координатной оси X (1, 0). Если мы применим к ней нашу функцию, мы получим:
(1\*cos(Θ) — 0\*sin(Θ), 1\*sin(Θ) + 0\*cos(Θ)) = (cos(Θ), sin(Θ))
Затем, мы включаем координатную ось Y (0, 1). Получим:
(0\*cos(Θ) — 1\*sin(Θ), 0\*sin(Θ) + 1\*cos(Θ)) = (-sin(Θ), cos(Θ))
Включаем полученные координатные оси в матрицу, и получаем двухмерную матрицу вращения:
```
[cos(Θ) -sin(Θ)
sin(Θ) cos(Θ)]
```
Применим эту матрицу к [Сюзанне](http://ru.wikipedia.org/wiki/Blender#Suzanne), мартышке из графического пакета Blender. Угол поворота Θ равен 45 градусов по часовой стрелке.
Как видите — это работает. Но что если нам надо осуществить вращение вокруг точки, отличной от (0, 0)?
Например, мы хотим вращать голову мартышки вокруг точки, расположенной в её ухе:
Чтобы сделать это, мы можем начать с создания матрицы перемещения (translation matrix) T, которая перемещает объект из начальной точки в точку вращения в ухе мартышки, и матрицу вращения R, для вращения объекта вокруг начальной точки. Теперь для вращения вокруг точки, расположенной в ухе, мы можем сперва переместить точку в ухе на место начальной точки, с помощью инвертирования матрицы T, записанной как T-1. Затем, мы вращаем объект вокруг начальной точки, с помощью матрицы R, а затем применяем матрицу T для перемещения точки вращения назад, к своему исходному положению.
Ниже дана иллюстрация к каждому из описанных шагов:
Это важный шаблон, который мы будем применять позднее — применение вращения для двух противоположных трансформаций позволяет нам вращать объект в другом «пространстве». Что очень удобно и полезно.
Теперь рассмотрим трёхмерное вращение.
#### Трёхмерное вращение
Вращение вокруг оси Z работает по тому-же принципу, что и вращение в двухмерном пространстве. Нам лишь нужно изменить нашу старую матрицу, добавив к ней дополнительную колонку и строку:
```
[cos(Θ) -sin(Θ) 0
sin(Θ) cos(Θ) 0
0 0 1]
```
Применим эту матрицу к трехмерной версии Сюзанны, мартышки из пакета Blender. Угол поворота Θ пусть будет равен 45 градусов по часовой стрелке.
То-же самое. Вращение только вокруг оси Z ограничивает нас, как насчёт вращения вокруг произвольной оси?
#### Вращение, определяемое осью и углом (Axis-angle rotation)
Представление вращения, определяемого осью и углом, также известно как вращение в экспоненциальных координатах, параметризованное вращением двух величин. Вектора, определяющего вращение направляющей оси (прямая линия) и угла, описывающего величину поворота вокруг этой оси. Вращение осуществляется согласно [правилу правой руки](http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE_%D0%BF%D1%80%D0%B0%D0%B2%D0%BE%D0%B9_%D1%80%D1%83%D0%BA%D0%B8).
Итак, вращение задаётся двумя параметрами (axis, angle), где axis — вектор оси вращения, а angle — угол вращения. Этот приём довольно прост и являет собой отправную точку для множества других операций вращения, с которыми я работаю. Как практически применить вращение, определяемое осью и углом?
Допустим мы имеем дело с осью вращения, показанной на рисунке ниже:
Мы знаем как вращать объект вокруг оси Z, и мы знаем как вращать объект в других пространствах. Итак, нам лишь надо создать пространство, где наша ось вращения будет являться осью Z. И если эта ось будет осью Z, то что будет являться осями X и Y? Займемся вычислениями сейчас.
Чтобы создать новые оси X и Y нам нужно лишь выбрать два вектора, которые перпендикулярны новой оси Z и перпендикулярны друг другу. Мы уже говорили ранее о векторном умножении, которое берёт два вектора и даёт в итоге перпендикулярный им вектор.
У нас есть один вектор сейчас, это ось вращения, назовём его A. Возьмём теперь случайный другой вектор B, который находится не в том-же направлении, что и вектор A. Пусть это будет (0, 0, 1) к примеру.
Теперь мы имеем ось вращения A и случайный вектор B, мы можем получить нормаль C, через векторное произведение A и B. С перпендикулярен векторам A и B. Теперь мы делаем вектор B перпендикулярным векторам A и C через их векторное произведение. И всё, у нас есть все нужные нам оси координат.
На словах это звучит сложно, но довольно просто выглядит в коде или будучи показанным в картинках.
Ниже показано, как это выглядит в коде:
```
B = (0,0,1);
C = cross(A,B);
B = cross(C,A);
```
Тут показана иллюстрация для каждого шага:
Теперь, имея информацию о новых координатных осях, мы можем составить матрицу M, включив каждую ось как колонку в эту матрицу. Нам надо убедиться, что вектор A является третьей колонкой, чтобы он был нашей новой осью координат Z.
```
[B0 C0 A0
B1 C1 A1
B2 C2 A2]
```
Теперь это похоже на то, что мы делали для поворота в двухмерном пространстве. Мы можем применить инвертированную матрицу M, чтобы переместиться в новую систему координат, затем произвести вращение, согласно матрице R, чтобы повернуть объект вокруг оси Z, затем применить матрицу M, чтобы вернуться в исходное координатное пространство.
Теперь мы можем вращать объект вокруг произвольной оси. В конце концов мы можем просто создать матрицу T = T = M-1RM и использовать её много раз, без дополнительных усилий с нашей стороны. Есть более эффективные способы конвертирования вращений, определяемых осью и углом во вращения, определяемые матрицами. Просто описанный нами подход показывает многое из того, о чём мы говорили ранее.
Вращение, определяемое осью и углом, возможно, самый интуитивно понятный способ. Применяя его, очень легко инвертировать поворот, поменяв знак у угла, и легко интерполировать, путём интерполяции угла. Однако тут есть серьёзное ограничение, и заключается оно в том, что такое вращение не является суммирующим. То есть вы не можете комбинировать два вращения, определяемых осью и углом в третье.
Вращение, определяемое осью и углом — хороший способ для начала, но оно должно быть преобразовано во что-то другое, чтобы использоваться в более сложных случаях.
#### Эйлеровские углы
Эйлеровские углы представляют собой другой способ вращения, заключающийся в трёх вложенных вращениях относительно осей X, Y и Z. Вы, возможно, сталкивались с их применением в играх, где камера показывает действие от первого лица, либо от третьего лица.
Допустим вы играете в шутер от первого лица и вы повернулись на 30 градусов влево, а затем посмотрели на 40 градусов вверх. В конце-концов в вас стреляют, попадают, и, в результате удара, камера поворачивается вокруг своей оси на 45 градусов. Ниже показано вращение с помощью углов Эйлера (30, 40, 45).
Углы Эйлера — удобное и простое в управлении средство. Но у этого способа есть два недостатка.
Первый, это вероятность возникновения ситуации под названием [«блокировка оси» или «шарнирный замок» (gimbal lock)](http://www.wikiznanie.ru/ru-wz/index.php/%D0%A8%D0%B0%D1%80%D0%BD%D0%B8%D1%80%D0%BD%D1%8B%D0%B9_%D0%B7%D0%B0%D0%BC%D0%BE%D0%BA). Представьте, что вы играете в шутер от первого лица, где вы можете посмотреть влево, вправо, вверх и вниз или повернуть камеру вокруг зрительной оси. Теперь представьте, что вы смотрите прямо вверх. В этой ситуации попытка взглянуть налево или направо будет аналогична попытке вращения камеры. Всё что мы можем вы этом случае, это вращать камеру вокруг своей оси, либо посмотреть вниз. Как вы можете представить, это ограничение делает непрактичным применение углов Эйлера в лётных симуляторах.
Второе — интерполяция между двумя эйлеровскими углами вращения не даёт кратчайшего пути между ними.
Например, у вас две интерполяции между двумя одинаковыми вращениями. Первая использует интерполяцию эйлеровского угла, вторая использует сферическую линейную интерполяцию (spherical linear interpolation (SLERP)), чтобы найти кратчайший путь.
Итак, что-же больше подойдет для интерполяции вращений? Может быть матрицы?
#### Вращение с помощью матриц
Как мы уже говорили ранее, матрицы вращения хранят в себе информацию о трёх осях. Это означает, что интерполяция между двумя матрицами лишь линейно интерполирует каждую ось. В результате это даёт нам эффективный путь, то так-же привносит новые проблемы. Например, тут показаны два вращения и одно интерполированное полу-вращение:
Как вы можете заметить, интерполированное вращение значительно меньше, чем любое из исходных вращений, и две оси более не перпендикулярны друг другу. Это логично, если вдуматься — середина отрезка, соединяющего любые две точки на сфере будет расположена ближе к центру сферы.
Это в свою очередь порождает известный «эффект фантика» (candy wrapper effect), при применении скелетной анимации. Ниже показана демонстрация этого эффекта на примере кролика из нашей игры [Overgrowth](http://www.youtube.com/WolfireGames) (*прим. переводчика: обратите внимание на середину туловища кролика*).
Вращение, основанное на матричных операциях, очень полезно, так как они могут аккумулировать вращения без всяких проблем, вроде блокировки оси (gimbal lock), и может очень эффективно применяться к точкам сцены. Вот почему поддержка вращения на матрицах встроена в графические карты. Для любого типа трёхмерной графики матричный формат вращения — это всегда итоговый применяемый способ.
Однако, как мы уже знаем, матрицы не очень хорошо интерполируются, и они не столь интуитивно понятны.
Итак, остался только один главный формат вращения. Последний, но тем не менее, важный.
#### Кватернионы
Что-же такое кватернионы? Если очень кратко, то это альтернативный вариант вращения, основанный на оси и угле (axis-angle rotation), который существует в пространстве.
Подобно матрицам они могут аккумулировать вращения, то есть вы можете составлять из них цепочку вращений, без опаски получить блокировку оси (gimbal lock). И в то-же время, в отличие от матриц, они могут хорошо интерполироваться из одного положения в другое.
Являются-ли кватернионы лучшим решением, нежели остальные способы вращений (rotation formats)?
На сегодняшний день они комбинируют все сильные стороны других способов вращений. Но у них есть два слабых места, рассмотрев которые, мы придём к выводу, что кватернионы лучше использовать для промежуточных вращений. Итак, каковы недостатки кватернионов.
Во-первых кватернионы непросто отобразить на трёхмерном пространстве. И мы вынуждены всегда реализовывать вращение более простым способом, а затем конвертировать его. Во-вторых, кватернионы не могут эффективно вращать точки, и мы вынуждены конвертировать их в матрицы, чтобы повернуть значительное количество точек.
Это означает, что вы скорее всего не начнете или не закончите серию вращений с помощью кватернионов. Но с их помощью можно реализовать промежуточные вращения более эффективно, нежели при применении любого другого подхода.
«Внутренняя кухня» механизма кватернионов не очень понятна и не интересна мне. И, возможно, не будет интересна и вам, если только вы не математик. И я советую вам найти библиотеки, которые работают с кватернионами, чтобы облегчить вам решение ваших задач с их помощью.
Математические библиотеки [«Bullet»](http://bulletphysics.org) или [«Blender»](http://www.blender.org/) будут хорошим вариантом для начала. | https://habr.com/ru/post/131931/ | null | ru | null |
# Начался третий ежегодный чемпионат Russian AI Cup
[](http://habrahabr.ru/company/mailru/blog/236033/)
Доброго дня и приятного понедельника всем! Сегодня начало не только рабочей недели, но и чемпионата по программированию искусственного интеллекта [Russian AI Cup](http://russianaicup.ru/), организатором которого является Mail.Ru Group. Он проходит ежегодно, начиная с 2012 года. В этот раз перед участниками поставлена задача по написанию алгоритма для команды хоккеистов. Принять участие могут все желающие, любых возрастов и квалификаций. Главное — иметь базовые навыки программирования. Список возможных языков программирования ограничен, вы можете выбрать один из следующих вариантов: C++, Java, C#, Python, Ruby или Pascal. Кстати, в прошлом году предпочтения участников распределились таким образом: 36% выбрали C++, 25% — Java, 21% — C#.
Чемпионат состоит из четырёх этапов: [песочницы](http://russianaicup.ru/p/sandbox), двух отборочных раундов и финала. По сути, песочница является аналогом квалификационных игр. В ней авторы могут на протяжении всего чемпионата обкатывать различные идеи и стратегии. По результатам игр в песочнице отберут 900 участников для первого раунда. В нём меряются силами команды из двух «хоккеистов». По окончании первого раунда 300 лучших участников перейдут во второй отборочный раунд. Здесь в каждой «хоккейной команде» будет участвовать уже по три виртуальных хоккеиста. И, наконец, 50 лучших стратегий по результатам второго раунда и 10 по рейтингу песочницы смогут сразиться в финале чемпионата. Цель каждой стратегии — забить как можно больше голов, как и в обычном хоккее. Для этого хоккеисты могут перемещаться по игровому полю и выполнять различные действия: подбирать шайбу, отдавать пас, бить по воротам и так далее. Все участники имеют возможность создавать игры, чтобы изучать сильнейших противников и совершенствовать свою тактику. Вот пример простой стратегии на Java — хоккеист сперва едет за шайбой, а, завладев ею, поворачивается в сторону ворот противника и бьёт:
```
import model.*;
import static java.lang.StrictMath.PI;
import static java.lang.StrictMath.abs;
public final class MyStrategy implements Strategy {
private static final double STRIKE_ANGLE = 1.0D * PI / 180.0D;
@Override
public void move(Hockeyist self, World world, Game game, Move move) {
if (world.getPuck().getOwnerHockeyistId() == self.getId()) {
Player opponentPlayer= world.getOpponentPlayer();
double netX = 0.5D * (opponentPlayer.getNetBack() + opponentPlayer.getNetFront());
double netY = 0.5D * (opponentPlayer.getNetBottom() + opponentPlayer.getNetTop());
double angleToNet = self.getAngleTo(netX, netY);
move.setTurn(angleToNet);
if (abs(angleToNet) < STRIKE_ANGLE) {
move.setAction(ActionType.STRIKE);
}
} else {
move.setSpeedUp(1.0D);
move.setTurn(self.getAngleTo(world.getPuck()));
move.setAction(ActionType.TAKE_PUCK);
}
}
}
```
*«Мы заинтересованы в развитии IT-отрасли в России и с этой целью регулярно проводим IT-чемпионаты, которые собирают огромное количество участников, интересующихся информационными технологиями. Russian AI Cup даёт всем желающим возможность проверить свои силы в создании искусственного интеллекта и привести своего персонажа или свою команду к победе, получив ценные призы и еще более ценный опыт»*, — прокомментировал Дмитрий Волошин, руководитель департамента образования Mail.Ru Group.
Награды получат восемь сильнейших программистов. За 1 место — Mac Pro, за 2 место — MacBook Pro, за 3 место — MacBook Air, за 4, 5, 6, 7 и 8 места – iPad mini. Будут отмечены и победители из песочницы, для них приготовлены iPod nano.
Расписание этапов чемпионата:
Песочница — с 8 сентября по 19 октября. 15 сентября рейтинг будет обнулён.
Раунд 1: с 27 по 28 сентября.
Раунд 2: с 4 по 5 октября.
Финал: с 11 по 12 октября.
Ждём вас! | https://habr.com/ru/post/236033/ | null | ru | null |
# Книга «Веб-разработка с применением Node и Express. Полноценное использование стека JavaScript. 2-е издание »
[](https://habr.com/ru/company/piter/blog/542488/) Привет, Хаброжители! Создавайте динамические веб-приложения с применением Express — ключевого компонента из стека разработки Node/JavaScript. Итан Браун описывает работу с Express 5 на примере создания полноценного приложения. В книге рассматриваются все этапы и компоненты — от серверного рендеринга до разработки API для работы с одностраничными приложениями (SPA). Express является золотой серединой между устоявшимся фреймворком и отсутствием фреймворка вообще, поэтому он оставляет вам определенную свободу при архитектурном выборе. Эта книга предоставит лучшие решения для фронтенд- и бэкенд-разработчиков, использующих Express. Научитесь смотреть на веб-разработку под новым углом! — Создайте систему шаблонизации для отображения динамических данных. — Подробно изучите объекты запроса и отклика, промежуточное ПО и маршрутизацию URL-адресов. — Создайте симуляцию продакшен-среды и выполняйте в ней тестирование. — Научитесь долговременному хранению информации в документных базах данных с помощью MongoDB и в реляционных базах данных — с помощью PostgreSQL. — Открывайте другим программам доступ к вашим ресурсам благодаря API. — Создавайте защищенные приложения с применением аутентификации, авторизации и HTTPS. — Интегрируйтесь с социальными сетями, включайте геолокацию и многое другое. — Внедрите план по запуску и сопровождению вашего приложения. — Освойте критически важные навыки отладки.
### Сети доставки контента
Когда вы переводите свой сайт в эксплуатацию, статические ресурсы должны быть выложены где-то в Интернете. Возможно, вы привыкли выкладывать их на том же сервере, где генерируется весь ваш динамический HTML. В нашем примере до сих пор также использовался данный подход: запускаемый командой node meadowlark.js сервер Node/Express раздает как все виды HTML, так и статические ресурсы. Однако, если хотите оптимизировать производительность вашего сайта (или заложить эту возможность на будущее), вам понадобится возможность выкладывать статические ресурсы в сети доставки контента (content delivery network, CDN). CDN — сервер, оптимизированный для доставки статических ресурсов. Он использует специальные заголовки (о которых мы скоро узнаем больше), включающие кэширование в браузере.
Помимо этого, CDN может включать географическую оптимизацию (часто называемую edge caching), то есть статическое содержимое будет доставляться с ближайшего к вашему клиенту сервера. Хотя Интернет очень быстр (конечно, он работает не со скоростью света, но с близкой к ней), данные будут доставляться еще быстрее с расстояния сотни километров, чем тысячи. Экономия времени в каждом отдельном случае незначительна, но, если умножить ее на количество пользователей, запросов и ресурсов, она быстро приобретет внушительные размеры.
На большую часть ваших статических ресурсов будут ссылаться в представлениях HTML
```
элементы ссылаются на CSS-файлы,
``` | https://habr.com/ru/post/542488/ | null | ru | null |
# История исследования одного jar трояна
Статья о том, как исследовать незнакомые \*.jar файлы.
Мне очень часто в ICQ приходит спам. Как правило, предлагают зайти на один из фэйковых «вконтакте» с опечаткой в имени. Но тут прислали просьбу авторизовать с ссылкой на фотографию. Сообщение банально, ничего нового, что-то вроде: «Хочу с тобой познакомиться, посмотри на фотку по ссылке ….., тебе будет интересно со мной сфоткаться». Ссылка не вела на фэйковый вконтакте, но предлагала скачать файл foto.jar.
Проверяем антивирусом – все ОК.
##### Беглый обзор
Становится интересно. Раскрываем архив и начинаем исследовать.
Файл jar содержал такие файлы:
Имеем дело с Java приложением. Скорее всего, для мобильных устройств. Смотрим любым редактором текстовых файлов файл **main.class** и видим подтверждение – в тексте программы есть вызовы **MIDlet**.
Осталось разобраться, что делает эта программа. Опять, воспользуемся текстовым редактором. Просмотрим файлы классов. В файле **a.class** ищем подсказку, что делает это приложение:
«MessageConnection, javax.wireless.messaging.TextMessage, sms://» – намекают нам, что приложение отправляет SMS.
Обычно на этом можно останавливаться. Файл, пришедший с ICQ спамом, который называют фотографией, на самом деле оказывается программой для мобильных устройств, которая отсылает SMS.
Параллельно, принято решение посмотреть, что же делает это приложение. Загружаю эмулятор, среду выполнения. В результате получаем:
Загружается форма с полосой прогресса, нажимаем ОК, полоса растет, в определенный момент, когда доходит до определенного процента — отправляется SMS.
Когда доходим до 100% — приложение «портится»
##### Погружение в код
Попытки найти прямо в коде классов номер, на который отсылают сообщение, не увенчались успехом. Стало интересно.
Для более глубокого исследования, декомпилируем исходники. Декомпиляция дала половинчатые результаты. Один декомпилятор не смог вскрыть метод startApp(), выдав ошибку. Потому после непродолжительного поиска был найден онлайн декомпилятор, который смог вскрыть все файлы, но в качестве имени переменных подставлял только “a”. Но этого было достаточно, чтобы понять логику приложения.
Весь результат декомпиляции приводить не буду, только наиболее значимые фрагменты:
Фрагмент функции **startApp()** класса **main.class**:
```
…….
this.a = "";
this.b = "http://ero.******.ws";
if(this.a == null) {
this.a = "";
……..
try {
b var1;
(var1 = this.a).a = var1.getClass().getResourceAsStream("/settings.xml");
var1.a = var1.a.available();
var1.a = new int[var1.a];
int var2;
for(var2 = 0; var2 < var1.a; ++var2) {
var1.a[var2] = var1.a.read();
}
………
```
Из этого фрагмента видно, что из файла **settings.xml** подгружается информация. И формируется строка с именем сайта.
```
public void commandAction(Command var1, Displayable var2) {
if(var1 == this.d) {
++this.a.b;
++this.a.d;
this.a.a += this.a.c;
if(this.a.d == 17) {
this.a.d = 0;
this.Sender();
}
if(this.a.b == 100) {
this.destroyApp(false);
}
this.a.repaint();
}
if(var1 == this.a) {
this.a.setCurrent(this.a);
}
if(var1 == this.c) {
this.notifyDestroyed();
}
if(var1 == this.b) {
try {
this.platformRequest(this.b);
} catch (ConnectionNotFoundException var3) {
var3.printStackTrace();
}
this.notifyDestroyed();
}
}
```
Когда достигаем 17%, вызываем **Sender()**. Когда достигаем 100% — вызываем **destroyApp()**, чтобы пользователь не смог запустить приложение еще раз. Переходим к процедуре **Sender()**.
```
public void Sender() {
if(this.a < this.a.length) {
a var1 = this.a;
(new Thread(var1)).start();
}
}
```
Запускается экземпляр переменной класса **a** в новом потоке.
Фрагмент кода класса a.
```
public final void run() {
try {
……..
this.a = "sms://" + this.a.a[this.a.a];
……..
this.a.send(this.a);
} catch (SecurityException var1) {
System.out.println("!!!!!!!!!!!");
} catch (Exception var2) {
this.a = false;
}
……..
}
```
Итак, итоги подведем.
Данное приложение распространяется через ICQ, поражает мобильные телефоны, пытается отправить SMS на номер, который хранится в файле settings.xml, номер кстати: **7781**.
Проверяем онлайн антивирусом опять.
**UPD. Спасибо за подсказанные ссылки MainNika**
Необфусцированные трояны с подобным механизмом работы:
[habrahabr.ru/blogs/java/112165](http://habrahabr.ru/blogs/java/112165/)
[habrahabr.ru/blogs/infosecurity/113017](http://habrahabr.ru/blogs/infosecurity/113017/)
[habrahabr.ru/blogs/personal/50072](http://habrahabr.ru/blogs/personal/50072/)
Вопрос по Java коду подобного трояна, с интересной дискуссией:
[habrahabr.ru/blogs/personal/75899](http://habrahabr.ru/blogs/personal/75899/) | https://habr.com/ru/post/118422/ | null | ru | null |
# Печать статей из Хабрахабра
Пытаетесь отпечатать статью с Хабра, а она не печатается? Пока создатели Хабра чинят свои стили, можно воспользоваться моим, доступным в виде букмарклета, стиля для Stylish или в исходном виде.
Он убирает всё, что не надо, чинит переносы текста на другой лист, уменьшает большие элементы, пополняет ссылки адресом.
Он не печатает комментарии. Если надо, будет.
Он не печатает заголовок. Браузер обычно сам этим занимается.
Он неизвестно как работает в Internet Explorer. Переходите на другой браузер.
Поскольку парсер Хабры очень строг, выложить букмарклет тут я не могу (или не умею) ни в каком виде. Есть два решения:
1. Перетащить его на панель закладок [с моего сайта](http://serve.sokolov.cc/habrahabrPrintStyle.html).
2. Создать новую закладку и ввести в поле «адрес» вот эту бандуру:
````
javascript:function addCss(z){var s=document.createElement('style');s.type = 'text/css';if(s.styleSheet){s.styleSheet.cssText=z;}else{s.appendChild(document.createTextNode(z));}document.getElementsByTagName('head')[0].appendChild(s);}addCss('*{background:white!important;color:black!important;overflow:visible!important;max-width:8.2in}h1,h2,h3,h4,h5,h6{page-break-after:avoid}pre,code,samp{white-space:pre-wrap;page-break-inside:avoid}ul,ol,li{page-break-inside:avoid}table table,tr,td{page-break-before:avoid;page-break-after:avoid}body>a,#header-wrapper,#header,#footer,#sidebar,.page-navigation,#comments,.entry-title .blog,.tags,.entry-info,.entry-title{display:none!important}.content{width:8.2in!important;margin:0!important;padding:0!important;float:none!important;color:black;font-size:12pt!important;line-height:120%!important;font-family:Georgia,serif!important}a{text-decoration:none!important;color:black!important}.content a:link:after,.content a:visited:after{content:" (" attr(href) ")";font-size:90%}');
````
Для обсуждения, код выложен и здесь:
````
* {
background: white !important;
color: black !important;
overflow: visible !important;
max-width: 8.2in;
}
h1,h2,h3,h4,h5,h6 { page-break-after: avoid }
pre,code,samp { white-space: pre-wrap; page-break-inside: avoid }
ul, ol, li { page-break-inside: avoid; }
table table,tr,td { page-break-before: avoid; page-break-after: avoid }
body > a,
#header-wrapper, #header, #footer, #sidebar,
.page-navigation, #comments, .entry-title .blog,
.tags, .entry-info, .entry-title { display: none !important }
.content { width: 8.2in !important;
margin: 0 !important;
padding: 0 !important; float: none !important;
color: black;
font-size: 12pt !important; line-height: 120% !important;
font-family: Georgia, serif !important }
a { text-decoration: none !important; color: black !important }
.content a:link:after,
.content a:visited:after { content: " (" attr(href) ")"; font-size: 90% }
````
Жду позитивных комментариев и исправлений грамматики. ^\_^ | https://habr.com/ru/post/38236/ | null | ru | null |
# (Как написать (Lisp) интерпретатор (на Python))
*Перевод статьи "(How to Write a (Lisp) Interpreter (in Python))" Питера Норвига. В данной статье Питер довольно кратко, но емко описывает принцип работы интерпретаторов и показывает как можно написать совсем крошечный (всего 90 строк на Python) интерпретатор подмножества языка Scheme. Перевод публикуется с разрешения автора.
Питер Норвиг (англ. Peter Norvig) — американский ученый в области вычислительной техники. В данный момент работает директором по исследованиям (ранее — директор по качеству поиска) в корпорации Google. Ранее являлся главой Подразделения вычислительной техники в исследовательском центре Амес NASA, где он руководил штатом из двухсот ученых, занимающихся разработками NASA в областях анатомии и робототехники, автоматизированной разработке ПО и анализа данных, нейроинженерии, разработки коллективных систем, и принятия решений, основанном на симуляции.*
Эта статья преследует две цели: в общих чертах описать имплементацию интерпретаторов языков программирования, а так же продемонстрировать реализацию подмножества языка [*Scheme*](http://ru.wikipedia.org/wiki/Scheme), диалекта Lisp, используя [Python](http://python.org/). Я назвал свой интерпретатор *Lispy* ([lis.py](http://norvig.com/lis.py)). Год назад я показывал как написать [интерпретатор Scheme на Java](http://norvig.com/jscheme.html), а так же [на Common Lisp](http://books.google.com/books?id=QzGuHnDhvZIC&lpg=PA756&vq=scheme%20interpreter&dq=Paradigms%20of%20Artificial%20Intelligence%20Programming&pg=PA753#v=onepage&q&f=false). На этот раз целью является демонстрация, кратко и доступно насколько возможно, того, что [Алан Кей назвал](http://queue.acm.org/detail.cfm?id=1039523) *«Уравнения Максвелла программного обеспечения»* (Maxwell's Equations of Software).
#### Синтаксис и семантика *Lispy*
Большинство языков программирования имеют различные синтаксические соглашения (ключевые слова, инфиксные операторы, скобки, приоритет операторов, точечная нотация, точки с запятой, и т.д.), но как у члена семьи языков Lisp, весь синтаксис Scheme основан на списках в скобочно-префиксной нотации. Эта форма может показаться незнакомой, но она имеет преимущества в простоте и согласованности. Некоторые шутят, что «Lisp» означает *«Много Раздражающих Глупых Скобок»* (Lots of Irritating Silly Parentheses), я считаю, это означает *«Lisp синтаксически чист»* (Lisp Is Syntactically Pure). Смотрите:
| Java | | Scheme |
| --- | --- | --- |
| `if (*x.val() > 0*) { *z = f(a \* x.val() + b);*}` | | `(if (> (val x) 0) (set! z (f (+ (* a (val x)) b))))` | | https://habr.com/ru/post/115206/ | null | ru | null |
# Использование URL-адреса функции AWS Lambda для создания бессерверного бэкенда для Slack
Сочетание сервисов AWS Lambda и Amazon API Gateway часто используется как архитектура для бессерверных микросервисов и решений на базе API. Эта архитектура позволяет разработчикам сосредоточиться на своих приложениях, а не тратить время на настройку и управление серверами.
API Gateway — это многофункциональное решение, включающее поддержку различных типов API (HTTP, REST, WebSocket), несколько схем аутентификации, возможность версионирования API, развёртывание Canary ([Canary Deployment](https://harness.io/blog/continuous-verification/blue-green-canary-deployment-strategies/)) и многое другое. Однако, если ваши требования скромнее, и всё, что вам нужно, это конечная точка HTTP(S) для вашей Lambda функции(например, для работы в качестве вебхука), вы можете использовать [URL-адреса функций Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-urls.html). Когда вы создаёте URL-функции, Lambda автоматически генерирует уникальную конечную точку HTTP(S), предназначенную для вашей функции.
В этой статье мы покажем на практическом примере, как использовать URL-адрес функции Lambda. Вы создадите [функцию Go Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-golang.html), которая будет служить бессерверным вебхук бэкендом для [Slack](https://slack.com/).
Данное пошаговое руководство содержит:
* Краткий обзор приложения.
* Настройку и развёртывание функции (наряду с некоторыми проблемами, на которые следует обратить внимание).
* Инструкцию, как настроить Slack, чтобы включить сквозную интеграцию.
* … Далее просто тестируйте приложение и получайте удовольствие.
К концу этого поста вы настроите, интегрируете и развернёте полезное (и, надеюсь, весёлое?) приложение с использованием URL-функции Lambda. В процессе вы получите общее представление об этой возможности и сможете использовать её при создании собственных решений.
> Код также [доступен на GitHub](https://github.com/abhirockzz/awsome-slack-backend).
Как это работает
----------------
Пример приложения, представленный в этом посте, представляет собой урезанную версию [Giphy для Slack](https://get.slack.help/hc/en-us/articles/204714258-Giphy-for-Slack). Оригинальное приложение Giphy для Slack возвращает кучу GIF-файлов по поисковому запросу, и пользователь может выбрать один из них. Чтобы упростить задачу, я немного изменил её таким образом, чтобы бессерверный бэкенд просто возвращал одно случайное изображение по ключевому слову поиска с помощью [Giphy Random API](https://developers.giphy.com/docs/#operation--gifs-random-get).
Поскольку решение будет интегрировано как [Slash-команда](https://api.slack.com/interactivity/slash-commands) в Slack, конечный пользователь будет вызывать его из рабочего пространства Slack, используя команду `/awsome <ваш поисковый запрос>` (где `awsome` — не что иное, как название slash-команды). Это, в свою очередь, вызовет URL-адрес функции Lambda (о её конфигурировании мы расскажем чуть позже), которая позаботится обо всём остальном.
К примеру, если вызвать её из рабочего пространства Slack, используя команду `/awsome serverless`, она вернёт случайную гифку (вы сами сможете попробовать это позже).
Вот общий обзор того, что делает функция Lambda:
* В результате вызова Slash Commands — Slack на URL-адрес функции Lambda отправляется строка с кодировкой base64 — поэтому первым шагом будет её декодирование.
* Предполагается, что функция вызывается только Slack, и нам нужно убедиться, что это так. Slack делает это возможным, позволяя приложениям проверять запросы, используя подписанный секрет ([signing secret](https://api.slack.com/authentication/verifying-requests-from-slack)) — функция просто реализует Go-версию метода сопоставления подписи, представленного [здесь](https://api.slack.com/authentication/verifying-requests-from-slack).
* Если проверка подписи прошла успешно (в случае неудачи мы возвращаем клиенту ошибку), запрос Slack парсится, чтобы извлечь текст (`text`) поиска, который отправил пользователь.
* Затем вызывается [Giphy Random API](https://developers.giphy.com/docs/api/endpoint#random) с поисковым запросом. Если мы получаем успешный ответ, то парсим его и отправляем обратно в Slack в нужном формате.
Наконец, пользователь может увидеть гифку в своём рабочем пространстве Slack.
Я пропущу подробное описание кода, чтобы сосредоточиться на других аспектах такого решения, но подпись функции заслуживает упоминания — она похожа на ту, что вы использовали бы в случае решения на базе API Gateway:
```
func Funcy(r events.LambdaFunctionURLRequest) (events.LambdaFunctionURLResponse, error) {
...
}
```
Мы используем [events.LambdaFunctionURLRequest](https://pkg.go.dev/github.com/aws/aws-lambda-go/events#LambdaFunctionURLRequest) в качестве входа и возвращаем [events.LambdaFunctionURLResponse](https://pkg.go.dev/github.com/aws/aws-lambda-go/events#LambdaFunctionURLResponse). За кулисами Lambda сопоставляет запрос с объектом события, прежде чем передать его функции. Наконец, ответ функции сопоставляется с HTTP-ответом, который Lambda отправляет обратно клиенту через URL-функции.
> Подробности вы можете прочитать в [документации](https://docs.aws.amazon.com/lambda/latest/dg/urls-invocation.html#urls-payloads).
Довольно удобно, верно? Вы можете использовать ассоциации API Gateway без необходимости устанавливать и настраивать такой шлюз.
С этой вводной информацией давайте перейдём к той части, где вы развернёте функцию и попробуете использовать её в Slack. Но перед этим убедитесь, что у вас подготовлено всё необходимое:
Рекомендуемые требования
------------------------
* [Создайте учётную запись AWS](https://portal.aws.amazon.com/gp/aws/developer/registration/index.html) (если у вас её ещё нет) и войдите в неё. Пользователь IAM, которого вы используете, должен обладать достаточными полномочиями для выполнения необходимых вызовов служб AWS и управления ресурсами AWS.
* Установите и настройте [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html).
* Установите [Go](https://go.dev/dl/).
* Установите [Git](https://git-scm.com/downloads).
* Создайте [рабочее пространство Slack](https://slack.com/create), если у вас его нет.
* Создайте учётную запись GIPHY (это бесплатно) и [создайте приложение](https://developers.giphy.com/dashboard/?create=true). Каждое созданное вами приложение будет иметь свой собственный API-ключ.
> Пожалуйста, запишите куда-нибудь ключ API GIPHY, так как вы ещё будете использовать его в дальнейшем
Склонируйте приведённый ниже репозиторий Github и переместите его в нужную директорию:
```
git clone https://github.com/abhirockzz/awsome-slack-backend
cd awsome-slack-backend/function
```
> В последующих шагах используется AWS CLI — я намеренно использовал AWS CLI, чтобы осветить определённые аспекты процесса. Также рекомендую ознакомиться с [этим руководством](https://docs.aws.amazon.com/lambda/latest/dg/urls-tutorial.html) по CloudFormation и SAM.
Создайте, заархивируйте и разверните функцию
--------------------------------------------
```
export FUNC_NAME=awsome-slack-backend
export FUNC_GO_BINARY_NAME=awsome
export ZIP_NAME=function.zip
GOOS=linux go build -o $FUNC_GO_BINARY_NAME main.go
zip function.zip $FUNC_GO_BINARY_NAME
```
Сначала создайте роль IAM для Lambda и подключите политику `AWSLambdaBasicExecutionRole`:
```
export ROLE_NAME=demo-lambda-role
ROLE_ARN=$(aws iam create-role \
--role-name $ROLE_NAME \
--assume-role-policy-document '{"Version":
"2012-10-17","Statement": [{ "Effect": "Allow", "Principal":
{"Service": "lambda.amazonaws.com"}, "Action": "sts:AssumeRole"}]}' \
--query 'Role.[Arn]' --output text)
aws iam attach-role-policy --role-name $ROLE_NAME --policy-arn
arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
```
Создайте функцию:
```
aws lambda create-function \
--function-name $FUNC_NAME \
--runtime go1.x \
--zip-file fileb://$ZIP_NAME \
--handler $FUNC_GO_BINARY_NAME \
--role $ROLE_ARN
```
После того как функция будет создана, перейдите к добавлению URL-адреса функции:
```
aws lambda create-function-url-config \
--function-name $FUNC_NAME \
--auth-type NONE
```
> Для этого пробного приложения мы используем NONE в качестве типа аутентификации. Это означает, что URL-адрес функции Lambda будет общедоступен — подробнее об этом расскажу чуть позже.
Если вы перейдёте в консоль AWS и откроете только что созданную функцию, вы увидите URL-адрес функции, связанный с ней:
Давайте вызовем функцию — скопируйте URL-функции и вставьте его в браузер или используйте любой другой инструмент (например, `curl`).
```
curl -i
```
Вы должны получить ответ `{"Message": "Forbidden"}` с кодом состояния `HTTP 403 Forbidden`.
> Не волнуйтесь, это вполне ожидаемо — я хотел убедиться, что вы столкнётесь с этой проблемой и поймёте её первопричину.
Даже если мы используем `NONE` в качестве схемы аутентификации, пользователи всё равно должны иметь разрешения `lambda:InvokeFunctionUrl`, чтобы успешно вызвать URL-функции. Сложность заключается в том, что когда вы создаёте URL-функции (с типом аутентификации `NONE`) через консоль или модель бессерверных приложений AWS (AWS Serverless Application Model), Lambda *автоматически* создаёт заявление для политики на основе ресурсов (подробности в [документации](https://docs.aws.amazon.com/lambda/latest/dg/urls-auth.html#urls-auth-none)). Это исключено, если вы используете AWS CLI (как в нашем примере), AWS CloudFormation или Lambda API напрямую — вы должны добавить разрешения самостоятельно.
Давайте сделаем это:
```
aws lambda add-permission \
--function-name $FUNC_NAME \
--action lambda:InvokeFunctionUrl \
--statement-id FunctionURLAllowPublicAccess \
--principal "*" \
--function-url-auth-type NONE
```
> Чтобы увидеть политику, перейдите к своей функции в консоли AWS: Конфигурация (Configuration) > Разрешения (Permissions).
Вызовите функцию снова:
```
curl -i
```
На этот раз вы получите другую ошибку с кодом состояния `HTTP 401 Unauthorized`. Это тоже вполне ожидаемо.
Давайте завершим остальную часть конфигурации, чтобы всё заработало.
Настроим Slack
--------------
> Обратите внимание, что большинство инструкций в этом разделе были адаптированы из [документации Slack](https://api.slack.com/slash-commands#creating_commands).
Начните со входа в [рабочее пространство Slack](https://slack.com/signin) и [создания нового приложения Slack](https://api.slack.com/apps/new).
После этого создайте ([Slash Command](https://api.slack.com/legacy/custom-integrations/slash-commands)) — перейдите на страницу настроек вашего приложения, а затем нажмите на функцию *Slash Commands* в навигационном меню. Перед вами появится кнопка «создать новую команду» (*Create New Command*), нажав на которую вы увидите окно, где вам будет предложено определить новую команду с косой чертой с помощью необходимой информации.
Введите необходимую информацию — `/awsome` для команды и URL Lambda функции в *Request URL*.
Наконец, установите приложение в рабочем пространстве — нажмите на функцию базовой информации (*Basic Information*) в навигационном меню, выберите пункт установки вашего приложения в рабочее пространство (*Install your app to your workspace*) и нажмите *Install App to Workspace*. Это позволит установить приложение в рабочую область Slack для тестирования вашего приложения и [генерирования токенов](https://api.slack.com/interactivity/slash-commands), необходимых для взаимодействия с API Slack.
Как только вы закончите установку приложения, на той же странице появится пункт с учётными данными приложения (*App Credentials*). Оттуда вам нужно взять свой подписанный секрет Slack (*Slack Signing Secret*).
> Запишите свой подписанный секрет, так как вы ещё будете использовать его позднее.
Обновление функции
------------------
Теперь, когда у вас есть подписанный ключ Slack, вам нужно позаботиться о том, чтобы он также был настроен и в функции. Также не забудьте про ключ API GIPHY, поскольку он нужен функции для вызова конечной точки GIPHY REST.
Давайте обновим функцию, чтобы включить их в качестве переменных окружения:
```
aws lambda update-function-configuration \
--function-name $FUNC_NAME \
--environment "Variables={SLACK_SIGNING_SECRET=,GIPHY\_API\_KEY=}"
```
> В этом примере для хранения ключей для Slack и GIPHY используются переменные среды Lambda — это сделано только в демонстрационных целях. Для безопасного хранения и управления учётными данными следует использовать такие решения, как [AWS Secrets Manager](https://aws.amazon.com/secrets-manager).
Всё готово!
-----------
Перейдите в своё рабочее пространство Slack и вызовите команду. Например, чтобы получить случайную гифку с кошечкой, просто введите:
```
/awsome cat
```
Я получил такой ответ с команды. А вы? :-)
Не стесняйтесь побаловаться с получившимся приложением.
Напоследок, приберёмся
----------------------
Как только вы закончите, удалите функцию вместе с политикой и ролью IAM.
```
aws lambda delete-function --function-name $FUNC_NAME
aws iam detach-role-policy --role-name $ROLE_NAME --policy-arn
arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
aws iam delete-role --role-name $ROLE_NAME
```
Заключение
----------
Вы настроили и развернули бессерверный бэкенд для Slack, и в процессе узнали о некоторых аспектах URL-адресов Lambda функций через призму примера этого приложения. Я бы рекомендовал вам изучить другие возможности, такие как [аутентификация AWS\_IAM](https://docs.aws.amazon.com/lambda/latest/dg/urls-auth.html#urls-auth-iam), [конфигурация CORS](https://docs.aws.amazon.com/lambda/latest/dg/urls-configuration.html#urls-cors), [ограничения дросселирования](https://docs.aws.amazon.com/lambda/latest/dg/urls-configuration.html#urls-throttling), [мониторинг](https://docs.aws.amazon.com/lambda/latest/dg/urls-monitoring.html) и т.д.
Счастливого кодинга!
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/667204/ | null | ru | null |
# Чудесное введение в программирование
Доброго времени суток хабр.
Хотел бы преподнести на суд общественности перевод одной чудесной статьи, в которой описаны базовые принципы программирования. Пару слов о том — зачем собственно это все и кому это надо? Отвечаю — последние несколько месяцев я, сам начинающий программист, активно пытаюсь обучать ребят из других сфер. В этом нелегком труде мне приходится шерстить интернет в поисках в первую очередь интересных материалов, чтобы разбить их стереотипы насчет того что код — это скучно и нудно. К моему глубокому сожалению, таких материалов не так уж много. Я уверен, есть огромное количество новичков, которые регулярно читают хабр и эта статья будет им крайне интересна и полезна.
Итак, оригинал [здесь](http://blog.learnstreet.com/fundamentals-of-coding/), автор Song Zheng.
#### Основы программирования
##### Часть 1. Простые примеры кода.
Возможно вы считаете, что программирование — это очень сложно. Но это не так. В действительности каждый из нас имеет навыки программирования. Не ожидали?
Давайте представим, что мы ведем машину и перед нами появляется знак «СТОП». И что вы сделаете? Вы остановитесь!
Глубоко в глубине нашего мозга, в сплетениях нейронов запрограммированны (На Ruby) примерно такие команды:
```
if self.saw(stopSign)
self.stopCar()
end
```
Чтобы вам было проще понять значение слова " self ", вы можете смело заменить его на " Я ", смысл останется прежним. В целом большинство языков программирования придерживается для своего синтаксиса следующего стиля:
```
существительное.глагол(предмет)
```
##### Разбираем этот пример
Существительное в этом примере называется Объектом. Объект умеет делать разные полезные действия.
Глагол из примера называется Методом или Функцией. Метод содержит пару строчек кода и это код выполняется каждый раз, когда вы его вызываете.
Например, где-то внутри вашей головы метод, отвечающий за остановку машины мог бы выглядеть вот так:
```
def stopCar()
self.stepOnBrakes()
self.lookLeft()
self.lookRight()
end
```
«Предмет» находящийся в скобках называется параметром. Это просто какие-то данные, которые мы хотели бы передать в наш метод.
Теперь представим что вы учитель и вы решили проявить акцию невиданной щедрости и раздать всем своим ученикам по конфетке (в оригинале " fabulous teacher", неприменимо для наших широт). Каждому своему ученику вы раздаете по Ферреро.
Если бы вы были компьютером, то в вашей голове выполнился бы примерно такой код:
```
for e in students
self.giveChocolateTo( e )
end
```
В этом коде вместо «е» подставляется по очереди каждый из ваших учеников, которому вы даете конфетку.
Как вы думаете, как можно было бы описать в коде то, как вы занимаетесь спортом? Например вот так:
```
while ( self.amStillAlive() )
self.keepRunning()
end
```
Стоит заметить, что 90% логики в программировании приходится на выражения ' if ' — для управления ходом выполнения задачи и циклов 'for' и 'while'.
Прежде чем идти дальше, я хотел бы показать вам пару строк кода, который вы можете запустить и посмотреть что из этого выйдет:
```
x = 0
while (x > -1)
x = x+1
end
```
Разберем пример.
Сначала мы сохраняем в переменную **x** значение равное 0. Затем, в течении того времени, пока **x** больше -1, мы увеличиваем значение в переменной **x** на 1.
Ожидаемый результат в этом примере — это бесконечный цикл, который будет раз за разом увеличивать значение переменной на единицу. Это приведет к тому что процессор вашего компьютера начнет усердно работать, согревая вас своими теплыми потоками воздуха. Идеально в качестве грелки в холодный зимний день =)
Знание циклов и условных операторов позволяет вам начать программировать прямо сейчас. Стоит теперь научиться правильно с ними работать. Вы должны уметь создавать объекты всегда, когда это потребуется.
##### Часть 2. Основы.
Представьте что вы Б-г и в 6-й день создания мира. Вы все 5 дней трудились в поте лица, а теперь предстоит создать миллионы людей за 1 день. Как это реализовать? Возможно стоит просто сесть и делать людей один за одним? Нет, все что вам надо так это макет, который описывает, как должен выглядеть человек, и затем с этого макета можно создать столько людей, сколько вы успеете до конца дня.
Собственно этот «макет» — есть один из базовых концептов программирования и зовется он — Класс. Каждый раз, когда вы чувствуете себя неловко при упоминании слова «Класс» — просто замените его на «Макет», это облегчит ваше восприятие.
Давайте представим, что вы — разработчик игр и вы хотели бы создать в этой игре множество разных персонажей. Для начала вам стоит создать класс с теми свойствами, которые вы хотели бы видеть в созданном из класса объекте:
```
class Character
def initialize(nameVariable, intelligenceVariable)
@name = nameVariable
@intelligence = intelligenceVariable
end
end
```
Метод ‘initialize’ выполняется каждый раз, когда создается новый объект и наделяет его теми свойствами, который вы описали в базовом классе. В методе мы задаем имя персонажа «nameVariable» и его уровень его интеллекта «intelligenceVariable» ( префикс " @ " является приставкой «self» для свойств персонажа ). Когда персонаж создан, создаются и его свойства. Давайте создадим 2-х персонажей — персонажа «А» и персонажа «Б»:
```
a = Character.new( "aperson", 10 )
b = Character.new( "bperson", 10 )
```
Для персонажа А мы задали 2 значения “aperson” и “10”, которые стали свойствами этого персонажа ( потому-что каждый раз при создании объекта выполняется метод «initialize» ).
В результате у нас есть 2 персонажа, одного из них зовут “aperson” и “bperson”, у которых уровень интеллекта равен 10.
Вы заметили как легко мы создали персонаж, всего лишь раз описав класс? Вы можете создавать объекты еще и еще, всего лишь вызывая Character.new(…). Например вот так:
```
x = 0;
while( x < 5,000,000,000 ){
Character.new( "Adam", x )
Character.new( "Eve", x )
x = x+1;
}
```
Вот таким образом и было создано 5 миллиардов Адамов и Ев, которым постепенно увеличивали значение интеллекта. Примерно вот так:
Теперь давайте представим, что каждый наш персонаж обладает способностью смотреть известное телешоу «Джерси Шоур». Т.к. эта способность касается всех персонажей, то стоит это указать в нашем макете-классе:
```
class Character
def initialize(nameVariable, intelligenceVariable)
...
end
def watchJerseyShore()
@intelligence = @intelligence - 2
end
end
```
С этого момента, каждый раз, когда персонаж будет использовать ‘watchJerseyShore’ метод, уровень его интеллекта будет снижаться. Например вот так:
```
a.watchJerseyShore()
a.watchJerseyShore()
```
Персонаж А посмотрел шоу 2 раза, соответственно уровень его интеллекта снизился до 6.
Возможно это не очевидно, но единственным способом как-то изменить значение интеллекта у персонажа — это вызвать метод watchJerseyShore(). Данная жесткость предотвращает возможность изменения значений у персонажа, в данном случае уровень интеллекта персонажа. Уровень интеллекта не может быть изменен случайно, его можно изменить только намеренно вызвав метод watchJerseyShore(). Эта важная концепция называется **Инкапсуляцией**, идея сводится к тому, чтобы доступ к свойствам объекта был ограничен. Например, если однажды, выпив лишнего, вы попытаетесь выполнить метод a.intelligence = 100000 — вы получите ошибку.
Ко всему прочему, если вы заходите создать класс «Тинейджер», у которого будут такие свойства как «имя», «интеллект» и который так-же смотрит шоу «Джерси Шоур», стоит ли вам слепо копировать весь тот код, который вы писали, описывая класс Персонаж? Нет! Все что вам необходимо сделать — унаследовать от базового класса его свойства. Если расширить класс Тинейджер классом Персонаж, то все свойства Персонажа унаследуются классом Тинейджер.
```
class Teenager < Character
end
```
Дальше можно просто создать объект Тинейджер:
```
teeny = Teenager.new( "teeny", 10)
```
Teeny — это объект класса Тинейджер с именем «Teeny» и уровнем интеллекта равным 10. Для того чтобы снизить уровень интеллекта нашего Teeny стоит просто посмотреть шоу Джерси:
```
teeny.watchJerseyShore()
```
Эта способность является важной концепцией и называется — **Наследование**.
Тинейджер рос не таким как все и вы решили изменить значение его метода, отвечающего за просмотр шоу Джерси Шоур. Вы могли бы изменить этот метод следующим образом:
```
class Teenager < Character
def watchJerseyShore()
@intelligence = @intelligence + 2
end
end
```
С этих пор, каждый раз как только тинейджер смотрит шоу Джерси, уровень его интеллекта увеличивается! Класс Тинейджеров может не только наследовать все методы и свойства от базового класса, он может так-же и переопределять их. Эта гибкость в переопределении методов, которые наследуются от базового класса — является важной концепцией и называется **Полиморфизмом**.
Все вместе — Инкапсуляция, Наследование и Полиморфизм составляют основу Объектно-ориентированных языков программирования. Если вы понимаете эти 3 принципа, то вам не составит труда постичь такие языки как Ruby, Java, Objective C, C#, Python и много много других.
##### END
Я попытался довольно вольно перевести некоторые части этой замечательной статьи. Я уверен что есть куда стремится в плане совершенствования подачи мысли в массы, так что судите строго, все будет учтено и исправлено.
Благодарю за внимание, искренне надеюсь что эта чудесная статья поможет начинающим в понимании 3-х краеугольных камней ООП. | https://habr.com/ru/post/180513/ | null | ru | null |
# Starline Hackathon 2020
Всем привет, с целью передачи опыта, а также для того, чтобы структурировать и закрепить весь тот объем информации, который пришлось перелопатить, я пишу эту статью. Я не ставлю перед собой целью изложить мануал по созданию нашего решения (тк [исходный код](https://github.com/urpylka/starline-hackathon/) и так полностью открыт). Подразумеваю, что основной интерес в том, чтобы изложить основые принципы построения подобных систем, изложить используемые источники, рассказать о том от чего мы отказались, и к чему мы пришли. Постараюсь сохранить баланс между количеством информацией и читаемостью.
Если вы не знаете что такое ROS советую к изучению ресурс [Voltbto.com](http://docs.voltbro.ru/starting-ros/), вот например [статья по работе с сервисами в ROS](http://docs.voltbro.ru/starting-ros/messaging/rabota-s-service.html).
В конце марта 2020 года компания Starline во второй раз в своей истории провела [хакатон](https://robofinist.ru/event/info/short/id/339).
По сравнению с [предыдущим хакатоном](https://robofinist.ru/event/info/short/id/239) ([youtube](https://www.youtube.com/watch?v=g4KLKweEs1E)), проведённым в октябре 2018 года, в этот раз сильно повысился уровень организации: был чёткий регламент, система оценки, равные условия для всех участников и сложное квалификационное задание - такое, каким и должно быть.
Организаторы в этот раз взяли высокую планку по сложности соревнований: настолько, что из 25 поданных заявок квалификацию прошли только 5. Для решения квалификационного задания было необходимо настроить роботу в [симуляторе](https://github.com/turtlebot/turtlebot_simulator) `gazebo` для проезда из одной точки в другую. Подробнее об этом [здесь](https://github.com/urpylka/starline-hackathon/blob/2020-2-stimulator_g/README.md).
Такой уровень не может не радовать: наконец в России появилось ещё одно хорошее соревнование по робототехнике для специалистов, а не для школьников. Кстати по этой теме, отнести к таким соревнованиям в России на данный момент я могу лишь несколько (мой личный рейтинг):
1. **Starline** Hackathon
2. **COEX** Hackathon
3. **Робофест** Autonet 18+
4. **UpGreat** [Зимний город](https://city.upgreat.one/final/) + очень крутая [статья на vc.ru](https://vc.ru/transport/96952-final-sorevnovaniya-bespilotnyh-avtomobiley-zimniy-gorod-s-kommentariyami-komand)
5. **Робокросс** [тык-1](https://www.russianrobotics.ru/activities/robokross-2019/), [тык-2](https://life.ru/p/1231991)
6. **Робофинист** РТК Экстремал Pro (информация есть [здесь](https://robofinist.ru/event/info/competitions/id/213))
7. **Крок** [Конкурс летающих роботов](https://habr.com/ru/company/croc/blog/192704/) [больше не проводит]
Все эти соревнования отличаются друг от друга достаточно сильно, но в них мне как специалисту было [бы] интересно участвовать.
Теперь расскажу немного про сам хакатон. Хотя по факту он уже таким не являлся, за исключением, возможно, жеребьевки участников без команды. В нём присутствовали все атрибуты соревнования: есть отборочные, заранее известное и чётко прописанное задание (а соответственно и подготовка).
Я [@urpylka](https://github.com/urpylka) с моим другом Артуром [@goldarte](https://github.com/goldarte) решили участвовать вдвоём (в предыдущий раз я занял третье место, а он – первое).
### Дано
Каждой команде был выделен робот Turtlebot E2 следующего содержания:
1. Платформа Kobuki
2. RGBD-камера Orbbec Astra
3. Rplidar A2
4. Компьютер Intel NUC [BOXNUC7I7BNH]
5. Дополнительная камера Logitech HD Pro C920
По условиям соревнования, для равенства всех участников, разрешалось только менять компоновку из представленных выше компонентов и использовать произвольное ПО. Ставить более мощный компьютер или дополнительные сенсоры, принесённые на площадку, запрещалось.
Изначально соревование должно было проходить 4 дня в неспешной обстановке, но в конце второго дня мы узнали о том, что организаторам пришлось сократить один день ввиду короновирусной обстановки в городе.
Организаторами изначально был построен целый город (7x7 клеток): из квадратных черных матов было сделано дорожное полотно с разметкой, а из коробок разного размера с прикрепленными иллюстрациями были оформленны дома. У каждого дома на полу малярной лентой была отмечена его позиция, чтобы если кто-то сместил дом, знал куда его вернуть на место. Это важно для возможности ориентации робота с помощью построенной карты.
В городе имелись препятствия (про расположение которых мы не знали заранее):
1. Светофоры
2. Знаки “Стоп”
3. Блоки “Дорожные работы”
4. Другие участники движения в виде статичных моделей машин
Также была сплошная разметка, где было запрещено движение по встречной полосе и пересечение самой полосы.
### Задание и решение
По заданию нужно было проехать из точки старта в неё же (при этом вернуться в точку старта нужно с другой стороны) с учетом всех препятствий и сделать это как можно больше раз за отведенное время. При этом нарушения накладывают временны́е штрафы.
Мы разделили решение на несколько частей и занялись ими по отдельности:
1. Стейт машина для управления роботом
2. Определение дорожной разметки и способ не пересекать сплошную
3. Машинное зрение для распознавания знаков “Стоп” и светофоров
4. Ориентация и перемещение робота по городу с использованием алгоритмов, доступных в ROS
В начале решения задач по техническому зрению, мы изначально понимали какие есть алгоритмы и как они работают. Хорошей кодовой базой и документацией к ней являются [мануалы для TurtleBot3 на robotis.com](http://emanual.robotis.com/docs/en/platform/turtlebot3/autonomous_driving/#ros-1-autonomous-driving), плюс в их репозитории с соревнований [autorace](https://www.youtube.com/watch?v=47YnSBAssOM): [turtlebot3*autorace*](https://github.com/ROBOTIS-GIT/turtlebot3_autorace)*,*[*https://github.com/ROBOTIS-GIT/turtlebot3*autorace*2020*](https://urpylka.com/posts/post-64/turtlebot3_autorace_2020)*. В этих репозиториях есть хорошие примеры:*
* [*Автоматическая парковка по разметке*](https://github.com/ROBOTIS-GIT/turtlebot3_autorace_2020/tree/master/turtlebot3_autorace_parking)*(правда разметка там упрощенная: всего одна дорожная полоса, плюс левая линия окращена в желтый цвет);*
* [*Распознание объектов*](https://github.com/ROBOTIS-GIT/turtlebot3_autorace_2020/blob/master/turtlebot3_autorace_traffic_light)*;*
* [*Реализация стейт-машины*](https://github.com/ROBOTIS-GIT/turtlebot3_autorace/blob/master/turtlebot3_autorace_core/nodes/core_node_mission)*.*
#### State Machine
*Идея решения изначально была следующая: Делаем стэйт-машину с двумя состояниями:*`GOTO_0`, `GOTO_1`. Они являются состояниями следования в точки `0` и `1` на карте соотвественно.
В момент, когда робот находится в точке `0`, на глобальную карту планировщика наносится препятствие, отмеченное красной линией; в момент, когда робот покидает точку `0`, на глобальной карте удаляется препятствие, отмеченное красной линией, и добавляется другое препятствие, отмеченное зелёной линией. Это нужно для того, чтобы глобальный планировщик не строил маршрутов, ведущих на точку старта по тому же пути, по которому из неё выехал робот.
По завершению (достижению точки) состояния циклично меняются. Так достигается то, что робот ездит кругами.
В состояниях `GOTO_0`, `GOTO_1` стэйт-машины проверяется, не был ли замечен красный свет светофора или знак “Стоп”. Если таковые были замечены, делаем остановку до окончания красного света или на одну секунду в случае знака.
Также впоследствии были добавлены состояния `INIT` и `IDLE`. В `INIT` мы включаем платформу, инициализируем объекты вспомогательных классов и переходим в состояние `IDLE`. Также перейти в состояние `IDLE` можно из `GOTO_0` и `GOTO_1`. В качестве фреймворка для state-machine было реализовано [собстсвенное решение](https://github.com/urpylka/starline-hackathon/blob/2020-2-stimulator_g/catkin_ws/src/solution_3/src/state_machine.py), построенное на базе [стэйт-машины Karn Saheb](https://dev.to/karn/building-a-simple-state-machine-in-python). В реализацию класса `StateMachine` добавлено поле `S`типа пустого класса `ObjectStorage`. Это позволяет организовать удобную работу с одними данными из разных состояний через `setattr(Class, Attr, Value)` и через его сокращенный вариант `Class.Attr = Value`.
#### Детекция разметки
В начале думали использовать, что вроде `lane-detection`:
1. [github/awesome-lane-detection](https://github.com/amusi/awesome-lane-detection)
2. [github поиск lane-detection](https://github.com/search?q=lane+detector)
3. [hackster.io curved-lane-detection](https://www.hackster.io/kemfic/curved-lane-detection-34f771)
Также завели конфигурирование `birdview` с помощью `dynamic_reconfigure`.
Затем посмотрели в сторону использования нейронных сетей для детектирования попутной полосы цветом `color-segmentation`. Нам понравилось решение [dheera/ros-semantic-segmentation](https://github.com/dheera/ros-semantic-segmentation). По размеченной цветом картинке можно высчитать координаты области и передавать эти данные в локальный планировщик.
На тему семантической сегментации изображений есть [статья](https://habr.com/en/post/452088/) на хабре.
Однако после тестов в симуляторе, мы поняли, что это решение ведет себя ненадежно, и в рамках соревнования нам нужно что-то иное. Идея пришла довольно быстро. Мы решили нанести на глобальную карту сплошную разметку.
Составленная карта для робота представляет собой растровое изображение. После составления начальной карты алгоритмом `gmapping` мы дорисовали её руками. Убрали помехи в виде случайно зафиксированных людей и роботов, а также нанесли сплошную разметку.
Затем нам нужно было как-то правильно выбирать полосу и не ехать по встречке. Мы решили динамически наносить на глобальную карту препятствия, таким образом, что если робот въезжает в радиус `R1` центра некоторого перекрестка, то во всех запрещенных встречных направлениях перекрестка строятся препятствия, до тех пор пока робот не отдалится от центра данного перекрестка на радиус `R2`.
#### Распознание объектов
В рамках ограниченного времени хакатона, было решено заранее поискать готовые инструменты для выделения нужных объектов на изображении. Одним из инструментов оказался ROS пакет [find\_object\_2d](http://wiki.ros.org/find_object_2d): он позволяет на лету сконфигурировать детектор фич и дескриптор для классификации объектов по заранее имеющимся картинкам, а также предоставляет список определённых объектов и их координат с матрицами гомографии в топик `/objects` и `objectsStamped`. Помимо выделения объектов нужно было, например, правильно распознать цвет светофора, поэтому помимо готовых решений пришлось применять решения из библиотеки [opencv](https://opencv.org/). Итоговым решением задачи по определению знака стоп и цвета светофора стала нода [detect\_objects\_node.py](https://github.com/urpylka/starline-hackathon/blob/2020-2-stimulator_g/catkin_ws/src/solution_3/src/detect_objects_node/detect_objects_node.py). Кстати вот [неплохой код](https://github.com/ooleksyuk/CarND-Capstone/blob/master/ros/src/tl_detector/tl_detector.py) из проекта по управлению машиной [CarND-Capstone](https://github.com/ooleksyuk/CarND-Capstone) в котором мы черпнули много полезного.
**Распознавание знака стоп**
Распознавание знака стоп было реализовано с помощью пакета `find_object_2d`. В качестве детектора фич и дескриптора был выбран ORB с увеличенным количеством итераций афинных преобразований для более робастного определения знака под разными углами. Все параметры распознавания доступны [здесь](https://github.com/urpylka/starline-hackathon/blob/2020-2-stimulator_g/catkin_ws/src/solution_3/objects/settings.ini). Для довольно уверенного распознавания знака с разных ракурсов хватило вот этой картинки:
С помощью матрицы гомографии, данные которой уже в готовом виде присутствуют в топике `/objects`, можно восстановить перспективу и размеры объекта для добавления ограничений по размеру знака при его распознавании.
Для удобной интеграции распознавания знака с машиной состояний был реализован сервис `detected_stop`, который возвращает информацию о том, распознан знак или нет.
Для настройки некоторых параметров детектора был применён механизм динамической конфигурации параметров [dynamic\_reconfigure](http://wiki.ros.org/dynamic_reconfigure), который позволяет на лету (что особенно актуально в условиях ограниченного времени) подобрать нужные параметры через инструмент [rqt](http://wiki.ros.org/rqt_reconfigure). Например вот так мы настраивали распознание красного света светофора:
**Распознавание светофора и его цвета**
С распознаванием светофора ситуация оказалась менее очевидной. Изначально был план с помощью `find_object_2d` определить границы светофора и уже внутри этих границ определять цвет светофора. Но возникло несколько проблем. Во-первых изображение светофора с гораздо меньшим успехом определялось на тех же детекторах, что и знак стоп (с другими за короткое время успеха добиться тоже не удалось). Во-вторых надёжность определения границ светофора страдала при переключении его цвета. Поэтому по ходу тестирования определения объектов на хакатоне пришлось переключиться и придумать другой способ.
Рабочий алгоритм по выделению цвета светофора выглядел следующим образом: вначале на изображении выделяются области определённой насыщенности в цветовом пространстве HSV, затем среди этих областей производится поиск областей, наиболее похожих на круг (методом Hough Circles) с определёнными границами по размеру. Если такие области есть - мы определили, что находимся у светофора с определённым цветом.
Минусов такого алгоритма определения состояния светофора было много - как минимум любой объект красного цвета, похожий на круг, мог сбить нас с толку (что и произошло при первом запуске на соревновании). Но также был рассчёт на то, что затянув ограничения должным образом, мы избавимся от ложных случаев и увеличим количество правильных распознаваний состояния светофора, с учётом того, что в помещении не было других красных круглых объектов.
Особенным моментом стало то, что мы не могли использовать видимое изображение с камеры Astra в виду очень узкого угла обзора. А также не особо подходила камера `Logitech HD Pro C920`также из-за достаточно узкого угла обзора установленная камера внутри робота не позволяет увидеть знак с другого края дороги – нужна более широкоугольная камера. Мы же более-менее решили эту проблему с выносом камеры за пределы робота.
#### Navigation Stack
Приведу схему ROS Navigation Stack (информация взята из [презентации PhD Paul‑Edouard Sarlin](https://github.com/Skydes/Turtlebot-Navigation-Stack/blob/master/doc/presentation/presentation.pdf)) для общего понимания процессов.
* **Map prior**: что заранее известно о окружающей среде
* **Kinect**: камера глубины, возвращающая облако точек
* **Odometry**: позиция робота в лабиринте
* **Map updater**: обрабатывает данные для создания и обновления внутренней карты окружающей среды
* **Global planner**: вычисляет маршрут от начальной точки в цель, используюя карту
* **Local planner**: выполняет и корректирует с учетом обстановки процесс перемещения робота по построенному маршруту
Для управления роботом используется [супер-пакет](https://github.com/ros-planning/navigation) `navigation`, он содержит в себе `move_base`([утилита](http://wiki.ros.org/move_base) для управления роботом через угловые скорости) и два планировщика: локальный и глобальный. Планировщик – это программа, которая, опираясь на положение робота на карте окружающего пространства, может построить маршрут в заданную координату. Локальный планировщик работает с небольшим участком карты в ограниченном пространстве вокруг робота с учётом данных с датчиков робота об окружающих объектах. Глобальный планировщик строит общий маршрут, ориентируясь по всей карте, без учета возможного появления новых препятствий.
Полезным к изучению будет [мануал](http://wiki.ros.org/navigation/Tutorials/RobotSetup) по настройке Navigation Stack на роботе. И туда же очень хорошая [статья](https://blog.zhaw.ch/icclab/configuring-the-ros-navigation-stack-on-a-new-robot/) по настройке ROS Navigation Stack.
> Также вышел [новый пакет](https://github.com/locusrobotics/robot_navigation) `robot_navigation`, как замена старому.
>
>
Для решения задачи ориентирования по построенной карте мы использовали стандартный алгоритм `amcl`. В него мы передавали подготовленную карту без разметки, чтобы алгоритм не сходил с ума, когда не видел разметки с помощью лидара.
Вместо стандартного локального планировщика мы решили использовать `teb_local_planner` ([github](https://github.com/rst-tu-dortmund/teb_local_planner)), который написали ребята из [TU Dortmund University](https://github.com/rst-tu-dortmund). Несколько ссылочек c примерами:
* [https://github.com/rst-tu-dortmund/teb*local*planner*tutorials*](https://github.com/rst-tu-dortmund/teb_local_planner_tutorials)
* [*http://wiki.ros.org/navigation/Tutorials/Navigation%20Tuning%20Guide#The*Local*Planner*](http://wiki.ros.org/navigation/Tutorials/Navigation%20Tuning%20Guide#The_Local_Planner)
* [*http://wiki.ros.org/teb*local*planner/Tutorials*](http://wiki.ros.org/teb_local_planner/Tutorials)
*Для описанных выше вещей нужно было как-то добавлять препятствия, построенные на отдельных картах в планировщик или на глобальную карту, которую также кушает планировщик.*
*В планировщиках обычно используются простые по назначению слои:*
* `obstacle_layer` – динамические препятствия ([пример](https://stackoverflow.com/questions/44194541/obstacle-inflation-in-costmap-2d) настройки Obstacle inflation in costmap2d)
* `inflation_layer` – утолщение препятствий
* `static_layer` – статичная карта
Каждый слой должен быть определнного типа:
* `costmap_2d::StaticLayer` – препятствия, построенные на базе заданной статической карты
* `costmap_2d::ObstacleLayer` – препятствия добавляемые с помощью топика типа `LaserScan` или `PointCloud`
* `costmap_2d::InflationLayer` – добавляет в `costmap` линию некоторого радиуса и определнной плотности вокруг препятствий
* `costmap_2d::VoxelLayer` – добавление 3D объектов
Помимо использования обычного набора слоев, можно добавить свой. Однако у меня после добавления слоя типа `costmap_2d::StaticLayer`, содержащего сплошную разметку, получаемый `costmap` был с сильными дефектами.
Подробнее про `costmap_2d` вы можете прочитать в официальной документации [здесь](http://wiki.ros.org/costmap_2d). Там вы можете найти примеры конфигураций ([1](http://wiki.ros.org/costmap_2d/Tutorials), [2](http://wiki.ros.org/costmap_2d/Tutorials/Creating%20a%20New%20Layer), [3](http://wiki.ros.org/costmap_2d/Tutorials/Configuring%20Layered%20Costmaps)), описание простых типов ([staticmap](http://wiki.ros.org/costmap_2d/hydro/staticmap), [obstacles](http://wiki.ros.org/costmap_2d/hydro/obstacles)), описание [flat](http://wiki.ros.org/costmap_2d/flat) и [layered](http://wiki.ros.org/costmap_2d/layered).
Также я нашел решение [Sr4l/virtual*obstacles*](https://github.com/Sr4l/virtual_obstacles)*, которое представляло из себя Costmap Plugin для добавления слоев типа*`costmap_2d::MovingObjects`. У проекта была не очень хорошая документация, поэтому я написал [Lars Kistner](https://github.com/Sr4l) и он дополнил репу и прислал еще дополнительные инструкции и интересное [видео](https://www.youtube.com/watch?v=L57m816jgKE), где он это использует. Однако я не успел завести это решение и решил использовать что-то более топорное. В дальнейшем наверное правильнее будет использовать его решение.
*Для построения препятствий на карте я написал*[*реализацию*](https://github.com/urpylka/starline-hackathon/blob/2020-2-stimulator_g/catkin_ws/src/solution_3/src/publish_wall_to_costmap.py)*рисования линий с помощью простейшего*[*алгоритма Брезенхэма*](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%91%D1%80%D0%B5%D0%B7%D0%B5%D0%BD%D1%85%D1%8D%D0%BC%D0%B0)*.*
*Для динамического слияния (наложения) карт я написал*[*Maps Merger*](https://github.com/urpylka/starline-hackathon/blob/2020-2-stimulator_g/catkin_ws/src/solution_3/src/merge_grids.py)*.*
*Итого у нас получилось пять карт:*
1. `/maps/map_amcl` – чистая карта, полученная с помощью алгоритма `gmapping` (подробнее о построении карты [здесь](http://learn.turtlebot.com/2015/02/01/11/))
2. `/maps/map_mb` – `/maps/map_amcl` + нарисованные сплошные линии (**передавалась в глобальный планировщик**)
3. `/maps/crossroads` – карта с динамически наносимыми на неё перекрестками
4. `/maps/start_wall` – карта с динамически наносимыми на неё стенками у точки старта
5. `/maps/map_merged` - карта динамически строящаяся из `/maps/map_mb`, `/maps/crossroads`, `/maps/start_wall`(**передавалась в локальный планировщик**)
> *Статические карты поднимаются с помощью стандартной*[*утилиты*](http://wiki.ros.org/map_server)`map_server`*входящей в стек*`navigation`*.*
>
>
*После настроек стека навигации можно выполнить следующую команды для теста робота:*
```
rostopic pub /move_base_simple/goal geometry_msgs/PoseStamped '{header: {stamp: now, frame_id: "map"}, pose: {position: {x: 0.674, y: 0.119, z: 0.0}, orientation: {w: 1.0}}}'
# PS Координаты и фреймы должны быть ваши (выбраны исходя из используемых карт)
```
Подробнее о том как сделать проверку написано [здесь](http://learn.turtlebot.com/2015/02/03/11/). Также чтобы робот не дергался при старте и остановке (при заданных высоких скоростях) можно настроить `velocity_smoother`, подорбнее об этом [здесь](https://github.com/gpldecha/turtlebot-navigation/blob/master/turtlebot_nav/launch/includes/velocity_smoother.launch.xml).
***Другие интересные источники по теме***
* [Статья](https://roboticsknowledgebase.com/wiki/state-estimation/ros-cost-maps/) по использованию `costmap_2d` для квадракоптера на Pixhawk
* [Статья Layered Costmaps for Context-Sensitive Navigation](http://wustl.probablydavid.com/publications/IROS2014.pdf) David V. Lu, Dave Hershberger, and William D. Smart
* [Работа Fast Gaussian Process Occupancy Maps. In 2018 15th International Conference on Control, Automation, Robotics and Vision (ICARCV) (pp. 1502–1507). IEEE.](https://github.com/STAR-Center/fastGPOM) Yuan, Y., Kuang, H. & Schwertfeger, S. ([Файл gpmaps.py](https://github.com/STAR-Center/fastGPOM/blob/master/gp_occ_mapping/src/scripts/gpmaps.py))
* [Супер-пакет](https://github.com/ros/geometry2) ROS `geometry2` для проведения преобразований. Примеры [здесь 1](https://answers.ros.org/question/35844/help-with-navigation-error-transform-from-base_link-to-map/) и [здесь 2](https://github.com/goldarte/arucow/blob/master/aruco_destination_pose.py).
* [Утилита](https://wiki.ros.org/occupancy_grid_utils) `occupancy_grid_utils`
* Также ребята из того же [TU Dortmund University](https://github.com/rst-tu-dortmund) написали `costmap_converter` утилиту позволяющую вынимать примитивы из `costmap`. Исходный код выложен на [github](https://github.com/rst-tu-dortmund/costmap_converter), софт написан с использованием алгоритма [DBSCAN](https://en.wikipedia.org/wiki/DBSCAN).
* [Аналог](https://github.com.cnpmjs.org/stonier/cost_map) для `costmap_2d`, Это [библиотека](https://github.com.cnpmjs.org/stonier/cost_map) C++, прямо аналогичная библиотеке GridMap ETHZ ASL, но разработанная для использования с затратами, когда элемент данных представляет собой беззнаковый символ (в отличие от двойников grid\_map).
#### Определение препятствий
Некоторые команды просто убирали несколько уровней платформы TurtleBot и использовали только лидар. Мы же решили разделить эти задачи и завести их на разные сенсоры.
Для детекции других участников движения и блоков дорожных работ мы решили исопльзовать RGBD-камеру с программной проекцией облака точек в плоскость на заданной высоте (и в дальнейшем использованием этого решения в качестве лидара). Эту информацию мы передавали в локальный планировщик, который выполнял дорисовку карты и перепостроение маршрута для объезда препятствий.
Для реализации алгоритма SLAM мы использовали лидар, расположенный наверху робота, он не цеплял динамических препятствий, и тем самым снижалась вероятность возникновения ошибки.
Также для детекции более низких препятствий, нам пришлось сместить RGBD-камеру ниже.
### Итог
В этот раз занять призовое место не удалось. Проблема заключалась в том, что мы слишком сосредоточились на прикладных вещах и рассчитывали, что отлаженный в симуляторе `teb_local_planner` будет работать также хорошо. По сути это основной механизм в софте, отвечающий за перемещение. Каково было наше удивление, когда за два часа до защиты мы поняли, что робот даже нормально развернуться не может. В итоге мы потратили последние 2 часа в попытке отладить планировщик, и робот поехал. Однако на первом же повороте робот застрял, увидев препятствие, между которым до сплошной полосы оставалось небольшое пространство. Он не смог перестроить глобальный маршрут из-за ограничений планнера и застрял, замкнувшись в бесконечном цикле попыток въехать и выехать за пределы мётрвой зоны, куда он сам себя загнал.
Как результат выиграли более простые примитивные решения, которые либо обходили все по правилу прохождения лабиринта, либо двигались по заранее сохраненному маршруту и не считывали ни светофоров, ни знаков.
У нас же была очень круто проведененная неделя в Питере в компании специалистов и друзей. Мы очень благодарны компании [Starline](https://www.starline.ru/), в частности: Алексею Хованскому, Николаю Дема, Александру Никифорову, Кириллу Гореву, Веденину Даниилу и Маркеловой Виктории.
Бонусом укажу пару-тройку ссылочек на ресурсы ребят и компанию ораганизавторов:
* [developer.starline.ru](https://developer.starline.ru/) – открытое API некоторых продуктов Starline.
* [Портал РобоФинист](https://robofinist.ru/), кстати его основным разработчик является всего один человек – Кирилл Горев. А еще на этом [портале](https://robofinist.ru/event/info/media/id/339) вы можете найти больше фоточек с этого замечательного мероприятия.
* [YouTube канал Николая Дема](https://www.youtube.com/channel/UCiGwbcr2f2ON77etnY-aVxw). Коля крутой робототехник и на его ютубчике периодически появляются интересные видосы.
На этом всё, спасибо большое за прочтение! | https://habr.com/ru/post/529790/ | null | ru | null |
# Реализация и оптимизация генератора уровней в Unity
В мае этого года мы обсуждали алгоритм, который используем для генерации внешнего мира в игре Fireside. Сегодня мы возвращаемся к этой теме. В прошлый раз нам удалось [сгенерировать набор точек на текстуре с помощью фильтрации шума Перлина](https://linusgaertig.itch.io/fireside/devlog/146441/a-concept-for-procedural-level-generation). Хотя это решение удобно, оно имеет две важные проблемы:
1. Оно не особо быстрое
2. На самом деле мы не создавали ассетов в Unity
Давайте устраним эти проблемы. Сегодня мы:
1. Создадим в Unity фреймворк, который позволит нам использовать алгоритм генерации текстур
2. При помоги сгенерированных текстур создадим ассеты в игровом мире
3. Распараллелим генерацию текстур с помощью C# System.Threading.Tasks, чтобы ускорить процесс
Интеграция генерации карт в движок Unity
----------------------------------------
Мы будем писать Scriptable Objects движка Unity для создания модульного окружения в целях генерации карт. Таким образом, мы дадим гейм-дизайнерам свободу настройки входных данных алгоритма без необходимости работы с кодом. Если вы ещё не слышали о ScriptableObjects, то рекомендую для начала изучить [документацию](https://learn.unity.com/tutorial/introduction-to-scriptable-objects#) Unity.
Сначала нам потребуется набор различных контейнеров данных. Наш конвейер довольно сложен, и если поместить все необходимые параметры в один объект, он окажется слишком объёмным. Поэтому мы будем использовать по одному пакету данных на каждый уровень алгоритма.
Итак, карта составляется из одного или нескольких сегментов (slice), состоящих из одного или нескольких фрагментов (chunk), созданных из одной или нескольких текстур. Примечание: в большинстве алгоритмов этап сегментов пропускается, но я включил этот этап для дизайна конкретной игры и генерации путей; о причинах я расскажу в этой статье. Можно без проблем игнорировать сегменты и всё равно реализовать описанное здесь решение. При помощи очень удобного [ExtendedScriptableObjectDrawer](https://gist.github.com/tomkail/ba4136e6aa990f4dc94e0d39ec6a058c) Тома Кэйла мы можем расширить настройки для простоты редактирования.
Здесь вы видите, какой тип данных и на каком уровне мы упаковываем. По сути, каждая генерируемая нами текстура будет распределять один ассет карты. Поэтому чтобы получить разнообразное распределение ассетов, нам нужно наложить друг на друга множество текстур. Разбиение карты на фрагменты и сегменты позволяет нам изменять генерируемые ассеты в соответствии с расстоянием от точки начала координат.
| | |
| --- | --- |
| **Уровень** | **Тип данных** |
| Map (Карта) | * Конвейер, используемый для генерации текстур
* Масштаб, сопоставляющий пространство текстуры с мировым пространством
* Параметры для дорог
* Seed
* Какой сегмент (slice) будет использоваться на каком расстоянии от точки начала координат
|
| Slice (Сегмент) | * Какой фрагмент (chunk) используется в зависимости от расстояния до центра сегмента
|
| Chunk (Фрагмент) | * Сопоставление между текстурами и ассетом, который должен располагаться на точках, сгенерированных из текстуры
* Текстурные параметры для каждой текстуры
* Текстурные параметры для пути
|
| Texture (Текстура) | * Все параметры, описанные в первой части нашего девлога по процедурной генерации карт.
|
Каждый уровень данных имеет связанный с ним класс C#, использующий паттерн «фабрика», который мы применяем для выполнения логики каждого этапа. Если бы мы хотели только распределять ассеты, то этапы генерации были бы очень простыми. Однако нам также нужно создать пути, по которым будет двигаться игрок. Это немного усложняет архитектуру, потому что после генерации точек нам нужно соединить фрагменты и сегменты.
| | | |
| --- | --- | --- |
|
Генератор карт |
Генератор сегментов |
Генератор фрагментов |
Если не учитывать пока генерацию путей, то единственная логика, которая нам сейчас нужна — это преобразование сгенерированных на текстуре точек в мировое пространство. Это реализуется благодаря использованию параметра масштабирования из параметров карты, что обеспечивает нам удобный контроль над плотностью размещения ассетов.
| | | |
| --- | --- | --- |
|
scale = 25 |
scale = 50 |
scale = 75 |
```
internal static Vector3 TexturePointToWorldPoint(
Vector2Int texturePoint,
float scale,
Plane plane,
Vector3 origin,
ProceduralTextureGenerationSettings settings)
{
float tx = (float)texturePoint.x / (float)settings.width;
float ty = (float)texturePoint.y / (float)settings.height;
Vector3 right = GetRight(plane) * scale * tx;
Vector3 up = GetUp(plane) * scale * ty;
return origin + right + up;
}
```
Поскольку мы сохранили кажду точку в мировом пространстве со связанным с ней префабом, для расположения ассетов достаточно просто вызвать Instantiate для префаба, ссылка на который указана в соответствующем слое параметров фрагмента. Единственное, что нужно учитывать — наш алгоритм не гарантирует, что ассеты не наложатся друг на друга. Пока мы применим такое решение: дадим каждому префабу коллайдер и будем уничтожать все ассеты, с которыми пересекаемся при создании экземпляра префаба. Как сказано в нашем предыдущем девлоге, нужно вызвать Physics2D.SyncTransforms() и yield return new WaitForFixedUpdate(), чтобы проверки коллизий работали правильно.
```
public IEnumerator PlaceAssets(Chunk chunk)
{
GameObject chunkObject = new GameObject("Chunk::" + chunk.settings.name);
chunkObject.transform.SetParent(worldRoot);
ContactFilter2D cf2d = new ContactFilter2D();
foreach (int layerIndex in chunk.generatedLayerAnchors.Keys)
{
GameObject layerParent = new GameObject();
layerParent.name = chunkObject.name + "::" + "Layer::"+chunk.generatedLayerAnchors[layerIndex].Item1.asset.name;
layerParent.transform.SetParent(chunkObject.transform);
foreach (Vector3 point in chunk.generatedLayerAnchors[layerIndex].Item2)
{
PlaceableAsset inst = Instantiate(chunk.generatedLayerAnchors[layerIndex].Item1.asset, layerParent.transform);
inst.transform.position = point;
Collider2D[] cols = new Collider2D[16];
Physics2D.SyncTransforms();
int numOverlaps = Physics2D.OverlapCollider(inst.mapgenerationCollider, cf2d, cols);
for (int i = 0; i < numOverlaps; i++)
{
if (cols[i].transform.parent != null &&
cols[i].transform.parent.TryGetComponent(out PlaceableAsset toDestroy))
Destroy(cols[i].transform.parent.gameObject);
}
}
yield return new WaitForFixedUpdate();
}
}
```
Вот и всё! Нам удалось преобразовать наш эксперимент на Processing в работающую систему на движке Unity! Но, увы…
Она медленная
Ускоряем работу
---------------
Мы улучшили наш алгоритм, распараллелив его. Так как мы генерируем набор независимых друг от друга текстур (но зависящих от лежащего в их основе шума Перлина), то можно распараллелить генерацию текстур в каждом фрагменте и даже распараллелить генерацию фрагментов.
В официальной документации C# написано, что async / await [являются базовой функциональностью C#](https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/features). Хотя я хорошо знаком с другими возможностями. перечисленными на этом сайте, до начала проекта я не использовал ни async, ни Tasks. Основная причина заключается в том, что в Unity есть похожая функциональность. И это… (барабанная дробь) корутины. На самом деле, в руководствах по программированию на C# [в качестве примера](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/async/task-asynchronous-programming-model) используется стандартный способ применения корутин (выполнение запроса к серверу). Это объясняет, почему я (и многие другие Unity-разработчики, которых я знаю) пока не использовал пока асинхронное программирование на C#. Однако это очень полезная возможность и мы используем её, чтобы распараллелить генерацию карт.
```
//Foo prints the same result as Bar
void Start(){
Foo();
}
async Task Foo()
{
Debug.Log(“Hello”);
await Task.Delay(1000);
Debug.Log(“There”);
}
void Start(){
StartCoroutine(Bar());
}
IEnumerator Bar(){
Debug.Log(“Hello”);
yield return new WaitForSeconds(1.0f);
Debug.Log(“There”);
}
```
Вот краткое введение в асинхронное программирование. Как и в случае с корутинами, при реализации асинхронного метода нам нужно возвращать особый тип (Task). Кроме того, нужно пометить метод ключевым словом async. Затем можно использовать ключевое слово await таким же образом, каким бы мы использовали оператор yield в корутине.
Однако существует также очень удобный метод Task.WhenAll, который создаёт Task, блокирующий исполнение, пока не будет завершён набор задач. Это позволяет нам реализовать следующее:
```
//Generates textures for all layers in parallel.
foreach (ChunkLayerSettings setting in settings.chunkLayerSettings)
{
//generate texture for this chunk
textureTasks.Add(textureGenerator.GenerateTextureRoutine(
setting.textureSettings,
seed,
chunkCoords,
new TextureGenerationData(seed, chunkCoords, setting.textureSettings)));
}
result = await Task.WhenAll(textureTasks);
```
В отличие от корутин, эти задачи выполняются параллельно и не тратят время выполнения в основном потоке. Теперь мы просто можем использовать такой подход при генерации как фрагментов, так и текстур. Это значительно увеличивает производительность: с примерно 10 секунд на сегмент до 3 на сегмент.
При этом мы получаем алгоритм, способный генерировать достаточно сложные и обширные карты примерно за 10 секунд (3 сегмента). Возможны дальнейшие оптимизации, а производительностью можно управлять с помощью размера используемых текстур. | https://habr.com/ru/post/520582/ | null | ru | null |
# Наглядное руководство по SSH-туннелям
***Прим. переводчика:*** *автор статьи рассматривает практические сценарии и примеры организации SSH-туннелей. А для более наглядного объяснения того, как это работает, графически показывает потоки трафика.*
Туннели SSH — это зашифрованные TCP-соединения между клиентами и серверами SSH. Трафик входит с одной стороны туннеля и прозрачно выходит с другой. Изначально этот термин относился к туннелям на виртуальных сетевых интерфейсах TUN/TAP, однако сейчас так обычно называют проброс портов SSH.
Например, вот так будет выглядеть схема обратного туннеля, в котором обращение к порту 80 SSH-клиента выполняется через SSH-сервер с определенного IP-адреса (`1.2.3.4`):
Здесь и далее все схемы взяты из оригинала статьиСценарии использования туннелей\*:
* Предоставление зашифрованных каналов для протоколов, передающих данные «открытым текстом».
* Открытие бэкдоров в частные сети.
* Обход межсетевых экранов.
\*. ПримечаниеПеречень дополняется. Не стесняйтесь предлагать примеры или исправления
[на GitHub](https://github.com/linrock/ssh-tunnels).
Проброс портов
--------------
Перенаправляет порт из одной системы (локальной или удаленной) в другую.
### Проброс локального порта
Проброс локальных портов позволяет перенаправить трафик с SSH-клиента на целевой хост через SSH-сервер. Другими словами, можно получить доступ к удаленным сервисам по зашифрованному соединению так, как будто они локальные. Примеры использования:
* доступ к удаленному сервису (Redis, Memcached и т. д.) по внутреннему IP-адресу;
* локальный доступ к ресурсам, размещенным в частной сети;
* прозрачное проксирование запроса к удаленному сервису.
### Проброс удаленного порта
Проброс удаленного порта позволяет направить трафик с SSH-сервера в пункт назначения либо через SSH-клиент, либо через другой удаленный хост. Открывает пользователям в публичных сетях доступ к ресурсам в частных сетях. Примеры использования:
* открытие доступа к локальному серверу разработки через публичную сеть;
* предоставление доступа с ограничением по IP-адресу к удаленному ресурсу в частной сети.
### Динамический проброс портов
При динамической переадресации портов на SSH-клиенте поднимается SOCKS-прокси для перенаправления TCP-трафика через SSH-сервер на удаленный хост.
Пересылка с системных (privileged) портов
-----------------------------------------
Для пересылки трафика с системных портов (1–1023) необходимо запустить SSH с правами суперпользователя в системе, на которой открывается порт.
```
sudo ssh -L 80:example.com:80 ssh-server
```
### Флаги командной строки SSH
Ниже приведены несколько полезных флагов при создании туннелей:
```
-f # переводит процесс ssh в фоновый режим;
-n # предотвращает чтение из STDIN;
-N # не выполнять удаленные команды. Полезно, если нужно только перенаправить порты;
-T # отменяет переназначение терминала.
```
Вот пример команды для создания SSH-туннеля в фоновом режиме и проброса локального порта через SSH-сервер:
```
ssh -fnNT -L 127.0.0.1:8080:example.org:80 ssh-server
```
Для краткости примеры ниже приводятся без флагов командной строки.
Проброс локального порта
------------------------
Перенаправление соединений с порта локальной системы на порт удаленного хоста:
```
ssh -L 127.0.0.1:8080:example.org:80 ssh-server
```
Перенаправляет локальные подключения к *127.0.0.1:8080* на 80-й порт *example.org* через SSH-сервер. Трафик между локальной системой и SSH-сервером идет по SSH-туннелю. Трафик между SSH-сервером и *example.org* — нет. С точки зрения *example.org* трафик идет от SSH-сервера.
```
ssh -L 8080:example.org:80 ssh-server
```
```
ssh -L *:8080:example.org:80 ssh-server
```
Команды выше открывают доступ к *example.org:80* через SSH-туннель для подключений на порт 8080 на всех интерфейсах локальной системы.
```
ssh -L 192.168.0.1:5432:127.0.0.1:5432 ssh-server
```
Переадресует соединения с *192.168.0.1:5432* в локальной системе на *127.0.0.1:5432* на SSH-сервере. Обратите внимание, что здесь *127.0.0.1* — localhost с точки зрения SSH-сервера.
### Конфигурации SSH
Убедитесь, что на SSH-сервере включена переадресация TCP (по умолчанию так и должно быть). Проверьте запись в файле `/etc/ssh/sshd_config`:
```
AllowTcpForwarding yes
```
При переадресации портов на интерфейсы, отличные от *127.0.0.1*, в локальной системе необходимо включить `GatewayPorts` (в `/etc/ssh/ssh_config` или в командной строке):
```
GatewayPorts yes
```
#### Сценарии использования
Подходит для случаев, когда требуется защищенное соединение для доступа к удаленному сервису, который работает с незашифрованными данными. Например, Redis и Memcached используют протоколы на основе plaintext-данных.
В случае если защищенный доступ к одному из таких сервисов на удаленном сервере организован по общедоступным сетям, можно настроить туннель от локальной системы до этого сервера.
Проброс удаленного порта
------------------------
Пробрасывает порт на удаленной системе в другую систему.
```
ssh -R 8080:localhost:80 ssh-server
```
Перенаправляет трафик с порта 8080 SSH-сервера для всех интерфейсов на порт *localhost:80* на локальном компьютере. Если один из интерфейсов смотрит в Интернет, трафик, адресуемый на порт 8080, будет перенаправляться на локальную систему.
```
ssh -R 1.2.3.4:8080:localhost:80 ssh-server
```
Переадресует трафик с порта 8080 SSH-сервера на *localhost:80* в локальной системе, при этом доступ ко входу в SSH-туннель со стороны сервера разрешен только с IP-адреса *1.2.3.4* (обратите внимание: директиву `GatewayPorts` необходимо установить в `clientspecified`).
***Прим. переводчика:*** *здесь, возможно, ошибка. Флаг* `-R` *— это* `binding_address`*, выбор IP адреса на машине, на котором SSH-сервер будет слушать порт. Соответственно вместо одного человечка с IP должны быть человечки, а вместо* `ssh_server:8080` *должно быть* `1.2.3.4:8080`*.*
```
ssh -R 8080:example.org:80 ssh-server
```
Переадресует трафик с порта 8080 SSH-сервера для всех интерфейсов на *localhost:80* в локальной системе. Далее трафик из локальной системы направляется на *example.org:80*. С точки зрения *example.org* источником трафика выступает локальная система.
### Конфигурация SSH-сервера
SSH-сервер конфигурируется в файле `/etc/ssh/sshd_config`.
По умолчанию переадресуемые порты недоступны для доступа из Интернета. Для переадресации публичного интернет-трафика на локальный компьютер добавьте в `sshd_config` на удаленном сервере такую строку:
```
GatewayPorts yes
```
Также в `sshd_config` можно указать, каким клиентам разрешен доступ:
```
GatewayPorts clientspecified
```
Динамический проброс портов
---------------------------
Перенаправление трафика с нескольких портов на удаленный сервер.
```
ssh -D 3000 ssh-server
```
Команда выше поднимает SOCKS-прокси на порту 3000 для всех интерфейсов в локальной системе. Теперь трафик, отправленный через прокси-сервер на SSH-сервер, можно адресовать на любой порт или конечный хост. По умолчанию используется протокол SOCKS5, поддерживающий TCP и UDP.
```
ssh -D 127.0.0.1:3000 ssh-server
```
Поднимает SOCKS-прокси на *127.0.0.1:3000* в локальной системе.
При работающем SOCKS-прокси можно настроить браузер на его использование для доступа к ресурсам так, как будто соединения исходят от SSH-сервера. Например, если у SSH-сервера есть доступ к другим серверам в частной сети, с помощью SOCKS-прокси можно заходить на эти серверы локально (словно вы находитесь в той же сети), и не нужно настраивать VPN.
Работу SOCKS-прокси можно проверить командой:
```
curl -x socks5://127.0.0.1:12345 https://example.org
```
### Конфигурация SSH-клиента
SSH-клиент настраивается в файле `/etc/ssh/ssh_config`.
Включите `GatewayPorts` в системе, чтобы открыть доступ другим интерфейсам к SOCKS-прокси:
```
GatewayPorts yes
```
Поскольку `GatewayPorts` конфигурируется на SSH-клиенте, вместо `ssh_config` для настройки можно использовать параметры командной строки:
```
ssh -o GatewayPorts=yes -D 3000 ssh-server
```
Jump-хосты и команды прокси-сервера
-----------------------------------
Прозрачное подключение к удаленному хосту через промежуточные.
```
ssh -J user1@jump-host user2@remote-host
```
```
ssh -o "ProxyJump user1@jump-host" user2@remote-host
```
Устанавливает SSH-соединение с jump-хостом и переадресуют трафик на удаленный хост.
Подключается к удаленному хосту через промежуточный jump-хост. Приведенная выше команда должна сработать сразу, если у jump-хоста уже есть SSH-доступ к удаленному хосту. Если нет, можно использовать `agent forwarding` для проброса SSH-ключа с локального компьютера на удаленный хост.
```
ssh -J jump-host1,jump-host2 ssh-server
```
Можно указать несколько jump-хостов через запятую.
```
ssh -o ProxyCommand="nc -X 5 -x localhost:3000 %h %p" user@remote-host
```
Подключение к удаленному серверу через SOCKS5 с использованием `netcat`. С точки зрения сервера, IP-адрес отправителя принадлежит прокси-хосту. При этом для SSH-соединения используется сквозное шифрование, так что прокси-хост видит только зашифрованный трафик между локальной системой и удаленным хостом.
### Конфигурация SSH-клиента
SSH-клиент конфигурируется в файле `/etc/ssh/ssh_config`.
Для подключения `agent forwarding` можно добавить локальный SSH-ключ к локальному SSH-агенту с помощью `ssh-add`:
```
ssh-add
```
Надежные SSH-туннели
--------------------
Перечисленные выше команды работают на разовой основе: вы сразу получаете конкретный результат, и на этом их работа заканчивается. Поэтому, чтобы обеспечить защиту SSH-туннелей от сбоев в сети или ненадежных соединений, придется выполнить дополнительную настройку.
По умолчанию TCP-соединение, используемое для создания SSH-туннеля, может разрываться после некоторого периода бездействия. Чтобы это предотвратить, нужно настроить сервер (`/etc/ssh/sshd_config`) на отправку heartbeat-сообщений:
```
ClientAliveInterval 15
ClientAliveCountMax 4
```
На отсылку таких сообщений также можно настроить клиент (`/etc/ssh/ssh_config`):
```
ServerAliveInterval 15
ServerAliveCountMax 4
```
### Использование AutoSSH
Указанные выше настройки могут предотвратить разрывы из-за неактивности, но они не в состоянии восстановить прерванные соединения. Для автоматического перезапуска SSH-туннеля можно воспользоваться утилитой `autossh` — она создает SSH-туннель и отслеживает его работоспособность.
AutoSSH принимает те же аргументы для настройки переадресации портов, что и SSH:
```
autossh -R 2222:localhost:22 ssh-server
```
Эта команда создает туннель, способный восстанавливаться после сетевых сбоев. По умолчанию AutoSSH открывает дополнительные порты на SSH-клиенте/сервере для проверки работоспособности (healthcheck). Если трафик не проходит между healthcheck-портами, AutoSSH перезапускает туннель.
```
autossh -R 2222:localhost:22 \
-M 0 \
-o "ServerAliveInterval 10" -o "ServerAliveCountMax 3" \
remote-host
```
Флаг `-M 0` отключает healthcheck-порты (за проверку работоспособности в этом случае отвечает SSH-клиент). В примере выше сервер должен посылать сигналы каждые 10 секунд. Если не проходят три подряд сигнала, SSH-клиент завершает работу, а AutoSSH поднимает новый туннель.
Дополнительные примеры и сценарии использования
-----------------------------------------------
Прозрачный доступ к удаленному ресурсу в частной сети.
Предположим, в частной сети есть Git-репозиторий, доступ к которому возможен только через выделенный сервер в этой сети. Сервер не подключен к Интернету. Есть прямой доступ к серверу, но нет VPN-доступа к частной сети.
Требуется открыть доступ к Git-репозиторию, как если бы подключение к нему шло напрямую из локальной системы. Если есть SSH-доступ к другому серверу, который доступен как с локального компьютера, так и с выделенного сервера, можно создать SSH-туннель и воспользоваться директивами ProxyCommand.
```
ssh -L 127.0.0.1:22:127.0.0.1:2222 intermediate-host
```
Команда выше пробрасывает порт 2222 на промежуточном хосте на порт 22 выделенного сервера. Теперь можно подключиться к SSH-серверу на выделенном сервере, несмотря на то, что он недоступен из Интернета.
***Прим. переводчика:*** *возможно, что здесь тоже ошибка: перепутаны местами 22 и 2222 порты в команде.*
```
ssh -p 2222 user@localhost
```
Для большего удобства можно добавить несколько директив в локальный `~/.ssh/config`:
```
Host git.private.network
HostName git.private.network
ForwardAgent yes
ProxyCommand ssh private nc %h %p
Host private
HostName localhost
Port 2222
User private-user
ForwardAgent yes
ProxyCommand ssh tunnel@intermediate-host nc %h %p
```
В результате пользователь получает доступ к локальному Git-репозиторию, как если бы находился в частной сети.
P.S.
----
Читайте также в нашем блоге:
* «[Автоматизация SSH-доступа к нодам Kubernetes с помощью Fabric и интеграции от CoreOS](https://habr.com/ru/company/flant/blog/328648/)»;
* «[Немного хардкора: как поднять Kubernetes на двух старых ноутбуках с Gentoo](https://habr.com/ru/company/flant/blog/685616/)»;
* «[Как с tcpserver и netcat открыть туннель в Kubernetes pod или контейнер](https://habr.com/ru/company/flant/blog/479910/)». | https://habr.com/ru/post/691388/ | null | ru | null |
# Нянчим проект на React-redux с пелёнок
В начале этого года мы в HeadHunter начали проект, нацеленный на автоматизацию различных HR-процессов у компаний-клиентов. Архитектурой этого проекта на фронте выбрали React-Redux стек.
За 9 месяцев он вырос из небольшого приложения для тестирования сотрудников в многомодульный проект, который сегодня называется [“Оценка талантов”](https://test.hh.ru). По мере его роста мы сталкивались с вопросами:
* хранения стейта, его нормализации;
* построения масштабируемой архитектуры проекта, удобной иерархии — как в структуре, так и в бизнес-логике.
Это проявлялось в изменении подхода к построению компонентов, архитектуры редьюсеров.
Давайте поговорим о том, как мы развивали проект и какие решения принимали. Некоторые из них могут оказаться “холиварными”, а другие, напротив, “классикой” в построении большого проекта на redux. Надеюсь, что описанные ниже практики помогут вам при построении react-redux приложений, а живые примеры помогут разобраться, как работает тот или иной подход.
#### Общие сведения. Intro.
Веб-приложение представляет собой SPA. Рендеринг приложения только на клиенте (ниже расскажем почему). При разработке мы использовали React-redux стек с различными middlewares, например redux-thunk. В проекте используем es6, компилируемый при сборке через babel. Разработка ведется без применения es7, так как не хотим брать не принятые в стандарт решения.
Частично проект доступен на [test.hh.ru](https://test.hh.ru), но воспользоваться им можно только компаниям, зарегистрированным на hh.
#### Структура проекта
В качестве структуры проекта мы изначально взяли разделение приложения на несколько частей. Получилась “классическая” структура для данного стека:
Здесь:
* actions отвечает за хранение всех action creators проекта;
* components — все react компоненты;
* constants — константы. Важно, что в эту папку мы собираем не только константы наподобие `ENTER_KEY = 13`, но и различные названия actions, например:
```
export const FETCH_ACCOUNT = 'FETCH_ACCOUNT';
export const RECEIVE_ACCOUNT = 'RECEIVE_ACCOUNT';
```
Это сделано для того, чтобы по импортам можно было легко увидеть зависимости, без необходимости грепать строки.
Мы не выносим те константы, которые имеют значение только для конкретного компонента. Например: расстояние в пикселях от нижней границы контейнера, при достижении которого подгружаем новые данные (т. е. бесконечный скролл);
* containers — специфичная директория. Состоит из страничных компонентов, которые при необходимости (например, недостатке данных) вызывают action creators и отправляют компоненты на рендеринг. Кроме подобных страничных компонентов, в папке находятся различные декораторы\фасады. Что представляет собой такой декоратор? Для этого разберем код одного из контейнеров:
```
import React, { Component } from 'react';
import { connect } from 'react-redux';
import { compose } from 'redux';
import Content from '../components/content/content';
import Managers from '../components/managers/managers';
import composeRestricted from './restricted/restricted';
import { loadManagers } from '../actions/managers';
import title from './title/title';
class ManagersPage extends Component {
componentWillMount() {
if (!this.props.firstLoad) {
this.props.loadManagers(this.props.location);
}
}
render() {
return (
);
}
}
export default compose(
connect(
state => state.location,
{loadManagers}
),
title('managers', 'title.base'),
composeRestricted({user: true})
)(ManagersPage);
```
Здесь нам интересна нижняя часть, которая описывает export модуля. connect — стандартный декоратор react-redux. Он оборачивает наш компонент в дополнительный react компонент, который подписывается на изменения состояния глобального redux стора и передает location поле (плюс оборачивает action creator loadManagers в dispatch стора). Title, composeRestricted — самописные декораторы, которые аналогично оборачивают компонент. Здесь title добавляет заголовки. Второй декоратор — composeRestricted — отвечает за определение прав пользователя, отрисовку restricted страниц, если бекенд отправил соответствующую ошибку: например, нет прав или нет данных. Таких декораторов может быть большое количество: “что-то пошло не так”, дополнительные вычисления и т. д.;
* reducers — ничего интересного, просто управление стейтом приложения ;). Здесь же хранится “корневой” редьюсер, объединяющий все остальные (с помощью combineReducers);
* store — конфиг стора, его инициализация;
* index.js — точка входа в наше приложение. Инициализирует react, описывает роутинг, создает стор и т.п.;
С такой структурой мы и начали разработку нашего проекта. Невозможно заранее предугадать все требования к системе и все сложности, с которыми можно столкнуться в процессе разработки. Поэтому мы выбрали путь инкрементальной модернизации нашего проекта. Работает это следующим образом:
1. выбираем определенную модель приложения;
2. сталкиваемся с тем, что какой-то подход не решает наши задачи так, как нам хочется;
3. проводим рефакторинг, изменяем структуру приложения.
Разберем изменение структуры приложения с течением времени:
##### Построение структуры. Детство
Когда проект молодой и не оброс большим количеством файлов, целесообразно выбрать простую модель построения. Именно так мы и сделали.
Все action creators хранились по принципу — одна группа операций, объединенная по смыслу = один файл. Все файлы хранились одним списком в папке.
Выглядело это следующим образом:
Что такое “одна группа операций”? Можно сказать, что один файл action creators отвечает за экшены внутри одного редьюсера. В таком случае и action creator и редьюсер имеют одинаковое имя, но такое бывает не в 100% случаев. По смыслу же, это операции над одним типом объектов. Например, employee.js содержит различные методы для работы с определенным объектом — “сотрудник”. Это получение информации о нем, обработка ошибок загрузки данных, изменение данных и добавление нового сотрудника.
Типичный код подобных операций:
```
export function loadEmployee(id) {
return dispatch => {
// Генерируем action, в котором уведомляем, что начинаем асинхронную операцию с employee
dispatch(fetchEmployee());
fetch(`/employees/${id}`)
// Считываем ответ сервера
.then(checkStatus)
// Парсим
.then(result => result.json())
.then(result => {
// Генерируем экшен, который будет содержать нашего сотрудника (соответственно, далее этот сотрудник будет сохранен в редьюсер, произойдет изменение стора и рендеринг)
dispatch(receiveEmployee(result));
})
.catch(() => {
// Обработка ошибки, вызванная одной из нескольких ситуаций: 1) сервер ответил ошибкой; 2) не получилось распарсить результат; 3) ошибка при сохранении в редьюсер; 4) ошибка при рендеринге react компонент.
dispatch(releaseEmployee());
dispatch(errorRecord(t('employee.error')));
});
};
}
```
Важно заметить, что в этом коде мы обрабатываем одним catch сразу группу ошибок — как серверных, так и работу редьюсеров и реакт-компонентов. Более подробно, почему мы решили сделать именно такую архитектуру — в разделе неоднозначных решений в конце статьи.
Аналогичная модель построения была принята для редьюсеров, контейнеров и компонентов. Для компонентов существуют только некоторые “условности”. Каждый компонент находится в отдельной папке. Это позволяет нам класть внутрь папки как .js модуль, так и стили, а в некоторых случаях также и картинки\другие данные:
##### Отрочество
Данная структура прожила ровно до окончания работы над первым модулем. Перед переходом к новому модулю мы посмотрели трезвым взглядом на полученный набор компонентов и решили, что при увеличении системы этот подход к структуре проекта принесет “кашу”, где будет огромное количество файлов на одном уровне системы. Кроме того, если мы решим отдавать на фронт весь js не в одном файле (например, когда размер нашего js-бандла вырастет в мегабайты минифаенной-аглифаенной информации), а в нескольких бандлах, то нам придется довольно долго разруливать все зависимости модулей между собой.
Именно поэтому мы приняли следующее решение (опишу для двух модулей A и B, можно масштабировать на любое количество):
1. Все action creators, редьюсеры и контейнеры делятся на три типа: common, moduleA, moduleB.
2. Все константы, которые не описывают action type, лежат внутри папки constants. Эта же папка содержит директорию actions, в которой описываются нужные нам action types. Причем они также разделяются на два типа.
3. Компоненты делятся на 4 типа:
common — включает в себя общие реакт модули. Они представляют собой dummy react component (т. е. компоненты, которые только описывают UI, не управляют им, не влияют\не зависят напрямую от стейта приложения, не вызывают actions) По сути, это реиспользуемые в любом месте приложения компоненты.
blocks – компоненты, которые зависят от общего стейта приложения. Например, блок “уведомления”, или “нотификации”.
moduleA, moduleB — специфичные компоненты для модуля.
И блоки, и модули могут быть smart-компонентами, вызывать какие-то actions и т. д.
С принятыми правилами структура приложения стала выглядеть следующим образом:
Таким образом, мы получили четкую структуру, описывающую модульную сущность проекта, в которой можно легко определить отношение js файла к тому или иному модулю, а значит, если мы решим создавать разные бандлы на модули, то нам это не составит никакого труда (достаточно “натравить” вебпак на нужные части).
#### Разделение стейта приложения на модули
Окей, мы разделили структурно наши файлы, глаз радуется, но что насчет поддержки многомодульной структуры на уровне логики, редьюсеров?
Для небольших приложений описание рутового редьюсера обычно такое:
```
export const createReducer = () => {
return combineReducers({
account,
location,
records,
managers,
tooltip,
validation,
progress,
restrictedData,
command,
translations,
status,
features,
module,
settings,
menu,
routing: routeReducer,
});
};
```
Для небольших приложений это удобно, так как все данные расположены plain-коллекцией. Но с увеличением размеров приложения, увеличивается количество пересылаемых данных, появляется необходимость в дроблении редьюсеров, разделении их на модули. Как это можно сделать? Прежде чем перейти к результату, рассмотрим две ситуации.
##### Ситуация первая: “Дробление объекта на отдельные редьюсеры”
Предположим, у нас есть сущность employees. Эта сущность отлично подойдет для разбора различных ситуаций и описания принятия решения. С сущностью “сотрудник” менеджеры компаний могут делать различные действия: загружать, редактировать, создавать, приглашать на тесты, смотреть результаты тестов. Данное поле представляет собой объект с двумя полями: status и data. status определяет текущее состояние поля (FETCH\COMPLETE\FAIL), а data — полезные данные, массив сотрудников. Этого достаточно, чтобы получить данные с сервера и отобразить список сотрудников.
Теперь нам нужно добавить возможность выбора сотрудников:
Решить такую задачу можно тремя способами:
###### Способ первый:
Модифицируем элементы внутри массива employees.data таким образом, что кроме id, имени, фамилии, должности, каждый элемент будет содержать поле selected. При рендере чекбокса смотрим на это поле, а общую сумму считаем, например, так:
```
employees.data.reduce((employee, memo) => employee.selected ? memo + 1 : memo, 0);
```
Если в будущем нам нужно будет отправить выбранные id, то находим их все через тот же filter. Добавление\удаление выбранных происходит аналогично, через map. Плюсом этого способа является то, что данные хранятся централизованно. Минусом — мы по каждому “чиху” (добавление\снятие флага selected) трогаем весь объект. Это приводит к немалому количеству действий. Логику по работе с выбранными сотрудниками добавляем в employees редьюсер, action creator. Если же хочется разделить эти части (так как работа с выбранными сотрудниками никак не сказывается на основной задаче редьюсера employees — выводить сотрудников и заниматься пагинацией), то стоит посмотреть на два других способа.
###### Способ второй:
Создаем отдельный редьюсер, например `selectedEmployees`. Это иммутабельная мапа (при желании можно массив, просто объект), которая хранит только выбранные id. Добавление и удаление id из такой структуры выглядит гораздо проще. Отрисовка чекбокса усложняется только тем, что необходимо пройти по пути `store.selectedEmployees.has(id)`. Соответственно, вся работа с выбранными сотрудниками уходит в отдельный редьюсер, отдельную группу actions.
Данное решение лучше тем, что оно не занимается модификацией и нагрузкой другой части стейта, а добавляет рядом еще одно. Итого, если наше приложение состоит из этих двух редьюсеров, получим следующую структуру:
```
employees {state: COMPLETE, data: [{id: 1, ...}, {id: 2, ...}]}
selectedEmployees Map({1 => true})
```
###### Способ третий:
С течением времени, если использовать второй способ каждый раз, мы получим раздувшийся стейт, который будет состоять из employees, selectedEmployees, employee, employeeTest и т. д. Заметим, что редьюсеры связаны друг с другом: selectedEmployees относится к employees, а employeeTest к employee. Поэтому структурируем приложение, создав комбинированный редьюсер. Это даст нам более четкую и удобную структуру:
```
employees:
- list [{id: 1, ...}, {id: 2, ...}]
- selected Map({1 => true})
- status COMPLETE
employee:
- data
- test
```
Достигнуть такой структуры можно, построив иерархию из редьюсеров:
```
export const createReducer = () => {
return combineReducers({
employees: combineReducers({
list: employees,
selected: selectedEmployees,
status: employeesStatus
})
routing: routeReducer,
});
};
```
*Примечание: status не важен на этом уровне, его можно оставить внутри редьюсера, который отвечал за список сотрудников, как это было раньше.*
Именно этот способ мы и решили использовать. Он отлично подходит для различных ситуаций, где необходима групповая работа с объектами.
##### Ситуация вторая: “Нормализация данных”
При разработке SPA большую роль играет нормализация данных. Продолжим работать с нашими сотрудниками. Мы выбрали нужных сотрудников и отправили их на тест. Затем сотрудник проходит его, и компания получает результаты тестов. Нашему приложению необходимо хранить данные — результаты тестов сотрудников. У одного сотрудника может быть несколько результатов.
Подобную задачу можно также решить несколькими способами.
###### Плохой способ (человек-оркестр)
Данный способ предлагает доработать структуру employees так, чтобы сохранять полные данные о тесте внутри себя. То есть:
```
employees: {
status: COMPLETE,
list: [
{
id: 1,
name: ‘Георгий’,
testResults: {
id: 123,
score: 5
speed: 146,
description: ‘...’
...
}
}
]
}
```
Мы получили объект-оркестр в нашем сторе. Это неудобно, он несет в себе лишнюю вложенность. Намного красивее смотрится решение с нормализованными данными.
###### Хороший способ
Заметим, что у сотрудника и теста есть id. В базе данных есть связь между тестами и сотрудниками как раз по id сотрудника. Перенимаем такой же подход с бекенда и получаем следующую структуру:
```
employees: {
status: COMPLETE,
list: [
{
id: 1,
name: ‘Георгий’,
testResults: [123]
}
]
},
tests: {
123: {
id: 123,
score: 5
speed: 146,
description: ‘...’
...
}
}
```
В рутовом редьюсере получим:
```
export const createReducer = () => {
return combineReducers({
employees: combineReducers({
list: employees,
selected: selectedEmployees,
status: employeesStatus
}),
tests,
routing: routeReducer,
});
};
```
Мы структурировали наш стор, разложили все по полочкам, получив четкое понимание функциональности приложения.
##### Добавляем модули
При добавлении модулей разбиваем представление стейта на common группу и группы, принадлежащие разным модулям:
```
export const createReducer = () => {
return combineReducers({
moduleA: combineReducers({
employees: combineReducers({
list: employees,
selected: selectedEmployees,
status: employeesStatus
}),
tests,
}),
moduleB: combineReducers({...}),
// common группу расположим на первом уровне, не вкладывая отдельно
notifications,
routing: routeReducer,
});
};
```
Данный способ позволяет в структуре стора повторить файловую структуру. Таким образом, структура приложения повторяется как на файловом, так и на логическом уровне. А значит, упрощается понимание работы всего приложения в целом и уменьшается порог вхождения новых разработчиков в проект.
#### Принципы построения React-компонентов
Мы успешно построили структуру приложения, разделили код на модули, наши экшены и редьюсеры иерархичны и позволяют писать масштабируемый код. Самое время вернуться к вопросу о том, как строить компоненты, отвечающие за UI.
Мы придерживаемся принципов redux, а это означает, что глобальный стор — единственный источник правды. Наша цель — строить приложение таким способом, что по данным из стора можно полностью восстановить отображение сайта в любой момент времени. Из допустимых погрешностей разрешаем себе не восстанавливать данные об анимациях\состояниях дропдаунов, тултипов – открыт\закрыт.
На основе этих условий построим модель приложения.
##### Smart и dumb компоненты
Хорошо описан подход к построению и разделению по данным признакам в следующих ресурсах:
» [medium.com/@dan\_abramov/smart-and-dumb-components-7ca2f9a7c7d0#.aszvx1fh1](https://medium.com/@dan_abramov/smart-and-dumb-components-7ca2f9a7c7d0#.aszvx1fh1)
» [jaketrent.com/post/smart-dumb-components-react](http://jaketrent.com/post/smart-dumb-components-react/)
Мы придерживаемся аналогичного подхода. Все common-компоненты являются dummy-компонентами, которые только получают свойства и т. п. Компоненты, относящиеся к тому или иному модулю, могут быть как smart, так и dumb. Мы не вносим жесткого разграничения между ними в структуре, они хранятся рядом.
##### Чистые компоненты
Практически все наши компоненты не имеют собственного стейта. Такие компоненты либо получают стейт, action creators через декоратор connect, либо с помощью “водопада” от вышестоящих компонентов.
Но есть около 5% компонентов, обладающих собственным стейтом. Что такие компоненты представляют собой? Что хранят в своем стейте? Подобные компоненты в нашем приложении можно поделить на две группы.
###### Состояние всплывающих элементов:
Еще один пример:
В эту группу попадают компоненты, которые хранят информацию — отображать всплывающий элемент (дропдаун, тултип) или нет.
Типичный код для такого компонента:
```
import React, { Component } from 'react';
import PseudoLink from '../pseudoLink/pseudoLink';
import Dropdown from '../../common/dropdown/dropdown';
import './dropdownHint-styles.less';
class DropdownHint extends Component {
constructor(props, context) {
super(props, context);
this.state = {
dropdown: false,
};
}
renderDropdown() {
if (!this.state.dropdown) {
return '';
}
return (
{
this.setState({
dropdown: false,
});
}}>
{this.props.children}
);
}
render() {
return (
{
this.setState({
dropdown: true,
});
}}>
{this.renderDropdown()}
{this.props.text}
);
}
}
export default DropdownHint;
```
###### Вторая задача внутреннего стейта: временное кеширование или дополнение.
Рассмотрим следующий пример:
Нотификации наверху экрана анимируются при появлении и скрытии. Сама сущность нотификации хранится в глобальном стейте приложения, но для процесса скрытия (с последующим удалением) нотификации можно использовать один из нескольких подходов, не загрязняя глобальный стейт такой неважной информацией, как анимация.
**Способ первый — кеширование.**
Достаточно простой способ. Создаем компонент NotificationsManager, который отвечает за рендеринг компонентов-нотификаций (Notification). После того как NotificationsManager отрендерил очередную нотификацию, он запускает таймер, по окончании которого будет вызван экшен по скрытию нотификации. Перед его вызовом NotificationsManager кеширует нотификацию в своем стейте. Это позволяет удалить саму нотификацию из стора, а закешированные данные внутри локального стейта компонента позволяют провести анимацию ее исчезновения.
Этот способ неудобен тем, что мы обманываем наш стор — он считает, что нотификации никакой нет, но она на самом деле хранится в локальном стейте нашего компонента. Мы хотим “честный” стор, поэтому данный способ нам не подходит.
**Способ второй — дополняем информацию из стора локально.**
Этот способ более честный и привлекательный, так как не мешает с высокой точностью восстановить данные из стора. Заключается он в том, чтобы NotificationsManager при получении изменений нотификаций со стороны стора добавлял информацию в свой стейт о том, что необходимо делать с нотификацией (анимировать ее появление, исчезновение или ничего не делать). В таком случае NotificationManager уведомляет стор через экшен CLOSE\_NOTIFICATION только в момент, когда анимация исчезновения нотификации закончена. Этот подход позволяет отказаться от лишней информации в сторе (статус анимирования нотификации), и в то же время стор остается “единственным источником правды”, с помощью которого можно точно восстановить отображение всего приложения.
Опишем приближенно, каким образом будет работать такой подход. В сторе получаем:
```
notifications: [
{
id: 1,
text: ‘Я мистер мисикс, посмотрите на меня’
},
{
id: 2,
text: ‘Двое из ларца, одинаковых с лица’
},
{
id: 3,
text: ‘Что тебе надобно, старче?’
},
]
```
В локальном стейте компонента:
```
notifications: {
1: ‘out’,
3: ‘in’
}
```
Разберем пример. На уровне всего приложения мы знаем, что у нас существует 3 нотификации. На локальном уровне компонента мы сохраняем информацию, которая не несет смысловой нагрузки для приложения, но важна для локального рендера: id === 1 исчезает, id == 3 выезжает, а id === 2 статична.
Эту информацию можно хранить в сторе, но она не несет никакой полезной смысловой нагрузки. Не нужна никаким компонентам, кроме как самим нотификациям. Даже при восстановлении состояния всего приложения из стора такая информация не нужна и может быть вредна в конкретно этом случае. Кто захочет открыть приложение и увидеть как “что-то резко скрылось”.
Мы взяли на вооружение второй способ. В каждом случае с анимациями важно понимать, насколько оправданно заводить локальный стейт, нужен ли он, можно ли обойтись без стейтов вообще и т. д. Например, у нас во всем приложении этот способ применен только в нотификациях. В сторе мы не храним информацию об анимации.
#### Роутинг пользователя. Рендеринг
В роутинге пользователя у нас нет ничего сверхестественного. За роутинг отвечает стандартный компонент react-router, с redux мы связываем роутинг через react-router-redux.
Рендеринг нашего приложения происходит только на клиенте.
При первой загрузке страницы сервер отдает нам только стаб, в который для начальной инициализации кладет все данные в формате json, которые нам необходимы для отрисовки страницы: информацию об аккаунте, данные для страницы, описание ошибки (если есть). Затем уже клиентский код рендерит наше приложение.
Данный шаг был сделан по нескольким причинам:
1. Без отработавшего js кода приложение бессмысленно;
2. Нет необходимости поддержки рендеринга компонентов как на сервере, так и на клиенте;
3. Отсутствие node.js на сервере.
После первоначальной загрузки приложения все запросы работают через json-формат. Типы получаемых данных описываем обычным acceptType-хидером.
Рассмотрим пример такой работы:
Для рендеринга страницы employees нам нужна информация о сотрудниках (employees) и об аккаунте пользователя (account).
Если пользователь вводит в браузере урл этой страницы, то сервер отдаст html-код, содержащий следующий json:
```
window.pageData = {
account: // информация об аккаунте
employees: // информация о сотрудниках
}
```
Все редьюсеры, которые ожидают начальный стейт, умеют собирать нужные данные из этого объекта при инициализации.
Приведем схематический пример такой инициализации:
```
const initialData = window.pageData.employees;
export default function employees(state = initialData, actions) {
// reducer
}
```
В реальной жизни поля employees может не оказаться, поэтому мы получаем данные немного по-другому, но суть остается та же.
Следующий случай — на страницу заходят во время работы с приложением. В этом случае страничный контейнер вызовет соответствующий action creator, который пойдет на сервер с acceptType: application/json и получит только необходимые данные (массив сотрудников). Затем отработает редьюсер. “И все будут жить долго и счастливо”.
#### Неоднозначные решения
##### Единое место обработки ошибок
В самом начале статьи мы затрагивали код одного из action creator’ов:
```
export function loadEmployee(id) {
return dispatch => {
// генерируем action, в котором уведомляем, что начинаем асинхронную операцию с employee
dispatch(fetchEmployee());
fetch(`/employees/${id}`)
// считываем ответ сервера
.then(checkStatus)
// парсим
.then(result => result.json())
.then(result => {
// генерируем экшен, который будет содержать нашего сотрудника (соответственно, далее этот сотрудник будет сохранен в редьюсер, произойдет изменение стора и рендеринг)
dispatch(receiveEmployee(result));
})
.catch(() => {
dispatch(releaseEmployee());
dispatch(errorRecord(t('employee.error')));
});
};
}
```
После получения данных с сервера мы диспатчим receiveEmployee. Соответственно, далее сотрудник будет сохранен редьюсером в стор, состояние стора изменится, произойдет рендеринг. Эти действия выполняются синхронно. Здесь может скрываться подводный камень — catch отловит следующие категории ошибок:
1. сервер ответил ошибкой;
2. не получилось распарсить результат;
3. ошибка при сохранении в редьюсер;
4. ошибка при рендеринге react компонент.
Это происходит из-за “синхронности” кода. Таким образом, если мы упали на моменте рендеринга реакт компонентов, то пользователь увидит сообщение t('employee.error'). t — функция, которая по ключу подставит текст (перевод).
Мы получили “централизованное” место сбора ошибок. Такое решение нам подходит, так как мы намеренно хотим сообщить пользователю о том, что не получилось загрузить сотрудника, отобразить данные и т. п. Конечному пользователю все равно, где произошла ошибка: на стороне сервера или клиентской логики. В любом случае запрошенные данные он не увидит. Даже если бы мы разграничивали код, например так:
```
export function loadEmployee(id) {
return async dispatch => {
// генерируем action, в котором уведомляем, что начинаем асинхронную операцию с employee
dispatch(fetchEmployee());
let json;
try {
const res = await fetch(`/employees/${id}`);
checkStatus(res);
json = await getJson(res);
} catch () {
dispatch(releaseEmployee());
dispatch(errorRecord(t('employee.error')));
}
dispatch(receiveEmployee(result));
};
}
```
То нам бы пришлось обернуть в try-catch последний dispatch:
dispatch(receiveEmployee(result));
и сделать в нем то же самое, что и в предыдущем блок catch:
```
export function loadEmployee(id) {
return async dispatch => {
// генерируем action, в котором уведомляем, что начинаем асинхронную операцию с employee
dispatch(fetchEmployee());
let json;
try {
const res = await fetch(`/employees/${id}`);
checkStatus(res);
json = await getJson(res);
} catch () {
dispatch(releaseEmployee());
dispatch(errorRecord(t('employee.error')));
}
try {
dispatch(receiveEmployee(result));
} catch() {
dispatch(releaseEmployee());
dispatch(errorRecord(t('employee.error')));
}
};
}
```
В итоге мы получили лишнее дублирование кода, не выиграв в конкретно этом случае ничего.
**Важно понимать, что при таком подходе нужно разграничивать те случаи, когда централизованная обработка допустима, и те случаи, когда этого стоит избегать.**
##### Динамические редьюсеры
При увеличении количества редьюсеров, разделении их на разные модули и построении иерархической структуры, появляется необходимость избавляться от лишних данных, которые “не используются”. В многомодульном приложении (например, когда у нас 5—10 модулей, в каждом из которых 40—50 редьюсеров) появляется закономерное желание хранить в сторе данные только о выбранном модуле и общие редьюсеры. Зачем так делать? Когда пользователь работает с тем или иным модулем, он с высокой долей вероятности не будет работать с другими модулями. Визуально разные модули отличаются в оформлении, цветовой палитре. Это сделано для того, чтобы пользователь “одним взглядом” понимал, в каком контексте он находится. Соответственно, если пользователь находится в одном модуле, то состояние стора для других модулей, во-первых, не важно, во-вторых, инвалидно (пусто, так как при переходе в другой модуль все данные будут перезагружены с сервера, обновлены). А также, если мы хотим полностью восстановить состояние приложения из стора, нам достаточно содержимого общих полей стора и содержимого полей активного модуля. Остальные модули нам не нужны. Руководствуясь этими принципами, мы решили воспользоваться динамической подменой редьюсеров.
В основе данного решения лежит информация из следующих источников:
» [github.com/reactjs/redux/issues/37#issue-85098222](https://github.com/reactjs/redux/issues/37#issue-85098222)
» [gist.github.com/gaearon/0a2213881b5d53973514](https://gist.github.com/gaearon/0a2213881b5d53973514)
» [stackoverflow.com/questions/34095804/replacereducer-causing-unexpected-key-error](http://stackoverflow.com/questions/34095804/replacereducer-causing-unexpected-key-error)
Работает это следующим образом:
*Шаг 1.*
Создадим редьюсер, описывающий текущий модуль. Такой редьюсер отвечает за информацию, в каком модуле находится пользователь. Этот же редьюсер можем использовать для отрисовки меню (как пример).
*Шаг 2.*
Все наши модульные редьюсеры находятся внутри отдельного редьюсера. То есть до введения динамического переключения они выглядят следующим образом:
```
export const createReducer = () => {
return combineReducers({
moduleA: combineReducers({
employee: combineReducers({
list: employees,
selected: selectedEmployees,
status: employeesStatus
}),
tests,
}),
moduleB: combineReducers({...}),
// common группу расположим на первом уровне, не вкладывая отдельно
notifications,
routing: routeReducer,
});
}
```
Теперь создаем возможность динамического добавления редьюсеров:
```
export const createReducer = (dynamicReducers = {}) => {
return combineReducers(Object.assign({}, {
notifications,
routing: routeReducer,
// редьюсер, описывающий выбранный модуль
module,
}, dynamicReducers));
};
```
и описываем в файле редьюсеры, которые относятся к модулям:
```
export const aReducers = {
moduleA: combineReducers({
employee: combineReducers({
list: employees,
selected: selectedEmployees,
status: employeesStatus
}),
tests,
}),
}
```
*Шаг 3.*
Немного изменяем код конфигурации стора для того, чтобы можно было добавлять динамические редьюсеры:
```
export function configureStore() {
const store = createStoreWithMiddleware(createReducer());
store.dynamicReducers = {};
storeInstance = store;
switch (store.getState().module) {
case A:
injectAsyncReducer(aReducers);
break
case B:
injectAsyncReducer(bReducers);
break;
// Аналогично далее
}
return store;
}
export function injectAsyncReducer(reducers) {
if (reducers !== storeInstance.dynamicReducers) {
storeInstance.dynamicReducers = reducers;
storeInstance.replaceReducer(createReducer(storeInstance.dynamicReducers));
}
}
```
Мы получаем функцию injectAsyncReducer, с помощью которой в рантайме можем изменять редьюсеры.
*Шаг 4.*
Создаем необходимый action creator. С его помощью создаем action для смены выбранного модуля. Например такой:
```
export const checkoutAModule = () => {
// Заменяем набор редьюсеров
injectAsyncReducer(aReducers);
return {
type: CHECKOUT_MODULE,
module: A,
};
};
```
Аналогично действуем для остальных модулей, либо создаем один, но дженерный.
*Шаг 5.*
Добавляем декоратор, который отвечает за переключение модуля. Он выглядит примерно так:
```
import React, { Component } from 'react';
import { connect } from 'react-redux';
import { checkoutModuleA } from '../../actions/module';
import { A } from '../../constants/module';
export default function checkoutA() {
return Container => {
class AContainer extends Component {
componentWillMount() {
if (this.props.module !== A) {
this.props.checkoutModuleA();
}
}
render() {
return (
);
}
}
return connect(
state => {
return {
module: state.module,
};
}, {
checkoutModuleA,
}
)(AContainer);
};
}
```
Соответственно, так как модулей много, этот код легко можно сделать дженерным.
*Шаг 6.*
Добавляем этот декоратор для наших страничных контейнеров:
```
import React, { Component } from 'react';
import { connect } from 'react-redux';
import { compose } from 'redux';
import Content from '../components/content/content';
import Managers from '../components/managers/managers';
import composeRestricted from './restricted/restricted';
import { loadManagers } from '../actions/managers';
import title from './title/title';
class ManagersPage extends Component {
componentWillMount() {
if (!this.props.firstLoad) {
this.props.loadManagers(this.props.location);
}
}
render() {
return (
);
}
}
export default compose(
connect(
state => state.location,
{loadManagers}
),
checkoutA(),
title('managers', 'title.base'),
composeRestricted({user: true})
)(ManagersPage);
```
Готово! Теперь мы обучили наше приложение изменять набор редьюсеров. **Важно, что без острой необходимости данным способом пользоваться нежелательно.** Это объясняется тем, что мы “обрубаем” часть стора. Такой подход является оправданным только для больших систем с похожей структурой (модульные, независимые части, объединенные одним проектом).
#### Вместо вывода
С текущей архитектурой проект продолжает развиваться. Многие вопросы остались за рамками данной статьи, которая вышла и без того внушительной. Мы успели затронуть вопросы, связанные с построением структуры как на файловом, так и на логическом уровне, разделения и нормирования стейта приложения, хранения локального стейта в компонентах. Проделанная работа, при некотором усложнении проекта (увеличении количества модулей), позволила нам не сделать его запутанным и помогла уменьшить порог вхождения в него новых разработчиков. | https://habr.com/ru/post/310524/ | null | ru | null |
# Система рекомендаций фильмов с GUI на Python
[](https://habr.com/ru/company/skillfactory/blog/523132/)
«Без опыта я никому не нужен! Где взять опыт?» — часто думают люди, осваивающие новую для себя сферу или изучающие новый язык программирования. Решение есть — делать пет-проекты. Представленный под катом проект системы рекомендации фильмов не претендует на сложность и точность аналогичных систем от энтерпрайз-контор, но может стать практическим стартом для новичка, которому интересны системы рекомендации в целом. Этот пост также подойдет для демонстрации как использовать Python-библиотеку EasyGUI на практике.
Важное предупреждение: если вы крепкий миддл либо сеньор, то проект может показаться вам простым. Однако не стоит спешить опускать палец вниз и забывать про тех, кто не так опытен, и кому пост может быть полезен, ведь все мы когда-то были джунами.
---
Начало работы
-------------
В этой статье я расскажу, как создать базовую систему рекомендаций фильмов со встроенным графическим пользовательским интерфейсом. Прежде всего нам нужны данные. Чтобы получить хорошее представление о том, насколько хорошо система рекомендаций работает на самом деле, нам понадобится довольно большой набор данных. Используем MovieLens на 25M, который вы можете скачать [здесь](https://grouplens.org/datasets/movielens/25m/). Набор данных состоит из шести файлов .csv и файла readme, объясняющих набор данных. Не стесняйтесь взглянуть на него, если хотите. Мы будем использовать только эти три файла:
movies.csv; ratings.csv; tags.csv
Также потребуется несколько библиотек Python:
1. NumPy
2. Pandas
3. Progress (pip install progress)
4. Fuzzywuzzy (pip install fuzzywuzzy & pip install python-Levenshtein)
5. EasyGUI
Вероятно, все они могут быть установлены через pip. Точные команды будут зависеть от ОС. Кроме того, должна работать любая IDE Python (см. материал по ним [вот тут](https://habr.com/ru/company/skillfactory/blog/521838/)). Я пользуюсь Geany, легкой IDE для Raspbian. Посмотрим на набор данных:
movies.csv
Выше показан файл movies.csv с тремя столбцами данных, а именно: movieId, title и genres — идентификатор фильма, название и жанр. Все очень удобно и просто. Будем работать со всеми тремя.
Ниже мы видим tags.csv. Здесь используются только столбцы movieId и tag, связывающие тег со столбцом movieId, которые также есть в файлах movies.csv и rating.csv.
tags.csv
И последний, но не менее важный файл: rating.csv. От этого парня мы возьмем столбцы movieId и rating.
ratings.csv
Отлично, теперь давайте запустим IDE и начнем. Импортируем библиотеки, как показано ниже. Pandas и NumPy хорошо известны в области Data Science. Fuzzywuzzy, EasyGUI и библиотека Progress менее известны^ судя по тому, что мне удалось собрать, однако вы, возможно, знакомы с ними. Я добавлю в код много комментариев, чтобы все было понятно. Посмотрите:
Программа в основном состоит из набора функций, кроме начальной загрузки набора данных и настройки дисплея для gui, в который будет подаваться массив NumPy. Без настройки отображения в строке 12, когда список рекомендуемых фильмов из системы слишком длинный, мы получим урезанное и бесполезное изображение.
Есть разные способы сортировки значений на дисплее, например, цикл по массиву и добавление каждой строки к переменной, инициализированной в пустой список, однако этот метод мы будем использовать именно в строке 12.
Строки 16, 17, 33 и 35 — это, в основном, индикатор прогресса из библиотеки Progress. Цикл выполняется только один раз. Загрузка набора данных в мою систему занимает около 30 секунд, поэтому мы используем индикатор прогресса, чтобы показать, что набор данных загружается после запуска программы, как показано ниже. После этого нам не придется загружать его снова во время навигации по графическому интерфейсу.
Загрузка набора данных и главное меню графического интерфейса пользователя.
Внутри цикла, набор данных загружается во фреймы Pandas и данные немного изменяются для удобства. Начнем со слияния фильма и рейтингового фрейма в один фрейм. В столбце рейтинга есть несколько значений NaN, и мы будем иметь дело с этим, заполняя его средним рейтингом, вычисленным во всей колонке рейтингов. Поскольку некоторые фильмы имеют оценки с сотен площадок, мы хотим получить средний рейтинг каждого фильма и сгруппировать фильмы по movieId, который связан с названием фильма. Теперь, когда с данными проще работать, пришло время создавать функции.
Первая функция называется which\_way(). Эта функция вызывает главное меню графического интерфейса пользователя и предлагает сделать выбор. Ищите фильмы по жанру или по тегу. Пользователь, конечно, тоже может нажать кнопку отмены и вообще не искать фильмы, это полностью его дело.
which\_way()
Внутри функции мы определяем параметры для EasyGUI chiocebox, который отображается пользователю. Строка параметра, которую вводит пользователь, возвращается и сохраняется в переменной fieldValues. После условный оператор направляет пользователя к следующей функции или окну на основе выбора.
Если пользователь нажимает отмену, программа завершается. Но если пользователь нажимает поиск фильмов по жанру или поиск фильмов по тегу, то будут вызваны функции genre\_entry() или tag\_entry() и появится что-то, известное как EasyGUI multenterbox.
Из названия понятно, что это поле ввода может принимать несколько входных значений, когда необходимо. Обе функции genre\_entry() и tag\_entry() очень похожи, поэтому я объясню только одну из них, но в исходный код включу обе. Давай посмотрим на tag\_entry().
После передачи параметров отображения multenterbox вызывается другая функция, которая проверяет ввод данных пользователем. Пользовательский ввод возвращается функцией field\_check. Давайте взглянем на нее:
Иногда пользователи оставляют значение в поле пустым, возможно, по ошибке. Чтобы контролировать такое поведение, а также сделать графический интерфейс более надежным, нам нужны такие функции. Я нашел эту конкретную функцию на странице документации EasyGUI. По сути, пока вы вводите пустое поле, вам сообщат, что это поле является обязательным, и вы застрянете в цикле.
Как только пользователь что-то вводит, текст (строка) сохраняется в переменной fieldValues, а код работает со строки 114 в функции tag\_entry. Пользовательский ввод из поля EasyGUI multenter возвращается в виде списка. При нажатии кнопки отмены возвращается «Нет». Чтобы использовать этот ввод и в других функциях, нам нужно объявить переменную как глобальную.
Теперь мы нарезаем список пользовательского ввода из multenterbox, и сохраняем как переменную user\_input\_2. Нас интересует только возвращаемый текст, если пользователь не нажимает кнопку отмены, отсюда и условный оператор:
```
if fieldValues != None:
```
Если пользователь был достаточно любезен, чтобы ввести какой-то текст, мы переходим к функции Similarity\_test2(), которая в основном содержит базовые аспекты этой системы рекомендаций, в качестве альтернативы пользователь возвращается в главное меню. Similarity\_test1() и Similarity\_test2() очень похожи, так же как genre\_entry и tag\_entry. Я буду рассматривать здесь только Similarity\_test2(). Давайте посмотрим на это:
Как мы видим, она принимает один параметр, переменнаую user\_input\_2 из функции tag\_entry(). Помните тот фрейм данных, который мы создали в строке 19 из файла tags.csv? Сначала мы хотим собрать все уникальные теги из столбца тегов и сохранить их в переменной.
Существует множество способов применения библиотеки Fuzzywuzzy в зависимости от ваших задач. Мы будем работать так: `output = process.extract(query, choices)`
Можно передать дополнительный параметр — тип счетчика. Мы просто будем использовать синтаксис по умолчанию. По сути Fuzzywuzzy работает с расстоянием Левенштейна для вычисления различий между последовательностями и возвращает оценку в пределах 100%.
Функция process.extract(query, choices) возвращает список оценок, где каждая строка и ее оценка заключена в скобки, например (строка 95) в качестве элементов списка.
После перебора всего списка тегов и поиска совпадений с переменной user\_input\_2, мы перебираем список оценок и вырезаем только совпадения выше 90% и сохраняем их в переменной final\_2. Мы объявляем его глобальным, чтобы использовать в следующей функции. Если fuzzywuzzy не нашел для нас соответствия, вернется []. Если совпадение по условию не найдено, просим пользователя повторить попытку, вернувшись к функции tag\_entry(). В качестве альтернативы, когда у нас есть совпадения более чем на 90%, мы можем использовать их в функции tag(), как показано ниже:
tag()
Теперь, когда у нас есть совпадения более 90%, перебираем их в цикле и просматриваем каждую строку столбца tag фрейма данных df\_tags, чтобы увидеть, какие теги соответствуют строкам из Fuzzywuzzy. Теперь сохраняем все совпадения тегов вместе с идентификатором movieId в переменной final\_1. Чтобы очистить добавленные данные, мы отрезаем первый элемент и сбрасываем индекс фрейма данных. Теперь можно удалить столбец с именем index и все дубликаты из столбца movieId. Чтобы фильмы с наивысшим рейтингом отображались первыми в порядке убывания, отсортируем фрейм данных и удалим фильмы с рейтингом меньше 2,5/5,0.
Теперь мы можем вставить новую строку во фрейм данных прямо вверху и дублировать имена столбцов над ними. Это делается только для отображения EasyGUI. Элементу codebox не очень нравится фрейм данных pandas, поэтому нужно изменить формат фрейма.
Преобразуем каждый столбец фрейма в список, а затем повторно соберем его с помощью numpy. Да, мы просто убираем скобки и переходим к окну codebox для отображения списка. Это всё! Давайте найдем фильм по тегу: «hacker» и посмотрим, что покажут рекомендации.
Программа работает. Не стесняйтесь экспериментировать с ней и, пожалуйста, дайте мне знать, если я где-то ошибся!
**Исходный код проекта (осторожно, под спойлером целая простыня)**
```
# импорт библиотек
from fuzzywuzzy import fuzz
from fuzzywuzzy import process
from progress.bar import IncrementalBar
from easygui import *
import easygui as gui
import pandas as pd
import numpy as np
import sys
# максимальное увеличение размера массива отображения numpy для отображения easygui
np.set_printoptions(threshold=sys.maxsize)
# фрейм данных относительно большой, начальная загрузка займет около 30 секунд
# в зависимости от вашего компьютера, поэтому здесь уместна индикация загрузки
progress_bar = IncrementalBar('Loading Movie Database...', max=1)
for i in range(1):
# чтение файлов csv
df_tags = pd.read_csv("tags.csv", usecols = [1,2])
df_movies = pd.read_csv("movies.csv")
df_ratings = pd.read_csv("ratings.csv", usecols = [1,2])
# объединение столбцов из отдельных фреймов данных в новый фрейм
df_1 = pd.merge(df_movies ,df_ratings, on='movieId', how='outer')
# заполнение значений NaN средним рейтингом
df_1['rating'] = df_1['rating'].fillna(df_1['rating'].mean())
# группирование строк df по среднему рейтингу фильма
df_1 = pd.DataFrame(df_1.groupby('movieId')['rating'].mean().reset_index().round(1))
# добавление столбцов title и genres в df
df_1['title'] = df_movies['title']
df_1['genres'] = df_movies['genres']
progress_bar.next()
# заполнение индикатора загрузки при успешной загрузке
progress_bar.finish()
def which_way():
'''
Эта функция, которая выполняется при запуске программы.
Работает как перекресток, вы выбираете поиск фильмов по
тегу или по жанру. По выбору пользователь переходит к следующему окну.
'''
# определение параметров easygui choicebox
msg = "Choose an option:"
title = "Main Menu"
choices = ["Search recommended movies by genre:","Search recommended movies by tag:"]
fieldValues = choicebox(msg,title, choices)
# переменная fieldValues - это пользовательский ввод, который возвращается из графического интерфейса
# условный оператор, направляющий пользователя к следующему интерфейсу на основе ввода
if fieldValues == "Search recommended movies by genre:":
genre_entry()
elif fieldValues == "Search recommended movies by tag:":
tag_entry()
def field_check(msg, title, fieldNames):
'''
Эта функция проверяет отсутствие вводимых пользователем значений в multenterbox
и возвращает пользовательский ввод как переменную fieldValues.
Параметры:
msg, title и fieldnames графического интерфейса multienterbox
'''
fieldValues = multenterbox(msg, title, fieldNames)
# Цикл с условием, чтобы проверить,
# что поля ввода не пусты
while 1:
if fieldValues is None: break
errmsg = ""
for i in range(len(fieldNames)):
if fieldValues[i].strip() == "":
errmsg += ('"%s" is a required field.\n\n' % fieldNames[i])
if errmsg == "":
break # если пустых полей не найдено, перейти к следующему блоку кода
# cохранить пользовательский ввода в виде списка в переменной fieldValues
fieldValues = multenterbox(errmsg, title, fieldNames, fieldValues)
return fieldValues
def tag_entry():
'''
Эта функция определяет параметры easygui multenterbox и вызывает
field_check, если пользователь вводил значнеие,
вызывает тест на подобие; если совпадение не найдено, пользователь возвращается
в окно ввода
'''
# определение параметров easygui multenterbox
msg = "Enter movie tag for example: world war 2 | brad pitt | documentary \nIf tag not found you will be returned to this window"
title = 'Search by tag'
fieldNames = ["Tag"]
# вызов field_check() для проверки отсутствия пользовательского ввода и
# сохранения вода как переменной fieldValues
fieldValues = field_check(msg, title, fieldNames)
# Если пользователь ввел значение, сохраняем его в fieldValues[0]
if fieldValues != None:
global user_input_2
user_input_2 = fieldValues[0]
# здесь мы вызываем функцию, которая в основном проверяет строку
# на схожесть с другими строками. Когда пользователь нажимает кнопку отмены, он возвращается в главное меню
similarity_test2(user_input_2)
else:
which_way()
def tag():
'''
Эта функция добавляет все совпадающие по тегам фильмы во фрейм данных pandas,
изменяет фрейм данных для правильного отображения easygui, отбросив некоторые
столбцы, сбрасывая индекс df, объединяя фреймы и сортируя элементы так,
чтобы показывались фильмы с рейтингом >= 2.5. Она также преобразует столбцы df в списки
и приводит их в порядок в массиве numpy для отображения easygui.
'''
# добавление тегов найденных фильмов как объекта фрейма
final_1 = []
for i in final_2:
final_1.append(df_tags.loc[df_tags['tag'].isin(i)])
# сброс индекса df, удаление столбца индекса, а также повторяющихся записей
lst = final_1[0]
lst = lst.reset_index()
lst.drop('index', axis=1, inplace=True)
lst = lst.drop_duplicates(subset='movieId')
# слияние movieId с названиями и жанрами + удаление тега и идентификатора фильма
df = pd.merge(lst, df_1, on='movieId', how='left')
df.drop('tag', axis=1, inplace=True)
df.drop('movieId', axis=1, inplace=True)
# сортировка фильмов по рейтингам, отображение только фильмов с рейтингом выше или равным 2,5
data = df.sort_values(by='rating', ascending=False)
data = data[data['rating'] >= 2.5]
heading = [] # добавление названий столбцов как первой строки фрейма данных для отображения easygui
heading.insert(0, {'rating': 'Rating', 'title': '----------Title',
'genres': '----------Genre'})
data = pd.concat([pd.DataFrame(heading), data], ignore_index=True, sort=True)
# преобразование столбцов фрейма данных в списки
rating = data['rating'].tolist()
title = data['title'].tolist()
genres = data['genres'].tolist()
# составление массива numpy из списков столбцов dataframe для отображения easygui
data = np.concatenate([np.array(i)[:,None] for i in [rating,title,genres]], axis=1)
data = str(data).replace('[','').replace(']','')
# отображение фильмов пользователю
gui.codebox(msg='Movies filtered by tag returned from database:',
text=(data),title='Movies')
which_way()
def genre_entry():
'''
Эта функция определяет параметры easygui multenterbox
и вызывает field_check, если пользователь что-то вводил,
вызывается тест на подобие. Если совпадение не найдено, пользователь возвращается
в то же окно
'''
# определение параметров easygui multenterbox
msg = "Enter movie genre for example: mystery | action comedy | war \nIf genre not found you will be returned to this window"
title = "Search by genre"
fieldNames = ["Genre"]
# вызов field_check() для проверки отсутствия пользовательского ввода и
# сохранения ввода в fieldValues.
fieldValues = field_check(msg, title, fieldNames)
# Если пользовательский ввод не пуст, сохраняет его в переменной user_input
if fieldValues != None:
global user_input
user_input = fieldValues[0]
# здесь мы вызываем функцию, которая в основном проверяет строку
# на подобие с другими строками. Если пользователь нажмет кнопку отмена, то он вернется в главное меню
similarity_test1(user_input)
else:
which_way()
def genre():
'''
Эта функция добавляет все соответствующие жанру фильмы во фрейм pandas,
изменяет фрейм для правильного отображения easygui, отбросив некоторые
столбцы, сбрасывает индекс df, объединеняет фреймы и сортирует фильмы для отображения
только фильмов с рейтингом >= 2.5. Она также преобразует столбцы конечного df в списки
и приводит их в порядок в массиве numpy для отображения easygui.
'''
# добавление соответствующих жанру фильмов во фрейм.
final_1 = []
for i in final:
final_1.append(df_movies.loc[df_movies['genres'].isin(i)])
# сброс индекса df, удаление индекса столбцов и дубликатов записей
lst = final_1[0]
lst = lst.reset_index()
lst.drop('index', axis=1, inplace=True)
lst.drop('title', axis=1, inplace=True)
lst.drop('genres', axis=1, inplace=True)
lst = lst.drop_duplicates(subset='movieId')
# объединение идентификатора фильма с названием, рейтингом и жанром + удаление индекса, названия и жанра
df = pd.merge(lst, df_1, on='movieId', how='left')
# сортировка по рейтингу, отображение только фильмов с рейтингом выше или равным 2,5
data = df.sort_values(by='rating', ascending=False)
data.drop('movieId', axis=1, inplace=True)
data = data[data['rating'] >= 2.5]
heading = [] # add column names as first dataframe row for easygui display
heading.insert(0, {'rating': 'Rating', 'title': '----------Title',
'genres': '----------Genre'})
data = pd.concat([pd.DataFrame(heading), data], ignore_index=True, sort=True)
# преобразование столбцов фрейма данных в списки
rating = data['rating'].tolist()
title = data['title'].tolist()
genres = data['genres'].tolist()
# составление массива numpy из списков столбцов фрейма для отображения easygui
data = np.concatenate([np.array(i)[:,None] for i in [rating,title,genres]], axis=1)
data = str(data).replace('[','').replace(']','')
# отображение фильмов пользователю
gui.codebox(msg='Movies filtered by genre returned from database:',
text=(data),title='Movies')
which_way()
def similarity_test1(user_input):
'''
Эта функция проверяет схожесть строк путем сопоставления пользовательского ввода
для жанров фильмов, совпадения > 90% сохраняется в переменной, которая
затем передается функции жанра для сопоставления с базой данных и
возврата в окно ввода, если совпадение не найдено
'''
# сохранение жанров фильмов в качестве тестовой базы и пользовательского ввода для тестирования
genre_list = df_movies['genres'].unique()
query = user_input
choices = genre_list
# here fuzzywuzzy does its magic to test for similarity
output = process.extract(query, choices)
# сохранение совпадений в переменной и их передача следующей функции
global final
final = [i for i in output if i[1] > 90]
# если совпадений > 90% не найдено, вернуть пользователя в окно жанра
if final == []:
genre_entry()
else:
genre()
def similarity_test2(user_input_2):
'''
Эта функция проверяет схожесть строк путем сопоставления пользовательского ввода
в теги фильмов, совпадение > 90% сохраняется в переменной, которая
затем передается в функцию тега для сопоставления базы данных и
возврата в окно ввода, если совпадение не найдено
'''
# сохранение тега фильма в качестве тестовой базы и пользовательского ввода для тестирования
tag_list = df_tags['tag'].unique()
query = user_input_2
choices = tag_list
# here fuzzywuzzy does its magic to test for similarity
output = process.extract(query, choices)
# сохранение возвращенных совпадений в переменной и их передача следующей функции
global final_2
final_2 = [i for i in output if i[1] > 90]
#если совпадение> 90% не найдено, возврат в окно ввода
if final_2 == []:
tag_entry()
else:
tag()
if __name__ == '__main__':
which_way()
```
[](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
Получить востребованную профессию с нуля или Level Up по навыкам и зарплате, можно, пройдя наши онлайн-курсы.
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=141020)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=141020)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=141020)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=141020)
* [Профессия Java-разработчик с нуля](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=141020)
* [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FJS&utm_term=regular&utm_content=141020)
**Eще курсы**
* [Обучение профессии Data Science с нуля](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=141020)
* [Онлайн-буткемп по Data Science](https://skillfactory.ru/data-science-camp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSTCAMP&utm_term=regular&utm_content=141020)
* [Обучение профессии Data Analyst с нуля](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=141020)
* [Онлайн-буткемп по Data Analytics](https://skillfactory.ru/business-analytics-camp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DACAMP&utm_term=regular&utm_content=141020)
* [Курс по 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=141020)
* [Курс «Математика и 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=141020)
* [Продвинутый курс «Machine Learning Pro + Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=141020)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=141020)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=141020)
* [Профессия UX-дизайнер с нуля](https://contented.ru/edu/uxdesigner?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_UXS&utm_term=regular&utm_content=141020)
* [Профессия Web-дизайнер](https://contented.ru/edu/webdesigner?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WBDS&utm_term=regular&utm_content=141020)
Читать еще
----------
* [Как сделать интерактивную карту с помощью Python и open source библиотек](https://habr.com/ru/company/skillfactory/blog/521840/)
* [Данные внутри нас: Чем занимаются биоинформатики?](https://habr.com/ru/company/skillfactory/blog/522444/)
* [Machine Learning и Computer Vision в добывающей промышленности](https://habr.com/ru/company/skillfactory/blog/522776/) | https://habr.com/ru/post/523132/ | null | ru | null |
# Анализ данных из последнего слива Intel
Я порылся в 20 гигабайтах [слитых данных](https://t.me/exconfidential/590) с незащищённого CDN интела в поисках интересного и оценки серьёзности этой утечки.
*КДПВ. Прототип ноутбука на Tiger Lake.*
#### Краткое резюме
Большая часть слитой информации предназначена для OEM/ODM разработчиков и производителей, но заинтересует энтузиастов, исследующих BIOS и недокументированные режимы работы процессоров Intel. В них нет внутренней интеловской документации, критичной к обнародованию, или способной раскрыть секретные разработки. Также здесь не найти информации о неизвестных ранее уязвимостях.
#### Файлы
Не указанные здесь файлы либо являются просто новостными обновлениями Intel, либо бинарниками без описания или не заслуживают внимания.
**Файл 576931-potter-city-576931-v1-0-schem.pdf**
Диаграммы, электросхемы, рекомендации по разводке материнских плат с четырьмя сокетами для процессоров на ядре SandyBridge от 2010 года.
*Интересно, что используются только переназначаемые линии PCIe одного процессора*
На остальных страницах данные по всем указанным на диаграмме блокам. Может быть полезно для академических знаний, на реальные материнские платы переложить не получится.
*Например блокировочные конденсаторы для разных цепей с указанием точной маркировки компонента и рекомендации по размещению*
**Файл 367228-367228-rev-1-5.pdf**
Документация с электросхемами для чего-то вроде отладочной/демонстрационной платы для первого поколения «атомов».
*Структурная схема с пояснениями по работе цепи питания при включении*
**Файл 544767-intel-ethernet-connection-i219-reference-schematic-rev1-0.pdf**
Типовая схема подключения гигабитного сетевого адаптера [i219](https://ark.intel.com/content/www/ru/ru/ark/products/82186/intel-ethernet-connection-i219-v.html), 2015 год.
**Файл 555388-purley-platform-power-delivery-schematic-layout-checklist-rev1-1.xlsx**
Таблица для заполнения инженерами или тестировщиками плат сторонних производителей. Нужно проверить электросхему и топологию (а конкретно силовую часть) на соответствие рекомендуемым требованиям. В конце excel посчитает «очки» и выдаст результат в процентах:
**Файл 621487-cml-itbmt3-ta-ww14-2020.pdf**
Общее описание принципов работы технологии Turbo Boost 3.0 в Kaby Lake (это седьмое поколение Core от 2017 года). В частности описано, из каких регистров процессора подсистеме BIOS считывать максимальные множители буста отдельных ядер.
**Файл 20170823\_HDCP\_EB-1.0\_MEDIA\_Eng\_release.tar.gz**
Демон и тестовая утилита для проверки работы [HDCP](https://ru.wikipedia.org/wiki/HDCP) под Arch Linux. В архиве только бинарники и readme.
**Файл BVT\_Package\_10.0.0.1086.exe**
Утилита и документация для проверки соответствия системы требованиям Intel для маркировки компьютера логотипом [Intel vPro](https://www.intel.ru/content/www/ru/ru/architecture-and-technology/vpro/vpro-platform-general.html). Утилита проводит несколько тестов, и затем отчёт можно отправить в Intel, если все тесты пройдены успешно.
**Файл cmls102-prq-report-rev0.pdf**
Отчёт о методиках тестирования микросхем и прогнозируемых процентах отказа для процессоров Core и Xeon от апреля 2020 года. Из этого документа можно узнать, через что проходят процессоры перед попаданием в наши компьютеры:
*Infant Mortality Test — это первое тестирование микросхем после корпусирования в работе при повышенной температуре. Название [не самое морально допустимое](https://ru.wikipedia.org/wiki/%D0%9C%D0%BB%D0%B0%D0%B4%D0%B5%D0%BD%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%81%D0%BC%D0%B5%D1%80%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C), но чего ждать от авторов master/slave?*
Подробнее о процедуре тестирования микросхем можно будет узнать из фильма, который я скоро опубликую.
**Файл prq-prq-customer-report-skl-2-2-lga-dt-rev0.pdf**
Такой же отчёт для процессоров Pentium и i3 от 2015 года.
**Файл c-state-test-case-intel-soc-watch-bkc-626226-rev0-5.pdf**
Варианты тестирования режимов c-state и p-state процессора (оптимизация по потребляемой мощности и по частоте с напряжением). Пошаговая инструкция по настройкам BIOS и использованию специальной утилиты для тестирования.
**Файл FMX.Data.Flows.Training.v1.0\_2020-02-11\_AVM.pdf**
Какая-то плохо свёрстанная презентация на тему сетевой передачи. Наполовину состоит из аббревиатур, так что я не понял, о чём она конкретно. 2020 год.
**Файл glk\_platform\_intel®\_txe\_4.0.25.1324\_mr.pdf**
Некоторое (неполное) описание набора утилит для сборки и подписывания прошивок модуля [Intel TXE](https://www.intel.ru/content/www/ru/ru/support/articles/000025873/technologies.html). Например есть таблица компонентов TXE с их размерами и рекомендации по выбору ёмкости микросхемы flash для BIOS. 2020 год.
**Файл how to obtain intel system debugger nda.pdf**
Содержит руководство по получению отладочного комплекта для разработчиков систем с процессорами Intel. Буквально как и какие поля заполнять в форме на сайте. 2020 год.
**Файл qts-qpp-5v1-17-1.pdf**
Инструкция по Quartus Pro — софту для разработки под FPGA (до покупки интелом был известен, как Altera Quartus).
**Файл SeamlessUpdate\_CapsuleGeneration\_UserGuide\_v0.5.2.pdf**
Инструкция для производителей оборудования по сборке патчей для обновления биоса, Intel ME, микрокода и тому подобного.
**Файл SeamlessUpdate\_CapsuleGenerationEnv\_v0.5.2.zip**
Сам набор утилит для сборки.
**Файл simicsmodellibrary\_eaglestream\_rn\_v0\_6\_00.pdf**
Краткая инструкция по установке и использованию утилиты для эмуляции системы. Используется в разработке прошивки BIOS для ещё не вышедших процессоров.
Папка **Intel ME** cодержит утилиты, документацию и бинарники для [Intel ME](https://www.intel.ru/content/www/ru/ru/support/articles/000008927/software/chipset-software.html). Абсолютно ничего полезного не обнаружено. Есть исходник примера утилиты для прошивки, но он использует сишную библиотеку FWUpdateLib.lib, которая и выполняет всю интересную работу. В коде во всех функциях своеобразный выход из функций по goto (метка End во всех функциях одинаковая), больше ничего примечательного.
**Посмотреть листинг**
```
static UINT32 checkUpdateType(IN const char *fileName, IN UINT32 *updateType)
{
UINT32 status;
UINT16 flashMajor = 0;
UINT16 flashMinor = 0;
UINT16 flashHotfix = 0;
UINT16 flashBuild = 0;
UINT16 fileMajor = 0;
UINT16 fileMinor = 0;
UINT16 fileHotfix = 0;
UINT16 fileBuild = 0;
INT32 comparedVersion = 0;
if (fileName == NULL || updateType == NULL)
{
status = INTERNAL_ERROR;
goto End;
}
status = FwuPartitionVersionFromFlash(FPT_PARTITION_NAME_FTPR, &flashMajor, &flashMinor, &flashHotfix, &flashBuild);
if (status != SUCCESS)
{
goto End;
}
status = FwuPartitionVersionFromFile(fileName, FPT_PARTITION_NAME_FTPR, &fileMajor, &fileMinor, &fileHotfix, &fileBuild);
if (status != SUCCESS)
{
goto End;
}
comparedVersion = versionCompare(fileMajor, fileMinor, fileHotfix, fileBuild,
flashMajor, flashMinor, flashHotfix, flashBuild);
if (comparedVersion < 0)
{
*updateType = DOWNGRADE;
}
else if (comparedVersion > 0)
{
*updateType = UPGRADE;
}
else
{
*updateType = SAME_VERSION;
}
End:
return status;
}
```
**Папка Intel Restricted Secret**
А вот тут уже есть кое-что интересное. В папке KabylakePlatform\_3\_7\_9\KabylakePlatSamplePkg лежит пример BIOS для платформы Kaby Lake (это 7-ое поколение процессоров Core, вышли в 2017 году). Собирать я его не пробовал, но по виду тут есть всё необходимое.
В папке Features лежат исходники драйверов устройств. Например для SATA, с виду, вполне рабочий код поиска и инициализации устройства на PCIe.
**Листинг**
```
/**
This routine is called right after the .Supported() is called and returns
EFI_SUCCESS. Notes: The supported protocols are checked but the Protocols
are closed.
@param[in] This A pointer points to the Binding Protocol instance
@param[in] Controller The handle of controller to be tested. Parameter
passed by the caller
@param[in] RemainingDevicePath A pointer to the device path. Should be ignored by
device driver
@retval EFI_SUCCESS The device is started
@retval Other values Something error happened
**/
EFI_STATUS
EFIAPI
SataControllerStart (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE Controller,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
)
{
EFI_STATUS Status;
EFI_IDE_CONTROLLER_INIT_PROTOCOL *IdeInit;
EFI_PCI_IO_PROTOCOL *PciIo;
UINT8 NumberOfPort;
UINT64 CommandVal;
DEBUG ((DEBUG_INFO, "SataControllerStart() Start\n"));
///
/// Now test and open the EfiPciIoProtocol
///
Status = gBS->OpenProtocol (
Controller,
&gEfiPciIoProtocolGuid,
(VOID **) &PciIo,
This->DriverBindingHandle,
Controller,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
///
/// Status == 0 - A normal execution flow, SUCCESS and the program proceeds.
/// Status == ALREADY_STARTED - A non-zero Status code returned. It indicates
/// that the protocol has been opened and should be treated as a
/// normal condition and the program proceeds. The Protocol will not
/// opened 'again' by this call.
/// Status != ALREADY_STARTED - Error status, terminate program execution
///
if (EFI_ERROR (Status)) {
///
/// EFI_ALREADY_STARTED is also an error
///
return Status;
}
///
/// Get device capabilities
///
Status = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationSupported,
0,
&CommandVal
);
ASSERT_EFI_ERROR (Status);
///
/// Enable Command Register
///
Status = PciIo->Attributes (
PciIo,
EfiPciIoAttributeOperationEnable,
CommandVal & EFI_PCI_DEVICE_ENABLE,
NULL
);
ASSERT_EFI_ERROR (Status);
///
/// Get Number of Ports
///
PciIo->Mem.Read (
PciIo,
EfiPciIoWidthUint8,
EFI_AHCI_BAR_INDEX,
(UINT64) R_AHCI_CAPABILITY,
1,
& NumberOfPort
);
NumberOfPort = (NumberOfPort & 0x1F) + 1;
IdeInit = AllocatePool (sizeof (EFI_IDE_CONTROLLER_INIT_PROTOCOL));
if (IdeInit == NULL) {
return EFI_OUT_OF_RESOURCES;
}
IdeInit->GetChannelInfo = IdeInitGetChannelInfo;
IdeInit->NotifyPhase = IdeInitNotifyPhase;
IdeInit->SubmitData = IdeInitSubmitData;
IdeInit->DisqualifyMode = IdeInitDisqualifyMode;
IdeInit->CalculateMode = IdeInitCalculateMode;
IdeInit->SetTiming = IdeInitSetTiming;
IdeInit->EnumAll = SATA_ENUMER_ALL;
IdeInit->ChannelCount = NumberOfPort;
///
/// Install IDE_CONTROLLER_INIT protocol & private data to this instance
///
Status = gBS->InstallMultipleProtocolInterfaces (
&Controller,
&gEfiIdeControllerInitProtocolGuid,
IdeInit,
NULL
);
///
/// Close protocols opened by SATA controller driver
///
gBS->CloseProtocol (
Controller,
&gEfiPciIoProtocolGuid,
This->DriverBindingHandle,
Controller
);
DEBUG ((DEBUG_INFO, "SataControllerStart() End\n"));
return Status;
}
```
Также в папке Intel Restricted Secret лежат исходники:
* Кодов инициализации процессоров Kaby Lake с документацией;
* Что-то под названием Client Silicon API package;
* Инструкция по интеграции этого всего в свой BIOS (для разработчиков оборудования).
**Файл 482486-crystal-forest-gladden-stargo-schematic-design-files-rev2-1.zip**
Библиотеки [Cadence](https://www.cadence.com/en_US/home.html) для разработки под интеловскую платформу с кодовым названием [Crystal Forest](https://www.intel.com/content/www/us/en/design/products-and-solutions/processors-and-chipsets/crystal-forest/technical-library.html). Самих проектов с трассировкой плат нет.
*Логика*
*EEPROM*
*Дискретные компоненты*
*Разъёмы*
Обычный набор библиотек. Скорее всего, из пакета поставки Cadence. Сами файлы датированы 2012 годом.
**Файл 555146-kipsbay2-archive.zip**
То же самое для arduino-совместимых плат [Intel Galileo](https://www.intel.ru/content/www/ru/ru/support/articles/000005912/boards-and-kits/intel-galileo-boards.html). Тоже без файлов трассировки.
**Файл 607872-tgl-up3-up4-pdg-schchk-rev1-2.zip**
Очень подробная инструкция по разработке электросхем и трассировке плат для ещё не вышедшего 11-го поколения процессоров Core под кодовым названием Tiger Lake.
*Много таких наглядных иллюстраций с пояснениями*
**Файл 615188-wilson-city-schematic-walkthrough-bmc.zip**
Видеопрезентация с пояснениями к схеме какого-то чипсета с кодовым именем Wilson City. Озвучено синтезатором голоса.
*Кадр из этого захватывающего видео*
**Файл 615704-cml-s-udimm-3200-cmp-h-rvp-tdk-rev0p7.zip**
Электросхемы и проект Cadence с трассировкой типовой платы для процессоров [Comet Lake S](https://www.intel.ru/content/www/ru/ru/design/products-and-solutions/processors-and-chipsets/comet-lake-s/overview.html?grouping=EMT_Content%20Type&sort=title:asc) с UDIMM памятью.
*Красивые 10 слоёв*
*Преобразователь уровней для HDMI*
**Файл 618525-tigerlake-up3-tsn-aic.zip**
Похоже на электросхему и описание тестовой платы с периферией для ещё не вышедшего процессора Tiger Lake.
*PCIe плата с двумя контроллерами Ethernet и PHY для них*
*Пояснения к изменениям в этой ревизии*
**Файл 618730-ehl-mcl-hierarchical-schematic-lp4x-0-7.zip**
Библиотека компонентов Cadence для ещё не вышедших процессоров Elkhart Lake (линейка Intel Atom). Без файлов проекта, но есть полная электросхема для всей периферии и питания. Уже можно прикинуть, какие порты будут на плате.
**Файл adk\_source.2.0.11.09.standalone.snowridge\_transportip.tar.gz**
Исходники и инструкции утилиты для эмуляции сетевой подсистемы ещё не вышедших процессоров [Snowfish](https://ark.intel.com/content/www/us/en/ark/products/codename/87586/snow-ridge.html). Как я понял, она подключается к эмулятору процессоров Snowfish и позволяет тестировать сетевые возможности.
**Файл aml\_cfl\_s\_kbl\_skl-vbios\_9.0.1062.zip**
Какой-то скрипт для утилиты редактирования [VBIOS](https://ru.wikipedia.org/wiki/Video_BIOS) для OEM разработчиков. В текстовом виде описана структура файла прошивки VBIOS.
**Файл apl-i\_sic\_1.1.1\_v227\_51\_d20190502.zip**
Исходники кодов инициализации процессоров [Apollo Lake](https://ark.intel.com/content/www/ru/ru/ark/products/codename/80644/apollo-lake.html) и документация.
**Файл core 10x00k 10x00kf v 1.0.5.zip**
Содержит установщик утилиты с очень перспективным названием:
У меня нет такого процессора, так что проверить не получилось.
**Файл elkhartlake\_silicon\_and\_platformsamplecode\_v1.0.0.zip**
Исходники кодов инициализации теперь уже для Elkhart Lake, с частью исходников для BIOS и файлами Client Silicon. Подозреваю, что можно использовать пример BIOS для Kaby Lake, чтобы собрать BIOS для этих процессоров.
**Файл intel®pch chipset\_init kit — tglpchlp\_z0v5\_a0v11.zip**
Патч для BIOS в бинарном виде и инструкция к утилите для установки этого патча в прошивку. Сам патч исправляет какие-то ошибки в инициализации чипсета для процессоров Tiger Lake.
**Файл intel®powerandthermaldesignstudio\_ext\_2.1.1.zip**
Загадочная утилита Intel Power and Thermal Design Studio.
**Файлы KBL SST FDK training session 2.1.zip — KBL SST FDK training session 4.2.zip**
Запись видеоуроков по разработке то ли прошивки, то ли драйвера в какой-то графической утилите. За кадром слышен голос индуса с плохим произношением.
**Файл main\_pld\_adr\_engineering\_release\_ww19.zip**
[Verilog](https://ru.wikipedia.org/wiki/Verilog)-коды для уже упомянутого чипсета Wilson City. Видимо, для тестирования в [ПЛИС](https://ru.wikipedia.org/wiki/%D0%9F%D0%9B%D0%98%D0%A1) до изготовления в кремнии.
**Очень длинный листинг**
```
// (C) 2020 Intel Corporation. All rights reserved.
// Your use of Intel Corporation's design tools, logic functions and other
// software and tools, and its AMPP partner logic functions, and any output
// files from any of the foregoing (including device programming or simulation
// files), and any associated documentation or information are expressly subject
// to the terms and conditions of the Intel Program License Subscription
// Agreement, Intel FPGA IP License Agreement, or other applicable
// license agreement, including, without limitation, that your use is for the
// sole purpose of programming logic devices manufactured by Intel and sold by
// Intel or its authorized distributors. Please refer to the applicable
// agreement for further details.
`timescale 1ns/1ns
`define dedicated_debug_logic
module Wilson_City_Main (
// Input CLK
input iClk_2M,
input iClk_50M,
output o1mSCE,
//GSX Interface with BMC
input SGPIO_BMC_CLK,
input SGPIO_BMC_DOUT,
output SGPIO_BMC_DIN,
input SGPIO_BMC_LD_N,
//I2C Support
inout SMB_PLD_SDA, // SMB_PCH_PMBUS2_STBY_LVC3_SDA
input SMB_PLD_SCL, // SMB_PCH_PMBUS2_STBY_LVC3_SCL
output onSDAOE,
//LED and 7-Seg Control Logic
output [7:0] LED_CONTROL,
output FM_CPU1_DIMM_CH1_4_FAULT_LED_SEL,
output FM_CPU1_DIMM_CH5_8_FAULT_LED_SEL,
output FM_CPU2_DIMM_CH1_4_FAULT_LED_SEL,
output FM_CPU2_DIMM_CH5_8_FAULT_LED_SEL,
output FM_FAN_FAULT_LED_SEL_N,
output FM_POST_7SEG1_SEL_N,
output FM_POST_7SEG2_SEL_N,
output FM_POSTLED_SEL,
//CATERR DLY
output FM_CPU_CATERR_DLY_LVT3_N,
input FM_CPU_CATERR_PLD_LVT3_N, //% No Input FF
//ADR
input FM_ADR_COMPLETE, //% Input FF
output FM_ADR_COMPLETE_DLY,
output FM_ADR_SMI_GPIO_N,
inout FM_ADR_TRIGGER_N,
input FM_PLD_PCH_DATA, //% Input FF
input FM_PS_PWROK_DLY_SEL, //% Input FF
input FM_DIS_PS_PWROK_DLY, //% Input FF
//ESPI Support
output FM_PCH_ESPI_MUX_SEL,
//System THROTTLE
input FM_PMBUS_ALERT_B_EN, //% Input FF
input FM_THROTTLE_N, //% Input FF
input IRQ_SML1_PMBUS_PLD_ALERT_N, //% Input FF
output FM_SYS_THROTTLE_LVC3_PLD,
// Termtrip dly
input FM_CPU1_THERMTRIP_LVT3_PLD_N, //% Input FF
input FM_CPU2_THERMTRIP_LVT3_PLD_N, //% Input FF
input FM_MEM_THERM_EVENT_CPU1_LVT3_N, //% Input FF
input FM_MEM_THERM_EVENT_CPU2_LVT3_N, //% Input FF
output FM_THERMTRIP_DLY,
//MEMHOT
input IRQ_PVDDQ_ABCD_CPU1_VRHOT_LVC3_N,//% Input FF
input IRQ_PVDDQ_EFGH_CPU1_VRHOT_LVC3_N,//% Input FF
input IRQ_PVDDQ_ABCD_CPU2_VRHOT_LVC3_N,//% Input FF
input IRQ_PVDDQ_EFGH_CPU2_VRHOT_LVC3_N,//% Input FF
output FM_CPU1_MEMHOT_IN,
output FM_CPU2_MEMHOT_IN,
//MEMTRIP
input FM_CPU1_MEMTRIP_N, //% Input FF
input FM_CPU2_MEMTRIP_N, //% Input FF
//PROCHOT
input FM_PVCCIN_CPU1_PWR_IN_ALERT_N, //% Input FF
input FM_PVCCIN_CPU2_PWR_IN_ALERT_N, //% Input FF
input IRQ_PVCCIN_CPU1_VRHOT_LVC3_N, //% Input FF
input IRQ_PVCCIN_CPU2_VRHOT_LVC3_N, //% Input FF
output FM_CPU1_PROCHOT_LVC3_N,
output FM_CPU2_PROCHOT_LVC3_N,
//PERST & RST
input FM_RST_PERST_BIT0, //% No-Input FF
input FM_RST_PERST_BIT1, //% No-Input FF
input FM_RST_PERST_BIT2, //% No-Input FF
output RST_PCIE_PERST0_N,
output RST_PCIE_PERST1_N,
output RST_PCIE_PERST2_N,
output RST_CPU1_LVC3_N,
output RST_CPU2_LVC3_N,
output RST_PLTRST_B_N,//RST_PLTRST_PLD_B_N
input RST_PLTRST_N, //RST_PLTRST_PLD_N //% Input FF
//FIVR
input FM_CPU1_FIVR_FAULT_LVT3, //FM_CPU1_FIVR_FAULT_LVT3_PLD //% Input FF
input FM_CPU2_FIVR_FAULT_LVT3, //FM_CPU2_FIVR_FAULT_LVT3_PLD //% Input FF
//CPU Misc
input FM_CPU1_PKGID0, //% No-Input FF
input FM_CPU1_PKGID1, //% No-Input FF
input FM_CPU1_PKGID2, //% No-Input FF
input FM_CPU1_PROC_ID0, //% No-Input FF
input FM_CPU1_PROC_ID1, //% No-Input FF
input FM_CPU1_INTR_PRSNT, //% No-Input FF
input FM_CPU1_SKTOCC_LVT3_N, //FM_CPU1_SKTOCC_LVT3_PLD_N //% No-Input FF
input FM_CPU2_PKGID0, //% No-Input FF
input FM_CPU2_PKGID1, //% No-Input FF
input FM_CPU2_PKGID2, //% No-Input FF
input FM_CPU2_PROC_ID0, //% No-Input FF
input FM_CPU2_PROC_ID1, //% No-Input FF
input FM_CPU2_INTR_PRSNT, //% No-Input FF
input FM_CPU2_SKTOCC_LVT3_N, //FM_CPU2_SKTOCC_LVT3_PLD_N //% No-Input FF
//BMC
input FM_BMC_PWRBTN_OUT_N, //% Input FF
input FM_BMC_ONCTL_N, //FM_BMC_ONCTL_N_PLD //% Input FF
output RST_SRST_BMC_PLD_N, //RST_SRST_BMC_PLD_R_N
output FM_P2V5_BMC_EN, //FM_P2V5_BMC_EN_R
input PWRGD_P1V1_BMC_AUX, //% Input FF
//PCH
output RST_RSMRST_N, // RST_RSMRST_PLD_R_N
output PWRGD_PCH_PWROK, // PWRGD_PCH_PWROK_R
output PWRGD_SYS_PWROK, // PWRGD_SYS_PWROK_R
input FM_SLP_SUS_RSM_RST_N, //% Input FF
input FM_SLPS3_N, // FM_SLPS3_PLD_N //% Input FF
input FM_SLPS4_N, // FM_SLPS4_PLD_N //% Input FF
input FM_PCH_PRSNT_N, //% No-Input FF
output FM_PCH_P1V8_AUX_EN, // FM_PCH_P1V8_AUX_EN_R
input PWRGD_P1V05_PCH_AUX, //% Input FF
input PWRGD_P1V8_PCH_AUX, // PWRGD_P1V8_PCH_AUX_PLD //% Input FF
output FM_PFR_MUX_OE_CTL_PLD, //% PFR Mux Sel
input RST_DEDI_BUSY_PLD_N, //% Dediprog RST
//PSU Ctl
output FM_PS_EN, // FM_PS_EN_PLD_R
input PWRGD_PS_PWROK, // PWRGD_PS_PWROK_PLD_R //% Input FF
//Clock Logic
output FM_PLD_CLKS_OE_N,// FM_PLD_CLKS_OE_R_N
output FM_CPU_BCLK5_OE_R_N,
//Base Logic
input PWRGD_P3V3_AUX, //PWRGD_P3V3_AUX_PLD_R //% Input FF
//Main VR & Logic
input PWRGD_P3V3, //% Input FF
output FM_P5V_EN,
output FM_AUX_SW_EN,
//Mem
input PWRGD_CPU1_PVDDQ_ABCD, //% Input FF
input PWRGD_CPU1_PVDDQ_EFGH, //% Input FF
input PWRGD_CPU2_PVDDQ_ABCD, //% Input FF
input PWRGD_CPU2_PVDDQ_EFGH, //% Input FF
output FM_PVPP_CPU1_EN,
output FM_PVPP_CPU2_EN,
//CPU
output PWRGD_CPU1_LVC3,
output PWRGD_CPU2_LVC3,
input PWRGD_CPUPWRGD, //PWRGD_CPUPWRGD_PLD_R //% Input FF
output PWRGD_DRAMPWRGD_CPU,
output FM_P1V1_EN, // Used to turn on PCIE re-timmer vr
output FM_P1V8_PCIE_CPU1_EN,
output FM_P1V8_PCIE_CPU2_EN,
output FM_PVCCANA_CPU1_EN,
output FM_PVCCANA_CPU2_EN,
output FM_PVCCIN_CPU1_EN,
output FM_PVCCIN_CPU2_EN,
output FM_PVCCIO_CPU1_EN,
output FM_PVCCIO_CPU2_EN,
output FM_PVCCSA_CPU1_EN,
output FM_PVCCSA_CPU2_EN,
input PWRGD_BIAS_P1V1, //% Input FF
input PWRGD_P1V8_PCIE_CPU1, //% Input FF
input PWRGD_P1V8_PCIE_CPU2, //% Input FF
input PWRGD_PVCCIN_CPU1, //% Input FF
input PWRGD_PVCCIN_CPU2, //% Input FF
input PWRGD_PVCCIO_CPU1, //% Input FF
input PWRGD_PVCCIO_CPU2, //% Input FF
input PWRGD_PVCCSA_CPU1, //% Input FF
input PWRGD_PVCCSA_CPU2, //% Input FF
input PWRGD_VCCANA_PCIE_CPU1, //% Input FF
input PWRGD_VCCANA_PCIE_CPU2, //% Input FF
//DBP
input DBP_POWER_BTN_N, //% Input FF
input DBP_SYSPWROK, //DBP_SYSPWROK_PLD //% Input FF
//Debug
input FM_FORCE_PWRON_LVC3,
output FM_PLD_HEARTBEAT_LVC3,
// Front Panel
output FP_LED_FAN_FAULT_PWRSTBY_PLD_N, // Emeral ridge support
output FP_BMC_PWR_BTN_CO_N, // need add support OD
//Debug pins I/O
output SGPIO_DEBUG_PLD_CLK,
input SGPIO_DEBUG_PLD_DIN,
output SGPIO_DEBUG_PLD_DOUT,
output SGPIO_DEBUG_PLD_LD_N,
input SMB_DEBUG_PLD_SCL,
input SMB_DEBUG_PLD_SDA,
output oSMB_DEBUG_PLD_SDA_OE,
input FM_PLD_REV_N,
input SPI_BMC_BOOT_R_CS1_N,
output SPI_PFR_BOOT_CS1_N
);
//////////////////////////////////////////////////////////////////////////////////
// Parameters
//////////////////////////////////////////////////////////////////////////////////
parameter LOW =1'b0;
parameter HIGH=1'b1;
parameter FPGA_MAJOR_REV = 8'd00;
parameter FPGA_MINOR_REV = 8'd06;
parameter FPGA_DEBUG_MINIMUM_MAJOR_REV = 8'd00;
parameter FPGA_DEBUG_MINIMUM_MINOR_REV = 8'd01;
//////////////////////////////////////////////////////////////////////////////////
// Internal Signals
//////////////////////////////////////////////////////////////////////////////////
wire wCLK_20mSCE, wCLK_250mS, wCLK1SCE;
wire w1uSCE;
wire w5uSCE;
wire w10uSCE;
wire w500uSCE;
wire w1mSCE;
wire w250mSCE;
wire w20mSCE;
wire w1SCE;
wire wvRstPCIePERst_n [2:0];
wire wRstPchPerstN,wRstCPU0PerstN,wRstCPU1PerstN;
wire wPsuPwrEn,wPsuPwrFlt,wPsuPwrgd,wPwrgd_Ps_Pwrok_Dly;
wire wRst_n, wMemPwrEn;
wire wBmcPwrgd,wBmcPwrFlt;
wire wPchPwrgd,wPchPwrFlt;
wire wMemPwrgd,wMemPwrFlt;
wire wCpuPwrEn,wCpuPwrgd,wCpuPwrFlt;
wire wFault;
wire wTimeout;
wire [2:0] wDbgMemSt_CPU1;
wire [2:0] wDbgMemSt_CPU2;
wire [3:0] wDbgCpuSt_CPU1;
wire [3:0] wDbgCpuSt_CPU2;
wire [3:0] wDbgMstSt;
wire [3:0] wDbgMstSt7Seg;
wire [3:0] wFaultStage;
wire [7:0] wFaultState;
wire [254:0] wMonitorFaultState;
wire wGoOutFltSt;
wire FM_THROTTLE_N_FF;
wire IRQ_SML1_PMBUS_PLD_ALERT_N_FF;
wire FM_CPU1_THERMTRIP_LVT3_PLD_N_FF;
wire FM_CPU2_THERMTRIP_LVT3_PLD_N_FF;
wire FM_MEM_THERM_EVENT_CPU1_LVT3_N_FF;
wire FM_MEM_THERM_EVENT_CPU2_LVT3_N_FF;
wire IRQ_PVDDQ_ABCD_CPU1_VRHOT_LVC3_N_FF;
wire IRQ_PVDDQ_EFGH_CPU1_VRHOT_LVC3_N_FF;
wire IRQ_PVDDQ_ABCD_CPU2_VRHOT_LVC3_N_FF;
wire IRQ_PVDDQ_EFGH_CPU2_VRHOT_LVC3_N_FF;
wire FM_CPU1_MEMTRIP_N_FF;
wire FM_CPU2_MEMTRIP_N_FF;
wire FM_PVCCIN_CPU1_PWR_IN_ALERT_N_FF;
wire FM_PVCCIN_CPU2_PWR_IN_ALERT_N_FF;
wire IRQ_PVCCIN_CPU1_VRHOT_LVC3_N_FF;
wire IRQ_PVCCIN_CPU2_VRHOT_LVC3_N_FF;
wire FM_BMC_PWRBTN_OUT_N_FF;
wire FM_BMC_ONCTL_N_FF;
wire FM_SLP_SUS_RSM_RST_N_FF;
wire DBP_POWER_BTN_N_FF;
wire RST_PLTRST_N_FF;
wire FM_SLPS3_N_FF;
wire FM_SLPS4_N_FF;
wire PWRGD_P1V1_BMC_AUX_FF;
wire PWRGD_P1V8_PCH_AUX_FF;
wire PWRGD_P1V05_PCH_AUX_FF;
wire PWRGD_PS_PWROK_FF;
wire PWRGD_P3V3_AUX_FF;
wire PWRGD_P3V3_FF;
wire PWRGD_CPU1_PVDDQ_ABCD_FF;
wire PWRGD_CPU1_PVDDQ_EFGH_FF;
wire PWRGD_CPU2_PVDDQ_ABCD_FF;
wire PWRGD_CPU2_PVDDQ_EFGH_FF;
wire PWRGD_CPUPWRGD_FF;
wire PWRGD_BIAS_P1V1_FF;
wire PWRGD_P1V8_PCIE_CPU1_FF;
wire PWRGD_P1V8_PCIE_CPU2_FF;
wire PWRGD_PVCCIN_CPU1_FF;
wire PWRGD_PVCCIN_CPU2_FF;
wire PWRGD_PVCCIO_CPU1_FF;
wire PWRGD_PVCCIO_CPU2_FF;
wire PWRGD_PVCCSA_CPU1_FF;
wire PWRGD_PVCCSA_CPU2_FF;
wire PWRGD_VCCANA_PCIE_CPU1_FF;
wire PWRGD_VCCANA_PCIE_CPU2_FF;
wire FM_ADR_COMPLETE_FF;
wire FM_PLD_PCH_DATA_FF;
wire FM_PS_PWROK_DLY_SEL_FF;
wire FM_DIS_PS_PWROK_DLY_FF;
wire FM_PMBUS_ALERT_B_EN_FF;
wire FM_CPU1_FIVR_FAULT_LVT3_FF;
wire FM_CPU2_FIVR_FAULT_LVT3_FF;
wire DBP_SYSPWROK_FF;
wire wCPUPwrGd_Dly;
wire [7:0] wvPOSTCodeLEDs;
wire [7:0] wvFanFaultLEDs;
wire [15:0] wvP1DIMMLEDs;
wire [15:0] wvP2DIMMLEDs;
wire [15:0] wvP3DIMMLEDs;
wire [15:0] wvP4DIMMLEDs;
wire wvMCPSilicon;
wire wSocketRemoved;
wire wValidForcePowerOn;
wire wPWRGD_CPU_LVC3;
wire wPchPwrFltP1V05;
wire wPchPwrFltP1V8;
wire wSysOk;
wire wCPUMismatch;
wire wPWRGD_PS_PWROK_DLY;
wire wPWRGD_PS_PWROK_DLY_ADR;
wire wMainVRPwrEn;
wire wMainPwrFlt;
wire wP3v3PwrFlt;
wire wMainVRPwrgd;
wire wFM_AUX_SW_EN;
wire wFM_P5V_EN;
wire wMemPwrFltVDDQ_CPU1_ABCD;
wire wMemPwrFltVDDQ_CPU1_EFHG;
wire wMemPwrgd_CPU1;
wire wMemPwrFlt_CPU1;
wire wMemPwrFltVDDQ_CPU2_ABCD;
wire wMemPwrFltVDDQ_CPU2_EFHG;
wire wMemPwrgd_CPU2;
wire wMemPwrFlt_CPU2;
wire wCpuPwrgd_CPU1;
wire wCpuPwrFlt_CPU1;
wire wPWRGD_PVCCIO_CPU1;
wire wCpuPwrFltVCCIO_CPU1;
wire wCpuPwrFltP1V8_PCIE_CPU1;
wire wCpuPwrFltVCCANA_CPU1;
wire wCpuPwrFltVCCIN_CPU1;
wire wCpuPwrFltVCCSA_CPU1;
wire wCpuPwrgd_CPU2;
wire wCpuPwrFlt_CPU2;
wire wFM_PVCCIO_CPU2_EN;
wire wCpuPwrFltVCCIO_CPU2;
wire wCpuPwrFltP1V8_PCIE_CPU2;
wire wCpuPwrFltVCCANA_CPU2;
wire wCpuPwrFltVCCIN_CPU2;
wire wCpuPwrFltVCCSA_CPU2;
wire FM_BMC_ONCTL_N_LATCH;
wire wPwrEn;
wire wFM_CPU1_THERMTRIP_N;
wire wFM_CPU2_THERMTRIP_N;
wire [127:0] wInputLEDMux;
wire [7:0] wvPOSTCodeLEDMux;
wire wFM_CPU1_SKTOCC_LVT3_N;
wire wFM_CPU2_SKTOCC_LVT3_N;
wire wRSMRST_Delay_Dedi, wRSMRST_N;
wire [6:0] wByteSeg1_RevMajor;
wire [6:0] wByteSeg2_RevMinor;
wire [7:0] FPGA_REV_Major_DebugPLD;
wire [7:0] FPGA_REV_Minor_DebugPLD;
wire FM_PLD_REV_N_FF;
wire wDebugPLD_Valid;
wire wICX; //This indicates PROC ID is the ICX one and 1.8 and 2.0 vrs are not enabled
/////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// //
// Continuous assignments //
////////////////////////////////////////////////////////////////////////////////// //
// Signal by ByPass for Force Power on, will turn on if the silicon is not populated
assign wFM_CPU1_SKTOCC_LVT3_N = wValidForcePowerOn ? LOW : FM_CPU1_SKTOCC_LVT3_N;
assign wFM_CPU2_SKTOCC_LVT3_N = wValidForcePowerOn ? LOW : FM_CPU2_SKTOCC_LVT3_N;
assign wValidForcePowerOn = FM_FORCE_PWRON_LVC3 && FM_PCH_PRSNT_N && (FM_CPU1_SKTOCC_LVT3_N || wSysOk) && (FM_CPU2_SKTOCC_LVT3_N || wSysOk); //this is only valid if silicon is not populated or STP is present (PROC_ID and PKG_ID are 1's)
assign FM_PLD_HEARTBEAT_LVC3 = RST_PLTRST_N_FF ? 1'b0 : (wDbgMstSt == 4'd0) ? wCLK_20mSCE : wCLK_250mS; // This will indicate if a fault coundtion is detected
GlitchFilter2 GlitchFilter2_inst
(
.iClk(iClk_2M),//% Clock Input
.iRst(wRst_n),//% Asynchronous Reset Input
.iSignal(PWRGD_CPUPWRGD && PWRGD_PCH_PWROK),//% Input Signals
.oFilteredSignals(wPWRGD_CPU_LVC3)//%Glitchless Signal
);
assign PWRGD_CPU1_LVC3 = (!wFM_CPU1_SKTOCC_LVT3_N) ? wPWRGD_CPU_LVC3 : LOW;
assign PWRGD_CPU2_LVC3 = (!wFM_CPU2_SKTOCC_LVT3_N) ? wPWRGD_CPU_LVC3 : LOW;
//% This logic is for enable VCCIO of CPU2 in case the SKTOCC for CPU2 is empty, both VCCIO VR need be ON.
assign FM_PVCCIO_CPU2_EN = (!wFM_CPU2_SKTOCC_LVT3_N) ? wFM_PVCCIO_CPU2_EN : FM_PVCCIO_CPU1_EN ; // VCCIO need be always ON to avoid SI issues.
assign wPWRGD_PVCCIO_CPU1= (wFM_CPU2_SKTOCC_LVT3_N) ? PWRGD_PVCCIO_CPU1_FF : (PWRGD_PVCCIO_CPU1_FF && PWRGD_PVCCIO_CPU2_FF) ; // VCCIO need be always ON to avoid SI issues.
assign RST_PLTRST_B_N = RST_PLTRST_N_FF;
assign RST_CPU1_LVC3_N = (!wFM_CPU1_SKTOCC_LVT3_N) ? RST_PLTRST_N_FF : LOW;
assign RST_CPU2_LVC3_N = (!wFM_CPU2_SKTOCC_LVT3_N) ? RST_PLTRST_N_FF : LOW;
assign FP_LED_FAN_FAULT_PWRSTBY_PLD_N = (wvFanFaultLEDs==8'h00) ? HIGH : LOW;
assign FM_P1V1_EN = (FM_CPU1_INTR_PRSNT && !wValidForcePowerOn) ? FM_PVCCIO_CPU1_EN : FM_P1V8_PCIE_CPU1_EN;
assign wMemPwrgd = (!wFM_CPU2_SKTOCC_LVT3_N) ? (wMemPwrgd_CPU1 && wMemPwrgd_CPU2) : (wMemPwrgd_CPU1);
assign wCpuPwrgd = (!wFM_CPU2_SKTOCC_LVT3_N) ? (wCpuPwrgd_CPU1 && wCpuPwrgd_CPU2) : (wCpuPwrgd_CPU1);
assign wMemPwrFlt = (!wFM_CPU2_SKTOCC_LVT3_N) ? (wMemPwrFlt_CPU1 || wMemPwrFlt_CPU2) : (wMemPwrFlt_CPU1);
assign wCpuPwrFlt = (!wFM_CPU2_SKTOCC_LVT3_N) ? (wCpuPwrFlt_CPU1 || wCpuPwrFlt_CPU2) : (wCpuPwrFlt_CPU1);
assign wRSMRST_N = RST_RSMRST_N;
assign FM_PFR_MUX_OE_CTL_PLD = ( !wRSMRST_Delay_Dedi ) ? LOW : RST_DEDI_BUSY_PLD_N;//Should be 0 until 500us after RSMRST is asserted. After this, follow RST_DEDI signal
assign SPI_PFR_BOOT_CS1_N = SPI_BMC_BOOT_R_CS1_N; //PLD does not run security checks at its own.
assign wByteSeg1_RevMajor = !wCLK1SCE ? FPGA_MAJOR_REV[6:0] : FPGA_REV_Major_DebugPLD[6:0];
assign wByteSeg2_RevMinor = !wCLK1SCE ? FPGA_MINOR_REV[6:0] : FPGA_REV_Minor_DebugPLD[6:0];
assign o1mSCE = w1mSCE;
assign wDebugPLD_Valid = ( (FPGA_REV_Major_DebugPLD <= FPGA_DEBUG_MINIMUM_MAJOR_REV[6:0]) && (FPGA_REV_Minor_DebugPLD <= FPGA_DEBUG_MINIMUM_MINOR_REV[6:0]))? HIGH : LOW;
//////////////////////////////////////////////////////////////////////////////////
// Global Reset
//////////////////////////////////////////////////////////////////////////////////
reset mReset (
.PWRGD_P3V3_AUX(PWRGD_P3V3_AUX),
.iClk_2M(iClk_2M),
.oRst_n(wRst_n)
);
//////////////////////////////////////////////////////////////////////////////////
// Clock generation and CE
//////////////////////////////////////////////////////////////////////////////////
//% Clock divider three - Generates the following synchronous clock enables: 10uS, 50uS, 500uS, 1mS, 20mS and 250mS
ClkDivTree mClkDivTree
(
.iClk ( iClk_2M ),
.iRst ( ~wRst_n ),
.o1uSCE ( w1uSCE ),
.o5uSCE ( w5uSCE ),
.o10uSCE ( w10uSCE ),
.o500uSCE ( w500uSCE ),
.o1mSCE ( w1mSCE ),
.o250mSCE ( w250mSCE ),
.o20mSCE ( w20mSCE ),
.o1SCE ( w1SCE )
);
Toggle mToggle250mSCE // module to Toggle
(
.iRst (~wRst_n), //%Reset Input
.iClk (iClk_2M), //% Clock Input
.iCE (w250mSCE), //% Clock Enable
.oTSignal(wCLK_250mS) //% Output Signal Toggle
);
Toggle mTogglew20mSCE // module to Toggle
(
.iRst (~wRst_n), //%Reset Input
.iClk (iClk_2M), //% Clock Input
.iCE (w20mSCE), //% Clock Enable
.oTSignal(wCLK_20mSCE) //% Output Signal Toggle
);
Toggle mTogglew1SCE // module to Toggle
(
.iRst (~wRst_n), //%Reset Input
.iClk (iClk_2M), //% Clock Input
.iCE (w1SCE), //% Clock Enable
.oTSignal(wCLK1SCE) //% Output Signal Toggle
);
//////////////////////////////////////////////////////////////////////////////////
//Inputs Synchronizer
//////////////////////////////////////////////////////////////////////////////////
//% Active Low
InputsSyncWithDefault #
(
.SIZE ( 5'd20 ),
.DEFAULT_OUT ( 1'b1 )
)mSlpSync0
(
.iClk ( iClk_2M ),
.iRst_n ( wRst_n ),
.ivSync ({
FM_THROTTLE_N,
IRQ_SML1_PMBUS_PLD_ALERT_N,
FM_CPU1_THERMTRIP_LVT3_PLD_N,
FM_CPU2_THERMTRIP_LVT3_PLD_N,
FM_MEM_THERM_EVENT_CPU1_LVT3_N,
FM_MEM_THERM_EVENT_CPU2_LVT3_N,
IRQ_PVDDQ_ABCD_CPU1_VRHOT_LVC3_N,
IRQ_PVDDQ_EFGH_CPU1_VRHOT_LVC3_N,
IRQ_PVDDQ_ABCD_CPU2_VRHOT_LVC3_N,
IRQ_PVDDQ_EFGH_CPU2_VRHOT_LVC3_N,
FM_CPU1_MEMTRIP_N,
FM_CPU2_MEMTRIP_N,
FM_PVCCIN_CPU1_PWR_IN_ALERT_N,
FM_PVCCIN_CPU2_PWR_IN_ALERT_N,
IRQ_PVCCIN_CPU1_VRHOT_LVC3_N,
IRQ_PVCCIN_CPU2_VRHOT_LVC3_N,
FM_BMC_PWRBTN_OUT_N,
FM_BMC_ONCTL_N,
FM_SLP_SUS_RSM_RST_N,
DBP_POWER_BTN_N
}),
.ovSync ({
FM_THROTTLE_N_FF,
IRQ_SML1_PMBUS_PLD_ALERT_N_FF,
FM_CPU1_THERMTRIP_LVT3_PLD_N_FF,
FM_CPU2_THERMTRIP_LVT3_PLD_N_FF,
FM_MEM_THERM_EVENT_CPU1_LVT3_N_FF,
FM_MEM_THERM_EVENT_CPU2_LVT3_N_FF,
IRQ_PVDDQ_ABCD_CPU1_VRHOT_LVC3_N_FF,
IRQ_PVDDQ_EFGH_CPU1_VRHOT_LVC3_N_FF,
IRQ_PVDDQ_ABCD_CPU2_VRHOT_LVC3_N_FF,
IRQ_PVDDQ_EFGH_CPU2_VRHOT_LVC3_N_FF,
FM_CPU1_MEMTRIP_N_FF,
FM_CPU2_MEMTRIP_N_FF,
FM_PVCCIN_CPU1_PWR_IN_ALERT_N_FF,
FM_PVCCIN_CPU2_PWR_IN_ALERT_N_FF,
IRQ_PVCCIN_CPU1_VRHOT_LVC3_N_FF,
IRQ_PVCCIN_CPU2_VRHOT_LVC3_N_FF,
FM_BMC_PWRBTN_OUT_N_FF,
FM_BMC_ONCTL_N_FF,
FM_SLP_SUS_RSM_RST_N_FF,
DBP_POWER_BTN_N_FF
})
);
//% Active Low
InputsSyncWithDefault #
(
.SIZE ( 3'd4 ),
.DEFAULT_OUT ( 1'b0 )
)mSlpSync1
(
.iClk ( iClk_2M ),
.iRst_n ( wRst_n ),
.ivSync ({
RST_PLTRST_N,
FM_SLPS3_N,
FM_SLPS4_N,
FM_PLD_REV_N
}),
.ovSync ({
RST_PLTRST_N_FF,
FM_SLPS3_N_FF,
FM_SLPS4_N_FF,
FM_PLD_REV_N_FF
}) );
//% Active High
InputsSyncWithDefault #
(
.SIZE ( 5'd22 ),
.DEFAULT_OUT ( 1'b0 )
)mSlpSync2
(
.iClk ( iClk_2M ),
.iRst_n ( wRst_n ),
.ivSync ({
PWRGD_P1V1_BMC_AUX,
PWRGD_P1V8_PCH_AUX,
PWRGD_P1V05_PCH_AUX,
PWRGD_PS_PWROK,
PWRGD_P3V3_AUX,
PWRGD_P3V3,
PWRGD_CPU1_PVDDQ_ABCD,
PWRGD_CPU1_PVDDQ_EFGH,
PWRGD_CPU2_PVDDQ_ABCD,
PWRGD_CPU2_PVDDQ_EFGH,
PWRGD_CPUPWRGD,
PWRGD_BIAS_P1V1,
PWRGD_P1V8_PCIE_CPU1,
PWRGD_P1V8_PCIE_CPU2,
PWRGD_PVCCIN_CPU1,
PWRGD_PVCCIN_CPU2,
PWRGD_PVCCIO_CPU1,
PWRGD_PVCCIO_CPU2,
PWRGD_PVCCSA_CPU1,
PWRGD_PVCCSA_CPU2,
PWRGD_VCCANA_PCIE_CPU1,
PWRGD_VCCANA_PCIE_CPU2
}),
.ovSync ({
PWRGD_P1V1_BMC_AUX_FF,
PWRGD_P1V8_PCH_AUX_FF,
PWRGD_P1V05_PCH_AUX_FF,
PWRGD_PS_PWROK_FF,
PWRGD_P3V3_AUX_FF,
PWRGD_P3V3_FF,
PWRGD_CPU1_PVDDQ_ABCD_FF,
PWRGD_CPU1_PVDDQ_EFGH_FF,
PWRGD_CPU2_PVDDQ_ABCD_FF,
PWRGD_CPU2_PVDDQ_EFGH_FF,
PWRGD_CPUPWRGD_FF,
PWRGD_BIAS_P1V1_FF,
PWRGD_P1V8_PCIE_CPU1_FF,
PWRGD_P1V8_PCIE_CPU2_FF,
PWRGD_PVCCIN_CPU1_FF,
PWRGD_PVCCIN_CPU2_FF,
PWRGD_PVCCIO_CPU1_FF,
PWRGD_PVCCIO_CPU2_FF,
PWRGD_PVCCSA_CPU1_FF,
PWRGD_PVCCSA_CPU2_FF,
PWRGD_VCCANA_PCIE_CPU1_FF,
PWRGD_VCCANA_PCIE_CPU2_FF
}) );
//% Active High
InputsSyncWithDefault #
(
.SIZE ( 4'd8 ),
.DEFAULT_OUT ( 1'b0 )
)mSlpSync3
(
.iClk ( iClk_2M ),
.iRst_n ( wRst_n ),
.ivSync ({
FM_ADR_COMPLETE,
FM_PLD_PCH_DATA,
FM_PS_PWROK_DLY_SEL,
FM_DIS_PS_PWROK_DLY,
FM_PMBUS_ALERT_B_EN,
FM_CPU1_FIVR_FAULT_LVT3,
FM_CPU2_FIVR_FAULT_LVT3,
DBP_SYSPWROK
}),
.ovSync ({
FM_ADR_COMPLETE_FF,
FM_PLD_PCH_DATA_FF,
FM_PS_PWROK_DLY_SEL_FF,
FM_DIS_PS_PWROK_DLY_FF,
FM_PMBUS_ALERT_B_EN_FF,
FM_CPU1_FIVR_FAULT_LVT3_FF,
FM_CPU2_FIVR_FAULT_LVT3_FF,
DBP_SYSPWROK_FF
}) );
//////////////////////////////////////////////////////////////////////////////////
// Power Secuence
//////////////////////////////////////////////////////////////////////////////////
Bmc_Seq mBmc_Seq
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
.i1mSCE (w1mSCE),
.iGoOutFltSt (wGoOutFltSt),
//input
.PWRGD_P1V1_BMC_AUX (PWRGD_P1V1_BMC_AUX_FF),
.PWRGD_P3V3_AUX (PWRGD_P3V3_AUX_FF),
.PWRGD_PCH_P1V8 (PWRGD_P1V8_PCH_AUX_FF),
.FM_SLP_SUS_N (FM_SLP_SUS_RSM_RST_N_FF),
.RST_DEDI_BUSY_PLD_N(wRST_DEDI_BUSY_PLD_N),
//output
.FM_BMC_P2V5_AUX_EN (FM_P2V5_BMC_EN),
.RST_SRST_BMC_N (RST_SRST_BMC_PLD_N),
.oBmcPwrgd (wBmcPwrgd),
.oBmcPwrFlt (wBmcPwrFlt)
);
Pch_Seq mPch_Seq
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
.i1mSCE (w1mSCE),
.i1uSCE (w1uSCE),
.iGoOutFltSt (wGoOutFltSt),
//input
.FM_PCH_PRSNT_N (wValidForcePowerOn ? LOW : FM_PCH_PRSNT_N),
.PWRGD_P3V3_AUX (PWRGD_P3V3_AUX_FF),
.FM_SLP_SUS_N (FM_SLP_SUS_RSM_RST_N_FF),
.RST_SRST_BMC_N (RST_SRST_BMC_PLD_N),
.PWRGD_PCH_P1V8_AUX (PWRGD_P1V8_PCH_AUX_FF),
.PWRGD_PCH_P1V05_AUX (PWRGD_P1V05_PCH_AUX_FF),
.RST_DEDI_BUSY_PLD_N (RST_DEDI_BUSY_PLD_N),
//output
.FM_PCH_P1V8_AUX_EN (FM_PCH_P1V8_AUX_EN),
.RST_RSMRST_N (RST_RSMRST_N),
.oPchPwrFltP1V05 (wPchPwrFltP1V05),
.oPchPwrFltP1V8 (wPchPwrFltP1V8),
.oPchPwrgd (wPchPwrgd),
.oPchPwrFlt (wPchPwrFlt)
);
SysCheck mSysCheck
(
.iClk (iClk_2M),
.iRst (wRst_n),
.invCPUSktOcc ({wFM_CPU2_SKTOCC_LVT3_N,wFM_CPU1_SKTOCC_LVT3_N}),
.ivProcIDCPU1 ({FM_CPU1_PROC_ID1,FM_CPU1_PROC_ID0}),
.ivProcIDCPU2 ({FM_CPU2_PROC_ID1,FM_CPU2_PROC_ID0}),
.ivPkgIDCPU1 ({FM_CPU1_PKGID2,FM_CPU1_PKGID1,FM_CPU1_PKGID0}),
.ivPkgIDCPU2 ({FM_CPU2_PKGID2,FM_CPU2_PKGID1,FM_CPU2_PKGID0}),
.ivIntr ({FM_CPU2_INTR_PRSNT,FM_CPU1_INTR_PRSNT}),
.iAuxPwrDone ( PWRGD_P1V05_PCH_AUX_FF ),
.oSysOk ( wSysOk ),
.oCPUMismatch ( wCPUMismatch ),
.oMCPSilicon ( wvMCPSilicon ),
.oSocketRemoved (wSocketRemoved),
.oICX (wICX)
);
//S5 to S0 VR logic
PSU_Seq mPSU_Seq
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
.i1mSCE (w1mSCE),
.iGoOutFltSt (wGoOutFltSt),
//input
.iPsuPwrEn (wPsuPwrEn),
.PWRGD_PS_PWROK (wPWRGD_PS_PWROK_DLY_ADR/*PWRGD_PS_PWROK_FF*/), // need cover ADR logic
//output
.oPsuPwrFlt (wPsuPwrFlt), // output
.oPsuPwrgd (wPsuPwrgd), // output
.PWRGD_PS_PWROK_DLY (wPWRGD_PS_PWROK_DLY), // output include power up 100ms delay
.FM_PS_EN (FM_PS_EN) // output
);
MainVR_Seq mMainVR_Seq
(
.iClk (iClk_2M), // input
.iRst_n (wRst_n), // input
.iGoOutFltSt (wGoOutFltSt),
//input
.iMainVRPwrEn (wMainVRPwrEn),
.PWRGD_PS_PWROK (wPWRGD_PS_PWROK_DLY_ADR),//% PWRGD PS PWROK .
.PWRGD_P3V3 (PWRGD_P3V3_FF),//% Pwrgd from P3V3 VR
// output
.oMainPwrFlt (wMainPwrFlt), //% Fault condition.
.oP3v3PwrFlt (wP3v3PwrFlt), //% Fault P3V3 VR
.oMainVRPwrgd (wMainVRPwrgd), //% Main Vr's Enable
.FM_AUX_SW_EN (FM_AUX_SW_EN), //% 12V Only PSU Control AUX to Main SW
.FM_P5V_EN (FM_P5V_EN) //% P5V and P3V3 main Voltage enable
);
ClockLogic mClockLogic
(
.iClk (iClk_2M), // input
.iRst_n (wRst_n), // input
.iMainVRPwrgd (wMainVRPwrgd),
.iMCP_EN_CLK (wvMCPSilicon), //ICX MCP
.PWRGD_PCH_PWROK (PWRGD_PCH_PWROK),
//output
.FM_PLD_CLKS_OE_N (FM_PLD_CLKS_OE_N),
.FM_CPU_BCLK5_OE_N (FM_CPU_BCLK5_OE_R_N)
);
Mem_Seq mMem_SeqCPU1
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
.i1mSCE (w1mSCE),
.iMemPwrEn (wMemPwrEn), // input
.iGoOutFltSt (wGoOutFltSt), // input
.iEnableTimeOut (LOW),
.PWRGD_P3V3 (PWRGD_P3V3_FF), // input
.PWRGD_VDDQ_ABCD (PWRGD_CPU1_PVDDQ_ABCD_FF), // input
.PWRGD_VDDQ_EFGH (PWRGD_CPU1_PVDDQ_EFGH_FF), // input
.FM_SLPS4_N (FM_SLPS4_N_FF || wValidForcePowerOn),//input
.FM_MEM_VPP_EN (FM_PVPP_CPU1_EN), // output
.oMemPwrFltVDDQ_ABCD (wMemPwrFltVDDQ_CPU1_ABCD),
.oMemPwrFltVDDQ_EFHG (wMemPwrFltVDDQ_CPU1_EFHG),
.oMemPwrgd (wMemPwrgd_CPU1), // output
.oMemPwrFlt (wMemPwrFlt_CPU1), // output
.oDbgMemSt (wDbgMemSt_CPU1) // output [2:0] oDbgMemSt
);
Mem_Seq mMem_SeqCPU2
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
.i1mSCE (w1mSCE),
.iMemPwrEn (wMemPwrEn && (!wFM_CPU2_SKTOCC_LVT3_N)), // input
.iGoOutFltSt (wGoOutFltSt), // input
.iEnableTimeOut (LOW),
.PWRGD_P3V3 (PWRGD_P3V3_FF), // input
.PWRGD_VDDQ_ABCD (PWRGD_CPU2_PVDDQ_ABCD_FF), // input
.PWRGD_VDDQ_EFGH (PWRGD_CPU2_PVDDQ_EFGH_FF), // input
.FM_SLPS4_N (FM_SLPS4_N_FF || wValidForcePowerOn), //input
.FM_MEM_VPP_EN (FM_PVPP_CPU2_EN), // output
.oMemPwrFltVDDQ_ABCD (wMemPwrFltVDDQ_CPU2_ABCD),
.oMemPwrFltVDDQ_EFHG (wMemPwrFltVDDQ_CPU2_EFHG),
.oMemPwrgd (wMemPwrgd_CPU2), // output
.oMemPwrFlt (wMemPwrFlt_CPU2), // output
.oDbgMemSt (wDbgMemSt_CPU2) // output [2:0] oDbgMemSt
);
Cpu_Seq mCpu_Seq_CPU1
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
.i1mSCE (w1mSCE),
.iCpuPwrEn (wCpuPwrEn), // input
.iGoOutFltSt (wGoOutFltSt), // input
.iEnableTimeOut (LOW),
.iICX (wICX),
.FM_INTR_PRSNT (wValidForcePowerOn ? LOW : FM_CPU1_INTR_PRSNT),// input
.PWRGD_PVCCIO (wPWRGD_PVCCIO_CPU1), // input
.PWRGD_P1V8_PCIE (PWRGD_P1V8_PCIE_CPU1_FF && PWRGD_BIAS_P1V1_FF),// input // PWRGD_BIAS_P1V1 to support PCIE retimmer VR
.PWRGD_PVCCANA (PWRGD_VCCANA_PCIE_CPU1_FF),// input
.PWRGD_PVCCIN (PWRGD_PVCCIN_CPU1_FF),// input
.PWRGD_PVCCSA (PWRGD_PVCCSA_CPU1_FF),// input
.FM_PVCCIO_EN (FM_PVCCIO_CPU1_EN), // output
.FM_P1V8_PCIE_EN (FM_P1V8_PCIE_CPU1_EN), // output
.FM_PVCCANA_EN (FM_PVCCANA_CPU1_EN), // output
.FM_PVCCIN_EN (FM_PVCCIN_CPU1_EN), // output
.FM_PVCCSA_EN (FM_PVCCSA_CPU1_EN), // output
.oCpuPwrFltVCCIO (wCpuPwrFltVCCIO_CPU1),
.oCpuPwrFltP1V8_PCIE (wCpuPwrFltP1V8_PCIE_CPU1),
.oCpuPwrFltVCCANA (wCpuPwrFltVCCANA_CPU1),
.oCpuPwrFltVCCIN (wCpuPwrFltVCCIN_CPU1),
.oCpuPwrFltVCCSA (wCpuPwrFltVCCSA_CPU1),
.oCpuPwrgd (wCpuPwrgd_CPU1), // output
.oCpuPwrFlt (wCpuPwrFlt_CPU1), // output
.oDbgCpuSt (wDbgCpuSt_CPU1) // output [3:0] oDbgCpuSt
);
Cpu_Seq mCpu_Seq_CPU2
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
.i1mSCE (w1mSCE),
.iCpuPwrEn (wCpuPwrEn && !wFM_CPU2_SKTOCC_LVT3_N), // input
.iGoOutFltSt (wGoOutFltSt), // input
.iEnableTimeOut (LOW),
.iICX (wICX),
.FM_INTR_PRSNT (wValidForcePowerOn ? LOW : FM_CPU2_INTR_PRSNT),// input
.PWRGD_PVCCIO (PWRGD_PVCCIO_CPU2_FF), // input
.PWRGD_P1V8_PCIE (PWRGD_P1V8_PCIE_CPU2_FF),// input
.PWRGD_PVCCANA (PWRGD_VCCANA_PCIE_CPU2_FF),// input
.PWRGD_PVCCIN (PWRGD_PVCCIN_CPU2_FF),// input
.PWRGD_PVCCSA (PWRGD_PVCCSA_CPU2_FF),// input
.FM_PVCCIO_EN (wFM_PVCCIO_CPU2_EN), // output
.FM_P1V8_PCIE_EN (FM_P1V8_PCIE_CPU2_EN), // output
.FM_PVCCANA_EN (FM_PVCCANA_CPU2_EN), // output
.FM_PVCCIN_EN (FM_PVCCIN_CPU2_EN), // output
.FM_PVCCSA_EN (FM_PVCCSA_CPU2_EN), // output
.oCpuPwrFltVCCIO (wCpuPwrFltVCCIO_CPU2),
.oCpuPwrFltP1V8_PCIE (wCpuPwrFltP1V8_PCIE_CPU2),
.oCpuPwrFltVCCANA (wCpuPwrFltVCCANA_CPU2),
.oCpuPwrFltVCCIN (wCpuPwrFltVCCIN_CPU2),
.oCpuPwrFltVCCSA (wCpuPwrFltVCCSA_CPU2),
.oCpuPwrgd (wCpuPwrgd_CPU2), // output
.oCpuPwrFlt (wCpuPwrFlt_CPU2), // output
.oDbgCpuSt (wDbgCpuSt_CPU2) // output [3:0] oDbgCpuSt
);
PwrgdLogic mPwrgdLogic
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
.i1mSCE (w1mSCE),
.iMemPwrgd (wMemPwrgd), // input
.iCpuPwrgd (wCpuPwrgd), // input
.iBmcPwrgd (wBmcPwrgd), // input
.iPchPwrgd (wPchPwrgd), // input
.FM_SLPS3_N (FM_SLPS3_N_FF || wValidForcePowerOn), // input
.FM_SLPS4_N (FM_SLPS4_N_FF || wValidForcePowerOn), // input
.PWRGD_PS_PWROK_DLY (wPWRGD_PS_PWROK_DLY_ADR),
.DBP_SYSPWROK (DBP_SYSPWROK_FF), //input
.PWRGD_CPUPWRGD (PWRGD_CPUPWRGD),
.PWRGD_DRAMPWRGD_CPU (PWRGD_DRAMPWRGD_CPU), // output
//.PWRGD_CPU_LVC3 (wPWRGD_CPU_LVC3), //output
.PWRGD_PCH_PWROK (PWRGD_PCH_PWROK), // output
.PWRGD_SYS_PWROK (PWRGD_SYS_PWROK) // output
);
ADR mADR
(
.iClk (iClk_2M), // input
.iRst_n (wRst_n), // input
.i10uSCE (w10uSCE),
.PWRGD_PS_PWROK (PWRGD_PS_PWROK_FF), // 100ms delay power-up
.FM_SLPS4_N (FM_SLPS4_N_FF),
.FM_PS_EN (FM_PS_EN),
.PWRGD_CPUPWRGD (PWRGD_CPUPWRGD_FF),
.RST_PLTRST_N (RST_PLTRST_N_FF),
.FM_PS_PWROK_DLY_SEL (FM_PS_PWROK_DLY_SEL_FF),
.FM_DIS_PS_PWROK_DLY (FM_DIS_PS_PWROK_DLY_FF),
.FM_ADR_COMPLETE (FM_ADR_COMPLETE_FF),
.FM_PLD_PCH_DATA (FM_PLD_PCH_DATA_FF), // this logic is not used since need FW support
// output
.FM_ADR_SMI_GPIO_N (FM_ADR_SMI_GPIO_N),
.FM_ADR_TRIGGER_N (FM_ADR_TRIGGER_N),
.FM_ADR_COMPLETE_DLY (FM_ADR_COMPLETE_DLY),
.PWRGD_PS_PWROK_DLY_ADR (wPWRGD_PS_PWROK_DLY_ADR)
);
Mstr_Seq Mstr_Seq_inst
(
.iClk(iClk_2M), // input
.iRst_n(wRst_n), // input
.iForcePwrOn (wValidForcePowerOn),
.iEnableGoOutFltSt (LOW), //disable RP dont need go out fault state.
.iEnableTimeOut (LOW),
.iSysOk (wSysOk), //input
.iDebugPLD_Valid(wDebugPLD_Valid),
.iMemPwrgd(wMemPwrgd), // input
.iMemPwrFlt(wMemPwrFlt), // input
.iCpuPwrgd(wCpuPwrgd), // input
.iCpuPwrFlt(wCpuPwrFlt), // input
.iBmcPwrgd(wBmcPwrgd), // input
.iBmcPwrFlt(wBmcPwrFlt), // input
.iPchPwrgd(wPchPwrgd), // input
.iPchPwrFlt(wPchPwrFlt), // input
.iPSUPwrgd(wPsuPwrgd), // input
.iPsuPwrFlt(wPsuPwrFlt), // input
.iMainVRPwrgd (wMainVRPwrgd), //input
.iMainPwrFlt (wMainPwrFlt), //input
.iSocketRemoved(wSocketRemoved),
.PWRGD_P3V3_AUX(PWRGD_P3V3_AUX_FF), // input
.PWRGD_SYS_PWROK(PWRGD_SYS_PWROK), // input
.PWRGD_CPUPWRGD(PWRGD_CPUPWRGD_FF), // input
.FM_BMC_ONCTL_N(FM_BMC_ONCTL_N_LATCH), // input
.FM_SLPS4_N( (!FM_PCH_PRSNT_N) ? FM_SLPS4_N_FF : wValidForcePowerOn), // input
.FM_SLPS3_N( (!FM_PCH_PRSNT_N) ? FM_SLPS3_N_FF : wValidForcePowerOn), // input
.RST_PLTRST_N( (!FM_PCH_PRSNT_N) ? RST_PLTRST_N_FF : wValidForcePowerOn), // input
.RST_RSMRST_PCH_N(RST_RSMRST_N), // input
.RST_SRST_BMC_N(RST_SRST_BMC_PLD_N), // input
.FM_ADR_TRIGGER_N(FM_ADR_TRIGGER_N),
.oMemPwrEn(wMemPwrEn), // output
.oCpuPwrEn(wCpuPwrEn), // output
.oPsuPwrEn(wPsuPwrEn), // output
.oMainVRPwrEn(wMainVRPwrEn), // output
.oGoOutFltSt(wGoOutFltSt), // output
.oTimeOut(wTimeout), // output
.oFault(wFault), // output
.oPwrEn (wPwrEn), // output
.oDbgMstSt7Seg(wDbgMstSt7Seg), // output [3:0] wDbgMstSt7Seg
.oDbgMstSt(wDbgMstSt) // output [3:0] oDbgMstSt
);
//////////////////////////////////////////////////////////////////////////////////
//Memhot
//////////////////////////////////////////////////////////////////////////////////
Memhot mMemhot_CPU1
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
// input
.PWRGD_SYS_PWROK (PWRGD_SYS_PWROK),
.IRQ_PVDDQ_ABCD_VRHOT_LVC3_N (IRQ_PVDDQ_ABCD_CPU1_VRHOT_LVC3_N_FF),
.IRQ_PVDDQ_EFGH_VRHOT_LVC3_N (IRQ_PVDDQ_EFGH_CPU1_VRHOT_LVC3_N_FF),
.FM_SYS_THROTTLE_LVC3 (FM_SYS_THROTTLE_LVC3_PLD),
.FM_SKTOCC_LVT3_N (wFM_CPU1_SKTOCC_LVT3_N),
// output
.FM_MEMHOT_IN (FM_CPU1_MEMHOT_IN)//% The logic is inverted using a FET
);
Memhot mMemhot_CPU2
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
// input
.PWRGD_SYS_PWROK (PWRGD_SYS_PWROK),
.IRQ_PVDDQ_ABCD_VRHOT_LVC3_N (IRQ_PVDDQ_ABCD_CPU2_VRHOT_LVC3_N_FF),
.IRQ_PVDDQ_EFGH_VRHOT_LVC3_N (IRQ_PVDDQ_EFGH_CPU2_VRHOT_LVC3_N_FF),
.FM_SYS_THROTTLE_LVC3 (FM_SYS_THROTTLE_LVC3_PLD),
.FM_SKTOCC_LVT3_N (wFM_CPU2_SKTOCC_LVT3_N),
//output
.FM_MEMHOT_IN (FM_CPU2_MEMHOT_IN)//% The logic is inverted using a FET
);
//////////////////////////////////////////////////////////////////////////////////
//Prochot
//////////////////////////////////////////////////////////////////////////////////
Prochot mProchot_CPU1
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
.PWRGD_SYS_PWROK (PWRGD_SYS_PWROK),
.FM_PVCCIN_PWR_IN_ALERT_N (FM_PVCCIN_CPU1_PWR_IN_ALERT_N_FF),
.IRQ_PVCCIN_VRHOT_LVC3_N (IRQ_PVCCIN_CPU1_VRHOT_LVC3_N_FF),
.FM_SYS_THROTTLE_LVC3 (FM_SYS_THROTTLE_LVC3_PLD),
.FM_SKTOCC_LVT3_N (wFM_CPU1_SKTOCC_LVT3_N),
//output
.FM_PROCHOT_LVC3_N (FM_CPU1_PROCHOT_LVC3_N)
);
Prochot mProchot_CPU2
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
.PWRGD_SYS_PWROK (PWRGD_SYS_PWROK),
.FM_PVCCIN_PWR_IN_ALERT_N (FM_PVCCIN_CPU2_PWR_IN_ALERT_N_FF),
.IRQ_PVCCIN_VRHOT_LVC3_N (IRQ_PVCCIN_CPU2_VRHOT_LVC3_N_FF),
.FM_SYS_THROTTLE_LVC3 (FM_SYS_THROTTLE_LVC3_PLD),
.FM_SKTOCC_LVT3_N (wFM_CPU2_SKTOCC_LVT3_N),
//output
.FM_PROCHOT_LVC3_N (FM_CPU2_PROCHOT_LVC3_N)
);
//////////////////////////////////////////////////////////////////////////////////
//SmaRT
//////////////////////////////////////////////////////////////////////////////////
SmaRT mSmaRT
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
.IRQ_SML1_PMBUS_PLD_ALERT_N(IRQ_SML1_PMBUS_PLD_ALERT_N_FF),
.FM_PMBUS_ALERT_B_EN (FM_PMBUS_ALERT_B_EN_FF),
.FM_THROTTLE_N (FM_THROTTLE_N),
.PWRGD_SYS_PWROK (PWRGD_SYS_PWROK),
//output
.FM_SYS_THROTTLE_LVC3 (FM_SYS_THROTTLE_LVC3_PLD)//% The logic is inverted using a FET
);
//////////////////////////////////////////////////////////////////////////////////
//THERMTRIP DLY
//////////////////////////////////////////////////////////////////////////////////
//% CPUPWRGD 1.5ms delay
SignalValidationDelay#
(
.VALUE ( 1'b1 ),
.TOTAL_BITS ( 3'd4 ),
.POL ( 1'b1 )
)mThermTripDly
(
.iClk ( iClk_2M ),
.iRst ( ~wRst_n ),
.iCE ( w500uSCE ),
.ivMaxCnt ( 4'd3 ), // 500us * 3 = 1.5ms this because thermtrip condition is only valid after 1.5 ms
.iStart ( PWRGD_CPUPWRGD_FF ),
.oDone ( wCPUPwrGd_Dly )
);
thermtrip_dly mthermtrip_dly
(
.iClk_2M (iClk_2M),
.iRst_n (wRst_n),
.iCpuPwrgdDly (wCPUPwrGd_Dly),
.FM_CPU1_THERMTRIP_LVT3_N ( !wCPUPwrGd_Dly ? HIGH : FM_CPU1_THERMTRIP_LVT3_PLD_N_FF),
.FM_CPU2_THERMTRIP_LVT3_N ( !wCPUPwrGd_Dly ? HIGH : FM_CPU2_THERMTRIP_LVT3_PLD_N_FF),
.FM_MEM_THERM_EVENT_CPU1_LVT3_N ( !wMemPwrgd_CPU1 ? HIGH : FM_MEM_THERM_EVENT_CPU1_LVT3_N_FF),
.FM_MEM_THERM_EVENT_CPU2_LVT3_N ( !wMemPwrgd_CPU2 ? HIGH : FM_MEM_THERM_EVENT_CPU2_LVT3_N_FF),
.FM_CPU2_SKTOCC_LVT3_N (wFM_CPU2_SKTOCC_LVT3_N),
//output
.FM_THERMTRIP_DLY (FM_THERMTRIP_DLY)
);
//////////////////////////////////////////////////////////////////////////////////
// LED Logic control
//////////////////////////////////////////////////////////////////////////////////
led_control mled_control(
.iClk (iClk_2M),
.iRst_n (wRst_n),
.iPostCodeLed (wvPOSTCodeLEDs),
.iDimmFltLed_CPU1_1 (wvP1DIMMLEDs[7:0]),
.iDimmFltLed_CPU1_2 (wvP1DIMMLEDs[15:8]),
.iDimmFltLed_CPU2_1 (wvP2DIMMLEDs[7:0]),
.iDimmFltLed_CPU2_2 (wvP2DIMMLEDs[15:8]),
.iFanFltLed (wvFanFaultLEDs),
.iShowDebug7seg ( (!FM_PCH_PRSNT_N ? (!RST_PLTRST_N_FF) : 1'b1) || wValidForcePowerOn), // 7 Segment Support
.iShowDebugPostCode ( (!FM_PCH_PRSNT_N ? (!RST_PLTRST_N_FF) : 1'b1) || wValidForcePowerOn),
.iDebugPostcode (wvPOSTCodeLEDMux), //change wPostcodeLedMux to wDbgMstSt7Seg for PC
.iShowMainVer_N ( wCLK1SCE ),
.iShowPLDVersion ( FM_PLD_REV_N_FF ),
.iByteSeg1_RevMajor ( wByteSeg1_RevMajor ),
.iByteSeg2_RevMinor ( wByteSeg2_RevMinor ),
.iByteSeg1 ( wFault ? {3'b000,wFaultStage} : 7'd16 ), // 7 Segment Support (Left Display, value 16 is hypen)
.iByteSeg2 ( {3'b000,wDbgMstSt7Seg} ), // 7 Segment Support (Right Display)
.oLED_CONTROL (LED_CONTROL),
.oFanFlt_Sel_N (FM_FAN_FAULT_LED_SEL_N),
.oPostCode_Led_Sel (FM_POSTLED_SEL),
.oDimmFlt_CPU1_1_Led_Sel(FM_CPU1_DIMM_CH1_4_FAULT_LED_SEL),
.oDimmFlt_CPU1_2_Led_Sel(FM_CPU1_DIMM_CH5_8_FAULT_LED_SEL),
.oDimmFlt_CPU2_1_Led_Sel(FM_CPU2_DIMM_CH1_4_FAULT_LED_SEL),
.oDimmFlt_CPU2_2_Led_Sel(FM_CPU2_DIMM_CH5_8_FAULT_LED_SEL),
.oPost7Seg1_Sel_N (FM_POST_7SEG1_SEL_N), // 7 Segment Support
.oPost7Seg2_Sel_N (FM_POST_7SEG2_SEL_N) // 7 Segment Support
);
//////////////////////////////////////////////////////////////////////////////////
// Perst Logic
//////////////////////////////////////////////////////////////////////////////////
Rst_Perst #
(
.NUM_PCIE_SIGNALS (3) //% Number of PCIE resets
) mRst_Perst
(
.iClk (iClk_2M), //System Clock - 2MHz
.iRst_n (wRst_n), //System asynchronous reset
//PERST Table control
.ivOverride_Enable({~FM_RST_PERST_BIT2,~FM_RST_PERST_BIT1,~FM_RST_PERST_BIT0}),
.ivOvrValues ({PWRGD_CPUPWRGD_FF,PWRGD_CPUPWRGD_FF,PWRGD_CPUPWRGD_FF}),
.ivDefaultValues ({RST_PLTRST_N_FF,RST_PLTRST_N_FF,RST_PLTRST_N_FF}),
//Output PCIE Resets for PERST Table
.ovRstPCIePERst_n ({RST_PCIE_PERST2_N,RST_PCIE_PERST1_N,RST_PCIE_PERST0_N})
);
//////////////////////////////////////////////////////////////////////////////////
///CATERR
//////////////////////////////////////////////////////////////////////////////////
caterr mCaterr
(
.iClk_50M (iClk_50M),
.iCpuPwrgdDly (wCPUPwrGd_Dly),
.RST_PLTRST_N (RST_PLTRST_N_FF), //in This is used as the RESET
.FM_CPU_CATERR_PLD_LVT3_N (FM_CPU_CATERR_PLD_LVT3_N), //in
.FM_CPU_CATERR_DLY_LVT3_N (FM_CPU_CATERR_DLY_LVT3_N) //out
);
//////////////////////////////////////////////////////////////////////////////////
//eSPI control
//////////////////////////////////////////////////////////////////////////////////
eSPI_Ctl meSPI_Ctl
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
.i1uSCE (w1uSCE),
.RST_SRST_BMC_N (RST_SRST_BMC_PLD_N),
.iRsmRst_N (RST_RSMRST_N),
.oEspiMuxPCHSel (FM_PCH_ESPI_MUX_SEL)
);
//////////////////////////////////////////////////////////////////////////////////
//BMC Workaround
//////////////////////////////////////////////////////////////////////////////////
onctl_fix mOnctl_fix
(
.iClk_2M(iClk_2M),
.iRst_n(wRst_n),
.FM_BMC_ONCTL_N(FM_BMC_ONCTL_N_FF),
.FM_SLPS3_N(FM_SLPS3_N_FF ),
.FM_SLPS4_N(FM_SLPS4_N_FF),
//.FM_BMC_PWRBTN_OUT_N(FM_BMC_PWRBTN_OUT_N_FF),
//output
.FM_BMC_ONCTL_N_LATCH(FM_BMC_ONCTL_N_LATCH)
);
assign FP_BMC_PWR_BTN_CO_N = DBP_POWER_BTN_N;
//////////////////////////////////////////////////////////////////////////////////
// BMC Serial GPIO Logic
//////////////////////////////////////////////////////////////////////////////////
//% BMC Serial GPIO expander: Tx - {CPUs info and CPLDs version} Rx - {Port80 decoded Data}
GSX #
(
.TOTAL_INPUT_MODULES ( 4'd10 ),
.TOTAL_OUTPUT_MODULES ( 4'd10 )
)mGSX
(
.iGSXDataIn ( SGPIO_BMC_DOUT ),
.iGSXClk ( SGPIO_BMC_CLK ),
.inGSXLoad ( SGPIO_BMC_LD_N ),
.inGSXReset ( RST_PLTRST_N_FF || wValidForcePowerOn ),
.ivTxData ({
// First Byte
FM_CPU1_PROC_ID1, // SGPIO 7
FM_CPU1_PROC_ID0, // SGPIO 6
IRQ_PVDDQ_EFGH_CPU1_VRHOT_LVC3_N_FF, // SGPIO 5
IRQ_PVDDQ_ABCD_CPU1_VRHOT_LVC3_N_FF, // SGPIO 4
(wCPUPwrGd_Dly && !wFM_CPU1_SKTOCC_LVT3_N) ? ~FM_CPU1_FIVR_FAULT_LVT3_FF :HIGH, // SGPIO 3
IRQ_PVCCIN_CPU1_VRHOT_LVC3_N_FF, // SGPIO 2
wFM_CPU1_THERMTRIP_N, // SGPIO 1
wFM_CPU1_SKTOCC_LVT3_N, // SGPIO 0
// Second Byte
IRQ_PVDDQ_EFGH_CPU2_VRHOT_LVC3_N_FF, // SGPIO 15
IRQ_PVDDQ_ABCD_CPU2_VRHOT_LVC3_N_FF, // SGPIO 14
(wCPUPwrGd_Dly && !wFM_CPU2_SKTOCC_LVT3_N)? ~FM_CPU2_FIVR_FAULT_LVT3_FF :HIGH, // SGPIO 13
IRQ_PVCCIN_CPU2_VRHOT_LVC3_N_FF, // SGPIO 12
wFM_CPU2_THERMTRIP_N, // SGPIO 11
wFM_CPU2_SKTOCC_LVT3_N, // SGPIO 10
(!wFM_CPU1_SKTOCC_LVT3_N) ? FM_MEM_THERM_EVENT_CPU1_LVT3_N_FF : HIGH, // SGPIO 9
wCPUMismatch, // SGPIO 8
// Third Byte
4'b1111, // SGPIO [23:20] - CPU3 info
(!wFM_CPU2_SKTOCC_LVT3_N) ? ~FM_MEM_THERM_EVENT_CPU2_LVT3_N_FF : HIGH, // SGPIO 19
wCPUMismatch, // SGPIO 18
FM_CPU2_PROC_ID1, // SGPIO 17
FM_CPU2_PROC_ID0, // SGPIO 16
// Fourth Byte
8'b11101111, // SGPIO [31:24] - CPU3 and CPU4 info
// Fifth Byte
8'b10111111, // SGPIO [39:32] - CPU4 info
// Sixth Byte
FPGA_MINOR_REV, // SGPIO [47:40] - Revision code
// Seventh Byte
FPGA_MAJOR_REV,// SGPIO [55:48] - PLD Rev
// Eighth Byte
~wPchPwrFlt , // SGPIO63
1'b1, // SGPIO62
1'b1, // SGPIO61
~wPsuPwrFlt,// SGPIO60
~wP3v3PwrFlt,// SGPIO59
~wCpuPwrFlt_CPU1 && ~wCpuPwrFlt_CPU2, // SGPIO58
~wMemPwrFlt_CPU1 && ~wMemPwrFlt_CPU2, // SGPIO57
1'b0, // SGPIO56
// Nineth Byte
(wCPUPwrGd_Dly && !wFM_CPU2_SKTOCC_LVT3_N) ? FM_CPU2_MEMTRIP_N_FF :HIGH, // SGPIO71
FM_CPU2_PKGID2,// SGPIO70
FM_CPU2_PKGID1,// SGPIO69
FM_CPU2_PKGID0,// SGPIO68
(wCPUPwrGd_Dly && !wFM_CPU1_SKTOCC_LVT3_N) ? FM_CPU1_MEMTRIP_N_FF :HIGH, // SGPIO67
FM_CPU1_PKGID2,// SGPIO66
FM_CPU1_PKGID1,// SGPIO65
FM_CPU1_PKGID0,// SGPIO64
// Tenth Byte
8'hff /// SGPIO [79-72] PKG CPU3 and CPU4 info
}),
.oGSXDataOut ( SGPIO_BMC_DIN ),
.ovRxData ({
//Pin definition pending
wvP4DIMMLEDs[15:12], // 4 76 - 79
wvP3DIMMLEDs[15:12], // 4 72 - 75
wvP2DIMMLEDs[15:12], // 4 68 - 71
wvP1DIMMLEDs[15:12], // 4 64 - 67
wvP4DIMMLEDs[11:0], // 12 52 - 63
wvP3DIMMLEDs[11:0], // 12 40 - 51
wvP2DIMMLEDs[11:0], // 12 28 - 39
wvFanFaultLEDs, // 8 20 - 27
wvP1DIMMLEDs[11:0], // 12 8 - 19
wvPOSTCodeLEDs // 8 0-7
// First Byte
})
);
//////////////////////////////////////////////////////////////////////////////////
// THERMTRIP Latcher
//////////////////////////////////////////////////////////////////////////////////
SingleLatcher#
(
.EDGELATCH (1'b0)
) mLatchThermTrip_N_CPU1
(
.iClk (iClk_2M ),
.iRst_n (wRst_n ),
.iEnableLatch (wCPUPwrGd_Dly),//Enable latch /
.iSignalLatch (( wFM_CPU1_SKTOCC_LVT3_N | ~wCPUPwrGd_Dly ) ? 1'b1 : (FM_CPU1_THERMTRIP_LVT3_PLD_N_FF)),
.oSignalLatched (wFM_CPU1_THERMTRIP_N)
);
SingleLatcher#
(
.EDGELATCH (1'b0)
) mLatchThermTrip_N_CPU2
(
.iClk (iClk_2M ),
.iRst_n (wRst_n ),
.iEnableLatch (wCPUPwrGd_Dly),//Enable latch /
.iSignalLatch (( wFM_CPU2_SKTOCC_LVT3_N | ~wCPUPwrGd_Dly ) ? 1'b1 : (FM_CPU2_THERMTRIP_LVT3_PLD_N_FF)),
.oSignalLatched (wFM_CPU2_THERMTRIP_N)
);
//////////////////////////////////////////////////////////////////////////////////
// Led Mux Logic
//////////////////////////////////////////////////////////////////////////////////
assign wInputLEDMux = { //Signals To measure
8'hFF, //7:0 - register F
//ST_PS_OFF
LOW, //7 - register E
LOW, //6 - register E
LOW, //5 - register E
LOW, //4 - register E
LOW, //3 - register E
LOW, //2 - register E
LOW, //1 - register E
FM_SLPS3_N_FF, //0 - register E
//ST_MAIN_OFF
LOW, //7 - register D
LOW, //6 - register D
LOW, //5 - register D
LOW, //4 - register D
FM_AUX_SW_EN, //3 - register D
PWRGD_PS_PWROK_FF, //2 - register D
PWRGD_P3V3_FF, //1 - register D
FM_P5V_EN, //0 - register D
//ST_SHUTDOWN
wDbgCpuSt_CPU2, //4:7 register C
wDbgCpuSt_CPU1, //0:3 register C
//ST_DONE
LOW, //7 - register B
LOW, //6 - register B
LOW, //5 - register B
LOW, //4 - register B
LOW, //3 - register B
FM_BMC_ONCTL_N_FF, //2 - register B
FM_SLPS3_N_FF, //1 - register B
RST_PLTRST_N_FF, //0 - register B
//ST_RESET
LOW, //7 - register A
LOW, //6 - register A
LOW, //5 - register A
LOW, //4 - register A
LOW, //3 - register A
LOW, //2 - register A
LOW, //1 - register A
RST_PLTRST_N_FF, //0 - register A
//ST_CPUPWRGD
LOW, //7 - register 9
LOW, //6 - register 9
LOW, //5 - register 9
LOW, //4 - register 9
LOW, //3 - register 9
LOW, //2 - register 9
LOW, //1 - register 9
PWRGD_CPUPWRGD_FF, //0 - register 9
//ST_SYSPWROK
LOW, //7 - register 8
wMemPwrgd, //6 - register 8
wCpuPwrgd, //5 - register 8
wBmcPwrgd, //4 - register 8
wPchPwrgd, //3 - register 8
FM_SLPS3_N_FF, //2 - register 8
wPWRGD_PS_PWROK_DLY_ADR, //1 - register 8
DBP_SYSPWROK_FF, //0 - register 8
//ST_CPU
wDbgCpuSt_CPU2, //4:7 register 7
wDbgCpuSt_CPU1, //0:3 register 7
//ST_MEM
LOW, //7 - register 6
wMemPwrEn, //6 - register 6
PWRGD_CPU2_PVDDQ_EFGH_FF, //5 - register 6
PWRGD_CPU2_PVDDQ_ABCD_FF, //4 - register 6
PWRGD_CPU1_PVDDQ_EFGH_FF, //3 - register 6
PWRGD_CPU1_PVDDQ_ABCD_FF, //2 - register 6
FM_PVPP_CPU2_EN, //1 - register 6
FM_PVPP_CPU1_EN, //0 - register 6
//ST_MAIN
LOW, //7 - register 5
LOW, //6 - register 5
LOW, //5 - register 5
LOW, //4 - register 5
FM_AUX_SW_EN, //3 - register 5
PWRGD_PS_PWROK_FF, //2 - register 5
PWRGD_P3V3_FF, //1 - register 5
FM_P5V_EN, //0 - register 5
//ST_PS
LOW, //7 - register 4
LOW, //6 - register 4
LOW, //5 - register 4
LOW, //4 - register 4
LOW, //3 - register 4
LOW, //2 - register 4
PWRGD_PS_PWROK_FF, //1 - register 4
FM_PS_EN, //0 - register 4
//ST_S3
FM_PVPP_CPU2_EN, //7 - register 3
FM_PVPP_CPU1_EN, //6 - register 3
PWRGD_CPU2_PVDDQ_EFGH_FF, //5 - register 3
PWRGD_CPU2_PVDDQ_ABCD_FF, //4 - register 3
PWRGD_CPU1_PVDDQ_EFGH_FF, //3 - register 3
PWRGD_CPU1_PVDDQ_ABCD_FF, //2 - register 3
FM_SLPS4_N_FF, //1 - register 3
FM_SLPS3_N_FF, //0 - register 3
//ST_OFF
FM_CPU2_INTR_PRSNT, //7 - register 2
FM_CPU1_INTR_PRSNT, //6 - register 2
FM_CPU2_SKTOCC_LVT3_N, //5 - register 2
FM_CPU1_SKTOCC_LVT3_N, //4 - register 2
wCPUMismatch, //3 - register 2
wSysOk, //2 - register 2
FM_SLPS3_N_FF, //1 - register 2
FM_BMC_ONCTL_N_FF, //0 - register 2
//ST_STBY
LOW, //7 - register 1
FM_PCH_PRSNT_N, //6 - register 1
RST_RSMRST_N, //5 - register 1
RST_SRST_BMC_PLD_N, //4 - register 1
PWRGD_P1V1_BMC_AUX_FF, //3 - register 1
PWRGD_P1V05_PCH_AUX_FF, //2 - register 1
PWRGD_P1V8_PCH_AUX_FF, //1 - register 1
PWRGD_P3V3_AUX_FF, //0 - register 1
//ST_FAULT
wFaultState //7-0 - register 0
};
Mux128BitsTo8 mLEDMuxy8
(
.iSel (wDbgMstSt), //%Selector this will select what group you need measure.
.ivSignals (wInputLEDMux),
.ovSignals (wvPOSTCodeLEDMux)
);
//////////////////////////////////////////////////////////////////////////////////
//Fault detection
//////////////////////////////////////////////////////////////////////////////////
assign wMonitorFaultState= {
236'd0,
wCpuPwrFltVCCIO_CPU2, //18
wCpuPwrFltP1V8_PCIE_CPU2, //17
wCpuPwrFltVCCANA_CPU2, //16
wCpuPwrFltVCCIN_CPU2, //15
wCpuPwrFltVCCSA_CPU2, //14
wCpuPwrFltVCCIO_CPU1, //13
wCpuPwrFltP1V8_PCIE_CPU1, //12
wCpuPwrFltVCCANA_CPU1, //11
wCpuPwrFltVCCIN_CPU1, //10
wCpuPwrFltVCCSA_CPU1, //9
wMemPwrFltVDDQ_CPU2_EFHG, //8
wMemPwrFltVDDQ_CPU2_ABCD, //7
wMemPwrFltVDDQ_CPU1_EFHG, //6
wMemPwrFltVDDQ_CPU1_ABCD, //5
wMainPwrFlt, //4
wPsuPwrFlt, //3
wPchPwrFltP1V05, //2
wPchPwrFltP1V8, //1
wBmcPwrFlt //0
};
Fault2Code8bits mFault2Code8bits
(
.iClk (iClk_2M),
.iRst_n (wRst_n),
.iFaultstate(wMonitorFaultState),
.i250mSCE (w250mSCE),
.iMaxNumberValue(8'd18),
.oFaultStage(wFaultStage),
.oFaultState(wFaultState)
);
//////////////////////////////////////////////////////////////////////////////////
//SMBus registers module
//////////////////////////////////////////////////////////////////////////////////
wire wFilteredSDA, wFilteredSCL;
wire [9:0] wvEvAddr;
wire [31:0] wvEvData;
wire wEvWE;
wire [7:0] wSmbSelLai;
//% SDA Filter
GlitchFilter #
(
.TOTAL_STAGES( 2'd3 )
) mSDAGlitchFilter
(
.iClk ( iClk_2M ),
.iRst ( !wRst_n ),
.iCE ( 1'b1 ),
.iSignal ( SMB_PLD_SDA ),
.oGlitchlessSignal ( wFilteredSDA )
);
//
//% SCL Filter
//
GlitchFilter #
(
.TOTAL_STAGES( 2'd3 )
) mSCLGlitchFilter
(
.iClk ( iClk_2M ),
.iRst ( !wRst_n ),
.iCE ( 1'b1 ),
.iSignal ( SMB_PLD_SCL ),
.oGlitchlessSignal ( wFilteredSCL )
);
//% SMBus registers module
IICRegs#
(
.MODULE_ADDRESS ( 7'h17 )
)mIICRegs
(
.iClk ( iClk_2M ),
.iRst ( !wRst_n),
.iSCL ( wFilteredSCL ),
.iSDA ( wFilteredSDA ),
.onSDAOE ( onSDAOE ),
.ivSMBusReg00 ({
4'b0000, //
wDbgMstSt7Seg // - Current power sequencer state
}),
.ivSMBusReg01 ({
wCPUMismatch, //
FM\_CPU1\_INTR\_PRSNT, //
FM\_CPU1\_SKTOCC\_LVT3\_N, //
FM\_CPU1\_PROC\_ID1, //
FM\_CPU1\_PROC\_ID0, //
FM\_CPU1\_PKGID2, //
FM\_CPU1\_PKGID1, //
FM\_CPU1\_PKGID0 //
}),
.ivSMBusReg02 ({
wSysOk, //
FM\_CPU2\_INTR\_PRSNT, //
FM\_CPU2\_SKTOCC\_LVT3\_N, //
FM\_CPU2\_PROC\_ID1, //
FM\_CPU2\_PROC\_ID0, //
FM\_CPU2\_PKGID2, //
FM\_CPU2\_PKGID1, //
FM\_CPU2\_PKGID0 //
}),
.ivSMBusReg03 ({
1'b1, //
FM\_BMC\_ONCTL\_N\_LATCH, //
PWRGD\_P3V3\_AUX\_FF, //
PWRGD\_P1V1\_BMC\_AUX\_FF, //
FM\_P2V5\_BMC\_EN, //
RST\_SRST\_BMC\_PLD\_N, //
wBmcPwrgd, //
wBmcPwrFlt //
}),
.ivSMBusReg04 ({
wValidForcePowerOn, //
FM\_PCH\_PRSNT\_N, //
FM\_SLP\_SUS\_RSM\_RST\_N\_FF, //
RST\_RSMRST\_N, //
FM\_SLPS4\_N\_FF, //
FM\_SLPS3\_N\_FF, //
PWRGD\_PCH\_PWROK, //
PWRGD\_SYS\_PWROK //
}),
.ivSMBusReg05 ({
wGoOutFltSt, //
PWRGD\_P1V8\_PCH\_AUX\_FF, //
PWRGD\_P1V05\_PCH\_AUX\_FF, //
FM\_PCH\_P1V8\_AUX\_EN, //
wPchPwrFltP1V05, //
wPchPwrFltP1V8, //
wPchPwrgd, //
wPchPwrFlt //
}),
.ivSMBusReg06 ({
wPwrEn, //
FM\_PS\_EN, //
PWRGD\_PS\_PWROK\_FF, //
wPsuPwrFlt, //
FM\_AUX\_SW\_EN, //
FM\_P5V\_EN, //
PWRGD\_P3V3\_FF, //
wMainPwrFlt //
}),
.ivSMBusReg07 ({
FM\_PLD\_CLKS\_OE\_N, //
1'b1, //
PWRGD\_CPU1\_PVDDQ\_ABCD\_FF, //
PWRGD\_CPU1\_PVDDQ\_EFGH\_FF, //
PWRGD\_CPU2\_PVDDQ\_ABCD\_FF, //
PWRGD\_CPU2\_PVDDQ\_EFGH\_FF, //
FM\_PVPP\_CPU1\_EN, //
FM\_PVPP\_CPU2\_EN //
}),
.ivSMBusReg08 ({
wDbgCpuSt\_CPU1, //
wDbgCpuSt\_CPU2 //
}),
.ivSMBusReg09 ( wvPOSTCodeLEDs ), // - BIOS POST Codes
.ivSMBusReg0A ( FPGA\_MAJOR\_REV ), // - CPLD1 Version
.ivSMBusReg0B ({
FM\_PS\_PWROK\_DLY\_SEL\_FF, //
FM\_DIS\_PS\_PWROK\_DLY\_FF, //
FM\_ADR\_COMPLETE\_FF, //
FM\_PLD\_PCH\_DATA, //
FM\_ADR\_SMI\_GPIO\_N, //
FM\_ADR\_TRIGGER\_N, //
FM\_ADR\_COMPLETE\_DLY, //
wPsuPwrFlt //
}),
.ivSMBusReg0C ({
RST\_PLTRST\_N\_FF, //
FM\_CPU1\_MEMHOT\_IN, //
FM\_CPU2\_MEMHOT\_IN, //
FM\_CPU1\_PROCHOT\_LVC3\_N, //
FM\_CPU2\_PROCHOT\_LVC3\_N, //
FM\_SYS\_THROTTLE\_LVC3\_PLD, //
FM\_THERMTRIP\_DLY, //
wvEvAddr[9] // - Event Logger Events Count MSB
} ),
.ivSMBusReg0D ( wvEvAddr[8:1] ), // - Event Logger Events Count LSB
.ivSMBusReg0E (FPGA\_MINOR\_REV ), // - PLD Version Test number
.ivSMBusReg0F ({
wFM\_CPU1\_THERMTRIP\_N, //
wFM\_CPU2\_THERMTRIP\_N, //
FM\_CPU1\_THERMTRIP\_LVT3\_PLD\_N\_FF, //
FM\_CPU2\_THERMTRIP\_LVT3\_PLD\_N\_FF, //
FM\_MEM\_THERM\_EVENT\_CPU1\_LVT3\_N\_FF, //
FM\_MEM\_THERM\_EVENT\_CPU2\_LVT3\_N\_FF, //
IRQ\_SML1\_PMBUS\_PLD\_ALERT\_N\_FF, //
FM\_PMBUS\_ALERT\_B\_EN\_FF //
}),
.ovSMBusReg30 ({
wSmbSelLai //
}),
//
//
.ivEventsAddress ( wvEvAddr ),
.iEventsWE ( wEvWE ),
.ivEventsInData ( wvEvData ),
.iEvRst ( !wRst\_n )
);
//////////////////////////////////////////////////////////////////////////////////
// Event Logger
//////////////////////////////////////////////////////////////////////////////////
EventLogger mEventLogger
(
.iClk ( iClk\_2M ),
.iRst ( !wRst\_n ),
.iSample ( w1uSCE ),
.ivInputs ({
RST\_PLTRST\_N\_FF, //31
PWRGD\_CPUPWRGD\_FF, //30
PWRGD\_SYS\_PWROK, //29
PWRGD\_PCH\_PWROK, //28
PWRGD\_PVCCSA\_CPU2\_FF, //27
PWRGD\_PVCCIN\_CPU2\_FF, //26
PWRGD\_VCCANA\_PCIE\_CPU2\_FF, //25
PWRGD\_P1V8\_PCIE\_CPU2\_FF, //24
PWRGD\_PVCCIO\_CPU2\_FF, //23
PWRGD\_PVCCSA\_CPU1\_FF, //22
PWRGD\_PVCCIN\_CPU1\_FF, //21
PWRGD\_VCCANA\_PCIE\_CPU1\_FF, //20
PWRGD\_BIAS\_P1V1\_FF, //19
PWRGD\_P1V8\_PCIE\_CPU1\_FF, //18
wPWRGD\_PVCCIO\_CPU1, //17
PWRGD\_CPU2\_PVDDQ\_ABCD\_FF, //16
PWRGD\_CPU1\_PVDDQ\_ABCD\_FF, //15
FM\_PLD\_CLKS\_OE\_N, //14
FM\_AUX\_SW\_EN, //13
PWRGD\_P3V3\_FF, //12
PWRGD\_PS\_PWROK\_FF, //11
FM\_BMC\_ONCTL\_N\_LATCH, //10
FM\_SLPS3\_N\_FF, //9
FM\_SLPS4\_N\_FF, //8
//------------------
RST\_RSMRST\_N, //-7
RST\_SRST\_BMC\_PLD\_N, //-6
PWRGD\_P1V05\_PCH\_AUX\_FF, //-5
PWRGD\_P1V1\_BMC\_AUX\_FF, //-4
PWRGD\_P1V8\_PCH\_AUX\_FF, //3
PWRGD\_P3V3\_AUX\_FF, // -2
FM\_SLP\_SUS\_RSM\_RST\_N\_FF, // - 1
wSysOk // - 0
}),
.ovAddress ( wvEvAddr ),
.ovData ( wvEvData ),
.oWE ( wEvWE )
);
wire wRST\_DEDI\_BUSY\_PLD\_N;
SignalValidationDelay#
(
.VALUE ( 1'b1 ),
.TOTAL\_BITS ( 4'd6 ),
.POL ( 1'b1 )
) mRSMRST\_Delay\_Dedi
(
.iClk ( iClk\_2M ),
.iRst ( ~wRst\_n),
.iCE ( w10uSCE ),
.ivMaxCnt ( 6'd49 ), //500us delay
.iStart ( wRSMRST\_N ),
.oDone ( wRSMRST\_Delay\_Dedi )
);
SignalValidationDelay#
(
.VALUE ( 1'b0 ),
.TOTAL\_BITS ( 3'd2 ),
.POL ( 1'b0 )
) mRST\_DEDI\_BUSY\_PLD\_N
(
.iClk ( iClk\_2M ),
.iRst ( ~wRst\_n),
.iCE ( w1uSCE ),
.ivMaxCnt ( 3'd2 ), //2us delay
.iStart ( RST\_DEDI\_BUSY\_PLD\_N ),
.oDone ( wRST\_DEDI\_BUSY\_PLD\_N )
);
//////////////////////////////////////////////////////////////////////////////////
// DEBUG GSX PORT - Communication for Debug (Secondary) PLD
//////////////////////////////////////////////////////////////////////////////////
wire [7:0] wGSX\_From\_DebugPLD;
GSX\_Master #
(
.TOTAL\_OUTPUT\_MODULES( 2'd3 )
) mGSX\_Master
(
.iClk(iClk\_2M), //% 2MHz Reference Clock
.iCE(w5uSCE), //% Chip enable to generate oSClock. 10uS to generate 100KHz SClock
.iReset(wRst\_n), //% Input reset.
.oSClock (SGPIO\_DEBUG\_PLD\_CLK), //% Output clock.
.oSLoad (SGPIO\_DEBUG\_PLD\_LD\_N), //% Output Last clock of a bit stream; begin a new bit stream on the next clock.
.oSDataOut (SGPIO\_DEBUG\_PLD\_DOUT), //% Input serial data bit stream.
.iSDataIn (SGPIO\_DEBUG\_PLD\_DIN), //% Output serial data bit stream.
.ovDataIn( {
//Third Byte
wGSX\_From\_DebugPLD[7:0], //8 23:16 - Spare from Debug (0xAA)
// Second Byte
FPGA\_REV\_Minor\_DebugPLD, // 8 15-8
// First Byte
FPGA\_REV\_Major\_DebugPLD // 8 0-7
} ), //% Data receive vector. Master receives using DataIn. At Modular PPO baseboard, no data is pretended to be received from Global PLD
.ivDataOut( { //Debug PLD is not intended to receive data from Main PLD, however misc data is set to test
8'h80, // SGPIO [23:16] - Third byte
8'h86, // SGPIO [15:8] - Second Byte
8'hAA // SGPIO [7:0] - First Byte
} ) //% Data transmit vector. Master transmits using DataOut
);
`ifdef dedicated\_debug\_logic
//////////////////////////////////////////////////////////////////////////////////
//SMBus registers module - Dedicated Debug Port
//////////////////////////////////////////////////////////////////////////////////
wire wDedicatedFilteredSDA, wDedicatedFilteredSCL;
//% SDA Filter
GlitchFilter #
(
.TOTAL\_STAGES( 2'd3 )
) mSDAGlitchFilter\_Dedicated
(
.iClk ( iClk\_2M ),
.iRst ( !wRst\_n ),
.iCE ( 1'b1 ),
.iSignal ( SMB\_DEBUG\_PLD\_SDA ),
.oGlitchlessSignal ( wDedicatedFilteredSDA )
);
//
//% SCL Filter
//
GlitchFilter #
(
.TOTAL\_STAGES( 2'd3 )
) mSCLGlitchFilter\_Dedicated
(
.iClk ( iClk\_2M ),
.iRst ( !wRst\_n ),
.iCE ( 1'b1 ),
.iSignal ( SMB\_DEBUG\_PLD\_SCL ),
.oGlitchlessSignal ( wDedicatedFilteredSCL )
);
//% SMBus registers module
IICRegs#
(
.MODULE\_ADDRESS ( 7'h17 )
)mIICRegs\_Dedicated
(
.iClk ( iClk\_2M ),
.iRst ( !wRst\_n),
.iSCL ( wDedicatedFilteredSCL ),
.iSDA ( wDedicatedFilteredSDA ),
.onSDAOE ( oSMB\_DEBUG\_PLD\_SDA\_OE ),
.ivSMBusReg00 ({
4'b0000, //
wDbgMstSt7Seg // - Current power sequencer state
}),
.ivSMBusReg01 ({
wCPUMismatch, //
FM\_CPU1\_INTR\_PRSNT, //
FM\_CPU1\_SKTOCC\_LVT3\_N, //
FM\_CPU1\_PROC\_ID1, //
FM\_CPU1\_PROC\_ID0, //
FM\_CPU1\_PKGID2, //
FM\_CPU1\_PKGID1, //
FM\_CPU1\_PKGID0 //
}),
.ivSMBusReg02 ({
wSysOk, //
FM\_CPU2\_INTR\_PRSNT, //
FM\_CPU2\_SKTOCC\_LVT3\_N, //
FM\_CPU2\_PROC\_ID1, //
FM\_CPU2\_PROC\_ID0, //
FM\_CPU2\_PKGID2, //
FM\_CPU2\_PKGID1, //
FM\_CPU2\_PKGID0 //
}),
.ivSMBusReg03 ({
1'b1, //
FM\_BMC\_ONCTL\_N\_LATCH, //
PWRGD\_P3V3\_AUX\_FF, //
PWRGD\_P1V1\_BMC\_AUX\_FF, //
FM\_P2V5\_BMC\_EN, //
RST\_SRST\_BMC\_PLD\_N, //
wBmcPwrgd, //
wBmcPwrFlt //
}),
.ivSMBusReg04 ({
wValidForcePowerOn, //
FM\_PCH\_PRSNT\_N, //
FM\_SLP\_SUS\_RSM\_RST\_N\_FF, //
RST\_RSMRST\_N, //
FM\_SLPS4\_N\_FF, //
FM\_SLPS3\_N\_FF, //
PWRGD\_PCH\_PWROK, //
PWRGD\_SYS\_PWROK //
}),
.ivSMBusReg05 ({
wGoOutFltSt, //
PWRGD\_P1V8\_PCH\_AUX\_FF, //
PWRGD\_P1V05\_PCH\_AUX\_FF, //
FM\_PCH\_P1V8\_AUX\_EN, //
wPchPwrFltP1V05, //
wPchPwrFltP1V8, //
wPchPwrgd, //
wPchPwrFlt //
}),
.ivSMBusReg06 ({
wPwrEn, //
FM\_PS\_EN, //
PWRGD\_PS\_PWROK\_FF, //
wPsuPwrFlt, //
FM\_AUX\_SW\_EN, //
FM\_P5V\_EN, //
PWRGD\_P3V3\_FF, //
wMainPwrFlt //
}),
.ivSMBusReg07 ({
FM\_PLD\_CLKS\_OE\_N, //
1'b1, //
PWRGD\_CPU1\_PVDDQ\_ABCD\_FF, //
PWRGD\_CPU1\_PVDDQ\_EFGH\_FF, //
PWRGD\_CPU2\_PVDDQ\_ABCD\_FF, //
PWRGD\_CPU2\_PVDDQ\_EFGH\_FF, //
FM\_PVPP\_CPU1\_EN, //
FM\_PVPP\_CPU2\_EN //
}),
.ivSMBusReg08 ({
wDbgCpuSt\_CPU1, //
wDbgCpuSt\_CPU2 //
}),
.ivSMBusReg09 ( wvPOSTCodeLEDs ), // - BIOS POST Codes
.ivSMBusReg0A ( FPGA\_MAJOR\_REV ), // - CPLD1 Version
.ivSMBusReg0B ({
FM\_PS\_PWROK\_DLY\_SEL\_FF, //
FM\_DIS\_PS\_PWROK\_DLY\_FF, //
FM\_ADR\_COMPLETE\_FF, //
FM\_PLD\_PCH\_DATA, //
FM\_ADR\_SMI\_GPIO\_N, //
FM\_ADR\_TRIGGER\_N, //
FM\_ADR\_COMPLETE\_DLY, //
wPsuPwrFlt //
}),
.ivSMBusReg0C ({
RST\_PLTRST\_N\_FF, //
FM\_CPU1\_MEMHOT\_IN, //
FM\_CPU2\_MEMHOT\_IN, //
FM\_CPU1\_PROCHOT\_LVC3\_N, //
FM\_CPU2\_PROCHOT\_LVC3\_N, //
FM\_SYS\_THROTTLE\_LVC3\_PLD, //
FM\_THERMTRIP\_DLY, //
wvEvAddr[9] // - Event Logger Events Count MSB
} ),
.ivSMBusReg0D ( wvEvAddr[8:1] ), // - Event Logger Events Count LSB
.ivSMBusReg0E ( FPGA\_MINOR\_REV ), // - PLD Version Test number
.ivSMBusReg0F ({
wFM\_CPU1\_THERMTRIP\_N, //
wFM\_CPU2\_THERMTRIP\_N, //
FM\_CPU1\_THERMTRIP\_LVT3\_PLD\_N\_FF, //
FM\_CPU2\_THERMTRIP\_LVT3\_PLD\_N\_FF, //
FM\_MEM\_THERM\_EVENT\_CPU1\_LVT3\_N\_FF, //
FM\_MEM\_THERM\_EVENT\_CPU2\_LVT3\_N\_FF, //
IRQ\_SML1\_PMBUS\_PLD\_ALERT\_N\_FF, //
FM\_PMBUS\_ALERT\_B\_EN\_FF //
}),
.ivSMBusReg10 ({
FM\_P1V1\_EN,
FM\_P1V8\_PCIE\_CPU1\_EN,
FM\_PVCCANA\_CPU1\_EN,
FM\_PVCCIN\_CPU1\_EN,
FM\_PVCCIO\_CPU1\_EN,
FM\_PVCCSA\_CPU1\_EN,
FM\_CPU1\_FIVR\_FAULT\_LVT3,
1'b1
}),
.ivSMBusReg11 ({
PWRGD\_BIAS\_P1V1,
PWRGD\_P1V8\_PCIE\_CPU1,
PWRGD\_VCCANA\_PCIE\_CPU1,
PWRGD\_PVCCIN\_CPU1,
PWRGD\_PVCCIO\_CPU1,
PWRGD\_PVCCSA\_CPU1,
PWRGD\_CPU1\_LVC3,
1'b1
}),
.ivSMBusReg12 ({
FM\_PVCCIN\_CPU1\_PWR\_IN\_ALERT\_N,
IRQ\_PVCCIN\_CPU1\_VRHOT\_LVC3\_N,
IRQ\_PVDDQ\_ABCD\_CPU1\_VRHOT\_LVC3\_N,
IRQ\_PVDDQ\_EFGH\_CPU1\_VRHOT\_LVC3\_N,
FM\_CPU1\_MEMTRIP\_N,
wFM\_CPU1\_THERMTRIP\_N,
FM\_MEM\_THERM\_EVENT\_CPU1\_LVT3\_N,
RST\_CPU1\_LVC3\_N
}),
.ivSMBusReg13 ({
wCpuPwrgd\_CPU1,
wCpuPwrFlt\_CPU1,
wPWRGD\_PVCCIO\_CPU1,
wCpuPwrFltVCCIO\_CPU1,
wCpuPwrFltP1V8\_PCIE\_CPU1,
wCpuPwrFltVCCANA\_CPU1,
wCpuPwrFltVCCIN\_CPU1,
wCpuPwrFltVCCSA\_CPU1
}),
.ivSMBusReg14 ({
wMemPwrFltVDDQ\_CPU1\_ABCD,
wMemPwrFltVDDQ\_CPU1\_EFHG,
wMemPwrFlt\_CPU1,
wMemPwrgd\_CPU1,
1'b1,
1'b1,
1'b1,
1'b1
}),
.ivSMBusReg15 ({
FM\_P1V8\_PCIE\_CPU2\_EN,
FM\_PVCCANA\_CPU2\_EN,
FM\_PVCCIN\_CPU2\_EN,
FM\_PVCCIO\_CPU2\_EN,
FM\_PVCCSA\_CPU2\_EN,
FM\_CPU2\_FIVR\_FAULT\_LVT3,
1'b1,
1'b1
}),
.ivSMBusReg16 ({
PWRGD\_P1V8\_PCIE\_CPU2,
PWRGD\_VCCANA\_PCIE\_CPU2,
PWRGD\_PVCCIN\_CPU2,
PWRGD\_PVCCIO\_CPU2,
PWRGD\_PVCCSA\_CPU2,
PWRGD\_CPU2\_LVC3,
1'b1,
1'b1
}),
.ivSMBusReg17 ({
FM\_PVCCIN\_CPU2\_PWR\_IN\_ALERT\_N,
IRQ\_PVCCIN\_CPU2\_VRHOT\_LVC3\_N,
IRQ\_PVDDQ\_ABCD\_CPU2\_VRHOT\_LVC3\_N,
IRQ\_PVDDQ\_EFGH\_CPU2\_VRHOT\_LVC3\_N,
FM\_CPU2\_MEMTRIP\_N,
wFM\_CPU2\_THERMTRIP\_N,
FM\_MEM\_THERM\_EVENT\_CPU2\_LVT3\_N,
RST\_CPU2\_LVC3\_N
}),
.ivSMBusReg18 ({
wCpuPwrgd\_CPU2,
wCpuPwrFlt\_CPU2,
wFM\_PVCCIO\_CPU2\_EN,
wCpuPwrFltVCCIO\_CPU2,
wCpuPwrFltP1V8\_PCIE\_CPU2,
wCpuPwrFltVCCANA\_CPU2,
wCpuPwrFltVCCIN\_CPU2,
wCpuPwrFltVCCSA\_CPU2
}),
.ivSMBusReg19 ({
wMemPwrFltVDDQ\_CPU2\_ABCD,
wMemPwrFltVDDQ\_CPU2\_EFHG,
wMemPwrFlt\_CPU2,
wMemPwrgd\_CPU2,
1'b1,
1'b1,
1'b1,
1'b1
}),
.ivSMBusReg1A ({
FM\_RST\_PERST\_BIT0,
FM\_RST\_PERST\_BIT1,
FM\_RST\_PERST\_BIT2,
RST\_PCIE\_PERST0\_N,
RST\_PCIE\_PERST1\_N,
RST\_PCIE\_PERST2\_N,
RST\_PLTRST\_B\_N,
PWRGD\_CPUPWRGD
}),
.ivSMBusReg1B ({
RST\_PLTRST\_N,
FM\_CPU\_CATERR\_DLY\_LVT3\_N,
FM\_CPU\_CATERR\_PLD\_LVT3\_N,
FM\_PCH\_ESPI\_MUX\_SEL,
PWRGD\_DRAMPWRGD\_CPU,
FM\_THROTTLE\_N,
DBP\_POWER\_BTN\_N,
DBP\_SYSPWROK
}),
.ivSMBusReg1C ({
FM\_PFR\_MUX\_OE\_CTL\_PLD,
RST\_DEDI\_BUSY\_PLD\_N,
1'b0,
FM\_CPU\_BCLK5\_OE\_R\_N,
FM\_PLD\_CLKS\_OE\_N,
FM\_P5V\_EN,
FM\_AUX\_SW\_EN,
FP\_LED\_FAN\_FAULT\_PWRSTBY\_PLD\_N
}),
.ivSMBusReg1D ({
wPwrEn,
wPsuPwrEn,
wFM\_P5V\_EN,
wMainVRPwrEn,
wFM\_AUX\_SW\_EN,
wMemPwrEn,
wCpuPwrEn,
wP3v3PwrFlt
}),
.ivSMBusReg1E ({
wPchPwrFltP1V8,
wPchPwrFltP1V05,
wPchPwrFlt,
wBmcPwrFlt,
wPsuPwrFlt,
wMainPwrFlt,
wMemPwrFlt,
wCpuPwrFlt
}),
.ivSMBusReg1F ({
wPsuPwrgd,
wPchPwrgd,
wBmcPwrgd,
wMainVRPwrgd,
wMemPwrgd,
wCpuPwrgd,
wFault,
wTimeout
}),
.ivSMBusReg20 ({
FPGA\_REV\_Major\_DebugPLD
}),//
.ivSMBusReg21 ({
FPGA\_REV\_Minor\_DebugPLD
}),//
.ivSMBusReg22 ({
7'd0,
wDebugPLD\_Valid
}),//
.ivSMBusReg23 ( 8'hAA ), //
.ivSMBusReg24 ( 8'h24 ), //
.ivSMBusReg25 ( 8'hAA ), //
.ivSMBusReg26 ( 8'h26 ), //
.ivSMBusReg27 ( 8'hAA ), //
.ivSMBusReg28 ( 8'h28 ), //
.ivSMBusReg29 ( 8'hAA ), //
.ivSMBusReg2A ( 8'h2A ), //
.ivSMBusReg2B ( 8'hAA ), //
.ivSMBusReg2C ( 8'h2C ), //
.ivSMBusReg2D ( 8'hAA ), //
.ivSMBusReg2E ( 8'h2E ), //
.ivSMBusReg2F ( 8'hAA ) //
);
`else
assign oSMB\_DEBUG\_PLD\_SDA\_OE = HIGH;
`endif
endmodule
```
**Файл PPSampleApp\_intel123.zip**
Исходники утилиты неизвестного назначения на C++ для VS2013. Пароль архива «intel123».
**Файл R5MR\_DT\_Firmware\_Release\_(8C2C17\_8C1C12).zip**
Исходники прошивки какого-то xDSL маршрутизатора Intel. Часть кода на ASM.
**Файл TGL\_3175\_01\_282\_Engineering\_Release.zip**
Исходники BIOS, кодов инициализации, Client Silicon и подобного для процессоров Tiger Lake.
**Файл tgl\_bios\_ww17\_2020.zip**
Несколько версий бинарников для сборки BIOS Tiger Lake.
**Файл TGL\_V2527\_10\_IPCM\_Sample\_Code\_V1.0.0.zip**
Исходники драйвера [IPCM](https://software.intel.com/content/www/us/en/develop/articles/intel-performance-counter-monitor.html) Tiger Lake для интеграции в свой BIOS.
**Файл ucodeupdatecapsule\_0x30\_0x31.zip**
Обновление микрокода для неизвестного процессора. Бинарники для включения в общий пакет обновления BIOS. Исходников [микрокода](https://ru.wikipedia.org/wiki/%D0%9C%D0%B8%D0%BA%D1%80%D0%BE%D0%BA%D0%BE%D0%B4) мы никогда не увидим.
**Файл wav\_fw\_src\_06.01.00\_er7.87\_20191226040022.zip**
Похоже на исходники прошивки интеловского маршрутизатора.
**Файл WW04'20\_Ext\_RKL\_S\_VP\_PPR.zip**
Библиотека моделей для эмуляции процессоров Rocket Lake S с описанием.
**Файл WW18'20\_Ext\_RKL\_S\_VP\_PPR.zip**
Обновление моделей для Rocket Lake S.
**Файл WW11'20\_Ext\_TGL\_H\_VP\_PPR.zip**
То же самое для Tiger Lake H.
**Файл WW18'20\_Ext\_ADL\_S\_VP\_PPR.zip**
То же для Alder Lake S.
Позже было [небольшое дополнение](https://t.me/exconfidential/604) к сливу.
**Файл Apollo Lake Intel® TXE 3.1.75.2351\_MR (probably incomplete).zip**
Инструкции, утилита и бинарный файл для сборки прошивки Intel TXE OEM-разработчками.
**Файл APS\_Software.zip**
Объёмный дистрибутив программы Intel Automated Power Switch. Из описания можно узнать, что она предназначена для всестороннего автоматизированного тестирования [p-states](https://software.intel.com/content/www/us/en/develop/documentation/vtune-help/top/reference/energy-analysis-metrics-reference/p-state.html) (регулирование напряжения и частоты в зависимости от нагрузки) мобильных и настольных систем. Приложена документация и инструкция по адаптированию тестов OEM-разработчиками для своих нужд.
**Файл Certificates.zip**
Тут лежат сертификаты для беспроводного приёмника HDCP.
Не могу представить сценариев их неправомерного использования. Возможно кто-то подскажет в комментариях.
**Файл tigerisland-rev1.zip**
Электросхемы, диаграммы и список компонентов прототипа ноутбука на Tiger Lake.
**Файл Lakefield\_Pets.zip**
Дистрибутив и документация программы Intel Platform Enablement Test Suite. Ещё одно приложение для автоматизированного тестирования Intel ME для платформы [Lakefield](https://newsroom.intel.com/news/intel-hybrid-processors-uncompromised-pc-experiences-innovative-form-factors-foldables-dual-screens/).
Вот и всё.
[Подписывайтесь на канал](https://t.me/govnokoder), ставьте лайки, [присылайте ваши донаты](https://money.yandex.ru/to/41001516590259). | https://habr.com/ru/post/514458/ | null | ru | null |
# Gradle и решение задач автоматизации
Всем привет, сегодня я хотел бы рассказать вам о моём опыте работы с Gradle, не просто переписать мануал (хотя он отлично написан), но рассказать с какими реальными проблемами я столкнулся и как побеждал их, а также показать какие возможности предоставляет нам Gradle. Тема очень обширная поэтому, к сожалению я не смогу рассмотреть многие аспекты подробно и последовательно, надеюсь что читатели уже немного знакомы с Gradle и смогут понять суть описываемых решений.
##### Лирика
Важное замечание по поводу maven — многие задачи которые я делал с помощью Gradle я никогда не пытался сделать раньше maven-ом, поэтому сравнить многие моменты, что лучше, а что хуже я к сожалению не смогу.
Первое, что в нём понравилось, это наконец-то «прощай xml», о да, для меня это действительно как заново родиться, как же было невероятно приятно писать сборку на настоящем языке программирования, какая же это свобода и вдохновение.
В статье будут использоваться некоторые понятия из OSGI и eclipse rcp, я не буду заострять на них внимание, чтобы не отвлекаться от главной темы.
В приложении есть простенький проект с примерами скриптов и некоторыми исходниками используемыми в статье: [тынц](https://www.dropbox.com/s/9x2bvvw22a7ad8j/gradle-example.zip)
##### Масштаб проблемы
Итак, что у нас было вначале: у нас имеется большая (по моим меркам) система запускаемая на OSGI платформе, проекты в системе это eclipse plug-in проекты, никакой интеграции с системой сборки нет, в качестве системы сборки используется ant, системы контроля зависимостей не было. Была задача сделать всё круто.
Итак я предложил Gradle мне дали добро, и началось.
###### Описание структуры проектов
Суть проблемы в том, что имеется директория с некой структурой в которой хранятся проекты.
Первое что нужно было сделать, это описать в скриптах сборки структуру директории и все имеющиеся проекты. Я это смог сделать с легкостью. В Gradle для этого используется понятие [multi project](http://www.gradle.org/docs/current/userguide/multi_project_builds.html). В корневой директории создаем файл settings.gradle и записываем пути к каждой папке где лежат проекты разделитель пути «:». Пример settings.gradle:
```
include "subproject-first"
include "subproject-first:child-first"
include "subproject-first:child-first:another-child:last-child"
include "subproject-first:child-first:another-child:another-last-child"
include "subproject-second"
```
Теперь мы можем посмотреть структуру нашей системы, выполнив команду:
```
gradle projects -q
```
Результат:
###### Настройка IDE
Следующим шагом была возможность импорта проектов в IDE. В Gradle есть плагины для idea и eclipse:
[тынц](http://www.gradle.org/docs/current/userguide/eclipse_plugin.html)
[барабынц](http://www.gradle.org/docs/current/dsl/org.gradle.plugins.ide.eclipse.model.EclipseProject.html)
У нас проекты очень жестко завязаны на eclipse из-за osgi, и куска eclipse-rcp который не позволял просто так взять target platform (это такая страшная штука из мира osgi, по сути это osgi framework и папка с кучей jar-ников) и использовать её в idea, но в общем это лирическое отступление.
Взяв eclipse плагин я смог настроить проекты именно так как мне надо было, а надо было мне сделать проекты как eclipse plug-in, прописать в настройках plugin dependencies, указать версию используемого компилятора. Пример настройки:
```
project.apply plugin: 'java'
project.apply plugin: 'eclipse'
project.apply plugin: 'idea'
project.eclipse {
jdt {
sourceCompatibility = '1.6'
}
project {
//применяем натуру и проект становится eclipse plug-in
natures 'org.eclipse.pde.PluginNature'
}
classpath {
downloadSources = true
downloadJavadoc = true
//используем java se 1.6 jre
containers.clear()
containers.add("org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6")
file {
//ручная правка .classpath добавление plugin-dependencies зависимостей (то есть зависимости от целевой платформы — есть такое понятие в osgi и эклипсе)
withXml {
Node node = it.asNode()
node.appendNode('classpathentry', [kind: 'con', path: 'org.eclipse.pde.core.requiredPlugins'])
}
}
}
}
```
То есть, как видите настроек для eclipse много, а то что нельзя сделать через api eclipse плагина, можно сделать вручную исправив xml файл настроек.
###### Зависимости
Следующий шаг, dependency management: [документация](http://www.gradle.org/docs/current/userguide/dependency_management.html).
Я раньше думал, что нет ничего лучше dependency managment в maven, сейчас я думаю, что я ошибался. Gradle может использовать зависимости из maven, ivy, и простые папки и файлы, да и вообще при желании можно сделать, что-то очень нестандартное, например использовать ftp сервер в качестве repository. Для примера, как прописываются зависимости:
```
project(":myproject") {
dependencies {
//зависимость от другого проекта
compile project(":other-my-project")
//берем зависимости из локальной папки
compile fileTree(dir: "libs", include: "*.jar")
//берем зависимость из maven репозитория
compile 'org.hibernate:hibernate-core:3.6.3.Final'
}
}
```
Но это только начало. В Gradle есть понятие configurations — это что-то похожее на группы в которые добавляются зависимости. То есть в нашем примере compile это и есть configuration, которую создает java plugin.
Эта возможность помогла мне красиво решить одну проблему с зависимостями, суть этой проблемы вот в чем, у нас ядро разрабатывают за границей, и результат к нам приходит в виде zip архива, внутри которого имеется множество различных файлов, в том числе необходимый набор библиотек. Этот архив заливается в artifactory внешними силами, а я в свою очередь получаю его из artifactory, сохраняю его в temp директорию, распаковываю, беру из распакованной папки все необходимые мне библиотеки.
Скачивание и распаковка архива:
```
//получаем путь к temp папке куда будем распаковывать архив
File sdkDir = getSdkDir(sdkVersion)
//создаем необходимые нам конфигурации
project.configurations {
sdk
libsFromSdk
}
//прописываем artifactory репозиторий откуда будем брать наш архив
project.repositories {
maven { url 'http://localrepo:8081/artifactory/repo' }
mavenCentral()
mavenLocal()
}
//прописываем зависимость
project.dependencies {
sdk group: 'com.kontora', name: 'sdk', version: sdkVersion, ext: 'zip'
}
Configuration cfg = project.configurations.sdk
//берем zip файл из зависимости
cfg.files.each { File zipArchive ->
//извлекаем архив в папку
project.ant.unzip src: zipArchive, dest: sdkDir.absolutePath
}
```
Обратите внимание, что весь набор действий запрограммирован с помощью dsl языка Gradle в терминах сборки. Нет необходимости писать свой низкоуровневый код на языке программирования.
Подключение зависимостей в проект из распакованного архива:
```
project.dependencies {
libsFromSdk project.fileTree(dir: "$pathToSdk/libs", include: "*.jar")
…
//копируем все зависимости из libsFromSdk в compile конфигурацию
project.compile libsFromSdk
}
```
И итоге мы получим все наши зависимости для компиляции.
###### Я люблю тебя код, что само по себе и не ново
Наши скрипты тем временем растут и увеличиваются, пора бы и подумать над вопросом ~~копипасты~~ дублирования кода. Предположим у нас есть программная система и мы все понимаем, что дублирование кода в системе это плохо, но почему-то дублирование строк текста в настройках системы сборки не считается чем-то неправильным. Я думаю причина этому, описание сборки в xml, ведь xml — это по сути конфигурационные файлы и применять правила программирования для файлов конфигурации не совсем корректно. Но вместе с тем писать в сотне файлов одинаковый текст конфигурации — это не совсем красиво, сложно для ориентации программиста и может стать причиной неявных и сложно обнаруживаемых ошибок в сборке. В Gradle eсли мы для сборки пишем код, то значит мы сможем избавиться от дублирования кода конфигурации в системе сборки, стандартным способом, как мы это делаем в обычном коде. И тут Gradle опять показал свою мощь и красоту.
[Трям](http://www.gradle.org/docs/current/userguide/organizing_build_logic.html).
После некоторого этапа исследований я написал свой первый плагин. Оказывается можно создать папку buildSrc в корневой папке системы, которая будет java, groovy, scala etc проектом по вашему выбору, и при старте системы сборки, в первую очередь будет скомпилирован проект buildSrc и классами из этого проекта можно будет пользоваться в скриптах сборки. По мне так это гениально.
В итоге, например сейчас у меня имена и пути к проектам прописаны только в одном месте в классе в buildSrc, а все остальные скрипты пользуются этими переменными в которых хранятся имена проектов (конечно разговор о преимуществах и недостатках этого подхода это отдельный разговор), при этом у меня есть авто дополнение кода, я просто пишу в любом месте сборки примерно так: MyProjects.subproject.child.absolutePath. Помимо этого большая часть логики сборки лежит в плагинах там же в buildSrc.
Ниже приведен пример плагина и его вызова в скрипте сборки:
Пример плагина:
```
package org.gradle.example
import org.gradle.api.Project
import org.gradle.api.Plugin
class MyPlugin implements Plugin{
private static final String PLUGIN\_EXTENSION = 'my'
Project project;
@Override
public void apply(Project project) {
MyPlugin plugin = project.extensions.create(PLUGIN\_EXTENSION, MyPlugin.class)
plugin.project = project;
}
public void applyCommonSettings() {
project.apply plugin: 'java'
project.apply plugin: 'eclipse'
project.apply plugin: 'idea'
}
}
```
Пример вызова плагина:
```
project.apply plugin: MyPlugin
my{
applyCommonSettings()
}
```
###### А у вас есть точно такое же только с перламутровыми пуговицами?
И переходя к плагинам Gradle: у нас в системе есть разные проекты с разными структурами и настройками, Это java, flex, android проекты. И всё это хозяйство нужно настраивать по разному для экспорта в IDE. Например у нас бОльшая часть проектов — это Osgi проекты, другая часть — это простые проекты, у некоторых проектов имеется legacy структура (то есть только папка src) и т.д. И тут Gradle позволил легко справиться с этой задачей. Я написал несколько классов в которых указал какие у нас могут быть настройки, написал класс фабрики в котором описал все настройки каждого проекта, и когда происходит импорт проекта в ide, мы получаем эти настройки и применяем их. Примера кода я тут приводить не буду, потому что это просто groovy код с обычной логикой.
Также я смог написать свои собственные валидаторы проверяющие правильность структуры проектов.
Также планируется много всяких прикольных штук. К сожалению нет времени на то, чтобы рассказать про написание unit тестов для gradle плагинов, возможности логгирования и многое другое
##### Заключение
Я очень доволен гредлом, он оправдал себя на 101% желаю и вам познать радость работы с этой системой. | https://habr.com/ru/post/192268/ | null | ru | null |
# Even more jQuery?
За последние несколько лет я полюбил язык Javascript. Мне прекрасно известно, сколько вокруг него обсуждений и холиваров. И я прекрасно знаю его назначение, где он может быть применим, а где нет.
Все мы хоть раз слышали о jQuery. С некоторых пор я буквально влюбился в это творение, как и в сам JavaScript. За моей спиной очень много строк кода. Рабочего, любительского, простого фонарного кода. С недавних пор я начал изучать структуру всеми любимой jQuery и пришёл к выводу, что это ничто иное, как шедевр.
Почему здесь эта статья?
------------------------
На моём счету немало разработок, которыми я пытался упростить себе процесс программирования, многие из них были jQuery-like. Но увы, разработка и поддержка останавливалась и забрасывалась в силу моей занятости и они так и не вышли за пределы моего жесткого диска.
Некоторое время назад мне, уже будучи неплохо ознакомленному со структурой jQuery, пришла в голову мысль: что если сделать конструктор, где мы сами будем указывать функцию, которая будет подбирать для нас необходимые данные и собирать их в объект jQuery? Нет, здесь нет никакой речи о селекторном разборе веб-страниц, об анимациях, ajax и прочих плюшках и вкусностях jQuery. Я подумал: что если наша библиотека будет подстраиваться под требования программиста (будь то перебор банальных чисел, строк, объектов с данными или даже файлов) вне зависимости от платформы, на которой запущен данный код?
Так пришла идея собрать этот небольшой фреймворк.
Давайте разберемся, что к чему.
**jQuery Builder** — это микрофреймворк, предназначенный для создания jQuery-like библиотек для манипуляции различными данными. На данный момент я пока решил унаследовать класс jQuery от родного js-массива, но в будущем это будет исключено и будут созданы свои аналоги стандартных методов.
Приведу пару простых примеров:
Пример №1. Предположим, у нас есть массив данных, из которого нам нужно сформировать jQuery-объект с необходимыми методами. Пусть это будут банальные числа.
**Код**
```
// Наши числа
var numbers = [4, 8, 15, 16, 23, 42, 108];
// Сам конструктор
var builder = new JQueryBuilder(function (selector) {
// Перебираем числа
for(var i = 0; i < numbers.length; i++) {
// Проверяем селектор
switch (selector) {
// Если мы ищем чётные числа
case 'even' :
// ... и число подходит под требования
if (numbers[i] % 2 === 0) {
// Добавляем его в выборку
this.push(numbers[i]);
}
break;
// Если мы ищем нечётные числа
case 'odd' :
// ... и число подходит под требования
if (numbers[i] % 2 !== 0) {
// Добавляем его в выборку
this.push(numbers[i]);
}
break;
}
}
});
```
Поле jQuery содержит в себе необходимый нам объект (если быть точнее, это функция), где будет содержаться наша выборка и необходимые методы (из jQuery.fn).
Итак, мы только что выполнили первую основную задачу — мы сформировали наш конструктор. Он представляет из себя функцию, в которой исполняется цикл, перебирающий наш массив. При соответствии числа нашим требованиям число будет добавлено в выборку.
Теперь создадим новый метод. Всё делается точно так же как в настоящем jQuery — через объект fn.
**Код**
```
var $ = builder.jQuery;
$.fn.add = function (value) {
var self = this;
return this.each(function (i) {
self[i] += value;
});
};
var result = $('even').add(5);
console.log(result); // [9, 13, 21, 47, 113]
```
Ожидаю в комментариях [эту картинку](http://i.stack.imgur.com/62J0l.gif), однако здесь всё гораздо приятнее. Данная библиотека, по моему мнению, может оказаться полезной для быстрого нахождения решения частых (и не только) задач касательно массивов.
Пример №2. Теперь проделаем что-то подобное со строками.
**Код**
```
var $ = jQueryBuilder.fromArray().jQuery;
$.fn.extend({
reverse: function () {
var self = this;
return this.each(function (i) {
var result = '';
for(var x = self[i].length - 1; x >= 0 ; x--) {
result += self[i][x];
}
self[i] = result;
});
},
upper: function () {
var self = this;
return this.each(function (i) {
self[i] = this.toUpperCase();
});
},
lower: function () {
var self = this;
return this.each(function (i) {
self[i] = this.toLowerCase();
});
}
});
var result = $('abcde', 'xyZ', 'HAAR')
.reverse()
.lower()
;
console.log(result); // ["edcba", "zyx", "raah"]
```
На мой взгляд, всё очень просто и понятно. В следующей статье я расскажу, как применил эту библиотеку к Adobe After Effects, в котором есть возможность писать скрипты на Javascript. Получился эдакий jQuery для перебора и управления слоями в композиции. В ближайшем будуем планирую изучить скриптинг Фотошопа и разработать аналог для него.
Репозиторий [тут](https://github.com/Serabass/jquery-builder). Обещаю постепенно дополнять примерами.
Спасибо за внимание.
**UPD.**
Сейчас плотно изучаю Coffeescript. Планирую переписать Builder на него. | https://habr.com/ru/post/254713/ | null | ru | null |
# Угадывание мыслей и выполнение несуществующих команд средствами bash
В Debian в bash был добавлен патч, благодаря которому пользователь может написать свою функцию, выполняемую в случае, если введённая пользователем команда отсутствует. В Ubuntu эту фичу использует подсказка command-not-found, заметно тормозящая работу, в то время как можно найти более интересные и полезные возможности применения этого механизма, оставив поиск пакета специализированным программам. Поделюсь своим опытом.
У нашего подразделения есть специальная сеть для тестовых серверов и виртуальных машин: 192.168.20.0/24, и очень часто приходится набирать команды типа `ssh [email protected]`, причем в командах различается только последняя цифра. У ограниченного числа серверов нужно указывать другой `username`. Реже приходится ходить на сервера в других подсетях (в пределах 192.168.0.0/16); также иногда клиенты открывают нам доступ к своим системам, чтобы мы смогли продиагностировать их проблему и решить ее на месте.
Как следует из предыдущего абзаца, очень часто набираются команды вида:
```
ssh [email protected]
ssh [email protected]
ssh [email protected]
```
Возникает естественное желание этот процесс сократить и оптимизировать. Когда серверов было немного, я насоздавал множество [хитрых алиасов](http://bappoy.pp.ru/2007/11/21/konsole-encodings.html) вроде следующего:
```
alias 123='ssh [email protected]'
```
Однако вскоре я понял, что поддерживать список из полусотни alias'ов — не true unix way, и задумался об альтернативах. Вспомнил об опытах вебмастеров эпохи web 1.0 по использованию 404 ошибки для отображения страницы с нужным содержанием, задумался о том, каким образом bash перехватывает вызов неизвестной команды и подменяет её командой поиска нужного пакета… В результате беглого изучения состава пакета command-not-found было выяснено, что используется функция `command_not_found_handle`. Она принимает в качестве аргумента введённую пользователем команду, выполняет некие действия и возвращает 127, если ничего нельзя сделать (в таком случае bash выводит стандартное сообщение об ошибке), или любое другое число, если что-то получилось.
Остальное оказалось делом техники. В `~/.bashrc` была добавлена функция:
```
command_not_found_handle () {
if [[ ! "$1" ]] ; then
return 127
fi
n="$1"
if echo $n| perl -ne 'exit(/^([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])$/ ? 0:1)' ; then
ip=192.168.20.$n
elif echo $n| perl -ne 'exit (/^([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])$/ ? 0:1)' ; then
ip=192.168.$n
elif echo $n| perl -ne 'exit (/^([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])$/ ? 0:1)' ; then
ip=$n
else
return 127
fi
ssh $ip
}
```
Любое введённое число от 1 до 255 преобразуется в команду `ssh 192.168.20.число`; два числа — в `ssh 192.168.число.число`; любой введённый IP-адрес превращается в `ssh IP-адрес`. Во всех остальных случаях просто выводится сообщение `"command not found"`.
Поскольку используется довольно сложное регулярное выражение, то для его обработки пришлось использовать perl. Ещё был вариант с `grep -qP`, но эксперименальная опция `-P` (расширенная поддержка perl-овых регулярных выражений) включена в grep не во всех дистрибутивах (например, в Ubuntu 8.04 её нет, а в 8.10 уже есть).
Чтобы для всех хостов в 20 сети подставлялось общее имя пользователя ordinary\_user, а для избранных хостов — специальные имена, в ~/.ssh/config я добавил строчки (общие параметры для всех хостов, предваряемые конструкцией `Host *`, должны находиться в конце списка):
```
Host 192.168.20.251
User special_user1
Host 192.168.20.252
User special_user2
Host 192.168.20.254
User special_user3
Host *
User ordinary_user
```
К сожалению, мне не удалось заставить эту функцию обрабатывать также и параметры командной строки: функции command\_not\_found\_handle передаётся только первый позиционный параметр, остальные недоступны. Поэтому для каждого нестандартного хоста придётся либо писать полный вариант команды со всеми параметрами, либо указывать настройки сервера в ~/.ssh/config, подобно указанным выше. Имеются и прочие недостатки в реализации, обсуждаемые, в частности, на сайте [smylers hates software](http://smylers.hates-software.com/2008/01/04/090399e2.html).
Однако даже с такими ограничениями открываются новые потрясающие возможности. Думаю, что предложенное мной применение не единственное, и этот пост — не последний на данную тему.
P.S. бонус для дочитавших до этого места: [библиотека регулярных выражений perl](http://regexlib.com/), где я нашел регэксп для проверки строки на соответствие IP-адресу. | https://habr.com/ru/post/44788/ | null | ru | null |
# Dagaz: Ищем таланты
***Делай с нами,
делай, как мы,
делай лучше нас!
Телепередача 80-ых***
Должен признаться, я не очень хорош в разработке ботов. Уверен, есть люди, умеющие это делать гораздо лучше меня. И я бы очень хотел, чтобы такие люди присоединились к [проекту](https://glukkazan.github.io/). В плане материального поощрения, предложить я могу немногое. Dagaz был задуман как бесплатная и общедоступная альтернатива [Zillions of Games](http://www.zillions-of-games.com/). Сам я [не против](https://github.com/GlukKazan/Dagaz/blob/master/LICENSE.txt) его коммерческого использования, просто пока не придумал, как это можно сделать.
Проект, безусловно, продолжит развиваться и останется бесплатным (в своей основе). Любого человека, внесшего свой вклад в его развитие я буду считать своим другом и соавтором. Разумеется, указание авторства, для всех модулей, в разработке которых эти люди приняли участие, будет обязательным. Кроме того, я готов оказать любую посильную техническую помощь по проекту. Например, я могу рассказать о том, как разрабатывать игровых ботов.
Прежде всего, стоит заметить, что далеко не для всех игр вопрос разработки ботов стоит остро. В случае головоломок, бот, умеющий находить решение — скорее роскошь, чем жизненная необходимость. Кроме того, существуют игры, в силу объективных причин, гораздо более сложные для человека, чем для компьютера. В полной мере это относится к различным [манкалам](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D0%BD%D0%BA%D0%B0%D0%BB%D0%B0).
[](https://glukkazan.github.io/mancala/oware.htm)
Победить у компьютера в такой игре тяжело. И это не потому, что вы не умеете в неё играть! Я знаю человека, [который умеет](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%B8%D1%80%D1%8E%D0%BA,_%D0%94%D0%BC%D0%B8%D1%82%D1%80%D0%B8%D0%B9_%D0%98%D0%B3%D0%BE%D1%80%D0%B5%D0%B2%D0%B8%D1%87). Так вот, победил он далеко не с первой попытки и с очень небольшим перевесом. И это при том, что в ней используется далеко не самый удачный [бот](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/ai/maxmin-ai-v2.js), гораздо более скромно проявляющий себя в [других играх](https://glukkazan.github.io/shogi/mini-shogi.htm). Манкалы словно бы специально созданы для компьютеров! Но дело не только в них.
[](https://glukkazan.github.io/elimination/fox-and-geese-british.htm)
Здесь бот ещё [проще](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/ai/aggressive-ai.js), но сама [игра](https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D1%81%D0%B0_%D0%B8_%D0%B3%D1%83%D1%81%D0%B8) ассиметрична. Задача «лисы» (есть всё, что только возможно) гораздо проще задачи «гусей» (зажать «лису», лишив её хода) и за «лису» играет компьютер. Если кому-то удастся у него выиграть, сообщите. Потому что мне это пока не удалось. Сам процесс вроде понятен, но постоянно упускаешь из виду какую нибудь «мелочь».
Также, имеются игры, с которыми боты вполне справляются, хотя могли бы играть гораздо лучше. [Reversi](https://glukkazan.github.io/custodian/reversi.htm) — отличный тому пример. Уверен, человеку, хорошо играющему в эту игру, справиться с ботом будет не трудно, но для меня, например, это непосильная задача. Увы, с большей частью наиболее популярных игр мои боты не справляются совершенно. Вот список тех из них, для которых эта проблема наиболее актуальна:
1. Шашки — в первую очередь "[Русские](https://glukkazan.github.io/checkers/russian-checkers.htm)", "[Международные](https://glukkazan.github.io/checkers/international-checkers.htm)" и "[Фризские](https://glukkazan.github.io/checkers/frisian-checkers.htm)". Боты с ними, в принципе, работают, но играют на уровне очень слабого новичка. Также очень интересны "[Турецкие шашки](https://glukkazan.github.io/checkers/turkish-dama.htm)", здесь боты играют ещё хуже. Самого пристального внимания заслуживают "[Столбовые шашки](https://glukkazan.github.io/checkers/column-checkers.htm)" и "[Ласка](https://glukkazan.github.io/checkers/laska.htm)". Это действительно сложные и очень интересные игры!
2. [Шахматы](https://glukkazan.github.io/checkmate/chess.htm) и всё что на них [похоже](https://glukkazan.github.io/checkmate/chess.svg). В эти игры, все мои боты играют совершенно отвратительно. То же относится к "[Китайским](https://glukkazan.github.io/xiangqi/xiangqi.svg)" и, в ещё большей степени, "[Японским](https://glukkazan.github.io/shogi/shogi.svg)" шахматам. Здесь, я не говорю о "[больших](https://glukkazan.github.io/shogi/tenjiku-shogi.htm) [играх](https://glukkazan.github.io/shogi/ko-shogi-board.htm)", разработка ботов для которых довольно специфична и в которые мало кто играет (я знаю таких людей). В первую очередь, для меня интересны наиболее популярные варианты. [Шашматы](https://glukkazan.github.io/checkers/cheskers.htm) также в приоритете. Их вообще стоит вынести в отдельную категорию, поскольку они взяли всё самое сложное «из обоих миров». В первую очередь, меня интересуют "[Белорусские шахматы](https://glukkazan.github.io/checkmate/belarusian-chess.htm)" и "[Алтайская шатра](https://glukkazan.github.io/checkers/shatra-board.htm)". Любители совсем уж хардкорной экзотики могут опробовать свои силы на "[Платформенных шахматах](https://glukkazan.github.io/checkmate/platform-chess.htm)".
3. Постановочные игры, прежде всего "[Рендзю](https://glukkazan.github.io/renju/renju-board.htm)" и "[Го](https://glukkazan.github.io/go/go-19x19-board.htm)". Это очень свежая тема, в том смысле, что я вот только что к ним приступил. Вообще, игры со сбросом фигур на доску (наравне с манкалами) — тема текущей итерации проекта, так что таких игр совсем скоро будет больше. И уже сейчас понятно, что некоторые из них (Го например) требуют особого подхода при разработке AI. А ведь есть и ещё более [замороченные игры](https://glukkazan.github.io/go/three-color-go-board.htm).
4. В эту категорию попадают игры самые разнообразные. Здесь и детские "[Джунгли](https://glukkazan.github.io/breakthrough/jungle-board.htm)" и французский "[Агон](https://glukkazan.github.io/custodian/agon-board.htm)" XVIII-го века. Игры [большие](https://glukkazan.github.io/custodian/alea-evangeli-board.htm) и [поменьше](https://glukkazan.github.io/breakthrough/epaminondas-8x8.htm). Игры совершенно [безумные](https://glukkazan.github.io/races/hanga-roa-board.htm). Всех их объединяет одно. Я не имею ни малейшего представления о том, как подступиться к разработке их AI. И, разумеется, я буду просто счастлив, если кто-то поможет довести до ума AI для моего "[Спока](https://glukkazan.github.io/elimination/spock-board.htm)".
Так каким же образом можно написать своего бота? В качестве самого первого шага, стоит скачать содержимое [этого](https://github.com/GlukKazan/Dagaz) или [этого](https://github.com/GlukKazan/GlukKazan.github.io) репозитория к себе на компьютер (без чего писать, а тем более отлаживать, что либо будет тяжело). Хотя второй из перечисленных репозиториев является, по сути, релизным, никакой обфускации или минификации он, на текущий момент, не использует. Все приложения устроены предельно просто. Из html-файла последовательно загружаются несколько js-скриптов.
**Примерно вот так**
```
Turkish Dama
| |
| --- |
| Traditional - Turkish [no AI](turkish-dama-board.htm) |
| Broken canvas... |
|
|
| | |
| --- | --- |
| | |
|
```
Можно заметить, что из числа сторонних библиотек, я использую только очень для меня удобную [Underscore](http://underscorejs.ru/) (я не настаиваю на её использовании). Все скрипты ботов содержат в своём имени "-ai". Именно они нам сейчас и интересны. Но прежде чем двигаться дальше, стоит немного рассказать о том:
**Что такое дизайн игры?**
Прежде всего, Dagaz отделяет дизайн игры (ZrfDesign) от её состояния (ZrfBoard). Дизайн определяет топологию доски и правила перемещения фигур, а состояние — то какие фигуры и где находятся, в данный конкретный момент. Объект ZrfDesign создаётся один раз на всю игру, объектов ZrfBoard может создаваться (в том числе, для нужд ботов) неограниченное количество. В начале игры, дизайн инициализируется вызовом функции **Dagaz.Model.BuildDesign**:
**turkish-dama.js**
```
Dagaz.Model.BuildDesign = function(design) {
design.checkVersion("z2j", "2");
design.checkVersion("zrf", "2.0");
design.checkVersion("animate-captures", "false");
design.checkVersion("smart-moves", "true");
design.checkVersion("maximal-captures", "true");
design.addDirection("w");
design.addDirection("e");
design.addDirection("s");
design.addDirection("n");
design.addPlayer("White", [1, 0, 3, 2]);
design.addPlayer("Black", [0, 1, 3, 2]);
design.addPosition("a8", [0, 1, 8, 0]);
design.addPosition("b8", [-1, 1, 8, 0]);
...
design.addPosition("h1", [-1, 0, 0, -8]);
design.addZone("promotion", 1, [0, 1, 2, 3, 4, 5, 6, 7]);
design.addZone("promotion", 2, [56, 57, 58, 59, 60, 61, 62, 63]);
design.addCommand(0, ZRF.FUNCTION, 24); // from
design.addCommand(0, ZRF.PARAM, 0); // $1
design.addCommand(0, ZRF.FUNCTION, 22); // navigate
design.addCommand(0, ZRF.FUNCTION, 2); // enemy?
design.addCommand(0, ZRF.FUNCTION, 20); // verify
design.addCommand(0, ZRF.FUNCTION, 26); // capture
design.addCommand(0, ZRF.PARAM, 1); // $2
design.addCommand(0, ZRF.FUNCTION, 22); // navigate
design.addCommand(0, ZRF.FUNCTION, 1); // empty?
design.addCommand(0, ZRF.FUNCTION, 20); // verify
design.addCommand(0, ZRF.IN_ZONE, 0); // promotion
design.addCommand(0, ZRF.IF, 4);
design.addCommand(0, ZRF.MODE, 0); // jump-type
design.addCommand(0, ZRF.FUNCTION, 25); // to
design.addCommand(0, ZRF.JUMP, 3);
design.addCommand(0, ZRF.PROMOTE, 1); // King
design.addCommand(0, ZRF.FUNCTION, 25); // to
design.addCommand(0, ZRF.FUNCTION, 28); // end
...
design.addPriority(0); // jump-type
design.addPriority(1); // normal-type
design.addPiece("Man", 0, 1);
design.addMove(0, 0, [3, 3], 0);
design.addMove(0, 0, [0, 0], 0);
design.addMove(0, 0, [1, 1], 0);
design.addMove(0, 1, [3], 1);
design.addMove(0, 1, [0], 1);
design.addMove(0, 1, [1], 1);
...
design.setup("White", "Man", 48);
design.setup("White", "Man", 49);
...
}
```
Весь этот код генерируется из [zrf](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/checkers/turkish-dama.zrf)-файла автоматически и трогать его не надо. На что здесь стоит обратить внимание? Вызовы **addPlayer** определяют игроков и, в простейшем случае, очерёдность их ходов (на второй аргумент функции пока отвлекаться не будем). Функция **addPosition** определяет единичную позицию на доске, а **addDirection** — направление. В самом конце, вызовами **setup** задаётся начальная расстановка фигур.
Позиции и направления — это просто два линейных массива, индексируемых с нуля. Таким образом, положение фигуры на доске всегда определяется целым не отрицательным числом. Такое числовое значение, в любой момент, можно превратить в имя позиции, используя функцию **Dagaz.Model.posToString**. Обратное преобразование выполняет **Dagaz.Model.stringToPos**.
С направлениями немного сложнее. Также как и позиции, они кодируются целыми не отрицательными числами (в соответствии с порядком вызова **addDirection** при конфигурировании дизайна игры). Получить код направления из имени можно использовав метод **getDirection** объекта design. Метод **allDirections** позволяет получить массив всех доступных направлений (для получения списка всех позиций имеется аналогичный метод **allPositions**). Но что такое само направление?
Помните второй аргумент **addPosition**? Фактически, это массив смещений внутри линейного списка всех позиций, по одному для каждого направления. Если соответствующее значение равно нулю, двигаться в указанном направлении из этой позиции запрещено (нет такого направления). Сама навигация осуществляется следующим методом:
```
ZrfDesign.prototype.navigate = function(player, pos, dir) {
if (!_.isUndefined(this.players[player])) {
dir = this.players[player][dir];
}
if (this.positions[pos][dir] != 0) {
return + pos + this.positions[pos][dir];
} else {
return null;
}
}
```
Как видите, достаточно просто прибавить смещение к индексу позиции или вернуть null, если такое перемещение запрещено. Все перемещения должны формулироваться в «системе координат» первого игрока. Это означает, что например в Шахматах, чёрные пешки, также как и белые движутся «на север». За правильную перекодировку направлений отвечает второй аргумент метода **addPlayer**.
Осталось рассказать об игровых зонах. Это просто списки «особых» позиций на доске, определяемые методом **addZone**. Зоны индивидуальны для каждого игрока. Это означает, что одна и та же (по имени) зона, для разных игроков, может содержать различные позиции. Для проверки нахождения позиции в заданной зоне используется метод **inZone**. Все определения перечисленных функций можно найти в исходном тексте модуля [zrf-model.js](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/model/zrf-model.js)
Таким образом, у нас есть дизайн, не изменяемый в процессе игры, и набор игровых состояний, кодирующих расстановку фигур, на момент начала каждого хода, но возникает законный вопрос:
**Как изменять игровое состояние?**
Вообще говоря, никак, потому что изменять его непосредственно вы никогда не должны! Конечно, в [zrf-model](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/model/zrf-model.js) имеется метод **setPiece**, позволяющий поместить фигуру на доску, но вызывать его напрямую не надо! Игровое состояние иммутабельно. Новое состояние создаётся из старого применением к нему хода (объекта типа ZrfMove), методом **apply**.
Откуда берутся эти самые ходы? Они генерируются самим игровым состоянием при вызове метода **generate**. При этом, дизайн и расширения игры следят за тем, чтобы в список сформированных ходов попали только ходы, допустимые правилами игры! Также как и игровое состояние, ходы не должны изменяться разработчиком бота непосредственно, но можно в любой момент, выполнить генерацию допустимых ходов, получить новое состояние игры, применив ход и, разумеется, **читать** любую информацию, содержащуюся в этих объектах.
Итак, чем нас может порадовать ZrfBoard? Прежде всего, мы всегда можем узнать, чей сейчас ход, обратившись к члену **player** (в отличии от позиций и направлений, игроки в Dagaz индексируются начиная с единицы). Целочисленный член **zSign** содержит значение [zobrist-хэша](https://en.wikipedia.org/wiki/Zobrist_hashing) идентифицирующее расстановку фигур. Метод **getPiece** позволяет получить фигуру, находящуюся по указанной позиции (принимается числовой индекс). Если метод возвращает null, значит опрашиваемая позиция пуста.
Сама фигура (ZrfPiece) содержит два члена: **type** — тип фигуры (числовое значение индексируемое с нуля) и владельца — **player**. Кроме того, объекты ZrfPiece могут содержать значения атрибутов (индексируемые числовыми ключами). Метод **getValue** позволяет получить такое значение, указав индекс. Как обычно, null означает отсутствие искомого значения. Допускается хранение значений как строкового, так и числового типов.
Осталось разобраться с ходами (ZrfMove). Это самая сложная часть. Во многих играх, таких как Шахматы и Шашки, допускаются «сложные» ходы, включающие в себя одновременное перемещение нескольких фигур, последовательное взятие фигур, одну за другой и т.п. Поскольку ход переводит игру из одного непротиворечивого состояние в другое, все эти действия кодируются в рамках **одного** хода и применяются атомарно (всё или ничего).
Последовательность всех выполняемых действий содержится в массиве **actions**. Каждое элементарное действие представляет собой четырёхэлементный массив, содержащий следующие элементы:
0 — **Массив** начальных позиций перемещения
1 — **Массив** конечных позиций перемещения
2 — **Массив** фигур (объектов типа ZrfPiece) помещаемых на доску
3 — Целое **число**, содержащее номер частичного хода, в рамках составного
Каждый из перечисленных массивов, обычно состоит из одного элемента. Массивы большего размера используются редко, для недетерминированных ходов, применяемых в некоторых играх. Номер частичного хода определяет очерёдность выполнения действий. Если для двух действий это значение одинаково, они выполняются одновременно. В противном случае, первым выполняется действие с меньшим номером частичного хода. Используются три разновидности действий:
1. Взятие фигуры — нулевой элемент заполнен, первый элемент содержит null
2. Сброс (добавление фигуры на доску) — нулевой элемент равен null, заполнены первый и второй элементы
3. Перемещение — заполнены нулевой и первый элементы, также может быть заполнен второй элемент (если фигура превращается в процессе выполнения хода)
Метод **toString** позволяет получить текстовое описание (нотацию) хода. Иногда это здорово помогает в процессе отладки.
Вся игра представляет собой, по сути, повторяющийся цикл, состоящий из генерации допустимых ходов и последующего применения их к игровому состоянию. Итерации повторяются (с чередованием ходов игроков, заданным правилами игры) до тех пор, пока не произойдёт одно из следующих событий.
1. Список ходов, сгенерированных одним из игроков, оказывается пуст (в зависимости от игры, это может расцениваться как поражение, ничья или даже победа игрока)
2. Функция **Dagaz.Model.checkGoals** возвращает значение, отличное от null
Второй пункт позволяет запрограммировать корректное завершение для практически любой игры.
**Вот, например, как это выглядит для Reversi**
```
var isValid = function(design, board, player, pos) {
for (var dir = 0; dir < design.dirs.length; dir++) {
var p = design.navigate(player, pos, dir);
if (p === null) continue;
var piece = board.getPiece(p);
if ((piece === null) || (piece.player == player)) continue;
while (p !== null) {
p = design.navigate(player, p, dir);
if (p !== null) {
piece = board.getPiece(p);
if (piece === null) break;
if (piece.player == player) return true;
}
}
}
return false;
}
var checkGoals = Dagaz.Model.checkGoals;
Dagaz.Model.checkGoals = function(design, board, player) {
var fc = 0; var ec = 0;
var positions = [];
_.each(design.allPositions(), function(pos) {
var piece = board.getPiece(pos);
if (piece === null) {
positions.push(pos);
} else {
if (piece.player == player) {
fc++;
} else {
ec++;
}
}
});
var f = true;
_.each(positions, function(pos) {
if (f) {
if (isValid(design, board, player, pos)) f = false;
if (isValid(design, board, design.nextPlayer(player), pos)) f = false;
}
});
if (f) {
if (fc == ec) return 0;
if (fc > ec) {
return 1;
} else {
return -1;
}
}
return checkGoals(design, board, player);
}
```
Обратите внимание на функцию **isValid**. При помощи неё, определяется наличие разрешённых правилами игры ходов и только в том случае, если ни один из игроков не может сделать такой ход, определяется победитель (просто тот игрок, у которого больше фигур на доске).
Функция **checkGoals** — неотъемлемая часть дизайна игры. На момент разработки бота, она уже определена и вполне достаточно просто уметь её вызывать, для корректного определения позиций, завершающих игру. Функция может быть вызвана для любого игрового состояния и принимает три аргумента: дизайн игры, текущее состояние игры и идентификатор игрока, с точки зрения которого оценивается позиция. Результат вызова интерпретируется следующим образом:
**1** — победа игрока **player**
**-1** — поражение игрока **player**
**0** — ничья
**null** — не терминальная позиция (игра может быть продолжена)
Ещё одна важная вещь, о которой необходимо знать, до того как приступать к разработке каких либо ботов — это оценочная функция. Я уже довольно подробно [писал](https://habrahabr.ru/post/349516/) об этом раньше, но ещё раз повторюсь. Задачей оценочной функции является числовая оценка позиции, с точки зрения одного из игроков (чем больше значение — тем лучше позиция).
**Вот как она может выглядеть**
```
Dagaz.AI.eval = function(design, params, board, player) {
var r = 0;
_.each(design.allPositions(), function(pos) {
var piece = board.getPiece(pos);
if (piece !== null) {
var v = design.price[piece.type];
if (piece.player != player) {
v = -v;
}
r += v;
}
});
return r;
}
```
Обычно (но не обязательно) оценка позиции, с точки зрения одного из игроков, совпадает с оценкой той же позиции его противником, взятой с противоположным знаком. Без соблюдения этого условия не будут работать, например, [минимаксные алгоритмы](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D1%8C%D1%84%D0%B0-%D0%B1%D0%B5%D1%82%D0%B0-%D0%BE%D1%82%D1%81%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D0%B5). Существуют игры (например те, в которых участвует [более двух игроков](https://glukkazan.github.io/shogi/yonin-shogi.htm)), в которых соблюсти это условие не представляется возможным. Также, есть игры, в которых использование минимакса затруднительно, по другим причинам (например, сложная очерёдность передачи хода).
[](https://glukkazan.github.io/stalemate/virus-wars.htm)
В этих случаях, на первый план выходят эвристики (при использовании минимакса они тоже очень полезны, поскольку позволяют предварительно отсортировать возможные ходы по их потенциальной «силе»). В отличии от оценочной функции, эвристика оценивает сам ход, а не позицию на доске после его выполнения. Эвристика может быть как очень [сложной](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/other-games/virus-wars-extension.js), так и максимально простой.
**Такой, например**
```
Dagaz.AI.heuristic = function(ai, design, board, move) {
return move.actions.length;
}
```
В тибетской игре "[Минг-Манг](https://glukkazan.github.io/custodian/ming-mang-small.htm)", чем больше мы берём фигур противника за ход, тем лучше. Поскольку ход в «Минг-Манг» состоит из перемещения своей фигуры и произвольного количества взятий, для того, чтобы получить хорошую эвристику, достаточно просто оценить количество элементов в массиве **move.actions** (о структуре хода в Dagaz я рассказывал выше).
Далеко не для всех игр построить качественную оценочную функцию бывает легко. В особенно сложных случаях хорошо помогают «маленькие хитрости». Про «покрытие», очень полезное в играх шахматного типа, я уже писал [ранее](https://habrahabr.ru/post/349516/). Другой возможностью является хранение вспомогательных значений в атрибутах фигур.
[](https://glukkazan.github.io/renju/renju.htm)
В "[Рендзю](https://www.gambler.ru/%D0%A0%D1%8D%D0%BD%D0%B4%D0%B7%D1%8E)" наиболее важным аспектом является наличие на доске «троек» и «четвёрок», ориентированных по четырём различным направлениям. Эта информация используется не только AI, но и для выявления ситуаций всевозможных «фолов» (длинных рядов и «вилок»), запрещённых для первого игрока, а также для определения завершения игры (5 камней «в ряд»). Между тем, поиск таких конфигураций на доске — задача довольно таки ресурсоёмкая.
С другой стороны, если мы уже храним счётчики с длинами рядов, для всех ранее поставленных на доску камней, задача обновления этих счётчиков, при добавлении нового камня, становится [тривиальной](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/renju-family/renju-extension.js). Чуть более сложен (но вполне [реализуем](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/go-family/go-extension.js)) подсчёт количества "[дамэ](http://go-igo.ru/dictionary-go/dame.html)" для групп камней, в играх семейства "[Го](https://ru.wikipedia.org/wiki/%D0%93%D0%BE)". В любом случае, гораздо проще хранить эти значения, чем вычислять снова и снова, каждый раз, когда они понадобятся. Конечно, эти мелочи, сами по себе, не превратят бота в [AlphaGo](https://ru.wikipedia.org/wiki/AlphaGo), но могут сделать его разработку гораздо более комфортной.
Вот мы и подошли к разговору о ботах. Задача бота, в Dagaz — выбор наилучшего (в каком-то смысле) хода из списка всех допустимых ходов, сгенерированных игровым состоянием. Вот как выглядит самый простой бот:
**random-ai.js**
```
(function() {
function RandomAi(params) {
this.params = params;
if (_.isUndefined(this.params.rand)) {
this.params.rand = _.random;
}
}
var findBot = Dagaz.AI.findBot;
Dagaz.AI.findBot = function(type, params, parent) {
if ((type == "random") || (type == "solver")) {
return new RandomAi(params);
} else {
return findBot(type, params, parent);
}
}
RandomAi.prototype.setContext = function(ctx, board) {
ctx.board = board;
}
RandomAi.prototype.getMove = function(ctx) {
var moves = Dagaz.AI.generate(ctx, ctx.board);
if (moves.length == 0) {
return { done: true, ai: "nothing" };
}
if (moves.length == 1) {
return { done: true, move: moves[0], ai: "once" };
}
var ix = this.params.rand(0, moves.length - 1);
return {
done: true,
move: moves[ix],
ai: "random"
};
}
})();
```
Да-да, просто выбор случайного хода из всех доступных. Кстати, не надо думать, что это совершенно бесполезный бот. У него есть свои, очень важные, применения.
Уже по этому листингу можно понять следующее:
1. Любой бот должен «встроиться» в цепочку вызовов **Dagaz.AI.findBot** (для того, чтобы [контроллер](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/app-v2.js) смог его найти. Поиск бота осуществляется по его типу. Основных типов три: **«opening»**, **«common»** и **«random»**. Найденные боты также выстраиваются «в цепочку». Это делается для того, чтобы первым наилучший ход искал бот, предназначенный для дебютов ([sgf-ai](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/ai/sgf-ai-v2.js), например), вслед за ним отрабатывал главный бот ([maxmin-ai](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/ai/maxmin-ai-v2.js), в большинстве случаев), а уж если он ничего не нашёл (счёл все ходы слишком плохими), в игру включался [random-ai](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/ai/random-ai.js), просто чтобы сходить хотя бы как нибудь. Для решения головоломок используется специальный тип бота "**solver**".
2. Для каждого игрока, с которым работает бот, создаётся свой «контекст» (это делается для того, чтобы один бот мог обслуживать одновременно несколько различных игроков). Внутри контекста можно хранить любые данные, разделяемые между последовательными обращениями к боту (например, дерево состояний игры). Перед запросом у бота «наилучшего» хода, контроллер передаёт боту текущее состояние игры (вызовом метода **setContext**).
3. Ход у бота запрашивается методом **getMove**. Метод возвращает хэш, содержащий поле **move** (искомый ход). Также, если бот завершил поиск хода, он должен передать **true** в поле **done** возвращаемого хэша. В настоящее время эта функциональность не используется, но подразумевается, что контроллер может запросить у бота ход несколько раз подряд. В случае, если бот не успел найти наилучший ход за отведённое время, он может вернуть лучший ход из уже рассмотренных, но не устанавливать поле **done**, чтобы контроллер продолжил опрос.
Посмотрим на чуть более сложный бот:
**heuristic-ai.js**
```
(function() {
Dagaz.AI.NOISE_FACTOR = 10;
function Ai(params, parent) {
this.params = params;
this.parent = parent;
if (_.isUndefined(this.params.NOISE_FACTOR)) {
this.params.NOISE_FACTOR = Dagaz.AI.NOISE_FACTOR;
}
}
var findBot = Dagaz.AI.findBot;
Dagaz.AI.findBot = function(type, params, parent) {
if ((type == "heuristic") || (type == "common") || (type == "1") || (type == "2")) {
return new Ai(params, parent);
} else {
return findBot(type, params, parent);
}
}
Ai.prototype.setContext = function(ctx, board) {
if (this.parent) {
this.parent.setContext(ctx, board);
}
ctx.board = board;
ctx.timestamp = Date.now();
}
Ai.prototype.getMove = function(ctx) {
ctx.board.moves = Dagaz.AI.generate(ctx, ctx.board);
if (ctx.board.moves.length == 0) {
return { done: true, ai: "nothing" };
}
var nodes = _.chain(ctx.board.moves)
.map(function(m) {
return {
move: m,
weight: Dagaz.AI.heuristic(this, ctx.design, ctx.board, m)
};
}, this)
.filter(function(n) {
return n.weight >= 0;
}).value();
if (this.params.NOISE_FACTOR > 1) {
_.each(nodes, function(n) {
n.weight *= this.params.NOISE_FACTOR;
n.weight += _.random(0, this.params.NOISE_FACTOR - 1);
}, this);
}
if (nodes.length > 0) {
nodes = _.sortBy(nodes, function(n) {
return -n.weight;
});
return {
done: true,
move: nodes[0].move,
time: Date.now() - ctx.timestamp,
ai: "heuristic"
};
}
if (this.parent) {
return this.parent.getMove(ctx);
}
}
})();
```
Это не столько «искусственный интеллект», сколько «искусственные инстинкты». Просто выбор хода с максимальной эвристикой, без какого бы ты ни было использования оценочной функции. Этот бот быстр и прозрачен в отладке, но на этом его достоинства заканчиваются. Глубину его интеллекта вы можете оценить по текущему уровню игры "[Рендзю](https://glukkazan.github.io/renju/renju.htm)", "[Войны вирусов](https://glukkazan.github.io/stalemate/virus-wars.htm)" и особенно "[Атари Го](https://glukkazan.github.io/go/atari-go.htm)". В идеале, хотелось бы добиться нормальной работы чего нибудь вроде [этого](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/ai/ab-ai-v3.js) (моя реализация минимакса с альфа-бета отсечением пока что, увы, не работающая).
Говоря об отладке ботов, стоит отметить, что дело это кропотливое, нудное и к особому веселью не располагающее. Любой инструмент облегчающий этот процесс безусловно стоит использовать. В первую очередь это касается модуля [common-setup](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/model/common-setup-v2.js). Достаточно добавить его в список загружаемых скриптов и в логе (как включить лог в браузере, думаю объяснять не надо), после выполнения каждого хода, начнут появляться записи примерно такого вида:
```
Setup: ?setup=+19;0:1=4;+2;0:1=4;+5;0:2=3;+7;0:1=2;0:2=5;+7;0:2=5;+29;
```
Добавив эту запись к адресной строки браузера (вот [так](https://glukkazan.github.io/go/atari-go-board.htm?setup=+19;0:1=4;+2;0:1=4;+5;0:2=3;+7;0:1=2;0:2=5;+7;0:2=5;+29;)) можно воссоздать соответствующую позицию немедленно, без нудного воспроизведения предшествующих ходов. А при некоторой сноровке, можно навостриться читать эту нотацию и даже редактировать её непосредственно в адресной строке.
Другая полезная возможность предоставляется контроллером. Если в htm-файле заменить [app-v2](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/app-v2.js) на [app-auto](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/app-auto.js), можно заставить ботов сражаться друг с другом, не отвлекаясь на кликанье по доске мышью. Помните странные числовые типы ботов в **heuristic-ai.js**?
```
...
Dagaz.AI.findBot = function(type, params, parent) {
if ((type == "heuristic") || (type == "common") ||
(type == "1") || (type == "2")) {
return new Ai(params, parent);
} else {
return findBot(type, params, parent);
}
}
...
```
Бот с типом "**1**" будет загружаться для первого игрока, а с типом "**2**" для второго. Это конечно не **autoplay** из [Axiom](http://zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1452), но тоже штука весьма полезная. Кроме того, в отличии от **autoplay**, только двумя игроками **app-auto** не ограничивается.
Модуль [debug-ai](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/kernel/controller/ai/debug-ai.js) ещё один полезный инструмент, который стоит взять на вооружение. Иногда, при отладке логики игры, бывает недостаточно просто воспроизвести позицию. В таких случаях, бывает необходимо, чтобы бот воспроизводил ходы по заданному списку и **debug-ai** умеет это делать. Именно с его помощью я отлаживал "[Апокалипсис](https://glukkazan.github.io/elimination/apocalypse.htm)".
Ну вот, в общем-то и вся премудрость. Как я уже сказал, дело нудное, но не сверхъестественное. И я буду рад, если в этом деле ко мне кто нибудь присоединиться. Кстати, буквально два дня назад на почту проекта пришло первое письмо. Garrick Wells здорово помог мне с [дебютами](https://github.com/GlukKazan/Dagaz/blob/master/src/debug/games/shogi-family/data/micro-shogi.txt) для [Micro Shogi](https://glukkazan.github.io/shogi/micro-shogi.htm). Попутно, я обнаружил и [исправил](https://github.com/GlukKazan/Dagaz/commit/55235fdaab840198c26e89c45a01255b6b69c98e) серьёзный баг, затронувший эту и несколько других игр. Это именно та форма сотрудничества, к которой я стремлюсь. | https://habr.com/ru/post/353116/ | null | ru | null |
# Шпаргалки по безопасности: Nodejs
Довольно много уже было сказано о популярности NodeJS. Рост количества приложений очевиден – NodeJS довольно прост в освоении, имеет огромное количество библиотек, а также динамично развивающуюся экосистему.
Мы подготовили [**рекомендации для NodeJS разработчиков**](https://cheatsheetseries.owasp.org/cheatsheets/Nodejs_security_cheat_sheet.html), основываясь на OWASP Cheat Sheets, которые помогут вам предусмотреть проблемы с безопасностью при разработке приложений.
**Рекомендации к безопасности NodeJS приложений можно разделить на следующие категории:**
* Безопасность при разработке приложения;
* Безопасность сервера;
* Безопасность платформы;
Безопасность при разработке приложения
--------------------------------------
**Избегайте callback hell**
Использование функций обратных вызовов (коллбэков) — одна из самых сильных сторон NodeJS, однако при вложенности коллбэков можно легко забыть обработать ошибку в одной из функций. Один из способов избежать callback hell — использование промисов. Даже если используемый вами модуль не поддерживает работу с промисами, вы всегда можете использовать Promise.promisifyAll(). Но даже используя промисы, стоит обращать внимание на вложенность. Чтобы полностью избежать ошибки callback hell придерживайтесь «плоской» цепочки промисов.
*Пример callback hell:*
```
function func1(name, callback) {
setTimeout(function() {
// operations
}, 500);
}
function func2(name, callback) {
setTimeout(function() {
// operations
}, 100);
}
function func3(name, callback) {
setTimeout(function() {
// operations
}, 900);
}
function func4(name, callback) {
setTimeout(function() {
// operations
}, 3000);
}
func1("input1", function(err, result1){
if(err){
// error operations
}
else {
//some operations
func2("input2", function(err, result2){
if(err){
//error operations
}
else{
//some operations
func3("input3", function(err, result3){
if(err){
//error operations
}
else{
// some operations
func4("input 4", function(err, result4){
if(err){
// error operations
}
else {
// some operations
}
});
}
});
}
});
}
});
```
*Тот же код, с использованием плоской цепочки промисов:*
```
function func1(name, callback) {
setTimeout(function() {
// operations
}, 500);
}
function func2(name, callback) {
setTimeout(function() {
// operations
}, 100);
}
function func3(name, callback) {
setTimeout(function() {
// operations
}, 900);
}
function func4(name, callback) {
setTimeout(function() {
// operations
}, 3000);
}
func1("input1")
.then(function (result){
return func2("input2");
})
.then(function (result){
return func3("input3");
})
.then(function (result){
return func4("input4");
})
.catch(function (error) {
// error operations
});
```
**Ограничивайте размер запроса**
Разбор тела запроса может оказаться довольно ресурсоемкой операцией. Если не ограничивать размер запроса, злоумышленники смогут отправлять достаточно большие запросы, способные заполнить все дисковое пространство или исчерпать все ресурсы сервера, но в то же время ограничение размера запроса для всех случаев может быть некорректным, так как существуют запросы, как например загрузка файла. Поэтому рекомендуется устанавливать ограничения для разных типов контента. Например, с помощью фреймфорка express это можно реализовать следующим образом:
```
app.use(express.urlencoded({ limit: "1kb" }));
app.use(express.json({ limit: "1kb" }));
app.use(express.multipart({ limit:"10mb" }));
```
Следует заметить, что злоумышленник может изменить тип содержимого запроса и обойти ограничения, поэтому необходимо проверять соответствие содержимого запроса на соответствие типу контента, указанному в заголовке запроса. Если проверка типа содержимого влияет на производительность, то можно проверять только определенные типы или запросы, размер которых превышает определенный размер.
**Не блокируйте event loop**
Важная составляющая языка — event loop, который как раз и позволяет переключать контекст выполнения, не дожидаясь окончания выполнения операции. Однако существуют блокирующие операции, окончания выполнения которых NodeJS приходится дожидаться, прежде чем продолжить выполнение кода. Например, большинство синхронных методов относятся к блокирующим:
```
const fs = require('fs');
fs.unlinkSync('/file.txt');
```
Рекомендуется выполнять подобные операции асинхронно:
```
const fs = require('fs');
fs.unlink('/file.txt', (err) => {
if (err) throw err;
});
```
При этом не забывайте, что код, стоящий после асинхронного вызова будет выполнен, не дожидаясь окончания выполнения предыдущей операции.
Например, в коде, приведенном ниже, файл удалится до того, как он будет прочтен, что может привести к race condition.
```
const fs = require('fs');
fs.readFile('/file.txt', (err, data) => {
// perform actions on file content
});
fs.unlinkSync('/file.txt');
```
Чтобы избежать этого, можно записать все операции в неблокирующую функцию:
```
const fs = require('fs');
fs.readFile('/file.txt', (err, data) => {
// perform actions on file content
fs.unlink('/file.txt', (err) => {
if (err) throw err;
});
});
```
**Проверяйте поля ввода**
Проверка полей ввода — важная часть безопасности любого приложения. Ошибки проверки могут привести к тому, что ваше приложение станет уязвимым сразу для множества типов атак: sql-инъекции, xss, command injection и другим. Чтобы упростить проверку форм можно воспользоваться пакетами validator, mongo-express-sanitize.
**Экранируйте пользовательские данные**
Одно из правил, выполнение которого поможет вам защититься от xss атак — экранирование пользовательских данных. Для этого можно воспользоваться библиотекой escape-html или node-esapi.
**Ведите логи**
Кроме того, что это поможет при отладке ошибок, логирование может использоваться для реагирования на инциденты. Подробнее о необходимости логирования вы можете почитать **[тут](https://acribia.ru/articles/journaling)**. Одни из самых популярных пакетов для логирования в NodeJS — Winston и Bunyan. В примере ниже показано как с помощью Winston выводить логи как в консоль, так и в файл:
```
var logger = new (Winston.Logger) ({
transports: [
new (winston.transports.Console)(),
new (winston.transports.File)({ filename: 'application.log' })
],
level: 'verbose'
});
```
**Контролируйте цикл событий**
Если ваш сервер находится в условиях интенсивного сетевого трафика, пользователи могу испытывать сложности с доступностью вашего сервиса. По сути, это атака типа DoS. В таком случае вы можете отслеживать время отклика и, если оно превышает заданное, отправлять сообщение 503 Server Too Busy. Помочь в этом может модуль toobusy-js.
Пример использования модуля:
```
var toobusy = require('toobusy-js');
var express = require('express');
var app = express();
app.use(function(req, res, next) {
if (toobusy()) {
// log if you see necessary
res.send(503, "Server Too Busy");
} else {
next();
}
});
```
**Примите меры предосторожности против брут-форса**
Опять же на помощь приходят модули. Например, express-brute или express-bouncer. Пример использования:
```
var bouncer = require('express-bouncer');
bouncer.whitelist.push('127.0.0.1'); // whitelist an IP address
// give a custom error message
bouncer.blocked = function (req, res, next, remaining) {
res.send(429, "Too many requests have been made. Please wait " + remaining/1000 + " seconds.");
};
// route to protect
app.post("/login", bouncer.block, function(req, res) {
if (LoginFailed){ }
else {
bouncer.reset( req );
}
});
```
Использование CAPTCHA является еще одним распространенным механизмом противодействия брут-форсу. Часто используемый модуль, помогающий реализовать CAPTCHA — svg-captcha.
**Используйте CSRF токены**
Один из самых надежных способов защиты от CSRF атак — использование CSRF токена. Токен должен быть сгенерирован с высокой энтропией, строго проверяться и быть привязанным к сеансу пользователя. Для обеспечения работы CSRF токена можно воспользоваться модулем csurf.
Пример использования:
```
var csrf = require('csurf');
csrfProtection = csrf({ cookie: true });
app.get('/form', csrfProtection, function(req, res) {
res.render('send', { csrfToken: req.csrfToken() })
})
app.post('/process', parseForm, csrfProtection, function(req, res) {
res.send('data is being processed');
});
```
Не забудьте добавить токен в скрытое поле на странице:
Более подробно о CSRF токенах можно прочесть в нашей [**статье**](https://habr.com/ru/company/acribia/blog/476880/).
**Удаляйте ненужные роуты**
Веб-приложение не должно содержать страниц, которые не используются пользователями, поскольку это может увеличить поверхность атаки. Поэтому все неиспользуемые API роуты должны быть отключены. Особенно стоит обратить внимание на этот вопрос, если вы используете фреймфорки Sails или Feathers, поскольку они автоматически генерируют API эндпоинты.
**Защититесь от HPP (HTTP Parameter Pollution)**
По умолчанию express складывает все параметры из запроса в массив. OWASP рекомендует использовать модуль hpp, который игнорирует все значения параметров из req.query и/или req.body и просто выбирает последнее значение среди повторяющихся.
```
var hpp = require('hpp');
app.use(hpp());
```
**Контролируйте возвращаемые значения**
К примеру, в таблице пользователей могут храниться важные данные: пароль, адрес электронной почты, дата рождения и т.д. Поэтому важно возвращать только необходимые данные.
Например:
```
exports.sanitizeUser = function(user) {
return {
id: user.id,
username: user.username,
fullName: user.fullName
};
};
```
**Используйте дескрипторы**
С помощью дескрипторов можно описать поведение свойства для различных операций: writable — можно ли менять значение свойства, enumerable — можно ли использовать свойство в цикле for..in, configurable — можно ли перезаписывать свойство. Рекомендуется обращать внимание на перечисленные свойства, так как при определении свойства объекта все эти атрибуты имеют значение true по умолчанию. Изменить значение свойств можно следующим образом:
```
var o = {};
Object.defineProperty(o, "a", {
writable: true,
enumerable: true,
configurable: true,
value: "A"
});
```
**Используйте ACL**
Для разграничения доступа к данным с учетом ролей может помочь модуль acl. Например, добавление разрешения выглядит следующим образом:
```
// guest is allowed to view blogs
acl.allow('guest', 'blogs', 'view')
// allow function accepts arrays as any parameter
acl.allow('member', 'blogs', ['edit', 'view', 'delete'])
```
**Отлавливайте uncaughtException**
По умолчанию, в случае неперехваченного исключения NodeJS выведет текущий stack trace и завершит поток выполнения. Однако NodeJS позволяет настроить это поведение. В случае появления неперехваченного исключения генерируется событие uncaughtException, которое можно отловить с помощью объекта process:
```
process.on("uncaughtException", function(err) {
// clean up allocated resources
// log necessary error details to log files
process.exit(); // exit the process to avoid unknown state
});
```
Стоит помнить, что при возникновении uncaughtException необходимо очистить все выделенные ресурсы (например, файловые дескрипторы и хэндлеры) перед завершением Z процесса, чтобы избежать возникновения непредвиденных ошибок. Настоятельно не рекомендуется продолжать работу программы в случае возникновения uncaughtException.
Также при отображении сообщений об ошибках пользователю не следует раскрывать подробную информацию об ошибке, такую как stack trace.
Безопасность сервера
--------------------
**Устанавливайте флаги для заголовков при работе с куками**
Есть несколько флагов, использование которых поможет защититься от таких атак как xss и csrf: httpOnly, запрещающий доступ к кукам посредством javascript; Secure — позволяет отправку куки только по HTTPS и SameSite, определяющий возможность передачи куки стороннему ресурсу.
Пример использования:
```
var session = require('express-session');
app.use(session({
secret: 'your-secret-key',
key: 'cookieName',
cookie: { secure: true, httpOnly: true, path: '/user', sameSite: true}
}));
```
**Устанавливайте HTTP-заголовки для обеспечения безопасности**
Ниже приведены заголовки и примеры их подключения, которые помогут вам защититься от ряда распространённых атак. Установка заголовков выполняется с помощью модуля helmet
• Strict-Transport-Security: HTTP Strict Transport Security (HSTS) сообщает браузеру о том, что приложение может быть доступно только по HTTPS
```
app.use(helmet.hsts()); // default configuration
app.use(helmet.hsts("", "")); // custom configuration
```
• X-Frame-Options: определяет, может ли страница использоваться в frame, iframe, embed или object
```
app.use(hemlet.xframe()); // default behavior (DENY)
helmet.xframe('sameorigin'); // SAMEORIGIN
helmet.xframe('allow-from', 'http://alloweduri.com'); //ALLOW-FROM uri
```
• X-XSS-Protection: позволяет браузеру прекращать загрузку страницы, если он обнаружил отраженную XSS атаку.
```
var xssFilter = require('x-xss-protection');
app.use(xssFilter());
```
• X-Content-Type-Options: используется для предотвращения атаки с использованием MIME типов
```
app.use(helmet.noSniff());
```
• Content-Security-Policy: позволяет предотвращать такие атаки как XSS и атаки внедрения данных
```
const csp = require('helmet-csp')
app.use(csp({
directives: {
defaultSrc: ["'self'"], // default value for all directives that are absent
scriptSrc: ["'self'"], // helps prevent XSS attacks
frameAncestors: ["'none'"], // helps prevent Clickjacking attacks
imgSrc: ["'self'", "'http://imgexample.com'"],
styleSrc: ["'none'"]
}
}))
```
• Cache-Control и Pragma: для управления кэшированием, особенно этот заголовок может быть полезен для страниц, которые содержат конфиденциальные данные. Однако стоит помнить, что отключение кэширования на всех страницах может сказаться на производительности
```
app.use(helmet.noCache());
```
• X-Download-Options: заголовок запрещает Inter Explorer исполнять скаченные файлы
```
app.use(helmet.ieNoOpen());
```
• Expect-CT: Certificate Transparency — механизм, созданный, чтобы решить некоторые проблемы с инфраструктурой SSL сертификатов, данный заголовок сообщает браузеру о необходимости дополнительной проверки сертификата в логах CT
```
var expectCt = require('expect-ct');
app.use(expectCt({ maxAge: 123 }));
app.use(expectCt({ enforce: true, maxAge: 123 }));
app.use(expectCt({ enforce: true, maxAge: 123, reportUri: 'http://example.com'}));
```
• X-Powered-By: необязательный заголовок, который используется, чтобы указать технологию, используемую на сервере. Скрыть данный заголовок можно следующим образом:
```
app.use(helmet.hidePoweredBy());
```
Кроме того, можно подменить значение, чтобы скрыть реальную информацию об используемых вами технологиях:
```
app.use(helmet.hidePoweredBy({ setTo: 'PHP 4.2.0' }));
```
Безопасность платформы
----------------------
**Обновляйте ваши пакеты**
Безопасность вашего приложения зависит в том числе и от безопасности используемых вами пакетов, поэтому важно пользоваться последней версией пакета. Чтобы убедиться, что используемый вами пакет не содержит известных уязвимостей можно воспользоваться [**специальным списком OWASP**](https://jeremylong.github.io/DependencyCheck/analyzers/nodejs.html). Также можно воспользоваться библиотекой, выполняющей проверку пакетов на известные уязвимости Retire.js.
**Не используйте небезопасные функции**
Существуют функции, от использования которых по возможности рекомендуется отказаться. Среди таких функций — eval(), исполняющая принимаемую в качестве аргумента строку. В сочетании с пользовательским вводом использование этой функции может привести к уязвимости удаленного выполнения кода, так как по схожим причинам использование child\_process.exec также является небезопасным, так как функция передает принятые аргументы в bin/sh.
Кроме того, существует ряд модулей, пользоваться которыми стоит с осторожностью. Например, модуль fs для работы с файлами. Если определенным образом сформированный пользовательский ввод подать в функцию, то ваше приложение может стать уязвимым к включению локального файла и directory traversal.
Модуль vm, предоставляющий API для компиляции и запуска кода на виртуальной машинеV8, стоит использовать только в песочнице.
[**Здесь**](https://cheatsheetseries.owasp.org/cheatsheets/Nodejs_security_cheat_sheet.html) можно ознакомиться с другими функциями, которые могут сделать ваше приложение небезопасным
**Будьте осторожны, используя регулярные выражения**
Регулярное выражение может быть написано так, что можно добиться ситуации, когда время работы выражения будет расти экспоненциально, что может привести к отказу в обслуживании. Подобные атаки называются ReDoS. Есть несколько инструментов, позволяющих проверить, является ли безопасным регулярные выражение, одно из таких — vuln-regex-detector.
**Периодически запускайте линтеры**
Во время разработки тяжело удерживать в голове все рекомендации по обеспечению безопасности, а если речь идет о командной разработке, непросто добиться соблюдения правил всеми членами команды. Для таких целей и существуют инструменты для статического анализа безопасности. Такие инструменты, не выполняя ваш код ищут в нем уязвимости. Кроме того, линтеры позволяют добавлять пользовательские правила поиска мест в коде, которые могут быть уязвимы. Самые часто используемые линтеры — ESLint и JSHint.
**Используйте strict mode**
Javascript имеет ряд небезопасных и устаревших функций, которые не должны использоваться. Чтобы исключить возможность использования этих функций и предусмотрен strict mode.
**Придерживайтесь общих принципов безопасности**
В описанных рекомендациях основной упор делается на NodeJS, но не стоит забывать про общие принципы безопасности, которые необходимо соблюдать независимо от используемой платформы. | https://habr.com/ru/post/493714/ | null | ru | null |
# Скорости разработки и исполнения, не достижимые на С
В продолжении [статьи](http://habrahabr.ru/post/182356/) о кроссплатформенной и кросс-аппаратной оптимизации, на примере задачи поиска полным проходом по таблице из 5 полей и 10 000 000 строк, и неизбежности этой задачи даже при индексном поиске, я покажу как ускорить такой поиск в **3.5-5.3** раза с использованием **C++** независимо от аппаратной платформы.
В предыдущей статье нам удалось ускорить поиск в 1.3 раза: [GitHub.com](https://github.com/AlexeyAB/cpp_find_order/blob/06a80340ff403c4693bfe0ff8b80584f029c71a3/main.cpp)
Мы не будем банально описывать конструкции языка, а покажем преимущества C++ при решении одного из этапов реальной задачи.
Мы по-прежнему пишем кроссплатформенно под MSVC11(MSVS2012) и GCC 4.7.2, и используем в них C и частично реализованный стандарт C++11.
Для упрощения понимания мы все ещё пишем без индексного поиска, но это решение в дальнейшем будет использоваться при индексном поиске.
#### 1. Hardcore-ное решение на C++
Действительно хардкорным решением это выглядело бы на C. Это потому, что к несчастью для C-разработчиков, вам придется создать 3840 функций и нигде в них не ошибиться. Пока C-разработчики их пишут, мы отнесемся к ним с большим уважением, а я покажу, как эти 3840 функции может написать за вас компилятор C++. Сделает он это не быстро, но на порядки быстрее и точнее, чем их напишут C-разработчики.
Все очень просто, в теории СУБД есть такое понятие, как селективность предиката (`selectivity`) – процент подходящих строк таблицы по одному из условий(предиката). Чем меньше селективность условия, тем раньше по нему надо сравнивать, и тем раньше мы поймем, что строка не подходит. Т.е. избавимся от сравнений по следующим условиям.
В реальных СУБД для этого оптимизатором собирается статистика и подбирается нужная формула для расчета селективности в зависимости от графика распределения данных. Думаю, дискретной математики и комбинаторики с перебором полей на сегодня вам достаточно, поэтому для простоты мы будем считать селективность по кардинальности из расчета равномерного распределения данных. (Кардинальность колонки (cardinality) – процент уникальных значений в колонке.)
Селективность (количество строк) будет равна:
`selectivity = c_array_size * (1 + field.end – field.begin) / cardinality;`
Размер массива и кардинальность для равномерно распределенных данных нам известна на этапе компиляции. А границы условий поиска для каждого поля мы получаем во время исполнения и рассчитываем селективность.
Затем выбираем поля в порядке возрастания селективности начиная с наименьшей. И в зависимости от порядка выбранных номеров полей, мы формируем числовой индекс наиболее оптимальной функции, которую затем вызываем для поиска.
Оптимизированные функции на каждый вариант условий поиска, а точнее полиморфные классы, мы генерируем двумя вложенными раскрутками шаблонов:
1. Перебор всех вариантов наличия условий поиска (как это было в [предыдущем решении на C++](http://habrahabr.ru/post/182356/))
2. Перебор всех вариантов порядка условий поиска
Итого создается и заполняется массив из `(2^5)*5! = 32*120 = 3840` объектов с разной реализацией, но с общим базовым абстрактным предком.
Проверки диапазона на больше и меньше для одного поля идут всегда вместе. Переставлять независимо или менять местами проверку минимального и максимального значений для одного поля мы пока не будем, чтобы не затягивать время компиляции.
Теперь разберем, как будет выглядеть код.
#### 2. Уменьшение зависимостей
Сначала для реализации нашего решения придется реализовать доступ к полям строки через шаблонные compile-time-геттеры. Это так же добавит приятный бонус – уменьшение зависимостей – теперь любые изменения типов и числа полей в коде будут затрагивать только структуру строки `T_cash_account_row.`
Сам интерфейс нашего поискового класса будет оставаться неизменным, а реализация поиска по произвольной таблице будет осуществляться инстанцированием шаблонного поискового класса.
Так будет выглядеть код структуры строки с полями:
```
/* Row */
struct T_cash_account_row {
// Fields:
enum T_field_enum { amount_of_money_e, gender_e, age_e, code_e, height_e, /*<<<<<- add fields here (with index) */
last_e /*<<<<<- add included fields here (without index) */
};
static_assert(last_e > 0, "Number of indexed fields in enum of T_cash_account_row must be greater than 0!");
unsigned code:20; // 0 - 1000000
unsigned gender:1; // 0 - 1
unsigned age:7; // 0 - 100
unsigned amount_of_money:20; // 0 - 1000000
unsigned height:9; // 0 – 300
// Get field value
template inline
typename std::enable\_if::type get\_field\_value() const { return code; }
template inline
typename std::enable\_if::type get\_field\_value() const { return gender; }
template inline
typename std::enable\_if::type get\_field\_value() const { return age; }
template inline
typename std::enable\_if::type get\_field\_value() const { return amount\_of\_money; }
template inline
typename std::enable\_if::type get\_field\_value() const { return height; }
template inline
typename std::enable\_if::type get\_field\_value() const { return true; }
static\_assert(5 == last\_e, "Add/delete new field-case and correct this assert!");
};
/\* ----------------------------------------------------------------------- \*/
```
Перечисления `enum T_field_enum` по умолчанию всегда имеют значения в порядке возрастания начиная с 0 ([C++03 7.2 Enumeration declarations](https://code.google.com/p/openassist/downloads/detail?name=C%2B%2B%20Standard%20-%20ANSI%20ISO%20IEC%2014882%202003.pdf)).
Шаблон `std::enable_if<>` из библиотеки `#include` позволяет получать экземпляры функций/классов только для определенных значений параметра шаблона. В противном случае происходит ошибка подстановки при инстанцировании, и по принципу [SFINAE (substitution-failure-is-not-an-error)](http://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error#cite_note-1) – при ошибке подстановки ошибка компиляции не возникает, а экземпляр функции просто не создается. Подробней в стандарте ([С++03 14.8.2 Template argument deduction](https://code.google.com/p/openassist/downloads/detail?name=C%2B%2B%20Standard%20-%20ANSI%20ISO%20IEC%2014882%202003.pdf)).
Это необходимо для обращения через параметры шаблона геттера к нужным полям разного типа, например так:
`auto code = row->get_field_value();`
В нашем случае все 5 полей имеют одинаковый тип и можно было бы обойтись без `std::enable_if<>`, но мы же думаем наперёд. В моем примере вы можете изменить тип любого из 5 полей и геттеры отлично скомпилируются и сработают. Допустим, если бы мы сделали их через специализации шаблонной функции, то получали бы ошибки при обращении к разным типам, например такой код не скомпилируется:
```
/* Row */
struct T_cash_account_row {
// Fields:
enum T_field_enum { amount_of_money_e, gender_e, age_e, code_e, height_e, /*<<<<<- add fields here (with index) */
last_e /*<<<<<- add included fields here (without index) */
};
static_assert(last_e > 0, "Number of indexed fields in enum of T_user_row must be greater than 0!");
unsigned code:20; // 0 - 1000000
unsigned gender:1; // 0 - 1
unsigned age:7; // 0 - 100
unsigned amount_of_money:20; // 0 - 1000000
int height; // 0 – 300
// Get field value
template inline unsigned get\_field\_value();
template inline int get\_field\_value();
static\_assert(5 == last\_e, "Add/delete new field-case and correct this assert!");
};
template<> inline unsigned T\_cash\_account\_row::get\_field\_value() { return code; }
template<> inline unsigned T\_cash\_account\_row::get\_field\_value() { return gender; }
template<> inline unsigned T\_cash\_account\_row::get\_field\_value() { return age; }
template<> inline unsigned T\_cash\_account\_row::get\_field\_value() { return amount\_of\_money; }
template<> inline int T\_cash\_account\_row::get\_field\_value() { return height; }
template<> inline unsigned T\_cash\_account\_row::get\_field\_value() { return 1; }
/\* ----------------------------------------------------------------------- \*/
int main() {
T\_cash\_account\_row \*row = new T\_cash\_account\_row;
auto code = row->get\_field\_value();
return 0;
}
```
Компилятор естественно выдаст ошибку о не однозначном вызове функции `get_field_value<>()`. [Ideone.com](http://ideone.com/QgW7tH)
Наш же вариант отлично скомпилируется: [ideone.com](http://ideone.com/9yahUB)
С геттерами разобрались, теперь применим раскрутку шаблонов (unrolling of template) похожую на раскрутку из прошлой статьи, но не для конструктора, а для функтора (функтор – это класс с перегруженным оператором вызова `operator()(…)`):
```
// The templated functor of unrolling of the input templated functor (reusable)
template class T>
struct T\_unroll\_functor {
T\_unroll\_functor next\_unroll;
T functor;
template inline bool operator()(T1 const& val1, T2 const& val2) {
return next\_unroll(val1, val2) && functor(val1, val2);
}
};
// End of unroll
template class T>
struct T\_unroll\_functor<0, T> {
template inline bool operator()(T1 const&, T2 const&) { return true; }
};
// -------------------------------------------------------------------------
```
Такой раскруткой мы развернем сравнения для каждого поля, основываясь на значении перечисления `last_e` и доступе к полям через наши шаблонные геттеры.
А разворачивать будем функтор `struct T_test_pred` следующим образом:
```
// The filters for each search variant (range_filters)
template
struct T\_custom\_filter : T\_filter {
// Test predicates functor for unrolling
template
struct T\_test\_pred {
bool inline operator()(T\_row \*const \_\_restrict row, T\_range\_filters \*const \_\_restrict range\_filters) const
{
typedef typename T\_row::T\_field\_enum T\_field\_enum;
// Without fields where use\_filter==0
return ( T\_filter::template T\_get\_use\_filter::value ||
(row->template get\_field\_value(field\_num)>() >=
range\_filters->begin.template get\_field\_value(field\_num)>()&&
row->template get\_field\_value(field\_num)>() <=
range\_filters->end.template get\_field\_value(field\_num)>())
);
}
};
// -----------------------------------------------------------------------
// search
virtual size\_t search(T\_row \*const \_\_restrict array\_ptr, const size\_t c\_array\_size, T\_row \*const \_\_restrict result\_ptr, T\_range\_filters \*const \_\_restrict range\_filters) final
{
size\_t result\_size = 0;
size\_t i; // loop index
T\_unroll\_functor test\_predicate;
for(i = 0; i < c\_array\_size; ++i) {
if(test\_predicate(array\_ptr + i, range\_filters))
result\_ptr[result\_size] = array\_ptr[i], ++result\_size;
}
return result\_size;
}
};
// -------------------------------------------------------------------------
```
Замечу ещё, что теперь в классах `T_filter<>, T_custom_filter<> и T_optimized_search<>` появился параметр шаблона `T_row`, в который передается тип строки таблицы – в нашем случае `T_cash_account_row`.
Теперь все изменения количества, названий и типов полей таблицы сосредоточены исключительно внутри `T_cash_account_row`, а весь код поиска генерируется автоматически из шаблонных классов, достаточно только инстанцировать шаблон типом нужной строки:
`T_optimized_search optimized\_search; // C++ optimized search`
Вот ссылка на получившийся рабочий код: [GitHub.com](https://github.com/AlexeyAB/cpp_find_order/blob/5a99194666e8e72cca1cdfbe8652a9026191be0e/main.cpp)
В этом примере наглядно показано почему в критически важных участках кода team-lead и performance-architect должен уделять внимание не только внешним интерфейсам модулей, но и типам объектов передаваемых через эти интерфейсы. В нашем случае это: `T_cash_account_row и T_range_filters`. Задав возможность в `T_cash_account_row` передавать параметры через шаблонные геттеры, мы предопределяем более гибкую реализацию разработчиком модуля через раскрутку шаблонов, а так же более гибкую реализацию тестов при использовании техники разработки через тестирование TDD, что я покажу в следующей статье.
На компиляторе MSVC11(MSVS2012) и одном ядре CPU Core i5 K750 результат такой:
> Generated rows: 10000000
>
> C++-Searching…
>
> C++-optimized search took 0.056000 seconds.
>
> Found rows: 38
>
> C-Searching…
>
> C-search took 0.074000 seconds.
>
> The C++ faster than C: 1.321429 times
>
> Found rows: 38
Как видим, код на C++ по прежнему быстрее в 1.3 раза, чем код на C. Получаемый ассемблерный код функции `test_predicate` по прежнему идентичен предыдущему варианту на C++, [test\_pradicate\_enum\_cpp.asm](https://github.com/AlexeyAB/cpp_find_order/tree/7d0e5d577cafe6ec840475e64f8e8121dcee1379/msvc11_disasm).
«Картинка disasm из TortoiseDiff»
Но теперь мы сосредоточили все изменения в одном месте, что значительно облегчит использование этого модуля поиска.
Кроме того, мы подготовили код к другой, ещё более производительной оптимизации.
#### 3. Ускорение в 3.5 – 5.3 раза
Достаточно часто встречаются статьи по C++, где рассматриваются compile-time вычисления или например [поиск простых чисел на шаблонах.](http://habrahabr.ru/post/124476/) Статьи интересные, но как замечают сами авторы: «я расскажу, как сделать совершенно бесполезную вещь».
Я же расскажу, как получить заметное ускорение поиска от compile-time вычислений и оптимизаций с использованием шаблонов.
##### 3.1 Простые вычисления на шаблонах
Начнем с самого простого из нужного нам, реализуем compile-time вычисление факториала:
```
template
struct factorial : std::integral\_constant::value> {};
template <> struct factorial<0> : std::integral\_constant {};
```
Вычисление факториала нам понадобиться для создания статичного массива `std::array<>` с числом элементов равным `(2^5)*5! = 3840`.
Из дискретной математики и комбинаторики известно, что число различных перестановок уникальных элементов равно факториалу их количества. А число вариантов наличия элементов равно 2 в степени количества элементов. (Конечно, нам абсолютно не важно, как переставлены отсутствующие элементы, и отсутствие лишних вариантов могло бы ускорить компиляцию, но я пытаюсь как можно сильнее упростить эту статью.)
Теперь посмотрим какие оптимизации будут внутри структуры
`struct T_custom_filter` при её инстанцировании.
Во-первых, она теперь ещё принимает параметр `index_order`. А во-вторых в ней изменился поисковый раскручиваемый функтор.
```
// The filters for each search variant (range_filters)
template
struct T\_custom\_filter : T\_filter {
// Test predicates functor for unrolling
template
struct T\_test\_pred {
bool inline operator()(T\_row \*const \_\_restrict row, T\_range\_filters \*const \_\_restrict range\_filters) const
{
typedef typename T\_row::T\_field\_enum T\_field\_enum;
// Without fields where use\_filter==0
enum { ordered\_field\_number = T\_filter::template T\_number\_field::value };
return ( T\_filter::template T\_get\_use\_filter::value ||
(row->template get\_field\_value(ordered\_field\_number)>() >=
range\_filters->begin.template get\_field\_value(ordered\_field\_number)>() &&
row->template get\_field\_value(ordered\_field\_number)>() <=
range\_filters->end.template get\_field\_value(ordered\_field\_number)>())
);
}
};
// -----------------------------------------------------------------------
// search
virtual size\_t search(T\_row \*const \_\_restrict array\_ptr, const size\_t c\_array\_size, T\_row \*const \_\_restrict result\_ptr, T\_range\_filters \*const \_\_restrict range\_filters) final;
};
// -------------------------------------------------------------------------
```
Как и прежде, шаблон `T_get_use_filter` возвращает флаг использования (или не использования) фильтра по полю `number_filter` для данного индекса index\_pred.
```
// whether to use the filter for a given predicate? (strictly at compile time)
template
struct T\_get\_use\_filter : std::integral\_constant {};
```
Из шаблона `T_number_field<>` на основании `index_order` – индекса порядка сравнения полей и порядкового номера поля `field_num`, мы получаем номер поля `ordered_field_number` для получения его значения из геттера `get_field_value(ordered\_field\_number)>()`.
##### 3.2 Более сложные вычисления на шаблонах
Теперь сложнее. Реализуем вычисление порядка поля в шаблонном классе `T_number_field<>`. Индекс порядка полей `index_order` формируется следующим образом – например, индекс для 5 полей составляется по следующей формуле:
`index_order = field0 + 5*field1 + 5*4*field2 + 5*4*3*field3 + 5*4*3*2*field4;`
где `field1` – номер поля от 0 до 4-их (из 5-ти имеющихся), идущий первым при сравнении; field2 – номер поля от 0 до 3 (из 4-ех оставшихся), идущий вторым при сравнении; …; а field5 – номер поля от 0 до 0 (из 1-го оставшегося) идущий последним, т.к. он всегда 0, то его можно опустить:
`index_order = field0 + 5*field1 + 5*4*field2 + 5*4*3*field3;`
или, что тоже самое:
`index_order = field0 + 5*(field1 + 4*(field2 + 3*(field3)));`
Кому-то возможно будет легче представить значение index\_order, как число с переменной основой системы исчисления, где `field0` – первая цифра с основой 5 (может принимать 5 значений 0-4), в `field1` – вторая цифра с основой 4 (может принимать 4 значения 0-3), и так далее. Таким образом в (5!) комбинаций мы можем закодировать любые перестановки полей. Для лучшего понимания желательно ознакомиться с основами теории вероятности или перебором из дискретной математики.
Визуально это можно изобразить так: круглыми скобками () обозначаем наименьшее значение приоритета из имеющихся (наиболее приоритетное), квадратным [] – его номер из имеющихся, а фигурными {} – реальный номер поля. Например, изначально имеем 5 полей с такими приоритетами: 5, 3, 1, 2, 4
```
Номер поля: 0 1 2 3 4
Приоритет сравнения:5 3 (1) 2 4 - [2] – текущий номер поля (field0) {2}
Приоритет сравнения:5 3 (2) 4 - [2] – текущий номер поля (field1) {3}
Приоритет сравнения:5 (3) 4 - [1] – текущий номер поля (field2) {1}
Приоритет сравнения:5 (4) - [1] – текущий номер поля (field3) {4}
Приоритет сравнения:(5) - [0] – текущий номер поля (field4) {0}
```
Подставив числа в: `index_order = field0 + 5*(field1 + 4*(field2 + 3*(field3)));`
Мы получаем значение индекса: `index_order = 2 + 5*(2 + 4*(1 + 3*(1))) = 92;`
Позже мы покажем, как это реализуется в run-time функции `T_optimized_search::get_index_order().`
Сейчас же, в результате раскрутки этот индекс нам известен на этапе компиляции, и стоит обратная задача, как из него получить порядковый номер для каждого поля в compile-time.
Сначала научимся получать числа стоящие в квадратных скобках []. В нашем конкретном случае «текущие номера полей» находятся следующим образом, для полученного нами `index_order = 2 + 5*(2 + 4*(1 + 3*(1))) = 92`:
```
field0 = index_order % 5 = 92 % 5 = 2;
field1 = (index_order/5) % 4 = (92/5) % 4 = 2;
field2 = (index_order/(5*4)) % 3 = (92/5*4) % 3 = 1;
field3 = (index_order/(5*4*3)) % 2 = (92/5*4*3) % 2 = 1;
field4 = 0;
```
В compile-time это делает следующий шаблонный класс:
```
// Get the sequence number the remaining field for the number_filter, after removal of all previous
template
struct T\_number\_remaining\_field : std::integral\_constant::value> {};
// End of unroll
template
struct T\_number\_remaining\_field : std::integral\_constant {};
// -------------------------------------------------------------------------
```
И получаем значение «текущего номера поля» равного number\_filter, инстанцированием шаблона таким образом `T_number_remaining_field::value`.
Здесь есть момент, где некоторые могут запутаться: кто-то может подумать, что при (`number_filter=0`), т.е. `T_number_remaining_field::value` сразу вызывается частичная специализация с двумя параметрами:
`template struct T\_number\_remaining\_field`
Где `index_order` подставится в `index_order`, а 0 подставится в `index`. Но это не так!
По стандарту ([С++03 14.8.2 Template argument deduction](https://code.google.com/p/openassist/downloads/detail?name=C%2B%2B%20Standard%20-%20ANSI%20ISO%20IEC%2014882%202003.pdf)), сначала из общего шаблона подставляются значения по умолчанию `index = T_row::last_e` и фактически наше инстанцирование превращается в `T_number_remaining_field::value`. А затем уже идет обращение к специализации:
`template struct T\_number\_remaining\_field`
И для нулевого текущего номера поля из 5 полей (`T_row::last_e=5`) получаем `index_order % 5`, что и требовалось.
Мы реализовали способ нахождения «текущих номеров полей» тех, что в квадратных скобках. Теперь нам нужно реализовать получение реальных номеров полей тех, что в фигурных скобках {}.
Как мы видели из нашего визуального представления, «текущие номера полей» в квадратных скобках [] не всегда совпадают с реальными номерами полей в фигурных скобках {}. Если представить колоду пронумерованных карт лежащих в порядке возрастания снизу-вверх, то изначально их номера будут совпадать с их порядок в колоде. Но вынимая карты из середины, у тех карт, что лежат выше них, каждый раз будет уменьшаться на единицу порядковый номер в колоде относительно их реального номера.
В нашем случае это при водит к тому, что все поля имеющие меньший реальный номер {} и меньшее значение приоритета () (более приоритетное, которые раньше изымаются), уменьшают на единицу «текущее значение поля» [], чей реальный номер и значение приоритета больше. Такие смещения и рассчитывают следующие шаблонные классы:
```
// Get 1 or 0 offset if current_field (for number_filter) affect to number_field
template
struct T\_offset {
enum { current\_field = T\_number\_remaining\_field::value,
value = (current\_field <= number\_field)?1:0 };
};
// Get offset of number\_field (enum in row-type) for number\_filter
template
struct T\_offset\_number\_field {
enum { offset = T\_offset::value,
value = T\_offset\_number\_field::value + offset };
};
// End of unroll
template
struct T\_offset\_number\_field : std::integral\_constant {};
```
И наконец, реальные номера полей мы получаем следующим шаблонным классом:
```
// (Main) Get number of field (enum in row-type) for number_filter
template
struct T\_number\_field {
enum { remaining\_field = T\_number\_remaining\_field::value,
value = remaining\_field + T\_offset\_number\_field::value };
};
// -------------------------------------------------------------------------
```
Готово.
##### 3.3 Вложенная раскрутка шаблонов
Теперь нам надо инстанцировать шаблон фильтра `T_custom_filter<>` по наличию полей поиска и по их порядку. Для этого мы применим вложенную раскрутку шаблонов:
```
template
class T\_optimized\_search {
// unroll tamplates
template
struct T\_unroll\_find {
template
struct T\_unroll\_order {
template T\_unroll\_order(T &filters) {
filters[index\_pred + index\_order\*(1<() );
}
};
T\_unroll\_constructor::value, T\_unroll\_order> fill\_ordered\_filter;
template T\_unroll\_find(T &filters) : fill\_ordered\_filter(filters)
{}
};
// -------------------------------------------------------------------------
std::array>, (1<::value> filters;
T\_unroll\_constructor< 1< fill\_filter;
public:
T\_optimized\_search() : fill\_filter(filters) {}
// C++ optimized search
inline size\_t search(T\_row \*const \_\_restrict array\_ptr, const size\_t c\_array\_size,
T\_row \*const \_\_restrict result\_ptr, T\_range\_filters \*const \_\_restrict range\_filters)
{
auto const& filter = filters[T\_filter::get\_index\_pred(range\_filters) +
T\_filter::get\_index\_order(range\_filters)\*(1<search(array\_ptr, c\_array\_size, result\_ptr, range\_filters);
}
};
// -------------------------------------------------------------------------
```
Здесь мы использовали compile-time раскрутку наличия сравнения полей `struct T_unroll_find<>`, а внутри неё использовали раскрутку порядка сравнения полей `struct T_unroll_order<>`.
А в поисковой функции мы используем run-time функции `get_index_pred()` – получения индекса в зависимости от необходимости сравнения полей, и функции `get_index_order()` – получения индекса в зависимости от необходимого порядка сравнения полей.
Первая функция осталась той же:
```
// Get index of T_test_pred version for current search range
static inline const unsigned get_index_pred(T_range_filters *const __restrict range_filters) {
unsigned result = 0;
for(size_t i = 0; i < T_row::last_e; ++i)
result |= range_filters->use_filter[i]?(1<
```
И добавилась вторая `get_index_order()`. Сначала уточню, что в структуре строки `struct T_cash_account_row` появилась функция `get_bitf_size()` – получения кардинальности (именно в такой форме, а не через switch/case, она может выступать как constexpr, т.е. вычисляемой compile-time, но MSVC11 это пока не поддерживает):
```
/* Row */
struct T_cash_account_row {
...
// Get cardinality
template
// constexpr // not supported in the MSVS2012(MVCC11)
static inline const unsigned int get\_bitf\_size() {
return (field\_enum == gender\_e)? 1:
(field\_enum == age\_e)? 100:
(field\_enum == height\_e)? 300:
(field\_enum == code\_e)? 1000000:
(field\_enum == amount\_of\_money\_e)?1000000:
0;
static\_assert(5 == last\_e, "Add/delete new field-case and correct this assert!");
}
};
```
И ещё раз напомню формулу селективности (количество строк):
`selectivity = c_array_size * (1 + field.end – field.begin) / cardinality;`
А теперь и сама функция получения индекса в зависимости от порядка сравнения полей, использующая шаблонную раскрутку конструктора для вычисления селективности для каждого условия/поля:
```
// The unrolling filling of selectivity in a compile-time
template
struct T\_selectivity\_fill {
T\_selectivity\_fill(std::map \*const \_\_restrict ordered\_filters, T\_range\_filters \*const \_\_restrict range\_filters)
{
// selectivity for each field-filter
const unsigned selectivity = range\_filters->use\_filter[field\_num]?
((1 +
range\_filters->end.template get\_field\_value() -
range\_filters->begin.template get\_field\_value() )\*c\_array\_size /
T\_row::template get\_bitf\_size()) // cardinality
:c\_array\_size;
ordered\_filters->insert(std::make\_pair(field\_num, selectivity));
}
};
// Get index of T\_test\_pred version for current search range
static inline const unsigned get\_index\_order(
T\_range\_filters \*const \_\_restrict range\_filters)
{
unsigned result = 0;
std::map ordered\_filters;
T\_unroll\_constructor selectivity\_fill(&ordered\_filters, range\_filters);
unsigned multiplexor = 1;
for(size\_t i = 0; i < T\_row::last\_e; ++i) {
unsigned cur\_index = 0, min\_index = 0;
unsigned field\_num = ordered\_filters.cbegin()->first;
unsigned min = c\_array\_size;
for(auto const& it : ordered\_filters) {
if (it.second < min)
min = it.second, field\_num = it.first, min\_index = cur\_index;
++cur\_index;
}
ordered\_filters.erase(field\_num);
result += min\_index\*multiplexor;
multiplexor \*= (T\_row::last\_e - i);
}
return result;
}
// -------------------------------------------------------------------------
```
Здесь ключ в `std::map<>` заполняется номерами полей, а значение заполняется предполагаемой селективностью. Затем в цикле находим минимальную селективность, берем из ключа соответствующий номер поля, по нему удаляем запись из `std::map<>`, и используем этот номер поля для составления индекса. И так в цикле для каждого поля. Мы уже описывали как получается этот индекс, возвращаемый функцией `get_index_order`, математически:
`index_order = field1 + 5*(field2 + 4*(field3 + 3*(field4)));`
Так мы смогли раскрутить поисковый шаблон `3840` раз, заполнить этими объектами статичный массив и получить в run-time индекс необходимого объекта с оптимизированной функцией поиска, для данных условий поиска.
Получаемый ассемблерный код функции `test_predicate` изменился по сравнению с предыдущим вариантом на C++ – два сравнения поменялись местами, первое из них теперь идет последним: [github.com asm](https://github.com/AlexeyAB/cpp_find_order/tree/7d0e5d577cafe6ec840475e64f8e8121dcee1379/msvc11_disasm).
«Картинка из TortoiseDiff»
#### 4. Результаты тестов
Вот полностью рабочий вариант этого решения на C++: [GitHub.com](https://github.com/AlexeyAB/cpp_find_order/blob/ba568e1f9652ae106d4e50f978ff074269d16bc9/main.cpp)
На GCC4.7.2 с ключом –O3 –march=native, CPU Core i5 K750 и размером exe-файла в 1.3МБ результат такой:
> Generated rows: 10000000
>
> C++-Searching…
>
> C++-optimized search took 0.017000 seconds.
>
> Found rows: 38
>
> C-Searching…
>
> C-search took 0.090000 seconds.
>
> The C++ faster than C: 5.294118 times
>
> Found rows: 38
А на MSVC11(MSVS2012) с ключом /O2 /Ob2 /Oi, CPU Core i5 K750 и размером exe-файла в 1.42МБ результат такой:
> Generated rows: 10000000
>
> C++-Searching…
>
> C++-optimized search took 0.021000 seconds.
>
> Found rows: 38
>
> C-Searching…
>
> C-search took 0.074000 seconds.
>
> The C++ faster than C: 3.523809 times
>
> Found rows: 38
Как мы видим, время исполнения упало с 74мс на C, до 21мс на C++, т.е. скорость выросла в **3.5 раза**. Отлично. И как видно GCC показывает ещё более заметную разницу в скорости, в **5.3 раза**. И это абсолютно кросс-аппаратное решение, в отличие от SIMD-инструкций и cache-prefetch. В отличие от [PGO](http://habrahabr.ru/post/138132/), который создает один оптимизированный путь исполнения программы, мы создали 3840 путей оптимизированных на все случаи входных данных.
Может быть это решение вам покажется сложным, зато теперь понятно, что значит действительно знать C++. Если вы не знаете хорошо C++ то у вас остается единственная альтернатива – писать на C.
Чтобы развеять сомнения, что это можно решить на C через массив указателей на функции, приведу пример. Т.к. я знаю, что хорошей оптимизации на C в данном случае не получится, то я не буду реализовывать механизм вычисления селективности и перестановки условий, а просто руками оптимально поменяю функции местами при заполнении массива указателей.
Вот рабочий вариант этого решения на C: [GitHub.com](https://github.com/AlexeyAB/cpp_find_order/blob/ba568e1f9652ae106d4e50f978ff074269d16bc9/main.cpp)
Чем он отличается от примера с C-оптимизацией из прошлой статьи можете посмотреть в diff с предыдущей версией: [GitHub.com](https://github.com/AlexeyAB/cpp_find_order/commit/ba568e1f9652ae106d4e50f978ff074269d16bc9#diff-0)
На GCC4.7.2 с ключом –O3 –march=native, CPU Core i5 K750 результат такой:
> Generated rows: 10000000
>
> C-optimized-Searching…
>
> C-optimized-search took 0.049000 seconds.
>
> Found rows: 38
>
> C-Searching…
>
> C-search took 0.086000 seconds.
>
> The C++ faster than C: 1.755102 times
>
> Found rows: 38
А на MSVC11 с ключом /O2 /Ob2 /Oi, CPU Core i5 K750 результат такой:
> Generated rows: 10000000
>
> C-optimized-Searching…
>
> C-optimized-search took 0.045000 seconds.
>
> Found rows: 38
>
> C-Searching…
>
> C-search took 0.074000 seconds.
>
> The C++ faster than C: 1.644444 times
>
> Found rows: 38
Как мы видим результат с оптимизацией на C отстает от нашей оптимизации на C++ более чем в **2 — 3 раза**.
Ускорение на GCC на C в **1.8** раза против **5.3** раза на C++, и ускорение на MSVC на C в **1.6** раза против **3.5** раза на C++. Причем оптимизация на C легко компилируется компилятором C++ без единого изменения, но не наоборот.
#### 5. Заключение
Я показал, как с помощью C++–шаблонов реализовать вычисления и кросс-аппаратную оптимизацию во время компиляции для получения ускорения в **3.5-5.3** раза для реальной задачи.
Нет таких оптимизаций в C, которые бы нельзя было применить в C++, т.к. имеется почти полная обратная совместимость. А вот в C – единственная альтернатива C++–шаблонам для подобных оптимизаций – это писать десятки, сотни и тысячи функций – вот уж где действительно copy-paste.
Напомню, что эта оптимизация не применима в Java и C#, т.к. в generics невозможно в параметрах использовать значения, а возможно только типы. Java и C# имеют другие преимущества – это развитые библиотеки и защита от глупых ошибок.
В следующих статьях я опишу наиболее подходящий для данной задачи вариант индексного поиска, почему здесь не подойдут мульти-индексные соединения Index Hash Join и Bitmap AND, а необходимо применять Index Organized Tables и стратегию доступа к данным Index Only Scan. Опишу недостатки бинарного поиска, и почему в нашем случае подойдет упорядоченный хэш-индекс. Добьемся скорости от 0.15 до 3.6 миллиона запросов в секунду на одном ядре Core i5 K750, а затем покажем, как это реализуется в многопоточном варианте со слабым конкурентным доступом и редкими изменениями. Ускорим этот поиск на GPU и покажем почему будущее за многопоточным паттерном – distributed states, с одним барьером памяти на группу записей. Затем вплотную подойдем к задаче поиска в высоконагруженном web-проекте и сравним его реализации с использованием FastCGI и boost::asio. Но не все сразу. | https://habr.com/ru/post/182428/ | null | ru | null |
# Перехват функций в ядре Linux с помощью ftrace
[](https://en3l.deviantart.com/art/Ninja-penguin-207123041)В одном проекте, связанном с безопасностью Linux-систем, нам потребовалось перехватывать вызовы важных функций внутри ядра (вроде открытия файлов и запуска процессов) для обеспечения возможности мониторинга активности в системе и превентивного блокирования деятельности подозрительных процессов.
В процессе разработки нам удалось изобрести довольно неплохой подход, позволяющий удобно перехватить любую функцию в ядре по имени и выполнить свой код вокруг её вызовов. Перехватчик можно устанавливать из загружаемого GPL-модуля, без пересборки ядра. Подход поддерживает ядра версий 3.19+ для архитектуры x86\_64.
(Изображение пингвина чуть выше: [© En3l с DeviantArt](https://en3l.deviantart.com/art/Ninja-penguin-207123041).)
Известные подходы
-----------------
### Linux Security API
Наиболее правильным было бы использование *Linux Security API* — специального интерфейса, созданного именно для этих целей. В критических местах ядерного кода расположены вызовы security-функций, которые в свою очередь вызывают коллбеки, установленные security-модулем. Security-модуль может изучать контекст операции и принимать решение о её разрешении или запрете.
К сожалению, у Linux Security API есть пара важных ограничений:
* security-модули не могут быть загружены динамически, являются частью ядра и требуют его пересборки
* в системе может быть только один security-модуль (с небольшими исключениями)
Если по поводу множественности модулей позиция разработчиков ядра неоднозначная, то запрет на динамическую загрузку принципиальный: security-модуль должен быть частью ядра, чтобы обеспечивать безопасность постоянно, с момента загрузки.
Таким образом, для использования Security API необходимо поставлять собственную сборку ядра, а также интегрировать дополнительный модуль с SELinux или AppArmor, которые используются популярными дистрибутивами. Заказчик на подобные обязательства подписываться не хотел, поэтому этот путь оказался закрыт.
По этим причинам Security API нам не подошёл, иначе он был бы идеальным вариантом.
### Модификация таблицы системных вызовов
Мониторинг требовался в основном для действий, выполняемых пользовательскими приложениями, так что в принципе мог бы быть реализован на уровне системных вызовов. Как известно, Linux хранит все обработчики системных вызовов в таблице `sys_call_table`. Подмена значений в этой таблице приводит к смене поведения всей системы. Таким образом, сохранив старое значения обработчика и подставив в таблицу собственный обработчик, мы можем перехватить любой системный вызов.
У этого подхода есть определённые преимущества:
* **Полный контроль над любыми системными вызовами** — единственным интерфейсом к ядру у пользовательских приложений. Используя его мы можем быть уверены, что не пропустим какое-нибудь важное действие, выполняемое пользовательским процессом.
* **Минимальные накладные расходы.** Есть единоразовые капитальные вложения при обновлении таблицы системных вызовов. Помимо неизбежной полезной нагрузки мониторинга, единственным расходом является лишний вызов функции (для вызова оригинального обработчика системного вызова).
* **Минимальные требования к ядру.** При желании этот подход не требует каких-либо дополнительных конфигурационных опций в ядре, так что в теории поддерживает максимально широкий спектр систем.
Однако, он также страдает от некоторых недостатков:
* **Техническая сложность реализации.** Сама по себе замена указателей в таблице не представляет трудностей. Но сопутствующие задачи требуют неочевидных решений и определённой квалификации:
+ поиск таблицы системных вызовов
+ обход защиты от модификации таблицы
+ атомарное и безопасное выполнение замены
Это всё интересные вещи, но они требуют драгоценного времени разработчиков сначала на реализацию, а затем на поддержку и понимание.
* **Невозможность перехвата некоторых обработчиков.** В ядрах до версии 4.16 обработка системных вызовов для архитектуры x86\_64 содержала целый ряд оптимизаций. Некоторые из них требовали того, что обработчик системного вызова являлся специальным переходничком, реализованным на ассемблере. Соответственно, подобные обработчики порой сложно, а иногда и вовсе невозможно заменить на свои, написанные на Си. Более того, в разных версиях ядра используются разные оптимизации, что добавляет в копилку технических сложностей.
* **Перехватываются только системные вызовы.** Этот подход позволяет заменять обработчики системных вызовов, что ограничивает точки входа только ими. Все дополнительные проверки выполняются либо в начале, либо в конце, и у нас есть лишь аргументы системного вызова и его возвращаемое значение. Иногда это приводит к необходимости дублировать проверки на адекватность аргументов и проверки доступа. Иногда вызывает лишние накладные расходы, когда требуется дважды копировать память пользовательского процесса: если аргумент передаётся через указатель, то его сначала придётся скопировать нам самим, затем оригинальный обработчик скопирует аргумент ещё раз для себя. Кроме того, в некоторых случаях системные вызовы предоставляют слишком низкую гранулярность событий, которые приходится дополнительно фильтровать от шума.
Изначально мы выбрали и успешно реализовали именно этот подход, преследуя выгоды от поддержки наибольшего количества систем. Однако, в то время мы ещё не знали об особенностях x86\_64 и ограничениях на перехватываемые вызовы. Позже для нас оказалась критичной поддержка системных вызовов, связанных с запуском новых процессов — clone() и execve(),— которые как раз являются особенными. Именно это и привело нас к поиску новых вариантов.
### Использование kprobes
Одним из вариантов, которые рассматривались, было использование *kprobes*: специализированного API, в первую очередь предназначенного для отладки и трассирования ядра. Этот интерфейс позволяет устанавливать пред- и постобработчики для *любой инструкции* в ядре, а также обработчики на вход и возврат из функции. Обработчики получают доступ к регистрам и могут их изменять. Таким образом, мы бы могли получить как мониторинг, так и возможность влиять на дальнейший ход работы.
Преимущества, которые даёт использование kprobes для перехвата:
* **Зрелый API.** Kprobes существуют и улучшаются с незапамятных времён (2002 год). Они обладают хорошо задокументированным интерфейсом, большинство подводных камней уже найдено, их работа по возможности оптимизирована, и так далее. В общем, целая гора преимуществ над экспериментальными самописными велосипедами.
* **Перехват любого места в ядре.** Kprobes реализуются с помощью точек останова (инструкции int3), внедряемых в исполнимый код ядра. Это позволяет устанавливать kprobes в буквально любом месте любой функции, если оно известно. Аналогично, kretprobes реализуются через подмену адреса возврата на стеке и позволяют перехватить возврат из любой функции (за исключением тех, которые управление в принципе не возвращают).
Недостатки kprobes:
* **Техническая сложность.** Kprobes — это только способ установить точку останова в любом места ядра. Для получения аргументов функции или значений локальных переменных надо знать, в каких регистрах или где на стеке они лежат, и самостоятельно их оттуда извлекать. Для блокировки вызова функции необходимо вручную модифицировать состояние процесса так, чтобы процессор подумал, что он уже вернул управление из функции.
* **Jprobes объявлены устаревшими.** Jprobes — это надстройка над kprobes, позволяющая удобно перехватывать вызовы функций. Она самостоятельно извлечёт аргументы функции из регистров или стека и вызовет ваш обработчик, который должен иметь ту же сигнатуру, что и перехватываемая функция. Подвох в том, что jprobes объявлены устаревшими и вырезаны из современных ядер.
* **Нетривиальные накладные расходы.** Расстановка точек останова дорогая, но она выполняется единоразово. Точки останова не влияют на остальные функции, однако их обработка относительно недешёвая. К счастью, для архитектуры x86\_64 реализована jump-оптимизация, существенно уменьшающая стоимость kprobes, но она всё ещё остаётся больше, чем, например, при модификации таблицы системных вызовов.
* **Ограничения kretprobes.** Kretprobes реализуются через подмену адреса возврата на стеке. Соответственно, им необходимо где-то хранить оригинальный адрес, чтобы вернуться туда после обработки kretprobe. Адреса хранятся в буфере фиксированного размера. В случае его переполнения, когда в системе выполняется слишком много одновременных вызовов перехваченной функции, kretprobes будет пропускать срабатывания.
* **Отключенное вытеснение.** Так как kprobes основывается на прерываниях и жонглирует регистрами процессора, то для синхронизации все обработчики выполняются с отключенным *вытеснением* (preemption). Это накладывает определённые ограничения на обработчики: в них нельзя ждать — выделять много памяти, заниматься вводом-выводом, спать в таймерах и семафорах, и прочие известные вещи.
В процессе исследования темы наш взгляд упал на фреймворк **ftrace**, способный заменить jprobes. Как оказалось, для наших нужд перехвата вызовов функций он подходит лучше. Однако, если вам необходимо трассирование конкретных инструкций внутри функций, то kprobes не стоит списывать со счетов.
### Сплайсинг
Для полноты картины стоит также описать классический способ перехвата функций, заключающийся в замене инструкций в начале функции на безусловный переход, ведущий в наш обработчик. Оригинальные инструкции переносятся в другое место и исполняются перед переходом обратно в перехваченную функцию. С помощью двух переходов мы вшиваем (splice in) свой дополнительный код в функцию, поэтому такой подход называется *сплайсингом*.
Именно таким образом и реализуется jump-оптимизация для kprobes. Используя сплайсинг можно добиться тех же результатов, но без дополнительных расходов на kprobes и с полным контролем ситуации.
Преимущества сплайсинга очевидны:
* **Минимальные требования к ядру.** Сплайсинг не требует каких-либо особенных опций в ядре и работает в начале любой функции. Нужно только знать её адрес.
* **Минимальные накладные расходы.** Два безусловных перехода — вот и все действия, которые надо выполнить перехваченному коду, чтобы передать управление обработчику и обратно. Подобные переходы отлично предсказываются процессором и являются очень дешёвыми.
Однако, главный недостаток этого подхода серьёзно омрачает картину:
* **Техническая сложность.** Она зашкаливает. Нельзя просто так взять и переписать машинный код. Вот краткий и неполный список задач, которые придётся решить:
+ синхронизация установки и снятия перехвата (что если функцию вызовут прямо в процессе замены её инструкций?)
+ обход защиты на модификацию регионов памяти с кодом
+ инвалидация кешей процессора после замены инструкций
+ дизассемблирование заменяемых инструкций, чтобы скопировать их целыми
+ проверка на отсутствие переходов внутрь заменяемого куска
+ проверка на возможность переместить заменяемый кусок в другое место
Да, можно подсматривать в kprobes и использовать внутриядерный фреймворк livepatch, но итоговое решение всё равно остаётся довольно сложным. Страшно представить, какое количество спящих проблем будет в каждой новой его реализации.
В общем, если вы способны призвать этого демона, подчиняющего только посвящённым, и готовы терпеть его в своём коде, то сплайсинг — это вполне рабочий подход для перехвата вызовов функций. Я негативно относился к написанию велосипедов, поэтому этот вариант оставался для нас резервным на случай, если совсем не будет никакого прогресса с готовыми решениями попроще.
Новый подход с ftrace
---------------------
**Ftrace** — это фреймворк для трассирования ядра на уровне функций. Он разрабатывается с 2008 года и обладает просто фантастическим интерфейсом для пользовательских программ. Ftrace позволяет отслеживать частоту и длительность вызовов функций, отображать графы вызовов, фильтровать интересующие функции по шаблонам, и так далее. О возможностях ftrace можно начать читать [отсюда](https://habr.com/company/selectel/blog/280322/), и дальше по приведённым ссылкам и официальной документации.
Реализуется ftrace на основе ключей компилятора `-pg` и `-mfentry`, которые вставляют в начало каждой функции вызов специальной трассировочной функции mcount() или \_\_fentry\_\_(). Обычно, в пользовательских программах эта возможность компилятора используется профилировщиками, чтобы отслеживать вызовы всех функций. Ядро же использует эти функции для реализации фреймворка ftrace.
Вызывать ftrace из *каждой* функции — это, разумеется, не дёшево, поэтому для популярных архитектур доступна оптимизация: *динамический ftrace*. Суть в том, что ядро знает расположение всех вызовов mcount() или \_\_fentry\_\_() и на ранних этапах загрузки заменяет их машинный код на **nop** — специальную ничего не делающую инструкцию. При включении трассирования в нужные функции вызовы ftrace добавляются обратно. Таким образом, если ftrace не используется, то его влияние на систему минимально.
### Описание нужных функций
Каждую перехватываемую функцию можно описать следующей структурой:
```
/**
* struct ftrace_hook - описывает перехватываемую функцию
*
* @name: имя перехватываемой функции
*
* @function: адрес функции-обёртки, которая будет вызываться вместо
* перехваченной функции
*
* @original: указатель на место, куда следует записать адрес
* перехватываемой функции, заполняется при установке
*
* @address: адрес перехватываемой функции, выясняется при установке
*
* @ops: служебная информация ftrace, инициализируется нулями,
* при установке перехвата будет доинициализирована
*/
struct ftrace_hook {
const char *name;
void *function;
void *original;
unsigned long address;
struct ftrace_ops ops;
};
```
Пользователю необходимо заполнить только первые три поля: name, function, original. Остальные поля считаются деталью реализации. Описание всех перехватываемых функций можно собрать в массив и использовать макросы, чтобы повысить компактность кода:
```
#define HOOK(_name, _function, _original) \
{ \
.name = (_name), \
.function = (_function), \
.original = (_original), \
}
static struct ftrace_hook hooked_functions[] = {
HOOK("sys_clone", fh_sys_clone, ℜ_sys_clone),
HOOK("sys_execve", fh_sys_execve, ℜ_sys_execve),
};
```
Обёртки над перехватываемыми функциями выглядят следующим образом:
```
/*
* Это указатель на оригинальный обработчик системного вызова execve().
* Его можно вызывать из обёртки. Очень важно в точности соблюдать
* сигнатуру функции: порядок и типы аргументов и возвращаемого значения,
* а также спецификаторы ABI (внимание на "asmlinkage").
*/
static asmlinkage long (*real_sys_execve)(const char __user *filename,
const char __user *const __user *argv,
const char __user *const __user *envp);
/*
* Эта функция будет вызываться вместо перехваченной. Её аргументы — это
* аргументы оригинальной функции. Её возвращаемое значение будет передано
* вызывающей функции. Она может выполнять произвольный код до, после
* или вместо оригинальной функции.
*/
static asmlinkage long fh_sys_execve(const char __user *filename,
const char __user *const __user *argv,
const char __user *const __user *envp)
{
long ret;
pr_debug("execve() called: filename=%p argv=%p envp=%p\n",
filename, argv, envp);
ret = real_sys_execve(filename, argv, envp);
pr_debug("execve() returns: %ld\n", ret);
return ret;
}
```
Как видим, перехватываемые функции с минимумом лишнего кода. Единственный момент, требующий тщательного внимания — это сигнатуры функций. Они должны совпадать один к одному. Без этого, очевидно, аргументы будут переданы неправильно и всё пойдёт под откос. Для перехвата системных вызовов это важно в меньшей степени, так как их обработчики очень стабильные и для эффективности аргументы принимают в том же порядке, что и сами системные вызовы. Однако, если вы планируете перехватывать другие функции, то следует помнить о том, что [внутри ядра стабильных интерфейсов нет](https://dri.freedesktop.org/docs/drm/process/stable-api-nonsense.html).
### Инициализация ftrace
Для начала нам потребуется найти и сохранить адрес функции, которую мы будем перехватывать. Ftrace позволяет трассировать функции по имени, но нам всё равно надо знать адрес оригинальной функции, чтобы вызывать её.
Добыть адрес можно с помощью *kallsyms* — списка всех символов в ядре. В этот список входят *все* символы, не только экспортируемые для модулей. Получение адреса перехватываемой функции выглядит примерно так:
```
static int resolve_hook_address(struct ftrace_hook *hook)
{
hook->address = kallsyms_lookup_name(hook->name);
if (!hook->address) {
pr_debug("unresolved symbol: %s\n", hook->name);
return -ENOENT;
}
*((unsigned long*) hook->original) = hook->address;
return 0;
}
```
Дальше необходимо инициализировать структуру `ftrace_ops`. В ней обязательным
полем является лишь *func*, указывающая на коллбек, но нам также необходимо
установить некоторые важные флаги:
```
int fh_install_hook(struct ftrace_hook *hook)
{
int err;
err = resolve_hook_address(hook);
if (err)
return err;
hook->ops.func = fh_ftrace_thunk;
hook->ops.flags = FTRACE_OPS_FL_SAVE_REGS
| FTRACE_OPS_FL_IPMODIFY;
/* ... */
}
```
*fh\_ftrace\_thunk*() — это наш коллбек, который ftrace будет вызывать при трассировании функции. О нём позже. Флаги, которые мы устанавливаем, будут необходимы для выполнения перехвата. Они предписывают ftrace сохранить и восстановить регистры процессора, содержимое которых мы сможем изменить в коллбеке.
Теперь мы готовы к включению перехвата. Для этого необходимо сначала включить ftrace для интересующей нас функции с помощью ftrace\_set\_filter\_ip(), а затем разрешить ftrace вызывать наш коллбек с помощью register\_ftrace\_function():
```
int fh_install_hook(struct ftrace_hook *hook)
{
/* ... */
err = ftrace_set_filter_ip(&hook->ops, hook->address, 0, 0);
if (err) {
pr_debug("ftrace_set_filter_ip() failed: %d\n", err);
return err;
}
err = register_ftrace_function(&hook->ops);
if (err) {
pr_debug("register_ftrace_function() failed: %d\n", err);
/* Не забываем выключить ftrace в случае ошибки. */
ftrace_set_filter_ip(&hook->ops, hook->address, 1, 0);
return err;
}
return 0;
}
```
Выключается перехват аналогично, только в обратном порядке:
```
void fh_remove_hook(struct ftrace_hook *hook)
{
int err;
err = unregister_ftrace_function(&hook->ops);
if (err) {
pr_debug("unregister_ftrace_function() failed: %d\n", err);
}
err = ftrace_set_filter_ip(&hook->ops, hook->address, 1, 0);
if (err) {
pr_debug("ftrace_set_filter_ip() failed: %d\n", err);
}
}
```
После завершения вызова unregister\_ftrace\_function() гарантируется отсутствие активаций установленного коллбека в системе (а вместе с ним — и наших обёрток). Поэтому мы можем, например, спокойно выгрузить модуль-перехватчик, не опасаясь, что где-то в системе ещё выполняются наши функции (ведь если они пропадут, то процессор расстроится).
### Выполнение перехвата функций
Как же выполняется собственно перехват? Очень просто. Ftrace позволяет изменять состояние регистров после выхода из коллбека. Изменяя регистр %rip — указатель на следующую исполняемую инструкцию,— мы изменяем инструкции, которые исполняет процессор — то есть можем заставить его выполнить безусловный переход из текущей функции в нашу. Таким образом мы перехватываем управление на себя.
Коллбек для ftrace выглядит следующим образом:
```
static void notrace fh_ftrace_thunk(unsigned long ip, unsigned long parent_ip,
struct ftrace_ops *ops, struct pt_regs *regs)
{
struct ftrace_hook *hook = container_of(ops, struct ftrace_hook, ops);
regs->ip = (unsigned long) hook->function;
}
```
С помощью макроса container\_of() мы получаем адрес нашей `struct ftrace_hook` по адресу внедрённой в неё `struct ftrace_ops`, после чего заменяем значение регистра %rip в структуре `struct pt_regs` на адрес нашего обработчика. Всё. Для архитектур, отличных от x86\_64, этот регистр может называться по-другому (вроде IP или PC), но идея в принципе применима и для них.
Обратите внимание на спецификатор **notrace**, добавленный для коллбека. Им можно помечать функции, запрещённые для трассировки с помощью ftrace. Например, так помечены функции самого ftrace, задействованные в процессе трассировки. Это помогает предотвратить зависание системы в бесконечном цикле при трассировании всех функций в ядре (ftrace так умеет).
Коллбек ftrace обычно вызывает с отключенным вытеснением (как и kprobes). Возможны исключения, но на них не стоит рассчитывать. В нашем случае, правда, это ограничение не важно, так мы всего лишь заменяем восемь байтов в структуре.
Функция-обёртка, которая вызывается позже, будет выполняться в том же контексте, что и оригинальная функция. Поэтому там можно делать то же, что позволено делать в перехватываемой функции. Например, если вы перехватываете обработчик прерывания, то спать в обёртке всё ещё нельзя.
### Защита от рекурсивных вызовов
В коде выше есть подвох: когда наша обёртка вызовет оригинальную функцию, та опять попадёт в ftrace, который опять вызовет наш коллбек, который опять передаст управление обёртке. Эту бесконечную рекурсию необходимо как-то оборвать.
Наиболее элегантный способ, который пришёл нам в голову — это использовать `parent_ip` — один из аргументов ftrace-коллбека, который содержит адрес возврата в функцию, которая вызвала трассируемую функцию. Обычно этот аргумент используют для построения графа вызовов функций. Мы же можем воспользоваться им для того, чтобы отличить первый вызов перехваченной функции от повторного.
Действительно, при повторном вызове `parent_ip` должен указывать внутрь нашей обёртки, тогда как при первом — куда-то в другое место ядра. Передавать управление следует только при первом вызове функции, все другие должны дать выполниться оригинальной функции.
Проверку на вхождение можно очень эффективно выполнить, сравнивая адрес с границами текущего модуля (который содержит все наши функции). Это отлично работает в случае, если в модуле лишь обёртка вызывает перехваченную функцию. В противном случае необходимо быть более избирательным.
Итого, правильный ftrace-коллбек выглядит следующим образом:
```
static void notrace fh_ftrace_thunk(unsigned long ip, unsigned long parent_ip,
struct ftrace_ops *ops, struct pt_regs *regs)
{
struct ftrace_hook *hook = container_of(ops, struct ftrace_hook, ops);
/* Пропускаем вызовы функции из текущего модуля. */
if (!within_module(parent_ip, THIS_MODULE))
regs->ip = (unsigned long) hook->function;
}
```
Отличительные особенности/преимущества данного подхода:
* **Низкие накладные расходы.** Всего лишь несколько вычитаний и сравнений. Никаких спинлоков, проходов по спискам, и так далее.
* **Не требует глобального состояния.** Отсутствие синхронизации делает подобный подход автоматически совместимым с вытеснением. Он не привязан к глобальному списку процессов, так что позволяет перехватывать в том числе обработчики прерываний.
* **Нет ограничений на функции.** Этот подход лишён недостатка *kretprobes* и из коробки поддерживает любое количество активаций перехватываемой функции, в том числе рекурсивных (когда ядро само вызывает функцию несколько раз). При рекурсивных вызовах адрес возврата всё ещё находится вне нашего модуля, так что проверка в коллбеке работает корректно.
### Схема работы перехвата
Рассмотрим пример: вы набрали в терминале команду **ls**, чтобы увидеть список файлов в текущей директории. Командный интерпретатор (скажем, Bash) для запуска нового процесса использует традиционную пару функций *fork*() + *execve*() из стандартной библиотеки языка Си. Внутри эти функции реализуются через системные вызовы **clone()** и **execve()** соответственно. Допустим, мы перехватываем системный вызов execve(), чтобы контролировать запуск новых процессов.
В графическом виде перехват функции-обработчика выглядит так:
Здесь мы видим, как пользовательский процесс (голубой) выполняет системный вызов в ядро (красное), где фреймворк ftrace (фиолетовый) вызывает функции из нашего модуля (зелёного).
1. **Пользовательский процесс выполняет SYSCALL.** С помощью этой инструкции выполняется переход в режим ядра и управление передаётся низкоуровневому обработчику системных вызовов — *entry\_SYSCALL\_64*(). Он отвечает за все системные вызовы 64-битных программ на 64-битных ядрах.
2. **Управление переходит к конкретному обработчику.** Ядро быстро делает низкоуровневые дела, [реализованные на ассемблере](https://elixir.bootlin.com/linux/v4.16/source/arch/x86/entry/entry_64.S#L206), и передаёт управление высокоуровневой функции *do\_syscall\_64*(), [написанной на Си](https://elixir.bootlin.com/linux/v4.16/source/arch/x86/entry/common.c#L269). Эта функция в свою очередь обращается к таблице обработчиков системных вызовов `sys_call_table` и вызывает оттуда конкретный обработчик по номеру системного вызова — в нашем случае это будет функция *sys\_execve*().
3. **Вызывается ftrace.** В начале каждой функции ядра находится вызов функции *\_\_fentry\_\_*(), которая реализуется фреймворком ftrace. В функциях, которые трассировать не надо, этот вызов обычно заменён на инструкции *nop*, но в интересной нам функции sys\_execve() этот вызов присутствует.
4. **Ftrace вызывает наш коллбек.** В процессе работы ftrace вызывает все зарегистрированные трассировочные коллбеки, включая и наш. В одном месте может быть установлен только один коллбек, изменяющий значение регистра %rip, так что другие коллбеки нам не помешают.
5. **Коллбек выполняет перехват.** Коллбек смотрит на значение `parent_ip`, указывающее внутрь do\_syscall\_64() — так как именно эта функция вызвала обработчик sys\_execve() — и принимает решение выполнит перехват, обновляя значение *регистра %rip* в структуре `pt_regs`.
6. **Ftrace восстанавливает регистры.** Следуя флагу FTRACE\_SAVE\_REGS, ftrace сохраняет состояние регистров в структуре `pt_regs` перед вызовом обработчиков. При завершении обработки ftrace восстанавливает регистры из этой структуры. Наш обработчик изменяет регистр %rip — указатель на следующую исполняемую инструкцию — что в итоге приводит к передаче управления по новому адресу.
7. **Управление получает функция-обёртка.** Из-за безусловного перехода активация функции sys\_execve() как бы прерывается. Вместо неё управление получает наша функция *fh\_sys\_execve*(). При этом всё остальное состояние процессора и памяти остаётся без изменений, поэтому наша функция получает все аргументы оригинального обработчика и при завершении вернёт управление в функцию do\_syscall\_64().
8. **Обёртка вызывает оригинальную функцию.** С этого момента судьба системного вызова находится в наших руках. Функция fh\_sys\_execve() может проанализировать аргументы и контекст системного вызова (кто что запускает) и запретить или разрешить процессу его выполнение. В случае запрета функция просто возвращает код ошибки. Иначе же ей следует вызвать оригинальный обработчик — sys\_execve() вызывается повторно, через указатель *real\_sys\_execve*, который был сохранён при настройке перехвата.
9. **Управление получает коллбек.** Как и при первом вызове sys\_execve(), управление опять проходит через ftrace и передаётся в наш коллбек. Однако, в этот раз ситуация развивается немного по-другому…
10. **Коллбек ничего не делает.** Потому что в этот раз функция sys\_execve() вызывается нашей функцией fh\_sys\_execve(), а не ядром из do\_syscall\_64(). Поэтому коллбек не модифицирует регистры и выполнение функции sys\_execve() продолжается как обычно. Единственный побочный эффект такого дела: ftrace видит вход в sys\_execve() дважды.
11. **Управление возвращается обёртке.** Во второй раз обработчик системного вызова sys\_execve() вернёт управление в нашу функцию fh\_sys\_execve(). К этому моменту новый процесс уже почти запущен. Мы можем посмотреть, завершился ли вызов execve() с ошибкой, изучить свежезапущенный процесс, сделать соответствующие записи в лог, и т. д.
12. **Управление возвращается ядру.** Наконец fh\_sys\_execve() завершается и управление переходит в do\_syscall\_64(), которая считает, что системный вызов был завершён как обычно. Ядро продолжает свои ядерные дела.
13. **Управление возвращается в пользовательский процесс.** Наконец ядро выполняет инструкцию IRET (или SYSRET, но для execve() — всегда IRET), устанавливая регистры для нового пользовательского процесса и переводя центральный процессор в режим исполнения пользовательского кода. Системный вызов (и запуск нового процесса) завершён.
Преимущества и недостатки
-------------------------
В итоге мы получаем очень удобный способ перехвата любых функций в ядре, обладающий следующими преимуществами:
* **Зрелый API и простой код.** Использование готовых интерфейсов в ядре существенно упрощает код. Вся установка перехвата требует пары вызовов функций, заполнение двух полей в структуре, и мааааленького кусочка магии в коллбеке. Остальной код — это исключительно бизнес-логика, выполняемая вокруг перехваченной функции.
* **Перехват любой функции по имени.** Для указания интересующей нас функции достаточно написать её имя в обычной строке. Не требуются какие-то особые реверансы с редактором связей, разбор внутренних структур данных ядра, сканирование памяти, или что-то подобное. Мы можем перехватить любую функцию (даже не экспортируемую для модулей), зная лишь её имя.
* **Перехват совместим с трассировкой.** Очевидно, что этот способ не конфликтует с ftrace, так что с ядра всё ещё можно снимать очень полезные показатели производительности. Использование kprobes или сплайсинга может помешать механизмам ftrace.
Какие же недостатки у этого решения?
* **Требования к конфигурации ядра.** Для успешного выполнения перехвата функций с помощью ftrace ядро должно предоставлять целый ряд возможностей:
+ список символов kallsyms для поиска функций по имени
+ фреймворк ftrace в целом для выполнения трассировки
+ опции ftrace, критически важные для перехвата
Все эти возможности не являются критичными для функционирования системы и могут быть отключены в конфигурации ядра. Правда, обычно ядра, используемые популярными дистрибутивами, все эти опции в себе всё равно содержат, так как они не влияют на производительность и полезны при отладке. Однако, если вам необходимо поддерживать какие-то особенные ядра, то следует иметь в виду эти требования.
* **Накладные расходы на ftrace** меньше, чем у kprobes (так как ftrace не использует точки останова), но они выше, чем у сплайсинга, сделанного вручную. Действительно, *динамический ftrace* — это и есть по сути сплайсинг, только вдобавок выполняющий «ненужный» код ftrace и другие коллбеки.
* **Оборачиваются функции целиком.** Как и традиционный сплайсинг, данный подход полностью оборачивает вызовы функций. Однако, если сплайсинг технически возможно выполнить в любом месте функции, то ftrace срабатывает исключительно при входе. Естественно, обычно это не вызывает сложностей и даже наоборот удобно, но подобное ограничение иногда может быть недостатком.
* **Двойной вызов ftrace.** Описанный выше подход с анализом указателя `parent_ip` приводит к повторному вызову ftrace для перехваченных функций. Это добавляет немного накладных расходов и может сбивать показания других трассировок, которые будут видеть в два раза больше вызовов. Этого недостатка можно избежать, применив немного чёрной магии: вызов ftrace расположен в начале функции, так что если адрес оригинальной функции сдвинуть вперёд на 5 байтов (длина инструкции call), то через ftrace можно перескочить.
Рассмотрим некоторые недостатки подробнее.
### Требования к конфигурации ядра
Для начала, ядра должно поддерживать ftrace и kallsyms. Для этого должны быть включены следующие опции:
* CONFIG\_FTRACE
* CONFIG\_KALLSYMS
Затем, ftrace должна поддерживать динамическую модификацию регистров. За эту возможность отвечает опция
* CONFIG\_DYNAMIC\_FTRACE\_WITH\_REGS
Далее, используемое ядро должно быть основано на *версии 3.19 или выше*, чтобы иметь доступ к флагу FTRACE\_OPS\_FL\_IPMODIFY. Более ранние версии ядра тоже умеют заменять регистр %rip, но начиная с 3.19 это следует делать только после установки данного флага. Наличие флага для старых ядер приведёт к ошибке компиляции, а его отсутствие для новых — к неработающему перехвату.
Наконец, для выполнения перехвата критическим является расположение вызова ftrace внутри функции: вызов должен располагаться в самом начале, до пролога функции (где выделяется место под локальные переменные и формируется стековый фрейм). Эта особенность архитектуры учитывается опцией
* CONFIG\_HAVE\_FENTRY
Архитектура x86\_64 поддерживает эту опцию, а вот i386 — нет. Из-за ограничений архитектуры i386 компилятор не может вставить вызов ftrace до пролога функции, поэтому к моменту вызова ftrace стек функции уже оказывается модифицированным. В таком случае для перехвата недостаточно лишь изменить значение регистра %eip — нужно ещё обратить все действия, выполненные в прологе, которые отличаются от функции к функции.
По этой причине перехват с помощью ftrace не поддерживает 32-битную архитектуру x86. В принципе, его можно было бы реализовать с помощью определённой чёрной магии (генерируя и выполняя «антипролог»), но тогда пострадает техническая простота решения, являющаяся одним из преимуществ использования ftrace.
### Неочевидные сюрпризы
Во время тестирования мы столкнулись с одной интересной *особенностью*: на некоторых дистрибутивах перехват функций приводил к зависанию системы намертво. Естественно, это происходило только на системах, отличных от используемых разработчиками. Проблема также не воспроизводилась на исходном прототипе перехвата, с любыми дистрибутивами и версиями ядер.
Отладка показывала, что зависание происходит внутри перехваченной функции. По какой-то мистической причине при вызове оригинальной функции внутри ftrace-коллбека адрес `parent_ip` продолжал указывать в код ядра вместо кода функции обёртки. Из-за этого возникал бесконечный цикл, так как ftrace раз за разом вызывал нашу обёртку, не выполняя каких-либо полезных действий.
К счастью, у нас был в распоряжении как рабочий, так и поломанный код, поэтому нахождение различий было лишь вопросом времени. После проведённой унификации кода и выбрасывания всего ненужного, различия между версиями удалось локализовать до функции-обёртки.
Вот этот вариант работал:
```
static asmlinkage long fh_sys_execve(const char __user *filename,
const char __user *const __user *argv,
const char __user *const __user *envp)
{
long ret;
pr_debug("execve() called: filename=%p argv=%p envp=%p\n",
filename, argv, envp);
ret = real_sys_execve(filename, argv, envp);
pr_debug("execve() returns: %ld\n", ret);
return ret;
}
```
а вот этот — вешал систему:
```
static asmlinkage long fh_sys_execve(const char __user *filename,
const char __user *const __user *argv,
const char __user *const __user *envp)
{
long ret;
pr_devel("execve() called: filename=%p argv=%p envp=%p\n",
filename, argv, envp);
ret = real_sys_execve(filename, argv, envp);
pr_devel("execve() returns: %ld\n", ret);
return ret;
}
```
Как так выходит, что уровень логгирования влияет на поведение? Внимательное изучение машинного кода двух функций быстро прояснило ситуацию и вызвало то самое чувство, когда виноват именно компилятор. Обычно он находится в списке подозреваемых где-то рядом с космическими лучами, но не в этот раз.
Дело, как оказалось, в том, что вызовы pr\_devel() раскрываются в пустоту. Этот вариант printk-макроса используется для логгирования во время разработки. Такие записи в лог не интересны при эксплуатации, поэтому автоматически вырезаются из кода, если не объявить макрос DEBUG. После этого функция для компилятора превращается в такую:
```
static asmlinkage long fh_sys_execve(const char __user *filename,
const char __user *const __user *argv,
const char __user *const __user *envp)
{
return real_sys_execve(filename, argv, envp);
}
```
И тут на сцену выходят оптимизации. В данном случае сработала так называемая *оптимизация хвостовых вызовов* (tail call optimization). Она позволяет компилятору заменить честный вызов функции на прямой переход к её телу, если одна функция вызывает другую и сразу же возвращает её значение. В машинном коде честный вызов выглядит так:
```
0000000000000000 :
0: e8 00 00 00 00 callq 5
5: ff 15 00 00 00 00 callq \*0x0(%rip)
b: f3 c3 repz retq
```
а нерабочий — вот так:
```
0000000000000000 :
0: e8 00 00 00 00 callq 5
5: 48 8b 05 00 00 00 00 mov 0x0(%rip),%rax
c: ff e0 jmpq \*%rax
```
Первая инструкция CALL — это тот самый вызов \_\_fentry\_\_(), вставляемый компилятором в начало всех функций. А вот дальше в нормальном коде видно вызов real\_sys\_execve (по указателю в памяти) через инструкцию CALL и возврат из fh\_sys\_execve() с помощью инструкции RET. Поломанный же код переходит к функции real\_sys\_execve() напрямую с помощью JMP.
Оптимизация хвостовых вызовов позволяет сэкономить немного времени на формировании «бессмысленного» стекового фрейма, в который входит и адрес возврата, сохраняемый в стеке инструкцией CALL. Однако, для нас корректность адреса возврата играет критичную роль — мы используем `parent_ip` для принятия решения о перехвате. После оптимизации функция fh\_sys\_execve() больше не сохраняет новый адрес возврата на стеке, там остаётся старый — указывающий в ядро. Поэтому `parent_ip` продолжает указывать внутрь ядра, что и приводит в конечном итоге к образованию бесконечного цикла.
Это также объясняет, почему проблема воспроизводилась лишь на некоторых дистрибутивах. При компиляции модулей разные дистрибутивы используют разные наборы флагов компиляции. В проблемных дистрибутивах оптимизация хвостовых вызовов была включена по умолчанию.
Решением проблемы для нас стало отключение оптимизации хвостовых вызовов для всего файла с функциями-обёртками:
```
#pragma GCC optimize("-fno-optimize-sibling-calls")
```
Заключение
----------
Что ещё можно сказать… Разработка низкоуровневого кода для ядра Linux — это весело. Я надеюсь, эта публикация сэкономит кому-то немного времени при муках выбора, что же использовать для написания своего лучшего в мире антивируса.
Если вам охота поэкспериментировать с перехватом самостоятельно, то полный код модуля ядра можно найти [на Github](https://github.com/ilammy/ftrace-hook). | https://habr.com/ru/post/413241/ | null | ru | null |
# IE8 и режим InPrivate
Как часто бывали случаи, когда знакомый просил вас на пару минут «одолжить» ваш PC для проверки почты/rss-ленты/форума? Я думаю, часто. А как часто мы просили попользоваться чужим компьютером для доступа в интернет? Даже если у вас не было таких случаев, они обязательно будут в будущем.
Вы едете в командировку, но у вас нет нетбука, а так бы хотелось быть на связи, вам соглашаются одолжить нетбук.Вы активно пользуетесь нетбуком, по привычке сохраняете пароли, автоматически запоминаете пользователей на сайте, в общем, чувствуете себя как дома. Вернулись домой, потратили полчаса на очистку истории посещения сайтов, cookie, сохраненных паролей и т.п. И все равно, отдавая ноутбук, вас не покидает чувство, что что-то забыли стереть, личные данные есть личная данные и знать о них другим людям, даже случайно, не нужно.
Таких случаев миллион: проверю почту в интернет кафе, зайду на страничку в одноклассниках/вконтакте(куда уж без них). Как же гарантировать безопасность наших личных данных?
Новый функционал IE8 позволяет решить данные проблемы качественно и быстро. Microsoft дает нам в руки 3 технологии:
* Режим InPrivate позволяет контролировать сохранение IE истории посещений, cookie и других данных.
* Удаление журнала обозревателя.
* InPrivate Фильтр информирует вас о страницах, которые могут просматривать вашу историю посещений, и позволяет пресечь это.
#### **Режим InPrivate**
Новый режим InPrivate:
* Не сохраняет новые cookie файлы
+ Все новые cookie файлы живут до закрытия окна
+ Ранее созданные cookie файлы остаются доступными
* DOM Storage работает по такому же принципу, как и cookie.
* Просмотренные сайты не будут запоминаться в историю посещений.
* Временные файлы будут удаляться после закрытия окна.
* Данные форм не сохраняются
* Пароли не сохраняются
* Адреса, введенные в строку адреса, не сохраняются
* Запросы, введенные в поле поиска, не сохраняются
* Посещенные ссылки не сохраняются
Активация режима InPrivate
Вы получаете новое окно с характерной меткой в адресной строке.
### **Удаление журнала обозревателя.**
Данная функция существует еще с 7 версии IE. Она позволяет в один клик удалить любую информацию, которую хранит браузер.
Мне особенно нравится забота о пользователе, которая позволяет удалить абсолютно все, исключая данные сайтов, которые добавлены в Избранное.
Microsoft прислушалась к отзывам пользователей и добавила еще одну возможность, как удаление журнала посещений после закрытия браузера.
### **Фильтрация InPrivate**
Позволяет контролировать доступ сторонним веб-приложениям, которые могут отслеживать ваши посещения. Многие знают, что отслеживать передвижение пользователей по сайтам можно не используя cookie. Каждые раз, когда вы просматриваете странице, IE локально сохраняет информацию о взаимодействии со сторонними элементами, а так же откуда идет запрос. Например, вы посещаете first.com и second.com, у которых в теле странице размещен снипет:
`Теперь woodgrove-int.com знает о том, что вы были на обоих сайтах first.com и second.com, сюда же относится Google Analytics и Яндекс Метрика.
Как раз о таких сторонних объектах InPrivate Blocking сохраняет информацию и при включенном InPrivate режиме, автоматически блокирует сайты, которые отслеживали вас более чем на 10 сайтах. В итоге tracking.js уже не будет передавать никаких данных.
Фильтрацию нужно включать отдельно.
Мы сами ставим запятую в «Казнить нельзя помиловать», контролируя каким сторонним объектам можно, а каким нельзя отдавать запрошенную информацию.
В обычном режиме браузер будет вести статистику о сторонних объектах для InPrivate Фильтрациии.
### **Итог**
IE предоставляет достаточно богатый функционал для контроля личных данных в интернет, а так же на любом PC.` | https://habr.com/ru/post/67928/ | null | ru | null |
# Формула 1 и та самая табличка со скоростью пилотов
Повод
-----
Пару месяцев назад в рамках сотрудничества Amazon и Formula 1 исследователи «с использованием мощностей облачных технологий» выкатили сравнение скорости пилотов всех времен и народов ([ссылка](https://ru.motorsport.com/f1/news/formula-1-sostavila-rejting-bystrejshikh-pilotov-v-istorii-vyshlo-neodnoznachno/4858954/)). Естественно, материал был рекламно-хайповый, и цели своей он достиг. Во всем формульном мире еще пару дней только и было разговоров в духе «а почему в рейтинге нет пилота N?» и «да как M может быть быстрее K, если K сделал его в сезоне L». Мне стало интересно более-менее повторить это исследование и, по возможности, обойтись без «всей мощи облачных технологий».
оригинальный рейтинг
---
Задача
------
Но вернемся к постановке задачи. На скорость пилота в гонке влияет огромное число факторов. Личный талант, скорость болида, правильная стратегия, действия других пилотов, погода, аварии и многое другое. Такова специфика автоспорта. Поэтому для своего пробного шара специалисты AWS взяли много более простую задачу – сравнить скорость пилотов в квалификации. Квалификационные заезды изначально строятся таким образом, чтобы насколько это возможно уравнять внешние условия для соперников. Пилоту остается выжать максимум из своих возможностей и возможностей машины.
Как любят говорить в F1, пилот – это лишь 10% успеха в гонке, остальные 90% - машина и работа команды. Поэтому с хоть какой-то степенью достоверности можно сравнивать только напарников по команде между собой, т.к. это, в теории, нивелирует фактор машины. Здесь тоже всегда есть масса домыслов и слухов, что при необходимости команда может топить одного своего пилота, либо просто не иметь возможности привозить последние обновления сразу на обе машины и отдавать лучшее своему быстрейшему гонщику. Но, в рамках нашей задачи, будем считать болиды сокомандников одинаковыми.
Идея
----
В таком случае каждая квалификация для нас превращается в набор парных сравнений скорости пилотов в рамках каждой команды. К счастью, мир формульных гонок довольно мал, и «большие» пилоты успевают поездить сразу с несколькими напарниками в рамках разных команд. Таким образом, мы сможем получить сравнение 2 пилотов, никогда не выступавших в рамках одной команды, «через третьего» - пилота, с которым оба в разное время оказывались в одном коллективе. Тут так же есть очень серьезные допущения, которые портят малину. Это и допущение, что уровень пилота остается стабильным несколько лет подряд, и допущение, что машина всегда идеально подходит пилоту.
Еще один неприятный момент. Сравнить так уж прям всех пилотов за всю историю, к сожалению, не удастся. Даже используя все «попарные» мостики, не удастся добраться до всех пилотов, выступавших в Ф1. Возможны как отдельные пары пилотов, всю карьеру выступавшие только в одной команде друг с другом, так и более сложные закрытые кластера пилотов, не пилотировавшие ни с кем из общего кластера одновременно в одной команде.
Первое, что приходит в голову для решения этой задачи в очень упрощенном виде, что каждому пилоту в соответствие можно сопоставить некий коэффициент скорости kp, который проявляется в каждой квалификации.
Т.о. скорость прохождения круга в квалификации V = V0\*kp\*kc\*Tr, где kc – такой же коэффициент скорости болида конкретной команды в конкретной гонке, а Tr – некая константа, характерная для трассы в конкретных условиях.
После серии преобразований можно вывести, что в каждой квалификации ln(ki)-ln(kj)=ln(tj)-ln(ti) для болидов гонщиков одной команды.
Получаем систему линейных уравнений. Систему довольно просто представить как матрицу m\*(n+1), где n – число пилотов, m – суммарное число гонщиков в квалификациях. В каждой строке есть коэффициенты 1 и -1 в столбцах, соответствующих пилотам, и логарифм обратного отношения их времен в столбце свободных коэффициентов.
В отличие от специалистов AWS, мы посчитаем коэффициент динамически, считая, что он остается стабильным только в течение одного-двух лет. Для того, чтобы прокинуть мостик между соседними годами, искусственно внесем в таблицу результаты «из прошлого» - поменяем лишь год для пилота на предыдущий, остальные столбцы оставив неизменными. Т.о. мы получим «замыленные» на перспективу 2 лет данные для каждого пилота и поставим его прошлого к ему теперешнему в напарники с 0 разницей в скорости.
Более того, по похожей схеме посчитаем и рейтинг болидов F1. Год от года в связи с изменением правил и техническим прогрессом машины меняются. Последние годы регламент составляется так, что в начале года команда выставляет новую машину, большую часть года ее дорабатывает, а на следующий год вынуждена делать машину, подходящую под новый регламент. Понять, насколько прогрессирует машина по ходу году довольно сложно, поэтому допустим, что она более-менее стабильна.
Здесь мы будем фиксировать пилота и трассу и смотреть, насколько на одной машине он прошел ее быстрее, чем на другой в перспективе 2 лет. У этого подхода есть 3 больших минуса. 1 – машина может быть быстрой, но не подходить пилоту. Мы же увидим, что она «хуже». Второй – трассы постоянно ротируются. Добавляются новые, уходят либо перестраиваются старые. Нам же для этого подхода нужен некоторый набор стабильных трасс. И третий – дождь. Если в один год он был, а в другой нет, то мы можем списать это на скорость машины.
Решение
-------
Данные квалификаций спарсим из Википедии, откуда еще. Формат квалификации менялся много раз, в разные периоды она состояла из 1, 2 и как теперь 3 фаз. Хоть это и не до конца верно, будем считать, что итоговое время пилота было показано в последней доступной фазе квалификации.
```
import sys
import re
import urllib.request
def get_wikipedia_page(title, lang='en'):
url = 'https://'+lang+'.wikipedia.org/wiki/'+(title.replace(' ', '_'))
fp = urllib.request.urlopen(url)
mybytes = fp.read()
mystr = mybytes.decode("utf8")
fp.close()
return mystr
title = 'List of Formula One Grands Prix'
try:
print('process: '+title)
th = get_wikipedia_page(title)
r1 = re.findall(r'href="/wiki/[\d][\d][\d][\d]_[\w]*_Grand_Prix"',th)
list_of_GP = list(set(r1))
except:
print("Unexpected error:", sys.exc_info()[0])
titles = list(map(lambda x: x[12: -1].replace('_', ' '), list_of_GP))
for title in titles:
try:
print('process: '+title)
th = get_wikipedia_page(title)
with open('texts/'+title+'.txt', 'w', encoding='utf8') as the_file:
the_file.write(th)
the_file.close()
except:
print("Unexpected error:", sys.exc_info()[0])
```
Из полученных html файлов регулярками выпарсим квалификационные таблицы. Также слегка стандартизируем текстовую часть данных. Приведем названия треков к одному виду (иногда встречаются несколько написаний одного и того же трека), сохраним его длину (это поможет различить разные версии одного и того же трека), поудаляем цифры и прочий «мусор» из имен пилотов. Сохраним итоговые данные в удобную csv.
Считаем полученный DataFrame. Создадим несколько столбцов, которые сильно нам помогут в дальнейшем:
Название трека + его длина. Этоот столбец нам понадобится, чтобы не путать разные версии одного и того же автодрома
Имя пилота + год – будем считать, что в течение 1 года пилот сохраняет один и тот же уровень формы, в течение 2 лет изменяет его незначительно
Машина = Конструктор + год. Вообще говоря, это не очень верно. На заре автоспорта производители могли использовать несколько разных версий машины в одном чемпионате и наоборот, несколько лет подряд использовать одну и ту же машину. Сейчас топ-команды умудряются привозить несколько крупных обновлений аэродинамики за год, малые команды пользуются этим реже.
```
qual_df = pd.read_csv('qual_results.csv')
qual_df['Track_pl_len'] = qual_df['Track'] + '_' +qual_df['Track_len'].apply(str)
qual_df['Car'] = qual_df['Constructor'] + '_' +qual_df['Year'].apply(str)
qual_df['Driver_pl_year'] = qual_df['Driver']+'_'+qual_df['Year'].apply(str)
qual_df_2 = qual_df.copy()
qual_df_2['Driver_pl_year'] = qual_df_2['Driver']+'_'+((qual_df_2['Year'].apply(int)-1)).apply(str)
double_df = pd.concat([qual_df, qual_df_2])
del qual_df2
```
Также создадим искусственный датафрейм. Скопируем основной датафрейм, но каждому пилоту присвоим прошлый год вместо текущего. Этот датафрейм сольем с основным. Таким образом для любых методов, если группироваться по пилоту, мы удваиваем информацию. Плюс явно говорим, что уровень формы не уходит за год, а изменяется довольно плавно. Полученный удвоенный датафрейм будем использовать в дальнейших расчетах.
А дальше произведем небольшую манипуляцию с данными. Произведем 2 раза для разных рейтингов, но подробно разберу для рейтинга пилотов.
* Посчитаем логарифм из времени на круге
* Разность логарифмов времен на квалификационном круге двух сокомандников равна обратной разности логарифмов коэффициентов их скорости, т.к. все остальные переменные считаем одинаковыми и зафиксированными
* Соответственно, просто мерджим 2 одинаковых датафрейма между собой по машине и гонке – и получаем большую простыню нужных нам попарных сравнений
* Фильтруем полученный датасет, чтобы каждый «мостик» из сравнения двух пилотов был достаточно «надежен» - я выставил лимит в 6 и более совместных квалификаций и разницу в скорости не более 2%. Также оставляем только пилотов, отметившихся в «главной» линии пилотов Ф1 – в той, что были основные чемпионы. Некоторое количество пилотов просто не пересекались с ними ни через кого в одной команде, поэтому узнать их скорость этим методом невозможно
* Выворачиваем 2 столбца с именами пилотов One Hot Encoding так, чтобы пилот x оказался с коэффициентом = 1 в столбце со своей фамилией, пилот y с -1
* И запускаем линейную регрессию, она в данном случае не выбрасывает огромные коэффициенты даже без регуляризации. Единственное, что мы сделали – удалили столбец с ровно 1 пилотом, т.е. искусственно присвоили ему коэффициент скорости 1, логарифм 0. Все остальные пилоты будут выстраиваться относительно него – выше или ниже
* Вытаскиваем посчитанные коэффициенты линейной регрессии. По нашей задумке они будут равны ln(k) - логарафму от коэффициента скорости пилота.
Очень похожее действие провернем и для машин, которые будем наоборот сравнивать на одних и тех же трассах с одним и тем же пилотом за рулем.
Результаты
----------
Прежде чем подводить итоги по тому методу, по которому считал я, хочу все же показать результаты «карьерного» измерения, т.е. то, что презентовали F1 и Amazon.
Немного поигравшись с параметрами запуска, на тех же данных удалось получить следующую таблицу:
Последний столбец пересчитал исходя из того, чтобы точкой отсчета был Сенна
Это 18 первых пилотов, если составлять рейтинг без учета динамики по ходу карьеры. Опять же, параметров довольно много + ошибки парсинга + оговорки, какое время брать в многоуровневых квалификациях. Серым я затемнил пилотов, которых нет в официальной лучшей 10. Если их не учитывать, то рейтинги очень похожи. Все те же люди на похожих расстояниях. Ниже Ферстаппен, выше Феттель.
Самое интересное здесь – как в топе появился перспективный дебютант Рассел. Появился за счет 2019 года, в котором разнес вернувшегося после кучи пропущенных лет и тяжелейшей травмы некогда быстрого поляка Роберта Кубицу. Роберт весь год жаловался на машину, воевал с командой и на следующий год ушел из Ф1.
Сравнивать с ним Рассела – некорректно. Столь длинное отсутствие не могло не сказаться на форме Кубицы. В сравнении же мы считаем, что это одинаково быстрый пилот. Видимо, так же посчитали аналитики Ф1 и подчистили рейтинг. Как из него исчезли сверстабильные Боттас и Риккьярдо для меня загадка. Много лет в Ф1, точно пересекались с Хэмильтоном и Ферстаппеным и смотрелись/смотрятся на их фоне отлично.
А вот что получается, если построить рейтинг год к году:
| | | |
| --- | --- | --- |
| N | Driver | Total min |
| 1 | Ayrton Senna | - 0,435 |
| 2 | Michael Schumacher | - 0,408 |
| 3 | Alain Prost | - 0,289 |
| 4 | Damon Hill | - 0,037 |
| 5 | Lewis Hamilton | - 0,037 |
| 6 | Charles Leclerc | 0,016 |
| 7 | Rubens Barrichello | 0,024 |
| 8 | Fernando Alonso | 0,067 |
| 9 | Nico Rosberg | 0,081 |
| 10 | Nigel Mansell | 0,102 |
| 11 | Carlos Pace | 0,117 |
| 12 | Mika Häkkinen | 0,145 |
| 13 | Max Verstappen | 0,147 |
| 14 | Valtteri Bottas | 0,153 |
| 15 | Elio de Angelis | 0,164 |
| 16 | Daniel Ricciardo | 0,165 |
| 17 | Jarno Trulli | 0,172 |
| 18 | Giancarlo Fisichella | 0,184 |
И расширить его в перспективе времени (для всех пилотов здесь первый отмеченный год предваряет дебют или возвращение после перерыва, т.е. фактически в Ф1 пилота еще не было):
 Можно в разрезе каждого года выступлений смотреть, какой гонщик был в наибольшей квалификационной форме.
И такой же рейтинг для машин:
Мерседес 2020 года – быстрейшая машина не только чемпионата, но и за всю историю (формально – с 1979 года, дальше проследить связи между конкретными машинами тяжело ввиду изменений в календаре).
На графике бросается в глаза, как Renault сбросило секунду за счет нового двигателя не только на заводских машинах, но и на клиентах. Невероятно быстрый Racing Point, сбросивший почти 2 сек за межсезонье, Alpha Tauri 2020, неприлично похожая на Red Bull 2019 и провал двигателя Ferrari 2020, из-за которого команда откатилась на уровень 2018 года вместе со своими клиентами.
Интересно, что по этой графике быстрейшей машиной 2019 года была не Mercedes, которая взяла 10 поулов, а Red Bull и только более быстрый Хэмилтон позволял команде завоевывать поулы и титул. Леклер же, который взял поулов больше, чем Хэмилтон и Боттас каждый, творил просто чудеса, не вписывающиеся в модель.
Здесь во всей красе проявляется несовершенство самого метода попарных сравнений. Если у пилота есть длительные периоды стабильных выступлений с одним и тем же сокомандником, построить по нему статистику крайне тяжело. Сравнения получаются через много-много лет и пилотов, а каждое лишнее звено добавляет неточности. То же самое касается рейтинга машин. Чудо, что он вообще строится и выглядит адекватно.
Поскольку абсурдность и низкое качество полученной модели уже понятны, приложу ее предсказания на предстоящий этап в Имоле (результаты Уильямсов предсказать не получится, т.к. в команде 2 молодых пилота, не пересекавшихся с остальными пилотами в Ф1):
| | | |
| --- | --- | --- |
| **Driver** | **Car** | **Time\_predicted\_sec** |
| Lewis Hamilton | Mercedes | 77,711 |
| Valtteri Bottas | Mercedes | 77,850 |
| Max Verstappen | Red Bull Racing-Honda | 78,252 |
| Lando Norris | McLaren-Renault | 78,324 |
| Sergio Pérez | Racing Point-BWT Mercedes | 78,345 |
| Lance Stroll | Racing Point-BWT Mercedes | 78,439 |
| Daniel Ricciardo | Renault | 78,451 |
| Carlos Sainz Jr. | McLaren-Renault | 78,549 |
| Esteban Ocon | Renault | 78,665 |
| Alexander Albon | Red Bull Racing-Honda | 78,878 |
| Pierre Gasly | AlphaTauri-Honda | 78,985 |
| Daniil Kvyat | AlphaTauri-Honda | 79,108 |
| Charles Leclerc | Ferrari | 79,116 |
| Sebastian Vettel | Ferrari | 79,531 |
| Romain Grosjean | Haas-Ferrari | 79,656 |
| Kevin Magnussen | Haas-Ferrari | 79,738 |
| Kimi Räikkönen | Alfa Romeo Racing-Ferrari | 80,399 |
| Antonio Giovinazzi | Alfa Romeo Racing-Ferrari | 80,658 |
Выводы
------
Формула 1 и Amazon добились своей цели и привлекли внимание к себе. Так же они подкинули интересную задачку: как разделить влияние пилота и машины в таком своеобразном виде спорта.
Есть ощущение, что уровень упрощения, на который пошли авторы оригинального исследования, заставил их сильно фильтровать исходные данные / результаты, чтобы получить рейтинг, который всех устроит.
В задаче оказалось больше подводных камней, чем казалось сначала. Дожди, поломки, неравнозначность сезонов и болидов – чего только не встречалось за 70 лет истории Ф1. И чудо, что большая часть этих данных оцифрована и доступна для ознакомления и обработки.
Приличной регрессии построить так и не удалось, вроде бы беспроблемная модель все равно подкидывает неожиданные результаты. Все попытки построить единую модель, учитывающую одновременно влияние машины и пилота, пришли к необходимости жесткой регуляризации.
К статье прикладываю гитхаб с исходными данными и сводными таблицами для самостоятельного изучения, код добавлю, как только мне будет за него не так стыдно.
→ [Ссылка на Github](https://github.com/molec1/f1_analysis) | https://habr.com/ru/post/525788/ | null | ru | null |
# Боитесь внедрять CRM-систему? Возможно, ваш бизнес болен
Есть ли в бизнесе место страху? Вопрос не самый простой — какой уж страх может быть у людей, которые когда-то отказались от самой идеи стабильной работы, оклада и офисной рутины, создали своё дело ради своих целей: заработать, перестать работать «на дядю», сделать мир лучше или спасти его. Но нет, любой предприниматель считает деньги и покупка чего-либо для корпоративных нужд — это затраты, и важно понять, окупятся они или нет. Иногда положение дел обретает интересные перекосы: руководитель готов закупать самые дорогие телефоны и ноутбуки, но не рискнёт купить CRM, потому что она ему кажется излишеством — ведь и так всё работает. А то купишь её, а она «не взлетит», не принесёт доход, вызовет возмущение у сотрудников, станет лишним активом. Нередко единственная причина такого поведения жадность, на втором месте — страх. И если про первую причину нам остаётся напомнить, что жадность фраера сгубила, то со страхами интереснее разобраться.
[](https://habr.com/ru/company/regionsoft/blog/468843/)
Прежде чем внедрить CRM-систему, важно понять, как она впишется в вашу долгосрочную стратегию, проще говоря, зачем она вам? Вы должны отдавать себе отчёт в том, что она реально сможет работать внутри вашего бизнеса, удовлетворит внутренний спрос и внутренние требования. Прежде всего попробуйте ответить на вопросы:
* Что движет моей потребностью в CRM?
* Что я хочу сделать с помощью этой CRM?
* Какие функции CRM мне нужны?
* Какие проблемы решит CRM?
После этого можно приступать к выбору вендора и конкретной системы. Но так гладко не проходит почти никогда. Причиной — тем самые страхи. Мы насчитали семь основных.
Ваши сотрудники сопротивляются внедрению CRM и другого ПО
---------------------------------------------------------
*Если парень взял табличку и блокнот засунул в стол,
Это значит, что продажник способ зашибать нашёл.
Это значит утекают деньги мимо ваших рук,
Так что вы не удивляйтесь, если данные уйдут.*
*CRM они внедрить решили, ага. Клиентов учитывать.*
Часто встречается ситуация, когда сотрудники в компании выступают как лобби и могут «продавить» руководителя на крутой корпоратив, летнюю поездку всей компанией куда-нибудь, на какие-то не особо нужные офисные развлечения. В принципе, это нормально: человек проводит на работе 9 часов в день, а иногда и больше и хочется комфорта, удобства и немного приятностей типа офисной кухни, перегородок у столов, холодильника, настольных игр или кофемашины. Но когда дело касается операционных и управленческих решений, давление со стороны сотрудников не должно мешать развитию компании.
Если решение о внедрении CRM/ERP или любой другой корпоративной системы принимается сверху (а чаще всего именно так оно и принимается), сотрудники могут бойкотировать новое программное обеспечение. Сделать это легко — достаточно просто не работать в системе и не вносить в неё данные, ссылаясь на неудобный интерфейс, излишнюю трату времени или рабочую нагрузку. И всё, руководитель не может сделать ничего: работа идёт своим чередом, никто не бездельничает, просто коллегам неудобно, плохо, они выбирают старую методу работы. Такая ИТ-забастовка чревата многими проблемами: снижением скорости работы, неокупившимися затратами, корпоративными конфликтами. Если сотрудники компании позволяют себе отказаться от компромисса и организовать такое протестное лобби, задумайтесь о том, насколько вы сильны как управленец и что вы делаете не так.
### Как бороться
Из этой ситуации на практике довольно много безболезненных выходов. Перечислим некоторые советы, которые помогут адаптировать CRM в коллективе и не вызвать негатив.
* CRM-систему внутри коллектива нужно продать — так же, как вам её продали вендоры. Соберите сотрудников, расскажите о преимуществах и возможностях, ответьте на волнующие вопросы, чётко обозначьте линию контроля, за которую CRM не будет заходить (условно говоря, почти все сотрудники будут бояться, что CRM логирует историю посещений сайтов и «пишет» клавиатуру, а этого ни одна система не делает — скажите об этом прямо, покажите админку на большом мониторе).
* Выявите ядро сопротивления. В небольшой компании это, как правило один, реже два человека. Проведите встречу с этим сотрудником, разъясните причины внедрения, попросите стать вашим союзником и ранним последователем CRM, предложите роль внутреннего эксперта. Если чувствуете, что не понял, или понимаете, что сфера его интересов лежит в возможностях левачить на клиентской базе, брать откаты, продавать в обход компании и т.д., ворошите муравейник до конца: ищите всех заинтересованных, вычисляйте его сделки, и, если у вас на руках есть неоспоримые факты, дайте понять человеку, что в вашем бизнесе воровать и левачить нельзя, и если человек не принимает этих правил, он должен принять решение об увольнении. В процессе увольнения такого сотрудника не забывайте о наборе мер информационной безопасности во избежание утечки данных и ухода клиентской базы.
* Проведите хорошее, комплексное обучение с вендором и без, сформируйте внутренних экспертов, обеспечьте сотрудников распечатанными мануалами — работникам компании должно быть комфортно с новым ПО, они должны знать, что им помогут даже с самым дурацким вопросом.
* А вообще, иногда сотрудники не знают, с чем борются, поэтому просто проведите юзабилити-тестирование (не один день!), чтобы показать им, как классно и удобно использовать CRM. Они втянутся. Когда мы изучали зарубежный опыт внедрения CRM-систем, нам понравилось упражнение «День в жизни»: сотрудники разом переходят на CRM и работают с ней (в демо-версии) день, два, три, неделю, а затем подробно пишут/рассказывают о том, что они делали, что было хорошо, а что не понравилось, как бы они хотели работать с CRM-системой. Так вы убиваете двух зайцев: знакомите с системой и заодно собираете требования.
* Внедряйте CRM вместе с сотрудниками: тестируйте демо-версии, формируйте рабочие группы, собирайте требования со всех подразделений, которых коснётся автоматизация.
А главное, не бойтесь ваших сотрудников и их реакций. У любого девиантного поведения есть своя причина и своя первопричина. Ищите их и воздействуйте на оба слоя мотивов не работать с автоматизацией. Это тот случай, когда не нужен ни кнут, ни пряник — нужен грамотный анализ и корректирующие ситуацию действия.
Вы считаете расходы на CRM ненужным вложением
---------------------------------------------
*Если инвестиций ноль в ваш доходный бизнес,
То скорей всего по вам жахнет сильно кризис.
Без вложений бизнес ждёт, ох, итог простой:
Был доходный — истощился — стал вдруг доходной.*
*Деньги? Какие деньги?*
Распространённое мнение: зачем нам CRM-система, если есть Excel, ещё и платить за неё! На крайний случай, бесплатную возьмём или опенсорс на коленке соберём. На самом деле, есть ровно один способ не потратиться на CRM — просто не пользоваться ей. В остальных случаях вам всё равно придётся платить за лицензии, за работу программиста, за платную техподдержку бесплатной системы и т.д. Вы же продукт своего бизнеса бесплатно не раздаёте, с чего-то всё равно имеете выручку, правильно? Так почему вендоры CRM должны быть альтруистами и кормить сотрудников росой? Они обеспечивают вас сложным программным решением, на которое ушло огромное количество человеко-часов и материальных затрат, которое имеет довольно высокую себестоимость. Вам же не придёт в голову требовать в дилерском центре отдать автомобиль за так? Т.е. мы разобрались с первой частью мысли — платить придётся в любом случае. Даже если вы умудритесь не обратиться к вендору, а просто использовать CRM, вы заплатите за неё временем, потраченным сотрудниками на настройку и самообучение, на многочисленные первичные ошибки и внезапные открытия «о, вот как оно работает».
Другое дело, если единственный мотив отказаться от CRM-системы — это необходимость вложений. В принципе, для российского среднего и малого бизнеса это зачастую неудивительно: главное, получить маржу, а какой уж там метод, интенсивный или экстенсивный, это вы для заумных постов на Хабр оставьте. Но нет, в 2019 году такой подход прокатывает всё меньше, а вскоре вообще не прокатит. У нас всех есть конкуренты, во многих отраслях ценовые методы конкуренции уже не работают, остаётся выбирать неценовые, среди которых главный — сервис. Если вы найдёте подход к каждому клиенту, как к другу, выручка будет расти. И CRM сейчас — вынужденная инвестиция, плата за организованную клиентскую базу, которой легко управлять, которую удобно анализировать, которая гарантирует персонализацию. Плюс ко всему, CRM-системы сегодня — это ключевой элемент информационной безопасности, то есть сохранности ваших данных у вас, а не у конкурентов и злоумышленников. Если вы не готовы платить за порядок, безопасность и контролируемость процессов, вы явно недолюбливаете свой бизнес и не цените труд работников.
### Как бороться
Мы не знаем. Считаете, что для перевозок грузов лошадь с телегой круче, чем GAZelle Next, считайте дальше.
Топ-менеджеры игнорируют внедрение
----------------------------------
*Если РОП, CIO и CTO отвели глаза,
Это значит, что процессы вскоре ждёт гроза.
Не нужны летучки вам, регламенты, приличия —
Бизнес приведёт к чертям топов безразличие.*
Страх, очень близкий к предыдущему, но менее выраженный, отчего более опасный и почти не предсказуемый. Решение о внедрении CRM-системы принято, активно идёт работа со сбором требований, сотрудники готовы принять новую автоматизированную реальность, но есть группа людей, которые просто умывают руки и отходят в сторону от процесса — топ-менеджеры (начальники отделов, руководители департаментов и проч.). Причём так поступать может как коммерческий департамент (мы не просили, нам не надо), так и технический (нафиг ещё внедрять и поддерживать). Причин несколько:
* конкретный менеджер имел возможность осуществить поставку «своей» CRM-системы с каким-либо персональным бонусом (откатом);
* менеджер боится нового уровня прозрачности клиентской базы и сделок, сокращения личных неформальных контактов с клиентами (ловить рыбку в мутной воде удобнее);
* менеджер не привык работать и ему не хочется включаться в сложный, трудоёмкий и ответственный процесс;
* технический руководитель/системный администратор не хочет обучаться, внедрять, а затем и обслуживать сложное корпоративное ПО, требующее настройки и постоянных внутренних консультаций;
* у сотрудников был негативный опыт работы с системами автоматизации на предыдущей работе, они не верят в то, что CRM/ERP поможет в этот раз.
Увы, когда руководители боятся брать ответственность и включаться в процесс, подчинённые невольно копируют их поведение и также начинают относиться к инновациям настороженно. Такое отношение топов — пагубное явление, это признак нарушенных коммуникаций в бизнесе, проблем с иерархией и распределением рабочих задач.
### Как бороться
Путь опять же похож на предыдущий — плотно работать с сомневающимся руководителем, выяснить реальные причины и помочь разобраться в сложных вопросах. Однако здесь появляется дополнительная задача — разработать дорожную карту взаимодействия руководителя и его подчинённых. Причём желательно в прямом смысле слова: прописать и проговорить, как именно будет работать сотрудник с внедрением в вверенном подразделении. В течение внедрения необходимо проводить совещания и сверять статус работ по каждому подразделению — это важно даже в некризисных ситуациях.
Вы боитесь CRM как технологии
-----------------------------
*Если вы не айти-бизнес, от внедрений далеки,
Может взять и показаться, что ПО вам не с руки.
Если нет у вас админа, программиста — не беда,
Вендор к вам придёт на помощь — правда, платно, но всегда.*
Это очень распространённый и во многом оправданный страх — компания не хочет ввязываться во внедрение CRM или ERP, потому что это программное обеспечение, и оно требует определённых технических навыков. Во многих нетехнических компаниях малого и среднего бизнеса нет штатных программистов или системных администраторов, а иногда так вовсе весь штат: директор, бухгалтер и продажники. Отсюда возникают опасения: кто внедрит, настроит почту и телефонию, а как программировать процессы и разбираться в этой чёртовой нотации BPMN 2.0, настраивать шаблоны, делать дополнительные отчёты, организовывать рассылки? А если интернет отвалится или сервер рухнет? Нет, хорошо не жили, нечего и начинать — такой фронт забот компании без технического бэкграунда просто не потянуть.
Этот страх порождает второй: как выбрать подрядчика? Аутсорсеры просят деньги за каждый шаг, фрилансеры делают всё тяп-ляп и исчезают с радаров, эникеи по объявлению не справляются с задачами, крупные системные интеграторы — это какие-то люди с другой галактики, судя по прайсам. Брать сотрудника — тоже сомнительное решение, т.к. задач не так много, а заработную плату нужно платить каждый месяц (хотя это лучшее решение для организации ИТ-инфраструктуры в любой компании, а с сотрудником можно договориться: либо сделать зарплату ниже и позволить заниматься своими проектами в офисе, либо назначить ему дополнительные задачи).
В итоге компания теряется и отказывается от внедрения CRM-систем перед лицом возможных технологических трудностей.
### Как бороться
Решение максимально простое: обратитесь к вендору. Не покупайте CRM у коучей и тренеров, рекламных агентств, журналистов и проч., пользуйтесь услугами профессиональных компаний и их технологических партнёров (это те, для кого внедрение и разработка — основной вид деятельности). Вендор имеет большой опыт внедрений и заранее знает, где будут проблемы, на что обратить внимание, где перестраховаться и что разъяснить клиенту (то есть вам) дополнительно. Да, услуги вендора платные, но это профессиональные услуги, за которые вы заплатите один раз и сможете спокойно жить долгое время. Рассмотрим примерный набор услуг вендора, которые вам пригодятся и обойдутся не слишком дорого.
* Базовая настройка CRM, распределение прав доступа, при необходимости настройка дополнительных мер безопасности.
* Обучение пользователей, в том числе онлайн.
* Подключение и интеграция виртуальной АТС, настройка телефонии в привязке к CRM, при необходимости настройка IVR.
* Настройка почтового клиента, мессенджеров, интеграции с сайтом, в том числе с помощью дополнительного ПО.
* Создание шаблонов договоров, коммерческого предложения, первичной документации и т.д.; при наличии технической возможности настройка калькуляторов.
* Моделирование и настройка бизнес-процессов.
* Интеграция с 1С, оборудованием, иным ПО.
* Прочие работы, которые могут оказать влияние на эксплуатацию CRM.
Впечатляющий список, который на самом деле гораздо шире, чем выглядит — мы построили его на своём примере, от вендора к вендору услуги значительно отличаются. Между тем, вы сами, без помощи вендора, программиста и системного администратора можете сэкономить на услугах. Для этого внимательно протестируйте выбранную вами CRM, изучите документацию, разберитесь в логике и вы поймёте, что легко справитесь с настройками, правами доступа, справочниками, бизнес-процессами и даже с рассылками. Это займёт гораздо меньше времени, чем вам кажется. Ну а для дальнейшего обслуживания мы всегда рекомендуем сформировать внутреннего эксперта и воспользоваться пакетом расширенной технической поддержки. Это не так дорого, но быстро, удобно и профессионально — вы не заметите простой в делах.
Руководитель компании на слово «CRM» реагирует «Что-что?»
---------------------------------------------------------
*Если босс совсем не смыслит в техно-инновациях,
То вручную вам придётся проводить транзакции,
Тратить время, средства, нервы и, конечно, силы.
Как итог — печальный бизнес и сотрудник хилый.*
*Какая, на, CRM, на? Работать идите, бездельники.*
Редкая, но ужасная ситуация: сотрудники сами хотят порядка в работе, удобных звонков, рассылок, напоминаний, карточки клиента с полной информацией, а получают в ответ «что ещё за фигня».
Проведём эксперимент. Заходим в google.co.uk, вводим «how persuade boss to buy crm», получаем такой вот список тем в топе:
```
How To Persuade Boss That You Need CRM Software
Convincing Your Boss You Need CRM Software
8 Arguments to convince your manager to adopt a CRM tool
Persuading Your Boss to Invest in the Right Sales Tool
```
Заходим в google.ru, вводим «как убедить начальника внедрить crm», получаем такой вот список тем в топе —
```
никакой, лишь темы с частичным вхождением некоторых слов из запроса.
```
И это, друзья мои, очень показательно — редко в какой российской компании инициатива автоматизации бизнеса идёт снизу. Соответственно, если руководитель знать не знает о CRM, у такой компании рано или поздно возникнут проблемы с работой с клиентами. Да, на таблицах, персональных записях и человеческой памяти можно просуществовать очень долго, однако рано или поздно произойдёт кризисная ситуация, в которой компания окажется незащищённой. После этого операционные риски и проблемы нахлынут серьёзной волной и реакционно мыслящий руководитель не сможет быстро развернуть вектор управления. Поэтому, если вы читаете этот пост и понимаете, что хотите работать в компании, зарабатывать больше, сохранить коллег, попробуйте инициировать автоматизацию — вполне возможно, вы станете героем. Ну или инициатива поимеет инициатора. Мы тут не даём никаких гарантий.
Вы боитесь утонуть в данных
---------------------------
*Если данные кривые, если в цифрах неполадки,
Это очень-очень плохо: значит, бизнес не в порядке.
Значит нет у вас стратегий и успеха нет,
Потому что лишь анализ на процесс льёт свет.*
У вас есть большое количество накопленной информации о сделках, клиентах, сотрудниках, результаты продаж и т.д. Вся эта информация разрозненная и практически не работает. Бывает страшно завести весь этот массив данных в CRM и начать работать с различными срезами — ведь такой анализ может привести к пересмотру как минимум парадигмы продаж, как крайняя мера — всей операционной деятельности. Глубокая аналитика даже небольших данных малого и среднего бизнеса реально способна перевернуть дела с ног на голову (точнее, наконец, поставить на ноги и встряхнуть).
К тому же аналитика требует другого подхода со стороны сотрудников: кроме привычных плана-факта появляются срезы, совершенно по-другому начинает оцениваться воронка продаж. Необходимо уметь интерпретировать полученные данные и применить их для реальной ежедневной работы, а не для красивых графиков на совещаниях и в отчётах перед генеральным. Так появляются страхи: не справиться, ошибиться, спалиться.
### Как бороться
CRM — удобнейший инструмент для аналитики, которые работает на вас. Вы и ваши сотрудники вносите детальные данные по каждой значимой транзакции внутри сделки, наполняете справочники, ведёте клиентов, планируете и т.д., а на выходе получаете множество различных отчётов, которые показывают и количественные, и качественные характеристики процессов (например, мы разработали свыше 100 готовых отчётов для малого и среднего бизнеса, которые включены в базовую поставку [RegionSoft CRM](http://www.regionsoft.ru/)).
Поэтому у вас несколько простых задач для того, чтобы иметь полную картину в цифрах:
* всегда вносить актуальные и корректные данные
* иметь единый источник ввода информации — CRM-систему
* следить за уведомлениями от CRM-системы и своевременно удалять дубли и ошибочные данные
* своевременно выгружать отчёты и отслеживать динамику
* принимать решения на основе аналитики, а не только интуиции.
Вы думаете, что CRM потянет за собой другие покупки софта
---------------------------------------------------------
*Деньги будто тонны три отняло внедрение —
Это значит, что у вас недоразумение.
Потому что если верно и продуманно внедрять,
Ваши деньги не убудут — будут только прирастать ;-)*
*Организованная группировка бизнес-приложений и аддонов пытается подтянуться за CRM.*
А вот этот страх основан на реальных событиях — на рынке действительно немало CRM-систем, которые, кроме абонентской платы, повлекут за собой множество разовых и периодических платежей: покупку коннекторов, плагинов, внешних приложений из маркетплейса и проч. Такой подход связан с бизнес-моделью конкретных вендоров, и вы либо принимаете это, либо ищете вендора, который оглашает весь список :-)
Компании опасаются, что им придётся приобретать или арендовать различное ПО, которое будет интегрировано с CRM: виртуальную АТС, сервис рассылок, складскую программу, программу для учёта закупок и т.д. Цель таких покупок — стремление выстроить единую сквозную ИТ-инфраструктуру с полной автоматизацией. Кроме того, возникает вопрос: насколько эффективно всё это будет работать вместе, сможет ли быть интегрировано и насколько высокой будет стоимость владения?
### Как бороться
Существует очень расхожее мнение, что CRM только для продаж, поэтому нередко компания выбирает первый попавшийся софт (а почти любая CRM способна справиться с базовыми параметрами продаж уровня клиент — сделка — сумма) и не стремиться выбрать комплексное, универсальное решение. Это плохо. Комплексные решения умеют обеспечивать классную автоматизацию, покрывать большую часть требований и экономить деньги. Например, наша CRM-система в старших редакциях включает в себя управление складом, производством, бизнес-процессы, многочисленные справочники, три уровня планировщиков, интеграцию с торговым оборудованием и многое другое. То есть она одна по цене лицензии CRM закрывает кучу вопросов.
Хотя есть задачи, когда приобретение дополнительных софтверных решений целесообразно, но это частные случаи, и их нужно оговаривать с вендором. Но покупать CRM, чтобы отдельно платить за склад + интеграцию, почтовый клиент + коннектор, бизнес-процессы + интеграцию и т.д. это странно и ужасно невыгодно. Выбирайте комплексные, универсальные решения, они круче.
Откуда у страхов растут ноги?
-----------------------------
Причин появления таких страхов много, они сильно отличаются от компании к компании, но есть 4 наиболее распространённых.
1. Недостаток знаний — когда мнение об автоматизации формируется на основании мнения людей в социальных сетях, отзывов тех, кто не смог разобраться в ПО или вовсе лживых, поддельных отзывов на сайтах (мы проводили по этому поводу [своё расследование](https://habr.com/ru/company/regionsoft/blog/444676/)). От вендоров поступает огромное количество информации, за которую они чаще всего отвечают, во всяком случае давно присутствующие на рынке. Изучайте различные источники, проверяйте информацию — нередко бывает, что бессовестные дилеры вендора А просто рерайтят статьи вендора Б и выдают за свои, а экспертиза-то у Б, а не у дилера А. Критическое мышление и доверенные источники (Хабр, сайты и блоги вендоров) — кратчайший путь к ликбезу.
2. Отказ от идеи внедрения — принципиальное нежелание даже попробовать выбрать CRM-систему. Как правило, в основе такого поведения лежит чужой негативный опыт. Здесь нужно понимать, что бизнес бизнесу рознь, и в каждой из компаний внедрение пройдёт по своему сценарию, а эксплуатация принесёт свой результат.
3. Жадность (не путать с расчётливостью и дальновидностью) — большая проблема, которая заключается в полном и ничем не мотивированном отказе от инвестиций в развитие компании. В конечном итоге приводит к стагнации, проблемам с персоналом и отставанию от конкурентов. В современном информационном потоке и при новых покупательских привычках (осмысленно выбирать, требовать качественный сервис, искать выгоду) отсутствие затрат на рекламу, корпоративный софт, развитие персонала чревато проседанием дохода.
4. Непринятие идеи CRM по убеждению («помогли» тренеры, сотрудники и т.д.). Здесь особо нечего комментировать: нет — и всё. Подумайте, чего может стоить такая принципиальность в деловой сфере и в жизни.
Мы перечислили самые распространённые страхи внедрения CRM. Узнали в чём-то себя? У нас для вас плохие новости — если в вашей компании есть эти страхи, значит, в ней в принципе что-то не так и, возможно, проблемы выстрелят в самый неподходящий момент. И мы будем отчаянными лжецами, если скажем, что стоит купить CRM и всё пройдёт. Проблемы гораздо системнее. Хорошо, если вы готовы их преодолевать.
Однако нельзя недооценивать роль автоматизации в наведении порядка в бизнесе. CRM-система помогает учитывать сделки, обеспечивает безопасность данных, частично исключает рутину и сокращает временные затраты на отдельные процессы и операции. Внедрение CRM может стать как итогом пересмотра бизнес-процессов и организационных изменений, так и базисом, который ляжет в основу будущих изменений (этот путь чуть сложнее). Но опыт наших клиентов показывает: с CRM лучше, чем без неё.
---
### Наш арсенал для комплексной автоматизации бизнеса:
[**RegionSoft CRM**](http://regionsoft.ru/) — мощная десктопная CRM-система для малого и среднего бизнеса. **До 30 сентября -15% и куча других плюшек.
NEW!** [**ZEDLine Support**](https://www.zedline.ru/) — облачный хелпдеск с удобным интерфейсом и высокой скоростью работы. Теперь с учётом трудозатрат, а **до 30 сентября мы сами пополняем ваш баланс, добавляя 50% к вашему платежу на лицевой счёт.**
Пишите, звоните, обращайтесь — автоматизируем до зубов! :-) | https://habr.com/ru/post/468843/ | null | ru | null |
# Реверс-инжиниринг рендеринга «Ведьмака 3»
Первая часть перевода находится [здесь](https://habr.com/ru/post/422573/). В этой части мы поговорим об эффекте резкости, средней яркости, фазах Луны и атмосферных явлениях во время дождя.
Часть 6. Sharpen
----------------
В этой части мы подробнее рассмотрим ещё один эффект постобработки из The Witcher 3 — Sharpen.
Sharpening делает изображение на выходе немного чётче. Этот эффект известен нам по Photoshop и другим графическим редакторам.
В The Witcher 3 у sharpening есть две опции: low и high. О разнице между ними я расскажу ниже, а пока давайте взглянем на скриншоты:
*Опция «Low» — до*
*Опция «Low» — после*
*Опция «High» — до*
*Опция «High» — после*
Если вы хотите взглянуть на более подробные (интерактивные) сравнения, то посмотрите [раздел в руководстве о производительности The Witcher 3 компании Nvidia](https://www.geforce.com/whats-new/guides/the-witcher-3-wild-hunt-graphics-performance-and-tweaking-guide#the-witcher-3-wild-hunt-sharpen). Как видите, эффект особенно заметен на траве и листве.
В этой части поста мы изучим кадр из самого начала игры: я выбрал его намеренно, потому что здесь мы видим рельеф (длинная дистанция отрисовки) и купол неба.
С точки зрения входных данных для sharpening требуется цветовой буфер **t0** (LDR после тональной коррекции и lens flares) и буфер глубин **t1**.
Давайте изучим ассемблерный код пиксельного шейдера:
`ps_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb3[3], immediateIndexed
dcl_constantbuffer cb12[23], immediateIndexed
dcl_sampler s0, mode_default
dcl_resource_texture2d (float,float,float,float) t0
dcl_resource_texture2d (float,float,float,float) t1
dcl_input_ps_siv v0.xy, position
dcl_output o0.xyzw
dcl_temps 7
0: ftoi r0.xy, v0.xyxx
1: mov r0.zw, l(0, 0, 0, 0)
2: ld_indexable(texture2d)(float,float,float,float) r0.x, r0.xyzw, t1.xyzw
3: mad r0.x, r0.x, cb12[22].x, cb12[22].y
4: mad r0.y, r0.x, cb12[21].x, cb12[21].y
5: max r0.y, r0.y, l(0.000100)
6: div r0.y, l(1.000000, 1.000000, 1.000000, 1.000000), r0.y
7: mad_sat r0.y, r0.y, cb3[1].z, cb3[1].w
8: add r0.z, -cb3[1].x, cb3[1].y
9: mad r0.y, r0.y, r0.z, cb3[1].x
10: add r0.y, r0.y, l(1.000000)
11: ge r0.x, r0.x, l(1.000000)
12: movc r0.x, r0.x, l(0), l(1.000000)
13: mul r0.z, r0.x, r0.y
14: round_z r1.xy, v0.xyxx
15: add r1.xy, r1.xyxx, l(0.500000, 0.500000, 0.000000, 0.000000)
16: div r1.xy, r1.xyxx, cb3[0].zwzz
17: sample_l(texture2d)(float,float,float,float) r2.xyz, r1.xyxx, t0.xyzw, s0, l(0)
18: lt r0.z, l(0), r0.z
19: if_nz r0.z
20: div r3.xy, l(0.500000, 0.500000, 0.000000, 0.000000), cb3[0].zwzz
21: add r0.zw, r1.xxxy, -r3.xxxy
22: sample_l(texture2d)(float,float,float,float) r4.xyz, r0.zwzz, t0.xyzw, s0, l(0)
23: mov r3.zw, -r3.xxxy
24: add r5.xyzw, r1.xyxy, r3.zyxw
25: sample_l(texture2d)(float,float,float,float) r6.xyz, r5.xyxx, t0.xyzw, s0, l(0)
26: add r4.xyz, r4.xyzx, r6.xyzx
27: sample_l(texture2d)(float,float,float,float) r5.xyz, r5.zwzz, t0.xyzw, s0, l(0)
28: add r4.xyz, r4.xyzx, r5.xyzx
29: add r0.zw, r1.xxxy, r3.xxxy
30: sample_l(texture2d)(float,float,float,float) r1.xyz, r0.zwzz, t0.xyzw, s0, l(0)
31: add r1.xyz, r1.xyzx, r4.xyzx
32: mul r3.xyz, r1.xyzx, l(0.250000, 0.250000, 0.250000, 0.000000)
33: mad r1.xyz, -r1.xyzx, l(0.250000, 0.250000, 0.250000, 0.000000), r2.xyzx
34: max r0.z, abs(r1.z), abs(r1.y)
35: max r0.z, r0.z, abs(r1.x)
36: mad_sat r0.z, r0.z, cb3[2].x, cb3[2].y
37: mad r0.x, r0.y, r0.x, l(-1.000000)
38: mad r0.x, r0.z, r0.x, l(1.000000)
39: dp3 r0.y, l(0.212600, 0.715200, 0.072200, 0.000000), r2.xyzx
40: dp3 r0.z, l(0.212600, 0.715200, 0.072200, 0.000000), r3.xyzx
41: max r0.w, r0.y, l(0.000100)
42: div r1.xyz, r2.xyzx, r0.wwww
43: add r0.y, -r0.z, r0.y
44: mad r0.x, r0.x, r0.y, r0.z
45: max r0.x, r0.x, l(0)
46: mul r2.xyz, r0.xxxx, r1.xyzx
47: endif
48: mov o0.xyz, r2.xyzx
49: mov o0.w, l(1.000000)
50: ret`
50 строк ассемблерного кода выглядят как вполне посильная задача. Давайте приступим к её решению.
### Генерация величины Sharpen
Первый этап заключается в загрузке ([Load](https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-to-load)) буфера глубин (строка 1). Стоит заметить, что в «Ведьмаке 3» используется перевёрнутая глубина (1.0 — близко, 0.0 — далеко). Как вы можете знать, аппаратная глубина привязывается нелинейным образом (подробности см. в [этой статье](https://developer.nvidia.com/content/depth-precision-visualized)).
Строки 3-6 выполняют очень интересный способ привязки этой аппаратной глубины [1.0 — 0.0] к значениям [близко-далеко] (мы задаём их на этапе MatrixPerspectiveFov). Рассмотрим значения из буфера констант:
Имея для «близко» значение 0.2, а для «далеко» значение 5000, мы можем вычислить значения cb12\_v21.xy следующим образом:
`cb12_v21.y = 1.0 / near
cb12_v21.x = - (1.0 / near) + (1.0 / near) * (near / far)`
Этот фрагмент кода довольно часто встречается в шейдерах TW3, поэтому я считаю, что это просто функция.
После получения «глубины пирамиды видимости» строка 7 использует масштаб/искажение для создания коэффициента интерполяции (здесь мы используем [saturate](https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-saturate), чтобы ограничить значения интервалом [0-1]).
cb3\_v1.xy и cb3\_v2.xy — это, яркость эффекта sharpening на ближних и дальних расстояниях. Давайте назовём их «sharpenNear» и «sharpenFar». И это единственное отличие опций «Low» и «High» данного эффекта в The Witcher 3.
Теперь настало время использовать полученный коэффициент. Строки 8-9 просто выполняют `lerp(sharpenNear, sharpenFar, interpolationCoeff)`. Для чего это нужно? Благодаря этому мы получаем разную яркость рядом с Геральтом и вдали от него. Посмотрите:
Возможно, это едва заметно, но здесь мы интерполировали на основании расстояния яркость sharpen рядом с игроком (2.177151) и яркость эффекта очень далеко (1.91303). После этого вычисления мы прибавляем к яркости 1.0 (строка 10). Зачем это нужно? Предположим, что показанная выше операция lerp дала нам 0.0. После прибавления 1.0 мы, естественно, получим 1.0, и это значение, которое не повлияет на пиксель при выполнении sharpening. Подробнее об этом рассказано ниже.
Во время добавления резкости мы не хотим влиять на небо. Этого можно достичь, добавив простую условную проверку:
`// Не выполнять sharpen для неба
float fSkyboxTest = (fDepth >= 1.0) ? 0 : 1;`
В The Witcher 3 значение глубины пикселей неба равно 1.0, поэтому мы используем его, чтобы получить своего рода «двоичный фильтр» (интересный факт: в данном случае [step](https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-step) сработает неправильно).
Теперь мы можем умножить интерполированную яркость на «фильтр неба»:
Это умножение выполняется в строке 13.
Пример кода шейдера:
`// Вычисление финального значения sharpen
float fSharpenAmount = fSharpenIntensity * fSkyboxTest;`
### Центр сэмплирования пикселя
В [SV\_Position](https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-semantics) есть аспект, который будет здесь важен: [смещение в половину пикселя](http://www.asawicki.info/news_1516_half-pixel_offset_in_directx_11.html). Оказывается, что этот пиксель в верхнем левом углу (0, 0) имеет координаты не не (0, 0) с точки зрения of SV\_Position.xy, а (0.5, 0.5). Ничего себе!
Здесь мы хотим взять сэмпл в центре пикселя, поэтому посмотрим на строки 14-16. Можно записать их на HLSL:
`// Сэмплируем центр пикселя.
// Избавляемся от "половинопиксельного" смещения в SV_Position.xy.
float2 uvCenter = trunc( Input.Position.xy );
// Прибавляем половину пикселя, чтобы мы сэмплировали именно центр пикселя
uvCenter += float2(0.5, 0.5);
uvCenter /= g_Viewport.xy`
А позже мы сэмплируем входную текстуру цвета из texcoords «uvCenter». Не волнуйтесь, результат сэмплирования будет тем же, что и при «обычном» способе (SV\_Position.xy / ViewportSize.xy).
### To sharpen or not to sharpen
Решение о том, нужно ли применять sharpen, зависит от fSharpenAmount.
`// Получаем значение текущего пикселя
float3 colorCenter = TexColorBuffer.SampleLevel( samplerLinearClamp, uvCenter, 0 ).rgb;
// Финальный результат
float3 finalColor = colorCenter;
if ( fSharpenAmount > 0 )
{
// здесь выполняем sharpening...
}
return float4( finalColor, 1 );`
### Sharpen
Настало время взглянуть на сами внутренности алгоритма.
По сути, он выполняет следующие действия:
— сэмплирует четыре раза входную текстуру цвета по углам пикселя,
— складывает сэмплы и вычисляет среднее значение,
— вычисляет разность между «center» и «cornerAverage»,
— находит максимальный абсолютный компонент разности,
— корректирует макс. абс. компонент, используя значения scale+bias,
— определяет величину эффекта, используя макс. абс. компонент,
— вычисляет значение яркости (luma) для «centerColor» и «averageColor»,
— делит colorCenter на его luma,
— вычисляет новое, интерполированное значение luma на основе величины эффекта,
— умножает colorCenter на новое значение luma.
Довольно много работы, и мне было сложно в этом разобраться, потому что я никогда не экспериментировал с фильтрами резкости.
Давайте начнём с паттерна сэмплирования. Как можно увидеть в ассемблерном коде, выполняется четыре считывания текстуры.
Лучше всего будет показать это на примере изображения пикселя (уровень мастерства художника — *эксперт*):
Все считывания в шейдере используют билинейное сэмплирование (D3D11\_FILTER\_MIN\_MAG\_LINEAR\_MIP\_POINT).
Смещение от центра до каждого из углов равен (±0.5, ±0.5), в зависимости от угла.
Видите, как это можно реализовать на HLSL? Давайте посмотрим:
`float2 uvCorner;
float2 uvOffset = float2( 0.5, 0.5 ) / g_Viewport.xy; // remember about division!
float3 colorCorners = 0;
// Верхний левый угол
// -0,5, -0.5
uvCorner = uvCenter - uvOffset;
colorCorners += TexColorBuffer.SampleLevel( samplerLinearClamp, uvCorner, 0 ).rgb;
// Верхний правый угол
// +0.5, -0.5
uvCorner = uvCenter + float2(uvOffset.x, -uvOffset.y);
colorCorners += TexColorBuffer.SampleLevel( samplerLinearClamp, uvCorner, 0 ).rgb;
// Нижний левый угол
// -0.5, +0.5
uvCorner = uvCenter + float2(-uvOffset.x, uvOffset.y);
colorCorners += TexColorBuffer.SampleLevel( samplerLinearClamp, uvCorner, 0 ).rgb;
// Нижний правый угол
// +0.5, +0.5
uvCorner = uvCenter + uvOffset;
colorCorners += TexColorBuffer.SampleLevel( samplerLinearClamp, uvCorner, 0 ).rgb;`
Итак, теперь все четыре сэмпла суммированы в переменной «colorCorners». Давайте выполним следующие шаги:
`// Вычисляем среднее четырёх углов
float3 averageColorCorners = colorCorners / 4.0;
// Вычисляем разность цветов
float3 diffColor = colorCenter - averageColorCorners;
// Находим макс. абс. RGB-компонент разности
float fDiffColorMaxComponent = max( abs(diffColor.x), max( abs(diffColor.y), abs(diffColor.z) ) );
// Корректируем этот коэффициент
float fDiffColorMaxComponentScaled = saturate( fDiffColorMaxComponent * sharpenLumScale + sharpenLumBias );
// Вычисляем необходимую величину резкости пикселя.
// Заметьте здесь "1.0" - именно поэтому мы прибавили в fSharpenIntensity значение 1.0.
float fPixelSharpenAmount = lerp(1.0, fSharpenAmount, fDiffColorMaxComponentScaled);
// Вычисляем яркость "центра" пикселя и яркость среднего значения.
float lumaCenter = dot( LUMINANCE_RGB, finalColor );
float lumaCornersAverage = dot( LUMINANCE_RGB, averageColorCorners );
// делим "centerColor" на его яркость
float3 fColorBalanced = colorCenter / max( lumaCenter, 1e-4 );
// Вычисляем новую яркость
float fPixelLuminance = lerp(lumaCornersAverage, lumaCenter, fPixelSharpenAmount);
// Вычисляем цвет на выходе
finalColor = fColorBalanced * max(fPixelLuminance, 0.0);
}
return float4(finalColor, 1.0);`
Распознавание краёв выполняется вычислением макс. абс. компонента разности. Умный ход! Посмотрите его визуализацию:
*Визуализация максимального абсолютного компонента разности.*
Отлично. Готовый HLSL-шейдер выложен [здесь](https://drive.google.com/file/d/1TVMbNldvFS5vbt1gsKPSXlqJijiaDPtt/view?usp=sharing). Простите за довольно плохое форматирование. Можете воспользоваться моей программой [HLSLexplorer](https://astralcode.blogspot.com/2018/11/few-words-about-hlslexplorer.html) и поэкспериментировать с кодом.
Могу с радостью сказать, что представленный выше код создаёт тот же ассемблерный код, что и в игре!
Подведём итог: шейдер резкости «Ведьмака 3» очень хорошо написан (заметьте. что fPixelSharpenAmount больше 1.0! это интересно...). Кроме того, основной способ изменения яркости эффекта — это яркость ближних/дальних объектов. В этой игре они не являются константами; я собрал несколько примеров значений:
Скеллиге:
| | sharpenNear | sharpenFar | sharpenDistanceScale | sharpenDistanceBias | sharpenLumScale | sharpenLumBias |
| --- | --- | --- | --- | --- | --- | --- |
| **low** |
| **high** | 2.0 | 1.8 | 0.025 | -0.25 | -13.33333 | 1.33333 |
Каэр Морхен:
| | sharpenNear | sharpenFar | sharpenDistanceScale | sharpenDistanceBias | sharpenLumScale | sharpenLumBias |
| --- | --- | --- | --- | --- | --- | --- |
| low | 0.57751 | 0.31303 | 0.06665 | -0.33256 | -1.0 | 2.0 |
| high | 2.17751 | 1.91303 | 0.06665 | -0.33256 | -1.0 | 2.0 |
Часть 7. Средняя яркость
------------------------
Операцию вычисления средней яркости текущего кадра можно найти практически в любой современной видеоигре. Это значение часто позже используется для эффекта адаптации глаза и тональной коррекции (см. в [предыдущей части](https://habr.com/ru/post/422573/) поста). В простых решениях используется вычисление яркости для, допустим текстуры размером 5122, затем вычисление её mip-уровней и применение последнего. Обычно это срабатывает, но сильно ограничивает возможности. В более сложных решениях используются вычислительные шейдеры, выполняющие, например [параллельную редукцию](https://software.intel.com/en-us/articles/compute-shader-hdr-and-bloom).
Давайте узнаем, как эту задачу решила в «Ведьмаке 3» команда CD Projekt Red. В предыдущей части я уже исследовал тональную коррекцию и адаптацию глаза, поэтому единственным оставшимся куском головоломки осталась средняя яркость.
Начнём с того, что вычисление средней яркости The Witcher 3 состоит из двух проходов. Для понятности я решил разбить их на отдельные части, и сначала мы рассмотрим первый проход — «распределение яркости» (вычисление гистограммы яркости).
### Распределение яркости
Эти два прохода довольно просто найти в любом анализаторе кадров. Они являются идущими по порядку вызовами [Dispatch](https://docs.microsoft.com/en-us/windows/desktop/api/d3d11/nf-d3d11-id3d11devicecontext-dispatch) прямо перед выполнением адаптации глаза:
Давайте рассмотрим входные данные для этого прохода. Ему необходимы две текстуры:
1) HDR-буфер цветов, масштаб которого снижен до 1/4 x 1/4 (например, с 1920x1080 до 480x270),
2) Полноэкранный буфер глубин
*HDR-буфер цветов с разрешением 1/4 x 1/4. Заметьте хитрый трюк — этот буфер является частью большего буфера. Многократное использование буферов — это хорошая практика.*
*Полноэкранный буфер глубин*
Зачем уменьшать масштаб буфера цветов? Думаю, всё дело в производительности.
Что касается выходных данных этого прохода, то ими является структурированный буфер. 256 элемента по 4 байта каждый.
Здесь у шейдеров нет отладочной информации, поэтому предположим, что это просто буфер беззнаковых значений int.
Важно: первый этап вычисления средней яркости вызывает [ClearUnorderedAccessViewUint](https://docs.microsoft.com/en-us/windows/desktop/api/d3d11/nf-d3d11-id3d11devicecontext-clearunorderedaccessviewuint) для обнуления всех элементов структурированного буфера.
Давайте изучим ассемблерный код вычислительного шейдера (это первый вычислительный шейдер за весь наш анализ!)
`cs_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb0[3], immediateIndexed
dcl_resource_texture2d (float,float,float,float) t0
dcl_resource_texture2d (float,float,float,float) t1
dcl_uav_structured u0, 4
dcl_input vThreadGroupID.x
dcl_input vThreadIDInGroup.x
dcl_temps 6
dcl_tgsm_structured g0, 4, 256
dcl_thread_group 64, 1, 1
0: store_structured g0.x, vThreadIDInGroup.x, l(0), l(0)
1: iadd r0.xyz, vThreadIDInGroup.xxxx, l(64, 128, 192, 0)
2: store_structured g0.x, r0.x, l(0), l(0)
3: store_structured g0.x, r0.y, l(0), l(0)
4: store_structured g0.x, r0.z, l(0), l(0)
5: sync_g_t
6: ftoi r1.x, cb0[2].z
7: mov r2.y, vThreadGroupID.x
8: mov r2.zw, l(0, 0, 0, 0)
9: mov r3.zw, l(0, 0, 0, 0)
10: mov r4.yw, l(0, 0, 0, 0)
11: mov r1.y, l(0)
12: loop
13: utof r1.z, r1.y
14: ge r1.z, r1.z, cb0[0].x
15: breakc_nz r1.z
16: iadd r2.x, r1.y, vThreadIDInGroup.x
17: utof r1.z, r2.x
18: lt r1.z, r1.z, cb0[0].x
19: if_nz r1.z
20: ld_indexable(texture2d)(float,float,float,float) r5.xyz, r2.xyzw, t0.xyzw
21: dp3 r1.z, r5.xyzx, l(0.212600, 0.715200, 0.072200, 0.000000)
22: imul null, r3.xy, r1.xxxx, r2.xyxx
23: ld_indexable(texture2d)(float,float,float,float) r1.w, r3.xyzw, t1.yzwx
24: eq r1.w, r1.w, cb0[2].w
25: and r1.w, r1.w, cb0[2].y
26: add r2.x, -r1.z, cb0[2].x
27: mad r1.z, r1.w, r2.x, r1.z
28: add r1.z, r1.z, l(1.000000)
29: log r1.z, r1.z
30: mul r1.z, r1.z, l(88.722839)
31: ftou r1.z, r1.z
32: umin r4.x, r1.z, l(255)
33: atomic_iadd g0, r4.xyxx, l(1)
34: endif
35: iadd r1.y, r1.y, l(64)
36: endloop
37: sync_g_t
38: ld_structured r1.x, vThreadIDInGroup.x, l(0), g0.xxxx
39: mov r4.z, vThreadIDInGroup.x
40: atomic_iadd u0, r4.zwzz, r1.x
41: ld_structured r1.x, r0.x, l(0), g0.xxxx
42: mov r0.w, l(0)
43: atomic_iadd u0, r0.xwxx, r1.x
44: ld_structured r0.x, r0.y, l(0), g0.xxxx
45: atomic_iadd u0, r0.ywyy, r0.x
46: ld_structured r0.x, r0.z, l(0), g0.xxxx
47: atomic_iadd u0, r0.zwzz, r0.x
48: ret`
И буфер констант:
Мы уже знаем, что первыми входными данными является HDR-буфер цветов. При FullHD его разрешение равно 480x270. Посмотрим на вызов Dispatch.
Dispatch(270, 1, 1) — это означает, что мы запускаем 270 групп потоков. Проще говоря, мы запускаем по одной группе потоков на каждую строку буфера цветов.
*Каждая группа потоков выполняет одну строку HDR-буфера цветов*
Теперь, когда у нас есть этот контекст, давайте попробуем выяснить, что же делает шейдер.
Каждая группа потоков имеет 64 потоков в направлении X (dcl\_thread\_group 64, 1, 1), а также общую память, 256 элементов по 4 байта в каждом (dcl\_tgsm\_structured g0, 4, 256).
Заметьте, что в шейдере мы используем [SV\_GroupThreadID](https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/sv-groupthreadid) (vThreadIDInGroup.x) [0-63] и [SV\_GroupID](https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/sv-groupid) (vThreadGroupID.x) [0-269].
1) Мы начинаем с того, что присваиваем всем элементам общей памяти нулевые значения. Так как в общей памяти содержится 256 элемента и 64 потока на группу, это удобно можно сделать с помощью простого цикла:
`// Первый шаг - присвоение всем общим данным нулевых значений.
// Так как в каждой группе потоков есть 64 потока, каждый из них может с помощью простого смещения обнулить 4 элемента.
[unroll] for (uint idx=0; idx < 4; idx++)
{
const uint offset = threadID + idx*64;
shared_data[ offset ] = 0;
}`
2) После этого мы устанавливаем барьер с помощью [GroupMemoryBarrierWithGroupSync](https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/groupmemorybarrierwithgroupsync) (sync\_g\_t). Мы делаем это, чтобы гарантировать обнуление всеми потоками всех элементов в общей памяти групп перед переходом к следующему этапу.
3) Теперь мы выполняем цикл, который можно приблизительно записать так:
`// cb0_v0.x - это ширина буфера цветов уменьшенного масштаба. Для 1920x1080 она равна 1920/4 = 480;
float ViewportSizeX = cb0_v0.x;
[loop] for ( uint PositionX = 0; PositionX < ViewportSizeX; PositionX += 64 )
{
...`
Это простой цикл for с инкрементом на 64 (вы уже поняли, почему?).
Следующий этап — вычисление позиции загружаемого пикселя.
Давайте подумаем об этом.
Для координаты Y мы можем использовать SV\_GroupID.x, потому что мы запустили 270 групп потоков.
Для координаты X мы… можем воспользоваться преимуществом текущего потока группы! Давайте попробуем это сделать.
Так как в каждой группе по 64 потока, такое решение обойдёт все пиксели.
Рассмотрим группу потоков (0, 0, 0).
— Поток (0, 0, 0) обработает пиксели (0, 0), (64, 0), (128, 0), (192, 0), (256, 0), (320, 0), (384, 0), (448, 0).
— Поток (1, 0, 0) обработает пиксели (1, 0), (65, 0), (129, 0), (193, 0), (257, 0), (321, 0), (385, 0), (449, 0)…
— Поток (63, 0, 0) обработает пиксели (63, 0), (127, 0), (191, 0), (255, 0), (319, 0), (383, 0), (447, 0)
Таким образом, будут обработаны все пиксели.
Также нам нужно гарантировать, что мы не загрузим пиксели из-за пределов буфера цветов:
`// Мы попиксельно перемещаемся вдоль оси X. Значение Y равно GroupID.
uint CurrentPixelPositionX = PositionX + threadID;
uint CurrentPixelPositionY = groupID;
if ( CurrentPixelPositionX < ViewportSizeX )
{
// HDR-буфер цветов.
// Вычисляем позицию HDR-буфера цветов в экранном пространстве, загружаем его и вычисляем яркость.
uint2 colorPos = uint2(CurrentPixelPositionX, CurrentPixelPositionY);
float3 color = texture0.Load( int3(colorPos, 0) ).rgb;
float luma = dot(color, LUMA_RGB);`
Видите? Всё довольно просто!
Также я вычислил яркость (строка 21 ассемблерного кода).
Отлично, мы уже вычислили яркость из цветного пикселя. Следующий шаг — загрузка (не сэмплирование!) соответствующего значения глубины.
Но здесь у нас есть проблема, потому что мы подключили буфер глубин полного разрешения. Что с этим делать?
Это на удивление просто — достаточно умножить colorPos на какую-нибудь константу (cb0\_v2.z). Мы уменьшили масштаб HDR-буфера цветов в четыре раза. поэтому значением будет 4!
`const int iDepthTextureScale = (int) cb0_v2.z;
uint2 depthPos = iDepthTextureScale * colorPos;
float depth = texture1.Load( int3(depthPos, 0) ).x;`
Пока всё здорово! Но… мы дошли до строк 24-25…
`24: eq r2.x, r2.x, cb0[2].w
25: and r2.x, r2.x, cb0[2].y`
Так. Сначала у нас есть [сравнение равенства](https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/eq--sm4---asm-) с плавающей запятой, его результат записывается в r2.x, а сразу после этого идёт… что? Побитовое [И](https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/and--sm4---asm-)?? Серьёзно? Для значения с плавающей запятой? Какого чёрта???
**Проблема 'eq+and'**
Позвольте просто сказать, что это для меня была самая сложная часть шейдера. Я даже пробовал странные комбинации asint/asfloat…
А если использовать немного другой подход? Давайте просто выполним в HLSL обычное сравнение float-float.
`float DummyPS() : SV_Target0
{
float test = (cb0_v0.x == cb0_v0.y);
return test;
}`
А вот как выглядит вывод в ассемблерном коде:
`0: eq r0.x, cb0[0].y, cb0[0].x
1: and o0.x, r0.x, l(0x3f800000)
2: ret`
Интересно, правда? Не ожидал увидеть здесь «and».
0x3f800000 — это просто 1.0f… Логично, потому что мы получаем в случае успеха сравнения 1.0 и 0.0 в противном случае.
А что если мы «заменим» 1.0 каким-то другим значением? Например так:
`float DummyPS() : SV_Target0
{
float test = (cb0_v0.x == cb0_v0.y) ? cb0_v0.z : 0.0;
return test;
}`
Получим такой результат:
`0: eq r0.x, cb0[0].y, cb0[0].x
1: and o0.x, r0.x, cb0[0].z
2: ret`
Ха! Сработало. Это просто магия компилятора HLSL. Примечание: если заменить чем-то другим 0.0, то получится просто movc.
Вернёмся к вычислительному шейдеру. Следующим шагом будет проверка равенства глубины значению cb0\_v2.w. Оно всегда равно 0.0 — проще говоря, мы проверяем, находится ли пиксель на дальней плоскости (в небе). Если да, то мы присваиваем этому коэффициенту какое-то значение, приблизительно 0.5 (я проверял на нескольких кадрах).
Такой вычисленный коэффициент используется для интерполяции между яркостью цвета и яркостью «неба» (значением cb0\_v2.x, которое часто примерно равно 0.0). Предполагаю, что это нужно для управления важностью неба в вычислении средней яркости. Обычно важность уменьшается. Очень умная идея.
`// Проверяем, лежит ли пиксель на дальней плоскости (в небе). Если да, то мы можем указать, как он будет
// смешиваться с нашими значениями.
float value = (depth == cb0_v2.w) ? cb0_v2.y : 0.0;
// Если 'value' равно 0.0, то эта lerp просто даёт нам 'luma'. Однако если 'value' отличается
// (часто около 0.50), то вычисленное luma имеет гораздо меньший вес. (cb0_v2.x обычно близко к 0.0).
float lumaOk = lerp( luma, cb0_v2.x, value );`
Так как у нас есть lumaOk, следующим этапом будет вычисление его натурального логарифма для создания хорошего распределения. Но постойте, допустим, lumaOk равно 0.0. Мы знаем, что значение log(0) является неопределённым, поэтому прибавляем 1.0, потому что log(1) = 0.0.
После этого мы масштабируем вычисленный логарифм на 128, чтобы распределить его по 256 ячейкам. Очень умно!
И именно отсюда берётся это значение 88.722839. Это `128 * натуральный логарифм (2)`.
Это просто способ, которым HLSL вычисляет логарифмы.
В ассемблерном коде HLSL есть только одна функция, вычисляющая логарифмы: [log](https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/log--sm4---asm-), и она имеет основание 2.
`// Предположим, что lumaOk равно 0.0.
// log(0) имеет значение undefined
// log(1) = 0.
// вычисляем натуральный логарифм яркости
lumaOk = log(lumaOk + 1.0);
// Масштабируем логарифм яркости на 128
lumaOk *= 128;`
Наконец мы вычисляем из логарифмически распределённой яркости индекс ячейки и прибавляем 1 к соответствующей ячейке в общей памяти.
`// Вычисляем правильный индекс. Значение имеет формат Uint, поэтому в массиве 256 элементов,
// нужно убедиться, что мы не вышли за границы.
uint uLuma = (uint) lumaOk;
uLuma = min(uLuma, 255);
// Прибавляем 1 к соответствующему значению яркости.
InterlockedAdd( shared_data[uLuma], 1 );`
Следующим шагом снова будет установка барьера, чтобы гарантировать, что были обработаны все пиксели в строке.
А последним шагом будет прибавление значений из общей памяти в структурированный буфер. Это делается тем же самым образом, через простой цикл:
`// Ждём, пока обработаются все пиксели в строке
GroupMemoryBarrierWithGroupSync();
// Прибавление вычисленных значений в структурированный буфер.
[unroll] for (uint idx = 0; idx < 4; idx++)
{
const uint offset = threadID + idx*64;
uint data = shared_data[offset];
InterlockedAdd( g_buffer[offset], data );
}`
После того, как все 64 потока в группе потоков заполнят общие данные, каждый поток добавляет 4 значения в буфер вывода.
Рассмотрим буфер вывода. Давайте подумаем об этом. Сумма всех значений в буфере равна общему количеству пикселей! (при 480x270 = 129 600). То есть мы знаем, сколько пикселей имеют конкретное значение яркости.
Если вы слабо разбираетесь в вычислительных шейдерах (как я), то поначалу это может быть непонятно, поэтому прочитайте пост ещё несколько раз, возьмите бумагу и карандаш, и попробуйте разобраться в концепциях, на которых построена эта техника.
Вот и всё! Именно так «Ведьмак 3» вычисляет гистограмму яркости. Лично я при написании этой части многому научился. Поздравляю ребят из CD Projekt Red с отличной работой!
Если вы интересуетесь полным HLSL-шейдером, то он выложен [здесь](https://pastebin.com/8tgrw1bi). Я всегда стремлюсь получить как можно более близкий к игровому ассемблерный код и совершенно счастлив, что мне это снова удалось!
Вычисление средней яркости
--------------------------
Это вторая часть анализа вычислений средней яркости в «The Witcher 3: Wild Hunt».
Прежде чем мы вступим в бой с ещё одним вычислительным шейдером, давайте вкратце повторим, что произошло в прошлой части: мы работали с HDR-буфером цветов с уменьшенным до 1/4x1/4 масштабом. После первого прохода мы получили гистограмму яркости (структурированный буфер 256 беззнаковых целочисленных значений). Мы вычислили логарифм для яркости каждого пикселя, распределили его по 256 ячейкам и увеличили соответствующее значение структурированного буфера по 1 на пиксель. Благодаря этому общая сумма всех значений в этих 256 ячейках равна количеству пикселей.
*Пример вывода первого прохода. Здесь 256 элементов.*
Например, наш полноэкранный буфер имеет размер 1920x1080. После уменьшения масштаба первый проход использовал буфер 480x270. Сумма всех 256 значений в буфере будет равна 480 \* 270 = 129 600.
После этого краткого вступления мы готовы перейти к следующему этапу: к вычислениям.
На этот раз используется только одна группа потоков ( Dispatch(1, 1, 1) ).
Давайте посмотрим на ассемблерный код вычислительного шейдера:
`cs_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb0[1], immediateIndexed
dcl_uav_structured u0, 4
dcl_uav_typed_texture2d (float,float,float,float) u1
dcl_input vThreadIDInGroup.x
dcl_temps 4
dcl_tgsm_structured g0, 4, 256
dcl_thread_group 64, 1, 1
0: ld_structured_indexable(structured_buffer, stride=4)(mixed,mixed,mixed,mixed) r0.x, vThreadIDInGroup.x, l(0), u0.xxxx
1: store_structured g0.x, vThreadIDInGroup.x, l(0), r0.x
2: iadd r0.xyz, vThreadIDInGroup.xxxx, l(64, 128, 192, 0)
3: ld_structured_indexable(structured_buffer, stride=4)(mixed,mixed,mixed,mixed) r0.w, r0.x, l(0), u0.xxxx
4: store_structured g0.x, r0.x, l(0), r0.w
5: ld_structured_indexable(structured_buffer, stride=4)(mixed,mixed,mixed,mixed) r0.x, r0.y, l(0), u0.xxxx
6: store_structured g0.x, r0.y, l(0), r0.x
7: ld_structured_indexable(structured_buffer, stride=4)(mixed,mixed,mixed,mixed) r0.x, r0.z, l(0), u0.xxxx
8: store_structured g0.x, r0.z, l(0), r0.x
9: sync_g_t
10: if_z vThreadIDInGroup.x
11: mul r0.x, cb0[0].y, cb0[0].x
12: ftou r0.x, r0.x
13: utof r0.y, r0.x
14: mul r0.yz, r0.yyyy, cb0[0].zzwz
15: ftoi r0.yz, r0.yyzy
16: iadd r0.x, r0.x, l(-1)
17: imax r0.y, r0.y, l(0)
18: imin r0.y, r0.x, r0.y
19: imax r0.z, r0.y, r0.z
20: imin r0.x, r0.x, r0.z
21: mov r1.z, l(-1)
22: mov r2.xyz, l(0, 0, 0, 0)
23: loop
24: breakc_nz r2.x
25: ld_structured r0.z, r2.z, l(0), g0.xxxx
26: iadd r3.x, r0.z, r2.y
27: ilt r0.z, r0.y, r3.x
28: iadd r3.y, r2.z, l(1)
29: mov r1.xy, r2.yzyy
30: mov r3.z, r2.x
31: movc r2.xyz, r0.zzzz, r1.zxyz, r3.zxyz
32: endloop
33: mov r0.w, l(-1)
34: mov r1.yz, r2.yyzy
35: mov r1.xw, l(0, 0, 0, 0)
36: loop
37: breakc_nz r1.x
38: ld_structured r2.x, r1.z, l(0), g0.xxxx
39: iadd r1.y, r1.y, r2.x
40: utof r2.x, r2.x
41: utof r2.w, r1.z
42: add r2.w, r2.w, l(0.500000)
43: mul r2.w, r2.w, l(0.011271)
44: exp r2.w, r2.w
45: add r2.w, r2.w, l(-1.000000)
46: mad r3.z, r2.x, r2.w, r1.w
47: ilt r2.x, r0.x, r1.y
48: iadd r2.w, -r2.y, r1.y
49: itof r2.w, r2.w
50: div r0.z, r3.z, r2.w
51: iadd r3.y, r1.z, l(1)
52: mov r0.y, r1.z
53: mov r3.w, r1.x
54: movc r1.xzw, r2.xxxx, r0.wwyz, r3.wwyz
55: endloop
56: store_uav_typed u1.xyzw, l(0, 0, 0, 0), r1.wwww
57: endif
58: ret`
Здесь есть один буфер констант:
Вкратце взглянем на ассемблерный код: прикреплено два UAV (u0: входной буфер из первой части и u1: выходная текстура формата 1x1 R32\_FLOAT). Также мы видим, что есть 64 потока на группу и 256 элементов 4-байтной общей групповой памяти.
Начнём с заполнения общей памяти данными из входного буфера. У нас 64 потока, поэтому делать придётся почти то же самое, что и раньше.
Чтобы быть абсолютно уверенными, что для дальнейшей обработки загружены все данные, после этого мы ставим барьер.
`// Первый этап - заполнение всех общих данных данными из предыдущего этапа.
// Так как в каждой группе потоков по 64 потока, каждый может заполнить 4 элемента в одном потоке
// с помощью простого смещения.
[unroll] for (uint idx=0; idx < 4; idx++)
{
const uint offset = threadID + idx*64;
shared_data[ offset ] = g_buffer[offset];
}
// Здесь мы устанавливаем барьер, то есть блокируем выполнение всех потоков группы, пока не будет завершён
// весь общий доступ групп и все потоки в группе не достигнут этого вызова.
GroupMemoryBarrierWithGroupSync();`
Все вычисления выполняются только в одном потоке, все другие используются просто для загрузки значений из буфера в общую память.
«Вычисляющий» поток имеет индекс 0. Почему? Теоретически, мы можем использовать любой поток из интервала [0-63], но благодаря сравнению с 0 мы можем избежать дополнительного сравнения integer-integer (инструкции [ieq](https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/ieq--sm4---asm-)).
Алгоритм основан на указании интервала пикселей, которые будут учитываться в операции.
В строке 11 мы умножаем width\*height, получая общее количество пикселей и умножаем их на два числа из интервала [0.0f-1.0f], обозначающие начало и конец интервала. Дальше используются ограничения, гарантирующие, что `0 <= Start <= End <= totalPixels - 1`:
`// Выполняем вычисления только для потока с индексом 0.
[branch] if (threadID == 0)
{
// Общее количество пикселей в буфере с уменьшенным масштабом
uint totalPixels = cb0_v0.x * cb0_v0.y;
// Интервал пикселей (или, если конкретнее, интервал яркости на экране),
// который мы хотим задействовать в вычислении средней яркости.
int pixelsToConsiderStart = totalPixels * cb0_v0.z;
int pixelsToConsiderEnd = totalPixels * cb0_v0.w;
int pixelsMinusOne = totalPixels - 1;
pixelsToConsiderStart = clamp( pixelsToConsiderStart, 0, pixelsMinusOne );
pixelsToConsiderEnd = clamp( pixelsToConsiderEnd, pixelsToConsiderStart, pixelsMinusOne );`
Как видите, ниже есть два цикла. Проблема с ними (или с их ассемблерным кодом) в том, что в концах циклов есть странные условные переходы. Мне было очень сложно воссоздать их. Также взгляните на строку 21. Почему там "-1"? Я объясню это чуть ниже.
Задача первого цикла — отбросить *pixelsToConsiderStart* и дать нам индекс ячейки буфера, в которой присутствует пиксель *pixelsToConsiderStart* +1 (а также количество всех пикселей в предыдущих ячейках).
Допустим, что *pixelsToConsiderStart* примерно равна 30000, а в буфере 37000 пикселей в ячейке «ноль» (такое случается в игре ночью). Поэтому мы хотим начать анализ яркости примерно с пикселя 30001, который присутствует в ячейке «ноль». В данном случае мы сразу же выходим из цикла, получив начальный индекс '0' и ноль отброшенных пикселей.
Посмотрите на код HLSL:
`// Количество уже обработанных пикселей
int numProcessedPixels = 0;
// Ячейка яркости [0-255]
int lumaValue = 0;
// Надо ли продолжать выполнение цикла
bool bExitLoop = false;
// Задача первого цикла - отбросить "pixelsToConsiderStart" пикселей.
// Мы сохраняем количество отброшенных пикселей из предыдущих ячеек и lumaValue, чтобы использовать их в следующем цикле.
[loop]
while (!bExitLoop)
{
// Получаем количество пикселей с заданным значением яркости.
uint numPixels = shared_data[lumaValue];
// Проверяем, сколько пикселей должно быть с lumaValue
int tempSum = numProcessedPixels + numPixels;
// Если больше, чем pixelsToConsiderStart, то выходим из цикла.
// Следовательно, мы начнём вычисление яркости из lumaValue.
// Проще говоря, pixelsToConsiderStart - это количество "затемнённых" пикселей, которые нужно отбросить, прежде чем начинать вычисления.
[flatten]
if (tempSum > pixelsToConsiderStart)
{
bExitLoop = true;
}
else
{
numProcessedPixels = tempSum;
lumaValue++;
}
}`
Загадочное число "-1" из строки 21 ассемблерного кода связано с булевым условием выполнения цикла (я обнаружил это почти случайно).
Получив количество пикселей из ячеек *lumaValue* и само *lumaValue*, мы можем переходить ко второму циклу.
Задача второго цикла — вычисление влияния пикселей и средней яркости.
Мы начинаем с *lumaValue*, вычисленного в первом цикле.
`float finalAvgLuminance = 0.0f;
// Количество отброшенных в первом цикле пикселей
uint numProcessedPixelStart = numProcessedPixels;
// Задача этого цикла - вычисление влияния пикселей и средней яркости.
// Мы начинаем с точки, вычисленной в предыдущем цикле, сохраняя количество отброшенных пикселей и начальную позицию lumaValue.
// Декодируем значение яркости из интервала [0-255], умножаем его на количество пикселей, имеющих это значение яркости, и суммируем их, пока не дойдём
// до обработки пикселей pixelsToConsiderEnd.
// После этого мы делим общее влияние на количество проанализированных пикселей.
bExitLoop = false;
[loop]
while (!bExitLoop)
{
// Получаем количество пикселей с заданным значением яркости.
uint numPixels = shared_data[lumaValue];
// Прибавляем ко всем обработанным пикселям
numProcessedPixels += numPixels;
// Текущее обрабатываемое значение яркости, распределённое в интервале [0-255] (uint)
uint encodedLumaUint = lumaValue;
// Количество пикселей с текущим обрабатываемым значением яркости
float numberOfPixelsWithCurrentLuma = numPixels;
// Текущее обрабатываемое значение яркости, закодированное в интервале [0-255] (float)
float encodedLumaFloat = encodedLumaUint;`
На этом этапе мы получили закодированное в интервале [0.0f-255.f] значение яркости.
Процесс декодирования довольно прост — нужно обратить вычисления этапа кодирования.
Краткий повтор процесса кодирования:
`float luma = dot( hdrPixelColor, float3(0.2126, 0.7152, 0.0722) );
...
float outLuma;
// так как log(0) равен undef, а log(1) = 0
outLuma = luma + 1.0;
// распределяем логарифмически
outLuma = log( outLuma );
// масштабируем на 128, что означает log(1) * 128 = 0, log(2,71828) * 128 = 128, log(7,38905) * 128 = 256
outLuma = outLuma * 128
// преобразуем в uint
uint outLumaUint = min( (uint) outLuma, 255);`
Чтобы декодировать яркость, мы обращаем процесс кодирования, например вот так:
`// начинаем с прибавления 0.5f (мы не хотим, чтобы получился нулевой результат)
float fDecodedLuma = encodedLumaFloat + 0.5;
// и декоридуем яркость:
// Делим на 128
fDecodedLuma /= 128.0;
// exp(x), что отменяет log(x)
fDecodedLuma = exp(fDecodedLuma);
// Вычитаем 1.0
fDecodedLuma -= 1.0;`
Затем мы вычисляем распределение, умножая количество пикселей с заданной яркостью на декодированную яркость, и суммируя их, пока не дойдём до обработки *pixelsToConsiderEnd*пикселей.
После этого мы делим общее влияние на число проанализированных пикселей.
Вот оставшаяся часть цикла (и шейдера):
`// Вычисляем влияние этой яркости
float fCurrentLumaContribution = numberOfPixelsWithCurrentLuma * fDecodedLuma;
// (Временное) влияние от всех предыдущих проходов и текущего.
float tempTotalContribution = fCurrentLumaContribution + finalAvgLuminance;
[flatten]
if (numProcessedPixels > pixelsToConsiderEnd )
{
// чтобы выйти из цикла
bExitLoop = true;
// Мы уже обработали все нужные пиксели, поэтому выполняем здесь окончательное деление.
// Количество всех обработанных пикселей для выбранного пользователем начала
int diff = numProcessedPixels - numProcessedPixelStart;
// Вычисляем окончательную среднюю яркость
finalAvgLuminance = tempTotalContribution / float(diff);
}
else
{
// Передаём текущее влияние дальше и увеличиваем lumaValue
finalAvgLuminance = tempTotalContribution;
lumaValue++;
}
}
// Сохраняем среднюю яркость
g_avgLuminance[uint2(0,0)] = finalAvgLuminance;`
Полный шейдер выложен [здесь](https://pastebin.com/U6zqMrcP). Он полностью совместим с моей программой [HLSLexplorer](https://astralcode.blogspot.com/2018/11/few-words-about-hlslexplorer.html), без которой бы я не смог эффективно воссоздать вычисление средней яркости в «Ведьмаке 3» (да и все другие эффекты тоже!).
В заключение несколько мыслей. С точки зрения вычисления средней яркости этот шейдер было сложно воссоздать. Основные причины:
1) Странные «отложенные» проверки выполнения цикла, на это потребовалось гораздо больше времени, чем я предполагал ранее.
2) Проблемы с отладкой этого вычислительного шейдера в RenderDoc (v. 1.2).
Операции «ld\_structured\_indexable» поддерживаются не полностью, хотя результат считывания из индекса 0 даёт верное значение, все остальные возвращают нули, из-за чего циклы продолжаются бесконечно.
Хоть мне и не удалось добиться того же ассемблерного кода, что и в оригинале (ниже см. скриншот с различиями), с помощью RenderDoc я смог выполнить инъекцию этого шейдера в конвейер — и результаты оказались такими же!
*Результат битвы. Слева — мой шейдер, справа — оригинальный ассемблерный код.*
Часть 8. Луна и её фазы
-----------------------
В восьмой части статьи я исследую шейдер Луны из «Ведьмака 3» (а конкретнее — из расширения «Кровь и вино»).
Луна — важный элемент ночного неба, и её может быть достаточно сложно сделать правдоподобной, но для меня прогулки по ночам в TW3 стали настоящим удовольствием.
Только посмотрите на эту сцену!
Прежде чем мы возьмёмся за пиксельный шейдер, скажу несколько слов о нюансах рендеринга. С геометрической точки зрения, Луна — это просто сфера (см. ниже), у которой есть координаты текстур, векторы нормалей и касательных. Вершинный шейдер вычисляет позицию в мировом пространстве, а также нормализованные векторы нормалей, касательных и касательных к двум точкам (с помощью векторного произведения), умноженные на матрицу мира.
Чтобы гарантировать, что Луна полностью лежит на удалённой плоскости, полям MinDepth и MaxDepth структуры [D3D11\_VIEWPORT](https://docs.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_viewport) присвоены значения 0.0 (тот же трюк, который использовался для купола неба). Луна рендерится сразу после неба.
*Сфера, используемая для отрисовки Луны*
Ну всё, думаю, можно приступать. Давайте взглянем на пиксельный шейдер:
`ps_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb0[1], immediateIndexed
dcl_constantbuffer cb2[3], immediateIndexed
dcl_constantbuffer cb12[267], immediateIndexed
dcl_sampler s0, mode_default
dcl_resource_texture2d (float,float,float,float) t0
dcl_input_ps linear v1.w
dcl_input_ps linear v2.xyzw
dcl_input_ps linear v3.xy
dcl_input_ps linear v4.xy
dcl_output o0.xyzw
dcl_temps 3
0: mov r0.x, -cb0[0].w
1: mov r0.y, l(0)
2: add r0.xy, r0.xyxx, v2.xyxx
3: sample_indexable(texture2d)(float,float,float,float) r0.xyzw, r0.xyxx, t0.xyzw, s0
4: add r0.xyz, r0.xyzx, l(-0.500000, -0.500000, -0.500000, 0.000000)
5: log r0.w, r0.w
6: mul r0.w, r0.w, l(2.200000)
7: exp r0.w, r0.w
8: add r0.xyz, r0.xyzx, r0.xyzx
9: dp3 r1.x, r0.xyzx, r0.xyzx
10: rsq r1.x, r1.x
11: mul r0.xyz, r0.xyzx, r1.xxxx
12: mul r1.xy, r0.yyyy, v3.xyxx
13: mad r0.xy, v4.xyxx, r0.xxxx, r1.xyxx
14: mad r0.xy, v2.zwzz, r0.zzzz, r0.xyxx
15: mad r0.z, cb0[0].y, l(0.033864), cb0[0].w
16: mul r0.z, r0.z, l(6.283185)
17: sincos r1.x, r2.x, r0.z
18: mov r2.y, r1.x
19: dp2_sat r0.x, r0.xyxx, r2.xyxx
20: mul r0.xyz, r0.xxxx, cb12[266].xyzx
21: mul r0.xyz, r0.xyzx, r0.wwww
22: mul r0.xyz, r0.xyzx, cb2[2].xyzx
23: add_sat r0.w, -v1.w, l(1.000000)
24: mul r0.w, r0.w, cb2[2].w
25: mul o0.xyz, r0.wwww, r0.xyzx
26: mov o0.w, l(0)
27: ret`
Главная причина того, что я выбрал шейдер из «Крови и вина», проста — он короче.
Сначала мы вычисляем смещение для сэмплирования текстуры.
cb0[0].w используется как смещение по оси X. С помощью этого простого трюка мы можем симулировать вращение Луны вокруг своей оси.
*Примеры значений из буфера констант*
В качестве входных данных прикреплена одна текстура (1024x512). В RGB-каналах закодирована карта нормалей, а в альфа-канале — цвет поверхности Луны. Умно!
*Альфа-канал текстуры — это цвет поверхности Луны.*
*RGB-каналы текстуры — это карта нормалей.*
Получив правильные координаты текстуры, мы сэмплируем RGBA-каналы. Нам необходимо распаковать карту нормалей и выполнить гамма-коррекцию цвета поверхности. На текущий момент HLSL-шейдер можно записать вот так, например:
`float4 MoonPS(in InputStruct IN) : SV_Target0
{
// Смещения Texcoords
float2 uvOffsets = float2(-cb0_v0.w, 0.0);
// Готовые texcoords
float2 uv = IN.param2.xy + uvOffsets;
// Сэмплирование текстуры
float4 sampledTexture = texture0.Sample( sampler0, uv);
// Цвет поверхности Луны - выполняем гамма-коррекцию
float moonColorTex = pow(sampledTexture.a, 2.2 );
// Распаковываем нормали из интервала [0,1] в интервал [-1,1].
// Примечание: sampledTexture.xyz * 2.0 - 1.0 работает аналогичным образом
float3 sampledNormal = normalize((sampledTexture.xyz - 0.5) * 2);`
Следующим шагом будет выполнение привязки нормалей, но только в компонентах XY. (В The Witcher 3 ось Z направлена вверх, а весь Z-канал текстуры равен 1.0). Мы можем сделать это следующим образом:
`// Векторы касательного пространства
float3 Tangent = IN.param4.xyz;
float3 Normal = float3(IN.param2.zw, IN.param3.w);
float3 Bitangent = IN.param3.xyz;
// Матрица TBN
float3x3 TBN = float3x3(Tangent, Bitangent, Normal);
// Вычисление вектора нормали XY
// Ужимаем матрицу TBN во float3x2: 3 строки, 2 столбца
float2 vNormal = mul(sampledNormal, (float3x2)TBN).xy;`
Теперь настало время моей любимой части этого шейдера. Снова взгляните на строки 15-16:
`15: mad r0.z, cb0[0].y, l(0.033864), cb0[0].w
16: mul r0.z, r0.z, l(6.283185)`
Что это за загадочное 0.033864? Поначалу кажется, что в нём нет никакого смысла, но если вычислить обратное ему значение, то получим примерно 29.53, что равно длительности [синодического месяца](https://en.wikipedia.org/wiki/Lunar_month#Synodic_month) в сутках! Вот, что я называю внимательностью к деталям!
Мы можем достоверно предположить, что cb0[0].y — это количество дней, прошедших за время геймплея. Здесь используется дополнительное отклонение, применяемое в качестве смещения по оси X текстуры.
Получив этот коэффициент, мы умножаем его на 2\*Pi.
Затем с помощью sincos мы вычисляем другой 2d-вектор.
Вычислением скалярного произведения между вектором нормали и «лунным» вектором симулируется одна фаза луны.
`// Лунная фаза.
// Мы вычисляем days/29.53 + bias.
float phase = cb0_v0.y * (1.0 / SYNODIC_MONTH_LENGTH) + cb0_v0.w;
// Умножаем на 2*PI. Таким образом, 29.53 будет равно полному периоду
// для функций sin/cos.
phase *= TWOPI;
// Вычисляем синус и косинус лунной фазы.
float outSin = 0.0;
float outCos = 0.0;
sincos(phase, outSin, outCos);
// Вычисляем лунную фазу
float lunarPhase = saturate( dot(vNormal, float2(outCos, outSin)) );`
Посмотрите на скриншоты с разными фазами Луны:
Последний этап — выполнение серии операций умножения для вычисления окончательного цвета.
`// Выполняем серию операций умножения для вычисления окончательного цвета.
// cb12_v266.xyz используется, чтобы усилить свечение и цвет Луны.
// например (1.54, 2.82, 4.13)
float3 moonSurfaceGlowColor = cb12_v266.xyz;
float3 moonColor = lunarPhase * moonSurfaceGlowColor;
moonColor = moonColorTex * moonColor;
// cb_v2.xyz - это, вероятно, фильтр, например (1.0, 1.0, 1.0)
moonColor *= cb2_v2.xyz;
// Не совсем понимаю, что делает этот фрагмент, возможно. это какое-то значение непрозрачности горизонта.
// Как бы то ни было, он имеет не такое большое влияние на окончательный цвет,
// как параметры выше.
float paramHorizon = saturate(1.0 - IN.param1.w);
paramHorizon *= cb2_v2.w;
moonColor *= paramHorizon;
// Выводим окончательный цвет с нулевым значением альфы
return float4(moonColor, 0.0);`
Возможно, вы не понимаете, почему этот шейдер передаёт на выход значение альфы 0.0. Это потому, что Луна рендерится со включенным смешением:
Такой подход позволяет получать цвет фона (неба), если этот шейдер возвращает чёрный цвет.
Если вам интересен полный шейдер, то можно взять его [здесь](https://pastebin.com/NTqC8sSu). У него большие буферы констант и он уже должен быть готов к инъекции в RenderDoc вместо оригинального шейдера (просто переименуйте «MoonPS» в «EditedShaderPS»).
И последнее: я хотел поделиться с вами результатами:
Слева — мой шейдер, справа — оригинальный шейдер из игры.
Разница минимальна и не влияет на результаты.
Как видите, этот шейдер воссоздать было довольно просто.
Часть 9. G-буфер
----------------
В этой части я раскрою некоторые подробности геометрического буфера (gbuffer) в The Witcher 3.
Будем считать, что вы знаете основы отложенного затенения (deferred shading).
Краткое повторение: идея откладывания в том, чтобы не вычислять всё готовое освещение и затенение сразу, а разделить вычисления на два этапа.
В первом (проходе геометрии) мы заполняем GBuffer данными о поверхности (позиция, нормали, specular color и т.д...), а во втором (проходе освещения) комбинируем всё и вычисляем освещение.
Отложенное затенение — это очень популярный подход, потому что оно позволяет вычислять за один полноэкранный проход такими техниками, как [тайловое отложенное затенение](https://software.intel.com/en-us/articles/deferred-rendering-for-current-and-future-rendering-pipelines), что сильно повышает производительность.
Если говорить просто, то GBuffer — это набор текстур со свойствами геометрии. Очень важно создать для него правильную структуру. В качестве примера из реальной жизни можно изучить [технологии рендеринга Crysis 3](https://www.slideshare.net/TiagoAlexSousa/rendering-technologies-from-crysis-3-gdc-2013).
После этого краткого введения давайте рассмотрим пример кадра из «Ведьмака 3: Кровь и вино»:
*Одна из множества гостиниц в Туссенте*
Основной GBuffer состоит из трёх полноэкранных render target в формате DXGI\_FORMAT\_R8G8B8A8\_UNORM и буфера глубин + стенсила в формате DXGI\_FORMAT\_D24\_UNORM\_S8\_UINT.
Вот их скриншоты:
*Render Target 0 — RGB-каналы, цвет поверхности*
*Render Target 0 — альфа-канал. Честно говоря, понятия не имею, что это за информация.*
*Render Target 1 — RGB-каналы. Здесь записаны векторы нормалей в интервале [0-1].*
*Render Target 1 — альфа-канал. Похоже на отражающую способность!*
*Render Target 2 — RGB-каналы. Похоже на specular color!*
В этой сцене альфа-канал чёрный (но позже он используется).
*Буфер глубин. Заметьте, что здесь используется перевёрнутая глубина.*
*Стенсил-буфер, используемый для пометки определённого типа пикселей (например кожи, растительности и т.д.)*
Это не весь GBuffer. Проход освещения также использует зонды освещения и другие буферы, но их в этой статье я рассматривать не буду.
Прежде чем приступать к «основной» части поста, приведу общие наблюдения:
### Общие наблюдения
**1) Единственный очищаемый буфер — это буфер глубин/стенсила.**
Если проанализировать упомянутые выше текстуры в хорошем анализаторе кадров, то вы будете немного удивлены, потому что для них не используется вызов «Clear», за исключением Depth/Stencil.
То есть в реальности RenderTarget1 выглядит так (заметьте «размытые» пиксели на дальней плоскости):
Это простая и умная оптимизация.
Важный урок: на вызовы [ClearRenderTargetView](https://docs.microsoft.com/en-us/windows/desktop/api/d3d11/nf-d3d11-id3d11devicecontext-clearrendertargetview) нужно тратить ресурсы, поэтому используйте их только при необходимости.
**2) Перевёрнутая глубина — это круто**
Во [многих](https://outerra.blogspot.com/2012/11/maximizing-depth-buffer-range-and.html) [статьях](https://developer.nvidia.com/content/depth-precision-visualized) [уже](https://nlguillemot.wordpress.com/2016/12/07/reversed-z-in-opengl/) [писали](http://dev.theomader.com/depth-precision/) о точности буфера глубин с плавающей запятой. В Witcher 3 используется reversed-z. Это естественный выбор для такой игры с открытым миром и дальними дистанциями отрисовки.
Переключиться на DirectX будет несложно:
a) Очищаем буфер глубин записью «0», а не «1».
В традиционном подходе для очистки буфера глубин использовалось дальнее значение «1». После переворота глубины новым «дальним» значением стал 0, поэтому нужно всё поменять.
b) Поменять местами значения ближней и дальней границ при вычислении матрицы проецирования
c) Изменить проверку глубины с «меньше» на «больше»
Для OpenGL нужно проделать чуть больше работы (см. упомянутые выше статьи), но она того стоит.
**3) Не храним позицию в мире**
Да, всё так просто. В проходе освещения позицию в мире воссоздаём из глубины.
### Пиксельный шейдер
В этой части я хотел показать именно пиксельный шейдер, поставляющий в GBuffer данные поверхностей.
Итак, теперь мы уже знаем, как хранить цвет, нормали и specular.
Разумеется, всё не так просто, как вы могли подумать.
Проблема пиксельного шейдера в том, что он имеет множество вариантов. Они отличаются по количеству передаваемых им текстур и количеству параметров, используемых из буфера констант (вероятно, из буфера констант, описывающего материал).
Для анализа я решил использовать эту красивую бочку:
*Наша героическая бочка!*
Пожалуйста, поприветствуйте текстуры:
Итак, у нас есть albedo, карта нормалей и specular color. Довольно стандартный случай.
Прежде чем начнём, несколько слов о входных данных геометрии:
Геометрия передаётся с позицией, texcoords, буферами нормалей и касательных.
Вершинный шейдер выводит как минимум texcoords, нормализованные векторы касательных/нормалей/касательных к двум точкам, ранее умноженные на матрицу мира. Для более сложных материалов (например, с двумя диффузными картами или двумя картами нормалей) вершинный шейдер может выводить другие данные, но я хотел показать здесь простой пример.
Пиксельный шейдер в ассемблерном коде:
`ps_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb4[3], immediateIndexed
dcl_sampler s0, mode_default
dcl_sampler s13, mode_default
dcl_resource_texture2d (float,float,float,float) t0
dcl_resource_texture2d (float,float,float,float) t1
dcl_resource_texture2d (float,float,float,float) t2
dcl_resource_texture2d (float,float,float,float) t13
dcl_input_ps linear v0.zw
dcl_input_ps linear v1.xyzw
dcl_input_ps linear v2.xyz
dcl_input_ps linear v3.xyz
dcl_input_ps_sgv v4.x, isfrontface
dcl_output o0.xyzw
dcl_output o1.xyzw
dcl_output o2.xyzw
dcl_temps 3
0: sample_indexable(texture2d)(float,float,float,float) r0.xyzw, v1.xyxx, t1.xyzw, s0
1: sample_indexable(texture2d)(float,float,float,float) r1.xyz, v1.xyxx, t0.xyzw, s0
2: add r1.w, r1.y, r1.x
3: add r1.w, r1.z, r1.w
4: mul r2.x, r1.w, l(0.333300)
5: add r2.y, l(-1.000000), cb4[1].x
6: mul r2.y, r2.y, l(0.500000)
7: mov_sat r2.z, r2.y
8: mad r1.w, r1.w, l(-0.666600), l(1.000000)
9: mad r1.w, r2.z, r1.w, r2.x
10: mul r2.xzw, r1.xxyz, cb4[0].xxyz
11: mul_sat r2.xzw, r2.xxzw, l(1.500000, 0.000000, 1.500000, 1.500000)
12: mul_sat r1.w, abs(r2.y), r1.w
13: add r2.xyz, -r1.xyzx, r2.xzwx
14: mad r1.xyz, r1.wwww, r2.xyzx, r1.xyzx
15: max r1.w, r1.z, r1.y
16: max r1.w, r1.w, r1.x
17: lt r1.w, l(0.220000), r1.w
18: movc r1.w, r1.w, l(-0.300000), l(-0.150000)
19: mad r1.w, v0.z, r1.w, l(1.000000)
20: mul o0.xyz, r1.wwww, r1.xyzx
21: add r0.xyz, r0.xyzx, l(-0.500000, -0.500000, -0.500000, 0.000000)
22: add r0.xyz, r0.xyzx, r0.xyzx
23: mov r1.x, v0.w
24: mov r1.yz, v1.zzwz
25: mul r1.xyz, r0.yyyy, r1.xyzx
26: mad r1.xyz, v3.xyzx, r0.xxxx, r1.xyzx
27: mad r0.xyz, v2.xyzx, r0.zzzz, r1.xyzx
28: uge r1.x, l(0), v4.x
29: if_nz r1.x
30: dp3 r1.x, v2.xyzx, r0.xyzx
31: mul r1.xyz, r1.xxxx, v2.xyzx
32: mad r0.xyz, -r1.xyzx, l(2.000000, 2.000000, 2.000000, 0.000000), r0.xyzx
33: endif
34: sample_indexable(texture2d)(float,float,float,float) r1.xyz, v1.xyxx, t2.xyzw, s0
35: max r1.w, r1.z, r1.y
36: max r1.w, r1.w, r1.x
37: lt r1.w, l(0.200000), r1.w
38: movc r2.xyz, r1.wwww, r1.xyzx, l(0.120000, 0.120000, 0.120000, 0.000000)
39: add r2.xyz, -r1.xyzx, r2.xyzx
40: mad o2.xyz, v0.zzzz, r2.xyzx, r1.xyzx
41: lt r1.x, r0.w, l(0.330000)
42: mul r1.y, r0.w, l(0.950000)
43: movc r1.x, r1.x, r1.y, l(0.330000)
44: add r1.x, -r0.w, r1.x
45: mad o1.w, v0.z, r1.x, r0.w
46: dp3 r0.w, r0.xyzx, r0.xyzx
47: rsq r0.w, r0.w
48: mul r0.xyz, r0.wwww, r0.xyzx
49: max r0.w, abs(r0.y), abs(r0.x)
50: max r0.w, r0.w, abs(r0.z)
51: lt r1.xy, abs(r0.zyzz), r0.wwww
52: movc r1.yz, r1.yyyy, abs(r0.zzyz), abs(r0.zzxz)
53: movc r1.xy, r1.xxxx, r1.yzyy, abs(r0.yxyy)
54: lt r1.z, r1.y, r1.x
55: movc r1.xy, r1.zzzz, r1.xyxx, r1.yxyy
56: div r1.z, r1.y, r1.x
57: div r0.xyz, r0.xyzx, r0.wwww
58: sample_l(texture2d)(float,float,float,float) r0.w, r1.xzxx, t13.yzwx, s13, l(0)
59: mul r0.xyz, r0.wwww, r0.xyzx
60: mad o1.xyz, r0.xyzx, l(0.500000, 0.500000, 0.500000, 0.000000), l(0.500000, 0.500000, 0.500000, 0.000000)
61: mov o0.w, cb4[2].x
62: mov o2.w, l(0)
63: ret`
Шейдер состоит из нескольких этапов. Я опишу каждую основную часть этого шейдера по отдельности.
Но сначала как обычно — скриншот со значениями из буфера констант:
#### Albedo
Начнём мы со сложных вещей. Это не просто «OutputColor.rgb = Texture.Sample(uv).rgb»
После сэмплирования RGB текстуры цвета (строка 1), следующие 14 строки — это то, что я называю «буфером снижения насыщенности». Давайте я покажу код на HLSL:
`float3 albedoColorFilter( in float3 color, in float desaturationFactor, in float3 desaturationValue )
{
float sumColorComponents = color.r + color.g + color.b;
float averageColorComponentValue = 0.3333 * sumColorComponents;
float oneMinusAverageColorComponentValue = 1.0 - averageColorComponentValue;
float factor = 0.5 * (desaturationFactor - 1.0);
float avgColorComponent = lerp(averageColorComponentValue, oneMinusAverageColorComponentValue, saturate(factor));
float3 desaturatedColor = saturate(color * desaturationValue * 1.5);
float mask = saturate( avgColorComponent * abs(factor) );
float3 finalColor = lerp( color, desaturatedColor, mask );
return finalColor;
}`
Для большинства объектов этот код не делает ничего, кроме возврата исходного цвета из текстуры. Это достигается соответствующими значениями «material cbuffer». cb4\_v1.x имеет значение 1.0, что возвращает в маске, равной 0.0, и выдаёт входной цвет из инструкции *lerp*.
Однако существуют некоторые исключения. Наибольшее найденное мной значение *desaturationFactor* равно 4.0 (оно никогда не бывает меньше 1.0), а *desaturatedColor* зависит от материала. Оно может быть чем-то вроде (0.2, 0.3, 0.4); здесь нет строгих правил. Разумеется, я не удержался от реализации этого в своём собственном DX11-фреймворке, и вот результаты, где все значения *desaturatedColor* равны float3( 0.25, 0.3, 0.45 )
*desaturationFactor = 1.0 (не оказывает никакого эффекта)*
*desaturationFactor = 2.0*
*desaturationFactor = 3.0*
*desaturationFactor = 4.0*
Я уверен, что это просто применение параметров материалов, но выполняемое не конце части с albedo.
Строки 15-20 добавляют финальные штрихи:
`15: max r1.w, r1.z, r1.y
16: max r1.w, r1.w, r1.x
17: lt r1.w, l(0.220000), r1.w
18: movc r1.w, r1.w, l(-0.300000), l(-0.150000)
19: mad r1.w, v0.z, r1.w, l(1.000000)
20: mul o0.xyz, r1.wwww, r1.xyzx`
v0.z — это выходные данные из вершинного шейдера, и они равны нулю. Не забывайте об этом, потому что v0.z позже ещё будет использовано пару раз.
Похоже, что это какой-то коэффициент, и весь код похож на небольшое затемнение albedo, но так как v0.z равно 0, цвет остаётся неизменным. HLSL:
`/* ALBEDO */
// опциональный фильтр снижения насыщенности (?)
float3 albedoColor = albedoColorFilter( colorTex, cb4_v1.x, cb4_v0.rgb );
float albedoMaxComponent = getMaxComponent( albedoColor );
// Понятия не имею, что это
// В большинстве случаев вершинный шейдер выводит "paramZ" со значением 0
float paramZ = Input.out0.z; // помните, чаще всего это 0
// Заметьте, что 0.70 и 0.85 отсутствуют в ассемблерном коде вывода
// Так как я хотел использовать здесь lerp, мне пришлось настроить их вручную.
float param = (albedoMaxComponent > 0.22) ? 0.70 : 0.85;
float mulParam = lerp(1, param, paramZ);
// Вывод
pout.RT0.rgb = albedoColor * mulParam;
pout.RT0.a = cb4_v2.x;`
Что касается RT0.a, то, как мы видим, оно берётся из буфера констант материала, но так как у шейдера нет отладочной информации, сложно сказать, что это такое. Возможно просвечиваемость?
Мы закончили с первым render target!
### Нормали
Начнём с распаковки карты нормалей, а затем как обычно выполним привязку нормалей:
`/* НОРМАЛИ */
float3 sampledNormal = ((normalTex.xyz - 0.5) * 2);
// Данные для создания матрицы TBN
float3 Tangent = Input.TangentW.xyz;
float3 Normal = Input.NormalW.xyz;
float3 Bitangent;
Bitangent.x = Input.out0.w;
Bitangent.yz = Input.out1.zw;
// в реальном сценарии это насыщение удаляется; это хак, для того, чтобы умножение normal-tbn
// давало в ассемблерном коде инструкции 'mad' вместо кучи 'mov'
Bitangent = saturate(Bitangent);
float3x3 TBN = float3x3(Tangent, Bitangent, Normal);
float3 normal = mul( sampledNormal, TBN );`
Пока ничего удивительного.
*Посмотрите на строки 28-33:*
`28: uge r1.x, l(0), v4.x
29: if_nz r1.x
30: dp3 r1.x, v2.xyzx, r0.xyzx
31: mul r1.xyz, r1.xxxx, v2.xyzx
32: mad r0.xyz, -r1.xyzx, l(2.000000, 2.000000, 2.000000, 0.000000), r0.xyzx
33: endif`
Мы можем приблизительно написать их следующим образом:
`[branch] if (bIsFrontFace <= 0)
{
float cosTheta = dot(Input.NormalW, normal);
float3 invNormal = cosTheta * Input.NormalW;
normal = normal - 2*invNormal;
}`
Не уверен, правильно ли так писать. Если вы знаете, что это за математическая операция, то дайте мне знать.
Мы видим, что пиксельный шейдер использует SV\_IsFrontFace.
Что это такое? На помощью приходит [документация](https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-semantics) (я хотел написать «msdn», но...):
> Определяет, смотрит ли треугольник в камеру. Для линий и точек IsFrontFace имеет значение true. Исключением являются линии, нарисованные из треугольников (режим wireframe), которые задают IsFrontFace аналогично растеризации треугольника в solid mode. Запись в него может производиться шейдером геометрии, а считывание из него — пиксельным шейдером.
Я хотел проверить это самостоятельно. И в самом деле, эффект заметен только в каркасном (wireframe) режиме. Полагаю, этот фрагмент кода нужен для правильного вычисления нормалей (а значит и освещения) в режиме wireframe.
Вот сравнение: оба цвета каркаса готовой сцены при этом включенном/отключенном трюке, а также текстура нормалей gbuffer [0-1] при включенном/отключенном трюке:
*Цвет сцены без трюка*
*Цвет сцены с трюком*
*Нормали [0-1] без трюка*
*Нормали [0-1] с трюком*
Вы заметили, что каждый render target в GBuffer имеет формат R8G8B8A8\_UNORM? Это означает, что на один компонент приходится 256 возможных значений. Достаточно ли этого для хранения нормалей?
Хранение в Gbuffer высококачественных нормалей с достаточным количеством байтов — известная проблема, но, к счастью, существует [множество](https://aras-p.info/texts/CompactNormalStorage.html) [разных](https://knarkowicz.wordpress.com/2014/04/16/octahedron-normal-vector-encoding/) [материалов](http://hacksoflife.blogspot.com/2011/02/g-buffer-normals-revisited.html) по которым можно [поучиться](http://c0de517e.blogspot.com/2015/01/notes-on-g-buffer-normal-encodings.html).
Возможно, некоторые из вас уже знают, какая техника здесь используется. Нужно сказать, что в целом проходе геометрии есть одна дополнительная текстура, прикреплённая к слоту 13...:
Ха! В The Witcher 3 используется техника под названием "[Best Fit Normals](http://advances.realtimerendering.com/s2010/Kaplanyan-CryEngine3(SIGGRAPH%202010%20Advanced%20RealTime%20Rendering%20Course).pdf)". Здесь я не буду объяснять её подробно (посмотрите презентацию). Она была изобретена примерно в 2009-2010 году компанией Crytek, и поскольку CryEngine имеет открытые исходники, BFN тоже [open source](https://github.com/CRYTEK/CRYENGINE/blob/release/Engine/Shaders/HWScripts/CryFX/Common.cfi#L383).
BFN придаёт текстуре нормалей «зернистый» вид.
После масштабирования нормалей с помощью BFN мы перекодируем их из интервала [-1;1] в [0, 1].
### Specular
Начнём со строки 34, и сэмплируем текстуру specular:
`34: sample_indexable(texture2d)(float,float,float,float) r1.xyz, v1.xyxx, t2.xyzw, s0
35: max r1.w, r1.z, r1.y
36: max r1.w, r1.w, r1.x
37: lt r1.w, l(0.200000), r1.w
38: movc r2.xyz, r1.wwww, r1.xyzx, l(0.120000, 0.120000, 0.120000, 0.000000)
39: add r2.xyz, -r1.xyzx, r2.xyzx
40: mad o2.xyz, v0.zzzz, r2.xyzx, r1.xyzx`
Как видите, здесь есть знакомый нам по Albedo фильтр «затемнения»:
Вычисляем компонент с макс. значением, а затем вычисляем «затемнённый» цвет и интерполируем его с исходным specular color, взяв параметр из вершинного шейдера… который равен 0, поэтому на выходе мы получаем цвет из текстуры.
HLSL:
`/* SPECULAR */
float3 specularTex = texture2.Sample( samplerAnisoWrap, Texcoords ).rgb;
// Тот же алгоритм, что и в Albedo. Вычисляем макс. компонент, сравниваем его с
// каким-то пороговым значением и при необходимости вычисляем значение "минимума".
// Так как в анализируемой сцене paramZ имеет значение 0, окончательным результатом будет
//значение из текстуры.
float specularMaxComponent = getMaxComponent( specularTex );
float3 specB = (specularMaxComponent > 0.2) ? specularTex : float3(0.12, 0.12, 0.12);
float3 finalSpec = lerp(specularTex, specB, paramZ);
pout.RT2.xyz = finalSpec;`
### Отражающая способность
Я понятия не имею, подходит ли это название для этого параметра, потому что не знаю, как он влияет на проход освещения. Дело в том, что альфа-канал входной карты нормалей содержит дополнительные данные:
*Альфа-канал текстуры «карты нормалей».*
Ассемблерный код:
`41: lt r1.x, r0.w, l(0.330000)
42: mul r1.y, r0.w, l(0.950000)
43: movc r1.x, r1.x, r1.y, l(0.330000)
44: add r1.x, -r0.w, r1.x
45: mad o1.w, v0.z, r1.x, r0.w`
Поздоровайтесь с нашим старым другом — v0.z! Его смысл схож с albedo и с specular:
`/* REFLECTIVITY */
float reflectivity = normalTex.a;
float reflectivity2 = (reflectivity < 0.33) ? (reflectivity * 0.95) : 0.33;
float finalReflectivity = lerp(reflectivity, reflectivity2, paramZ);
pout.RT1.a = finalReflectivity;`
Отлично! Это конец анализа первого варианта пиксельного шейдера.
Вот сравнение моего шейдера (слева) с исходным (справа):
Эти различия не влияют на вычисления, поэтому моя работа здесь закончена.
### Пиксельный шейдер: вариант «Albedo + нормали»
Я решил показать ещё один вариант, теперь только с картами albedo и нормалей, без текстуры specular. Ассемблерный код чуть длиннее:
`ps_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb4[8], immediateIndexed
dcl_sampler s0, mode_default
dcl_sampler s13, mode_default
dcl_resource_texture2d (float,float,float,float) t0
dcl_resource_texture2d (float,float,float,float) t1
dcl_resource_texture2d (float,float,float,float) t13
dcl_input_ps linear v0.zw
dcl_input_ps linear v1.xyzw
dcl_input_ps linear v2.xyz
dcl_input_ps linear v3.xyz
dcl_input_ps_sgv v4.x, isfrontface
dcl_output o0.xyzw
dcl_output o1.xyzw
dcl_output o2.xyzw
dcl_temps 4
0: mul r0.x, v0.z, cb4[0].x
1: sample_indexable(texture2d)(float,float,float,float) r1.xyzw, v1.xyxx, t1.xyzw, s0
2: sample_indexable(texture2d)(float,float,float,float) r0.yzw, v1.xyxx, t0.wxyz, s0
3: add r2.x, r0.z, r0.y
4: add r2.x, r0.w, r2.x
5: add r2.z, l(-1.000000), cb4[2].x
6: mul r2.yz, r2.xxzx, l(0.000000, 0.333300, 0.500000, 0.000000)
7: mov_sat r2.w, r2.z
8: mad r2.x, r2.x, l(-0.666600), l(1.000000)
9: mad r2.x, r2.w, r2.x, r2.y
10: mul r3.xyz, r0.yzwy, cb4[1].xyzx
11: mul_sat r3.xyz, r3.xyzx, l(1.500000, 1.500000, 1.500000, 0.000000)
12: mul_sat r2.x, abs(r2.z), r2.x
13: add r2.yzw, -r0.yyzw, r3.xxyz
14: mad r0.yzw, r2.xxxx, r2.yyzw, r0.yyzw
15: max r2.x, r0.w, r0.z
16: max r2.x, r0.y, r2.x
17: lt r2.x, l(0.220000), r2.x
18: movc r2.x, r2.x, l(-0.300000), l(-0.150000)
19: mad r0.x, r0.x, r2.x, l(1.000000)
20: mul o0.xyz, r0.xxxx, r0.yzwy
21: add r0.xyz, r1.xyzx, l(-0.500000, -0.500000, -0.500000, 0.000000)
22: add r0.xyz, r0.xyzx, r0.xyzx
23: mov r1.x, v0.w
24: mov r1.yz, v1.zzwz
25: mul r1.xyz, r0.yyyy, r1.xyzx
26: mad r0.xyw, v3.xyxz, r0.xxxx, r1.xyxz
27: mad r0.xyz, v2.xyzx, r0.zzzz, r0.xywx
28: uge r0.w, l(0), v4.x
29: if_nz r0.w
30: dp3 r0.w, v2.xyzx, r0.xyzx
31: mul r1.xyz, r0.wwww, v2.xyzx
32: mad r0.xyz, -r1.xyzx, l(2.000000, 2.000000, 2.000000, 0.000000), r0.xyzx
33: endif
34: add r0.w, -r1.w, l(1.000000)
35: log r1.xyz, cb4[3].xyzx
36: mul r1.xyz, r1.xyzx, l(2.200000, 2.200000, 2.200000, 0.000000)
37: exp r1.xyz, r1.xyzx
38: mad r0.w, r0.w, cb4[4].x, cb4[5].x
39: mul_sat r1.xyz, r0.wwww, r1.xyzx
40: log r1.xyz, r1.xyzx
41: mul r1.xyz, r1.xyzx, l(0.454545, 0.454545, 0.454545, 0.000000)
42: exp r1.xyz, r1.xyzx
43: max r0.w, r1.z, r1.y
44: max r0.w, r0.w, r1.x
45: lt r0.w, l(0.200000), r0.w
46: movc r2.xyz, r0.wwww, r1.xyzx, l(0.120000, 0.120000, 0.120000, 0.000000)
47: add r2.xyz, -r1.xyzx, r2.xyzx
48: mad o2.xyz, v0.zzzz, r2.xyzx, r1.xyzx
49: lt r0.w, r1.w, l(0.330000)
50: mul r1.x, r1.w, l(0.950000)
51: movc r0.w, r0.w, r1.x, l(0.330000)
52: add r0.w, -r1.w, r0.w
53: mad o1.w, v0.z, r0.w, r1.w
54: lt r0.w, l(0), cb4[7].x
55: and o2.w, r0.w, l(0.064706)
56: dp3 r0.w, r0.xyzx, r0.xyzx
57: rsq r0.w, r0.w
58: mul r0.xyz, r0.wwww, r0.xyzx
59: max r0.w, abs(r0.y), abs(r0.x)
60: max r0.w, r0.w, abs(r0.z)
61: lt r1.xy, abs(r0.zyzz), r0.wwww
62: movc r1.yz, r1.yyyy, abs(r0.zzyz), abs(r0.zzxz)
63: movc r1.xy, r1.xxxx, r1.yzyy, abs(r0.yxyy)
64: lt r1.z, r1.y, r1.x
65: movc r1.xy, r1.zzzz, r1.xyxx, r1.yxyy
66: div r1.z, r1.y, r1.x
67: div r0.xyz, r0.xyzx, r0.wwww
68: sample_l(texture2d)(float,float,float,float) r0.w, r1.xzxx, t13.yzwx, s13, l(0)
69: mul r0.xyz, r0.wwww, r0.xyzx
70: mad o1.xyz, r0.xyzx, l(0.500000, 0.500000, 0.500000, 0.000000), l(0.500000, 0.500000, 0.500000, 0.000000)
71: mov o0.w, cb4[6].x
72: ret`
Разница между этим и предыдущим вариантами в следующем:
a) **строки 1, 19**: параметр интерполяции v0.z умножается на cb4[0].x из буфера констант, но это произведение используется только для интерполяции albedo в строке 19. Для других выходных данных используется «обычное» значение v0.z.
b) **строки 54-55**: o2.w теперь задаётся при условии, что (cb4[7].x > 0.0 )
Мы уже узнаём этот паттерн «какое-то сравнение — И» из вычисления гистограммы яркости. Его можно записать так:
`pout.RT2.w = (cb4_v7.x > 0.0) ? (16.5/255.0) : 0.0;`
c) **строки 34-42**: полностью другое вычисление specular.
Здесь нет текстуры specular. Давайте посмотрим отвечающий за эту часть ассемблерный код:
`34: add r0.w, -r1.w, l(1.000000)
35: log r1.xyz, cb4[3].xyzx
36: mul r1.xyz, r1.xyzx, l(2.200000, 2.200000, 2.200000, 0.000000)
37: exp r1.xyz, r1.xyzx
38: mad r0.w, r0.w, cb4[4].x, cb4[5].x
39: mul_sat r1.xyz, r0.wwww, r1.xyzx
40: log r1.xyz, r1.xyzx
41: mul r1.xyz, r1.xyzx, l(0.454545, 0.454545, 0.454545, 0.000000)
42: exp r1.xyz, r1.xyzx`
Заметьте, что здесь мы использовали (1 — отражаемая способность). К счастью, в HLSL это написать довольно просто:
`float oneMinusReflectivity = 1.0 - normalTex.a;
float3 specularTex = pow(cb4_v3.rgb, 2.2);
oneMinusReflectivity = oneMinusReflectivity * cb4_v4.x + cb4_v5.x;
specularTex = saturate(specularTex * oneMinusReflectivity);
specularTex = pow(specularTex, 1.0/2.2);
// продолжение как в первом варианте...
float specularMaxComponent = getMaxComponent( specularTex );
...`
Добавлю, что в этом вариенте буфер констант с данными материалов чуть больше. Здесь эти дополнительные значения используются для эмуляции specular color.
Остальная часть шейдера такая же, как в предыдущем варианте.
72 строк ассемблерного кода — это слишком много для отображения в WinMerge, поэтому поверьте мне на слово: у меня код получился почти таким же, как в оригинале. Или вы можете скачать мой [HLSLexplorer](https://astralcode.blogspot.com/2018/11/few-words-about-hlslexplorer.html) и убедиться в этом самостоятельно!
### Подведём итог
… и если вы дочитали досюда, то, возможно, хотите ещё чуть больше углубиться.
То, что кажется простым в реальной жизни чаще всего таким не является, и передача данных в gbuffer The Witcher 3 не стала исключением. Я показал вам только простейшие варианты пиксельных шейдеров, отвечающих за неё, а также привёл общие наблюдения, которые относятся к отложенному затенению в целом.
Для самых терпеливых два варианта пиксельных шейдеров есть в pastebin:
[Вариант 1 — с текстурой specular](https://pastebin.com/VtAabHKK)
[Вариант 2 — без текстуры specular](https://pastebin.com/khWQwpgv)
Часть 10. Занавесы дождя в отдалении
------------------------------------
В этой части мы рассмотрим замечательный атмосферный эффект, который мне очень нравится — далёкие [занавесы](https://en.wikipedia.org/wiki/Precipitation_shaft) дождя/освещения рядом с горизонтом. В игре их проще всего встретить на островах Скеллиге.
Лично мне очень нравится это атмосферное явление и было любопытно, как программисты графики CD Projekt Red его реализовали. Давайте разберёмся!
Вот два скриншота до и после применения занавесов дождя:
*До занавесов дождя*
*После занавесов дождя*
### Геометрия
Сначала мы остановимся на геометрии. Идея заключается в использовании небольшого цилиндра:
*Цилиндр в локальном пространстве*
С точки зрения его позиции в локальном пространстве он достаточно мал — его позиция находится в интервале (0.0 — 1.0).
Входная схема для этого вызова отрисовки выглядит так…
Для нас здесь важно следующее: Texcoords и Instance\_Transform.
Texcoords обёрнуты довольно просто: U верхнего и нижнего основания находятся в интервале [0.02777 — 1.02734]. V на нижнем основании равно 1.0, а на верхнем — 0.0. Как видите, можно довольно просто создать этот меш даже процедурно.
Получив этот небольшой цилиндр в локальном пространстве, мы умножаем его на матрицу мира, предоставляемую для каждого экземпляра элемента ввода INSTANCE\_TRANSFORM. Давайте проверим значения этой матрицы:
Выглядит довольно пугающе, правда? Но не волнуйтесь, мы разберём эту матрицу и посмотрим, что она скрывает!
`XMMATRIX mat( -227.7472, 159.8043, 374.0736, -116.4951,
-194.7577, -173.3836, -494.4982, 238.6908,
-14.16466, -185.4743, 784.564, -1.45565,
0.0, 0.0, 0.0, 1.0 );
mat = XMMatrixTranspose( mat );
XMVECTOR vScale;
XMVECTOR vRotateQuat;
XMVECTOR vTranslation;
XMMatrixDecompose( &vScale, &vRotateQuat, &vTranslation, mat );
// Матрица поворота...
XMMATRIX matRotate = XMMatrixRotationQuaternion( vRotateQuat );`
Результаты очень интересны:
`vRotateQuat: (0.0924987569, -0.314900011, 0.883411944, -0.334462732)
vScale: (299.999969, 300.000000, 1000.00012)
vTranslation: (-116.495102, 238.690796, -1.45564997)`
Важно знать позицию камеры в этом конкретном кадре: (-116.5338, 234.8695, 2.09)
Как видите, мы отмасштабировали цилиндр, чтобы сделать его довольно большим в мировом пространстве (в TW3 ось Z направлена вверх), перенесли его относительно позиции камеры, и повернули.
Вот как выглядит цилиндр после преобразования вершинным шейдером:
*Цилиндр после преобразования вершинным шейдером. Посмотрите, как он расположен относительно пирамиды видимости.*
### Вершинный шейдер
Входная геометрия и вершинный шейдер строго зависимы друг от друга.
Давайте внимательнее посмотрим на ассемблерный код вершинного шейдера:
`vs_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb1[7], immediateIndexed
dcl_constantbuffer cb2[6], immediateIndexed
dcl_input v0.xyz
dcl_input v1.xy
dcl_input v4.xyzw
dcl_input v5.xyzw
dcl_input v6.xyzw
dcl_input v7.xyzw
dcl_output o0.xyz
dcl_output o1.xyzw
dcl_output_siv o2.xyzw, position
dcl_temps 2
0: mov o0.xy, v1.xyxx
1: mul r0.xyzw, v5.xyzw, cb1[6].yyyy
2: mad r0.xyzw, v4.xyzw, cb1[6].xxxx, r0.xyzw
3: mad r0.xyzw, v6.xyzw, cb1[6].zzzz, r0.xyzw
4: mad r0.xyzw, cb1[6].wwww, l(0.000000, 0.000000, 0.000000, 1.000000), r0.xyzw
5: mad r1.xyz, v0.xyzx, cb2[4].xyzx, cb2[5].xyzx
6: mov r1.w, l(1.000000)
7: dp4 o0.z, r1.xyzw, r0.xyzw
8: mov o1.xyzw, v7.xyzw
9: mul r0.xyzw, v5.xyzw, cb1[0].yyyy
10: mad r0.xyzw, v4.xyzw, cb1[0].xxxx, r0.xyzw
11: mad r0.xyzw, v6.xyzw, cb1[0].zzzz, r0.xyzw
12: mad r0.xyzw, cb1[0].wwww, l(0.000000, 0.000000, 0.000000, 1.000000), r0.xyzw
13: dp4 o2.x, r1.xyzw, r0.xyzw
14: mul r0.xyzw, v5.xyzw, cb1[1].yyyy
15: mad r0.xyzw, v4.xyzw, cb1[1].xxxx, r0.xyzw
16: mad r0.xyzw, v6.xyzw, cb1[1].zzzz, r0.xyzw
17: mad r0.xyzw, cb1[1].wwww, l(0.000000, 0.000000, 0.000000, 1.000000), r0.xyzw
18: dp4 o2.y, r1.xyzw, r0.xyzw
19: mul r0.xyzw, v5.xyzw, cb1[2].yyyy
20: mad r0.xyzw, v4.xyzw, cb1[2].xxxx, r0.xyzw
21: mad r0.xyzw, v6.xyzw, cb1[2].zzzz, r0.xyzw
22: mad r0.xyzw, cb1[2].wwww, l(0.000000, 0.000000, 0.000000, 1.000000), r0.xyzw
23: dp4 o2.z, r1.xyzw, r0.xyzw
24: mul r0.xyzw, v5.xyzw, cb1[3].yyyy
25: mad r0.xyzw, v4.xyzw, cb1[3].xxxx, r0.xyzw
26: mad r0.xyzw, v6.xyzw, cb1[3].zzzz, r0.xyzw
27: mad r0.xyzw, cb1[3].wwww, l(0.000000, 0.000000, 0.000000, 1.000000), r0.xyzw
28: dp4 o2.w, r1.xyzw, r0.xyzw
29: ret`
Наряду с простой передачей Texcoords (строка 0) и Instance\_LOD\_Params (строка 8), для вывода нужны ещё два элемента: SV\_Position (это очевидно) и Height (компонент .z) позиции в мире.
Помните, что локальное пространство находится в интервале [0-1]? Так вот, прямо перед применением матрицы мира вершинный шейдер использует масштаб и отклонение для изменения локальной позиции. Умный ход!
В данном случае scale = float3(4, 4, 2), а bias = float3(-2, -2, -1).<
Паттерн, который заметен между строками 9 и 28 — это умножение двух row-major-матриц.
Давайте просто посмотрим на готовый вершинный шейдер на HLSL:
`cbuffer cbPerFrame : register (b1)
{
row_major float4x4 g_viewProjMatrix;
row_major float4x4 g_rainShaftsViewProjMatrix;
}
cbuffer cbPerObject : register (b2)
{
float4x4 g_mtxWorld;
float4 g_modelScale;
float4 g_modelBias;
}
struct VS_INPUT
{
float3 PositionW : POSITION;
float2 Texcoord : TEXCOORD;
float3 NormalW : NORMAL;
float3 TangentW : TANGENT;
float4 InstanceTransform0 : INSTANCE_TRANSFORM0;
float4 InstanceTransform1 : INSTANCE_TRANSFORM1;
float4 InstanceTransform2 : INSTANCE_TRANSFORM2;
float4 InstanceLODParams : INSTANCE_LOD_PARAMS;
};
struct VS_OUTPUT
{
float3 TexcoordAndZ : Texcoord0;
float4 LODParams : LODParams;
float4 PositionH : SV_Position;
};
VS_OUTPUT RainShaftsVS( VS_INPUT Input )
{
VS_OUTPUT Output = (VS_OUTPUT)0;
// простая передача данных
Output.TexcoordAndZ.xy = Input.Texcoord;
Output.LODParams = Input.InstanceLODParams;
// мировое пространство
float3 meshScale = g_modelScale.xyz; // float3( 4, 4, 2 );
float3 meshBias = g_modelBias.xyz; // float3( -2, -2, -1 );
float3 PositionL = Input.PositionW * meshScale + meshBias;
// Построение вручную матрицы instanceWorld из float4s:
float4x4 matInstanceWorld = float4x4(Input.InstanceTransform0, Input.InstanceTransform1,
Input.InstanceTransform2 , float4(0, 0, 0, 1) );
// Высота в мировом пространстве (.z)
float4x4 matWorldInstanceLod = mul( g_rainShaftsViewProjMatrix, matInstanceWorld );
Output.TexcoordAndZ.z = mul( float4(PositionL, 1.0), transpose(matWorldInstanceLod) ).z;
// SV_Posiiton
float4x4 matModelViewProjection = mul(g_viewProjMatrix, matInstanceWorld );
Output.PositionH = mul( float4(PositionL, 1.0), transpose(matModelViewProjection) );
return Output;
}`
Сравнение моего шейдера (слева) и оригинального (справа):
Различия не влияют на вычисления. Я выполнил инъекцию моего шейдера в кадр и всё по-прежнему было в порядке!
### Пиксельный шейдер
Наконец-то! Для начала я покажу вам входные данные:
Здесь используются две текстуры: текстура шума и буфер глубин:
Значения из буферов констант:
И ассемблерный код пиксельного шейдера:
`ps_5_0
dcl_globalFlags refactoringAllowed
dcl_constantbuffer cb0[8], immediateIndexed
dcl_constantbuffer cb2[3], immediateIndexed
dcl_constantbuffer cb12[23], immediateIndexed
dcl_constantbuffer cb4[8], immediateIndexed
dcl_sampler s0, mode_default
dcl_sampler s15, mode_default
dcl_resource_texture2d (float,float,float,float) t0
dcl_resource_texture2d (float,float,float,float) t15
dcl_input_ps linear v0.xyz
dcl_input_ps linear v1.w
dcl_input_ps_siv v2.xy, position
dcl_output o0.xyzw
dcl_temps 1
0: mul r0.xy, cb0[0].xxxx, cb4[5].xyxx
1: mad r0.xy, v0.xyxx, cb4[4].xyxx, r0.xyxx
2: sample_indexable(texture2d)(float,float,float,float) r0.x, r0.xyxx, t0.xyzw, s0
3: add r0.y, -cb4[2].x, cb4[3].x
4: mad_sat r0.x, r0.x, r0.y, cb4[2].x
5: mul r0.x, r0.x, v0.y
6: mul r0.x, r0.x, v1.w
7: mul r0.x, r0.x, cb4[1].x
8: mul r0.yz, v2.xxyx, cb0[1].zzwz
9: sample_l(texture2d)(float,float,float,float) r0.y, r0.yzyy, t15.yxzw, s15, l(0)
10: mad r0.y, r0.y, cb12[22].x, cb12[22].y
11: mad r0.y, r0.y, cb12[21].x, cb12[21].y
12: max r0.y, r0.y, l(0.000100)
13: div r0.y, l(1.000000, 1.000000, 1.000000, 1.000000), r0.y
14: add r0.y, r0.y, -v0.z
15: mul_sat r0.y, r0.y, cb4[6].x
16: mul_sat r0.x, r0.y, r0.x
17: mad r0.y, cb0[7].y, r0.x, -r0.x
18: mad r0.x, cb4[7].x, r0.y, r0.x
19: mul r0.xyz, r0.xxxx, cb4[0].xyzx
20: log r0.xyz, r0.xyzx
21: mul r0.xyz, r0.xyzx, l(2.200000, 2.200000, 2.200000, 0.000000)
22: exp r0.xyz, r0.xyzx
23: mul r0.xyz, r0.xyzx, cb2[2].xyzx
24: mul o0.xyz, r0.xyzx, cb2[2].wwww
25: mov o0.w, l(0)
26: ret`
Ого! Довольно большой объём, но на самом деле всё не так плохо.
Что же здесь происходит? Сначала мы вычисляем анимированные UV, воспользовавшись прошедшим временем из cbuffer (cb0[0].x) и масштабом/смещениями. Эти texcoords используются для сэмплирования из текстуры шума (строка 2).
Получив значение шума из текстуры, мы выполняем интерполяцию между значениями min/max (обычно 0 и 1).
Затем мы выполняем умножения, например на координату текстуры V (помните, что координата V идёт от 1 до 0?) — строка 5.
Таким образом мы вычислили «маску яркости» — она выглядит вот так:
Заметьте, что далёкие объекты (маяк, горы...) пропали. Это произошло, потому что цилиндр проходит тест глубины — цилиндр не находится на дальней плоскости и отрисовывается поверх этих объектов:
*Тест глубины*
Мы хотим имитировать то, что занавес дождя находится дальше (но необязательно на дальней плоскости). Чтобы сделать это, мы вычисляем ещё одну маску, «маску далёких объектов».
Вычисляется она по следующей формуле:
`farObjectsMask = saturate( (FrustumDepth - CylinderWorldSpaceHeight) * 0.001 );`
(0.001 берётся из буфера), что даёт нам нужную маску:
(В части про эффект Sharpen я уже поверхностно объяснял, как из буфера глубин извлекается глубина пирамиды видимости.)
Лично мне кажется, что этот эффект можно было реализовать менее затратно, без вычисления высоты в мировом пространстве, умножением глубины пирамиды видимости на меньшее число, например 0.0004.
При перемножении обеих масок получается окончательная:
Получив эту окончательную маску (строка 16), мы выполняем ещё одну интерполяцию, поторая почти ничего не делает (по крайней мере, в протестированном случае), а затем умножаем окончательную маску на цвет занавесов (строка 19), выполняем гамма-коррекцию (строки 20-22) и окончательные умножения (23-24).
В конце мы возвращаем цвет с нулевым альфа-значением. Так делается, потому что на этом проходе включено смешивание:
`FinalColor = SourceColor * 1.0 + (1.0 - SourceAlpha) * DestColor`
Если вы не совсем хорошо понимаете, как работает смешивание, то вот краткое объяснение:
SourceColor — это выходные RGB-данные из пиксельного шейдера, а DestColor — это текущий RGB-цвет пикселя в render target. Так как SourceAlpha всегда равна 0.0, вышеупомянутое уравнение упрощается до: `FinalColor = SourceColor + DestColor`.
Проще говоря, здесь мы выполняем аддитивное смешивание. Если пиксельный шейдер возвращает (0, 0, 0), то цвет останется таким же.
Вот готовый код на HLSL — думаю, что после объяснения понять его будет намного проще:
`struct VS_OUTPUT
{
float3 TexcoordAndWorldspaceHeight : Texcoord0;
float4 LODParams : LODParams; // float4(1,1,1,1)
float4 PositionH : SV_Position;
};
float getFrustumDepth( in float depth )
{
// from [1-0] to [0-1]
float d = depth * cb12_v22.x + cb12_v22.y;
// special coefficents
d = d * cb12_v21.x + cb12_v21.y;
// return frustum depth
return 1.0 / max(d, 1e-4);
}
float4 EditedShaderPS( in VS_OUTPUT Input ) : SV_Target0
{
// * Input from Vertex Shader
float2 InputUV = Input.TexcoordAndWorldspaceHeight.xy;
float WorldHeight = Input.TexcoordAndWorldspaceHeight.z;
float LODParam = Input.LODParams.w;
// * Inputs
float elapsedTime = cb0_v0.x;
float2 uvAnimation = cb4_v5.xy;
float2 uvScale = cb4_v4.xy;
float minValue = cb4_v2.x; // 0.0
float maxValue = cb4_v3.x; // 1.0
float3 shaftsColor = cb4_v0.rgb; // RGB( 147, 162, 173 )
float3 finalColorFilter = cb2_v2.rgb; // float3( 1.175, 1.296, 1.342 );
float finalEffectIntensity = cb2_v2.w;
float2 invViewportSize = cb0_v1.zw;
float depthScale = cb4_v6.x; // 0.001
// sample noise
float2 uvOffsets = elapsedTime * uvAnimation;
float2 uv = InputUV * uvScale + uvOffsets;
float disturb = texture0.Sample( sampler0, uv ).x;
// * Intensity mask
float intensity = saturate( lerp(minValue, maxValue, disturb) );
intensity *= InputUV.y; // transition from (0, 1)
intensity *= LODParam; // usually 1.0
intensity *= cb4_v1.x; // 1.0
// Sample depth
float2 ScreenUV = Input.PositionH.xy * invViewportSize;
float hardwareDepth = texture15.SampleLevel( sampler15, ScreenUV, 0 ).x;
float frustumDepth = getFrustumDepth( hardwareDepth );
// * Calculate mask covering distant objects behind cylinder.
// Seems that the input really is world-space height (.z component, see vertex shader)
float depth = frustumDepth - WorldHeight;
float distantObjectsMask = saturate( depth * depthScale );
// * calculate final mask
float finalEffectMask = saturate( intensity * distantObjectsMask );
// cb0_v7.y and cb4_v7.x are set to 1.0 so I didn't bother with naming them :)
float paramX = finalEffectMask;
float paramY = cb0_v7.y * finalEffectMask;
float effectAmount = lerp(paramX, paramY, cb4_v7.x);
// color of shafts comes from contant buffer
float3 effectColor = effectAmount * shaftsColor;
// gamma correction
effectColor = pow(effectColor, 2.2);
// final multiplications
effectColor *= finalColorFilter;
effectColor *= finalEffectIntensity;
// return with zero alpha 'cause the blending used here is:
// SourceColor * 1.0 + (1.0 - SrcAlpha) * DestColor
return float4( effectColor, 0.0 );
}`
С радостью могу сказать, что мой пиксельный шейдер создаёт тот же ассемблерный код, что и в оригинале.
Надеюсь, статья вам понравилась. Спасибо за прочтение! | https://habr.com/ru/post/437100/ | null | ru | null |
# Raspberry Pi + CentOS = Wi-Fi Hotspot (или малиновый роутер в красной шляпе)
**UPD** 14.03.2020:
[Raspberry Pi + Fedora (aarch64) = Wi-Fi Hotspot (или малиновый роутер в синей шляпе)](https://habr.com/ru/post/492322/)
В Интернете огромное количество информации по созданию Wi-Fi точек доступа на базе одноплатного ПК Raspberry. Как правило, подразумевается использование родной для «малинки» операционной системы — Raspbian.
Являясь адептом RPM-based систем, я не мог пройти мимо этого маленького чуда и не попробовать на нем мою любимую CentOS.
В статье представлена инструкция по изготовлению 5GHz/AC Wi-Fi роутера из Raspberry Pi 3 Model B+ на базе операционной системы CentOS. Будет несколько стандартных, но малоизвестных трюков, а в качестве бонуса — чертеж подключения к «малинке» дополнительного Wi-Fi оборудования, позволяющего ей одновременно работать в нескольких режимах (2,4+5GHz).
*(микс изображений из свободного доступа)*
Отметим сразу, что каких-то космических скоростей не получится. Я выжимаю из своей «малинки» по воздуху максимум 100 Мбит, и это покрывает скорость моего Интернет провайдера. Зачем нужен такой вялый AC, если даже на N в теории можно получить полгигабита? Если вы задались таким вопросом, то ступайте в магазин за настоящим роутером с восемью внешними антеннами.
0. Что понадобится
==================
* Собственно, само «малиновое изделие» калибра: Pi 3 Model B+ (для достижения заветных 5GHz скоростей и каналов);
* Добротная microSD >= 4GB;
* Рабочая станция с Linux и читателем/писателем microSD;
* Наличие достаточных скиллов в Linux, статья — для подготовленного Гика;
* Проводная сетевая (eth0) связанность между Raspberry и Linux, работающий DHCP-сервер в локальной сети и доступ в Интернет с обоих устройств.
Небольшой комментарий по последнему пункту. «Что появилось первым, яйцо или...» как сделать Wi-Fi роутер при отсутствии какого бы то ни было оборудования доступа в Интернет? Оставим за рамками статьи это занимательное упражнение и просто допустим, что Raspberry подключена к локальной сети проводом и имеет выход в Интернет. В этом случае нам не понадобятся дополнительные телевизор и манипулятор для настройки «малинки».
1. Установка CentOS
===================
[Домашняя страница проекта](https://wiki.centos.org/SpecialInterestGroup/AltArch/armhfp)
На момент написания этой статьи, работающая версия CentOS на устройстве — 32-битная. Где-то на просторах всемирной Сети мне попадались мнения о снижении производительности таких ОС на 64-битной архитектуре ARM аж на 20%. Оставлю этот момент без комментария.
На Linux-е качаем минимальный образ с ядром "**-RaspberryPI-**" и записываем его на microSD:
```
# xzcat CentOS-Userland-7-armv7hl-RaspberryPI-Minimal-1810-sda.raw.xz | \
dd of=/dev/mmcblk0 bs=4M
# sync
```
Перед началом использования образа удалим из него раздел SWAP, расширим корень на весь доступный объем и избавимся от SELinux. Алгоритм — простой: делаем копию корня на Linux, удаляем с microSD все разделы кроме первого (/boot), создаем новый корневой и возвращаем его содержимое из копии.
**Пример необходимых действий (суровый консольный вывод)**
```
# mount /dev/mmcblk0p3 /mnt
# cd /mnt
# tar cfz ~/pi.tgz . --no-selinux
# cd
# umount /mnt
```
```
# parted /dev/mmcblk0
(parted) unit s
(parted) print free
Model: SD SC16G (sd/mmc)
Disk /dev/mmcblk0: 31116288s
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
63s 2047s 1985s Free Space
1 2048s 1370111s 1368064s primary fat32 boot, lba
2 1370112s 2369535s 999424s primary linux-swap(v1)
3 2369536s 5298175s 2928640s primary ext4
5298176s 31116287s 25818112s Free Space
(parted) rm 3
(parted) rm 2
(parted) print free
Model: SD SC16G (sd/mmc)
Disk /dev/mmcblk0: 31116288s
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
63s 2047s 1985s Free Space
1 2048s 1370111s 1368064s primary fat32 boot, lba
1370112s 31116287s 29746176s Free Space
(parted) mkpart
Partition type? primary/extended? primary
File system type? [ext2]? ext4
Start? 1370112s
End? 31116287s
(parted) set
Partition number? 2
Flag to Invert? lba
New state? on/[off]? off
(parted) print free
Model: SD SC16G (sd/mmc)
Disk /dev/mmcblk0: 31116288s
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
63s 2047s 1985s Free Space
1 2048s 1370111s 1368064s primary fat32 boot, lba
2 1370112s 31116287s 29746176s primary ext4
(parted) quit
```
```
# mkfs.ext4 /dev/mmcblk0p2
mke2fs 1.44.6 (5-Mar-2019)
/dev/mmcblk0p2 contains a swap file system labelled '_swap'
Proceed anyway? (y,N) y
Discarding device blocks: done
Creating filesystem with 3718272 4k blocks and 930240 inodes
Filesystem UUID: 6a1a0694-8196-4724-a58d-edde1f189b31
Superblock backups stored on blocks:
32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208
Allocating group tables: done
Writing inode tables: done
Creating journal (16384 blocks): done
Writing superblocks and filesystem accounting information: done
# mount /dev/mmcblk0p2 /mnt
# tar xfz ~/pi.tgz -C /mnt --no-selinux
```
После распаковки содержимого корневого раздела самое время внести в него некоторые изменения.
Отключаем SELinux в **/mnt/etc/selinux/config**:
```
SELINUX=disabled
```
Редактируем **/mnt/etc/fstab**, оставляя в нем только две записи о разделах: загрузочный (/boot, без изменений) и корневой (изменяем значение UUID, которое можно узнать, изучив вывод команды blkid на Linux-е):
```
UUID=6a1a0694-8196-4724-a58d-edde1f189b31 / ext4 defaults,noatime 0 0
UUID=6938-F4F2 /boot vfat defaults,noatime 0 0
```
Наконец, изменяем параметры загрузки ядра: указываем новое расположение корневого раздела, отключаем вывод отладочной информации и (опционально) запрещаем ядру назначать IPv6 адреса на сетевых интерфейсах:
```
# cd
# umount /mnt
# mount /dev/mmcblk0p1 /mnt
```
Приводим содержимое **/mnt/cmdline.txt** к следующему виду (одна строка без переносов):
```
root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait quiet ipv6.disable_ipv6=1
```
Готово:
```
# cd
# umount /mnt
# sync
```
Переставляем microSD в «малинку», запускаем и получаем к ней сетевой доступ по ssh (root/centos).
2. Настройка CentOS
===================
Первые три незыблемые движения: **passwd**, **yum -y update**, **reboot**.
Управление сетью отдаем **networkd**:
```
# yum install systemd-networkd
# systemctl enable systemd-networkd
# systemctl disable NetworkManager
# chkconfig network off
```
Создаем файл (вместе с каталогами) **/etc/systemd/network/eth0.network**:
```
[Match]
Name=eth0
[Network]
DHCP=ipv4
```
Перезагружаем «малинку» и снова получаем к ней сетевой доступ по ssh (IP-адрес может измениться). Обратите внимание на то, что используется **/etc/resolv.conf**, созданный ранее Network Manager-ом. Поэтому, в случае проблем с resolve, отредактируйте его содержимое. Использовать **systemd-resolved** мы не будем.
Удаляем «лишнее», чиним и ускоряем загрузку ОС:
```
# systemctl set-default multi-user.target
# yum remove GeoIP Network* aic* alsa* cloud-utils-growpart \
cronie* dhc* firewal* initscripts iwl* kexec* logrotate \
postfix rsyslog selinux-pol* teamd wpa_supplicant
```
Кому нужен **cron** и кто не переваривает встроенные [таймеры systemd](https://www.freedesktop.org/software/systemd/man/systemd.timer), могут установить недостающее. **/var/log**-и смотрим через **journalctl**. Если потребуется история журнала (по умолчанию хранятся сведения только с момента старта системы):
```
# mkdir /var/log/journal
# systemd-tmpfiles --create --prefix /var/log/journal
# systemctl restart systemd-journald
# vi /etc/systemd/journald.conf
```
**Отключаем использование IPv6 основными службами (если требуется)****/etc/ssh/sshd\_config**:
```
AddressFamily inet
```
**/etc/sysconfig/chronyd**:
```
OPTIONS="-4"
```
Актуальность времени на «малинке» — важная штука. Так как «из коробки» отсутствует аппаратная возможность сохранять текущее состояние часов при перезагрузке, то нужна синхронизация. Очень хороший и быстрый демон для этого — **chrony** — уже установлен и запускается автоматически. Можно изменить NTP-серверы на ближайшие.
**/etc/chrony.conf**:
```
server 0.ru.pool.ntp.org iburst
server 1.ru.pool.ntp.org iburst
server 2.ru.pool.ntp.org iburst
server 3.ru.pool.ntp.org iburst
```
Для установки часового пояса будем использовать **трюк**. Так как наша цель — создание Wi-Fi роутера, работающего на 5GHz частотах, то заранее подготовимся к сюрпризам **регулятора**:
> # yum info crda
>
> Summary: Regulatory compliance daemon for 802.11 wireless networking
>
>
Эта злобная конструкция, ориентируясь в том числе на часовой пояс, «запрещает» использование (в России) 5GHz частот и каналов с «большими» номерами. Трюк заключается в установке тайм зоны без использования названий материков/городов, то есть вместо:
```
# timedatectl set-timezone Europe/Moscow
```
Вдавливаем:
```
# timedatectl set-timezone Etc/GMT-3
```
И финальные штрихи в прическе системы:
```
# hostnamectl set-hostname router
```
**/root/.bash\_profile**:
```
. . .
# User specific environment and startup programs
export PROMPT_COMMAND="echo -n $(($(
```
3. Дополнения CentOS
====================
Все, о чем было сказано выше, можно считать законченной инструкцией по установке «ванильного» CentOS на Raspberry Pi. У вас должен получиться ПК, который (пере)загружается менее чем за 10 секунд, использует менее 15 Мегабайт оперативной памяти и 1.5 Гигабайта microSD (на самом деле менее 1 Гигабайта из-за неполного /boot, но будем честными до конца):
Для установки ПО Wi-Fi точки доступа на эту систему потребуется немного расширить возможности стандартного дистрибутива CentOS. Прежде всего «прокачаем» драйвер(прошивку) встроенного Wi-Fi адаптера. На домашней странице проекта сказано:
> Wifi on the Raspberry 3B and 3B+
>
>
>
> The Raspberry PI 3B/3B+ firmware files are not allowed to be distributed by the CentOS Project. You can use the following articles to understand the issue, get the firmware and set up the wifi.
>
>
Что нельзя проекту CentOS, то не запрещено нам для личного использования. Заменяем дистрибутивную Wi-Fi прошивку в CentOS на соответствующую от разработчиков Broadcom (те самые ненавистные бинарные блобы...). Это, в частности, позволит использовать AC в режиме точки доступа.
**Wi-Fi firmware upgrade**Выясняем модель устройства и текущую версию прошивки:
```
# journalctl | grep $(basename $(readlink /sys/class/net/wlan0/device/driver))
Jan 01 04:00:03 router kernel: brcmfmac: F1 signature read @0x18000000=0x15264345
Jan 01 04:00:03 router kernel: brcmfmac: brcmf_fw_map_chip_to_name: using brcm/brcmfmac43455-sdio.bin for chip 0x004345(17221) rev 0x000006
Jan 01 04:00:03 router kernel: usbcore: registered new interface driver brcmfmac
Jan 01 04:00:03 router kernel: brcmfmac: brcmf_c_preinit_dcmds: Firmware version = wl0: Mar 1 2015 07:29:38 version 7.45.18 (r538002) FWID 01-6a2c8ad4
Jan 01 04:00:03 router kernel: brcmfmac: brcmf_c_preinit_dcmds: CLM version = API: 12.2 Data: 7.14.8 Compiler: 1.24.9 ClmImport: 1.24.9 Creation: 2014-09-02 03:05:33 Inc Data: 7.17.1 Inc Compiler: 1.26.11 Inc ClmImport: 1.26.11 Creation: 2015-03-01 07:22:34
```
Видим, что прошивка версии 7.45.18 от 01.03.2015, и запоминаем следующий набор цифр: **43455** (brcmfmac43455-sdio.bin).
[Качаем актуальный образ Raspbian](https://www.raspberrypi.org/downloads/raspbian/). Ленивые могут записать образ на microSD и оттуда забрать файлы с прошивкой. А можно смонтировать корневой раздел образа в Linux и скопировать нужное оттуда:
```
# wget https://downloads.raspberrypi.org/raspbian_lite_latest
# unzip -p raspbian_lite_latest > raspbian.img
# fdisk -l raspbian.img
Disk raspbian.img: 2 GiB, 2197815296 bytes, 4292608 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x17869b7d
Device Boot Start End Sectors Size Id Type
raspbian.img1 8192 532480 524289 256M c W95 FAT32 (LBA)
raspbian.img2 540672 4292607 3751936 1.8G 83 Linux
# mount -t ext4 -o loop,offset=$((540672 * 512)) raspbian.img /mnt
# cp -fv /mnt/lib/firmware/brcm/*43455* ...
'/mnt/lib/firmware/brcm/brcmfmac43455-sdio.bin' -> ...
'/mnt/lib/firmware/brcm/brcmfmac43455-sdio.clm_blob' -> ...
'/mnt/lib/firmware/brcm/brcmfmac43455-sdio.txt' -> ...
# umount /mnt
```
Полученные файлы прошивки Wi-Fi адаптера нужно скопировать с заменой на «малинку» в каталог **/usr/lib/firmware/brcm/**
Перезагружаем будущий роутер и довольно улыбаемся:
```
# journalctl | grep $(basename $(readlink /sys/class/net/wlan0/device/driver))
Jan 01 04:00:03 router kernel: brcmfmac: F1 signature read @0x18000000=0x15264345
Jan 01 04:00:03 router kernel: brcmfmac: brcmf_fw_map_chip_to_name: using brcm/brcmfmac43455-sdio.bin for chip 0x004345(17221) rev 0x000006
Jan 01 04:00:03 router kernel: usbcore: registered new interface driver brcmfmac
Jan 01 04:00:03 router kernel: brcmfmac: brcmf_c_preinit_dcmds: Firmware version = wl0: Feb 27 2018 03:15:32 version 7.45.154 (r684107 CY) FWID 01-4fbe0b04
Jan 01 04:00:03 router kernel: brcmfmac: brcmf_c_preinit_dcmds: CLM version = API: 12.2 Data: 9.10.105 Compiler: 1.29.4 ClmImport: 1.36.3 Creation: 2018-03-09 18:56:28
```
Версия: 7.45.154 от 27.02.2018.
Ну и конечно же EPEL:
```
# cat > /etc/yum.repos.d/epel.repo << EOF
[epel]
name=Epel rebuild for armhfp
baseurl=https://armv7.dev.centos.org/repodir/epel-pass-1/
enabled=1
gpgcheck=0
EOF
# yum clean all
# rm -rfv /var/cache/yum
# yum update
```
4. Сетевая конфигурация и предстоящие трудности
===============================================
Как мы договорились выше, «малинка» подключена «проводом» к локальной сети. Предположим, что и провайдер предоставляет доступ в Интернет точно таким же способом: адрес в публичной сети выдается динамически DHCP сервером (может быть с привязкой к MAC). В этом случае, после окончательной настройки «малинки», достаточно «воткнуть» в нее кабель провайдера и все готово. Авторизация с помощью **systemd-networkd** — тема отдельной статьи и здесь не рассматривается.
Wi-Fi интерфейс(ы) у Raspberry — это локальная сеть, а встроенный Ethernet адаптер (eth0) — внешняя. Локальную сеть пронумеруем статически, например: 192.168.0.0/24. Адрес «малинки»: 192.168.0.1. Во внешней сети (Интернет) будет работать DHCP сервер.
[Проблема единообразия именования](https://ru.wikipedia.org/wiki/%D0%95%D0%B4%D0%B8%D0%BD%D0%BE%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BD%D0%BE%D0%B5_%D0%B8%D0%BC%D0%B5%D0%BD%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D1%81%D0%B5%D1%82%D0%B5%D0%B2%D1%8B%D1%85_%D1%83%D1%81%D1%82%D1%80%D0%BE%D0%B9%D1%81%D1%82%D0%B2) и [известный гватемальский программист](https://lurkmore.to/%D0%9B%D0%B5%D0%BD%D0%BD%D0%B0%D1%80%D1%82_%D0%9F%D0%BE%D1%82%D1%82%D0%B5%D1%80%D0%B8%D0%BD%D0%B3) — две неприятности, поджидающие каждого, кто занимается настройкой сетевых интерфейсов и служб в systemd-дистрибутивах.
**Параллельный хаос (лирическое отступление)**Леннарт Поттеринг составил свою программу **systemd** очень хорошо. Эта **systemd** запускает другие программы так быстро, что те, не успев опомниться от судейского пинка свистка, спотыкаются и падают на старте даже не начав свой бег с препятствиями.
Ну а если серьезно, то агрессивное распараллеливание запускаемых процессов при старте systemd-ОС является неким «ослиным мостиком» для матерых последовательных LSB-шников. К счастью, привести в порядок этот «параллельный хаос» оказывается простым, правда не всегда очевидным делом.
Создаем два виртуальных интерфейса-моста (bridge) с постоянными именами: **lan** и **wan**. К первому «подключим» Wi-Fi адаптер(ы), ко второму — eth0 «малинки».
**/etc/systemd/network/lan.netdev**:
```
[NetDev]
Name=lan
Kind=bridge
```
**/etc/systemd/network/lan.network**:
```
[Match]
Name=lan
[Network]
Address=192.168.0.1/24
IPForward=yes
```
**/etc/systemd/network/wan.netdev**:
```
[NetDev]
Name=wan
Kind=bridge
#MACAddress=xx:xx:xx:xx:xx:xx
```
**/etc/systemd/network/wan.network**:
```
[Match]
Name=wan
[Network]
DHCP=ipv4
IPForward=yes
```
**IPForward=yes** избавляет от необходимости через sysctl намекать ядру о включении маршрутизации.
**MACAddress=** раскомментируем и изменим при необходимости.
Сначала «подключаем» eth0. Помним о «проблеме единообразия» и используем только MAC адрес этого интерфейса, узнать который можно, например, так:
```
# cat /sys/class/net/eth0/address
```
Создаем **/etc/systemd/network/eth.network**:
```
[Match]
MACAddress=b8:27:eb:xx:xx:xx
[Network]
Bridge=wan
```
Удаляем предыдущий файл конфигурации eth0, перезагружаем «малинку» и получаем к ней сетевой доступ (IP адрес скорее всего изменится):
```
# rm -fv /etc/systemd/network/eth0.network
# reboot
```
5. DNSMASQ
==========
Для изготовления точек доступа Wi-Fi ничего лучше сладкой парочки из **dnsmasq** + **hostapd** еще не придумали. По моему мнению.
**Если кто забыл, то...**[hostapd](https://www.w1.fi/hostapd/) — это штука, которая управляет Wi-Fi адаптерами (в частности, возьмет на себя труд по их подключению к виртуальному **lan** «малинки»), авторизует и регистрирует беспроводных клиентов.
[dnsmasq](https://ru.wikipedia.org/wiki/Dnsmasq) — настраивает сетевой стек клиентов: выдает IP-адреса, DNS-серверы, шлюз по умолчанию и тому подобные прелести.
Начинаем с dnsmasq:
```
# yum install dnsmasq
```
Шаблон **/etc/resolv.conf**:
```
nameserver 1.1.1.1
nameserver 1.0.0.1
nameserver 8.8.8.8
nameserver 8.8.4.4
nameserver 77.88.8.8
nameserver 77.88.8.1
domain router.local
search router.local
```
редактируем его по своему вкусу.
Минималистичный **/etc/dnsmasq.conf**:
```
domain-needed
bogus-priv
interface=lan
bind-dynamic
expand-hosts
domain=#
dhcp-range=192.168.0.100,192.168.0.199,255.255.255.0,24h
conf-dir=/etc/dnsmasq.d
```
«Магия» здесь заключается в параметре **bind-dynamic**, который указывает демону dnsmasq дожидаться появления в системе **interface=lan**, а не падать в обморок от приступа гордого одиночества после старта.
```
# systemctl enable dnsmasq
# systemctl start dnsmasq; journalctl -f
```
6. HOSTAPD
==========
И наконец, волшебные конфигурации hostapd. Не сомневаюсь, что кто-то читает эту статью в поиске именно этих заветных строчек.
Перед установкой hostapd нужно побороться с «проблемой единообразия». Встроенный Wi-Fi адаптер wlan0 может легко изменить свое имя на wlan1 при подключении дополнительного USB Wi-Fi оборудования. Поэтому зафиксируем имена интерфейсов следующим способом: придумаем (беспроводным) адаптерам уникальные названия и привяжем их к MAC адресам.
Для встроенного Wi-Fi адаптера, который пока еще wlan0:
```
# cat /sys/class/net/wlan0/address
b8:27:eb:xx:xx:xx
```
Создаем **/etc/systemd/network/wl0.link**:
```
[Match]
MACAddress=b8:27:eb:xx:xx:xx
[Link]
Name=wl0
```
Теперь мы будем уверены, что **wl0** — это встроенный Wi-Fi. Перезагружаем «малинку», чтобы в этом убедиться.
Устанавливаем:
```
# yum install hostapd wireless-tools
```
Конфигурационный файл **/etc/hostapd/hostapd.conf**:
```
ssid=rpi
wpa_passphrase=1234567890
channel=36
country_code=US
interface=wl0
bridge=lan
driver=nl80211
auth_algs=1
wpa=2
wpa_key_mgmt=WPA-PSK
rsn_pairwise=CCMP
macaddr_acl=0
hw_mode=a
wmm_enabled=1
# N
ieee80211n=1
require_ht=1
ht_capab=[MAX-AMSDU-3839][HT40+][SHORT-GI-20][SHORT-GI-40][DSSS_CCK-40]
# AC
ieee80211ac=1
require_vht=1
ieee80211d=0
ieee80211h=0
vht_capab=[MAX-AMSDU-3839][SHORT-GI-80]
vht_oper_chwidth=1
vht_oper_centr_freq_seg0_idx=42
```
Ни на минуту не забывая о [ГКЧП](https://ru.wikipedia.org/wiki/%D0%93%D0%BE%D1%81%D1%83%D0%B4%D0%B0%D1%80%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BA%D0%BE%D0%BC%D0%B8%D1%81%D1%81%D0%B8%D1%8F_%D0%BF%D0%BE_%D1%80%D0%B0%D0%B4%D0%B8%D0%BE%D1%87%D0%B0%D1%81%D1%82%D0%BE%D1%82%D0%B0%D0%BC), изменяем необходимые нам параметры и вручную проверяем на работоспособность:
```
# hostapd /etc/hostapd/hostapd.conf
```
hostapd запустится в интерактивном режиме, транслируя на консоль свое состояние. Если ошибок не будет, то к точке доступа уже можно будет подключаться клиентам, поддерживающим AC-режим. Для остановки hostapd — Ctrl-C.
Осталось включить hostapd в автозагрузку системы. Если поступить стандартно (systemctl enable hostapd), то после очередной перезагрузки можно получить «валяющегося в крови» демона с диагнозом "**интерфейс wl0 не найден**". В результате «параллельного хаоса» hostapd завелся быстрее, чем ядро нашло беспроводной адаптер.
В Интернете полно лекарств: от принудительного таймаута перед стартом демона (сколько-то минут), до еще одного демона, который мониторит появление интерфейса и (пере)запускает hostpad. Решения вполне себе рабочие, но ужасно некрасивые. Призываем на помощь великого **systemd** с его «целями» и "~~задачами~~" «зависимостями».
Копируем дистрибутивный service-файл в **/etc/systemd/system/hostapd.service**:
```
# cp -fv /usr/lib/systemd/system/hostapd.service /etc/systemd/system
```
и приводим его содержимое к следующему виду:
```
[Unit]
Description=Hostapd IEEE 802.11 AP, IEEE 802.1X/WPA/WPA2/EAP/RADIUS Authenticator
After=sys-subsystem-net-devices-wl0.device
BindsTo=sys-subsystem-net-devices-wl0.device
[Service]
Type=forking
PIDFile=/run/hostapd.pid
ExecStart=/usr/sbin/hostapd /etc/hostapd/hostapd.conf -P /run/hostapd.pid -B
[Install]
WantedBy=sys-subsystem-net-devices-wl0.device
```
Магия обновленного сервисного файла заключается в динамической привязке hostapd к новой цели — интерфейсу wl0. При появлении интерфейса — демон запускается, при пропадании — останавливается. И это все в онлайне — без перезагрузки системы. Особенно эта техника будет полезной при подключении к «малинке» USB Wi-Fi адаптера.
Вот теперь можно:
```
# systemctl enable hostapd
# reboot
```
7. IPTABLES
===========
«Шта???» © Да-да! Никакого **systemd**. Никаких новомодных комбайнов (в виде **firewalld**), которые в итоге делают одно и тоже.
Используем старый добрый **iptables**, службы которого после своего старта загрузят в ядро сетевые правила и спокойно завершат работу, не оставаясь резидентно и не потребляя ресурсов. У systemd есть элегантный **IPMasquerade=**, но трансляцию адресов (NAT) и файервол поручим все-таки iptables.
Устанавливаем:
```
# yum install iptables-services
# systemctl enable iptables ip6tables
```
Конфигурацию iptables я предпочитаю хранить в виде скрипта (пример):
```
#!/bin/bash
#
# Disable IPv6
#
ip6tables --flush
ip6tables --delete-chain
ip6tables --policy INPUT DROP
ip6tables --policy FORWARD DROP
ip6tables --policy OUTPUT DROP
ip6tables-save > /etc/sysconfig/ip6tables
systemctl restart ip6tables
#
# Cleaning
#
iptables -F
iptables -X
iptables -t nat -F
iptables -t nat -X
iptables -t mangle -F
iptables -t mangle -X
iptables -P INPUT DROP
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
#
# Loopback, lan
#
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i lan -j ACCEPT
#
# Ping, Established
#
iptables -A INPUT -p icmp --icmp-type echo-request -j ACCEPT
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
#
# NAT
#
iptables -t nat -A POSTROUTING -o wan -j MASQUERADE
#
# Saving
#
iptables-save > /etc/sysconfig/iptables
systemctl restart iptables
```
Выполняем вышеприведенный скрипт и теряем возможность устанавливать новые проводные ssh-соединения с «малинкой». Все правильно, мы изготовили Wi-Fi роутер, доступ к которому «через Интернет» по умолчанию запрещен — теперь только «по воздуху». Подключаем кабель провайдера в Ethernet и начинаем сёрфинг!
8. Бонус: +2,4GHz
=================
Когда по вышеописанному чертежу я собрал первый Raspberry роутер, то обнаружил у себя в хозяйстве некоторое количество гаджетов, которые в силу своих конструктивных ограничений Wi-Fi не могли увидеть «малинку» вообще. Перенастраивать роутер на работу в 802.11b/g/n было неспортивно, так как максимальная скорость «по воздуху» в таком случае не превышала 40 Мбит, а мой любимый Интернет провайдер предлагает мне 100 (по кабелю).
На самом деле, решение проблемы было уже придумано: второй Wi-Fi интерфейс, работающий на частоте 2,4GHz, и вторая точка доступа. В ближайшем ларьке я приобрел не первый, а второй попавшийся мне USB Wi-Fi «свисток». Продавец был истерзан вопросами о чипсете, совместимости с ARM-ядрами Linux и о возможности работы в режиме AP (он первый начал).
Конфигурируем «свисток» по аналогии со встроенным Wi-Fi адаптером.
Сначала — переименуем его в **wl1**:
```
# cat /sys/class/net/wlan0/address
b0:6e:bf:xx:xx:xx
```
**/etc/systemd/network/wl1.link**:
```
[Match]
MACAddress=b0:6e:bf:xx:xx:xx
[Link]
Name=wl1
```
Управлять новым Wi-Fi интерфейсом поручим отдельному демону hostapd, который будет запускаться и останавливаться в зависимости от наличия в системе строго определенного «свистка»: wl1.
Конфигурационный файл **/etc/hostapd/hostapd2.conf**:
```
ssid=rpi2
wpa_passphrase=1234567890
#channel=1
#channel=6
channel=11
interface=wl1
bridge=lan
driver=nl80211
auth_algs=1
wpa=2
wpa_key_mgmt=WPA-PSK
rsn_pairwise=CCMP
macaddr_acl=0
hw_mode=g
wmm_enabled=1
# N
ieee80211n=1
require_ht=1
ht_capab=[HT40][SHORT-GI-20][SHORT-GI-40][DSSS_CCK-40]
```
Содержимое этого файла напрямую зависит от модели USB Wi-Fi адаптера, поэтому банальный copy/paste может вас подвести.
Копируем дистрибутивный service-файл в **/etc/systemd/system/hostapd2.service**:
```
# cp -fv /usr/lib/systemd/system/hostapd.service /etc/systemd/system/hostapd2.service
```
и приводим его содержимое к следующему виду:
```
[Unit]
Description=Hostapd IEEE 802.11 AP, IEEE 802.1X/WPA/WPA2/EAP/RADIUS Authenticator
After=sys-subsystem-net-devices-wl1.device
BindsTo=sys-subsystem-net-devices-wl1.device
[Service]
Type=forking
PIDFile=/run/hostapd2.pid
ExecStart=/usr/sbin/hostapd /etc/hostapd/hostapd2.conf -P /run/hostapd2.pid -B
[Install]
WantedBy=sys-subsystem-net-devices-wl1.device
```
Осталось включить новый экземпляр hostapd:
```
# systemctl enable hostapd2
```
Вот и все! Подергайте «свисток» и саму «малинку», посмотрите на беспроводные сети вокруг.
И напоследок хочу предупредить о качестве USB Wi-Fi адаптера и электропитания Raspberry. Подключенный «на горячую свисток», иногда может вызвать «зависание малинки» из-за кратковременных электрических неприятностей. | https://habr.com/ru/post/458994/ | null | ru | null |
# Аналитика. Кот. Пятница
 Этот пост предназначен для подготовленного пользователя Хабрахабр и ведущих аналитиков веб-агентств, работающих с Google Analytics.
Три недели назад хабраюзер [centaurus](http://habrahabr.ru/users/centaurus/) опубликовал [пост](http://habrahabr.ru/post/190942/) о своих великолепных котиках, который имеет на данный момент 475 плюсов, почти 100 тысяч просмотров и занимает почетное первое место на пятой странице “Лучших постов за всё время”.
Мы, коллектив [Бурук](http://buruki.ru), решили, что нельзя оставлять мохнатых котиков только для технарей и добавили их к нам в выдачу вариантов перелета.
На первый взгляд наш поступок никак не связан со здравым смыслом, так же, как коты не связаны с авиабилетами и сравнением цен. Однако! Даже те, кто покупают билеты регулярно, знают, что это действительно стресс. Каждый раз пользователь боится перепутать фамилию, дату рождения и дату валидности паспорта. Если летит несколько человек, то проблемы нарастают кратно. После выбора рейса (обычно, на любой маршрут существует несколько десятков вариантов перелета) билет необходимо оплатить, а это снова напряжение — проверить валюту, которая будет списана, найти телефон для ввода кода 3D Secure и так далее.
Каждая покупка авиабилета это стресс и с ним нужно бороться. Для решения этой задачи в течение дня была разработана и внедрена функциональность кота, снимающего стресс. Фича изображена на иллюстрации ниже, живой пример можно посмотреть [по ссылке](http://buruki.ru/search/MOW/BKK/2013-12-02/2013-12-17/).
После клика на псевдоссылку с иконкой кота, пользователь видит попап с возможностью продолжить процедуру, поблагодарить разработчиков или отказаться от услуг кота. Так же предусмотрена возможность перехода на страницу автора кота [ru.iconka.com/cat-power](http://ru.iconka.com/cat-power/)
Внедрение любой функциональности требует оценки — реально ли она востребована пользователями. Возможно, разработчики живут в своём, оторванном от реальности, мире и решают несуществующие задачи.
Для проведения анализа была использована система Google Analytics от одной небольшой калифорнийской компании. Учет проводился на основе event’ов
**Немного кода для организации учета**
```
// Подключаем новый GA
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','__gaTracker');
__gaTracker('create', 'Ваш ID', {
'storage': 'none',
'clientId': 'Id пользователя/посетителя'
});
// При разработке можно использовать dummy функцию
/**
* Dummy analytics tracker function.
*
* @param {...} var_args
*/
function __gaTracker(var_args) {}
// Глобальные переменные и функции помещаем в namespace
var SiteNamespace = window.SiteNamespace || {};
SiteNamespace._ga_cache = {};
/**
* Удобная функция для отправки событий
*
* @param {Boolean} once - Посылать только "уникальные" события
* (уникальные комбинации переданных аргументов)
* @param {String} category - Категория
* @param {String} action - Действие
* @param {String} [label] - Ярлык
* @param {Number} [value] - Ценность
*/
SiteNamespace.trackGAEvent = function(once, category, action, label, value) {
if (typeof __gaTracker === 'undefined') {
return;
}
var cache = SiteNamespace._ga_cache;
if (!cache[category]) {
cache[category] = {};
}
if (!cache[category][action]) {
cache[category][action] = {};
}
if (cache[category][action][label]) {
if (once) {
// track only first usage
return;
}
} else {
cache[category][action][label] = true;
}
var opts = {
hitType: 'event',
eventCategory: category,
eventAction: action
};
if (typeof label !== 'undefined') {
opts['eventLabel'] = label;
}
if (typeof value !== 'undefined') {
opts['eventValue'] = value;
}
__gaTracker('send', opts);
};
```
В итоге были получены следующие аналитические данные:
За время, прошедшее с момента внедрения, стресс сняли более 1600 человек, спасибо им.
Среди пользователей большинство решило серьезно снять стресс, более 81% пользователей решили продолжить снятие стресса, просмотрев в среднем 8.74546 кота на сессию.
Из тех, кто продолжил просмотр, 95% (отлично!) пользователей были удовлетворены котами и сказали спасибо, 20 человек сказали спасибо более одного раза.
Около 31% респондентов признались в симпатии к собакам, а 21% оказались хейтерами котов.
Проведенное исследование будет продолжено, а количество снявших стресс возрастет.
Спасибо, [centaurus](http://habrahabr.ru/users/centaurus/) от Бурук и от довольных пользователей. | https://habr.com/ru/post/193528/ | null | ru | null |
# Полная кастомизация select без использования JS
Сколько я не мучил поисковик, а решения этого вопроса так и не нашлось. Конечно, всегда можно использовать JS и это нормально, но иногда ~~заказчик~~ душа просит изысков.
В заголовке я несколько приврал: всем известно, что select полностью кастомизировать нельзя, поэтому мы будем имитировать select. Сделаем мы это с помощью нескольких radio, нескольких label и одного div. Не так уж и много, правда?
**Структура**
```
linux
windows
other
```
Корневая label будет всегда видимой частью нашего альтернативного select. При клике на нее будет переключаться основной radio, который и отвечает за состояния открыт/закрыт у этой конструкции. Placeholder и традиционная стрелочка будут реализованы через псевдоэлементы :before и :after у корневой label. Все остальное, кроме wrapper (тот самый единственный div), по умолчанию скрыто. Почему мы не скрываем wrapper? Потому что в нем находится выбранный элемент (если такой есть), а он должен быть виден всегда.
**Основная часть**
```
label.selectGeneral
{
display: block;
position: relative;
}
/** Это обещанный placeholder **/
label.selectGeneral:before
{
content: attr(placeholder); /** Взять текст из атрибута placeholder **/
display: inline-block;
position: absolute;
top: 0;
left: 0;
z-index: -1;
max-width: 100%;
text-align: left;
white-space: nowrap; /** Не переносить слова **/
color: #adadad;
overflow-x: hidden; /** Скрыть лишнее **/
}
/** А это стрелочка **/
label.selectGeneral:after
{
content: "<>";
display: inline-block;
position: absolute;
top: 0;
right: 0;
text-align: center;
background-color: #ffffff;
transform: rotate(90deg);
}
label.selectGeneral input,
label.selectGeneral label
{
display: none;
}
label.selectGeneral div
{
min-width: 100%;
max-height: 500px; /** Ограничения на высоту списка выборов **/
overflow-x: hidden;
}
```
Осталось добавить немного магии — реализовать поведение всего этого добра. Магия будет основана на соседних селекторах и :checked у radio. Выбранный элемент виден всегда и при закрытом состоянии select перекрывает собой placeholder. При открытии select, показываются все остальные элементы для выбора, а wrapper, в который они вложены, немного съезжает вниз, что-бы было видно placeholder и пользователь не забыл, что же он, собственно, выбирает.
**Поведение**
```
/** Если наш альтернативный select открыт, то wrapper **/
label.selectGeneral input[type="radio"]:checked ~ div
{
position: absolute; /** приобретает абсолютную позицию **/
top: <высота label.selectGeneral>; /** и смешается немного вниз, открывая placeholder **/
overflow-y: auto;
}
/** Все label внутри wrapper'а при открытом select **/
label.selectGeneral input[type="radio"]:checked ~ div > label,
/** И выбранный вариант **/
label.selectGeneral input[type="radio"]:checked + label
{
display: block; /** должны быть видимыми **/
}
/** Подсветим элемент на который наведена мышь при открытом select **/
label.selectGeneral input[type="radio"]:checked ~ div > label:hover
{
background-color: #ffa834;
}
/** При закрытом select, нужно делегировать событие клика мышью с выбранного элемента родительскому label **/
label.selectGeneral input[type="radio"]:not(:checked) ~ div > input[type="radio"]:checked + label
{
position: relative;
z-index: -1;
}
```
В конце применен трюк с z-index, который позволяет расположить дочерний элемент ниже (глубже по z-оси) родительского. Этот замечательный факт позволяет делегировать реакцию на клик по выбранному элементу нашему select'у, что бы он раскрылся.
Рабочий пример можно лицезреть [тут](http://codepen.io/anon/pen/qEmNjb).
Из плюсов подхода можно отметить:
* Кроссбраузерность — это работает везде, где работают label
* Относительная легкость — код не перенасыщен лишними элементами
* Возможность полной кастомизацией — стилизуется каждая мелочь
* Гибкость — не придется дописывать новых стилей при добавлении пунктов выбора
Конечно же, есть и минусы, куда же без них:
* Отсутствие деградации — если не поддерживается, то стандартный select не спасет ситуацию (как подсказывают комментаторы — очень важный пункт для портативных устройств)
* Легкость легкостью, а дополнительный код все таки будет
* Невалидный код — div внутри label и атрибут placeholder у нее же, это не по стандарту
* Это не совсем минус, но эта штука не захлопывается сама при клике в любом месте экрана
Не думаю, что кто-то станет использовать это в production, но подход явно имеет право на жизнь.
UDPATE: Изменен код — добавлена функция автоматического закрытия select при выборе. | https://habr.com/ru/post/248243/ | null | ru | null |
# Разработка своего плагина визуализации для Grafana
Grafana — удобный инструмент для визуализации и мониторинга временных данных из множества источников. В этом посте я хочу рассказать ключевые концепции разработки своего плагина.
Создание своего плагина может понадобиться для 1) визуализации временных данных, т.к графановский движок удобен для создания запросов. 2) для расширения функциональности графаны под свои нужды.
Установка
=========
* Скачиваем и запускаем [Grafana любым способом](https://github.com/grafana/grafana)
* После запуска через `bin/grafana-server` должна появиться папка `data`
Что такое плагин c тех. точки зрения
====================================
Эти детали знать необязательно. Я разбирался с этими концепциями по ходу дела.
Grafana 5.x — это большое приложение [Angular](https://angularjs.org/) версии 1.6.6 :) и немного [React](https://reactjs.org/). Сам плагин — это angular controller, который лежит в файле `data/plugins/your-module/dist/module.js`, который может быть загружен как [SystemJS](https://github.com/systemjs/systemjs) модуль. Рядом должен быть файл `plugin.json` c мета-описанием плагина: название, id, иконки ...
Проект для разработки
=====================
Я рекомендую использовать следующий шаблон на [webpack](https://github.com/CorpGlory/grafana-plugin-template-webpack). Там есть описание фич почему он лучше. Кстати, он есть в [официальной документации](https://github.com/grafana/grafana/blob/master/PLUGIN_DEV.md#links)
В системе должен быть установлен [npm](https://www.npmjs.com/).
```
cd $GRAFANA_PATH/data/plugins
git clone https://github.com/CorpGlory/grafana-plugin-template-webpack.git
cd grafana-plugin-template-webpack
npm install
npm run build
```
**Альтернативная установка**
Можно склонировать в другую директорию, например в `/home/alex/development/grafana/plugins/grafana-plugin-template-webpack`, a потом создать файл `$GRAFANA_PATH/conf/custom.ini` и написать там
```
[plugin.template]
path = /home/alex/development/grafana/plugins/grafana-plugin-template-webpack
```
Теперь нужно перезапустить Grafana. Должна появиться строчка
`INFO[05-17|06:08:46] Registering plugin logger=plugins name="Plugin Template Name"`
в логах запуска графаны.
Дальше заходим на `localhost:3000`, нажимаем на знак `+` под логотипом для создания нового дашборда, в новом окне должно появиться окошко с выбором новой панели "Plugin Template Name". Должно появится такое окошко:
Разработка
==========
Открываем файл `src/module.js` — это наш "main". Отсюда графана делает загрузку плагина в страницу, ожидая инстанс `PanelCtrl`. Обратите внимание на последнюю строчку: `export { Ctrl as PanelCtrl }`. Вообще помните, что вы работаете в окружении большого фронт-энд приложения, где определено много переменных и можно импортировать библиотеки. Все, что 'import {...} from grafana/\*' — это уже доступные фичи.
Давайте перепишем конструктор вот так:
```
constructor($scope, $injector) {
super($scope, $injector);
console.log('hello from console');
}
```
Теперь можно использовать `npm run dev` вместо `npm run build`, т.к. код будет сам ребилдиться. Можно не перезагружать бэкенд графаны (это то, что мы запускали через `bin/grafana-server`), но графана любит кешировать файлы плагинов, так что будьте осторожны с перезагрузкой сбилженных сорцов. Внизу поста есть видео где я больше рассказываю о том, как устроена билд система, и использую шаблон Angular, который лежит в `partials`.
Наш класс является контроллером Angular и есть функция `link(scope, element)`. Я советую сделать `console.log(element)`, там будет html элемент с которым можно будет делать что хочется.
Вывод данных из запроса
=======================
Наш контроллер — наследник класса `PanelCtrl`, давайте теперь заменим его на класс `MetricsPanelCtrl`. Теперь, если зайти в режим [редактирования панели](http://docs.grafana.org/plugins/developing/defaults-and-editor-mode/), то там появился новая вкладка
Тут я использую [Grafana TestData](http://docs.grafana.org/features/datasources/testdata/)
Теперь изменим код класса-наследника вот так
```
constructor($scope, $injector) {
super($scope, $injector);
this.events.on(
'data-received', this._onDataReceived.bind(this)
);
}
_onDataReceived(data) {
console.log(data);
}
```
Здесь появилось использование объекта `this.events` — поле родительского класса, для подписки на событие о полученных данных. Больше фич MetricsPanelCtrl [только в исходниках](https://github.com/grafana/grafana/blob/master/public/app/features/panel/metrics_panel_ctrl.ts)
Перезагрузим плагин и получим данные от источника данных в консоли. Можно далее выбрать нужный вам источник данных и создавать к нему запросы через Grafana. И рендерить как захочется. Например, через [d3.js](https://d3js.org/).
Еще можно попробовать добавить вывод значения в шаблон. Для этого изменим конструктор:
```
constructor($scope, $injector) {
super($scope, $injector);
this.message = "nice!";
}
```
и изменим файл `partials/template.html`:
```
Hello from **Template Plugin** {{ ctrl.message }}
```
Заключение
==========
Можно почитать [официальную документацию](http://docs.grafana.org/plugins/developing/development/).
Я советую поразбираться с одним [опен-сорс плагином](https://github.com/CorpGlory/grafana-progress-list) для того, что бы разобраться как загружать данные и как получить больше из доступных для использования фич графаны. Например, использование [typescript](https://www.typescriptlang.org/), редактор, сохранение конфига `plugin.json` плагина, `assets`
Кстати, использование старых [директив англяра](https://docs.angularjs.org/guide/directive#creating-a-directive-that-manipulates-the-dom) — это зло, т.к. есть коллизи имен. Сейчас у нас есть размышления сделать билдер плагинов с компонентами.
И видео с аналогичным контентом от меня. Прошу прощения за звук. Тут есть еще доп информация:
Я еще рекомендую для разработки [Visual Studio Code](https://code.visualstudio.com/), в таком случае появится возможность [дебажить](https://www.youtube.com/watch?v=bAwy-pw41EU)
Всем удачного кодинга.
P.S. пост проверил [Alexander Zobnin](https://github.com/alexanderzobnin). Спасибо ему большое. | https://habr.com/ru/post/358746/ | null | ru | null |
# Статика в C#
Волею судьбы в последние годы у меня появилось ещё одно очень увлекательное хобби – учить. Я занимаюсь обучением людей, которые хотят стать программистами C#. Люди приходят разные: технари, гуманитарии, кто-то по своей воле, кого-то направляют от организаций. Не смотря на различные уровни, мне нужно их обучать. Поэтому я стараюсь постоянно обновлять и улучшать свои обучающие материалы. В связи с чем, пришёл к выводу: «А не плохо было бы оформить материалы в текстовом виде, чтобы ими было удобно пользоваться». Под катом я выложил как пример одну из недавно оформленных лекций.
##### Общая концепция
Перво на перво, следует разобраться что же такое статика. В C# есть ключевое слово static, которое можно применять к:
* полям
* свойствам
* методам
* операторам
* событиям
* конструктору
* классам
```
static class OneHuman
{
public static string Name { get; set; }
public static int Age { get; set; }
public static string GetInformation()
{
return string.Format("{0} is {1} years old", Name, Age);
}
}
```
Статика подразумевает, что вам не нужно создавать экземпляр класса. Все приведённые выше составляющие класса, доступны посредством указания его имени.
```
class Program
{
static void Main(string[] args)
{
OneHuman.Name = "Onizuka";
OneHuman.Age = 22;
Console.WriteLine(OneHuman.GetInformation());
}
}
```
Следует отметить, что необязательно делать весь класс статическим. Иногда достаточно применить статику для отдельных его членов.
```
class Box
{
public static string DefaultContext { get; set; }
public string Context { get; set; }
}
```
Если весь класс является статическим:
* Нельзя создавать экземпляр класса, используя ключевое слово new.
* Не разрешается использовать не статические члены этого же класса.
* Он не поддерживает наследование.
* Невозможно перегрузить методы.
Если класс не является статическим, но содержит статические методы, то на эти методы распространяются следующие ограничения:
* Не разрешается использовать не статические члены этого же класса из статических. Конечно же, вам никто не мешает создать экземпляр класса в статическом методе.
* Наследование и полиморфизм для статических членов не поддерживаются.
##### Больше деталей
Выше мы не рассматривали такую конструкцию, как статический конструктор. Один из достаточно интересных вопросов, на мой взгляд, когда происходит вызов статического конструктор у классов?
```
class Box
{
static Box()
{
Console.WriteLine("static ctor was called");
}
public Box()
{
Console.WriteLine("default ctor was calleds");
}
public static string Data { get { return "You are trying to get data"; } }
public const int Foo = 7;
}
```
Я думаю вы уже обратили внимание, что для статического конструктора не используется спецификатор доступа. Всё очень очевидно, создание статики вы не контролируете. Если попробовать выполнить приведённый ниже код, то можно убедиться в верности следующего утверждения: статический конструктор вызывается перед доступом к любому члену класса.
```
class Program
{
static void Main(string[] args)
{
var data = Box.Data;
var box = new Box();
}
}
```
Можно поиграться, закомментировав любую из строк в которых происходит обращение к классу Box. Теперь немного изменим код, и подправим наше утверждение
```
class Program
{
static void Main(string[] args)
{
var data = Box.Foo;
}
}
```
В данном случае вызов статического конструктора не происходит. Итак: **статический конструктор вызывается перед доступом к любому члену класса, за исключением констант**. Я не зря использовал слово класс в данном определении. Со структурами очень много “приколов”. Вы должно быть знаете, что в C# нельзя переопределить конструктор по-умолчанию, но можно определить статический конструктор без параметров. Однако он будет вызываться не всегда, так например не произойдёт его вызов, если вы, например, попытаетесь создать массив структур.
##### Общие рассуждения об использовании статики
Существует относительно много мнений, когда использовать статические классы и когда не стоит так поступать. Исходя из своего опыта, отмечу, статические классы — любимое оружие начинающих разработчиков. Попользовал и забыл — хорошая концепция. 
Чтобы разобраться в хитросплетениях о применяемости статики, следует вернуться к понятиям ООП. Представьте что у вас есть велосипед, но велосипед есть так же и у вашего соседа, и у соседа соседа, и т.д. В данном случае статика неприемлема. Т.к. велосипеды могут быть разного цвета, веса, обладать разным количеством колёс. То-бишь различные экземпляры одного и того же вида. Статика же применима для каких-то глобальных объектов\действий, когда не подразумевается создание экземпляров класса(часто для каких-то служебных методов: вывод на консоль — Console.WriteLine(), сортировка массива Array.Sort). Зачастую классы могут предоставлять как статическую, так и не статическую функциональность. Когда же у вас возникают сомнения, остановитесь и подумайте, понадобится ли вам экземпляр “этого”. Если же вы так хотите контролировать создание экземпляров класса или же вообще иметь только один, то для этих целей замечательно пригодится паттерн [Singleton](http://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%B8%D0%BD%D0%BE%D1%87%D0%BA%D0%B0_%28%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F%29). В рамках ООП статика обладает рядом недостатков. Чем же она так плоха?
###### Полиморфизм
Как упоминалось выше, статические классы не поддерживают наследование, т.е. вы не можете наследоваться от интерфейса или другого класса и таким образом расширить функциональность.
###### Тестирование
При использование статики тестирование достаточно затруднено. Нельзя оперативно подменять код, основываясь на интерфейсах. Если нужно менять, то серьёзно, переписывая значительные куски кода.
###### Единственная ответственность
Статические методы, зачастую, применяются для служебных целей, будь-то вывод в лог ошибок или сортировка массива. Поэтому иногда возникает желание запихнуть всю статическую функциональность в один класс, обозвав его MegaUtils. Так поступать не стоит, лучше создать целую кучу маленьких классов, отвечающих каждый за свою область деятельности. | https://habr.com/ru/post/206082/ | null | ru | null |
# Электронные библиотеки на работе и дома
Навеяно статьёй про [науку под замком](http://habrahabr.ru/post/189944/). Хотя моя статья не об этом, но тоже про доступ к электронным библиотекам, хотя и другого характера.
Работаю в западном… не, всё же северном университете, и приходится читать немало статей из своей области исследований. Благо, тут университетская библиотека подписана на множество электронных библиотек (интересно, сколько это удовольствие стоит… не, не так – сколько буржуи наживаются на наших статьях?). По моей тематике таких библиотек три – ACM, IEEE и Springer. А в них – львиная доля того, что мне нужно. И всё бы здорово, но есть одно НО.
Электронные библиотеки (ЭБ) определяют пользователей, видимо, по IP. Может я не прав, но доступ к ним открыт только если компьютер физически (через витую пару) подключен к сети Университета. По крайней мере, на станицах ЭБ значится по чьей подписке я могу скачивать статьи. Достаточно только подключиться к сети Университета по беспроводной сети, как сразу же ЭБ начинает просить деньги за статью. Понятное дело, что за пределами университета я только и вижу что тарифы на чтение труда коллег и своего собственного.
А что если я дома решил поработать (ну это я шучу: кто это сможет поработать в присутствии трёх сорванцов…) ну или в командировке мне позарез понадобилось что–то проверить, уточнить, или просто почитать, в конце–концов (очень реальный случай)? В какой–то момент, я решил что надо как–то это дело решать. Местный админ обрадовал меня только тем, что я не первый кто просит у него придумать решение как получить доступ к ЭБ удалённо. Без обещаний что–либо сделать. Позже от коллеги узнал что есть какое–то решение на общенациональном ресурсе, но работает оно как–то нестабильно – несмотря не то что коллега показала как она подключается к ЭБ через этот ресурс, у меня почему–то те же действия не привели к желаемому результату.
Вот тогда и появилось решение сделать всё самому, поскольку имеются небольшие навыки программирования PHP и JS. А также тот факт, что есть папки пользователей в локальной сети (из–под которой действует подписка на ЭБ), и в них можно размещать PHP–скрипты. Задумка выглядела так:
* разместить прокси в своей папке на локальном сервере Университета,
* написать расширение под Google Chrome, чтобы
* все ссылки ведущие на страницах ЭБ «не туда» (не на PDF статьи) менялись бы «на лету», т.е. всё выглядело бы так как будто нет никакого прокси и статьи открываются так как будто работаешь из внутренней сети Университета.
После поиска PHP проксей был взят простенький скрипт (благодарности Eric-Sebastien Lachance) передающий все HTTP заголовки (т.е. включая куки пользователя). Правда, его пришлось весьма расширить, чтобы 1) ограничить число доменов к которым можно обращаться пользователю, и 2) разрешать пользоваться им только студентам и работникам Университета (ну вы понимаете почему это не может стать доступным для всех желающих...), а для этого проверять залогинен ли пользователь в локальной сети (Интранете, залогиниться туда можно удалённо; кстати, этот шаг можно опустить, если пользоватся только самому). Для этого в каждом запросе, кроме собственно URL на PDF статьи, должен присутствовать ID его сессии в Интранете. Прокси делает запрос на страницу Интранета, установив нужный куки (JSESSIONID в моём случае) в переданное значение, и если от Интранета приходит положительный ответ, то выполняет запрос к ЭБ.
**Проверка пользователя**
```
function verifyUser($authCookieValue) {
global $authCheckURL;
global $authSuccessHTML;
global $authCookieName;
$result = false;
$error = '';
// create a new cURL resource
$ch = curl_init();
if ($ch !== false) {
// set URL and other appropriate options
$header = array();
$header[] = 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8';
$header[] = 'Accept-Language: en-US,en;q=0.5';
$header[] = 'Connection: close';
$header[] = 'DNT: 1';
curl_setopt($ch, CURLOPT_URL, $authCheckURL);
curl_setopt($ch, CURLOPT_HEADER, false);
curl_setopt($ch, CURLOPT_USERAGENT, 'User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:17.0) Gecko/20100101 Firefox/17.0');
curl_setopt($ch, CURLOPT_COOKIESESSION, true);
curl_setopt($ch, CURLOPT_COOKIE, $authCookieName.'='.$authCookieValue);
curl_setopt($ch, CURLOPT_ENCODING, 'gzip,deflate');
curl_setopt($ch, CURLOPT_HTTPHEADER, $header);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
// grab URL and pass it to the browser
$response = curl_exec($ch);
if($response === false) {
$error = curl_error($ch);
} else {
$result = strpos($response, $authSuccessHTML) !== false;
}
curl_close($ch);
} else {
$error = 'cannot initialize cURL';
}
return array(
'succeeded' => $result,
'error' => $error
);
}
```
На стороне пользователя работает расширение Google Chrome (состоит из двух частей – встраиваемый в страницу код, и код с доступом к вкладкам и куки работающий в фоновом режиме), и если URL относится к одной из трёх библиотек, то страница при загрузке сканируется на наличие определённых элементов которые должны быть на каждой странице где есть ссылка на PDF статьи (для каждой ЭБ это, конечно, разные элементы). Если такие элементы найдены, то туда подставляется запрос к прокси с правильно сформированной ссылкой на PDF статью. (Поиск того как и из каких из данных на странице правильно сформировать ссылку занял довольно немало времени).
**Пример для ACM**
```
// proxy config
var PROXY_URL = 'http://university.org/~user/proxy.php?';
var PROXY_URL_QUERY = 'urlForProxy=';
var PROXY_ID_QUERY = 'idForProxy=';
// page search and modification const
var ACM_PDF_LINK_NAME = 'FullTextPDF';
var ACM_ARTICLE_ID_NAME = 'id';
var ACM_PURCHASE_LINK = 'https://dl.acm.org/purchase.cfm';
var ACM_QUERY_URL = 'http://dl.acm.org/ft_gateway.cfm';
var ACM_QUERY = 'id={0}';
var ACM_LINK = '[PDF]({0} "FullText PDF") [proxy]';
// requests to the background page
var REQUEST_AUTH = 'auth';
function setACMLink() {
var pdfLink = document.getElementsByName(ACM_PDF_LINK_NAME)[0];
if (!pdfLink) {
var i, id, param;
var params = window.location.search.substr(1).split('&');
for (i = 0; i < params.length; i++) {
param = params[i].split('=');
if (param[0] === ACM_ARTICLE_ID_NAME) {
id = param[1].indexOf('.') > 0 ? param[1].split('.')[1] : param[1];
break;
}
}
if (id) {
var link = PROXY_URL + ACM_QUERY.format(id) + '&' +
PROXY_URL_QUERY + encodeURIComponent(ACM_QUERY_URL);
// purchase link is a placeholder for a link to PDF
var a, container;
var links = document.getElementsByTagName('a');
for (i = 0; i < links.length; i++) {
a = links[i];
if (a.href.indexOf(ACM_PURCHASE_LINK) === 0) {
container = a.parentNode;
container.innerHTML = ACM_LINK.format('#');
setClick(container.childNodes[0], link);
break;
}
}
}
}
}
function setClick(elem, link) {
elem.addEventListener('click', function (e) {
commPort.postMessage({name: REQUEST_AUTH, href: link});
e.preventDefault();
return false;
});
}
```
При клике на это ссылку к запросу присоединяется значение куки которая содержит ID сессии в Интранете Университета.
**Добавление идентификатора сессии в Интранете**В фоновом коде:
```
// config
var AUTH_URL = 'https://university.org/intranet';
var AUTH_COOKIE = 'JSESSIONID';
// const
var REQUEST_AUTH = 'auth';
chrome.runtime.onConnect.addListener(function (port) {
port.onMessage.addListener(function (request) {
var answer = {toRequest: request.name};
if (request.name === REQUEST_AUTH) { // check the authorization on the select web-site
answer.href = request.href;
answer.result = false;
answer.id = '';
chrome.cookies.get({url: AUTH_URL, name: AUTH_COOKIE}, function (cookie) {
if (cookie) {
answer.result = true;
answer.id = cookie.value;
}
port.postMessage(answer);
});
}
});
});
```
Во встроеном в страницу коде:
```
var commPort = chrome.runtime.connect();
commPort.onMessage.addListener(function (answer) {
if (answer.toRequest === REQUEST_AUTH) {
// add an authorization id, and send the request to to the proxy
window.location = answer.href + '&' + PROXY_ID_QUERY + answer.id;
}
});
```
Правда, для того чтобы открывались статьи на IEEE пришлось немало повозиться. Оказывается, для IEEE нужно открыть любую страницу на сайте его ЭБ через прокси (в Хроме открывается дополнительная вкладка, которая закрывается сразу после загрузки контента), чтобы получить от него куки с идентификаторами пользователя с подпиской. Плюс пришлось поколдовать с заменой в полученных куки значений domain и path (последнее было необязательным) в PHP, чтобы они могли автоматически передаваться вместе с запросом на PDF к прокси: приходили они (после этого дополнительного запроса для получения идентификаторов) как domain=ieeexplore.ieee.org, а линк на PDF уже указывал не на .ieeexplore.ieee.org/query, а на university.org/~user/proxy?url= ieeexplore.ieee.org%5Fquery, поэтому надо было править их на domain=.university.org, path=/~user/proxy.
**Переделка куки полученых от IEEE**
```
// config
$cookieDomain = '.university.org';
$cookiePath = '/~user';
$headerArray = explode("\r\n", $response['header']);
$js = '';
foreach ($headerArray as $headerLine) {
if (strpos($destinationURL, 'ieee.org') !== false) {
if (strpos($headerLine, 'Set-Cookie: ') !== false) {
$cookieArray = explode(': ', $headerLine, 2);
$headerLine = $cookieArray[0].': ';
$cookieDataArray = explode('; ', $cookieArray[1]);
$isFirstKey = true;
$js .= ' document.cookie = "';
foreach ($cookieDataArray as $cdKey => $cookieData) {
list($cname, $cvalue) = array_merge(explode('=', $cookieData), array(''));
if ($cname === 'domain') {
$cvalue = $cookieDomain;
$cookieDataArray[$cdKey] = $cname.'='.$cvalue;
}
if ($cname === 'path') {
$cvalue = $cookiePath;
$cookieDataArray[$cdKey] = $cname.'='.$cvalue;
}
$headerLine .= ($isFirstKey ? '' : '; ').$cookieDataArray[$cdKey];
$js .= ($isFirstKey ? '' : '; ').$cookieDataArray[$cdKey];
$isFirstKey = false;
}
$js .= "\";\r\n";
}
header($headerLine);
if (strlen($js) > 0) {
echo "\r\n\r\n".$js.''; // insert JS code into the page to set IEEE session and identification cookies
}
} else {
foreach ($headerArray as $headerLine) {
header($headerLine);
}
}
}
```
Последнее что хочу отметить, так это то это слабые стороны такой реализации:
* Если поменяется что–то в вёрстке страниц ЭБ, это решение перестанет работать. Зато пока работает это очень удобно: залогинился в Интранете, и работаешь
* Есть кое–какие проблемы с безопасностью: идентификатор сессии передаётся по HTTP, и потенциально его можно перехватить. Пока я один использую это решение, риск мне видится нулевым – как злоумышленник узнает что за набор цифр я передаю в прокси? Однако если он изучит расширение, получение доступа к чужому аккаунту в Интранете Университета станет делом техники. А HTTPS на директории пользователей на нашем сервере не распространяется… Возможно, надо будет использовать шифрование идентификатора сессии в расширении ([CryptoJS](http://code.google.com/p/crypto-js/)) и расшифровку на стороне сервера ([OpenSSL](http://php.net/manual/en/book.openssl.php)), так как всё же планирую разослать расширение коллегам
А вот полный [исходный код](https://www.dropbox.com/s/9cykv0d4fuzt66i/DLProxy.rar).
P.S. Если кто–то знает лучшее и такое же удобное решение, просьба поделиться. Можно брать код, пользовать, редактировать, делиться и т.д. Вообще, есть идея это на github залить, и если будут пожелания в комментариях, то так и сделаю.
P.P.S. За код сильно не ругайте — времени больше ушло на выяснение какие слать запросы проски (особенно для ЭБ на IEEE), чем на сам код. Он также может быть неполным — не всегда подставлять правильный линк. | https://habr.com/ru/post/192276/ | null | ru | null |
# Создание простейшего DI контейнера с использованием TDD
### Введение
Сегодня просмотрел ряд скринкастов от [Daniel Cazzulino](http://weblogs.asp.net/cazzu/archive/2009/02/02/funq.aspx), в которых он рассказывает о создании с нуля простейшего DI контейнера, что не могло не привлечь моего внимания. Ниже будут приведены примеры из его скринкастов.
Подробнее o IoC/DI контейнерах можно прочитать [здесь](http://habrahabr.ru/blogs/net/50845/)
### Требования
Нам понадобится Visual Studio 2008, 15-20 минут свободного времени и желание узнать как же сделать свой DI контейнер.
### Начнём. Funq1
* Для начала создадим проект Class Library в Visual Studio, назовём его Funq1
* Далее добавим в решение проект тестов (мы будем использовать TDD на базе тестов Visual Studio) и назовём его Funq1.Tests, создадим ссылку из него на наш проект Funq1
#### Funq1.Tests
* В проекте Funq1.Tests создадим тестовый класс ContainerFixture, который будет проверять функционал нашего контейнера.
* Добавим объявление интерфейсов IFoo, IBar, а так же соответственно классов Foo, Bar, для тестирования нашего контейнера:
> `1. public interface IBar { }
> 2. public interface IFoo { }
> 3.
> 4. public class Bar : IBar { }
> 5.
> 6. public class Foo : IFoo
> 7. {
> 8. public IBar Bar { get; private set; }
> 9.
> 10. public Foo(IBar bar)
> 11. {
> 12. Bar = bar;
> 13. }
> 14. }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
* Создадим тестовый метод, который проверит умеет ли наш контейнер регистрировать и возвращать объекты, выглядеть он будет примерно следующим образом:
> `1. [TestMethod]
> 2. public void RegisterTypeAndGetInstance()
> 3. {
> 4. var container = new Container();
> 5.
> 6. container.Register(() => new Bar());
> 7.
> 8. var bar = container.Resolve();
> 9.
> 10. Assert.IsNull(bar);
> 11. Assert.IsTrue(bar is Bar);
> 12. }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
* Итак, на тестовый класс ContainerFixture выглядит следующим образом:
> `1. using Microsoft.VisualStudio.TestTools.UnitTesting;
> 2.
> 3. namespace Funq1.Tests
> 4. {
> 5. [TestClass]
> 6. public class ContainerFixture
> 7. {
> 8. [TestMethod]
> 9. public void RegisterTypeAndGetInstance()
> 10. {
> 11. var container = new Container();
> 12.
> 13. container.Register(() => new Bar());
> 14.
> 15. var bar = container.Resolve();
> 16.
> 17. Assert.IsNull(bar);
> 18. Assert.IsTrue(bar is Bar);
> 19. }
> 20.
> 21. public interface IBar { }
> 22. public interface IFoo { }
> 23.
> 24. public class Bar : IBar { }
> 25.
> 26. public class Foo : IFoo
> 27. {
> 28. public IBar Bar { get; private set; }
> 29.
> 30. public Foo(IBar bar)
> 31. {
> 32. Bar = bar;
> 33. }
> 34. }
> 35. }
> 36. }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Funq1.Container
* Наш тест не проходит, так как Container остается не объявленный, в связи с этим в проекте Funq1 добавляем класс Container
* Объявляем поле, в котором будут храниться соответствия типов:
> `1. Dictionaryobject
> > factories = new Dictionaryobject>();
>
>
> \* This source code was highlighted with Source Code Highlighter.`
* Добавим метод для регистрации типа в контейнере:
> `1. public void Register(Func factory)
> 2. {
> 3. factories.Add(typeof(TService), factory);
> 4. }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
* А так же метод, для извлечения типа из контейнера:
> `1. public TService Resolve()
> 2. {
> 3. object factory = factories[typeof(TService)];
> 4.
> 5. return ((Func)factory).Invoke();
> 6. }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
* На данный момент наш Container выглядит следующим образом:
> `1. using System;
> 2. using System.Collections.Generic;
> 3.
> 4. namespace Funq1
> 5. {
> 6. public class Container
> 7. {
> 8. Dictionaryobject
> > factories = new Dictionaryobject>();
> -
>
> - public void Register(Func factory)
>
> - {
>
> - factories.Add(typeof(TService), factory);
>
> - }
>
> -
>
> - public TService Resolve()
>
> - {
>
> - object factory = factories[typeof(TService)];
>
> -
>
> - return ((Func)factory).Invoke();
>
> - }
>
> - }
>
> - }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Funq1.Tests
* Пробуем запустить тесты, но они не проходят, т.к. мы умышленно внесли ошибку в описании метода RegisterTypeAndGetInstance() в строке 17: Assert.IsNull(bar), чтобы убедиться, что тест срабатывает
* Для того, чтобы тест прошёл, следует изменить эту строчку на Assert.IsNotNull(bar);
* Далее нас интересует, а что же с зависимостью в конструкторе, как её необходимо зарегистрировать, для этого мы объявляем тестовый метод ResolveGetsDepedenciesInjected() и заносим следующие объявления:
> `1. container.Register(() => new Bar());
> 2. container.Resolve(() => new Foo(container.Resolve()));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
* Однако данное объявление не понравится нашему компилятору, т.к. в области видимости замыкания не присутствует container, в связи с этим данное объявление придётся немного изменить:
> `1. container.Register(c => new Bar());
> 2. container.Register(c => new Foo(c.Resolve()));
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Funq1
* Соответственно необходимо будет немного изменить наш контейнер, добавив в функции аргумент Container:
> `1. public void Register(Func factory)
> 2. {
> 3. factories.Add(typeof(TService), factory);
> 4. }
> 5.
> 6. public TService Resolve()
> 7. {
> 8. object factory = factories[typeof(TService)];
> 9.
> 10. return ((Func)factory).Invoke(this);
> 11. }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Funq1.Tests
* После внесенных в контейнер изменений необходимо будет немного поправить наш первый тестовый метод RegisterTypeAndGetInstance() строку 13 на выражение:
> `1. container.Register(c => new Bar());
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
* Далее вернемся к нашему методу ResolveGetsDepedenciesInjected() и добавим к нему извлечение объекта и утверждение-проверку на null, в результате получим:
> `1. [TestMethod]
> 2. public void ResolveGetsDepedenciesInjected()
> 3. {
> 4. var container = new Container();
> 5.
> 6. container.Register(c => new Bar());
> 7. container.Register(c => new Foo(c.Resolve()));
> 8.
> 9. var foo = container.Resolve() as Foo;
> 10.
> 11. Assert.IsNotNull(foo);
> 12. Assert.IsNotNull(foo.Bar);
> 13. }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
### Заключение
Вот и подошёл к концу наш увлекательный (надеюсь) урок по созданию с нуля простейшего DI контейнера, что же мы приобрели в процессе:
1. Базовое понимание функционирования DI контейнера
2. Практические навыки разработки с использованием TDD | https://habr.com/ru/post/53922/ | null | ru | null |
# Отправляем письма из мидлета или Как я дистанционно отлавливал ошибки
Многим наверно приходила в голову мысль о том что отправка из приложения писем на e-mail была бы весьма кстати. К примеру в качестве фидбека о работе программы, или с регистрационными данными, да мало ли для чего еще. Так и мне при разработке программы захотелось получать сообщения с ошибками в программе, так как будучи инди-разработчиком, под рукой имею десяток-другой наиболее распространенных телефонов, и провести крупномасштабное тестирование на широком диапазоне аппаратов, особенно новых, не так то просто. Поэтому механизм уведомлений о ошибках был бы весьма кстати, как минимум на этапе бета-тестирования. Покопавшись в сети нашел несколько библиотек для работы с электронной почтой, в том числе с mobilab'а. Но сколько бы не старался, у меня так и не получилось отправить письмо, хотя демки работали. А время поджимало.
Как гласит народная мудрость,
#### Хочешь сделать хорошо-сделай сам
Я нашел на [этом сайте](http://inettools.smpda.com/) исходники почтового клиента, и хотя бы он заработал. Но к сожалению обнаружил проблемы с кодировкой спецсимволов и кириллицы. Пришлось на скорую добавить свой кодировщик строк. Оформил всё в библиотеку, написал класс для работы с ней и добавил в приложение. Сначала это был отдельный пункт, из которого пользователи могли в случае чего отправлять сообщения, которые приходили мне на почту.
Позже пришел к выводу что надежней будет автоматизировать это дело, заранее предупредив пользователей о сборе информации о ошибках.
В результате итоговый код отправки стал таким:
```
} catch (Exception ex ){
sendMail("main class","some method" , ex);
}
public void sendMail(string classname, String methodname, Exception e)
{
SendMail mail=new SendMail();
mail.setText(classname+":"+methodname+":"+ e.toString());
mail.start();
}
```
А письма у меня выгладят примерно так
И собственно обработчик-отправщик
```
import Mail.Connection;
import Mail.Decoder;
import Mail.Message;
import Mail.SmtpClient;
public class SendMail extends Thread {
String host = "smtp.mail.ru";
int port=25;
String adressfrom = "[email protected]";
String pass = "123456";
String adressto = "[email protected]";
String subject = "Bugreport";
String text = "";
public void run() {
try {
String string = Decoder.encode(text, false);
SmtpClient smtpclient = new SmtpClient(new Connection());
smtpclient.open(host, port, adressfrom, pass);
Message message = new Message(adressfrom, adressto, Decoder.encode(subject), true));
message.addHeaderLine("X-mailer: 1.0");
message.addHeaderLine("Content-Type: text/plain; charset=UTF-8");
message.addHeaderLine("Content-Transfer-Encoding: quoted-printable");
message.addBodyLine(string.concat("\r\n"));
smtpclient.sendMessage(message);
smtpclient.close();
} catch (Exception exception) {
}
}
public void setText(String text) {
this.text = text;
}
}
```
Ну и исходники библиотеки [goo.gl/oVv8e](http://goo.gl/oVv8e) | https://habr.com/ru/post/146646/ | null | ru | null |
# Автоматизация Flex-приложений при помощи Java + Selenium + FlexMonkium
В этом посте я опишу свои исследования, которые мне пришлось проделать, когда на проекте стал вопрос об автоматизации тестирования. Проект представляет собой веб-сайт, клиентская часть которого написана на Flex, а серверная — на Python(Django).
##### Выбор средств для автоматизации
Для начала рассмотрим путь от начала, который я прошел, прежде чем остановился на связке Java + Selenium + FlexMonkium. А это:
* Selenium + Sfapi
* Ranorex
* FlexMonkey
* Selenium + FlexMonkium
Первым, что я попытался использовать в качестве средств автоматизации, был Sfapi(Selenium Flex-API). Работает он в связке с Selenium RC и каким-либо языком программирования, для которого есть драйвера (Java, C#, Python, Ruby). Из преимуществ следует отметить, что это бесплатное решение, которое действительно работает. Из недостатков — много кода, но мало результата. Плохо работает с динамическими элементами приложения. Причиной дальнейшего поиска решений стали большие объемы кода, которые выполняли простенькие операции.
Следующим софтом для автоматизации Flex-приложений, который я попробовал, оказался Ranorex Studio. Это очень приятный в использовании программный комплекс, с интуитивно понятным интерфейсом. Из плюсов стоит отметить быстрое создание тестов без знания языка программирования с помощью встроенного функционала и Spy-агента (который записывает последовательность действий пользователя), допиливание уже созданных тестов, методом конвертации их в любой язык программирования из предлагаемых (список поддерживаемых языков зависит от типа купленной лицензии) и хорошее взаимодействие с практически всеми UI-элементами Flex (на формах встречал жалобы на некорректную работу с элементом DataGrid, но во время работы мне не довелось с ним поработать). Из недостатков — высокая стоимость лицензии, если нужно тестировать приложение на разных доменах (например, тестовый и главный сервера), то необходимо предварительно с тестами произвести кое-какие преобразования, что бы они корректно начали взаимодействовать с интерфейсом приложения. Именно высокая стоимость лицензии послужила причиной для дальнейшего поиска решений.
Не дожидаясь окончания лицензии Ranorex, я продолжил поиски в сторону свободного ПО и на одном из форумов наткнулся на совет использовать FlexMonkey. На их сайте есть коротенькая, но вполне понятная документация, так же имеется форум с активными обсуждениями и «живая» поддержка. Само приложение написано на Adobe Air, имеет понятный и удобный интерфейс.
Как оказалось, FlexMonkey очень шустрый, удобный и бесплатный. Корректно поддерживает работу практически со всеми UI-компонентами (по крайне мере у меня работало все на ура), но так же имеет один недостаток — тесты нельзя усовершенствовать с помощью какого-либо языка программирования. По сути можно пользоваться только базовыми функциями, такими как проверка свойств компонентов, сравнивание значений этих свойств и т.д. Но, например, сделать подсчет писем в почтовом интерфейсе пользователя без средств программирования не получится. Вот здесь на помощь приходит следующий продукт от создателей FlexMonkey, который работает в связке с Selenium и называется [FlexMonkium](http://www.gorillalogic.com/flexmonkium).
##### Настройка рабочей среды
Для того, что бы приступить к автоматизации тестирования своего flex-приложения, необходимо настроить проект на взаимодействие с Selenium RC + FlexMonkium, а так же подготовить среду программирования (для примера я выбрал язык Java с Eclipse IDE). Далее все действия расписаны по шагам:
1. [Скачиваем](http://seleniumhq.org/download/) Selenium RC и Selenium Client Driver для языка программирования, на котором будут писаться тесты (в моем случае Java).
2. [Скачиваем FlexMonkium](http://www.gorillalogic.com/flexmonkium/downloads) (в примере использовалась версия 4.1.8). В архиве находятся три компонента — папка с библиотеками .swc, одну из которых нужно будет подключить к Flex-проекту, «user-extensions.js», являющийся расширением для Selenium server, благодаря которому он «будет понимать» команды управления flex-приложением, указанные в тестах и .xpi плагин, расширяющий функционал Selenium IDE для Firefox.
3. Открываем Flex-проект во Flash Builder и подключаем к проекту библиотеку .swc из скачанного архива. Всего в архиве несколько таких файлов с одинаковым названием и цифрой в конце. Цифра означает номер версии Flex-SDK (в моем случае это четвертая версия, то есть нужно [подключить](http://www.gorillalogic.com/books/flexmonkium-docs/flexmonkey-setup) automation\_monkey4.x.swc). После этого перекомпилируем проект и вуаля — он готов взаимодействовать с Selenium сервером.
4. Теперь нужно запустить Selenium сервер с файлом расширения команд, который позволит ему «понимать» команды, специфичные для управления flex-приложением. Этот файл содержится в скачанном архиве FlexMonkium и называется «user-extensions.js». Передается в качестве параметра в командной строке при запуске сервера. Для этих целей я создал отдельный bat-файл со следующим содержанием:
`java -jar C:\Automation\selenium-server-standalone-2.0rc2.jar -userExtensions C:\user-extensions.js`
После этого можно смело запускать сервер. Если все было правильно сделано, после запуска bat'ника на экране будет висеть примерно такое окошко:
Итак, тестируемое приложение готово к взаимодействию со средствами автоматизации тестирования, а Selenium-RC запущен и понимает команды управления flex-компонентами.
##### Создаем первый тест
В качестве языка для написания тестов я выбрал Java со средой разработки Eclipse в связке с библиотекой JUnit. При таком сочетании тесты прекрасно работали, но JUnit после каждого теста перезапускал браузер, что для меня было не желательно, так как многие мои тесты были продолжением предыдущих, а сброс состояния приложения меня не устраивал. После некоторых поисков по форумам я прочитал, что такое поведение невозможно отключить и мне пришлось отказаться от использования JUnit. В отчете мне требовалось всего лишь знать, какие тесты не прошли, на каких шагах это случилось и сколько всего таких ошибок возникло. Для этих целей я написал специальную функцию, которая выводит в консоль данную информацию. Она вызывается в случае, когда тест не прошел (когда не проходит тест, у него срабатывает таймаут) и Java сгенерировал исключение. В итоге у меня получился такой код:
```
import java.awt.event.KeyEvent;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import com.thoughtworks.selenium.DefaultSelenium;
import com.thoughtworks.selenium.HttpCommandProcessor;
import com.thoughtworks.selenium.Selenium;
public class TestRunner {
private Selenium selenium;
private HttpCommandProcessor proc;
private int errorsFound;
//Генерируем уникальный текст письма что бы не путаться
DateFormat dateFormat = new SimpleDateFormat("yyyy_MM_dd_HH_ss");
Date date = new Date();
String msg_text = dateFormat.format(date);
public static void main(String[] args) {
TestRunner tr= new TestRunner();
tr.errorsFound = 0;
try{
tr.seleniumStart();
//----Тестируем почту----
tr.goMail();
tr.postSend();
tr.outBoxVerifyMessage();
}catch(Exception ex) {}
}
//Starting selenium server
public void seleniumStart() throws InterruptedException
{
proc = new HttpCommandProcessor("localhost", 4444,
"*firefox3 c:\\Program Files\\MozillaFirefox3.6\\firefox.exe", "http://q/");
selenium = new DefaultSelenium(proc);
selenium.start();
Thread.sleep(5000);
selenium.open("/site_media/");
}
//Shutting down selenium server
public void seleniumStop()
{
if (selenium != null) {
selenium.stop();
selenium = null;
}
System.out.println("\r\nTesting compleated. Errors found: "+errorsFound);
}
//Error reporter
public void printError(String test, String step)
{
errorsFound ++;
System.out.println("\r\nError in Test: '"+test+"' on step: '"+step+"'");
}
//Step runner
public void testExec(String testName, String step, String cmd, String locator,
int time) throws Exception
{
for (int t = 0;; t++) {
if (t >= time) printError(testName, "Step "+step);
try {
if (proc.getBoolean(cmd, new String[] {locator})) break;
} catch (Exception e) { }
Thread.sleep(500);
}
}
//-----------------------------------------------------------------------------------
////////////////////////////////////////ПОЧТА////////////////////////////////////////
//-----------------------------------------------------------------------------------
//Переходим на страницу почты
public void goMail() throws Exception {
String test = "goMail";
//Step 1. Ждем загрузки флешки
testExec(test, "1", "isFlexMonkey", "", 60);
//Step 2. Кликаем на кнопку "Почта"
testExec(test, "2", "isFlexMonkey",
" ", 60);
}
//-----------------------------------------------------------------------------------
//Проверка отсылки почты
public void postSend() throws Exception {
String test = "postSend";
//Step 3. Кликаем на кнопку "Написать"
testExec(test, "3", "isFlexMonkey",
"", 60);
//Step 4. Раскрываем список адресатов
testExec(test, "4", "isFlexMonkey",
"", 60);
//Step 5. Выбираем адресата из списка
testExec(test, "5", "isFlexMonkey",
"", 60);
//Step 6. Переходим в поле "Тема"
testExec(test, "6", "isFlexMonkey",
"", 60);
//Step 7. Пишем тему письма
testExec(test, "7", "isFlexMonkey",
"", 60);
//Step 8. Переходим в следующее поле (текст письма)
testExec(test, "8", "isFlexMonkey", "", 60);
//Step 9. Пишем текст письма
testExec(test, "9", "isFlexMonkey",
"", 60);
//Step 10. Жмем кнопку отправить
testExec(test, "10", "isFlexMonkey", "", 60);
}
//-----------------------------------------------------------------------------------------------
//Проверка отправленного письма в исходящих
public void outBoxVerifyMessage() throws Exception {
String test = "outBoxVerifyMessage";
//Step 1. Переходим в исходящие
testExec(test, "1", "isFlexMonkey",
"", 60);
//Step 2. Проверяем тему
testExec(test, "2", "isFlexMonkey",
"", 10);
//Step 3. Проверяем текст
testExec(test, "3", "isFlexMonkey",
"", 10);
//Step 4. Проверяем получателя
testExec(test, "4", "isFlexMonkey",
"", 10);
}
}
```
В данном примере тестируется отправка письма по внутренней почте приложения, а так же проверка его отображения среди исходящих писем.
А теперь подробнее. Функции «seleniumStart» и «seleniumStop» начинают и завершают сессию. В первой функции инициализируется экземпляр класса Selenium, который посылает команды серверу. В него передаются такие параметры, как хост и порт (на котором запущен сервер Selenium), браузер (в котором будет проводиться тестирование) и url (по которому доступно тестируемое приложение).
Далее идет функция «printError», которая принимает в качестве параметров название теста и номер шага и выводит их в консоль. Вызывается эта функция при достижении таймаута на каком-либо шаге теста.
Чтобы не писать в каждом шаге блок повторяющегося кода, он был вынесен в отдельную функцию, называемую «testExec». Ее параметрами являются название и номер выполняемого шага (которые передаются в «printError» по истечению таймаута), команда для сервера, путь (локатор) к элементу в приложении, до которого пытаемся «достучаться», и таймаут. Обратите внимание, что путь приложения в приведенном примере имеет 2 типа: «VerifyProperty» и «UIEvent ». Первый используется для получения\сравнения значений атрибутов какого-либо элемента, а второй для осуществления действия над указанным элементом, например, кликнуть на кнопке. Указать можно UI-элемент приложения не только по его имени или id, но и по совокупности нескольких его свойств, которые дополнительно указываются в тегах «arg». Более подробную документацию можно получить на сайте [Gorilla Logic](http://www.gorillalogic.com/books/flexmonkium-docs/using-flexmonkium).
Чтобы не писать локаторы вручную, я записывал последовательность шагов через FlexMonkey, экспортировал тесты в xml файл и вставлял в Java-код. В результате получался такой результат:
```
...
```
Или же можно установить плагин flexmonkium.xpi в дополнении к Selenium IDE и делать запись тестов непосредственно из браузера Firefox.
Но во всяком случае эти 2 способа не гарантируют 100% точной работы тестов, особенно когда компоненты приложения имеют динамически генерируемый ID. В этом случае придется вручную дописать дополнительные аргументы, явно присущие требуемому компоненту. Свойства компонентов можно посмотреть во FlexMonkey или FlexMonkium Console.
##### Результат
На данный момент на проекте автоматизировано большинство регрессионных тестов. Их количество составило > 350, время выполнения которых примерно 3-4 часа.
Прошу прощения за такой большой кусок кода в примере, который раздул объем статьи. | https://habr.com/ru/post/129829/ | null | ru | null |
# Ленивый Reverse Engineering — Часть 2
Статья расскажет о практическом аспекте при использовании инструментария, который позволяет производить исследование программного обеспечения с минимальным порогом вхождения и максимальной информативностью. Рассмотрим следующие инструменты:
* эмуляторы
* библиотеки для разбора форматов файлов
* интерактивные дизассемблеры
* документация
* динамическая инструментация
Первую часть статьи читайте [здесь.](https://habr.com/ru/company/otus/blog/659445/)
### Эмуляторы
При анализе файлов, которые запускаются в операционных системах у специалиста по RE есть очень много подсказок. Например таких, как:
* используемые из библиотек функции
* разрядность процессора
* расположение кода и данных с которыми работает приложение внтури файла
* и т.д.
Но бывают и ситуации, когда нужно понять кусочек данных, который сам оп себе работать не будет, например шеллкод или базонезависимый код. Для изучения этого артефакта нужно написать кусок приложения на языке ассемблера, но для ускорения процесса мы будем использовать инструмент `msfvenom`.
Генерируем шеллкод:
```
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.56.12 LPORT=7777 -f raw -o shellcodex86.hex
```
Откроем в шестнадцатеричном виде:
Не очень понятно, хотя и можно получить дизассемблированный листинг:
Кстати файл открыт в [Hiew](https://www.hiew.ru). Проанализировать статически такой код можно и при большом опыте занимает несколько секунд, но а что если мы просто попробуем это упростить?
Возьмем проект на базе [libemu](https://github.com/buffer/libemu) — единственная активная ссылка на момент написания статьи. Библиотека достаточно древняя, но свою работу выполняет до сих пор хорошо.
Запуск достаточно прост так как мы не используем дополнительных уровней для пакования шеллкода, можно просто поставить путь до файла и нажать `Launch`:
В результате мы можем просто видеть наименования функций, которые использует шеллкод и не тратить время на его разбор.
А что насчет файлов? Можно ли запускать отдельные функции или куски кода чтобы посмотреть что происходит с процессором или ОС? Для этого можно использовать инструменты, которые построены на другом [проекте](https://www.unicorn-engine.org). Этот проект сейчас чуть ли не единственный, который используется исследователями для составления своих инструментов. Попробуем с ним повзаимодействовать. Для этого нам понадобится IDA Pro и вот этот [плагин](https://github.com/mandiant/flare-emu). Установка достатьчно проста, нужно скопировать файл плагина в директорию Python. Найти её можно там же, где была установлена IDA.
Остальной процесс аналогичен работе с эмулятором для шеллкода. Необходимо выбрать функцию для эмуляции и запустить ее. Оставим это упражнение на домашнее задание.
### Библиотеки для разбора форматов файлов
Существует множество форматов файлов, которые достаточно сложно разбирать используя только документацию и чтобы было еще проще это делать можно просто воспользоваться разметкой. Как мы и писали в прошлой статье удобна для этих задач библиотека [kaitai struct](https://kaitai.io). Но для ее использования придется программировать, а у нас `ленивый` выпуск. Поэтому попробуем найти что-то с использованием этой бибилиотеки. Сразу попадается [проект](https://github.com/taviso/kiewtai), который использует kaitai struct в качестве парсера и сразу же интегрирует его возможности в Hiew. Достаточно только скомпиллировать проект и выложить файл hew в директорию с установленным Hiew.
Загружаем файл, нажимаем F11 и выбираем формат, который мы хотим изучить:
На странице проекта показано, что если включать подробный разбор данных, то будет подсвечиваться каждое поле, однако в версии Hiew, который был использован для скрина эта фича не заработала. Дополнять возможности плагина можно за счет описания новых форматов файлов и рекомпиляции плагина.
**## Интерактивные дизассемблеры**
Про эти массивные проекты можно писать бесконечно. Рассмотрим чудо функцию, которая есть в IDA Pro — декомпиляция. Она предоставляет псевдокод, который имеет Си подобный синтаксис и его даже можно компиллировать с помощью компилляторов типа cl.exe и gcc. Только для успешной компиляции придется предоставить все библиотеки, которые требует код.
Загрузим наш файл в интерактивный дизассемблер. Это моэно сделать через меню File или просто переместить файл на ярлык IDA.
Проведем декомпиляцию main функции нажав кнопку F5:
Иногда эта супер сила не работает и нужно еще предварительно исправлять ошибки анализатора. Эти особенности рассмотрим в следующих статьях.
### Динамическая инструментация
По сути самая сложная среди инструментов, здесь без программирования не обойтись совсем. Можно поискать готовые сниппеты и подходы к изучению приложений, однако все равно придется немного `обработать напильником` чтобы использовать.
В этой статье будем использовать frida. Да, этот проект может быть использован не только для работы с мобильными приложениями.
Основные модули, которые предоставляет этот фреймворк позволяют отслеживать действия приложения на самых разных этапах. Например:
* Interceptor — универсальный набор методов, который позволяет работать с функциями приложений на любых поддерживаемых платформах
* Stalker — сбор данных о работе кода приложения, так же доступен для всех поддерживаемых платформ
* ObjC — набор методов для работы с Runtime iOS и macOS
* Java — набор методов для работы с Runtime Java, наиболее популярен в использовании для платформы Android
Инструмент позволяет произвести сбор информации как относительно одной функции так и всех сразу. Давайте попробуем собрать данные по тем функциям, которые мы видели в логах эмулятора:
1. LoadLibrary
2. WSAStartup
3. WSASocket
Как это сделать проще всего? Инструмент frida-trace. Инструмент сделает шаблон функции, которую можно будет модифицировать под любую задачу. Одно огрраничение - мониторинг в таком авиде работает только для одной функции. Ниже приведен пример для сбора данных по всем функциям, которые имеют префикс LoadLibrary:
```
frida-trace --decorate -i "LoadLibrary*" -f test.exe
```
Объединяя все инструменты вместе можно `лениво` проанализировать любой алгоритм, который будет в приложении без дополнительной защиты.
---
Автор статьи — Александр Колесников. Всех желающих также приглашаем на открытый урок, на котором разберём работу mbr руткита и проанализируем его ключевые этапы и стадии развёртывания. Регистрация [по ссылке.](https://otus.pw/NTaY/) | https://habr.com/ru/post/660995/ | null | ru | null |
# Знай свои секреты. Поиск и автоматическая проверка секретов сторонних сервисов
Привет, Хабр!
По традиции, представлюсь, меня зовут Юрий Шабалин, и вместе с командой Стингрей мы разрабатываем платформу анализа защищенности мобильных приложений. Сегодня я хотел бы рассказать о хранении секретов в мобильных приложениях. А именно о том, что происходит с аутентификационными данными от сторонних сервисов, которые мы так любим использовать. И, конечно, о том, какими последствиями может обернуться для приложения и компании отсутствие должного внимания к их безопасности. Поехали!
Оглавление
----------
* [Вступление](#%D0%92%D1%81%D1%82%D1%83%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5)
* [Проблема](#%D0%9F%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC%D0%B0)
* [Способы решения](#%D0%A1%D0%BF%D0%BE%D1%81%D0%BE%D0%B1%D1%8B%20%D1%80%D0%B5%D1%88%D0%B5%D0%BD%D0%B8%D1%8F)
* [Примеры](#%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D1%80%D1%8B)
+ [Firebase](#Firebase)
+ [Сервисы Google](#%D0%A1%D0%B5%D1%80%D0%B2%D0%B8%D1%81%D1%8B%20Google)
+ [FCM / GCM](#FCM%20/%20GCM)
+ [Добавление собственных проверок](#%D0%94%D0%BE%D0%B1%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5%20%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85%20%D0%BF%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%BE%D0%BA)
* [Варианты хранения](#%D0%92%D0%B0%D1%80%D0%B8%D0%B0%D0%BD%D1%82%D1%8B%20%D1%85%D1%80%D0%B0%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F)
+ [Хранение ключей в iOS](#%D0%A5%D1%80%D0%B0%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%B9%20%D0%B2%20iOS)
+ [Хранение ключей в Android](#%D0%A5%D1%80%D0%B0%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5%20%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%B9%20%D0%B2%20Android)
* [Заключение](#%D0%97%D0%B0%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5)
* [Ссылки](#%D0%A1%D1%81%D1%8B%D0%BB%D0%BA%D0%B8)
Вступление
----------
Как упоминалось в [одной из наших статей](https://habr.com/ru/company/swordfish_security/blog/658433/), проблема хранения данных - одна из самых часто встречающихся в мобильных приложениях. Причем речь может идти не только об информации, непосредственно связанной с самим приложением и пользователями (включая пароли, пин-коды, персональные и конфиденциальные сведения), но и о данных от сторонних сервисов. Что имеется в виду? Сегодня мобильные приложения для реализации своего функционала часто применяют внешние сервисы, включая рассылку Push-уведомлений, хранение изображений на S3, интеграцию с различными картами, сервисами местоположения и многое-многое другое. И это полностью оправданно - не надо тратить свое время на то, что можно подключить и сразу использовать. Интегрировать готовые и удобные сервисы намного проще и выгоднее как в части разработки, так и в части обеспечения безопасности. Но очень важно правильно хранить токены, используемые для этих интеграций, - об этом мы и поговорим.
### Проблема
По своему опыту могу сказать, что аналитикам по безопасности, тестирующим мобильные приложения, приходится тратить на этот процесс весьма много времени. Определить все сервисы, с которыми взаимодействует приложение, найти токены, применяемые для интеграции, проверить их валидность и их использование - это сложная техническая задача и огромный труд, особенно учитывая разнообразие сервисов и их возможностей.
Выдать права и токен только на один определенный сервис - очень сложно, особенно если раньше вы никогда этим не занимались или если речь идет о новом сервисе. Главная проблема - сделать так, чтобы токен работал только с нужным сервисом и не обладал лишними правами.
Как обычно происходит процедура выпуска токена? Взаимодействие с системой выдачи прав и разрешений в сложном и большом сервисе выглядит примерно так: “Мне нужно, чтобы мое приложение умело получать вот эти данные. В документации написано, что мне нужна вот такая роль. Хорошо, поставлю ее. Так, не работает… Поставим еще и вот эту роль, она тоже делает что-то похожее... Опять не работает… А если и вот это еще… О, работает! Так и оставим!“
Наверное, каждый из нас проходил такой путь, чтобы достичь нужного результата. Довольно часто этот процесс приводит к тому, что выданные токены для доступа имеют более широкие привилегии, чем необходимо.
Еще один пример - миграция одного сервиса в другой, когда прежние ключи еще действуют для обеспечения обратной совместимости. Если процесс выполнен некорректно, ключи могут получить больше привилегий, чем было до этого. Такое, конечно, происходит крайне редко, но может случиться, например, при переходе GCM (Google Cloud Messaging) в FCM (Firebase Cloud Messaging). И иногда это может стать проблемой. Об этом подробно рассказано в статье, автор которой нашел десятки, если не сотни, ключей FCM/GCM, дающих возможность [отправлять произвольные Push-сообщения](https://abss.me/posts/fcm-takeover/) от имени приложения.
Другой вариант - это банальная невнимательность или ошибка, когда в приложение попадает совсем не тот ключ, который должен. Вручную отличить их невозможно. Есть два ключа, есть две строки из 256 символов. Какой из них правильный, ни на одном из этапов разработки узнать не получится, только если специально это не проверить. Так что, если вы хотя бы однажды ошиблись с файлом или со значением ключа, оно может использоваться в приложении и до сих пор. И это не теория: так и было с одним из приложений, которые нам довелось анализировать.
Есть и еще один вариант, с которым мы сталкивались. Иногда при изменении процесса сборки или конфигурации в итоговый релизный артефакт попадает файл, которого там быть не должно. Именно так в одном из популярных приложений оказался “посторонний“ приватный ключ. Из-за этой ошибки пришлось срочно предпринимать решительные действия, выпускать новую версию, отзывать текущую, придумывать механизм, чтобы заменить скомпрометированный приватный ключ.
Как токен или ключ от какого-либо сервиса может попасть в приложение и остаться там на долгое время? Способов немало. А задача аналитиков безопасности - своевременно выявлять такие файлы или значения и сообщать об этом разработчикам. Они должны это сразу исправлять, не дожидаясь попадания такого рода информации в магазин приложений. Если такой токен получили клиенты, он считается скомпрометированным, и его использование в дальнейшем недопустимо. Что делать? Необходимо перевыпустить токен, включить его в приложение, убедиться, что приложение со старой версией больше никто не использует, возможно, отозвать старую версию и многое, многое другое. А ведь это все - время и дополнительные затраты, которых можно было бы избежать, как и репутационных потерь. А потратить ресурсы было бы лучше на добавление нового функционала и развитие бизнеса.
Способы решения
---------------
Каждый день сталкиваясь с поиском токенов, используемых для интеграций со сторонними сервисами, по определенным паттернам, и проверкой их на валидность, начинаешь задумываться о том, можно ли как-то автоматизировать этот процесс.
Существует несколько способов это сделать. Нашей командой было найдено и проанализировано как минимум три репозитория для поиска секретов:
1. [Keyhacks](https://github.com/streaak/keyhacks) - список различных регулярных выражений для самых разнообразных сервисов. Для некоторых из них есть описание того, как найденные ключи можно проверить. Также приводятся критерии определения успешности (например, что должно прийти в ответе, чтобы понять, валидный ключик или нет). Очень полезный репозиторий, который отлично подходит в качестве расширения проверок и базы для дальнейшей автоматизации.
Список достаточно активно развивается и поддерживается, и последнее обновление было 18 дней назад (на момент написания статьи).
2. [RegHex](https://github.com/l4yton/RegHex) - довольно большой и полный список регулярных выражений под многие сервисы. К большому сожалению, не содержит никаких сведений о том, как эти самые секреты проверять, являются ли они действующими или нет. Может использоваться, как отличное дополнение к двум другим репозиториям в части поиска определенных ключей.
Последнее обновление - 8 месяцев назад (на момент написания статьи).
3. [Detect-secrets](https://github.com/Yelp/detect-secrets) - репозиторий, который может стать отличным дополнительным шагом в процессе CI/CD или в процессе тестирования готового решения. В отличие от двух предыдущих, является не просто списком регулярных выражений, а полноценным инструментом для поиска секретов в коде и также имеет дополнительную функциональность в виде проверки некоторых секретов на валидность. Инструмент имеет модульную структуру и позволяет дописывать собственные плагины для поиска и валидации секретов. То есть, если обогатить этот репозиторий данными и способом проверки токеном из двух предыдущих, может получиться вполне хороший инструмент.
В дополнение к конкретным плагинам этот репозиторий имеет интересный режим поиска, основанный на определении “мусора“ (Gibberish Detector). Он основан на простой ML-модельке, которая определяет, похожа строка на слово или нет. Инструмент обучается на английском тексте (в примере - отрывок из Шерлока Холмса) и определяет, с какой частотой буквы следуют друг за другом. Он умеет оценивать, насколько строка, которую подали на вход, соответствует ранее обученной модели и насколько она похожа на реальное слово. Так как секреты, в основном, это случайно сгенерированная строка, то можно найти еще несколько ключей, формат которых изменился или для которых нет правил.
Примеры
-------
Основываясь на различных исследованиях и анализе приложений, можно выделить несколько сервисов, ключи от которых будет логично искать в мобильных приложениях и сразу проверять их на валидность:
* Firebase Cloud Messaging / Google Cloud Messaging
* Google Services
* Twitter
* Facebook
* Instagram
* AWS
* GitHub
* PayPal
* slack
* Cloudant
* IBM Cloud Object Storage
* Stripe
* Twillo
Про некоторые из них я бы хотел рассказать немного подробнее.
#### Firebase
Firebase — одно из широко используемых хранилищ данных для мобильных приложений. В 2018 году команда Appthority Mobile Threat Team (MTT) [обнаружила уязвимость](https://library.cyentia.com/report/report_001147.html), связанную с неправильной конфигурацией Firebase. Ее назвали “HospitalGown”. Вот краткая выдержка из отчета об этой уязвимости:
* Исследование было проведено на 2 705 987 приложениях. Было обнаружено, что 27 227 приложений для Android и 1 275 приложений для iOS используют базу данных Firebase;
* 9% приложений Android и почти половина приложений iOS (47%), применяющих БД Firebase, были уязвимы;
* Более 3 000 приложений хранили данные на примерно 2 300 незащищенных серверов;
* Каждая десятая БД Firebase (10,34%) была уязвима;
* Одни только уязвимые приложения для Android были загружены пользователями более 620 миллионов раз;
* Было раскрыто более 100 миллионов записей (113 гигабайт) данных.
Все это делает такой сервис лакомым кусочком для злоумышленника. А ведь автоматическая проверка на корректность настройки самой базы достаточно проста.
#### Сервисы Google
На данный момент, мы поддерживаем поиск и проверку токенов для 17 самых популярных сервисов Google (в скобках указана цена за количество запросов):
* Staticmap (`$2/1.000`)
* Streetview (`$7/1.000`)
* Directions (`$5/1.000`)
* Geocode (`$5/1.000`)
* Find Place From Text (`$17/1.000`)
* Autocomplete (`$2.83/1.000`)
* Elevation (`$5/1.000`)
* Timezone (`$5/1.000`)
* Nearest Roads (`$10/1.000`)
* Geolocation (`$5/1.000`)
* Route to Traveled (`$10/1.000`)
* Place Details (`$17/1.000`)
* Speed Limit-Roads (`$20/1.000`)
* Nearby Search-Places (`$32/1.000`)
* Text Search-Places (`$2.83/1.000`)
* Playable Locations (`$18/1.000`)
* Google Custom Search (`$5/1.000`)
Что может произойти, если мы, к примеру, храним в коде токен от сервиса “Nearby Search-Places“, каждая тысяча запросов к которому стоит для компании 32$? Злоумышленники, оценив ситуацию, могут написать простого бота, который в несколько потоков будет отправлять запросы с вашим токеном на этот сервис. В итоге, в конце месяца счет за услуги будет огромным. У Google оплата проводится постфактум, так что придется выложить очень много денег. Как вариант, злоумышленник может просто позаимствовать такой ключик для своего приложения, раз уж его оставили на видном месте. Конечно, многие компании заключают договор на безлимитное использование необходимых сервисов. Но это относится, скорее, к большим финансовым организациям, которые могут себе это позволить. Ну а более экономным может и не повезти.
Найденные ключи с автоматической валидациейКак показывает наша статистика, в достаточно большом количестве Android-приложений используются ключи такого типа от различных сервисов. Конечно, у Google есть процедура восстановления денежных средств при злоупотреблении ключами (то есть если счёт слишком большой, то можно попросить вернуть средства). Но наверняка все не так просто с возвратом (если кто-то может рассказать о реальных случаях, буду очень признателен).
#### FCM / GCM
Конечно, нельзя обойти вниманием [возможность отправки Push-сообщений](https://abss.me/posts/fcm-takeover/) **всем** пользователям, у которых было установлено приложение. Представьте: вдруг ваше приложение рассылает всем “молнию“ с предложением перейти к конкуренту. Не очень приятно, да? А ведь чтобы провернуть это, нужно всего лишь найти правильный ключ в исходном коде приложения и прочитать в документации, на какие API и в какой последовательности необходимо отправить запросы.
Именно из-за того, что это может иметь серьезные последствия для бизнеса, необходимо проверять добавляемые ключи и понимать, от каких они сервисов и какими привилегиями обладают.
Найденный ключ FCM с возможностью отправки PUSH сообщений#### Добавление собственных проверок
Используемые инструменты должны быть гибкими к особенностям продуктов. К примеру, в разрабатываемых мобильных приложениях в рамках одной экосистемы могут использоваться некоторые секретные внутренние токены. Также это будет полезно в случае, если выйдет горячая новость про компрометацию очередного сервиса или изменится формат ключей или способ проверки, - вам не нужно вручную ходить по всем репозиториям и проверять, нет ли у вас таких сервисов.
Один из вариантов проверки исходного кода предполагает использование инструмента [Detect-secrets](https://github.com/Yelp/detect-secrets) с реализацией собственного плагина. Для того, чтобы автоматически находить и валидировать внутренние токены в уже собранных приложениях и в данных, которые они используют при работе, мы сделали механизм `handle` для правил поиска чувствительных данных в приложении. После добавления проверки в выявленных уязвимостях можно будет увидеть значение токена, место, где он располагается, и результат проверки.
Пример добавленияПример `handle` для проверки токена и передачи в него минимального набора полей:
```
{
"name": "My custom token",
"url": "https://stingray-mobile.ru/authorize_zone/?key={key}",
"method": "get",
"unauthorized": "status_code>=400",
"status": "reason",
"price": "Unbelievable"
}
```
Здесь мы определяем, по какому URL проводить проверку, и какой код ошибки говорит нам, что запрос неуспешен. Конечно, существует возможность задать более сложный набор параметров, например, тело запроса, заголовки и т.д., но для понимания возможностей реализации вполне должно хватить этого небольшого примера.
Варианты хранения
-----------------
Для правильного и безопасного использования токенов и ключей от различных сторонних ресурсов есть несколько основных способов их хранения. Первый - это применение шифрования, что напрашивается само собой. Второй вариант - вообще не хранить такого рода токены на устройстве, а сделать промежуточный API на своем сервере, который будет обращаться к нужным сервисам и отдавать данные. В этом случае ключи хранятся не на устройстве, а на серверной стороне, где контроль над ними и вероятность их сохранности существенно выше. Но на такие меры стоит идти только в том случае, если ключи обладают слишком большим количеством привилегий, и это действительно необходимо. Ведь подобное решение потребует дополнительного времени на реализацию и тестирование. С другой стороны, усилия, направленные на контроль за передаваемыми данными и возможность их чем-то обогатить, вполне оправданы.
Так, к примеру, одна из организаций делала промежуточный “прокси“ API для различных сервисов аналитики для своего Web-сайта, чтобы не было гневных постов в соцсетях о том, что компания сливает данные пользователей, поскольку обращения идут не только на её домен. Да, был и такой случай, - пришлось долго и нудно объяснять, что это такое и зачем это нужно.
По первому способу с использованием шифрования возникает логичный вопрос: “Как ключи передавать и как хранить их на устройстве?” Основной нюанс заключается в необходимости максимально сократить время их нахождения в открытом виде на устройстве. Для этого (как один из вариантов) можно рассмотреть передачу ключей только при первом запуске приложения, а лучше при аутентификации (обязательно первой!) передавать их на клиента, где уже сразу шифровать, и потом правильно хранить. Таким образом, мы максимально сократим пребывание токенов в открытом виде. Они будут видны только при первой аутентификации и только в трафике мобильного приложения. Это, конечно, не идеальный вариант, но это точно лучше, чем хранить их в открытом виде.
### Хранение ключей в iOS
С хранением ключей в iOS все достаточно просто. Можно быть уверенным, что при запуске на устройстве с определенной версией iOS будет предоставлена возможность хранения в безопасном аппаратном хранилище ключей. Достаточно обратиться к механизму Security Enclave, сгенерировать там ключи, и зашифрованное значение положить положить в Keychain. В прошлых статьях мы уже говорили про использование Security Enclave в “сыром“ виде, а сегодня посмотрим, как можно применять интересную библиотеку [EllipticCurveKeyPair](https://github.com/agens-no/EllipticCurveKeyPair) (это небольшое изложение описанного в репозитории с некоторыми комментариями от меня):
Первое, что необходимо сделать это добавление зависимости в **Сocoapods**
```
pod EllipticCurveKeyPair
```
Или в **Carthage**
```
github "agens-no/EllipticCurveKeyPair"
```
Далее создадим экземпляр менеджера, который в дальнейшем будет управлять ключами и служить интерфейсом для всех операций:
```
struct KeyPair {
static let manager: EllipticCurveKeyPair.Manager = {
let publicAccessControl = EllipticCurveKeyPair.AccessControl(protection: kSecAttrAccessibleAlwaysThisDeviceOnly, flags: [])
let privateAccessControl = EllipticCurveKeyPair.AccessControl(protection: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly, flags: [.userPresence, .privateKeyUsage])
let config = EllipticCurveKeyPair.Config(
publicLabel: "payment.sign.public",
privateLabel: "payment.sign.private",
operationPrompt: "Confirm payment",
publicKeyAccessControl: publicAccessControl,
privateKeyAccessControl: privateAccessControl,
token: .secureEnclave)
return EllipticCurveKeyPair.Manager(config: config)
}()
}
```
Также можно использовать `KeyChain`, если по какой-то причине `Secure Enclave` недоступен:
```
let privateAccessControl = EllipticCurveKeyPair.AccessControl(protection: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly, flags: {
return EllipticCurveKeyPair.Device.hasSecureEnclave ? [.userPresence, .privateKeyUsage] : [.userPresence]
}())
```
Собственно, любые операции теперь можно совершать, используя `KeyPair.manager`.
**Шифрование**
```
do {
let digest = "some text to encrypt".data(using: .utf8)!
let encrypted = try KeyPair.manager.encrypt(digest, hash: .sha256)
} catch {
// handle error
}
```
Что интересно, можно шифровать данные на другом устройстве/ОС/платформе с помощью открытого ключа. Если вы хотите узнать все подробности о том, как шифровать в формате, который понимает `Secure Enclave`, то рекомендую ознакомиться [с этой статьей](https://darthnull.org/security/2018/05/31/secure-enclave-ecies/). Как вариант - можно дополнительно шифровать важные данные перед их отправкой на устройство.
**Расшифровка**
```
do {
let encrypted = ...
let decrypted = try KeyPair.manager.decrypt(encrypted, hash: .sha256)
let decryptedString = String(data: decrypted, encoding: .utf8)
} catch {
// handle error
}
```
**Подпись**
```
do {
let digest = "some text to sign".data(using: .utf8)!
let signature = try KeyPair.manager.sign(digest, hash: .sha256)
} catch {
// handle error
}
```
Кстати, с использованием подписи на закрытом ключе автор предлагает интересный кейс, практически аналог двухфакторной аутентификации или один из вариантов усиления/дополнения этого механизма:
1. Пользователь запрашивает соглашение, покупку или какую-либо операцию, которая требует его явного согласия;
2. Сервер отправляет push-уведомление с токеном, который должен быть подписан;
3. На устройстве подписываем токен при помощи закрытого ключа (что обязательно требует от пользователя подтверждения через FaceId/TouchId);
4. Подписанный токен отправляется на сервер;
5. Сервер при помощи открытого ключа проверяет подпись;
6. Если все прошло успешно, можно быть уверенным, что пользователь действительно подтвердил покупку/соглашение с использованием биометрии.
Достаточно удобная библиотека, которая большинство функций берет на себя и предоставляет неплохие возможности. Если планируете использовать Security Enclave, рекомендую более подробно с ней ознакомиться.
### Хранение ключей в Android
В случае с Android ситуация немного сложнее, чем с iOS, так как сегодня всё еще существует достаточно большая фрагментация различных версий и производителей Android.
Есть несколько основных способов хранения ключей в зависимости от версии операционной системы:
* На Android API<18 ключи шифрования должны храниться внутри директории приложения в BKS
* На Android API>=18 RSA ключи должны храниться в AndroidKeyStore, AES ключи в BKS
* На Android API>=23 RSA и AES ключи должны храниться в AndroidKeyStore
Не стоит забывать, что при использовании BKS во внутренней директории приложения необходимо дополнительно защищать его и хранящиеся в нем ключи с помощью надежного пароля. Как один из вариантов, сгенерированный пароль должен быть проверен в базе наиболее популярных паролей и должен соответствовать минимальным требованиям:
* Содержать не меньше 20 символов
* Содержать хотя бы одну прописную букву
* Содержать хотя бы одну строчную букву
* Содержать хотя бы одну цифру
* Содержать хотя бы один специальный символ
#### Пример генерации защищенного хранилища BKS с паролем и ключом, также защищенным паролем
```
$ keytool -importcert -v -trustcacerts -file "C:\Users\Indra\Documents\myapp.com.cer" -alias IntermediateCA -keystore "C:\Users\Indra\Documents\appKeyStore.bks" -provider org.bouncycastle.jce.provider.BouncyCastleProvider -providerpath "C:\Users\Indra\Downloads\bcprov-jdk15on-154.jar" -storetype BKS -storepass StorePass123
$ keytool -list -keystore "C:\Users\Indra\Documents\appKeyStore.bks" -provider org.bouncycastle.jce.provider.BouncyCastleProvider -providerpath "C:\Users\Indra\Downloads\bcprov-jdk15on-154.jar" -storetype BKS -storepass "StorePass123"
--------------------------------------------------------------------------------------------------------------------------------------------------------
$ openssl pkcs12 -export -in "/home/myapp/myapp_cert_2016/ssl_certificate.crt" -inkey "/home/myapp/myapp_cert_2016/domainname.key" -certfile "/home/myapp/myapp_cert_2016/ssl_certificate.crt" -out testkeystore.p12
Export password : exportpass123
$ keytool -importkeystore -srckeystore "C:\Users\Indra\myapp\testkeystore.p12" -srcstoretype pkcs12 -destkeystore ""C:\Users\Indra\myapp\wso2carbon.jks" -deststoretype JKS
Destination keystore password : exportpass123
----------------------------------------------------- Final JKS Keystore generation ------------------------------------------------------
$ openssl pkcs12 -export -in "/home/myapp/myapp_cert_2016/ssl_certificate.crt" -inkey "/home/myapp/myapp_cert_2016/domainname.key" -certfile "/home/myapp/myapp_cert_2016/ssl_certificate.crt" -out myapp_cert.p12
Export Password : StorePass123
$ keytool -importkeystore -srckeystore "C:\Users\Indra\myapp\myapp_cert.p12" -srcstoretype pkcs12 -destkeystore "C:\Users\Indra\myapp\myapp_keystore.jks" -deststoretype JKS
Import Password : StorePass123
----------------------------------------------------- Final BKS Keystore generation ------------------------------------------------------
$ keytool -importkeystore -srckeystore "C:\Users\Indra\myapp\myapp_keystore.jks -deststoretype JKS" -destkeystore "C:\Users\Indra\myapp\myapp_keystore.bks" -srcstoretype JKS -deststoretype BKS -srcstorepass StorePass123 -deststorepass StorePass123 -provider org.bouncycastle.jce.provider.BouncyCastleProvider -providerpath "C:\Users\Indra\Downloads\bcprov-jdk15on-154.jar"
On error or exception steps to be taken
- Comment above line and add the new line in java.security file in jre/lib/security
#security.provider.7=com.sun.security.sasl.Provider
security.provider.7=org.bouncycastle.jce.provider.BouncyCastleProvider
- You need to install the Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy
```
Для генерации и применения AndroidKeyStore можно использовать существующие вспомогательные библиотеки или самостоятельно реализовать генерацию и получение ключа. Приведенный ниже пример содержит основные фрагменты кода, которые могут потребоваться для реализации шифрования с хранением ключа в AndroidKeyStore. Не стоит относиться к этому коду, как к идеальному решению, скорее, он нужен в качестве отправной точки для дальнейшего развития.
**Добавление нового ключа в KeyStore**
```
public void createNewKeys(View view) {
String alias = aliasText.getText().toString();
try {
// Create new key if needed
if (!keyStore.containsAlias(alias)) {
Calendar start = Calendar.getInstance();
Calendar end = Calendar.getInstance();
end.add(Calendar.YEAR, 1);
KeyPairGeneratorSpec spec = new KeyPairGeneratorSpec.Builder(this)
.setAlias(alias)
.setSubject(new X500Principal("CN=Sample Name, O=Android Authority"))
.setSerialNumber(BigInteger.ONE)
.setStartDate(start.getTime())
.setEndDate(end.getTime())
.build();
KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA", "AndroidKeyStore");
generator.initialize(spec);
KeyPair keyPair = generator.generateKeyPair();
}
} catch (Exception e) {
Toast.makeText(this, "Exception " + e.getMessage() + " occured", Toast.LENGTH_LONG).show();
Log.e(TAG, Log.getStackTraceString(e));
}
refreshKeys();
}
```
**Удаление ключа из KeyStore**
```
public void deleteKey(final String alias) {
AlertDialog alertDialog =new AlertDialog.Builder(this)
.setTitle("Delete Key")
.setMessage("Do you want to delete the key \"" + alias + "\" from the keystore?")
.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
try {
keyStore.deleteEntry(alias);
refreshKeys();
} catch (KeyStoreException e) {
Toast.makeText(MainActivity.this,
"Exception " + e.getMessage() + " occured",
Toast.LENGTH_LONG).show();
Log.e(TAG, Log.getStackTraceString(e));
}
dialog.dismiss();
}
})
.setNegativeButton("No", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
}
})
.create();
alertDialog.show();
}
```
**Применение ключа для шифрования**
```
public void encryptString(String alias) {
try {
KeyStore.PrivateKeyEntry privateKeyEntry = (KeyStore.PrivateKeyEntry)keyStore.getEntry(alias, null);
RSAPublicKey publicKey = (RSAPublicKey) privateKeyEntry.getCertificate().getPublicKey();
// Encrypt the text
String initialText = startText.getText().toString();
if(initialText.isEmpty()) {
Toast.makeText(this, "Enter text in the 'Initial Text' widget", Toast.LENGTH_LONG).show();
return;
}
Cipher input = Cipher.getInstance("RSA/CBC/PKCS7Padding", "AndroidOpenSSL");
input.init(Cipher.ENCRYPT_MODE, publicKey);
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
CipherOutputStream cipherOutputStream = new CipherOutputStream(
outputStream, input);
cipherOutputStream.write(initialText.getBytes("UTF-8"));
cipherOutputStream.close();
byte [] vals = outputStream.toByteArray();
encryptedText.setText(Base64.encodeToString(vals, Base64.DEFAULT));
} catch (Exception e) {
Toast.makeText(this, "Exception " + e.getMessage() + " occured", Toast.LENGTH_LONG).show();
Log.e(TAG, Log.getStackTraceString(e));
}
}
```
**Применение ключа для расшифровки**
```
public void decryptString(String alias) {
try {
KeyStore.PrivateKeyEntry privateKeyEntry = (KeyStore.PrivateKeyEntry)keyStore.getEntry(alias, null);
RSAPrivateKey privateKey = (RSAPrivateKey) privateKeyEntry.getPrivateKey();
Cipher output = Cipher.getInstance("RSA/CBC/PKCS7Padding", "AndroidOpenSSL");
output.init(Cipher.DECRYPT_MODE, privateKey);
String cipherText = encryptedText.getText().toString();
CipherInputStream cipherInputStream = new CipherInputStream(
new ByteArrayInputStream(Base64.decode(cipherText, Base64.DEFAULT)), output);
ArrayList values = new ArrayList<>();
int nextByte;
while ((nextByte = cipherInputStream.read()) != -1) {
values.add((byte)nextByte);
}
byte[] bytes = new byte[values.size()];
for(int i = 0; i < bytes.length; i++) {
bytes[i] = values.get(i).byteValue();
}
String finalText = new String(bytes, 0, bytes.length, "UTF-8");
decryptedText.setText(finalText);
} catch (Exception e) {
Toast.makeText(this, "Exception " + e.getMessage() + " occured", Toast.LENGTH\_LONG).show();
Log.e(TAG, Log.getStackTraceString(e));
}
}
```
Заключение
----------
Подводя итоги, хотелось бы еще раз обратить внимание на несколько важных моментов. Относитесь очень аккуратно и внимательно к интеграциям, которые есть в вашем мобильном приложении. А главным образом к тому, как хранятся токены от сторонних сервисов и с какими правами эти токены созданы. Необходимо составить и поддерживать в актуальном состоянии полный перечень интеграций, используемых токенов и их прав. Кроме того, нужно регулярно проверять валидность/корректность токенов и то, чтобы к ним каким-то образом не были добавлены новые роли и права.
К сожалению, процессы ИБ и разработки нередко бывают разрозненны. Из-за этого добавление новых интеграций может пройти мимо первоначального анализа на безопасность, и узнать об этом можно только постфактум, когда может быть уже слишком поздно.
Автоматизация этого процесса способна сэкономить огромное количество времени, ресурсов и сил как разработчикам, так и аналитикам по безопасности. Она поможет быть уверенными в том, что в вашем приложении не содержится информации, утечка которой может повлиять как на финансовую составляющую, так и на репутацию всей компании.
Ссылки
------
1. [Unsecured Firebase Databases](https://library.cyentia.com/report/report_001147.html)
2. [Android KeyStore - Kotlin](https://developer.android.com/training/articles/keystore#kotlin)
3. [How to use the Android Keystore to store passwords](https://www.androidauthority.com/use-android-keystore-store-passwords-sensitive-information-623779/)
4. [Android Developer - Cryptography](https://developer.android.com/guide/topics/security/cryptography)
5. [Android Developer - EncryptedFile](https://developer.android.com/reference/androidx/security/crypto/EncryptedFile)
6. [Does the use of a smartphone's Secure Element really offer security benefits](https://security.stackexchange.com/questions/128003/does-the-use-of-a-smartphones-secure-element-really-offer-security-benefits-to)
7. [Qlassified Android Library](https://github.com/Q42/Qlassified-Android)
8. [detect-secrets](https://github.com/Yelp/detect-secrets)
9. [detect-secrets - Verified-Secrets](https://github.com/Yelp/detect-secrets/blob/master/docs/plugins.md#Verified-Secrets)
10. [keyhacks](https://github.com/streaak/keyhacks)
11. [RegHex](https://github.com/l4yton/RegHex) | https://habr.com/ru/post/663358/ | null | ru | null |
# Будущее Prometheus и экосистемы проекта (2020)
***Прим. перев.**: это перевод статьи, подготовленной по мотивам недавнего выступления Richard Hartmann — заметного представителя команды разработчиков Prometheus, директора по сообществам из Grafana Labs, основателя проекта OpenMetrics и председателя группы SIG Observability в CNCF. Автор подводит итоги последнего года в жизни Open Source-проекта (и сообщества) Prometheus, а также рассказывает об основных трудностях и ближайших перспективах.*
Во время [PromCon Online 2020](https://promcon.io/2020-online/) я выступил с докладом под названием «Будущее Prometheus и его экосистемы». И хочу поделиться с вами его ключевыми моментами.
Резюме
------
Со времени прошлой конференции PromCon — 2019 — в Prometheus произошло множество изменений.
### 2.14
В версии [2.14](https://github.com/prometheus/prometheus/releases/tag/v2.14.0) появился новый интерфейс на React. Хотя по функциональности он пока отстает от старого, мы над ним работаем и продолжаем улучшать.
### 2.15
Версия [2.15](https://github.com/prometheus/prometheus/releases/tag/v2.15.0) прошла под знаком API метаданных. [Формат экспозиции](https://prometheus.io/docs/instrumenting/exposition_formats/) Prometheus уже давно поддерживает специальные выражения `HELP`, `TYPE` и т.п., однако сам Prometheus раньше просто отбрасывал эти данные. Теперь, когда они остаются, можно открыть внешний доступ к ним через API. Например, Grafana уже пользуется этой возможностью и предоставляет пользователям дополнительную информацию о временных рядах, с которыми те работают:
### 2.16
В версии [2.16](https://github.com/prometheus/prometheus/releases/tag/v2.16.0) основное внимание было уделено различным улучшениям и стабильности. Например, пользователи еще с 2016 года просили о возможности выбора локального времени в UI, а также о реализации журнала запросов — было приятно закрыть эти проблемы.
### 2.17
К слову о затянувшихся запросах на фичи: версия [2.17](https://github.com/prometheus/prometheus/releases/tag/v2.17.0), наконец, дала долгожданную «I» в [ACID для БД](https://ru.wikipedia.org/wiki/ACID): [изолированность](https://ru.wikipedia.org/wiki/%D0%A3%D1%80%D0%BE%D0%B2%D0%B5%D0%BD%D1%8C_%D0%B8%D0%B7%D0%BE%D0%BB%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8_%D1%82%D1%80%D0%B0%D0%BD%D0%B7%D0%B0%D0%BA%D1%86%D0%B8%D0%B9).
### 2.18
В [2.18](https://github.com/prometheus/prometheus/releases/tag/v2.18.0) были улучшены трассировка и поддержка экземпляров в формате экспозиции. Экземпляры — это первый заметный для пользователя эффект от внедрения [OpenMetrics](https://openmetrics.io/) в Prometheus. Объединив их с Grafana, можно достичь удобной детализации, позволяющей переходить от:
… к:
### 2.19
В [2.19](https://github.com/prometheus/prometheus/releases/tag/v2.19.0) сократили потребление памяти на целых 50%! Даже несмотря на то, что Prometheus уже весьма эффективна, остается значительный потенциал для оптимизации — это одновременно и воодушевляет, и пугает.
Такой график — прекрасная тому иллюстрация:
### 2.20
Версия [2.20](https://github.com/prometheus/prometheus/releases/tag/v2.20.0) может похвастаться самым длинным списком изменений с момента выхода v2.6(!). Главным, вероятно, является родная поддержка обнаружения сервисов для Docker Swarm и DigitalOcean.
Но есть и более важное изменение, превосходящее по значимости реализацию двух независимых механизмов обнаружения сервисов: мы «разбираем» Prometheus по частям и по-новому смотрим на многие старые решения и устоявшиеся подходы. Мир изменился (возможно, к этому и мы приложили руку) — это необходимо учитывать как в самом проекте, так и в других.
### node\_exporter
Подводя итог, хочу заметить, что [node\_exporter](https://github.com/prometheus/node_exporter) достиг версии 1.0 и теперь включает в себя ЭКСПЕРИМЕНТАЛЬНУЮ поддержку TLS. Фонд Cloud Native Computing Foundation проспонсировал аудит node\_exporter'а компанией Cure53 (он охватывал как экспортер в целом, так и нашу реализацию TLS в частности). И он того стоил вдвойне: мы не только проверили TLS перед тем, как копировать его в другие экспортеры, но и использовали node\_exporter как подопытного кролика, с которого копируются и иные паттерны.
Будущее
-------
Иногда у меня возникает ощущение, что мы как проект почиваем на лаврах. Некоторое время назад я запустил мозговой штурм внутри Grafana под девизом «Prometheus'у не хватает функций» и призвал Red Hat поступить так же. Попутно мы создали доступный для всей команды Prometheus документ сразу обо ВСЕМ. Он служит основой для рассмотрения конкретных тем, разбитых на пункты для обсуждения во время dev-саммитов (по мере готовности этих пунктов).
### Саммиты разработчиков
В прошлом году у нас было два dev-саммита: один — после KubeCon EU, второй — после PromCon. Планировалось то же самое сделать в 2020 году, но помешал COVID. В этом году пока саммитов не было, но я полагаю, что мы нашли выход: более короткие, частые и виртуальные встречи. Мы проводим блоки по 4 часа вместо того, чтобы собираться сразу на 1-2 дня. Первый такой dev-саммит прошел 10 июля, а следующий, вероятно, состоится 7 августа. Мы продолжим проводить их, пока не разберем все накопившиеся вопросы (хотя их число постоянно растет по мере того, как добавляются все новые пункты из вышеупомянутого документа).
Сейчас я хочу сделать две вещи:
1. Ознакомить вас с тем, о чем нам удалось договориться. Не думаю, что будет полезно или справедливо рассказывать о том, над чем мы пока еще активно думаем. При этом я буду поднимать темы в таком же порядке, в котором мы их обсуждали. Этот порядок определяется общим голосованием — темы, набравшие наибольшее число голосов, обсуждаются в первую очередь.
2. Немного рассказать о том, как именно проходят эти встречи и о некоторых соображениях, лежащих в их основе. Хотя я, вероятно, скоро еще напишу пару заметок о ведении этих рабочих сессий.
### Метаданные
Метаданные начинают приносить реальную пользу в Prometheus (см. 2.15 выше). Нам нужно реализовать больше возможностей для работы с метаданными (например, распространять их через удаленное чтение/запись). Консенсус ниже не охватывает такие интересные вопросы, как «Что делать, если метаданные изменились/пропали?» или «Что делать, если они станут вектором атаки?».
> КОНСЕНСУС: Мы хотим лучше поддерживать метаданные. Работа будет вестись в [специальном документе](https://docs.google.com/document/d/1XiZePSjwU4X5iaIgCIvLzljJzl8lRAdvputuborUcaQ/edit).
>
>
>
> КОНСЕНСУС: [PR 6815](https://github.com/prometheus/prometheus/pull/6815) пойдет в качестве ЭКСПЕРИМЕНТАЛЬНОГО временного решения. Скорее всего, оно будет другим в версиях 3.х.
### Изменения в рабочем процессе и s/master/main/
Тема разгребания мусора, скопившегося в рабочих процессах, не требует особого пояснения, однако следует сказать несколько слов об устранении словоблудия (единстве терминологии). Мы серьезно настроены на очистку терминологии: это не самое важное, но то, чем мы можем заняться уже сейчас. Пока мы ждем соответствующего инструментария от GitHub. Как только он появится, попробуем привлечь к этой работе платного стажера через Community Bridge.
Я веду переговоры с Linux Foundation и CNCF о том, чтобы потенциально реализовать это во всех проектах. Отличная возможность для того, кто интересуется данной тематикой: возможность изучить множество проектов, поработать с различными инструментами, познакомиться со многими людьми. Свяжитесь со мной в Twitter ([@TwitchiH](https://twitter.com/TwitchiH)) или по почте (*richih* на сервере grafana.com), если вам это интересно.
> КОНСЕНСУС: Установить «Требовать прохождения проверок статусов перед merge'ем» во всех репозиториях prometheus/… Не допускать прямые push'и в main branch? Не допускать force push'и в main branch?
>
>
>
> КОНСЕНСУС: Отключить force push'и во все main branches.
>
>
>
> КОНСЕНСУС: Поведение по умолчанию разрешает push'и в main branch, однако его следует отключить для некоторых «важных» репозиториев, например, prometheus/prometheus (на усмотрение maintainer'а).
### Заполнение данными (backfilling)
Это один из самых давнишних запросов на фичи и хороший пример того, как следует подходить к консенсусу. В команде Prometheus циркулирует множество разных мнений по этому поводу, и сложно прийти к общему знаменателю. Поэтому я написал ограниченное и весьма конкретное консенсус-предложение с тремя критериями: «Мы хотим поддерживать backfilling *по сети* хотя бы *блоками*, которые *не пересекаются с головным блоком*».
После продолжительных обсуждений и попыток прийти к консенсусу стало ясно, что сделать это так просто не получится. Поэтому я переформулировал предложение следующим образом: «Мы хотим поддерживать backfilling *по сети* хотя бы *потоками*, которые *не пересекаются с head block*».
Только заставив каждого высказать свое определенное мнение по этому поводу, мы смогли прийти к окончательному варианту: «Мы хотели бы поддерживать backfilling *по сети* *блоками*, которые *не пересекаются с head block при условии надлежащей реализации*». Каждое слово здесь подобрано, чтобы отражать точную степень и границы консенсуса.
> КОНСЕНСУС: Мы хотим поддерживать текстовый формат экспозиции Prometheus и OpenMetrics, и один четко определенный CSV-формат для импорта данных.
>
>
>
> КОНСЕНСУС: Мы хотим поддерживать backfilling по сети хотя бы блоками, которые не пересекаются с головным.
>
>
>
> НЕ КОНСЕНСУС: Мы хотим поддерживать backfilling по сети хотя бы потоками, которые не пересекаются с головным блоком.
>
>
>
> КОНСЕНСУС: Мы хотели бы поддерживать backfilling по сети блоками, которые не пересекаются с головным блоком при условии надлежащей реализации.
### Вендоринг
Еще одна из задач, связанных с наведением порядка. Здесь я хочу покритиковать Go: он был разработан в мире, в котором единый монореп — это норма. Google хранит весь (или основную часть) своего общего кода в единственном репозитории. Этот подход имеет много преимуществ, но плохо переносится на реальные условия. Go медленно, но верно уходит от этого наследия.
Занимательный факт: я написал консенсус-предложение практически в самом начале обсуждения. Было понятно, что мы как минимум его попробуем. Было понятно, что Ben Kochie вызовется сделать это. И было понятно, что «жертвой» станет node\_exporter. Как правило, мы стремимся совершенствовать рабочий процесс, и волонтером всегда выступает Ben, а node\_exporter является тем тестовым стендом, с которого мы потом копируем результаты в другие экспортеры. И да, было важно, чтобы обсуждение продолжалось некоторое время и чтобы люди сами пришли к этому, вместо того, чтобы ставить их перед фактом.
> КОНСЕНСУС: Удалить его в node\_exporter и посмотреть, довольны ли мы будем результатом.
### Списки рассылки и IRC
Google заблокирован в Китае, однако наши списки рассылки работают на нем. Мы решили попробовать сделать так, чтобы можно было подписываться по электронной почте. Я проверил: [[email protected]](mailto:[email protected]) работает. Также можно почитать архивы (<https://www.mail-archive.com/[email protected]/maillist.html>), если есть такое желание.
Кроме того, мы позаботились о том, чтобы все желающие могли использовать IRC через Matrix, поскольку для некоторых [xkcd 1782](https://xkcd.com/1782/) весьма актуален.
> КОНСЕНСУС:
>
>
>
> Посмотреть, возможно ли подписываться на наши списки рассылок без учетки Google и подключить этот функционал; для публикации по-прежнему требуется подписка.
>
>
>
> Добавить ссылку на общедоступный архив списков рассылок в разделе docs/community и рассказать, как можно подписаться на рассылки без учетной записи Google.
>
>
>
> Отключить требования идентификации в каналах IRC, чтобы упростить использование Matrix; вернуть все назад, если будут атаки.
### Документация
Позвольте повторить слова, сказанные на саммите: «Самое первое, что мне не понравилось в Prometheus в 2015, году — это документация; в 2020-м я ее просто ненавижу. Она сложна в использовании и почти бесполезна, подходит только тем, кто уже знает, что делает, или по крайней мере хорошо представляет себе концепции». Короче говоря, мы будем работать в этом направлении:
> КОНСЕНСУС:
>
>
>
> Мы разделим документацию на три части:
>
>
>
> \* Руководство пользователя *(user manual)* как простой для понимания вариант по умолчанию.
>
> \* Справка *(reference)* по аналогии с той, что у нас сейчас есть с примерами на PromQL для ввода/вывода.
>
> \* Гайды *(guides)*, желательно на модульной основе.
>
>
>
> Мы попросим Diana Payton разработать единый стиль оформления, общую концепцию и т.п. для всей документации.
>
>
>
> Мы постараемся не ломать ссылки понапрасну.
Если вам это интересно, в настоящее время мы [ищем технического писателя в Grafana Cloud](https://apply.workable.com/grafana-labs/j/0DF1338E28), который будет работать над официальной upstream-документацией для Prometheus. В конце концов, мы серьезно относимся к своим обязательствам перед сообществом.
Как обычно, записи по итогам dev-саммита будут опубликованы. Также можно почитать [итоги саммита 2020-1](https://docs.google.com/document/d/1yuaPKLDvhJNXMF1ubsOOm5kE2_6dvCxHowBQIDs0KdU/) и [саммитов прошлых лет](https://prometheus.io/community/).
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «[Мониторинг и Kubernetes](https://habr.com/ru/company/flant/blog/412901/)» (обзор и видео доклада);
* «[Устройство и механизм работы Prometheus Operator в Kubernetes](https://habr.com/ru/company/flant/blog/412901/)»;
* «[Представляем k8s-image-availability-exporter для обнаружения пропавших образов в Kubernetes](https://habr.com/ru/company/flant/blog/495358/)». | https://habr.com/ru/post/513574/ | null | ru | null |
# Глобалы MUMPS: Экстремальное программирование баз данных. Часть 1
> **Примечание переводчика.**
>
>
>
> Есть интересная технология в мире БД — [MUMPS](http://ru.wikipedia.org/wiki/MUMPS). Этот язык программирования и доступа к данным известен уже несколько десятилетий, отлажен и является взрослой проверенной технологией.
>
>
>
> Приведу аналогию: если SQL можно сравнить с Бейсиком, то MUMPS больше похож на Си — даёт высочайшую производительность, гибкость и универсальность, позволяя создавать наисложнейшие структуры данных.
>
>
>
> Перед вами перевод первой части статьи «Extreme Database programming with MUMPS Globals». Если сообществу он покажется интересным, то последует перевод второй части.
#### Глава 1. Глобалы: альтернатива реляционному подходу
Истинное сердце технологии MUMPS — механизм хранения данных. Он основан на том, что называется глобальными переменными, или (более популярное название) глобалами (Globals). Глобалы — невероятно простая концепция, однако, при этом невероятно мощная.
Многие люди не приемлют глобалы. Это примитивные структуры. В них нет элементов управления, систем подстраховки или расширенного функционала, предоставляемого «приличными» базами данных. В результате, MUMPS часто списывают со счетов как бесполезную, недостаточную, или, вообще, неправильную систему. Если вы тоже так делаете — вы игнорируете простой, удобный и очень гибкий механизм хранения данных. В умелых руках отсутствие лишнего багажа и нетребовательность к ресурсам дают невероятное ощущение свободы. В неумелых руках все то же самое может привести к катастрофе. Это немного напоминает экстремальный вид спорта, например, свободное скалолазание. Немногие «настоящие» спортсмены будут рекомендовать его — потому что это самый быстрый, эффективный и увлекательный способ взобраться вон на ту гору, если вы справитесь со скалолазанием без страховки. Однако, компании — производители альпинистского оборудования ни за что не порекомендуют этот спорт, поскольку это значит снизить спрос на свою собственную продукцию!
Так что если вы принимаете вызов и готовы признать, что есть другие способы организовать хранилище данных кроме набившего оскомину реляционного и SQL подхода, давайте копать вглубь.
Это первая глава, в которой раскрываются основы глобалов. Вторая глава концентрируется на их применении в терминах, понятных программисту RDBMS/SQL. Если хотите, вы можете перейти сразу ко второй главе и вернуться к этому тексту позже, чтобы ознакомиться с основами.
Все системы MUMPS и их современные модификации, например, Caché, используют глобалы в качестве основы механизма хранения. Многие современные системы MUMPS и/или расширения предлагают более «привычный» взгляд на ключевые конструкции глобалов. Например, на глобалах можно создать представления (view) которые будут работать как объектная, реляционная или XML база данных. Более того, в теории та же самая физическая база данных на основе глобалов может быть логически представлена и использоваться в одной из этих форм (и даже во всех сразу). В итоге, появилось множество разработчиков, которые не в курсе, что в основе инструментов лежат глобалы. Они не знают, что это такое, как работает и как используется. Этот текст поможет вам узнать этот тайный и, мы надеемся, что вы согласитесь, очень увлекательный мир.
**Так что же такое глобалы?**
Вкратце, глобал — это постоянный, разреженный, динамический, многомерный массив, содержащий текстовые значения. MUMPS разрешает использовать как сохраняемые на диске (persistent), так и содержащиеся только в RAM многомерные массивы, известные как «локальные массивы».
В отличие от многих систем, MUMPS позволяет использовать одновременно буквенные и числовые индексы. Так что в MUMPS вы можете работать с подобным массивом:
```
Employee(company,country,office,employeeNumber) = employeeDetails
```
и отдельной записью:
```
Employee(“MGW”,”UK”,”London”,1) = “Rob Tweed`Director`020 8404 3054”
```
В этом примере элементы данных, из которых состоит информация о сотруднике (имя, должность, номер телефона), прикрепляются друг к другу в сочетании с символом обратного апострофа в качестве разделителя. MUMPS никак не управляет и не контролирует то, как вы организуете свои структуры: нет никакой схемы или словаря данных, описывающего ваши записи. Это предоставляет невероятную гибкость и ускоряет разработку. Вы можете произвольно назначить один или более разделителей данных, которые будут разбивать текстовое значение записи массива на любое количество «полей». Максимальная общая длина одной записи массива зависит от имплементации MUMPS, однако в Caché она составляет до 32k. Длина строки является переменной, и, как вы понимаете, исходя из наличия символа-разделителя, длина отдельных полей — тоже переменная. Это делает глобалы MUMPS очень эффективным механизмом хранения данных (в отличие от таблиц): в файлах MUMPS на диске практически нет места, которое бы хранило пустые, неиспользуемые пространства.
В примере выше запись сотрудника содержится в том, что называется «локальным массивом». Если бы вы вышли из сессии MUMPS, массив бы исчез, так же, как массив PHP после исчезновения страницы или сессии.
А теперь начнем веселье! Чтобы хранить запись сотрудника на диске постоянно, то есть, в виде глобала, просто добавьте "^" перед именем массива:
```
^Employee(company,country,office,employeeNumber) = employeeDetails
```
пример:
```
^Employee(“MGW”,”UK”,”London”,1) = “Rob Tweed`Director`020 8404 3054” Вот и все!
```
Чтобы создать такой элемент в глобале, вам нужно использовать команду MUMPS «set»:
```
set ^Employee(“MGW”,”UK”,”London”,1) = “Rob Tweed`Director`020 8404 3054”
```
Больше всего в MUMPS людей путает и пугает то, что основная часть команд может сокращаться до одной буквы (строчной или прописной), так что часто вы можете увидеть вместо команды, записанной выше, следующее:
```
s ^Employee(“MGW”,”UK”,”London”,1) = “Rob Tweed`Director`020 8404 3054”
```
Теперь, когда вы выйдете из MUMPS, запись не исчезнет, а останется на диске. Когда бы вы ни вернулись, вы можете считать запись с диска через глобал с индексами:
```
^Employee(“MGW”,”UK”,”London”,1)
```
Чтобы извлечь значение из глобала и присвоить его переменной обычно используют команду “set”, например:
```
Set companyRecord= ^Employee(“MGW”,”UK”,”London”,1)
```
Переменная companyRecord теперь содержит строковое значение: “Rob Tweed`Director`020 8404 3054”
Глобалы могут содержать столько индексов, сколько вы захотите, а эти индексы могут быть любым сочетанием текста и чисел (real или integer). Строковые индексы должны окружаться двойными кавычками, а численные — нет.
Большинство реализаци MUMPS по факту имеют предел общей длины индекса, так что совсем выйти за границы вам не удастся. Однако, вы убедитесь, что места хватит для любых ваших требований.
Чтобы удалить запись из глобала, вы можете использовать команду “kill”:
```
Kill ^Employee(“MGW”,”UK”,”London”,1)
```
Собственно, это все о глобалах. Настоящая сложность состоит в том, чтобы заставить такую примитивную структуру данных работать на вас. Это мы будем описывать во всем оставшемся документе. Мы попытаемся сделать это так, чтобы SQL-программист реляционных баз данных мог понять аналогичные техники и представления, которые использовал бы MUMPS-программист.
Запомните, что ничто в MUMPS не поддерживает какую-либо методологию дизайна баз данных. Вы можете добавлять инструменты контроля и проверки, которые будут следить за логикой, единообразием и отсутствием ошибок в вашей базе. Это означает, что вы будете выполнять ту работу, которую за вас выполнили бы привычные СУБД. Однако, вы быстро поймете, что можно автоматизировать наиболее часто повторяющиеся задачи и легко управлять базой данных на основе MUMPS
**Создание простой многоуровневой структуры**
Вы можете использовать несколько размерностей в одном и том же глобале одновременно, например:
```
^Employee(“MGW”,”UK”,”London”) = 2
^Employee(“MGW”,”UK”,”London”,1) = “Rob Tweed`Director`020 8404 3054”
^Employee(“MGW”,”UK”,”London”,2) = “Chris Munt`Director`01737 371457”
```
Используя 3 индеса мы указываем число работников в определенном офисе, а четыре — запись конкретного работника.
Ссылки между разными глобалами должен указывать программист. MUMPS, «из коробки», не предоставляет автоматическую индексацию и не устанавливает перекрестные ссылки.
Для того, чтобы сделать быструю выборку по номеру телефона мы создадим глобал ^EmployeeTelephone, где индексами будут телефонные номера, а значениями индексы глобала ^Employee, указывающими на запись сотрудника:
```
^EmployeeTelephone(“020 8404 3054) = “MGW`UK`London`1”
^EmployeeTelephone(“01737 371457”) = “MGW`UK`London`2”
```
В этом примере значение, хранящееся в каждом номере телефона, содержит также связующий индекс, указывающий на соответствующую запись сотрудника. Если вы знаете номер телефона, то все, что вам нужно, — разъединить данные с помощью обратного апострофа (разделителя) и извлечь основную запись сотрудника.
Пример:
```
S telNo=”020 8404 3054”
S indexData=^EmployeeTelephone(telNo) S company=$piece(indexData,”`”,1)
S country=$piece(indexData,”`”,2) S office=$piece(indexData,”`”,3)
S employeeNo=$piece(indexData,”`”,4)
S record=^Employee(company,country,office,employeeNo) S employee=$piece(record,”`”,1)
```
Обратите внимание на использование $piece — функции MUMPS для разделения значения на поля.
Одно из великих свойств MUMPS — вам не нужно ничего объявлять заранее. В SQL-мире изменение структуры данных требует изменения структуры таблиц (ALTER TABLE и т.п.). В MUMPS вы решаете, когда и как создать, изменить и удалять записи в глобале — все это автоматически и динамически контролируется только вами. Вы можете добавить дополнительные индексы и «поля» (pieces) в свои глобалы в любой момент безо всяких объявлений или чего-то подобного. Если вы хотите начать использовать другой глобал, просто начните это делать и он будет создан для вас динамически.
**Создание, считывание и удаление записи в глобале**
Вкратце, в MUMPS записи в глобалах создаются и извлекаются командой “Set”, и удаляются командой “Kill”.
1. Создание записи в глобале:
```
Set ^Employee(“MGW”,”UK”,”London”,1)=“Rob Tweed`Director`020 8404 3054”
```
Этот код создает индекс в глобале и сохраняет запись на диск.
2. Считывание записи из глобала
```
Set data=^Employee(“MGW”,”UK”,”London”,1)
```
Этот код извлекает элемент из глобала и помещает значение в локальную переменную с названием “data”.
3. Удаление записи из глобала:
```
kill ^Employee(“MGW”,”UK”,”London”,1)
```
Этот код удаляет указанную запись глобала с диска немедленно и навсегда. Осторожнее с командой Kill- ее невероятно легко и невероятно опасно использовать. Если вы укажете меньше индексов, чем есть в глобале — вы удалите все элементы индексируемые большим числом индексов. Если вы не укажете индекс вообще — вы удалите всю глобаль, пример:
```
Kill ^Employee(“MGW”,”UK”)
```
Эта строка удалит все записи всех офисов в Англии
```
Kill ^Employee
```
А эта команда удалит весь глобал ^Employee — сразу, навсегда и безвозвратно (если вы не сделали ее бекап).
**Обход глобала**
Одна из наиболее часто используемых функций — обход нескольких или всех глобалов. Допустим, вам нужно взять все записи сотрудников, чтобы отобразить список, из которого пользователь сможет выбрать одну запись, или сосчитать их. Для этого вам нужно использовать функцию MUMPS $order. Функция $order — это одна из жемчужин MUMPS, позволяющая манипулировать любыми данными, хранящимися в глобалах, с невероятной простотой.
Этот функционал не будет интуитивно понятен программисту «традиционных» баз данных, но его стоит понять, поскольку он одновременно очень мощен и прост.
Функция $order работает на одном уровне индексации внутри глобала и возвращает значение следующего индекса в выборке, которое существует на этом уровне глобала. Вы можете указать начальное значение, и функция $order найдет следующее значение, которое находится в выбранной последовательности. Чтобы найти первый индекс на указанном уровне, используйте пустое начальное значение (“”). Чтобы найти первый индекс на указанном уровне, который начинается на “C”, используйте начальное значение, которое идет по порядку сразу перед “C”, например, “B~”.
Так, чтобы найти первого сотрудника в глобале:
```
S company=””
S company=$order(^Employee(company))
```
Переменная company теперь содержит значение первого индекса company в первой записи глобала ^Employee.
Когда найдено последнее значение, при следующем запуске функции $order вернет пустое значение. Так, если бы в нашем глобале была только одна компания и мы повторили $order:
```
S company=$order(^Employee(company))
```
Тогда переменная company содержала бы пустое значение (“”)
Чтобы получить и обработать все компании в глобале Employee, нужно создать цикл:
```
S company=””
For s company=$order(^Employee(company)) quit:company=”” do
. ; сделать что-нибудь с company
```
Этот код демонстрирует интересные функции лаконичного кодирования MUMPS:
* Команда For с двумя последующими пробелами устанавливает бесконечную петлю.
* Quit:company=”” указывает условие выхода из цикла и использует конструкцию, известную как «пост-условие». Эта конструкция говорит «если значение компании пустое, выйти из цикла For». За Quit должно идти два пробела, если после команды идет любая другая команда.
* “do” в конце строки означает выполнить код, который идет на следующем уровне «точки». “do” будет выполняться на каждой итерации цикла For, пока значение компании не пустое
* Код, который нужно выполнять в каждом цикле, пишется после одиночной точки. В принципе, любая строка, начинающаяся с точки, формирует подпрограмму, которая выполняется командой “do” в конце второй строки в примере.
Так, мы задаем $order пустое значение, чтобы убедиться, что команда начнет с поиска первого индекса, хранящегося в глобале. Мы проходим через каждое значение, пока не закончатся сохраненные данные и получаем пустое значение, возвращенное $order, после чего мы завершаем цикл.
Вы обнаружите, что такой тип цикла — одна из самых распространенных вещей в программе MUMPS.
Мы можем расширить этот запрос и обработать весь глобал сразу. Для этого мы запускаем цикл на каждом уровне индекса, начиная с первого и перемещаясь к каждому последующему:
```
s company=””
for s company=$order(^Employee(company)) quit:company=”” do
. s country=””
. for s country=$order(^Employee(company,country)) quit:country=”” do
. . s office=””
. . for s office=$order(^Employee(company,country,office)) quit:office=”” do
. . . s employeeNo=””
. . . for s employeeNo=$order(^Employee(company,country,office,employeeNo)) quit:employeeNo=”” do
. . . . s record=^Employee(company,country,office,employeeNo)
. . . . ; сделать что-нибудь с записью
```
Обратите внимание на то, каким образом мы обозначили уровни «точек», чтобы создать иерархию вложенных подпрограмм. Также, обратите внимание на то, как $order используется для того, чтобы обойти значения всех 4-х индексов глобала.
> **Прим. переводчика**: в Caché для вложенных структур можно использовать фигурные скобки.
Если бы нам было нужно найти и обработать только записи работников компаний, начинающихся на “C”, тогда мы используем следующую популярную конструкцию:
```
s company=”B~”
f s company=$o(^Employee(company)) quit:$e(company,1) ’= ”C” do
. ; сделать что-нибудь с записью
```
Обратите внимание на функцию $extract (или $e). Она извлекает символ из указанной позиции значения строки: в данном случае первую букву названия компании. Также заметьте способ указания «не равно C»: он использует оператор MUMPS NOT, который записывается одиночной кавычкой (‘).
Этот цикл можно прочесть так:
* Начальное значение $order — величина перед “C” в последовательной выборке
* Запустить бесконечный цикл для поиска всех записей компаний в выборке
* Если первая буква названия компании не “C”, выйти из цикла
* В противном случае продолжить обрабатывать записи компаний.
Эта возможность начинать и прекращать обход глобала с любого конкретного индекса и на любом уровне вложенности индексов является уникальной функцией глобалов MUMPS.
**Проверка существования записи в глобале**
Вам часто нужно знать, существует ли конкретная запись в глобале. Для этого вы можете использовать функцию MUMPS $data:
```
if $data(^Employee(company)) do xxx
```
Строка читается как «если ^Employee(company) существует, тогда выполнить подпрограмму xxx». Функцию $data можно сокращать до $d.
$data вернет несколько разных значений.
* Если данные существуют на указанном уровне индекса и нет подузлов, вернется значение 1
* Если данные существуют на указанном уровне индекса и подузлы есть, вернется значение 11
* Если данных не существует на указанном уровне индекса, но есть подузлы, вернется значение 10
* Если данных не существует на указанном уровне индекса, вернется значение 0.
В MUMPS любое ненулевое значение при использовании логического оператора if оценивается как true. Таким образом, первые три значения, возвращенные $data (1, 10 и 11), будут считаться true. Последняя ситуация (нет данных и подузлов) оценивается как false.
В качестве примера рассмотрим следующий глобал:
```
^test=3
^test(“a”)=1
^test(“a”,”b”,”c”)=2
^test(“a”,”b”,”d”)=3
$data(^test) = 11
$data(^test(“a”,”b”)=10
$data(^test(“a”,”b”,”c”)=1
$data(^test(“b”)=0
```
**Предотвращение ошибок типа «данные не определены»**
Если вы попробуете извлечь несуществующую запись из глобала, MUMPS выдаст ошибку этапа выполнения (run-time error), например . Чтобы избежать этого, вы можете либо использовать функцию $data для проверки существования узла, либо использовать более удобную функцию $get. Это вернет значение глобального узла, если он существует, или пустое значение, если нет. Функцию $get можно сократить до $g
Так, основываясь на примере, который мы использовали в предыдущей секции с $data:
```
$get(^test) = 3
$get(^test(“a”,”b”)=”” ; поскольку на этом уровне индекса нет данных
$get(^test(“a”,”b”,”c”)=1
$get(^test(“b”)=””
$get(^nonExistentGlobal)=””
```
**Просмотр глобалов**
Caché и все остальные системы MUMPS включают в себя способы просмотра глобалов. Самый простой способ — команда ^%G для командной строки, которую вы обнаружите в Caché и некоторых других реализациях MUMPS. Запустите в сессии терминала следующее:
```
USER> D ^%G
Global ^ Employee
```
Введение имени глобала даст команду отобразить содержимое всего глобала. Однако, вы можете вывести отдельные индексы, например:
```
Employee()
```
Перечислит все значения только первого индекса
```
Employee(“MGW”
```
Перечислит все записи сотрудников с первым значением индекса MGW
```
Employee(“MGW”,)
```
Перечислит все вторые индексы записей сотрудников с первым индексом “MGW”
Caché предоставляет приложение для браузера с графическим интерфейсом под названием Caché Explorer, который позволяет просматривать и редактировать глобалы.
**Резюме**
Мы рассмотрели основы глобалов, а также их создания и редактирования. Следующая глава будет рассматривать глобалы с точки зрения человека, знакомого с реляционными базами данных.
Вероятно, вы уже поняли, что глобалы MUMPS практически не контролируют и не ограничивают ваши действия. Это и замечательно (вы можете быстро и гибко проектировать, создавать и изменять структуру ваших баз данных) и опасно (в неумелых руках база данных превращается в неконтролируемый бардак).
MUMPS полагается на вас, программисты. Страховки нет, однако нет и границ того, чего можно достичь или как вы будете этого достигать. Вы поймете MUMPS — великолепная и захватывающая рабочая среда, благодаря эффективности программирования и выполнения команд.
Когда вы освоите глобалы MUMPS, вы, наверное, будете удивлены: «Почему же все базы данных не могут работать также!» Это очень просто, интуитивно понятно, гибко и по производительности превосходит любую реляционную базу данных. К тому же, MUMPS доступен для практически любой платформы и масштабируется до размера огромных систем — некоторые крупнейшие интерактивные системы в мире основаны на MUMPS, иногда с десятками тысяч одновременно работающих пользователей.
Тем не менее, если вы думаете, что вам нужны инструменты и страховки, которые, по мнению реляционного мира, являются необходимыми, MUMPS определенно не для вас. А если вы все-таки намерены заняться свободным скалолазанием, переходите к следующей главе.
[Продолжение. Часть 2.](/post/176305/) | https://habr.com/ru/post/175659/ | null | ru | null |
# Aptana — создание плагинов
В последнее время в качестве основного рабочего редактора я выбрал [Aptana Studio Community Edition](http://www.aptana.com/). Редактор очень хорош (подробный обзор его возможностей тема для отдельного поста) и радует своей бесплатностью.
Так вот, Aptana поддерживает плагины Eclipse Monkey, которые можно создавать и самостоятельно! Как это делать? Сейчас расскажу на примере создания плагина для сжатия CSS-файлов.
Для начала нам необходимо создать в любом проекте (для скриптов я создал отдельный проект) папку «Monkey» или «Scripts». Затем создаем в новой папке JavaScript файл и открываем его.
В самом начале пишем следующее:
`/*
* Menu: CSS > Compact
* DOM: download.eclipse.org/technology/dash/update/org.eclipse.eclipsemonkey.lang.javascript
* DOM: localhost/com.aptana.ide.scripting
*/`
Этот комментарий описывает как будет отображаться ваш плагин на панели и в меню Scripts. В данном случае плагин попадет в раздел CSS под названием Compact.
Создаем функцию main, внутри этой функции и будут описываться все действия над редактируемым кодом:
`function main(){
}`
Первым делом нам надо убедиться что существует активный редактор, для этого в функцию main пишем следующее:
`var sourceEditor = editors.activeEditor;
if (sourceEditor === undefined)
{
alert("Нет активного редактора!");
}`
Создаем переменную sourceEditor, которую приравниваем к editros.activeEditor (активный редактор). Затем проверяем есть ли активный редактор и в случае отсутствия оного — выводим предупреждение.
Следующим шагом нам необходимо удостовериться, что редактируемый файл — это CSS-файл. Для этого создадим следующую функцию:
`function getLanguage()
{
var result = "";
try
{
result = editors.activeEditor.textEditor.getFileContext().getDefaultLanguage();
}
catch(e)
{
}
return result;
}`
Эта функция вернет нам тип файла в активном редакторе. Для ее вызова допишем наш if в функции main:
`else if (getLanguage() != "text/css")
{
alert("Сжимать можно только CSS-файлы!");
}`
Удостоверившись что существует активный редактор и файл в нем именно CSS, можно приступать непосредственно к работе над кодом. Для этого в наш if допишем:
`else
{
var comString = sourceEditor.source; // comString приравняли к тексту редактируемого файла
var reg = /\t/g; //Описали и
var comString = comString.replace(reg,''); //убрали все табы
var reg = /\/\*.*\*\//g; //Описали и убрали
var comString = comString.replace(reg,''); //все комментарии
var reg = /:\s*/g; // Описали и убрали все пробелы
var comString = comString.replace(reg,':'); // в конструкциях display: none;
var reg = /\r\n\r\n/g; // Описали и убрали
var comString = comString.replace(reg,''); // переводы строки
// Заменяем текст в редакторе, на отредактированный текст
sourceEditor.applyEdit(0, sourceEditor.sourceLength, comString);
}`
Вот и все. Сохранив этот плагин и перезапустив Aptana можно будет обнаружить в меню Scripts > CSS запись Compact вызвав которую, Вы сможете сжать свой CSS-файл.
Таким образом, совершая различные действия над переменной comString Вы можете создать плагин, который нужен именно Вам!
Конечный результат:
> `/\*
>
> \* Menu: CSS > Compact
>
> \* DOM: download.eclipse.org/technology/dash/update/org.eclipse.eclipsemonkey.lang.javascript
>
> \* DOM: localhost/com.aptana.ide.scripting
>
> \*/
>
>
>
> function main()
>
> {
>
> var sourceEditor = editors.activeEditor;
>
>
>
> if (sourceEditor === undefined)
>
> {
>
> alert("Нет активного редактора!");
>
> }
>
> else if (getLanguage() != "text/css")
>
> {
>
> alert("Сжимать можно только CSS-файлы!");
>
> }
>
> else
>
> {
>
> var comString = sourceEditor.source;
>
>
>
> var reg = /\t/g;
>
> var comString = comString.replace(reg,'');
>
>
>
> var reg = /\/\\*.\*\\*\//g;
>
> var comString = comString.replace(reg,'');
>
>
>
> var reg = /:\s\*/g;
>
> var comString = comString.replace(reg,':');
>
>
>
> var reg = /{\s\*/g;
>
> var comString = comString.replace(reg,'{');
>
>
>
> var reg = /}\s\*/g;
>
> var comString = comString.replace(reg,'}');
>
>
>
> var reg = /\s\*{/g;
>
> var comString = comString.replace(reg,'{');
>
>
>
> var reg = /;\s\*/g;
>
> var comString = comString.replace(reg,';');
>
>
>
> var reg = /\r\n/g;
>
> var comString = comString.replace(reg,'');
>
>
>
> sourceEditor.applyEdit(0, sourceEditor.sourceLength, comString);
>
> }
>
> }
>
>
>
> function getLanguage()
>
> {
>
> var result = "";
>
>
>
> try
>
> {
>
> result = editors.activeEditor.textEditor.getFileContext().getDefaultLanguage();
>
> }
>
> catch(e)
>
> {
>
> }
>
>
>
> return result;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
P.S. Пример, приведенный в этой статье не претендует на звание 100% компрессора CSS-файлов! | https://habr.com/ru/post/50199/ | null | ru | null |
# goto в CORE:: GLOBAL:: exit — где грабли?
У меня есть CGIшка, которую хочется запустить под FastCGI.
Она использует фреймвок, который обрабатывает html-шаблоны, выводит ошибки (die) в браузер, делает всяческие редиректы, отдаёт файлы, etc. — всё как обычно. Этот фреймвок, после формирования и вывода ответа на STDOUT, делает `exit()` — что тоже, в общем, не оригинально.
Этот `exit()` может быть вызван внутри `eval()`, а то и нескольких вложенных eval-ов — к примеру, если где-то, в глубине вычислений, CGIшка решает выдать юзеру редирект. Она при этом вызывает функцию фреймвока, он делает `print "Location: ..."` и `exit()`.
**Но под FastCGI `exit()` делать нельзя.**
Следовательно, приходится оный exit перехватывать, и делать либо `die()` (точно так же, как [это делает](http://theory.uwinnipeg.ca/modperl/docs/2.0/api/ModPerl/Util.html#C_exit_), например, mod\_perl), либо `goto`. Проблема с `die()` заключается в том, что в случае если `exit()` был вызван внутри `eval()`, и после вызова eval юзер не передаст неизвестную ему ошибку выше снова вызвав `die()` (а гарантировать такое поведение после каждого eval в этой CGIшке я не могу — скорее могу гарантировать что обычно этого не происходит), то `exit()` приведёт просто к выходу из ближайшего `eval()`, на что CGIшка вызвавшая редирект явно не рассчитывала!
### Псевдо-код CGIшки
`sub that_cgi_script {
...
eval { do_something() };
...
}
sub do_something {
# 1) may return if everything ok
# 2) may die on error, but such error non-important to
# calling code in above case and will be catched by
# eval and ignored
# 3) may redirect: print Location header and call exit()
}`
### Вариант exit через die
`my $FCGI_EXIT = "FCGI NORMAL EXIT\n";
BEGIN { *CORE::GLOBAL::exit = sub { die $FCGI_EXIT }; }
while (CGI::Fast->new()) {
eval { that_cgi_script(); };
die $@ if $@ && $@ ne $FCGI_EXIT;
$CGI::Fast::Ext_Request->Finish();
}`
### Вариант exit через goto
`BEGIN { *CORE::GLOBAL::exit = sub { goto EXIT }; }
while (CGI::Fast->new()) {
eval { that_cgi_script(); };
die $@ if $@;
EXIT:
$CGI::Fast::Ext_Request->Finish();
}`
### Что говорит perldoc -f goto
It may not be used to go into any construct that requires initialization, such as a subroutine or a «foreach» loop. It also can't be used to go into a construct that is optimized away, or to get out of a block or subroutine given to «sort».
### Итак, где же грабли?
Похоже, единственная проблема с `goto`, применимая к этой ситуации, это вызов `exit()` внутри `sort`. :) Я искренне верю, что эта CGIшка такого себе не позволяет. Аминь.
**Какие ещё могут быть грабли при использовании `goto` в `CORE::GLOBAL::exit`?** Меня настораживает то, что mod\_perl `goto` не использует, хотя вроде-бы это более эффективное решение, чем `die()`. | https://habr.com/ru/post/13681/ | null | ru | null |
# Команда GitHub представила нативную поддержку математических выражений в md-файлах
В блоге GitHub [сообщили](https://github.blog/2022-05-19-math-support-in-markdown/), что математические формулы и выражения — важная часть обмена информацией между разработчиками, инженерами и учеными. Поэтому теперь в GitHub появилась нативная функция для простой записи выражений в Markdown.
Для визуализации формул GitHub использует популярную библиотеку MathJax, которая разрабатывается под лозунгом «Красивая и доступная математика во всех браузерах». Команда GitHub рассказала, что подобную функцию пользователи впервые [запросили](https://github.com/github/markup/issues/274) 8 лет назад, но реализовать её удалось только сейчас.
Для визуализации формул пользователю следует использовать ключевые символы в виде `$` или `$$`. Система автоматически визуализирует все, что записано между этими символами. Сами формулы следует записывать в формате TeX или LaTeX.
К примеру, вот такая запись в GitHub Markdown
```
Когда $D > 0$, уравнение $(ax^2 + bx + c = 0)$ имеет два корня, которые можно найти следующим образом:
$$ x_{1}, x_{2} = {-b \pm \sqrt{D} \over 2a} $$
$$ D = b^2 - 4ac$$
```
будет отображаться следующим образом:
Важно отметить, что одиночный символ используется для встраивания формул в сам текст, а двойной создает отдельный блок с формулой. Для печати знака доллара в одной строке с выражением следует использовать экранирование в виде обратной косой черты или тега .
К примеру, если в самой формуле необходимо использовать символ доллара, то перед ним необходимо разместить обратную косую черту.
```
Используйте конструкцию `\$` для вставки символа доллара в формулу: $\sqrt{\$4}$
```
Если символ доллара необходимо записать в одной строке с формулой, то его следует взять в тег .
```
Чтобы разделить $100 пополам, нам надо вычислить $100/2$
```
В середине февраля 2022 года команда GitHub [представила](https://habr.com/ru/news/t/651569/) нативную поддержку диаграмм Mermaid.js в md-файлах репозиториев. Информационная служба Хабра, в свою очередь, [подготовила](https://habr.com/ru/post/652867/) обзор технологии и полноценное руководство пользователя на русском языке. | https://habr.com/ru/post/667268/ | null | ru | null |
# Переключения между провайдерами интернета на Debian 7
В последних дистрибутивах Linux довольно много всяких полезных плюшек в папке /etc, однако мало кто ими грамотно пользуется. Здесь я расскажу про часть из них применительно к последней стабильной версии Debian, и приведу пример реализации переключения на резервный канал.
Все попытки найти банальную автопереключалку приводили к связке из 1-2 скриптов, написанным «под себя» и мало поддающимися настройке. К dhcp не был привязан ни один из них, а значит любые манипуляции на стороне провайдера требовали вмешательство в настройки. Сам писал такие в свое время, но вот теперь решил на новой системе оформить это красиво – так, как это задумывали разработчики Debian, а именно – меняем файлы конфигурации, добавляем свои скрипты и не трогаем те, что нам предоставила система.
Итак, имеем:
— два кабеля от двух провайдеров, оба выдают IP по dhcp
— свежесобранный сервер под управлением debian wheezy с тремя сетевухами (возможно потом добавлю еще)
— желание чтоб инет не пропадал (работа не ждет!). Балансировку и т.п. оставим на потом.
Логика на первый взгляд простая:
— пингуем какой-нибудь хост по очереди через разные интерфейсы
— если пинг нестабильный, переключаемся на резервный канал.
Вот только в реализации была поставлена цель сделать всё максимально гибко, например не ограничивать количество потенциальных провайдеров и впоследствии делать минимум телодвижений для перенастройки.
Для начала посмотрим какие плюшки уже есть в системе
В папке /etc/network нас интересует файл interfaces и папки if-down.d, if-post-down.d, if-pre-up.d, if-up.d.
```
root@ns:/etc/network# cat interfaces
# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).
# The loopback network interface
iface lo inet loopback
# The primary network interface
iface eth0 inet static
address 192.168.104.1
netmask 255.255.255.0
iface eth1 inet dhcp
iface eth3 inet dhcp
```
При манипуляциях с интерфейсами через ifup/ifdown на папочки натравливается run-parts, и скриптам в них доступны следующие переменные окружения: IFACE, LOGICAL, ADDRFAM, METHOD, MODE, PHASE, MODE, VERBOSITY, PATH
При старте системы сначала запускаются скрипты из папки if-pre-up.d (по одному разу для каждого интерфейса, но перед ними идет IFACE=”--all”, потом поднимаются интерфейсы и запускаются скрипты из папки if-up.d и IFACE=”--all” идет уже в конце. При ifup ethX запускается по одному разу только для ethX (без “–all”). Аналогично if-down.d и if-post-down.d при ifdown и выключении системы.
Система позволяет назначить для каждой операции и для каждого интерфейса свой скрипт, но вносить похожие изменения каждый раз в 10 из 20 скриптов в мои планы не входило, поэтому будем писать один большой скрипт и расставим на него симлинки изо всех четырех папок. Понять, откуда он запущен, можно по переменным окружения.
Однако нам еще надо узнать информацию о шлюзах, которая пришла по dhcp. На этот случай тоже есть папки со скриптами /etc/dhcp/dhclient-enter-hooks.d и /etc/dhcp/dhclient-exit-hooks.d
Последовательность запуска такая:
— опросили сервер dhcp
— запустили содержимое папки dhclient-enter-hooks.d
— настроили сетевые параметры (ip, DNS, шлюз,…)
— запустили содержимое папки dhclient-exit-hooks.d
Скриптам тоже доступны разные полезные переменные (параметры, которые пришли от dhcp сервера), часть из которых нам надо будет сохранять.
После нескольких вечеров получилось следующее:
Все скрипты лежат в папке /etc/network/scripts. Из разных папок туда ведут симлинки
Настройки — /etc/default/network-scripts
Временые файлы кладем /var/lib/dhcp
Логи пишутся в файл /var/log/network-scripts.log
Настройки
```
# cat /etc/default/network-scripts
# Configuration file for /etc/network/scripts/*
# Host to ping for autoroute
HOST_TO_PING="4.2.2.1"
# Number of pings to check the connection
PING_COUNT=5
# list of LAN interfaces
IFLAN="eth0"
# WAN prio from first to last
IFWAN="eth1 eth3"
# open ports from WAN zone
WAN_PORTS_OPEN=""
```
Тут всё должно быть понятно. Интерфейсы LAN, WAN можно дописывать сколько угодно. В списке WAN первый – самый приоритетный, далее по убыванию.
Отдельно файл с функциями.
```
# cat /etc/network/scripts/functions
#!/bin/sh
DHCPLIB="/var/lib/dhcp"
LOGDIR="/var/log"
LOGFILE="$LOGDIR/network-scripts.log"
HOST_TO_PING="4.2.2.1"
PING_COUNT=3
SQUID_PORT="3128"
IFLAN=""
IFWAN=""
WAN_PORTS_OPEN=""
. /etc/default/network-scripts
# Local variables
DEFAULTWAN=${IFWAN% *}
log()
{
DATE=`date`
echo "$DATE $@" >> $LOGFILE
}
warn()
{
log "WARNING: $@"
echo "WARNING: $@"
}
cmd()
{
$@
RES=$?
log "$RES - $@"
return $RES
}
get_ip()
{
IP=`ip addr list $1 | grep " inet " | head -n 1 | cut -d " " -f 6 | cut -d / -f 1`
}
update_local_redirect()
{
for i in $IFLAN; do
cmd iptables -t nat $INS PREROUTING -i $i -p tcp --dport 80 -d $1 -j ACCEPT
done
}
update_squid()
{
case $1 in
start)
ADD="-A"
INS="-I"
;;
stop)
ADD="-D"
INS="-D"
;;
*)
ADD="-C"
INS="-C"
esac
for i in $IFLAN; do
# transparent proxy
cmd iptables -t nat $ADD PREROUTING -i $i -p tcp --dport 80 -j REDIRECT --to-port $SQUID_PORT
done
}
```
Тут мы имеем:
— импорт настроек из /etc/default/network-scripts
— ведение логов (log, warn),
— запуск команд с записью в лог параметров и результатов работы
— update\_local\_redirect() добавляет маршруты на 80 порт мимо transparent proxy
— update\_squid() добавляет правило для самого transparent proxy (запускается в /etc/init.d/squid3 – это единственный системный скрипт, в который пришлось влезть)
Тут и далее используется технология, придуманная мной несколько лет назад с переменными $ADD и $INS для iptables. Позволяет писать правило только в одном месте, и потом его добавлять-удалять, изменяя только эти переменные.
```
# cat /etc/network/scripts/route-enter
#!/bin/sh
. /etc/network/scripts/functions
log "$0 route-enter ${interface} ${reason} ${new_routers}"
# security bugfix
new_host_name=${new_host_name//[^-.a-zA-Z0-9]/}
# save routers to special file
echo -n ${new_routers} > $DHCPLIB/routers.${interface}
echo -n ${new_ip_address} > $DHCPLIB/ip_address.${interface}
case ${interface} in
$DEFAULTWAN)
# by default enable routers only for first WAN interface
;;
*)
# and clear it for others
unset new_routers
;;
esac
```
— Сохраняем new\_routers и new\_ip\_address в файл (потом понядобятся)
— default route разрешаем только для приоритетного интерфейса
```
# cat /etc/network/scripts/route-exit
#!/bin/sh
. /etc/network/scripts/functions
log "$0 route-exit ${interface} ${reason}"
update_routes()
{
cmd route $ADD -host $HOST_TO_PING gw ${routers}
# identyfy providers by DNS addresses
case $DNS in
*82.193.96*)
DESTIP=`resolveip -s stat.ipnet.ua`
cmd route $ADD -host $DESTIP gw ${routers}
;;
*193.41.63*|*192.168.11.1*)
DESTIP=`resolveip -s my.kyivstar.ua`
cmd route $ADD -host $DESTIP gw ${routers}
;;
*)
warn "route-exit - unknown DNS ${new_domain_name_servers} specified"
;;
esac
}
case ${reason} in
BOUND)
ADD="add"
DNS=${new_domain_name_servers}
# use saved-to-file value due to $old_routers can be cleared for some interfaces by other script
routers=`cat $DHCPLIB/routers.${interface}`
update_routes
;;
RELEASE)
# No need to delete routes during release
# ADD="del"
# routers=${old_routers}`
# update_routes
;;
PREINIT)
;;
RENEW)
if [ "$old_routers" != "$new_routers" ]; then
ADD="del"
DNS=${old_domain_name_servers}
routers=${old_routers}
update_routes
ADD="add"
DNS=${new_domain_name_servers}
routers=`cat $DHCPLIB/routers.${interface}`
update_routes
fi
if [ "$old_ip_address" != "$new_ip_address" ]; then
ADD="-D"
INS="-D"
update_local_redirect ${old_ip_address}
ADD="-A"
INS="-I"
update_local_redirect ${new_ip_address}
fi
;;
*)
warn "route-exit - unknown reason ${reason} used"
;;
esac
```
— Добавляем static route для сайтов с биллингом провайдеров. Локалка провайдера мне не нужна, но её тоже можно добавить. Идентификация по DNS серверам.
— для режима RENEW добавил перенастройку (если вдруг у провайдера что-то изменится), но пока не тестировал.
```
# cat /etc/network/scripts/firewall
#!/bin/bash
. /etc/network/scripts/functions
get_ip $IFACE
log "$0 $IFACE $LOGICAL $ADDRFAM $METHOD $MODE $PHASE $VERBOSITY $IP"
case $MODE in
start)
INS="-I"
ADD="-A"
echo -n $IP > $DHCPLIB/ip_address.$IFACE
;;
stop)
INS="-D"
ADD="-D"
echo -n > $DHCPLIB/ip_address.$IFACE
;;
*)
INS="-C"
ADD="-C"
warn "Wrong MODE:$MODE"
;;
esac
case $IFACE in
--all)
case $PHASE in
pre-down|post-up)
# skip proxy for local addresses
for j in $IFLAN $IFWAN; do
get_ip $j
update_local_redirect $IP
done
;;
post-up|pre-down)
;;
esac
;;
lo)
;;
*)
if [[ "$IFLAN" == *$IFACE* ]]; then
# LAN
case $PHASE in
pre-up|post-down)
cmd iptables $INS INPUT -p tcp -i $IFACE --dport 22 -j ACCEPT
;;
post-up|pre-down)
;;
*)
warn "Wrong PHASE:$PHASE"
;;
esac
fi
if [[ "$IFWAN" == *$IFACE* ]]; then
# WAN
case $PHASE in
pre-up|post-down)
# by default close all input connections
cmd iptables $ADD INPUT -p tcp -i $IFACE --dport 1:10000 -j DROP
cmd iptables $ADD INPUT -p udp -i $IFACE --dport 1:10000 -j DROP
# open ports from list
for PORT in $WAN_PORTS_OPEN; do
cmd iptables $INS INPUT -p tcp -i $IFACE --dport $PORT -j ACCEPT
done
;;
post-up|pre-down)
cmd iptables -t nat $ADD POSTROUTING -o $IFACE -j MASQUERADE
;;
*)
warn "Wrong PHASE:$PHASE"
;;
esac
fi
;;
esac
```
Правила firewall. Для общих таблиц пишем в момент pre-up и post-down, для NAT – в post-up и pre-down.
```
# cat /etc/network/scripts/autoroute
#!/bin/sh
# Script for cron to monitor WAN interfaces
# and (in future) SQUID status
. /etc/network/scripts/functions
CURRENT_ROUTE_DEV=`ip route show | grep default | awk '{print $5}'`
unset ROUTE_GOOD
PING_RESULTS=""
for i in $IFWAN; do
if [ -z $ROUTE_GOOD ]; then
PING_RESULT=`ping -c$PING_COUNT -q $HOST_TO_PING -I $i | grep 'packet loss' | awk '{print $6}'`
# If no route t host then set to 100% loss
if [ -z $PING_RESULT ]; then
warn "$0 No route to host $HOST_TO_PING on $i"
PING_RESULT='100%'
fi
if [ $PING_RESULT = '0%' ]; then
ROUTE_GOOD=$i
if [ -z $CURRENT_ROUTE_DEV ]; then
log "$0 Adding default route to $i"
cmd route add default gw `cat $DHCPLIB/routers.$i`
elif [ $CURRENT_ROUTE_DEV != $i ]; then
log "$0 Change default route from $CURRENT_ROUTE_DEV to $i"
cmd route del default
cmd route add default gw `cat $DHCPLIB/routers.$i`
fi
else
log "$0 loss $PING_RESULT on $i"
fi
fi
PING_RESULTS="$PING_RESULTS $PING_RESULT"
done
if [ -z $ROUTE_GOOD ]; then
warn "$0 lost all internet connections ($PING_RESULTS loss)"
fi
```
Тут всё просто: пингуем в порядке приоритета. Нашли лучший – переключаемся. Если что, пишем в лог.
Ну и напоследок
```
# cat /etc/cron.d/autoroute
PATH="/usr/bin:/bin:/usr/sbin:/sbin"
*/5 * * * * root /etc/network/scripts/autoroute
```
```
# cat /etc/logrotate.conf | tail
# system-specific logs may be configured here
/var/log/network-scripts.log {
weekly
missingok
rotate 7
compress
}
```
Симлинки
```
/etc/dhcp/dhclient-enter-hooks.d/route-enter -> ../../network/scripts/route-enter
/etc/dhcp/dhclient-exit-hooks.d/route-exit -> ../../network/scripts/route-exit
/etc/network/if-pre-up.d/firewall -> ../scripts/firewall
/etc/network/if-down.d/firewall -> ../scripts/firewall
/etc/network/if-up.d/firewall -> ../scripts/firewall
/etc/network/if-post-down.d/firewall -> ../scripts/firewall
``` | https://habr.com/ru/post/199478/ | null | ru | null |
# Занимательный C#. Пять примеров для кофе-брейка
Написав уже не одну статью про [Veeam Academy](https://academy.veeam.ru/?utm_source=habrahabr.ru&utm_medium=referral&utm_campaign=academy_habr), мы решили приоткрыть немного внутренней кухни и предлагаем вашему вниманию несколько примеров на C#, которые мы разбираем с нашими студентами. При их составлении мы отталкивались от того, что наша аудитория — это начинающие разработчики, но и опытным программистам тоже может быть интересно заглянуть под кат. Наша цель — показать, насколько глубока кроличья нора, параллельно объясняя особенности внутреннего устройства C#.
С другой стороны, мы будем рады комментариям опытных коллег, которые или укажут на недочёты в наших примерах, или смогут поделиться своими. Подобные вопросы любят использовать на собеседованиях, так что наверняка нам всем есть что рассказать.
Надеемся, что наша подборка будет для вас полезна, поможет освежить ваши знания или просто улыбнет.
#### Пример 1
Структуры в C#. С ними нередко возникают вопросы даже у опытных разработчиков, чем так часто любят пользоваться всевозможные онлайн-тесты.
Наш первый пример – пример на внимательность и на знание того, во что разворачивается блок using. А также вполне себе тема для общения во время собеседования.
Рассмотрим код:
```
public struct SDummy : IDisposable
{
private bool _dispose;
public void Dispose()
{
_dispose = true;
}
public bool GetDispose()
{
return _dispose;
}
static void Main(string[] args)
{
var d = new SDummy();
using (d)
{
Console.WriteLine(d.GetDispose());
}
Console.WriteLine(d.GetDispose());
}
}
```
**Что выведет на консоль метод Main?**Обратим внимание, что SDummy – это структура, реализующая интерфейс IDisposable, благодаря чему переменные типа SDummy можно использовать в блоке using.
Согласно [спецификации языка C#](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/statements#the-using-statement) using statement для значимых типов во время компиляции разворачивается в try-finally блок:
```
try
{
Console.WriteLine(d.GetDispose());
}
finally
{
((IDisposable)d).Dispose();
}
```
Итак, в нашем коде внутри блока using вызывается метод GetDispose(), который возвращает булевское поле \_dispose, значение которого для объекта d еще нигде не было задано (оно задается только в методе Dispose(), который еще не был вызван) и поэтому возвращается значение по умолчанию, равное False. Что дальше?
А дальше самое интересное.
Выполнение строки в блоке finally
```
((IDisposable)d).Dispose();
```
в обычном случае приводит к упаковке (boxing). Это нетрудно увидеть, например, [тут](https://sharplab.io/#v2:C4LglgNgNAJiDUAfAAgBgATIIwG4CwAUIcgMzoDOwATgK4DGw6AygCI0C27AnuiOgJIsw5AA4B7cgEMARhACmhdEvQBvRco0iqYAG6Tgc9NLFiI6APoxh48nPwENG9Y8xlkAFnRDREuQAoASmdHNQcXR0trX3QAXnRqGjtgjQBfQmTlUiMTMwBxOWBvG38gsJdQ8MdkAHYLKx9be0q0ojKqrAA2TE8AWUkwADs/bFQAbQBddEkqAHNyUsqKyuU9KnQYWPQBuQB3ZjZOLkD7DJdqLlOQy8rsAE4/GAA6fMKo20CApuWlFu+lADNBpIIBALm1FtdlABIPx+QRvGTyAIwAKPIq+Y6Qn7pcHhO4PZ4FdHvAKfS6/ZQpIA===) (справа вверху в Results сначала выберите C#, а потом IL):
В этом случае метод Dispose вызывается уже для другого объекта, а вовсе не для объекта d.
Запустим нашу программу и увидим, что программа действительно выводит на консоль «False False». Но все ли так просто? :)
На самом деле никакой УПАКОВКИ НЕ ПРОИСХОДИТ. Что, по словам Эрика Липперта, сделано ради оптимизации (см. [тут](https://stackoverflow.com/a/1330724) и [тут](https://stackoverflow.com/a/2413844)).
Но, если нет упаковки (что само по себе может показаться удивительным), почему на экране «False False», а не «False True», ведь Dispose теперь должен применяться к тому же объекту?!?
А вот и не к тому же!
Заглянем, во что разворачивает нашу программу [компилятор C#](https://sharplab.io/#v2:CYLg1APgAgDABFAjAbgLACgNQMxwM4AuATgK4DGBcAygCIkC29AnnCHAJI0CWeADgPZ4AhgCMANgFMMcGXADe02Ut5EuANyEEJcEf35i4AfWA8BeCWnRKli6wlxQALHG59BEgBQBKW9YVW7a2NTdzgAXjhiEgtfJQBfDFjZHB09AwBxCQJXM08fALt/QOsoAHYjEzdzS2KEzAKSxAA2BGcAWSEuADsPJBgAbQBdOCEiAHM8fOKi4tkNIjhgcLguiQB3ajpGJm9LJLtYOA9gKdmZGbOlJABOY4A6TOyQ828vGsu6/cbb4AesnPcr3edjq8US6CAA=):
```
public struct SDummy : IDisposable
{
private bool _dispose;
public void Dispose()
{
_dispose = true;
}
public bool GetDispose()
{
return _dispose;
}
private static void Main(string[] args)
{
SDummy sDummy = default(SDummy);
SDummy sDummy2 = sDummy;
try
{
Console.WriteLine(sDummy.GetDispose());
}
finally
{
((IDisposable)sDummy2).Dispose();
}
Console.WriteLine(sDummy.GetDispose());
}
}
```
Появилась новая переменная sDummy2, к которой применяется метод Dispose()!
Откуда взялась эта скрытая переменная?
Снова обратимся к [спеке](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/statements#the-using-statement):
> A using statement of the form 'using (expression) statement' has the same three possible expansions. In this case ResourceType is implicitly the compile-time type of the expression… The 'resource' variable is inaccessible in, and invisible to, the embedded statement.
>
>
Т.о. переменная sDummy оказывается невидимой и недоступной для встроенного выражения (embedded statement) блока using, а все операции внутри этого выражения производятся с другой переменной sDummy2.
В итоге метод Main выводит на консоль «False False», а не «False True», как считают многие из тех, кто столкнулся с этим примером впервые. При этом обязательно имейте в виду, что тут не происходит упаковки, но создается дополнительная скрытая переменная.
Общий вывод такой: изменяемые значимые типы (mutable value types) – это зло, которое лучше избегать.
Похожий пример рассмотрен [тут](https://ericlippert.com/2011/03/14/to-box-or-not-to-box). Если тема интересна, очень рекомендуем заглянуть.
Хочется сказать отдельное спасибо [SergeyT](https://habr.com/ru/users/sergeyt/) за ценные замечания к этому примеру.
#### Пример 2
Конструкторы и последовательность их вызовов – одна из основных тем любого объектно-ориентированного языка программирования. Иногда такая последовательность вызовов может удивить и, что гораздо хуже, даже «завалить» программу в самый неожиданный момент.
Итак, рассмотрим класс MyLogger:
```
class MyLogger
{
static MyLogger innerInstance = new MyLogger();
static MyLogger()
{
Console.WriteLine("Static Logger Constructor");
}
private MyLogger()
{
Console.WriteLine("Instance Logger Constructor");
}
public static MyLogger Instance { get { return innerInstance; } }
}
```
Предположим, что этот класс обладает некоторой бизнес-логикой, необходимой нам для поддержки логирования (функциональность сейчас не так важна).
Посмотрим, что есть в нашем классе MyLogger:
1. Задан статический конструктор
2. Есть приватный конструктор без параметров
3. Определена закрытая статическая переменная innerInstance
4. И есть открытое статическое свойство Instance для общения с внешним миром
Для простоты анализа этого примера внутри конструкторов класса мы добавили простой вывод на консоль.
Снаружи класса (без использования ухищрений типа reflection) мы можем использовать только открытое статическое свойство Instance, которое можем вызвать так:
```
class Program
{
public static void Main()
{
var logger = MyLogger.Instance;
}
}
```
**Что выведет эта программа?**Все мы знаем, что статический конструктор вызывается перед доступом к любому члену класса (за исключением констант). При этом запускается он единственный раз в рамках application domain.
В нашем случае мы обращаемся к члену класса — свойству Instance, что должно вызвать сначала запуск статического конструктора, а потом вызовет конструктор экземпляра класса. Т.е. программа выведет:
**Static Logger Constructor
Instance Logger Constructor**
Однако после запуска программы мы получим на консоли:
**Instance Logger Constructor
Static Logger Constructor**
Как так? Инстанс конструктор отработал раньше статического конструктора?!?
Ответ: Да!
И вот почему.
В стандарте ECMA-334 языка C# на счет статических классов указано следующее:
*17.4.5.1: «If a static constructor (§17.11) exists in the class, execution of the static field initializers occurs immediately prior to executing that static constructor.
…
17.11: … If a class contains any static fields with initializers, those initializers are executed in textual order immediately prior to executing the static constructor*
(Что в вольном переводе значит: если в классе есть статический конструктор, то запуск инициализации статических полей происходит непосредственно ПЕРЕД запуском статического конструктора.
…
Если класс содержит какие-либо статические поля с инициализаторами, то такие инициализаторы запускаются в порядке следования в тексте программы непосредственно ПЕРЕД запуском статического конструктора.)
В нашем случае статическое поле innerInstance объявлено вместе с инициализатором, в качестве которого выступает конструктор экземпляра класса. Согласно стандарту ECMA инициализатор должен быть вызван ПЕРЕД вызовом статического конструктора. Что и происходит в нашей программе: конструктор экземпляра, являясь инициализатором статического поля, вызывается ДО статического конструктора. Согласитесь, довольно неожиданно.
Обратим внимание, что это верно только для инициализаторов статических полей. В общем случае статический конструктор вызывается ПЕРЕД вызовом конструктора экземпляра класса.
Как, например, тут:
```
class MyLogger
{
static MyLogger()
{
Console.WriteLine("Static Logger Constructor");
}
public MyLogger()
{
Console.WriteLine("Instance Logger Constructor");
}
}
class Program
{
public static void Main()
{
var logger = new MyLogger();
}
}
```
И программа ожидаемо выведет на консоль:
**Static Logger Constructor
Instance Logger Constructor**
#### Пример 3
Программистам часто приходится писать вспомогательные функции (утилиты, хелперы и т.д.), чтобы облегчать себе жизнь. Обычно такие функции довольно просты и часто занимают всего несколько строк кода. Но споткнуться можно даже на ровном месте.
Пусть нам необходимо реализовать такую функцию, которая проверяет число на нечетность (т.е. что число не делится на 2 без остатка).
Реализация может выглядеть так:
```
static bool isOddNumber(int i)
{
return (i % 2 == 1);
}
```
На первый взгляд все хорошо и, например, для чисел 5,7 и 11 мы ожидаемо получаем True.
**А что вернет функция isOddNumber(-5)?**-5 нечетное число, но в качестве ответа нашей функции мы получим False!
Разберемся, в чем причина.
Согласно [MSDN](https://docs.microsoft.com/ru-ru/dotnet/csharp/language-reference/operators/remainder-operator) про оператор остатка от деления % написано следующее:
«Для целочисленных операндов результатом a % b является значение, произведенное a — (a / b) \* b»
В нашем случае для a=-5, b=2 мы получаем:
-5 % 2 = (-5) — ((-5) / 2) \* 2 = -5 + 4 = -1
Но -1 всегда не равно 1, что объясняет наш результат False.
Оператор % чувствителен к знаку операндов. Поэтому, чтобы не получать таких «сюрпризов», лучше результат сравнивать с нулем, у которого нет знака:
```
static bool isOddNumber(int i)
{
return (i % 2 != 0);
}
```
Или завести отдельную функцию проверки на четность и реализовать логику через нее:
```
static bool isEvenNumber(int i)
{
return (i % 2 == 0);
}
static bool isOddNumber(int i)
{
return !isEvenNumber(i);
}
```
#### Пример 4
Все, кто программировал на C#, наверняка встречался с LINQ, на котором так удобно работать с коллекциями, создавая запросы, фильтруя и агрегируя данные…
Мы не будем заглядывать под капот LINQ. Возможно, сделаем это в другой раз.
А пока рассмотрим небольшой пример:
```
int[] dataArray = new int[] { 0, 1, 2, 3, 4, 5 };
int summResult = 0;
var selectedData = dataArray.Select(
x =>
{
summResult += x;
return x;
});
Console.WriteLine(summResult);
```
**Что выведет этот код?**Мы получим на экране значение переменной summResult, которое равно начальному значению, т.е. 0.
Почему так произошло?
А потому, что определение LINQ запроса и запуск этого запроса – это две операции, которые выполняются отдельно. Таким образом, определение запроса еще не означает его запуск/выполнение.
Переменная summResult используется внутри анонимного делегата в методе Select: последовательно перебираются элементы массива dataArray и прибавляются к переменной summResult.
Можно предположить, что наш код напечатает сумму элементов массива dataArray. Но LINQ работает не так.
Рассмотрим переменную selectedData. Ключевое слово var – это «синтаксический сахар», который во многих случаях сокращает размер кода программы и улучшает ее читабельность. А настоящий тип переменной selectedData реализует интерфейс IEnumerable. Т.е. наш код выглядит так:
```
IEnumerable selectedData = dataArray.Select(
x =>
{
summResult += x;
return x;
});
```
Здесь мы определяем запрос (Query), но сам запрос не запускаем. Схожим образом можно работать с базой данных, задавая SQL запрос в виде строки, но для получения результата обращаясь к базе данных и запуская этот запрос в явном виде.
То есть пока мы только задали запрос, но не запустили его. Вот почему значение переменной summResult осталось без изменений. А запустить запрос можно, например, с помощью методов ToArray, ToList или ToDictionary:
```
int[] dataArray = new int[] { 0, 1, 2, 3, 4, 5 };
int summResult = 0;
// определяем запрос и сохраняем его в переменной selectedData
IEnumerable selectedData = dataArray.Select(
x =>
{
summResult += x;
return x;
});
// запускаем запрос selectedData
selectedData.ToArray();
// печатаем значение переменной summResult
Console.WriteLine(summResult);
```
Этот код уже выведет на экран значение переменной summResult, равное сумме всех элементов массива dataArray, равное 15.
С этим разобрались. А что тогда выведет на экран эта программа?
```
int[] dataArray = new int[] { 0, 1, 2, 3, 4, 5 }; //1
var summResult = dataArray.Sum() + dataArray.Skip(3).Take(2).Sum(); //2
var groupedData = dataArray.GroupBy(x => x).Select( //3
x =>
{
summResult += x.Key;
return x.Key;
});
Console.WriteLine(summResult); //4
```
Переменная groupedData (строка 3) на самом деле реализует интерфейс IEnumerable и по сути определяет запрос к источнику данных dataArray. А это значит, что для работы анонимного делегата, который изменяет значение переменной summResult, этот запрос должен быть запущен явно. Но такого запуска в нашей программе нет. Поэтому значение переменной summResult будет изменено только в строке 2, а все остальное мы можем не рассматривать в наших вычислениях.
Тогда нетрудно посчитать значение переменной summResult, которое равно, соответственно, 15 + 7, т.е. 22.
#### Пример 5
Скажем сразу — этот пример мы не рассматриваем на наших лекциях в Академии, но иногда обсуждаем во время кофе-брейков скорее как анекдот.
Несмотря на то, что он вряд ли является показательным с точки зрения определения уровня разработчика, этот пример встречался нам в нескольких различных тестах. Возможно, его используют за универсальность, потому что он отрабатывает одинаково как на C и C++, так и на C# и Java.
Итак, пусть есть строка кода:
```
int i = (int)+(char)-(int)+(long)-1;
```
**Чему будет равно значение переменной i?**Ответ: 1
Можно подумать, что здесь используется численная арифметика над размерами каждого типа в байтах, поскольку для преобразования типов тут довольно неожиданно встречаются знаки «+» и «-».
Известно, что в C# тип integer имеет размер 4 байта, long – 8, char – 2.
Тогда легко подумать, что наша строка кода будет равносильна следующему арифметическому выражению:
```
int i = (4)+(2)-(4)+(8)-1;
```
Однако это не так. А чтобы сбить с толку и направить по такому ложному рассуждению, пример может быть изменен, например, так:
```
int i = (int)+(char)-(int)+(long)-sizeof(int);
```
Знаки «+» и «-» используются в этом примере не как бинарные арифметические операции, а как унарные операторы. Тогда наша строка кода является лишь последовательностью явных преобразований типов, перемешанных с вызовами унарных операций, которую можно записать так:
```
int i =
(int)( // call explicit operator int(char), i.e. char to int
+( // call unary operator +
(char)( // call explicit operator char(int), i.e. int to char
-( // call unary operator -
(int)( // call explicit operator int(long), i.e. long to int
+( // call unary operator +
(long)( // call explicit operator long(int), i.e. int to long
-1
)
)
)
)
)
)
);
```
### Заинтересовало Обучение в Veeam Academy?
Сейчас идет набор на весенний интенсив по C# в Санкт-Петербурге, и мы приглашаем всех желающих пройти онлайн-тестирование на сайте [Veeam Academy.](https://academy.veeam.ru/?utm_source=habrahabr.ru&utm_medium=referral&utm_campaign=academy_habr)
Курс стартует 18 февраля 2019 г., продлится до середины мая и будет, как всегда, совершенно бесплатным. Регистрация для всех, кто хочет пройти входное тестирование, уже доступна на сайте Академии: [academy.veeam.ru](https://academy.veeam.ru/?utm_source=habrahabr.ru&utm_medium=referral&utm_campaign=academy_habr)
 | https://habr.com/ru/post/439478/ | null | ru | null |
# Кубер или два service discovery на один service mesh
Привет! Я Алексей, старший системный администратор ЮMoney. Так уж вышло, что я — главный по Куберу в компании. Поэтому когда меня попросили рассказать, как мы создавали сервис Kubernetes и что у нас в итоге получилось, уговаривать меня долго не пришлось.
### Зачем компании оркестрация контейнеров?
Когда приложений немного, то и задача такая, как правило, не стоит. Администраторы знают каждое приложение в лицо, живут они на небольшом числе серверов. В такой ситуации ресурсы обычно выделяются вручную.
С ростом количества приложений управлять ими вручную становится сложнее. Эта работа начинает занимать всё больший процент времени администраторов, которым, конечно же, не очень нравится рутина.
Когда-то давно у нас так и было: приложений было пара десятков, и жили они все на нескольких железных серверах без какой-либо контейнеризации. По мере роста компании и распиливания монолитов количество приложений стало расти, а сами они начали перемещаться в LXC/LXD-контейнеры. Но поскольку их всё ещё было немного, ручное управление размещением контейнеров, выделением ресурсов и сетями не было проблемой. Пока в конце концов мы не пришли к тому, что приложений у нас уже больше 160, в год добавляется ещё по 20, а живут они на 800+ LXC/LXD-контейнеров.
### Кубер v1
Для начала небольшое погружение в историю. Ещё четыре года назад, в конце 2017 – начале 2018 года, когда приложений было поменьше, около 60, и даже не все они ещё были в LXC, стало понятно, что нам нужна какая-то оркестрация контейнеров. На тот момент наряду с Kubernetes рассматривали ещё Swarm и Nomad, а последний даже подняли для нужд одного из наших подразделений (и он до сих пор жив).
Тогда-то один из Linux-админов компании и поднял тестовый кластер куба для экспериментов. От этого кластера ведут свою родословную все кластеры, живущие в нашей компании.
Первый тикет в Jira с тегом K8s, который мне удалось найтиКластер был инициативой снизу и делался одним сотрудником фактически на голом энтузиазме. От первой заявки на сети до появления работающего кластера прошло около года экспериментов. В этот кластер заехал созданный тем же сотрудником релизный бот, про которого отдельно подробно рассказал [@dvorob](/users/dvorob) в [своём докладе](https://youtu.be/5px43uLS7bU?list=PLd_j4Ug00ng2g3rrBSnpIOsg6Lag0P-ap), и... всё, больше ничего заехать не успело. Угадайте почему? Потому что закончилось всё ровно тем, чем всегда заканчиваются истории с `bus_factor == 1`. Конечно же, тот самый единственный и неповторимый сотрудник в один прекрасный день покинул компанию.
### Кубер v2
Созданный кластер с релизным ботом не бросили, а создали группу из трёх сотрудников, которым передали все наработки. Примерно в этот момент Кубер начал превращаться из проекта, созданного в свободное время энтузиастом, во что-то более походящее на боевую систему.
Втроём ребята проводили эксперименты и пытались нащупать подходящую нам архитектуру системы, которая должна была, насколько это возможно, соответствовать следующим требованиям:
* отказоустойчивость
* минимальные переделки приложений со стороны разработки
* совместимость с существующей инфраструктурой: система не должна стоять особняком
* масштабируемость
* тиражируемость: система должна быть воспроизводима
Хотелось, чтобы в куб можно было перенести приложения нашей платёжной системы без переделки самих приложений и инфраструктуры с нуля, а для переноса приложения в кластер достаточно было бы его упаковать в докер-контейнер.
К лету 2019-го появилась первая версия технического решения, а в сентябре разработка архитектуры кластера в основном была завершена. Было решено поднять четыре кластера K8s, по два на дата-центр. Каждый кластер состоял из трёх мастер-нод, на которых крутился control-plain и etcd, двух нод-балансировщиков, на которых поднимался ingress-nginx, и произвольного числа нод для рабочих нагрузок. Единым service mesh для всех приложений компании должен был стать Consul Connect.
За сентябрь-октябрь в новые кластеры начали заезжать приложения. Вообще, бо́льшая часть платёжной системы ЮMoney написана на Java и Node.js, которые деплоятся в LXD-контейнеры. Но для начала брали приложения, которые не были связаны с ядром платёжной системы, жили на отдельных виртуалках в VmWare vCenter и не проходили через стандартный CI/CD пайплайн. Это был десяток небольших РНР-приложений, которые стояли особняком и могли быть безболезненно мигрированы в новую инфраструктуру.
Кроме PHP-приложений для заезда в кластеры куба было выбрано одно небольшое новое Node.js-приложение, которое готовилось к выезду в продакшн и не было критичным в случае простоя. Нам было важно проверить работу на одном из стандартных приложений и убедиться, что всё работает как задумано.
Примерно на этом этапе к команде, занимавшейся Кубером, присоединился я: не хватало рабочих рук, и меня с ещё одним коллегой добавили для усиления. На тот момент у меня был некоторый опыт работы с докером, но ни с Kubernetes, ни с аналогами я дела не имел.
Казалось бы, всё идёт хорошо, но пушной полярный лис подкрался к нам с неожиданного направления. По разным причинам буквально за два месяца все три старых куберовца покидают проект. Вот так нежданно-негаданно в начале 2020 года команда Кубера осталась без людей, которые создавали этот сервис.
На какое-то время о развитии пришлось забыть. Мы забрали в команду ещё одного перспективного сотрудника, но экспертизы катастрофически не хватало. Втроём мы с трудом успевали решать текущие проблемы в довольно сыром сервисе.
### Проблемы с Consul Connect
Особенно много проблем доставлял Consul Connect, который постоянно терял связность между своими «дата-центрами» (не нашими физическими дата-центрами, а внутренними логическими сущностями Консула).
Проблемы с Consul Connect, вероятно из-за недостатка экспертизыКаждый кластер куба был отдельным «дата-центром» и отваливался от основного ДЦ по любому чиху. Следствием была потеря связности между приложением Node.js внутри кластера и компонентами снаружи. Очень подозреваю, что мы просто не сумели правильно приготовить connect, экспертизы по Consul у нас на тот момент было ещё меньше, чем по Куберу.
В конечном итоге спустя месяц терзаний мы вернули Node.js-приложение на наши стандартные LXD-рельсы, выпилили Consul Connect, более-менее стабилизировали работу кластеров куба и задумались над новой архитектурой кластеров.
### Кубер v3
Поскольку у предыдущей архитектуры оказался фатальный недостаток, надо было придумать на её основе что-то новое, но без коннекта. И тут совпали два события. Во-первых, я изучил возможности сетевого плагина Calico в плане обмена сетевыми маршрутами к подам через BGP и получил от наших сетевиков принципиальное ОК на возможность осуществить пиринг с их оборудованием. А во-вторых, в недрах команды DevOps родился проект по созданию service discovery на основе HAProxy+Consul.
Локальный HAProxy на каждой ноде приложения и без того использовался в компании для балансировки запросов приложения к другим частям платёжной системы. Фактически на нём был построен такой прото-service mesh, управлявшийся через Ansible. Для превращения в полноценный service mesh не хватало как раз обнаружения сервисов, которое и решили сделать на основе Consul.
Из этих двух фактов родилась новая концепция архитектуры кластера, в первую очередь – сетевой архитектуры. В «новом прекрасном Кубере будущего» мы отказывались от Ingress-контроллеров, добавляли к каждому поду sidecar с Consul-агентом и направляли трафик снаружи кластера напрямую в поды приложений. Кроме sidecar с агентом, для взаимодействия с внешними относительно кластера сервисами в поды приложений добавился sidecar с HAProxy.
На сетевом уровне поды каждого приложения оказывались в своей /24 сети для возможности управления сетевыми доступами снаружи кластера. Это важное соответствие существующей инфраструктуре, так как в её основе лежит сегментация на сетевом уровне.
На реализацию этих идей в проде ушёл почти год: кластеры на новой сетевой архитектуре запустились в дев-среде в начале 2021-го. И дело не только в переходе на новый service discovery. Пандемия, локдаун и переход на удалёнку в то время имели максимальный приоритет, так что задачи по BGP-пирингу между сетевой инфраструктурой и кластерами K8s были отложены до лучших времён. Вишенкой на торте стал процесс смены названия компании в середине года, затянувший все свободные ресурсы.
За прошедший год концепция успела немного мутировать. Было решено оставить только два кластера в продакшн – по одному на ДЦ. В прошлом такое решение не было бы отказоустойчивым, поскольку входящий трафик терминировался исключительно в том же ДЦ, куда прилетал изначально. Мы решили эту проблему, и количество кластеров стало возможно уменьшить без ущерба для отказоустойчивости: при проблемах с кластером в одном ДЦ запросы полетят во второй.
К концу февраля я вывел из эксплуатации один из старых кластеров и пересоздал его на новой сетевой архитектуре. Замаячила финишная прямая...
### Внешний аудит. Внедрение Istio
И в этот момент закралась мысль, что экспертиза в готовке Кубера ограничивается исключительно нашим опытом с нашими же кластерами. Есть неиллюзорная вероятность совершить глобальный факап просто за счёт того, что мы не сталкивались n большими и серьёзно нагруженными кластерами. Чтобы уменьшить вероятность таких проблем, мы запросили аудит от компании [Флант](https://habr.com/ru/company/flant), профессионально занимающихся внедрением и поддержкой Kubernetes.
Ребята практически под микроскопом рассмотрели нашу архитектуру и процессы и показали себя настоящими профессионалами. Пользуясь случаем, хочу лично поблагодарить [@distol](/users/distol)и [@jambo](/users/jambo)за прекрасные часы в Zoom и фирменное «Сложилось!».
После полуторамесячного аудита оказалось, что с конфигурацией самого по себе куба у нас всё более-менее ОК. А вот от идеи затащить в кластер наш самопальный service mesh нам крайне настойчиво порекомендовали отказаться и использовать вместо этого Istio – популярное решение, поддерживаемое хорошим комьюнити.
Игнорировать мнение экспертов было бы глупо, к тому же Istio изящнее решал проблемы межкластерного взаимодействия. Так что с апреля закипела работа по переезду на рельсы Istio внутри кластеров Кубера.
На RnD, тесты и интеграцию с уже существующим service discovery на HAProxy+Consul ушло несколько месяцев. Поначалу была идея затащить в Istio service mesh вообще все наши сервисы как в кубе, так и снаружи, но мы встретили непреодолимые проблемы при попытке включения в mesh хостов на Windows. К тому же, само решение по добавлению в mesh внешних относительно кластера хостов было явно сыровато. И раз уж всё равно придётся изобретать механизм для связи с хостами на Windows, решили, что точно такой же механизм отлично сработает и с Linux-хостами.
### Итоговое решение
Таким образом у нас получилось два service discovery. Один снаружи куба – на Consul, другой внутри – на CoreDNS. При этом фактически у нас получился единый гибридный service mesh: приложения могут прозрачно ходить друг в друга независимо от того, где они расположены.
Вот как это устроено.
В репозитории приложения находится файл description.yml, где описаны все сервисы, к которым приложению нужен доступ. В очень сокращённом виде он выглядит так:
```
application:
name: app-name
endpoints:
- name: endpoint-name
app: other-app
port:
prod: https
```
Внутри кластера K8s:
* Поды CoreDNS мы расположили на мастерах и настроили на них hostNetwork. Так DNS кластера оказался доступен снаружи.
* Для приложений, работающих в кластере, создаём [Headless-сервисы](https://kubernetes.io/docs/concepts/services-networking/service/#headless-services) в дополнение к обычным ClusterIP, чтобы иметь возможность получать IP-адреса подов по DNS.
* Каждое приложение в кластере K8s живёт в собственном namespace.
* Если у приложения в description.yml указаны внешние относительно кластера сервисы, при деплое такого приложения в его namespace создаются [ServiceEntry](https://istio.io/latest/docs/reference/config/networking/service-entry/), endpoint’ы для которых берутся из Consul и выглядят примерно так:
```
apiVersion: networking.istio.io/v1beta1
kind: ServiceEntry
metadata:
name: entry-name
namespace: app-namespace
spec:
endpoints:
- address: port-name.app-name.service.consul.domain
exportTo:
- .
hosts:
- app-name.virtual-namespace.svc
location: MESH_EXTERNAL
ports:
- name: https-app-name
number: 1234
protocol: HTTPS
resolution: DNS
```
Имя хоста для ServiceEntry внешних сервисов задаётся такое же, как если бы они были внутри кластера: `service.namespace.svc`. Когда (если) этот сервис переедет в Кубер, достаточно будет удалить ServiceEntry, чтобы перенаправить трафик.
Для приложений, живущих в LXC/LXD-контейнерах или виртуалках:
* на хосте устанавливается Consul agent, который регистрирует его в консуле и делает частью service mesh,
* также устанавливается HAProxy
* при деплое приложения для HAProxy генерируется конфигурация, исходя из значений в description.yml,
* HAProxy динамически отслеживает изменения благодаря использованию директивы server-template.
```
listen app_name_port_name
bind 127.0.0.1:1234 tfo
mode tcp
option tcp-check
default-server inter 2000 fall 2 rise 2
server-template app-name-port-name-active 32 _app-name._port-name.service.dc1.consul.domain check init-addr none
server-template app-name-port-name-backup 32 _app-name._port-name.service.dc2.consul.domain check init-addr none backup
server-template k8s-app-name-port-name-active 10 _port-name._tcp.headless-service.namespace.svc.cluster-in-same-dc.domain check resolve-opts init-addr none
server-template k8s-app-name-port-name-backup 10 _port-name._tcp.headless-service.namespace.svc.cluster-in-other-dc.domain check resolve-opts init-addr none backup
```
На Nginx+ балансировщиках для приложений, живущих в Kubernetes, поднимаются апстримы, смотрящие на SRV-записи в DNS кластеров куба, примерно такого вида:
```
upstream k8s-app-name-http {
...
server headless-service.namespace.svc.cluster-in-same-dc.domain max_fails=0 fail_timeout=10s service=_port-name._tcp resolve;
server headless-service.namespace.svc.cluster-in-other-dc.domain max_fails=0 fail_timeout=10s service=_port-name._tcp resolve backup;
}
```
Итого в августе 2021-го наконец-то была окончательно закончена разработка архитектуры кластера. А в сентябре приложения, уже жившие в K8s, переехали из старых кластеров в новые. Сегодня из LXC в кластер куба наконец-то начали переезжать компоненты на Java.
В конце концов Кубер в ЮMoney стал выглядеть так:
Архитектура кластера сейчас### Выводы
Таким образом, на то, чтобы довести сервис Kubernetes до продакшн-уровня у нас ушло порядка двух лет. Это цена, которую пришлось заплатить за безболезненный перенос приложений из легаси-инфраструктуры, за органичное встраивание Кубера в существующую систему. Насколько такой подход оправдан, каждая компания должна решать сама.
Возможно, в других случаях было бы эффективнее развернуть новую инфраструктуру на K8s с нуля, но на наших объёмах это почти невозможно. Поэтому мы вложились в то, чтобы предусмотреть все нюансы взаимодействий существующих приложений и подготовку рабочих механизмов, вместо того, чтобы поднять новый красивый Кубер с дефолтными настройками и сказать разработке: «Заезжайте!»
Сейчас мы на пороге великой миграции из LXC в Kubernetes. Ждите продолжения через год-другой. | https://habr.com/ru/post/590653/ | null | ru | null |
# Исследование защиты программы TurboLaunch 5.1.3
#### Простая защита или ломаем TurboLaunch 5.1.3 тремя способами (патч, сниффер, кейген).
**Цель**: TurboLaunch 5.1.3
**Инструменты**: OllyDbg 1.10, Dup2 (для создания патча), плагин CodeRipper для OllyDbg, Delphi 7 (для написания кейгена)
Был скучный вечер, я искал программу, которую хотелось бы «поковырять». Сначала правкой одного байта убрал триал у AWBackuper 4.0, это показалось очень не интересно, затем я вспомнил о программке, которая давно (года 4) стоит у меня на компьютере – это TurboLaunch от Savard Software. К ней существуют кейгены (наверное, около 10), но, ни в одном я не увидел одного маленького нюанса (хотя по большому счету он не практически не играет существенной роли), но о нем чуть позже.
И так, let’s begin…
##### Патчинг
Первым способом я выбрал патчинг, так как для новичков он является самым простым.
Грузим жертву в OllyDbg (дальше просто оля, olly). Запускаем и видим наг-окно, нажимаем «Enter My Registration Code»
Вводим свое имя (DimitarSerg) и «честно купленный» код 1234567890
Очень странно, но видим вот такое сообщение:
Поищем текст сообщения в текстовых строках. ПКМ-> Search for -> All referenced text strings.
Находим:
Чуть выше видим *Jump from 00529CD3*, то есть пришли мы оттуда.
Отлично, посмотрим, что там у нас:
«Классика»:
`CALL TurboLau.0053AEB0
TEST AL,AL
JE @TurboLau_00529D99`
Значит, идет проверка и в соответствии с результатом проверки прыжок.
Чуть ниже вот такие строки:
`00529D1A |. BA F49D5200 MOV EDX,TurboLau.00529DF4 ; ASCII "REGISTERED TO: "`
И такое:
`00529D3B |. 68 0C9E5200 PUSH TurboLau.00529E0C ; ASCII "Thank you for registering! Be sure to check out our web site for updated versions of TurboLaunch and other programs written by "`
Ну что же, тогда заглянем в 00529CCC |. E8 DF110100 CALL TurboLau.0053AEB0
там еще один колл, а внутри что-то похожее на процедуру регистрации. Ну и зачем нам процедура проверки, если можно обойтись и без нее ?!
И так в начало процедуры регистрации по адресу 540628 делаем «классический» патч
`xor eax,eax // обнуляем EAX
inc eax // EAX = EAX +1
Retn // return`
Сохраняем изменения. ПКМ-> Copy to executable -> All modifications -> Save file.
Сохраним его под новым именем, например, TurboLaunch1.exe
Хотим радоваться, но получаем в ответ такое:
Ай-ай-ай. Проверка целостности. Ну и Бог с ней:
Перегружаем программу в отладчике, затем ставим breakpoint на вызов функции **MessageBoxA**
`bp MessageBoxA`
В окне «Call Stack of main thread» смотрим, откуда пришли:
Делаем ПКМ-> Show Call и оказываемся по адресу
`00450CA4 |. E8 8F75FBFF CALL ; \MessageBoxA`
Листаем выше и видим:
`00450C7B |> \84DB TEST BL,BL
00450C7D |. 74 60 JE SHORT TurboLau.00450CDF`
Опять проверка.
Меняем условный переход на безусловный (JE –> JMP), сохраняем изменения и стартуем. Ура, программа запускается.
Окна с просьбой купить больше не наблюдаем, в окне About видим «Registered to».
В общем, на кого-то зарегистрировано, вот и хорошо.
Сделать патч в Dup2 или uPPP не является проблемой.
##### Поиск серийного номера.
Как вы заметили выше, сообщение о правильном/неправильном серийном номере формируется в зависимости от результата
`00529CD1 |. 84C0 TEST AL,AL`
А строкой выше видим:
`00529CCC |. E8 DF110100 CALL TurboLau.0053AEB0`
Логично, что вся процедура генерации проходит здесь…
Смотрим:
`0053AEB0 /$ 8B90 68010000 MOV EDX,DWORD PTR DS:[EAX+168]
0053AEB6 |. 8B80 64010000 MOV EAX,DWORD PTR DS:[EAX+164]
0053AEBC |. E8 67570000 CALL TurboLau.00540628
0053AEC1 \. C3 RETN`
Ставим breakpoint по адресу 0053AEB0 и при вводе имени / регистрационного номера останавливаемся здесь и видим, что происходит считывание введенных данных, а значит, самое интересное находится в CALL TurboLau.00540628.
Трассируем по F7, видим считывание, какие-то превращения, другие операции и т.д. и т.п., в результате, если уделить этой процедуре пару минут внимания и терпения, то во время выполнения инструкции
`00540758 |. 8B45 F4 MOV EAX,DWORD PTR SS:[EBP-C]`
Мы увидим:
Stack SS:[0012F1AC]=00C66E8C, (ASCII «D1F74F-5L3GRT-3WDULJ»)
Хм, неужели правильный серийный номер ?! Пробуем: имя DimitarSerg и серийный номер D1F74F-5L3GRT-3WDULJ, программа поздравляет нас с приобретением.
Так как серийный номер виден в открытом виде, то сериал сниффер пишется на ура, нужно только посмотреть в регистр EAX по адресу, который идет сразу за 00540758, то есть 0054075B.
Я не буду описывать методику написания сериал сниффера, но скажу, что у команды AT4RE есть такой инструмент, как Serial Sniffer Creator, можете воспользоваться им, должно выглядеть приблизительно вот так:
Но я ее не рекомендую, так как она не сниффает серийники в юникоде и у нее частые глюки с интерфейсом.
На паблике есть несколько примеров (темплейтов) по созданию снифферов, поэтому ассемблер или Delphi в руки и вперед «допиливать».
##### Кейген
Ну и самое интересное — это, конечно же, написание кейгена.
Как я описывал выше, вся процедура генерации начинается по адресу 00540628
Вводим любые данные регистрации, трассируем. Обращаем внимание на вот это место:
Заглянем в этот колл. Видим некоторые операции, выполняемые над именем, вычисления. Скажу наперед, что здесь происходит первая часть вычислений, результат которых используется чуть-чуть позже. Я не «великий спец» по ассемблеру, поэтому использую плагин CodeRipper.
Я покажу два способа кейгена: инлайн ассемблерного кода на Делфи и полностью переведенный код на паскаль:
> `Copy Source | Copy HTML1. procedure GenClick( Dummy : Pointer; Sender: PControl );
> 2. var NameBuffer,SerNum:String;
> 3. len,sn\_tmp:integer;
> 4. begin
> 5. if Nm.Text<>'' then begin
> 6. NameBuffer:=Nm.Text;
> 7. len:=Length(Nm.Text);
> 8. ASM
> 9. PUSHAD
> 10. mov ECX,NameBuffer
> 11. mov EBX,len
> 12. @TurboLau\_0053F42E:
> 13. XOR EAX,EAX
> 14. MOV AL,BYTE PTR DS:[ECX]
> 15. SHL EAX,8
> 16. XOR EDX,EAX
> 17. MOV EAX,8
> 18. @TurboLau\_0053F43C:
> 19. TEST DH,080h
> 20. JE @TurboLau\_0053F44B
> 21. ADD EDX,EDX
> 22. XOR EDX,01021h
> 23. JMP @TurboLau\_0053F44D
> 24. @TurboLau\_0053F44B:
> 25. ADD EDX,EDX
> 26. @TurboLau\_0053F44D:
> 27. DEC EAX
> 28. JNZ @TurboLau\_0053F43C
> 29. INC ECX
> 30. DEC EBX
> 31. JNZ @TurboLau\_0053F42E
> 32. MOV EAX,EDX
> 33. AND EAX,0FFFFh
> 34. mov sn\_tmp,EAX
> 35. POPAD
> 36. END;
> 37. Edit.text:=Int2Hex((sn\_tmp),4);
> 38. end
> 39. else
> 40. Edit.Text:='Enter Your Name';
> 41. End;`
Зачем я привел процедуру отдельно? Мне так было легче, сразу видно правильность работы рипнутого кода. Например, для имени DimitarSerg sn\_tmp = E330
Ну а дальше опять дело техники: используем плагин CodeRipper, начиная с адреса 5406BC до 540752 (видим, что это большой цикл генерации). На что хочу обратить внимание – это на некоторые коллы. CodeRipper пишет “;<= Jump/Call Address Not Resolved”, большинство из них не нужны и их можно удалить, но вот
005406EE |. E8 F52DECFF ||CALL TurboLau.004034E8
Этот колл ни в коем случае нельзя удалять, так как внутри:
> `Copy Source | Copy HTML1. @TurboLau\_004034E8:
> 2. PUSH EBX
> 3. XOR EBX,EBX
> 4. IMUL EDX,DWORD PTR DS:[EBX+0542008h],08088405h
> 5. INC EDX
> 6. MOV DWORD PTR DS:[EBX+0542008h],EDX
> 7. MUL EDX
> 8. MOV EAX,EDX
> 9. POP EBX
> 10. RETN`
Это, как мне подсказали (на тот момент не знал), что это стандартный Random, а DWORD PTR DS:[EBX+0542008h] (он же у меня sn\_tmp) – это RandomSeed.
А в рипнутом коде уже не вызывать ее как отдельную процедуру, а просто скопипастить в место ее вызова, вот фрагмент:
> `Copy Source | Copy HTML1. @TurboLau\_005406E9:
> 2. MOV EAX,021h
> 3. // -->CALL @TurboLau\_004034E8 ;<= Jump/Call Address Not Resolved
> 4. // содержимое колла
> 5. PUSH EBX
> 6. XOR EBX,EBX
> 7. IMUL EDX,sn\_tmp,08088405h
> 8. INC EDX
> 9. MOV sn\_tmp,EDX
> 10. MUL EDX
> 11. MOV EAX,EDX
> 12. POP EBX
> 13. MOV EBX,EAX
> 14. INC EBX
> 15. MOV AL,BYTE PTR SS:[EBP-0Dh]
> 16. XOR AL,0FFh
> 17. AND EAX,0FFh
> 18. ADD EBX,EAX
> 19. DEC ESI
> 20. JNZ @TurboLau\_005406E9`
Еще хочу обратить внимание на строку
00540715 |. BA 1C085400 |MOV EDX,TurboLau.0054081C; ASCII «GF2DSA38HJKL7M4NZXCV5BY9UPT6R1EWQ40I1CP7Z7GOEPQLZ»
Ее можно назвать “ключевой”, так как от нее прямо зависит регистрационный код. В регистр edx записывается указатель на строку по адресу 0054081C.
Полный исходник кейгена на Delphi с асмовскими вставками и на чистом паскале прилагаются, ничего сложного там нет.
Ну и то, с чего я начинал рассказ: после всех этих генераций мы НЕ ОСТАНАВЛИВАЕМСЯ, а топаем дальше и видим какие-то имена/ники и т.д.
Естественно, это же примитивный блэклист:
> `Copy Source | Copy HTML1. @TurboLau\_005407C4:
> 2. MOV EAX,DWORD PTR SS:[EBP-4] ; Цикл проверки блэклиста
> 3. MOV EDX,DWORD PTR DS:[ESI]
> 4. CALL @TurboLau\_00405030
> 5. JNZ @TurboLau\_005407D4
> 6. XOR EBX,EBX
> 7. JMP @TurboLau\_005407DA
> 8. @TurboLau\_005407D4:
> 9. ADD ESI,4
> 10. DEC EDI
> 11. JNZ @TurboLau\_005407C4`
Там проскакивают такие интересные ники, как Nitrogen / TSRh TeaM, REVENGE Crew, FiGHTiNG FOR FUN, TEAM VIRILITY… и т.д. Думаю, намек вы поняли.
Итого 44 имени. Не проблема скопипастить вручную, забить в строковой массив типа
BlackList:array [0..43] of string = (…), а при генерации смотреть, не является ли желаемое вами имя в блэклисте. (файл BlackList.txt тоже прилагаю).
Для “полного счастья” переводим код с асм-вставками на паскаль:
> `Copy Source | Copy HTML1. //…
> 2. var
> 3. BlackList:array [ 0..43] of string = ('zircon / pc97','freeware','registered user',
> 'NuZ''c97','Registered','kOUGER! [CB4]','Cosmo Cramer 1997','Cosmo Cramer MJ13',
> 'MJ13 Forever','cH/Phrozen Crew','Everybody','iCEMAN [uCF]','pank','Henry Pan',
> 'iTR [CORE]','mpbaer','CORE/JES','Chen Borchang','n03l','ODIN 97','lgb/cORE''97',
> 'MCC','blastsoft','CORE/DrRhui','Vizion/CORE','TEAM ViRiLiTY','Nambulu','NuZPc97',
> 'Weazel','Phrozen Crew','TEAM VIRILITY','x3u','Reg Name','FiGHTiNG FOR FUN','RaSCaL [TMG]',
> 'Nitros^21','TEAM TSRH','ttdown.com','Nitrogen / TSRh TeaM','Free Program','REVENGE Crew',
> 'Vladimir Kasho','Alexej Melnikov','Seth W. Hinshaw');
> 4. //…
> 5. procedure generate;
> 6. Var
> 7. NameBuffer,SerNum:String;
> 8. EDX,EAX,len,i,a,b,tmp1:integer;
> 9. Textname: PChar;
> 10. begin
> 11. len := GetWindowTextLengthA(TxtNameHwnd);
> 12. if len > 1 then
> 13. begin
> 14. { Get text from name input }
> 15. GetMem(Textname, len + 1);
> 16. GetWindowTextA(TxtNameHwnd,PAnsiChar(Textname),len + 1);
> 17. { Generate Serial }
> 18. KeyStr:= 'GF2DSA38HJKL7M4NZXCV5BY9UPT6R1EWQ40I1CP';
> 19. NameBuffer:=String(Textname);
> 20. SerNum:='';
> 21. Randomize;
> 22. EDX:= 0;
> 23. for i:=1 to len do
> 24. begin
> 25. EDX := EDX xor (ord(NameBuffer[i]) shl 8);
> 26. EAX := 8;
> 27. while EAX <> 0 do
> 28. begin;
> 29. if (EDX shr 8 and $0FF) >= $80
> 30. then
> 31. EDX := EDX shl 1 xor $1021
> 32. else
> 33. EDX := EDX shl 1;
> 34. dec(EAX);
> 35. end;
> 36. end;
> 37. RandSeed := EDX and $0FFFF;
> 38. i:=1;
> 39. while i <> $13 do
> 40. begin
> 41. a := 0;
> 42. b := $13 - i;
> 43. if b > 0 then
> 44. begin
> 45. while b > 0 do
> 46. begin
> 47. a:=Random(33);
> 48. inc(a);
> 49. if i > len then
> 50. tmp1:=ord(NameBuffer[i mod len])
> 51. else
> 52. tmp1:=ord(NameBuffer[i]);
> 53. tmp1:=tmp1 xor $0FF and $0FF;
> 54. a := a + tmp1;
> 55. dec(b);
> 56. end;
> 57. end;
> 58. while a > $21 do
> 59. begin
> 60. a := a - $21;
> 61. end;
> 62. SerNum := SerNum + KeyStr[a];
> 63. inc(i);
> 64. end;
> 65. Insert('-',SerNum,7);
> 66. Insert('-',SerNum,14);
> 67. For i:= 0 to 43 do
> 68. begin
> 69. if NameBuffer = BlackList[i] then
> 70. begin
> 71. SerNum:='BLACKLISTED NAME';
> 72. Break;
> 73. end else ;
> 74. end;
> 75. { Display The Results }
> 76. SetWindowTextA(TxtSerialHwnd,PChar(SerNum));
> 77. FreeMem (Textname, len + 1);
> 78. end
> 79. Else
> 80. { Display Error }
> 81. SetWindowText(TxtSerialHwnd,'Not Enough Characters..');
> 82. end;`
В результате у меня получился вот такой вот кейген:
Размер 36,5 Кб (неупакованный).Такой маленький размер кейгена достигается за счет использование KOL (Key Objects Library) – библиотеки для Delphi.Можно еще сделать и с использованием WinApi, вклеить свое лого, добавить xm / v2m трек (так я для публичного кейгена и сделал), но мой совет – не используйте VCL, если пишете кейгены на Delphi… 400кб и больше – это не размер для кейгена!
Кому больше нравится чистый ассемблер – Masm (Fasm, Tasm) в руки.
На этом мой рассказ подходит к концу, надеюсь, кто-то что-нибудь да почерпнет для себя из данной статьи. | https://habr.com/ru/post/132843/ | null | ru | null |
# Переадресация для Asterisk
Переадресация- штука интересная и количество сценариев переадресации звонка очень много.
В случае описываемом мной переадресация выполняется безусловно и включатеся по желанию абонента (вообще данный пример очень просто перделывется в условную переадресацию и если дойдут руки я постараюсь раскрыть эту тему), но все осложняется тем, что сервер на котором регистрируется Asterisk с выходом в город не умеет обрабатывать SIP сообщение 302-Moved Temporarily (Используется SIP канал, но диалплан может быть применен и к другим технологиям). Недостаток метода который я опишу здесь в том, что потребуется 2 Trunk'а или 1, но многоканальный (<2 канала). Метод использует собственную базу данных Asterisk [astDB](http://astbook.asteriskdocs.org/en/2nd_Edition/asterisk-book-html-chunk/asterisk-CHP-6-SECT-6.html), поэтому советую прочитать об этом, поскольку подробно останавливаться на этом моменте я не буду.
И так приступим: вот весь кусок диалплана, который отвечает за переадресацию вызова:
**`exten => #21,1,Set(DB(REDIRECT/${CALLERID(num)})=${EXTEN})
exten => #21#,1,Set(NOREDIRNUM=${DB_DELETE(REDIRECT/${CALLERID(num)})})
exten => s,1,Set(REDIRECTNUM=${DB(REDIRECT/${EXTEN})})
exten => s,n,GotoIf($[${ISNULL(${REDIRECTNUM})}]?internal:redirect)
exten => s,n(internal),Dial(SIP/${EXTEN})
exten => s,n(redirect),Dial(SIP/TRUNK/${REDIRECTNUM})`**
Теперь давайте разберем по частям, что за чем идет и что за что отвечает.
Как я уже сказал, переадресация выполняется по желанию клиента. То есть для того, чтобы использовать переадресацию нужно ее включить:
**`exten => #21,1,Set(DB(REDIRECT/${CALLERID(num)})=${EXTEN})`**
Эта команда запоминает набранный номер, и номер с которого он был набран, и сохраняет в базе данных Asterisk.
Здесь после набора комбинации #21 нужно донабрать номер для переадресации. Я помещаю в семейство REDIRECT набранный номер ${EXTEN}, который будет доступен по ключу ${CALLERID(num)}. То есть, проще говоря введенный номер будет храниться в таблице REDIRECT в строке ${CALLERID(num)} или доступен по адресу REDIRECT/${CALLERID(num)} базы данныx Asterisk (Команда DB). Переменная ${CALLERID(num)} хранит в себе номер, с которого присходит вызов.
Выключение переадресации происходит подобным образом:
**`exten => #21#,1,Set(NOREDIRNUM=${DB_DELETE(REDIRECT/${CALLERID(num)})})`**
Абонент, набирая комбинацию #21# с помощью утилиты DB\_DELETE очищает ячейку REDIRECT/${CALLERID(num)}
Здесь я использовал переменную NOREDIRNUM чтобы просто выпонить какие-либо действия с через Set() потому как она ругалась на отсутсвие знака "=". Но вообще можно попробывать и так:
**`exten => #21#,1,Set(DB_DELETE(REDIRECT/${CALLERID(num)}))`**
Следующие несколько строк занимаются как раз самым основным — реализацией вызова. Давайте рассмотрим их подробнее:
**`exten => s,1,Set(REDIRECTNUM=${DB(REDIRECT/${EXTEN})})`**
Данная строка извлекаем содержимое ячейки REDIRECT/${EXTEN} (номер переадрисации) и присваивает ее значение переменной REDIRECTNUM, для того чтобы проверить задан ли вообще номер переадрисации для данного абонента. То есть если, скажем мы звоним абоненту по номеру 100, то данная команда присваевает значение ячейки REDIRECT/100 переменной REDIRECTNUM.
**`exten => s,n,GotoIf($[${ISNULL(${REDIRECTNUM})}]?internal:redirect)`**
Далее производится проверка существования номера перадресации: Если переменная REDIRECTNUM ISNULL (пуста/неопределена) то мы переходим к строке с меткой internal и вызываем абонента по его основному номеру:
**`exten => s,n(internal),Dial(SIP/${EXTEN})`**
Если же переменная REDIRECTNUM не пуста, то вызываем номер, указанный в ней.
**`exten => s,n(redirect),Dial(SIP/TRUNK/${REDIRECTNUM})`**
Надеюсь кому-нибудь это поможет в освоении просторов Asterisk. | https://habr.com/ru/post/139178/ | null | ru | null |
# Выводим ноды на Google Maps
Предположим, что у нас есть достаточно простая задача — показывать на карте местоположение объектов (нод, пользователей). Например, [офисов](http://show.giftcentral.ru/offices), или, скажем, [магазинов подарков](http://giftcentral.ru/shop). Т.е. мы должны получить страницу, где выводится карта с расположением всех объектов заданного типа, и показать карту на странице каждого отдельного объекта. Речь пойдет о 6-ой версии [Друпала](http://drupal.org/), но в 5-ке всё аналогично (если честно, скрин в конце снят именно с Drupal 5). Чтобы выполнить эту задачу [я](http://www.b2blog.ru) буду использовать следующие модули: [GMAP](http://drupal.org/project/gmap), [Location](http://drupal.org/project/location), [Views](http://drupal.org/project/views) (на сайте [у меня](http://www.ajaxplanet.ru) используются еще и [CCK](http://drupal.org/project/cck) & [Contemplate](http://drupal.org/project/contemplate), но они в этой задаче настолько вспомогательны, что говорить о них не стоит). Итак, качаем-включаем. Для нормальной работы GMAP нам потребуется [получить у гугла Google Maps API Key](http://code.google.com/intl/ru/apis/maps/signup.html). Дело это бесплатное и быстрое. Полученный ключ вводим в настройках GMAP, затем выставляем настройки для карты. Cледом нам придется настраивать модуль Location (он же Местанахождение… долго искал)
Главное, что нас тут должно волновать — страна и галка "Use a Google Map to set latitude and longitude "Что ж, теперь разрешим использование геолокации для наших материалов. Итак, у меня уже есть тип материала "Офис", записи в котором я и буду выводить на карту:Выше я указал, что для каждой записи может быть только один адрес, задал город и страну по умолчанию. Осталось совсем немного: создадим карту, где будут показываться все объекты и выведем карту на странице самого объекта.Вывод общей карты делаем через View:Главное здесь — Стиль: Gmap. Ну и список полей с фильтром… Теперь осталось показать карту на странице самого офиса. Тут придется малость влезть в код. Итак, в шаблон для этого типа материалов я добавил следующую конструкцию:`php print gmap_simple_map($node-locations[0]['latitude'], $node->locations[0]['longitude'], '', '**'.$node->locations[0]['name'].'**
'.$node->locations[0]['street'], 15, '650px', '400px', FALSE,''); ?>`Т.е. вывожу карту размером 650х400 пикселей, показываю на ней маркер, в окошке с описанием пишу название ноды и адрес. Вот, собственно, и всё… Попробуем в действии? Добавим запись и проставим там местоположение:
Посмотрим, как выглядит карта на странице объекта:А вот так выглядит страница со списком объектов. Пока, их, правда, только 2, так что не слишком впечатляет:Впрочем, можно показать, скажем, [список магазинов подарков в Петербурге](http://giftcentral.ru/shop) или [местоположение львиных статуй в Питере](http://www.ride.spb.ru/map/node):[](http://giftcentral.ru/shop) | https://habr.com/ru/post/56505/ | null | ru | null |
# Нормализация запросов в Директе или немного о подводных камнях в подборе слов
Коллеги очень часто просят меня писать побольше о подводных камнях и различных секретах Яндекс.Директ. В этой заметке я расскажу о подводном камне №1 — нормализации или склейке запросов.
Итак, есть клиент РК в тематике авиабилеты. Тематика очень широкая, огромное количество трафика. Есть задача «показываться любому кто ищет любую информацию о любом направлении, доступном для авиаперелета, цена перехода должна быть минимально возможной — 30 копеек». Ок, задача понятна, настраиваем ([здесь](http://habrahabr.ru/blogs/context/103791/) — подробнее о том как настраивать одноцентовые РК).
Первичный медиаплан показал очень неожиданную картину. Вот фрагмент скриншота из «Оценки бюджета»
Статистика показов дает нам информацию о том что весьма непопулярное у туристов направление в столицу Индии запрашивается в 4-8 раз чаще чем популярные направления в Европу. Но это же бред какой-то! (с)
Смотрим семантическое ядро запроса «Москва Дели» и очень удивляемся.
В семантическом ядре явно видим что слова «Дели» (столица Индии) и «День» (промежуток времени суток) Яндекс считает одинаковыми и склеивает их в один запрос. Также как склеивает например единственные и множественные формы слова («купить авиабилет» и «купить авиабилеты» — Директ считает одним запросом, пока рекламодатель принудительно не закрепит словоформу с помощью соответствующего оператора).
Сообщаю саппорту Директа о таком странном поведении вордстата, получаю ожидаемый ответ. Это работает механизм нормализации.
`"Указанные Вами случаи относятся к так называемой нормализации, когда слова могут обозначать разные части речи.
Например, "день" и "дели" - это формы глагола "деть", поэтому показываются казалось бы совершенно разные словосочетания."`
Принудительно закрепляем словоформу «Дели» с помощью оператора (!) и получаем вполне адекватный прогноз — 776 показов в месяц целевой аудитории. Что вполнее соответсвует спросу интернет-аудитории на это направление.
Таким образом, благодаря общей сложности лингвистического аппарата русского языка и недостаточной интеллектуальности вордстата в понимании природы запросов — можем получить аналогичную картину в любой тематике:
Например при рекламе
а) по запросу «Москва — Киев» объявление показывается в том числе и абсолютно нецелевой аудитории — тем кто хочет «купить бильярдный кий в Москве». Слово «Киев» для яндекса лишь множественная форма запроса «кий»(бильярдный).
б) по запросу «ремонт полов». При покупке такого запроса объявление показывается тем кто ищет «ремонт часов Полет».
в) по запросу «купить %название продукта%» объявление показывается всем тем кто ищет «куплю %название продукта%», т.е не клиентам, а прямым конкурентам. Их менеджеры по продажам регулряно сканируют форумы и доски объявлений в поисках покупателей на %название продукта% именно с помощью такого запроса
и т.д. Случаи когда благодаря такого рода склейке запросов можно получить показы нецелевой аудитории довольно часты.
Отсюда два вывода.
1) Во всех сомнительных случаях смотрим семантическое ядро запроса на предмет склейки «нашего» запроса с «ненашими» запросами.
2) Во всех сомнительных случаях используем оператор закрепления словоформы (!)
Будьте внимательны и удачных продаж! | https://habr.com/ru/post/118580/ | null | ru | null |
# Как использовать Mongoose-схему для генерации graphQL-типов
В данной статье я расскажу вам как исходя из своего опыта я написал небольшой npm-модуль, который помог мне и, думаю, может помочь вам сэкономить приличное количество времени и сократить код практически в два раза.
Все начал с того что я решил написать изоморфный CMS для одного из моих проектов с использованием следующих технологий:
* **React** — для постройки UI
* **Express** — в качестве сервера
* **MongoDb + Mongoose** — noSQL база данных
* **graphQL** — основной API для взаимодействия с базой данных
* **Apollo-Client** — коннектор для удобного вызова запросов и мутаций через graphQL
* **webpack** — для сборки проекта и разделения клиентского и серверного кода
Упрощенная архитектура выглядит следующим образом:
```
__root
1 |__client
2 |__public
3 |__middleware
4 |__server
```
1. React-компоненты
2. Бандл клиентского кода и остальные публичные файлы
3. Mongoose: схемы, дополнительные методы и graphQL: типы, класс с запросами, класс с мутациями, схема
4. Бандл серверного кода вместе с express сервером
Соответственно, для каждой сущности в базе данных мы должны создать Mongoose-схему, чтобы иметь возможность манипулировать данными. Выглядит это примерно следующим образом:
```
let couponSchema = mongoose.Schema({
couponCode: Array,
description: String,
discountAmount: String,
minimumAmount: String,
singleUseOnly: Boolean,
createdAt: mongoose.Schema.Types.Date,
updatedAt: mongoose.Schema.Types.Date,
expirationDate: mongoose.Schema.Types.Date
});
```
Теперь если мы используем graphQL мы должны создать тип для каждой сущности в базе данных, причем тип каждого свойства должен быть идентичен тому же, что и в Mongoose схеме. Без graphQL-типов мы просто не сможем сгенерировать graphQL-схему. Тип выглядит следующим образом:
```
let couponType = new GraphQLObjectType({
name: 'couponType',
description: 'single use coupon',
fields: {
_id: {type: GraphQLString},
couponCode: {type: new GraphQLList(GraphQLString)},
description: {type: GraphQLString},
discountAmount: {type: GraphQLString},
minimumAmount: {type: GraphQLString},
singleUseOnly: {type: GraphQLBoolean},
createdAt: {type: GraphQLString},
updatedAt: {type: GraphQLString},
expirationDate: {type: GraphQLString}
}
});
```
Думаю, схожесть очевидна? А теперь представьте, что вы имеете несколько десятков сущностей и для каждой из них вам нужно практически дублировать одну и ту же логику. А ведь типы могут содержать массивы других типов и множество других вложенных элементов.
Собственно, для разрешения этой проблемы я написал небольшой модуль (всего 3kb), который поможет избежать дублирования логически идентичного кода и практически сократит вдвое ваш код, в моем случае я сократил код более чем на 2000 строк.
Для начала установим модуль:
```
npm i mongoose-schema-to-graphql --save
```
Модуль содержит одну единственную функцию “MTGQL”, которая принимает один объект с конфигурациями в качестве аргумента. Объект имеет следующую структуру:
```
let configs = {
name: 'couponType',
// название graphQL типа
description: 'Coupon base schema',
// описание graphQL типа
class: 'GraphQLObjectType',
// graphQL класс который будет использован для сборки
schema: couponSchema,
// Mongoose схема
exclude: ['_id'],
// свойства которые нужно исключить
props: {
price: {type: GraphQLFloat}
}
// дополнительные свойства которые нужно добавить или переписать
}
```
Пару примеров использования модуля ниже:
**dbSchema.js**
```
import mongoose from 'mongoose';
let selectObj = {
value: String,
label: String
};
let answerSchema = mongoose.Schema({
createdAt: mongoose.Schema.Types.Date,
updatedAt: mongoose.Schema.Types.Date,
title: String,
answersImage: String,
recommended: [selectObj],
isPublished: Boolean
});
export let questionSchema = mongoose.Schema({
question: String,
defRecommended: [selectObj],
createdAt: mongoose.Schema.Types.Date,
updatedAt: mongoose.Schema.Types.Date,
isPublished: Boolean,
multipleChoice: Boolean,
answers: [answerSchema]
});
```
В файле с вашими graphQL типами:
**type.js**
```
import MTGQL from 'mongoose-schema-to-graphql';
import {questionSchema} from './dbSchemas';
let config = {
name: 'questionType',
description: 'Question collection\'s type',
class: 'GraphQLObjectType',
schema: questionSchema,
exclude: ['_id']
};
export let questionType = MTGQL(config);
```
Собственно всего 10 строк кода, которые равносильны следующему:
```
import {
GraphQLObjectType,
GraphQLString,
GraphQLBoolean,
GraphQLList,
GraphQLInt
} from 'graphql';
let selectType = new GraphQLObjectType({
name: 'selectType',
fields: {
value: {type: GraphQLString},
label: {type: GraphQLString}
}
});
let answerType = new GraphQLObjectType({
name: 'answerType',
description: 'answer type for question',
fields: {
title: {type: GraphQLString},
answersImage: {type: GraphQLString},
recommended: {type: new GraphQLList(selectType)},
createdAt: {type: GraphQLString},
updatedAt: {type: GraphQLString},
isPublished: {type: GraphQLBoolean}
}
});
export let questionType = new GraphQLObjectType({
name: 'questionType',
description: 'Question collection\'s type',
fields: {
question: {type: GraphQLString},
defRecommended: {type: new GraphQLList(selectType)},
createdAt: {type: GraphQLString},
updatedAt: {type: GraphQLString},
isPublished: {type: GraphQLBoolean},
multipleChoice: {type: GraphQLBoolean},
answers: {type: new GraphQLList(answerType)}
}
});
```
Думаю, разница очевидна. Модуль не поддерживает напрямую “GraphQLFloat”, потому что в Mongoose схеме вы можете задать только тип «Number», который эквивалентен целому числу. Но эту проблему можно легко решить, передав нужное свойство через конфигурационный объект.
Более подробно о том, как работает модуль, вы можете посмотреть на [GitHub](https://github.com/sarkistlt/mongoose-schema-to-graphql).
Надеюсь, статья была вам полезна, если у вас есть какие-то предложения по улучшению, пишите, обязательно учту. Спасибо за внимание.
Оригинал статьи находится на [medium.com](https://medium.com/@sarkis.tlt/how-to-use-mongoose-schema-to-generate-graphql-type-ada63a89915#.90mrkwcgw). | https://habr.com/ru/post/310820/ | null | ru | null |
# Nullable reference types в Unity простыми словами
С выходом Unity 2021 LTS в полной степени стал доступен Nullable reference types. Коротко расскажу о том, как включить поддержку Nullables в Unity, и с какими проблемами вы можете встретиться.
Коротко о Nullable reference types
----------------------------------
Если вы уже знакомы с данной концепцией, то можете сразу перейти к разделу “[Как включить Null reference type в проекте Unity](#howtoenable)”.
Nullable reference types позволяет четко определять какие переменные ссылочного типа могут принимать значения null, а какие — нет. И еще на стадии написания кода находить уязвимые места, которые могу приводить Null reference exception.
```
public class Person
{
private string _name;
private string? _occupation;
}
```
В этом примере переменная поле \_name всегда должна иметь значение. В свою очередь для \_occupation допускается значение null. Уже в этом примере возникнет предупреждение, с указанием на то, что объект Person может быть создан с пустым полем \_name. Действительно, при таком раскладе \_name обязательно должен заполняться в конструкторе.
```
public class Person
{
private string _name;
private string? _occupation;
public Person(string name)
{
_name = name;
}
}
```
Или даже так.
```
public class Person
{
private readonly string _name;
private string? _occupation;
public Person(string name, string? occupation)
{
_name = name;
_occupation = occupation;
}
}
```
Это особенно полезно при тесной работе в команде. Коллега, создавая объект, сразу из конструктора поймёт поведение класса. Также мы можем более точно определять контракт интерфейса.
```
public interface IPerson
{
string Name { get; }
string? Occupation { get; }
}
```
Реализуя данный интерфейс, получим такой класс
```
public class Person : IPerson
{
public string Name { get; }
public string? Occupation { get; private set; }
public Person(string name, string? occupation)
{
Name = name;
Occupation = occupation;
}
}
```
В ходе разработки кода использующий этот класс IDE будет всячески указывать на места, которые могут нарушать заданную логику. Приведу пример работы с этим классом.
```
public class People
{
private readonly Dictionary \_persons;
public People(Dictionary persons)
{
\_persons = persons;
}
public string GetOccupationByName(string name)
{
if (\_persons.TryGetValue(name, out var person))
{
return person.Occupation;
}
return null;
}
}
```
Тут мы получим сразу два предупреждения. Мы утверждаем, что метод GetOccupationByName() возвращает string, без возможного null. Но при этом возвращаем null в конце, а так же возвращаем person.Occupation, где уже Occupation может быть null. Задаваемые же нами правила заставляют нас писать код более корректно. Либо указать, что GetOccupationByName() возвращает string?, либо, к примеру, ввести метод TryGetOccupationByName.
```
public bool TryGetOccupationByName(
string name,
[MaybeNullWhen(false)] out string occupation)
{
if (_persons.TryGetValue(name, out var person))
{
occupation = person.Occupation;
return occupation is not null;
}
occupation = null;
return false;
}
```
Думаю, вы обратили внимание на атрибут MaybeNullWhen(bool). Интуитивно понятно, что он позволяет указывать для occupation null, при результате false.
Как включить Null reference type в проекте Unity
------------------------------------------------
Конечно, мы всегда можем управлять доступностью Nullable reference type в конкретном месте через директивы #nullable enable, disable или restore. Но как включить эту опцию для всего проекта Unity по умолчанию?
На данный момент нет возможности это сделать напрямую через настройки в Assembly Definition в самом Unity или через настройки проекта в IDE.
Чтобы включить Nullable reference types для всего проекта Unity расположите файл Directory.Build.props в корневой папке. Содержимое должно быть таким.
```
enable
```
Для регулирования отдельных сборок разместите файл csc.rsp с текстом ‘-nullable:enable’ рядом с файлом сборки.
Если вы используете Visual Studio, не должно возникнуть никаких проблем. Для Rider от JetBrains проверьте ваши настройки MSBuild. Откройте настройки File -> Settings. Найдите там раздел “Build, Execution, Deployment” -> “Toolset and Build”, пункт “MSBuild version”. Версия MSBuild должна быть достаточно свежая. У меня с 17.0 все работает.
Сериализуемые поля в MonoBehaviour и ScriptableObject
-----------------------------------------------------
Для MonoBehaviour и ScriptableObject есть возможность указываться значения некоторых полей в редакторе через инспектор. Получается, что инициализация полей через конструктор не производится. А значит будут предупреждения.
Надеюсь, эту проблему поправят в будущем. А сейчас есть два возможных решения этой проблемы. Отключать данный функционал для области объявления этих полей.
```
public class Card : MonoBehaviour
{
#nullable disable
[SerializeField] private string _description;
[SerializeField] private Sprite _icon;
#nullable restore
}
```
При это для указаных полей предупреждения перестают работать. К примеру следующий код у анализатора уже не будет вызывать никаких вопросов.
```
private void Awake()
{
_icon = null;
}
```
Поэтому советую применять второй вариант: назначать всем полям значение null!.
```
public class Card : MonoBehaviour
{
[SerializeField] private string _description = null!;
[SerializeField] private Sprite _icon = null!;
private void Awake()
{
_icon = null;
}
}
```
Здесь в методе Awake() мы уже получим предупреждение.
Стоит коротко упомянуть, из-за того, что для MonoBehaviour нельзя указывать конструкторы, в некоторых случаях в их роли выступаю обычные методы. Тут мы столкнемся с теми же самыми проблемами. Способы их решение тут точно такие же.
```
public class Cube : MonoBehaviour
{
private ICollidingService _collidingService = null!;
public void Initialize(ICollidingService collidingService)
{
_collidingService = collidingService;
}
}
```
### Отсутствие поддержки в библиотеке Unity
На мой взгляд, пока это самая большая проблема, которая может отпугнуть разработчика Unity от использования Nullable reference types. К примеру.
```
public class Card : MonoBehaviour
{
[SerializeField] private Card _parent = null!;
private void Awake()
{
_parent = transform.parent.GetComponent();
}
}
```
Очевидно, что тут мы должны получить предупреждение, т.к. GetComponent может возвращать null, т.е. T?, но это, к сожалению, пока никак не отображено в библиотеке Unity. Так же печалит факт отсутствия хоть каких либо анонсов исправления этой ситуации.
Заключение
----------
Несмотря на перечисленные проблемы в Unity, я всё же считаю, что стоит начать присматриваться к этому новому функционалу. Постепенно внедрять в свои проекты шаг за шагом. Или пока ограничиваться локальным применением в новых фичах.
Благодаря Nullable reference types код становится более последовательным и помогает избегать некоторых будущих багов. Эффект особенно заметен, если разработка сильно пересекается между программистами. К примеру, один специалист все еще пишет реализацию интерфейса, где ещё полным полно заглушек, а другой — уже использует этот класс в другом месте. При этом всё ещё не может посмотреть его конечную реализацию.
И конечно же мы ждем от Unity, Rider и Visual Studio каких-то готовых решений упомянутых проблем. | https://habr.com/ru/post/703518/ | null | ru | null |
# Django forms поле — вложенная таблица
Добрый день, хабраюзер.
Предлагаю статью с реализацией поля формы django типа «вложенная таблица», с хранением данных в XML-формате.
Это поможет интересующимся лучше разобраться с работой поля и виджета django и сделать шаг к созданию любого произвольного поля.
Если вы это и так знаете, то для вас статья может быть не интересной.
Для одного документооборота на django
нужно сделать поддержку ввода в поля документа массива структурированных элементов (таблицу).
После недельного раздумья между вариантами
— Inline formset
— Вложенные документы (такой функционал уже был)
— Пользовательски поле / виджет c сериализацией в XML/JSON
был выбран formset в XML
Inline formset был отклонен из-за существенного усложнения архитектуры:
— Нужно сохранять inline только после его создания (влезаем в метод сохранения документа)
— Нужна отдельная модель,
— Модельные формы
Вложенные документы тоже не подошли (не делать же свою структуру документа под каждое такое поле)
Идея с кастомным полем привлекла больше.
Можно засунуть всю логику в поле / виджер и забыть о ней.
Этот подход добавляет минимум сложности к архитектуре системы.
Несмотря на удобную работу с JSON (loads, dumps),
был выбран XML из-за необходимости формирования отчетов из базы данных с помощью SQL.
Если PostgreSQL поддерживает работу с JSON, то у Oracle она появляется только с 12 версии.
При манипуляции с XML можно использовать индексы на уровне БД через xpath.
**Работа на уровне SQL**
```
-- Разбираем XML на колонки
select
t.id,
(xpath('/item/@n_phone', nt))[1] as n_phone1,
(xpath('/item/@is_primary', nt))[1] as is_primary1,
(xpath('/item/@n_phone', nt))[2] as n_phone2,
(xpath('/item/@is_primary', nt))[2] as is_primary2
from docflow_document17 t
cross join unnest(xpath('/xml/item', t.nested_table::xml)) as nt;
-- Проверяем строки XML-таблицы
select
t.id
from docflow_document17 t
where t.id = 2
and ('1231234', 'False') in (
select
(xpath('/item/@n_phone', nt_row))[1]::text,
(xpath('/item/@is_primary', nt_row))[1]::text
from unnest(xpath('/xml/item', t.nested_table::xml)) as nt_row
);
```
Изначально сходу был написан работающий виджет, который
— Принимал XML в метод render
— Генерировал и показывал formset
— В value\_from\_datadict генерировался formset, принимая параметр data, валидировал, собирал XML и выплевывал ее
**Все это отлично работало и было очень простым**
```
class XMLTableWidget(widgets_django.Textarea):
class Media:
js = (settings.STATIC_URL + 'forms_custom/xmltable.js',)
def __init__(self, formset_class, attrs=None):
super(XMLTableWidget, self).__init__(attrs=None)
self._Formset = formset_class
def render(self, name, value, attrs=None):
initial = []
if value:
xml = etree.fromstring(value)
for row in xml:
initial.append(row.attrib)
formset = self._Formset(initial=initial, prefix=name)
return render_to_string('forms_custom/xmltable.html', {'formset': formset})
def value_from_datadict(self, data, files, name):
u""" Если валидация прошла успешно,
то возвратиться измененный XML
Если что-то с formset-ом не так, то будет возвращено initial-значение
Внимание: валидацию на уровне formset-а делать нельзя,
потому что отсюда выбрасывать исключения нельзя """
formset_data = {k: v for k, v in data.items() if k.startswith(name)}
formset = self._Formset(data=formset_data, prefix=name)
if formset.is_valid():
from lxml.builder import E
xml_items = []
for item in formset.cleaned_data:
if item and not item[formset_deletion_field_name]:
del item[formset_deletion_field_name]
item = {k: unicode(v) for k, v in item.items()}
xml_items.append(E.item("", item))
xml = E.xml(*xml_items)
return etree.tostring(xml, pretty_print=False)
else:
initial_value = data.get('initial-%s' % name)
if initial_value:
return initial_value
else:
raise Exception(_('Error in table and initial not find'))
```
Если бы не один нюанс: невозможность нормальной валидации formset-а.
Можно, конечно, сделать formset максимально мягким, ловить XML и проверять данные на уровне поля или формы.
Можно, наверное в виджете хранить аттрибут «is\_formset\_valid» и проверять ее из поля типа self.widget.is\_formset\_valid,
но от этого как-то нехорошо становилось.
Нужно делать совместную работу поля и виджета.
Вот что получилось в итоге.
Решил не докучать перечитыванием исходного кода.
Вместо этого, излишне подробно прокомментировал методы.
Основная идея в том, чтобы стандартизировать разные входные параметры:
— XML, полученную при инициализации поля
— Словарь с данными на выходе из виджета
— Правильно подготовленную конструкцию
преобразовать в единый формат типа {«formset»: formset, «xml\_initial»: xml\_string}
А дальше «дело техники»
**поле XMLTableField**
```
class XMLTableField(fields.Field):
widget = widgets_custom.XMLTableWidget
hidden_widget = widgets_custom.XMLTableHiddenWidget
default_error_messages = {'invalid': _('Error in table')}
def __init__(self, formset_class, form_prefix, *args, **kwargs):
kwargs['show_hidden_initial'] = True # Для получения значения при ошибках валидации
super(XMLTableField, self).__init__(*args, **kwargs)
self._formset_class = formset_class
self._formset_prefix = form_prefix
self._procss_widget_data_cache = {}
self._prepare_value_cache = {}
def prepare_value(self, value):
u"""
Принимаем на вход данные в произвольном виде из разных источников
и приводим их к единому виду
Если входной аргумент unicode,
то это XML, считанная из БД при инициализации формы через initial
Если словарь,
то это или кусок POST-массива, полученного от виджета,
В этом случае, мы преобразуем его в formset, а xml_initial
поднимаем из hidden_initial формы.
именно для этого принудительно выставлено show_hidden_initial = True
или уже нормально подготовленный словарь, который не нужно подменять.
"""
if value is None:
return {'xml_initial': value,
'formset': self._formset_class(initial=[],
prefix=self._formset_prefix)}
elif type(value) == unicode:
value_hash = hash(value)
if value_hash not in self._prepare_value_cache:
initial = []
if value:
xml = etree.fromstring(value)
for row in xml:
# Нужно привести строковое 'False' в False,
# потому что в XML оно хранится в тексте,
# а нам нужно в bool
attrs = {}
for k,v in row.attrib.items():
attrs[k] = False if v == 'False' else v
initial.append(attrs)
formset = self._formset_class(initial=initial, prefix=self._formset_prefix)
self._prepare_value_cache[value_hash] = formset
return {'xml_initial': value, 'formset': self._prepare_value_cache[value_hash]}
elif type(value) == dict:
if 'xml' not in value:
formset = self._widget_data_to_formset(value)
return {'xml_initial': value['initial'], 'formset': formset}
return value
def clean(self, value):
u"""
При преобразовании данных от виджета в данные, возвращаемые формой,
пропускаем через валидацию formset-ом,
а потом этот formset переводим в XML
в методе _formset_to_xml может вызываться ValidationError, если formset не валидный
"""
formset = self._widget_data_to_formset(value, 'clean')
return self._formset_to_xml(formset)
def _formset_to_xml(self, formset):
u"""
Преобразование в XML
вынесено в отдельную функцию.
Используется в _has_changed для проверки измененности XML
и в clean для сохранения в cleaned_data
"""
if formset.is_valid():
from lxml.builder import E
xml_items = []
for item in formset.cleaned_data:
if item and not item.get(formset_deletion_field_name, False):
if formset_deletion_field_name in item:
del item[formset_deletion_field_name]
item = {k: unicode(v) for k, v in item.items()}
xml_items.append(E.item("", item))
xml = E.xml(*xml_items)
xml_str = etree.tostring(xml, pretty_print=False)
return xml_str
else:
raise ValidationError(self.error_messages['invalid'], code='invalid')
def _widget_data_to_formset(self, value, call_from=None):
u"""
Преобразуем кусок POST-словаря, относящегося к formset-у
Прогоняем через кэш, потому что через prepare_value эта функция вызывается много раз,
а на этапе валидации FormSet-а могут быть много сложной логики
"""
# Хэш для уменьшения нагрузки из-за частых вызовов self.prepare_value
formset_hash = hash(frozenset(value.items()))
if formset_hash not in self._procss_widget_data_cache:
formset = self._formset_class(data=value, prefix=self._formset_prefix)
self._procss_widget_data_cache[formset_hash] = formset
return formset
else:
return self._procss_widget_data_cache[formset_hash]
def _has_changed(self, initial, data):
u"""
Сюда приходят данные из виджета.
Их нужно перегнать в formset с его валидацией, потом в XML для сравнения c исходным значением,
потому что initial-значение лежит в XML
"""
formset = self._widget_data_to_formset(data)
try:
data_value = self._formset_to_xml(formset)
except ValidationError:
return True
return data_value != initial
```
**XMLTableHiddenWidget**
```
class XMLTableHiddenWidget(widgets_django.HiddenInput):
def render(self, name, value, attrs=None):
u""" Берем из массива xml_initial и пересылаем на render """
value = value['xml_initial']
return super(XMLTableHiddenWidget, self).render(name, value, attrs)
```
**XMLTableWidget**
```
class XMLTableWidget(widgets_django.Widget):
class Media:
js = (settings.STATIC_URL + 'forms_custom/xmltable.js',)
def render(self, name, value, attrs=None):
u"""
Сюда может прийти formset, инициализированный через initial
или через data
В любом случае, работаем с ним одинаково
"""
formset = value['formset']
return render_to_string('forms_custom/xmltable.html', {'formset': formset})
def value_from_datadict(self, data, files, name):
u"""
Нужно вытащить кусок данных, относящихся к formset-у
и отправить их на clean в поле
Дополнительно к этому, прицепим initial-значение,
которое пригодится при подготовки данных в поле
"""
formset_data = {k: v for k, v in data.items() if k.startswith(name)}
initial_key = 'initial-%s' % name
formset_data['initial'] = data[initial_key]
return formset_data
```
В этом случае, основной задачей было обеспечение максимальной компактности
**XMLTableWidget - шаблон**
```
{% load base_tags %}
{% load base_filters %}
{{formset.management_form}}
{% if formset.non_field_errors %}
{% for error in form.non\_field\_errors %}
{{ error }}
{% endfor %}
{% endif %}
{% for form in formset %}
{% if forloop.first %}
|
{% for field in form.visible\_fields %}
{% if field.name == 'DELETE' %}
|
{% else %}
{{field.label}} |
{% endif %}
{% endfor %}
{% endif %}
|
{% for field in form.visible\_fields %}
{% if field.name == 'DELETE' %}
{{field}}
|
{% else %}
{{ field|add\_widget\_css:"form-control" }}
{% if field.errors %}
{% for error in field.errors %}
{{ error }}
{% endfor %}
{% endif %}
|
{% endif %}
{% endfor %}
{% endfor %}
```
Заменим стандартные CheckBox-ы на иконки «крестиков»
и будем подкрашивать строку при пометке ее на удаление
**XMLTableWidget - скрипт**
```
function xmltable_mark_deleted(p_a, p_checkbox_id) {
var chb = $('#' + p_checkbox_id)
var row = $(p_a).parents('tr')
if(chb.prop('checked')) {
chb.removeProp('checked')
row.css('background-color', 'white')
}
else {
chb.attr('checked', '1')
row.css('background-color', '#f2dede')
}
}
```
Вот, в общем-то и все.
Можем теперь использовать это поле и получать сложные таблицы, валидировать их как нужно
и не сильно усложнили код системы
Пользователю нужно только подготовить FormSet:
**XMLTableWidget**
```
class NestedTableForm(forms.Form):
phone_type = forms.ChoiceField(label=u"Тип",
choices=[('', '---'),
('1', 'Моб.'),
('2', 'Раб.')],
required=False)
n_phone = forms.CharField(label=u"Номер", required=False)
is_primary = forms.BooleanField(label=u"Осн", required=False,
widget=forms.CheckboxInput(check_test=boolean_check))
nested_table_formset_class = formset_factory(NestedTableForm, can_delete=True)
```
и получить это поле.
Привожу ссылку на репозиторий с приложением для django, в составе которого можно найти это поле.
Можно как подключить приложение, так и скопировать код поля / виджетов / шаблона / скрипта куда угодно.
[bitbucket.org/dibrovsd/django\_forms\_custom/src](https://bitbucket.org/dibrovsd/django_forms_custom/src) | https://habr.com/ru/post/213701/ | null | ru | null |
# Пример удобной организация split (A/B) тестирование на серверной стороне
Здравствуйте, уважаемые хабравчане!
Хотел бы поделится с Вами некоторым опытом организации split тестирование на проекте с которым довелось работать, также прошу не судить строго, так как это моя первая статья и действительно огромного профита ожидать не стоит.
Как мы все знаем, split (A/B) тестирование на сайте представляет собой экспериментальный подход с целью повышение конверсии по какому-либо процессу на ресурсе путем отображения различным группам пользователей разного контента.
Целью поставленной задачи была организация довольно сложного тестирования разных вариантов контента (как статических, так и динамических), с возможным неограниченным количеством экспериментов и вариантов на каждой странице ресурса. Проведя некий анализ имеющихся готовых решений поставленной задачи удалось найти несколько вариантов — это были GWO(уже не существует как отдельный сервис, интегрирован в GA), решение на основе [nginx](http://nginx.org/ru/docs/http/ngx_http_split_clients_module.html) и [Visual Website Optimizer](http://visualwebsiteoptimizer.com/). Но не один из них не подходил по ряду причин: внешние сервисы переносят рендеринг на сторону клиента, что при сложных тестах бывает очень не удобно, а nginx стоит далеко не везде, плюс не всегда у разработчиков есть доступ к конфигурации веб сервера и также возникает проблема размазывания логики. Потому мной было принято решение реализации своего ~~велосипеда~~ варианта, основываясь на примере реализации модуля nginx.
Стандартные советы по реализации ( остаток от делания последней цифры IP адреса клиента и тд. ) мне также не нравились, потому решил для определения вариантов использовать контрольные суммы от ключа тестирования — профит варианта в использовании абсолютно любого буквенно-цифрового ключа, возможности создания огромного количества вариантов тестирования с любым процентным отношением. Выбор хеш функции пал на [MurmurHash2](http://en.wikipedia.org/wiki/MurmurHash), так как она характеризуется очень хорошим распределением и, чего уж скрывать, используется для хеширования в модуле nginx. Проект над которым я работаю реализован на php, для реализации хеш функции рекомендую использовать [данное](https://sites.google.com/site/nonunnet/php/php_murmurhash) расширение.
Теперь же коснемся более реализации. Для определения значения варианта тестирования по конкретному эксперименту я реализовал класс SplitTestModel, используя его как синглтон:
```
class SplitTestModel
{
public static function getInstance($key = ''){...}
private function __construct( $key ){...}
public function getSplitVariantByExperiment( $experimentName ){...}
}
```
Информацию о каждом эксперименте я в вынес в конфиг, которые представляет собой, в моей реализации, массив вида:
```
array(
'Experiment1' => array(
'Variant1' => 50,
'Variant2' => 50
),
'Experiment2' => array(
'Variant1' => 15,
'Variant2' => 35,
'Variant3' => 12,
'Variant4' => *
)
);
```
Где ключ верхнего уровня — названия эксперимента, вложенные ключи — названия вариантов, а соответствующие им значения — процент показов, '\*' означает все оставшиеся проценты.
Как уже возможно стало понятно, ключ хэшируется с помощью MurmurHash2. В приведенном по первому эксперименту примере при значениях хэша от 0 до 50 % от максимально возможного значения хеша, пользователь получит вариант значения равный 'Variant1', от 50 % от максимально возможного значения до 100% — соответственно значение 'Variant2'.
Удобство метода заключается в том, что теперь в любом месте кода, для конкретного пользователя мы можем получить его значения варианта по любому из экспериментов и в зависимости от варианта отдать клиенту тот или иной контент любой части страницы. Пример использования:
```
$variant1 = SplitTestModel::getInstance($user_id)->getSplitVariantByExperiment('experiment1');
$variant2 = SplitTestModel::getInstance($remote_addr)->getSplitVariantByExperiment('experiment2');
```
Все предельно просто!
Большое спасибо за внимание, и еще раз попрошу не судить строго. Если кому-либо будет интересно с удовольствием пришлю исходный код класса.
UPD:
[ссылка](https://github.com/Jackson88/SplitTestModel) на реализацию класса на github | https://habr.com/ru/post/169777/ | null | ru | null |
# xss уязвимость
Угрозы xss атак с применением javascript
----------------------------------------
> Прежде чем начать, стоит оговориться, что данный материал несет исключительно информационный характер.
В наше время одним из самых популярных видов атак является межсайтовый скриптинг с применением javascript. В этой статье мы рассмотрим, какие проблемы вызывает незаконное применение javascript, правила безопасности, чтобы предотвратить возможную xss атаку и предоставим собственное исследование, связанное с проверкой сайтов на наличие организованной безопасности веб-сайтов.
Что такое xss атака?
--------------------
Это такой тип атак, который внедряет в веб-системы вредоносный код, заставляя её выдавать измененные данные, подменяет ссылки (видимые/скрытые) или выводит собственную рекламу на пораженном ресурсе.
Существует два направления атак:
**Пассивные** – которые требуют непосредственного вмешательства субъекта атаки. Суть заключается в том, чтобы заставить жертву перейти по вредоносной ссылке для выполнения «вредокода». Такой тип атак более сложный в реализации, ведь необходимо обладать не только техническими, но и психологическими знаниями.
**Активные** – это вид атак, когда хакер пытается найти уязвимость в фильтре сайта. Как же реализуется такая атака? Все очень просто. Нужно при помощи комбинации тегов и символов создать такой запрос, чтобы сайт его понял и выполнил команду. Как только дыра в безопасности найдена, в наш запрос можно вложить «вредокод», который, к примеру, будет воровать cookie и пересылать в удобное нам место. Приведем пример скрипта, ворующего “печеньки” с сайта:
```
Img = new image()
Img.src = http://site.gif?+document.cookie;
```
Обычно приходится серьезно потрудиться, чтобы найти дыру в безопасности сайта, ведь большинство фильтров достаточно устойчивы. Но их пишут люди, а им свойственно ошибаться.
Правила безопасности
--------------------
Откуда и почему вообще возникают подобные уязвимости, которые приводят к катастрофическим последствиям? Все дело во внимательности и знании людей. Разработчики должны писать правильный код, поэтому в этом разделе мы расскажем про минимальные правила безопасности написания сайтов.
Как применяется атака, мы уже рассказывали, но повторимся еще раз. Вся суть xss атаки — это обнаружение дыры в фильтре с целью его обхода.
1. Одно из самых первых и основных правил для разработчика – это применение любого (хотя-бы самого минимального) фильтра.
В проведенном нами исследовании сайтов почти все они были защищены, но все же находились и те, которые не использовали никакой фильтрации получаемых данных. В основном, это встречается на сайтах, написанных на языке PHP. Но, например, в фраемворках python, таких как: flask или Django уже есть встроенные минимальные фильтры, их остается только усилить.
2. Фильтрация символов и вложенных конструкций.
Минимальный фильтр защитит нас от любительских атак и неграмотных специалистов, но от серьезных хакеров нужно строить более серьезную защиту, с более детальной фильтрацией данных. Разработчики должны учитывать и понимать возможную реализацию xss атаки и строить фильтр таким образом, чтобы он распознавал вложенные конструкции. Например, хакер может создать многоуровневую конструкцию, и в самый нижний из них вложить вредоносный javascript код. Фильтр будет блокировать верхний уровень, но нижний будет выполняться.
3. Фильтр должен учитывать всевозможные комбинации символов.
Одной из наших любимых проверок на xss уязвимость является использование открытых и закрытых скобок.
Например: `“/?,#”>>>><
Пишем команду с n-м количеством скобок. Фильтр видит это и пытается их закрыть, но при этом выполняется вложенный код. В этом запросе мы не только проверяем фильтр на различное количество скобок, но и смотрим, как фильтр будет реагировать на разные символы, будет ли он блокировать их или пропускать. Обратим ваше внимание на конструкцию в конце примера. Мы передаем скрипт как аргумент в скобках. Интересный способ тестирования фильтра. В нашем исследовании многие сайты не фильтровали такой тип атаки, подвергаясь угрозе.
4. Использование тегов.
Предположим, что вы фильтруете и символы, и многоуровневые конструкции. Но есть еще одна уязвимость, она связана с тегами img, bb, url. У этих тегов есть много параметров, в том числе и dynsrc и lowsrc, которые содержат в себе javacsript. Эти теги необходимо фильтровать в обязательном порядке. Если же вы не собираетесь использовать на сайте картинки, лучше вообще отключать их.
Пример использования:
```
[img]http://blabla.ru/1.jpg/dynsrc=javascript:alert()[/img]
```
К сожалению, недостаточно простой фильтровки тегов, нужно учитывать возможность того, что злоумышленник поместит внутри тега дополнительные символы, которые также необходимо отфильтровать.
Например:
```
[img]»»>«script>http://blabla.ru/1.jpg/dynsrc=javascript:alert()[/img]
```
5. Шифрование.
При построении фильтра необходимо в первую очередь учитывать возможность кодировки атак. Существует огромное количество программ кодировщиков, которые зашифруют атаку так, что фильтр не сможет распознать ее. Поэтому нужно обязательно использовать алгоритм расшифровки в фильтре до того, как программа будет выполнять код запроса.
Вот пример зашифрованного кода:
```
%68%74%74%70%3A%2F%2F%2A%2A%2A%2A%2A%2E%72%75%2F%66%72%65%65%3F%70%3D%27%3E%3C%73%63%72%69%70%74%20%73%72%63%3D%68%74%74%70%3A%2F%2F%68%61%6B%6E%65%74%2E%68%31%36%2E%72%75%2F%73%63%72%69%70%74%2F%6A%73%2E%6A%73%3E%3C%2F%73%63%72%69%70%74%3E
```
Шифрование необходимо не только для обхода фильтра, но и для социальной инженерии, обмана людей. Можно отправить зашифрованный код в виде ссылки. Вряд ли кто-то будет проверять её, отсюда вытекает ещё один пункт.
6. Социальная инженерия
Мало написать устойчивый к атакам фильтр, необходимо периодически проводить лекции с сотрудниками о правилах пользования интернетом и рассказывать про возможные уловки хакеров.
Пара основных правил: никогда не открывайте подозрительные ссылки и проверяйте зашифрованные, особенно если вы админ хостинга или сети.
Исследование сайтов на xss уязвимости с использованием javascript.
Насколько серьезно относятся разработчики к безопасности своих веб-приложений? Наша команда решила это проверить. В рамках нашего исследования мы изучили около 500 сайтов на ошибки в безопасности. Было потрачено много времени на сбор, обработку и структурирование информации. Все проверки проводились вручную, потому что нужного инструмента мы не нашли, а на написание собственного ПО не хватало времени и знаний. Но, уже имея опыт, в следующий раз мы займемся именно этим.
Объектами наших исследований были сайты интернет-магазинов. Мы выбрали именно их, потому что на таких сайтах существует возможность обратной связи. Через неё, при помощи методов социальной инженерии, можно внедрить ссылку с вредоносным кодом оператору сайта и скомпрометировать не только утечку персональных данных, но и изменение оболочки сайта, нелегальное внедрение собственной рекламы через javascript элементы и подмену настоящих ссылок на вредоносные.
Стоит упомянуть, что мы занимались только проверкой фильтров, это не нарушает законодательства (272-274 УК) Российской Федерации и не несет никакого наказания.
В результате исследования мы получили весьма неплохую статистику. Совсем малый процент сайтов, примерно 5% не имеет фильтра, что является в корне неправильно построенной системой. Но на практике оказалось, что все эти сайты были разработаны студентами. По умолчанию сайты без фильтра считаются автоматически взломанными, т.к. они не экранируют запрещенные символы и на них можно заливать «вредокод» через javascript. Остальные сайты имеют фильтры, но что можно сказать об их надежности?
Около 11% мы смогли обойти, имея лишь средние знания в этой области. Это является огромным недочетом со стороны разработчиков, который может принести проекту много вреда, ведь под удар попадают персональные данные пользователей. По закону (статья 13.11 КоАП часть 6) все сайты должны обеспечивать сохранность персональных данных при хранении материальных носителей и исключать несанкционированный к ним доступ. Если же это повлекло неправомерный доступ к персональным данным (уничтожение, изменение, копирование, блокирование и т.д.) — следует наложение штрафа в размере от 700 рублей до 50 000 рублей.
Большая часть сайтов хорошо защищена от атак, что не может не радовать нас как пользователей. Результат исследования наглядно продемонстрирован в диаграмме, представленной ниже.
Заключение
----------
В рамках этой статьи мы рассказали вам про xss уязвимости с использованием javascript, также мы провели реальное исследование на прочность и устойчивость сайтов. В результате оценки безопасности, было выявлено, что большая часть сайтов, а именно 84% хорошо защищена от данного типа атак. Но все же есть определенный процент сайтов, который не вызывает доверия и не может противостоять атакам. Это является грубым недочетом, который нужно исправлять. К сожалению не все владельцы сайтов готовы вложить деньги в улучшение безопасности веб-сайта. Но с каждым годом строгость закона в отношении разглашения, утечки и повреждения персональных данных ужесточается, тем самым заставляя недобросовестных владельцев лучше следить за безопасностью своих ресурсов. Возрастает размер штрафа за нарушение 6-й части статьи 13.11 КоАП, а вместе с ним растет и защищенность наших персональных данных.` | https://habr.com/ru/post/345494/ | null | ru | null |
# Пост-эксплуатация взломанного оборудования Cisco
Всем привет. Меня зовут [@in9uz](/users/in9uz), я являюсь исследователем сетевой безопасности и сетевым инженером. В этой небольшой статье ты узнаешь как происходит процесс пост-эксплуатации взломанного оборудования Cisco. Покажу несколько трюков, которые, возможно, подарят тебе импакт во время проведения пентеста.
### Intro (Disclaimer)
Данная статья предназначена для специалистов по безопасности, которые проводят тестирование на проникновение в рамках согласованного контракта. Разрушение и взлом чужих компьютерных сетей преследуются по закону. Будь осторожен.
### Играем в прятки, используя Cisco EEM
**Cisco EEM** - это небольшой, скажем так, "язык программирования" с помощью которого можно писать различные сценарии для Cisco IOS, автоматизировать рутинные задачи. В рамках тестирования на проникновения, EEM поможет нам спрятать созданного нами пользователя на взломанном устройстве.
Но! У такого метода есть и свои недостатки, такие как:
* **Есть N-ая вероятность спалиться** в логах сервера SYSLOG.
* **Есть N-ая вероятность спалиться** в логах сервера SNMP.
* Если сетевой инженер тоже использует Cisco EEM, **он может заподозрить** что-то не ладное.
Сначала нам нужно создать самого пользователя, который будет использоваться для закрепления на оборудовании. Соблюдай, чтобы префикс "hidden\_" тоже был у ника, создаваемого тобою пользователя. С помощью данного префикса мы и будем прятать созданного нами пользователя по маске " | hidden ":
```
Owned(config)# username hidden_papercut privilege 15 secret tellmeyouloveme
```
#### Прячем пользователя из вывода команды "show run"
Данная команда очень часто используется сетевыми инженерами, она выводит конфигурацию устройства, которая используется в данный момент времени.
```
Owned(config)# event manager applet hide_from_showrun
Owned(config-applet)# event cli pattern "show run" sync yes
Owned(config-applet)# action 0.0 cli command "enable"
Owned(config-applet)# action 1.0 cli command “show run | exclude hidden | event | action”
Owned(config-applet)# action 2.0 puts “$_cli_result_showrunapplet”
```
#### Прячем пользователя из вывода команды "show ssh"
Данная команда выводит активных на данный момент пользователей, подключенных через SSH.
```
Owned(config)# event manager applet hide_from_showssh
Owned(config-applet)# event cli pattern "show ssh" sync yes
Owned(config-applet)# action 0.0 cli command "enable"
Owned(config-applet)# action 1.0 cli command “show ssh | exclude hidden”
Owned(config-applet)# action 2.0 puts “$_cli_result_showsshapplet”
```
#### Прячем пользователя из вывода команды "show users"
Данная команда выводит активных на данный момент пользователей, подключенных через VTY. Обычно это удаленные Telnet/SSH-сессии.
```
Owned(config)# event manager applet hide_from_showusers
Owned(config-applet)# event cli pattern "show users" sync yes
Owned(config-applet)# action 0.0 cli command "enable"
Owned(config-applet)# action 1.0 cli command “show users | exclude hidden”
Owned(config-applet)# action 2.0 puts “$_cli_result_showusersapplet”
```
#### Прячем пользователя из локального логирования Cisco IOS
```
Owned(config)# event manager applet hide_from_showlog
Owned(config-applet)# event cli pattern "show log" sync yes
Owned(config-applet)# action 0.0 cli command "enable"
Owned(config-applet)# action 1.0 cli command “show log | exclude HA_EM | hidden”
Owned(config-applet)# action 2.0 puts “$_cli_result_showlogapplet”
```
С апплетами EEM можно экспериментировать, не ограничивайся только данными способами.
### Lateral VLAN Segmentation Bypass
Если ты получил доступ к коммутатору, к которому ты подключен напрямую - у тебя появляется возможность **обхода VLAN-сегментации** внутри сети. Достаточно переключить порт в режим магистрального канала (иначе говоря, Trunk), создать виртуальные интерфейсы с идентификаторами целевых VLAN-сетей и настроить IP-адрес. Можно попробовать запросить адрес динамически (DHCP), а можно настроить статически.
Сначала нужно выяснить, к какому именно порту ты подключен. Это можно выяснить либо через CDP-сообщения, либо поискать порт по маске "include":
CDP-объявление от коммутатора. Мы на порту GigabitEthernet 0/2Если вдруг CDP отключен, можно попробовать поискать порт по нашему MAC-адресу.
```
SW1(config)# show mac address-table | include 0050.0000.0500
```
Найден порт Gi0/2 по MAC-адресуПеред тем как переключиться в транк, необходимо перечислить существующие сети VLAN, выяснить их идентификаторы. Потом эти идентификаторы мы будем вешать на свой интерфейс, чтобы получать доступ к этим сетям VLAN. Таким образом, благодаря транку, мы можем получить доступ в любую сеть VLAN.
```
SW1# show vlan brief
```
Информация о сетях VLANКстати говоря, порт, к которому мы подключены - принадлежит сети VLAN 10.
Приступим. Входим в режим конфигурации интерфейса и переходим в транковый режим.
```
SW1(config)# interface GigabitEthernet 0/2
SW1(config-if)# switchport trunk encapsulation dot1q
SW1(config-if)# switchport mode trunk
```
Во время переключения в режим магистрального канала теряется связность. Но скоро мы это исправим.
Потеря связности в момент переключения режима портаСоздаем виртуальные интерфейсы и "вешаем" на них VLAN ID:
```
necreas1ng@Inguz:~$ sudo vconfig add eth0 10
necreas1ng@Inguz:~$ sudo vconfig add eth0 20
necreas1ng@Inguz:~$ sudo vconfig add eth0 50
necreas1ng@Inguz:~$ sudo vconfig add eth0 60
```
Поднимаем интерфейсы:
```
necreas1ng@Inguz:~$ sudo ifconfig eth0.10 up
necreas1ng@Inguz:~$ sudo ifconfig eth0.20 up
necreas1ng@Inguz:~$ sudo ifconfig eth0.50 up
necreas1ng@Inguz:~$ sudo ifconfig eth0.60 up
```
Теперь нужно запросить адрес по DHCP. Но если в твоем случае не будет такой возможности, то можно и статически настроить адрес.
```
necreas1ng@Inguz:~$ sudo dhclient -v eth0.10
necreas1ng@Inguz:~$ sudo dhclient -v eth0.20
necreas1ng@Inguz:~$ sudo dhclient -v eth0.50
necreas1ng@Inguz:~$ sudo dhclient -v eth0.60
```
Полученные IP-адреса по DHCPПример настройки статического IP-адреса на интерфейсе (VLAN 10):
```
necreas1ng@Inguz:~$ sudo ifconfig eth0.10 10.10.10.66 netmask 255.255.255.0
```
Для проверки связи инициирую ICMP-запросы до шлюзов по умолчанию для сетей VLAN 10, 20, 50, 60
Связность до шлюзовВ итоге, я обошел VLAN-сегментацию и могу пробиться в любую VLAN-сеть, что развязывает мне руки для дальнейших "наступательных" действий.
### Bruteforce hashes
Когда ты перечисляешь конфигурацию устройства, есть смысл попытаться сбрутить хеши паролей. Вдруг тебе удастся сбрутить хеш пароля той учетной записи, которая имеет максимальные привилегии. В Cisco IOS есть несколько типов паролей, которые находятся в зашифрованном виде. Табличка ниже сориентирует тебя по типам хешей, как брутить и сколько времени понадобится.
Таблица хешей в Cisco IOSТеперь приступим к самому брутфорсу. В выводе команды "show run" ты наверняка наткнешься на эти строчки:
Учетные записи и их пароли в зашифрованном видеБрутфорс хешей я проведу через утилиту John. Немного отформатирую хеши, чтобы John смог распознать сами хеши внутри файла, который мы будем подавать в качестве входных данных.
BeforeAfterНачинаем сам брутфорс. С помощью ключа **--wordlist** указываем путь до словаря. John сам определит тип хешей внутри файла.
Взломанные пароли пользователей lies и anxiousПопробуем зайти на маршрутизатор под адресом 10.10.10.100 с кредами пользователя lies:
Вход в панель управления маршрутизатором от имени lies### Configuration Enumeration
#### Классическое перечисление конфигурации
С помощью команды show run можно выяснить, какая конфигурация исполняется в данный момент времени. Это раскрывает некоторые особенности инфраструктуры, возможно, данная информация приведет тебя к более легкой "победе" во время пентеста. Например, вдруг ты обнаружишь использование AAA-сервера, что дает ещё один вектор атаки (для абьюзинга RADIUS/TACACS).
```
Owned# show run
```
Перечисление конфигурации, часть 1Перечисление конфигурации, часть 2#### Cisco IOS ver.
Будет полезно узнать версию Cisco IOS на устройстве. С помощью данной информации, пентестер сможет перечислить версию Cisco IOS на предмет наличия той или иной уязвимости. Вдруг он попал на роутер с read-only учеткой, а потенциальное наличие уязвимости даст ему LPE, черт его знает...
```
Owned# show version
```
Версия Cisco IOS#### CCAT
CCAT (Cisco Config Analysis Tool) - это специальная [утилита](https://github.com/frostbits-security/ccat), созданная для анализа файлов конфигурации оборудования Cisco на наличие брешей в безопасности. Она поможет автоматизировать процесс поиска мисконфигураций безопасности, данная утилита будет полезна как пентестерам, так и сетевым администраторам.
CCAT анализирует файл конфигурации### Outro
В рамках данной статьи я поделился небольшими трюками, которые помогут облегчить жизнь пентестеру. Но думаю, моя статья также подарит сетевым администраторам некоторую осведомленность, с помощью которой они смогут повысить уровень безопасности своего оборудования. | https://habr.com/ru/post/676942/ | null | ru | null |
# NoName Framework или Как я велосипед изобретал
**Привет тебе, хабраюзер!**
Сегодня я хочу представить на твой суд некоторое количество быдлокода, которое я с гордостью называю «своим фреймворком». Под катом вы увидите большое количество велосипедов с квадратными колесами, смехотворные комментарии к коду, довольно изрядное количество абсолютно бессмысленного текста и множество других подобных ужасов. Кого это не напугало — кликайте на кнопку «Читать дальше».
**На данный момент фреймворк претерпел некоторые изменения, так что не все примеры из статьи могут работать, а структура фреймворка будет несколько отличаться.**
#### Небольшое предисловие
На данный момент я учусь в подмосковном колледже на третьем курсе по специальности «Программное обеспечение вычислительной техники и автоматизированных систем». На втором семестре третьего курса нам сказали что-то вроде «Теперь вы готовы», и у нас появился новый предмет — Программное обеспечение компьютерных сетей, или, другими словами, нас начали учить HTML'ю. Немного ранее один из моих однокурсников начал изучать HTML, CSS и PHP и добился в этом некоторых успехов — сделал свой интернет-магазин. Как-то я попросил его показать мне исходники, и был не особо удивлен — если не считать некоторое количество инклудов, весь PHP состоял в расширении файлов (корзина и все прочие примочки, составлявшие «магазинную часть» были на Ecommtools тчк com).
Увидев такое, я просто не мог промолчать и начал ему что-то втирать про MVC, про базу и все такое прочее. Естественно, он почти ничего не понял из моих слов (я, как сами видите, объясняю не очень хорошо). Но буквально через пару недель подвернулся вышеупомянутый предмет. Преподаватель по нему вел у нас раньше, и я без особых проблем договорился с ним о том, что мы с однокурсником заниматься будем самостоятельно. В итоге, за энное количество пар, сайт был переписан с нуля моими собственными руками, а однокурсник, кроме нового сайта, получил внушительный багаж знаний (я надеюсь полезных).
Исходники я скинул себе (работали мы на его ноуте) и дома ковырял дальше, добавлял функционал, рефакторил, переделывал кое-что заново. В итоге у меня получилось некое подобие фреймворка, на котором вполне успешно работает несколько проектов. Теперь я решил открыть свое творение народу, дабы тот решил — забрасывать мне веб-программирование или развивать свое детище дальше. Да и мало ли, вдруг кому пригодится.
#### Особенности фреймворка
1. **Малый вес.** Ну очень малый. В распакованном виде он занимает около 34 килобайт (Если удалить стандартный текст приветствия и картинку-логотип)
2. **Отсутствие ООП.** Не знаю, преимущество это или наоборот минус, но по идее ООП-приложения съедают гораздо больше ресурсов, чем приложения, написанные в процедурном стиле. (Какая могла идти речь об объектах, когда человек, которому в первую очередь это демонстрировалось, в основах еще не до конца разобрался)
3. **MVC.** Ну, тут я думаю объяснять ничего не надо.
4. **Роутинг.** Маршрутизация (на мой взгляд) очень простая в использовании, но при этом довольно гибкая в настройке, хотя и требует доработки. Маршрутизация по-умолчанию — «Controller/Action/Param-1/Value-1/Param-2/Value-2».
5. **JSON и XML.** Для того, что бы получить ответ в одном из этих форматов, надо лишь дописать в конце адреса ".json" или ".xml" соответственно. То есть, если по адресу "/goods/view/id/3" вы получаете информацию о товаре, то по адресу "/goods/view/id/3.json" вы можете получить ее в формате JSON.
6. **Функционал.** Из коробки функционала немного, так как коммьюнити составляет всего 1 человек (я). Пока что есть плохонький скрипт рассылки мыла и вполне рабочая авторизация пользователей с использованием сессий.
7. **Бэктрейс.** Присутствует. Отключается, если приложение не в debug-режиме.
8. **БД.** Поддерживается только MySQL. Это минус, но на данный момент не критичный.
9. **ORM.** Ее быть тут не может, так как ООП отсутствует во фреймворке в принципе. Но кой-какая обвязочка над БД есть.
10. **ACL.** Отсутствует на данный момент, но в планах по развитию фреймворка (а развиваться он будет только в случае получения хотя-бы нескольких положительных отзывов) стоит на первом месте.
11. **DEBUG-режим.** Присутствует, влияет на вывод некоторых ошибок, на вывод бэктрейса, на используемые конфиги.
#### Структура фреймворка
##### Схема
```
| - app/
| - config/
| - debug/
| - *.php
| - *.php
| - controllers/
| - */
| - *Action.php
| - models/
| - *.php
| - views/
| - custom/
| - *.phtml
| - layout/
| - default.phtml
| - scripts/
| - */
| - *.phtml
| - library/
| - functions/
| - default.php
| - *.php
| - init/
| - configs.php
| - init.php
| - predispatch.php
| - models/
| - basemodel.php
| - router/
| - router.php
| - include.php
| - files/
| - *
| - index.php
| - .htaccess
```
##### Рассмотрим все по порядку
Начнем, пожалуй, с самого низа, то есть с файла **.htaccess**. Вот его содержимое:
```
RewriteEngine on
RewriteCond %{REQUEST_URI} !/files
RewriteRule .*$ index.php [L]
AddDefaultCharset UTF-8
```
То есть любой запрос, кроме начинающегося на "/files" будет перенаправлен на index.php. На самом деле это не единственный и далеко не лучший вариант реврайта, но я уже привык с ним работать и решил пока что не менять. Ну и кодировка по умолчанию: UTF-8. Больше ничего интересного мы тут не увидим.
Перейдем к **index.php**. Вот его содержимое:
```
// Включаем или отключаем дебаг (влияет на бэктрейс и загрузку конфигов)
define('APP_DEBUG', TRUE);
// Определяются папки приложения
define('APP_PATH', dirname(__FILE__) . DIRECTORY_SEPARATOR . 'app' . DIRECTORY_SEPARATOR);
define('LIBRARY_PATH', dirname(__FILE__) . DIRECTORY_SEPARATOR . 'library' . DIRECTORY_SEPARATOR);
// Подключаются все файлы, необходимые для работы фреймворка
require_once(LIBRARY_PATH . 'include.php');
// Запускаем экшн
startAction();
// Загружаем лайаут
loadLayout($_response['layout']);
```
Тут, я думаю, объяснять ничего не требуется, так как все действия прокомментированы.
Папка **files**. Как вы возможно помните, только к этой папке имеется доступ «напрямую», то есть, минуя **index.php**. Соответственно именно в нее складываются такие ресурсы, как таблицы стилей, JavaScript-файлы, изображения и так далее.
Далее рассмотрим папку **app**. Это, как ясно из названия, папка самого приложения. Она содержит конфигурацию приложения (папка **config**), контроллеры (папка **controllers**) и экшны этих контроллеров, модели (папка **models**) и представления (папка **views**).
Контроллер представляет собой папку, содержащую в себе PHP-файлы — экшны. Имя папки должно быть в camelCase. Имя файла-экшна должно быть также в camelCase, но с постфиксом «Action» в конце.
То есть, контроллер с названием **«goods»** и действиями **«index»**, **«show»**, **«new»**, **«edit»** и **«delete»** в файловой системе выглядел бы так:
```
| - controllers/
| - goods/
| - indexAction.php
| - showAction.php
| - newAction.php
| - editAction.php
| - deleteAction.php
```
Опционально, любой контроллер может содержать файл **\_init.php**. Содержимое этого файла будет выполняться перед запуском любого экшна в этом контроллере.
Теперь о моделях (папка **«models»**). В моем понимании, модель должна возвращать уже готовые к использованию данные, которые уже не придется дополнительно обрабатывать в контроллере. То есть, например, нужно вывести в блок 5 последних новостей. Можно составить запрос прямо из контроллера, но в моем понимании правильнее было бы свести код к такому виду:
```
loadModel('news');
$_view['last_news'] = getLastNews(5);
```
Тут метод `getLastNews()` объявляется в модели **«news»** и возвращает массив данных, которые осталось просто оформить и вывести в представлении.
Сама по себе модель представляет собой набор методов, объединенных в один файл.
Перейдем к представлениям — папке **«views»**. Она содержит 3 поддиректории: **custom**, **layout**, **scripts**. Все представления имеют расширение **.phtml**.
Папка **«layout»** хранит в себе все лайауты приложения. Тут объяснять особо нечего. Для вывода контента в лайаут используется метод `content()`.
В папке **«scripts»** хранятся представления для экшнов. Структура такая: **scripts/<имяКонтроллера>/<имяЭкшна>.phtml**.
Ну а в папке **«custom»** лежат все остальные представления, которые не подходят для первых двух папок. Например, тут могут находиться блоки сайдбара, вынесенный отдельно хэдер и так далее.
Ну и наконец, папка **«config»**. Она содержит поддиректорию **debug**, куда конфиги могут быть продублированы. Если константа **APP\_DEBUG** — истина, то приложение попытается найти запрошенный конфиг в папке **config/debug**, и только если там конфига не окажется, оно подключит его из папки **config**. Если же приложение **не** в дебаг режиме, папка **debug** будет проигнорирована.
Все конфиги — PHP-файлы возвращающие массив, то есть содержимое их примерно такое:
```
return array(
// . . .
);
```
Папка **«library»**. По сути это и есть сам фреймворк., поэтому подробно рассматривать я ее не буду (стыдно). Затрону лишь несколько деталей.
Папка **«functions»**. Если вам надо расширить функционал фреймворка, то вам сюда. PHP-файлы из этой папки подгружаются при помощи метода `loadFunction($fnc)`. Автолоада пока что нет, но в ближайшем будущем будет. Отдельно стоит обратить внимание на файл **«default.php»**. Он содержит весь основной функционал фреймворка и подключается при старте приложения.
В папке **«init»** нас интересует файл **«init.php»**. Он выполняется каждый раз при старте приложения и динамическую настройку следует выполнять именно там.
В папке **«models»** обратите внимание на файл **«basemodel.php»**. Это и есть та самая обвязка для MySQL, про которую я писал выше.
#### Работа с фреймворком
Попробуем создать небольшое приложение на этом фреймворке. Пусть это будет каталог прочитанных вами книг.
##### Создание и настройка проекта
Скачиваем фреймворк по одной из ссылок: [github.com/SazereS/NoNameFramework.git](https://github.com/SazereS/NoNameFramework.git) [yadi.sk/d/ZAnE6Yq\_4kgBe](http://yadi.sk/d/ZAnE6Yq_4kgBe) [troloload.ru/f/5979\_nonameframework.zip](http://troloload.ru/f/5979_nonameframework.zip) [dl.dropboxusercontent.com/u/85783372/NoNameFramework.zip](https://dl.dropboxusercontent.com/u/85783372/NoNameFramework.zip)
Распаковываем фреймворк в папку сайта. Наше приложение будет использовать базу данных, поэтому сразу создаем ее удобным вам способом.
Идем в **app/config** и открываем файл **mysql.php**. Заменяем значения по умолчанию на свои. У меня получилось так:
```
// mysql.php
return array(
'dbHost' => 'localhost',
'dbUser' => 'root',
'dbPass' => '',
'dbName' => 'test',
);
```
Далее открываем **library/init/init.php** и проверяем, что бы строчка `initDb();` была раскомментирована.
На этом начальную настройку можно считать завершенной.
##### Создание CRUD-приложения
В первую очередь нам понадобится таблица в базе данных. Пусть она называется **books** и состоит из столбцов **id, title, author, comment, mark**. Для этого выполняем этот запрос к созданной нами базе:
```
CREATE TABLE `books` (
`id` INT(10) NOT NULL AUTO_INCREMENT,
`title` VARCHAR(80) NOT NULL,
`author` VARCHAR(40) NOT NULL,
`comment` TEXT NOT NULL,
`mark` INT NOT NULL,
PRIMARY KEY (`id`)
)
COLLATE='utf8_general_ci'
ENGINE=MyISAM;
```
Так же нам понадобится модель. Для этого в папке **models** создаем файл **books.php**.
Создадим контроллер **books**. Для этого в папке **app/controllers** создаем папку **books**.
CRUD — аббревиатура от Create Read Update Delete (Создание, Чтение, Обновление, Удаление). Именно эти действия наш контроллер и будет производить. Создадим для каждого из этих действий соответствующий экшн. Имена этих экшнов пусть будут **new**, **view**, **edit** и **delete**. Кроме того нам понадобится экшн для вывода списка всех книг. Его назовем **«index»**. Для этого создаем пять файлов в папке **books**: **indexAction.php, newAction.php, viewAction.php, editAction.php и deleteAction.php.**
Некоторым из экшнов нужны файлы представления (**view**). Создавать мы их будем по мере необходимости. Начнем с экшна **new**. Для этого в папке **views/scripts** создаем подпапку **books** (по имени контроллера) а в ней файл **new.phtml** (по имени экшна). Временно вставим в него следующий текст: `**books/new**`. Теперь запустим ваш веб-сервер и перейдем по адресу «http://<АДРЕС ВАШЕГО САЙТА>/books/new». Там мы должны увидеть текст **books/new**.
Вернемся к нашему экшну. Откроем файл **newAction.php** и добавим туда следующий код:
```
php
// Подключаем модель models/books.php
loadModel('books');
// Проверяем, пришли ли данные методом POST
if(isPost()){
// Если пришли, то заносим их в переменную $post
$post = getPost();
// Пытаемся добавить книгу в базу
if(newBook($post)){
// Если получилось - перенаправляем на страницу со списком книг
redirect('books');
} else {
// Если не получилось - передаем введенные данные в представление
$_view['form'] = $post;
}
}
</code
```
Обратите внимание на переменную $\_view. Именно с помощью нее контроллер общается с представлением. Все значения, переданные в нее, будут доступны и из представлений, и из лайаута.
Кроме того, нам интересна функция `newBook()`. На самом деле этой функции еще не существует. Давайте создадим ее. Для этого открываем нашу модель (**books.php**) и вставляем туда следующий код:
```
php
function newBook($array) {
// Пытаемся вставить строку в таблицу 'books' и возвращаем результат операции
return insertRow('books', $array);
}
</code
```
На этом работа с моделью и экшном закончена, переходим во вью. Вставляем туда следующий код:
```
Название книги:
Автор:
Комментарий к книге:
=$\_view['form']['comment'] ?
Ваша оценка книги (от 1 до 10):
Сохранить
```
Теперь можно обновить страницу в браузере и попробовать добавить данные через форму. Данные добавляются, но после редиректа появляется сообщение об отсутствующем представлении. Давайте создадим его (файл будет называться **index.phtml**).
Теперь переходим в экшн **index**. Вставляем туда код:
```
php
// Подключаем модель
loadModel('books');
// Получаем данные о всех книгах и передаем их в представление
$_view['books'] = getAllBooks();
</code
```
Как вы видите, мы опять использовали несуществующую функцию `getAllBooks()`. Добавляем в нашу модель вот эти строчки:
```
function getAllBooks() {
// Возвращаем все строчки, которые есть в таблице
return fetchAll('books');
}
```
Переходим к представлению и вставляем туда это:
```
php if($_view['books']) foreach ($_view['books'] as $v) { ?
#=$v['id'] ?: [=$v['title'] ?](<?=baseUrl('books/view/id/'.$v['id']) ?>)
php } ?
```
Тут мы сталкиваемся с новой для нас функцией `baseUrl()`. Она нужна для создания корректных ссылок. В данном случае можно обойтись и без нее, сделав ссылку от корня сайта, но она избавляет от лишней мороки, особенно тех, у кого сайт расположен по адресу вроде **[localhost/framework/test](http://localhost/framework/test)**.
На этом с этим экшном можно закончить. Переходим к следующему в логической цепочке экшну — **view**. Сразу приведу здесь весь код, так как по аналогии все понятно.
viewAction.php:
```
php
loadModel('books');
// Передаем в функцию getBook() параметр, полученный из адресной строки
$_view['book'] = getBook(getParam('id'));
</code
```
Дополнение для модели:
```
function getBook($id) {
// Ищем одну-единственную строку с нужным нам айди
return fetchRow('books', 'id = ' . $id);
}
```
Представление (не забудьте его создать):
```
**Название:**
=$_view['book']['title'] ?
**Автор:**
=$_view['book']['author'] ?
**Комментарий:**
=$_view['book']['comment'] ?
**Оценка:**
=$_view['book']['mark'] ? из 10
[Изменить](<?=baseUrl('books/edit/id/'.$_view['book']['id']) ?>)
[Удалить](<?=baseUrl('books/delete/id/'.$_view['book']['id']) ?>)
```
Теперь **editAction**
editAction.php:
```
loadModel('books');
// Заполняем форму данными из базы
$_view['form'] = getBook(getParam('id'));
if(isPost()){
$post = getPost();
// Пытаемся изменить значения
if(updateBook(getParam('id'), $post)){
// Если получилось - перенаправляем на страницу с отредактированной книгой
redirect('books/view/id/'. getParam('id'));
} else {
// Если не получилось - передаем введенные данные в представление
$_view['form'] = $post;
}
}
// С помощью этой строчки мы будем рендерить представление
// не edit.phtml, а new.phtml
setResponse('action', 'new');
```
Обратите внимание, мы не создаем представление для этого действия, так как используем уже имеющуюся у нас форму из **new.phtml**
Добавляем функцию в модель:
```
function updateBook($id, $values) {
// Обновляем данные в строке с айди равном $id
return updateRow('books', 'id = ' . $id, $values);
}
```
И наконец, последний экшн — **delete**.
deleteAction.php:
```
loadModel('books');
deleteBook(getParam('id'));
redirect('books');
```
Функция для модели:
```
function deleteBook($id) {
// Удаляем строку с книгой
return deleteRow('books', 'id = ' . $id);
}
```
Этому действию представление не нужно в принципе, так как он в любом случае перенаправляет вас на индексный экшн.
Теперь можно немного улучшить получившийся код. Как вы могли заметить, каждый раз, в начале экшна мы выполняли одну и ту же операцию — `loadModel('books')`. Давайте вынесем ее отдельно. Для этого в папке нашего контроллера создадим файл **\_init.php** и поместим эту строчку туда, а из контроллеров удалим. Потыкайте на ссылки и убедитесь в работоспособности проекта.
Теперь сделаем ссылки на создание новой записи и на список всех записей. Для этого откроем файл **app/views/layout/default.phtml**. Процедура `content()` выводит содержимое представления в лайаут. Добавьте прямо над ней следующие строчки кода:
```
[Список книг](<?=baseUrl('books') ?>)
[Добавить книгу](<?=baseUrl('books/new') ?>)
```
Теперь ссылки на список и форму добавления будет на всех страницах приложения.
##### Маршрутизация
Давайте определимся, как в идеале должен выглядеть адрес каждого экшна. Я предлагаю такой вариант:
```
'books' => '',
'books/new' -> 'book/new',
'books/view/id/{id}' -> 'book/{id}',
'books/edit/id/{id}' -> 'book/{id}/edit',
'books/delete/id/{id}' -> 'book/{id}/delete',
```
Для того, что бы это заработало? открываем файл **config/router.php** и приводим массив к следующему виду:
```
return array(
# Это - роут индексной страницы
'' => 'books',
# Остальные роуты
'book/new' => 'books/new',
'book/{id|int}' => 'books/view/id/{id}',
'book/{id|int}/edit' => 'books/edit/id/{id}',
'book/{id|int}/delete' => 'books/delete/id/{id}',
);
```
Теперь по адресу **book/1** будет открываться информация о книге с айди 1. Остальное по аналогии.
##### Чуть подробнее о синтаксе маршрутов
Ключом ассоциативного массива является шаблон маршрута, а значением — реальный адрес экшна со всеми параметрами. Динамические части заключаются в фигурные скобки. Имейте в виду, что каждый блок маршрута может либо полностью статическим, либо полностью динамическим, то есть такая запись — `'user/{id}' => 'users/profile/id/{id}'` — будет верной, а запись `'id{id}' => 'users/profile/id/{id}'` — неверной, то есть на данный момент ссылок вроде **[yoursite.com/id33523](http://yoursite.com/id33523)** добиться не получится, хотя я собираюсь исправить это в ближайшее время.
Маршруты имеют фильтрацию по типу данных (строка — string, str; целое число — int, integer; дробное число — float, real) и максимальной длине передаваемого значения. Для добавления фильтра, после имени параметра укажите фильтры через вертикальную черту. Примеры:
```
# Просто роут
'{id|int}' => 'index/index/id/{id}',
# Роуты для тестов
'test/{test|3}' => 'index/index/result/success1/param/{test}',
'test/{test|integer}' => 'index/index/result/success2/param/{test}',
'test/{test|float}' => 'index/index/result/success2/param/{test}',
'test/{test|str|5}' => 'index/index/result/success4/param/{test}',
'test/{test|string}' => 'index/index/result/success5/param/{test}',
# Айди после контроллера запускает экшн 'view'
'{controller}/{id|int}' => '{controller}/view/id/{id}',
# Все айдишники идут сразу после экшна
'{controller}/{action}/{id|int}' => '{controller}/{action}/id/{id}',
```
#### Заключение
На самом деле это далеко не все особенности этого фреймворка, но надоело писать =). Надеюсь, что хоть кому-нибудь мое творение пригодится, иначе, зачем я тут распинался?
#### Ссылки на скачивание
GitHub: [github.com/SazereS/NoNameFramework.git](https://github.com/SazereS/NoNameFramework.git)
Яндекс.Диск: [yadi.sk/d/ZAnE6Yq\_4kgBe](http://yadi.sk/d/ZAnE6Yq_4kgBe)
Dropbox: [dl.dropboxusercontent.com/u/85783372/NoNameFramework.zip](https://dl.dropboxusercontent.com/u/85783372/NoNameFramework.zip)
Troloload: [troloload.ru/f/5979\_nonameframework.zip](http://troloload.ru/f/5979_nonameframework.zip)
**БОЛЬШАЯ ПРОСЬБА! Тыкайте в ошибки носом и не стесняйтесь указывать на слабые места. Даже высказывания типа «Бросай программирование — не твое это» будут приняты с благодарностью, если будут подкреплены аргументами. Заранее спасибо!** | https://habr.com/ru/post/179433/ | null | ru | null |
# Установка неподписанных программ на устройства с iOS 9 без Jailbreak
Дорого дня, уважаемые хабражители!
Сегодня я расскажу вам о том, как можно установить неподписанное (или плохо подписанное) приложение на устройство с iOS 9. Да, без Jailbreak. Да, бесплатно. Нужен лишь компьютер с OS X и Apple ID. Как такое возможно? Читаем под катом.
Осторожно! Много картинок!
Как извеcтно, Apple разрешили разработчикам, не заплатившим $99 в год за возможность выкладывать приложения в AppStore, тестировать свои собственные программы на реальных устройствах с iOS 9. Раньше эта привилегия была лишь у «проплаченных» разработчиков. Ну и у тех, кто делает jailbreak.
Стало быть, теперь каждый человек, имеющий Apple ID и OS X с установленным Xcode, может стать разработчиком приложений и получить Provision Profile для своего приложения! На этом-то и основан описанный в данной статье метод. Если у тебя, читатель, есть всё вышеперечисленное, то смело иди на [developer.apple.com](http://developer.apple.com) и регистрируйся в качестве разработчика!
Теперь переходим к самому интересному. Запускаем Xcode, открываем настройки и переходим во вкладку «Accounts», где нажимаем на плюсик и вводим данные своего Apple ID. Теперь видим, что добавленный аккаунт является бесплатным участником программы для разработчиков под iOS. Замечательно! Теперь жмём «View Details...».
Вверху видим, что у нас не создан Signing identity, нажимаем на кнопку Create.
Теперь переходим к созданию Provision Profile. Через сайт его создать не выйдет: баг, однако! Но у нас ведь есть Xcode, так что не отчаиваемся, а создаём новый проект. Я выбрал игру, но это не имеет значения.
Bundle ID я задал ru.habr.testapp, это потом пригодится, когда я буду искать этот профайл среди других, а их у меня в системе много. Если у тебя, уважаемый читатель, это первый опыт с Xcode, то будет сильно проще найти нужный профайл.
Что ж, теперь заходим в настройки проекта и видим, что параметр «Team» не установлен. Установим его в наш свежедобавленный аккаунт разработчика!
У меня тут много всякого, но у тебя, читатель, должен быть лишь один аккаунт. Его и выбирай!
Теперь видим, что у нас беда с подписью, ведь нет Provision Profile, но Xcode героически предлагает взять исправление проблемы на себя и «исправить положение вещей». Что ж, позволим ему это сделать: жмём «Fix issue».
Вуаля! Теперь профайл есть, в чём легко убедиться, зайдя опять в свойство аккаунта:
Теперь идём в терминал: ведь нам нужен сам профайл, а он запрятан в хитром месте. Переходим в папку `~/Library/MobileDevice/Provisioning Profiles/` и видим, что у нас там либо бардак (если в системе много профайлов накопилось, у меня их 50 штук), либо порядок (если ты, читатель, являешься новичком в разработке под iOS).
Если же есть сомнения в том, какой именно профайл нам нужен, то можно воспользоваться моим [скриптом](https://gist.github.com/silvansky/3470cd7125356f166165) для поиска «того самого»:
Как видите, bundle id я использовал для поиска профайла.
Что ж, теперь у нас есть аккаунт разработчика и провижн профайл. Что нам теперь нужно? Ах да, нужна программка для переподписания ipa-файла нашим профайлом! Можно попробовать поколдовать с консолью, а можно воспользоваться готовым GUI-решением [iModSign](https://imzdl.com/downloads.html). Качаем программу и устанавливаем в `/Applications/`. Теперь можем запустить её и настроить. Я уже настраивал у себя, так что скриншоты не совсем верные для первого запуска, но я думаю, что ты, читатель, не идиот, так что разберёшься.
Первые две кнопки неактивны, ибо я уже их нажимал. По нажатию на первую устанавливаются command line tools, которые Xcode по умолчанию не ставит, по нажатию на вторую появляется окно выбора сертификата разработчика:
Конечно, у тебя, читатель, должен и здесь быть порядок, не то что у меня, в моей замусоренной системе.
По нажатию на третью кнопку, мы можем выбрать наш найденный профайл.
Ну вот и всё, программа настроена и готова к работе! Что бы нам такое установить?.. Ну, к примеру, [BarMagnet](http://iemulators.com/ipa) для управления торрент-качалками. Качаем .ipa файл и перетаскиваем в iModSign.
Готово для подписания! Жмём на «Start Job».
Заходим теперь в папку `iModSigned`, находящуюся на рабочем столе. Там видим уже подписанный ipa:
Дабл-клик — и он добавлен в iTunes, и теперь мы можем его установить на девайс. Я тестировал на iPad Air 2 с установленным iOS 9.0.2, ясно дело, никакого Jailbreak для него пока ещё нет.
После синхронизации и установки, которая проходит гладко, можно увидеть BarMagnet на устройстве:
Но он не запустится, можете поверить. А можете и проверить. Но это поправимо, просто наш девайс пока нам же не доверяет. Но мы его научим доверять, зайдя в настройки и подтвердив доверие разработчику:
У меня тут уже доверие включено, но в первый раз это выглядит немного иначе. Но опять же, ты же, читатель, не идиот? Найдёшь там нужную кнопку? Конечно, найдёшь!
Всё, можно запускать программу и радоваться возможности управления всеми своими торрентокачалками прямо с девайса!
Надеюсь, что ты, читатель, не будешь злоупотреблять данным методом и устанавливать игры, скачанные с торрентов. И конечно же, ты понимаешь, что всё написанное — чисто для ознакомления, а я не несу никакой ответственности за возможные последствия для девайса или ещё чего. И я не гарантирую работоспособность метода с последующими версиями iOS и Xcode. И даже с текущими!
Так что будьте осторожны. И берегите себя. | https://habr.com/ru/post/268515/ | null | ru | null |
# Защита контейнеров с помощью фильтров Seccomp
[](https://habr.com/ru/company/ruvds/blog/689184/)
Многие компании используют контейнеры в качестве фундаментальной технологии для управления своими приложениями и их выполнения. Если вы уже имеете опыт работы с контейнерами, то понимаете их мотивацию: контейнеры обеспечивают совершенно новые уровни портируемости и масштабируемости. Однако использование контейнеров, как и любой другой технологии, также означает и появление новых способов применения эксплойтов приложений.
При определённых конфигурациях контейнеров эксплойт приложения в конце концов может привести к компрометации хоста, на котором запущен контейнер. Также стоит учесть и другие вопросы, например, секреты, хранящиеся в контейнерах как переменные окружения, и то, к чему контейнеры имеют доступ. Если вы хотите больше узнать о рекомендациях по обеспечению безопасности контейнеров Docker, то можете воспользоваться [полезной шпаргалкой](https://blog.gitguardian.com/how-to-improve-your-docker-containers-security-cheat-sheet/).
Сложившийся жизненный цикл разработки ПО уже включает в себя процессы обеспечения безопасности, например, сканирование уязвимостей и анализ состава ПО, но требуется и нечто большее. Большинство существующих технологий обеспечения безопасности приложений предотвращают уязвимость приложений, но не многие способны предотвратить урон, вызванный успешным эксплойтом приложения. Я изучил новый способ защиты приложений в контейнерах **после внедрения эксплойтов**. В этом посте я расскажу, что это и как безболезненно интегрировать его в уже сложившиеся процессы разработки ПО. В качестве дополнительной защиты я использовал Seccomp-BPF, поэтому прежде чем вдаваться в подробности, нужно немного рассказать о нём.
▍ Вводная информация
--------------------
Выполняемые на компьютерах программы активно используют функции операционной системы. В современных языках программирования такие задачи, как открывание файлов и создание новых процессов, абстрагированы, однако внутри кода они выполняются при помощи запросов к ядру, называемых **системными вызовами** (syscall). Насколько важны syscall для работы программы? В ядре Linux есть примерно четыреста syscall, и даже в простой программе «Hello, World!», написанной на C, используются два из них: write и exit.
Код, выполняемый в так называемом «пользовательском пространстве», не может сделать ничего, не попросив сделать это ядро. Умные разработчики ядра Linux решили воспользоваться этим и создать мощную функцию защиты. В июле 2012 года была выпущена версия Linux 3.5, в которой была добавлена поддержка Seccomp-BPF.
> Seccomp-BPF — это функция ядра Linux, позволяющая **благодаря созданию специального фильтра ограничить список системных вызовов, которые может выполнять процесс**.
Теоретически можно создать фильтр Seccomp-BPF, позволяющий процессу выполнять только те syscall, которые необходимы для его работы, и ничего больше. Это будет полезно в случае, если приложение оказалось уязвимым для эксплойтов таким образом, что злоумышленник может создавать дополнительные процессы. Если Seccomp не позволяет процессу выполнять новые syscall, есть большая вероятность, что это помешает нападающему.
Seccomp — очень крутая штука, она даже интегрирована в среду выполнения контейнера и такие инструменты управления Docker и Kubernetes. Возникает вопрос: «Почему Seccomp не используют везде?» Думаю, причина в том, что не хватает ресурсов для восполнения пробела между низкоуровневой функцией ядра наподобие Seccomp и современными процессами разработки ПО. Не у каждой организации есть разработчик низкоуровневого кода, подробно знающий тему syscall. К тому же нужно тратить дополнительные ресурсы на то, чтобы разобраться, какие системные вызовы нужны вашей программе и дополнять её с каждой новой фичей, реализуемой в коде.
Я думал о том, как решить эту проблему, и пришёл к такой мысли: «Что, если записывать те syscall, которые выполняет программа в процессе своей работы?» Я рассказал о своей идее одному из коллег, и на следующий день он прислал мне ссылку на инструмент на GitHub. Оказалось, разработчики Red Hat уже создали инструмент под названием [`oci-seccomp-bpf-hook`](https://github.com/containers/oci-seccomp-bpf-hook), выполняющий именно эту задачу!
▍ Создание фильтра Seccomp-BPF
------------------------------
Инструмент `oci-seccomp-bpf-hook` был создан для работы с Linux-контейнерами. OCI расшифровывается как «Open Container Initiative», это набор стандартов для сред выполнения контейнеров, определяющий, какие виды интерфейсов они должны иметь возможность предоставлять. Соответствующие требованиям OCI среды выполнения (например, Docker) имеют механизм под названием «хуки», позволяющий запускать код до запуска контейнера и после завершения его работы. Вместо того чтобы объяснять, как инструмент Red Hat использует эти хуки, лучше будет показать это на примере.
Red Hat разработал `oci-seccomp-bpf-hook` для использования с его средой выполнения контейнеров podman. Podman во многом обратно совместим с Docker, поэтому, если вы работали с Docker, синтаксис в моих примерах будет казаться вам знакомым. Кроме того, хук OCI в настоящее время доступен только в связанных с Red Hat DNF-репозиториях, или его можно установить их исходников. Чтобы не усложнять демо, я просто воспользуюсь сервером Fedora (если у вас нет среды Fedora, то рекомендую запустить виртуальную машину Fedora на чём-нибудь наподобие Virtualbox или VMware).
Первым делом для использования `oci-seccomp-bpf-hook` нужно убедиться, что он установлен вместе с podman. Для этого можно выполнить следующую команду:
```
sudo dnf install podman oci-seccomp-bpf-hook
```
Теперь, когда у нас есть podman и хук OCI, мы можем наконец приступить к генерации фильтра Seccomp-BPF. В [readme](https://github.com/containers/oci-seccomp-bpf-hook) можно узнать, что синтаксис выглядит так:
```
sudo podman run --annotation io.containers.trace-syscall="if:[absolute path to the input file];of:[absolute path to the output file]" IMAGE COMMAND
```
Давайте выполним команду `ls` в простом контейнере и передадим вывод на `/dev/null`. При этом мы будем записывать системные вызовы, выполняемые командой `ls`, и сохранять их в файл `/tmp/ls.json`.
```
sudo podman run --annotation io.containers.trace-syscall=of:/tmp/ls.json fedora:35 ls / > /dev/null
```
Так как мы передаём вывод команды `ls` в `/dev/null`, в терминале вывода быть не должно. Однако после выполнения команды мы можем взглянуть на файл, в который сохраняли системные вызовы. В нём мы видим, что команда сработала и syscall были записаны:
```
cat /tmp/ls.json
{"defaultAction":"SCMP_ACT_ERRNO","architectures":["SCMP_ARCH_X86_64"],"syscalls":[{"names":["access","arch_prctl","brk","capset","chdir","close","close_range","dup2","execve","exit_group","fchdir","fchown","fstatfs","getdents64","getegid","geteuid","getgid","getrandom","getuid","ioctl","lseek","mmap","mount","mprotect","munmap","newfstatat","openat","openat2","pivot_root","prctl","pread64","prlimit64","pselect6","read","rt_sigaction","rt_sigprocmask","seccomp","set_robust_list","set_tid_address","sethostname","setresgid","setresuid","setsid","statfs","statx","umask","umount2","write"],"action":"SCMP_ACT_ALLOW","args":[],"comment":"","includes":{},"excludes":{}}]}
```
Этот файл и есть наш фильтр Seccomp, теперь мы можем использовать его с любой средой выполнения, которая его поддерживает. Давайте попробуем использовать фильтр с той же контейнированной командой `ls`, которую мы только что выполняли:
```
sudo podman run --security-opt seccomp=/tmp/ls.json fedora ls / > /dev/null
```
Нет ни вывода, ни ошибок, это означает, что команда была успешно выполнена с применённым фильтром Seccomp. А теперь начинается самое интересное. Мы добавим контейнеру возможностей, которых не было, когда мы записывали системные вызовы для создания фильтра Seccomp. Достаточно будет добавить команде `ls` флаг `-l`.
```
sudo podman run --security-opt seccomp=/tmp/ls.json fedora ls -l / > /dev/null
ls: /: Operation not permitted
ls: /proc: Operation not permitted
ls: /root: Operation not permitted
…
```
Как видите, на сей раз мы получаем серию ошибок, сообщающих, что нельзя выполнить операцию, которую пытается выполнить наша команда. Добавление флага `-l` к команде `ls` добавила процессу несколько новых syscall, которые отсутствуют в белом списке фильтра Seccomp. Если мы сгенерируем новый фильтр Seccomp с командой `ls -l`, то увидим, что новый фильтр работает, потому что теперь в нём есть все требуемые syscall.
```
sudo podman run --annotation io.containers.trace-syscall=of:/tmp/lsl.json fedora ls -l / > /dev/null
sudo podman run --security-opt seccomp=/tmp/lsl.json fedora ls -l / > /dev/null
```
Как видите, использование фильтров Seccomp с контейнерами сильно ограничивает их возможности. В ситуации, когда нападающий может использовать эксплойт вашего приложения, это может помешать ему нанести урон или вообще применять эксплойты.
Благодаря хуку OCI Red Hat, для создания фильтра Seccomp вам больше не нужно иметь глубоких знаний системных вызовов ядра Linux. Вы легко можете создать фильтр для конкретного приложения, не позволяющий контейнеру делать ничего сверх того, что он должен делать. Это серьёзный шаг для восполнения пробела между возможностями ядра и высокоуровневой разработкой ПО.
▍ В заключение
--------------
Как бы ни был прекрасен `oci-seccomp-bpf-hook`, сам по себе он не полностью исполнил мою мечту интегрировать Seccomp в сложившийся процесс разработки ПО. Всё равно необходимы дополнительные ресурсы, связанные с работой этого инструмента, а разработчики не будут гореть желанием тратить время на ручное изменение фильтра Seccomp под каждое обновление приложения. Чтобы окончательно восполнить этот пробел и максимально упростить использование Seccomp в энтерпрайз-приложениях, нам нужно найти способ автоматизировать генерацию фильтров Seccomp-BPF. К счастью, взглянув на современный процесс разработки ПО, мы находим идеальное место для внедрения этой автоматизации: **вовремя** **Continuous Integration (CI)**.
Процессы CI уже стали неотъемлемой частью сложившегося жизненного цикла разработки ПО. Если вы незнакомы с CI, то скажу, что она позволяет использовать такие возможности, как автоматизированное юнит-тестирование и сканирование безопасности кода, при каждом коммите в репозиторий git. Существует множество инструментов для CI, поэтому это идеальный этап для автоматизации генерации фильтра Seccomp для контейнированного приложения.
Вскоре я напишу ещё один пост с демонстрацией того, как создать процесс CI, генерирующий фильтр Seccomp при каждом обновлении кода. Благодаря этому, вы, наконец, сможете воспользоваться преимуществами ограничений syscall при помощи Seccomp и защитить свои приложения!
> **[Telegram-канал](https://bit.ly/3KZeaxv) и [уютный чат](https://bit.ly/3qoIOXs) для обсуждений**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=zashhita_kontejnerov_s_pomoshhyu_filtrov_seccomp) | https://habr.com/ru/post/689184/ | null | ru | null |
# Как правильно готовить автоматизацию или Что покрывать тестами в первую очередь
Привет, это Эрик Бурыгин, я техлид курса [«Автоматизатор тестирования на Java»](https://practicum.yandex.ru/qa-automation-engineer-java/?utm_source=pr&utm_medium=content&utm_content=28_10_21&utm_campaign=pr_content_qa-automation-engineer-java_habr) в Яндекс.Практикуме и лид в Яндексе. Каждый ручной тестировщик считает, что автоматизация — это круто и её непременно нужно втащить в проект. Что может быть лучше, чем полное покрытие автотестами продукта, когда тесты гоняются 24/7 и отлавливают баги? Вот прочитал я эти строки, и захотелось ещё раз всё заавтоматизировать!
Но, как это часто бывает, при внедрении автоматизации вы тратите много человеческих ресурсов, а профита долгое время не видно. Возникает вопрос о целесообразности этой инициативы. То, что на первых этапах автоматизация отнимает много сил — вполне нормально, но в перспективе она должна экономить время, а не наоборот. Попробуем понять, как этого добиться.
Выбор средств автоматизации имеет огромное значение, и здесь для каждого проекта всё очень индивидуально, однако это не самый важный вопрос, на который нужно ответить, поэтому мы не будем подробно останавливаться на нём в этой статье.
### Поймите, что автоматизировать в первую очередь
Для начала нужно чётко определиться с тем, что автоматизировать в первую очередь!
В большинстве проектов есть две сущности: регресс и смоук. Почему-то многие выбирают для старта автоматизации регресс или его части. Путь хорош, только вот достаточно тернист и долог. Конечно, даже 10 автотестов сократят регресс, но чтобы посчитать профит и защитить идею перед руководителями, этого будет маловато. Если, конечно, у вас в регрессе не 50 кейсов.
Давайте разберём все подводные камни такого пути на примере нашего проекта и пройдём путь ошибок и побед с самого начала.
*«По просьбе выживших имена персонажей были изменены. Из уважения к погибшим всё показано так, как было на самом деле».*
Итак, мы делаем приложение по продаже кастомных байков Custom Bike для платформ iOS и Android. Полный регресс приложения — это 2500+ кейсов на платформу и примерно несколько недель человеко-часов. Для написания тест-кейсов мы используем Testpalm от Яндекса. Релизимся часто. Но как бы мы не стремились ускорить процесс выкладки, регрессы оставались узким местом. Тестировщики утопали в них, теряя всякую мотивацию. Конечно, можно было нарастить команду, но это путь вникуда, так как новые фичи выкатываются каждый релиз и регресс становится всё необъятнее.
Вот мы и решили втащить в проект автоматизацию и, как вы наверное догадались, начали с регресса, а именно — с регресса Android-приложения. Благо культура автоматизации тестирования в команде была на высоком уровне — на тот момент мы очень преуспели в автоматизации веба и API. Но как всегда, без ложки дёгтя не обошлось — наша экспертиза в автоматизации мобилок была близка к нулю, а изучать новое было проблематично, ибо задач и так хватало. Как сейчас помню фразу: *«Чтобы автоматизировать Android, нужно становиться Android-разработчиком»*.
Однако нашлись энтузиасты, которые готовы были пробовать. Мы начали поднимать проект на Expresso, прикрутили Robot Pattern — и в путь! Мы занимались автоматизацией всё свободное время, так как рабочее было занято текущими задачами. Автоматизировали ночами дома, в барах, ресторанах и на пикниках. Так за месяц мы преодолели барьер в 30%, а через полгода вышли на 70% регресса. Круто — скажете вы. Да, круто. Однако нужно понимать, что больше ничем мы в своё свободное время не занимались, а со временем каждый процент регресса давался всё сложнее. Кейсы создавались постоянно, появлялись моменты, к которым просто так не подойти, к тому же нужно было качать инфраструктуру. Тесты начинали флакать, мы упирались в лимит ресурсов и технологий… Путь был неплох, но скажу честно — не у всех есть такой запал и временной ресурс.
Профит был, но мы всё равно не могли релизиться так часто, как хотели, а именно — выпускать релизы на каждой платформе раз в неделю. Начали думать и решили внедрить практику «смелых, до первой сломанной судьбы» — в каждом релизе пробегать не весь регресс, а проверять только места, где были изменения. Так у нас появились кастомные смоуки. В них входили дефолтные и критичные кейсы для приложения, а также кейсы на новые фичи и всё, что гипотетически могло быть затронуто. Этот подход хорош, но требует определённой экспертизы, потому что нужно обладать глубоким пониманием приложения и платформы и, конечно, уверенностью, что не выстрелит где-нибудь в неожиданном месте.
Кастомные смоуки дали хороший результат и сократили прохождение предрелизных кейсов до двух человеко-дней. Вы спросите: а как же 70% автоматизации? Дело в том, что смоук постоянно менялся, и не всегда тест-кейсы попадали в то, что уже было автоматизировано. К тому же автоматизация iOS находилась в зачаточном состоянии. При этом автотесты давали нехилую защиту от ошибок — перейдя на новый подход, некоторые из проверок мы стали делать очень редко.
### Как понять, что автоматизировать
Мы не остановились на достигнутом и стали думать дальше: как быть ещё более эффективными, ускорить процесс и не потерять в качестве. После анализа смоуков и регрессов за несколько месяцев поняли, что некоторые кейсы повторяются чаще, а некоторые встречаются по одному разу. Один раз собрать статистику и всё посчитать используя, например, Excel — не проблема. Но делать это каждый раз и поддерживать актуальность достаточно трудозатратно. Мы решили автоматизировать сбор статистики.
Testpalm позволяет без проблем выгрузить весь пул кейсов, что у нас есть.
Это можно сделать с помощью Python и библиотеки Requests. Пример:
```
requests.get('http://testpalm.ru/testcases/custombike')
```
Список кейсов получен, но нам нужна статистика, а пока мало что можно посчитать. Чтобы посчитать статистику, нужны маркеры. Testpalm отлично с этим справляется — там есть теги, поэтому мы начали при каждом сборе смоука добавлять тег-версию релиза: Android\_4.11, Android\_4.12, Android\_4.13 и т. д. Это позволило нехитрым способом сосчитать, сколько раз каждый кейс был задействован в смоуках из выгруженного джейсона. Пример:
```
count = (" ".join(item.get("attributes").get(attribute_version))).lower().count(platform)
```
Стало понятнее. Осталось забрать из полученного списка самую важную информацию, а именно: ссылку на кейс в Tespalm, название кейса, количество проходов — и вывести этот список. Пример кода:
```
print(item["link"] + " " + item["name"] + " {}".format(item["count"]))
```
Пример получившегося списка:
> https://testpalm.ru/testcase/custombike-994 Диплинки facebook 8
>
> https://testpalm.ru/testcase/custombike-1534 Реклама в листинге 8
>
> https://testpalm.ru/testcase/custombike-266 Карточка мото 7
>
> https://testpalm.ru/testcase/custombike-607 Геосаджест 7
>
> https://testpalm.ru/testcase/custombike-1286 Опция турбо 7
>
> https://testpalm.ru/testcase/custombike-1564 Опция продвижение 7
>
> https://testpalm.ru/testcase/custombike-1922 Опция поднятие 7
>
> https://testpalm.ru/testcase/custombike-567 Реклама в карточке мото 6
>
> https://testpalm.ru/testcase/custombike-663 Пожаловаться в карточке мото 6
>
> https://testpalm.ru/testcase/custombike-924 Диплинки на выдачу 5
>
> https://testpalm.ru/testcase/custombike-946 Смена региона 5
Теперь точно понятно! Но чтобы всё было по красоте, осталось обернуть полученные данные в табличку. Для хранения документации мы используем вики, и всё, что нужно было сделать — добавить вики-разметку в выводимый результат. Пример кода:
```
print("#|")
print("|| Ссылка на пальму | Название кейса| Количество проходов ||")
for item in cases_list:
print("|| " + item["link"] + " | " + item["name"] + " | {}".format(item["count"]) + " ||")
print("|#")
```
Так мы получили красивую легкочитаемую табличку.
**Смотреть пример в вики-разметке**
```
|| Ссылка на Testpalm | Название кейса | Количество проходов ||
|| https://testpalm.ru/testcase/custombike-994 | Диплинки facebook | 8 ||
|| https://testpalm.ru/testcase/custombike-1534 | Реклама в листинге | 8 ||
|| https://testpalm.ru/testcase/custombike-266 | Карточка мото | 7 ||
|| https://testpalm.ru/testcase/custombike-607 | Геосаджест | 7 ||
|| https://testpalm.ru/testcase/custombike-1286 | Опция турбо | 7 ||
|| https://testpalm.ru/testcase/custombike-1564 | Опция продвижение | 7 ||
|| https://testpalm.ru/testcase/custombike-1922 | Опция поднятие | 7 ||
|| https://testpalm.ru/testcase/custombike-567 | Реклама в карточке мото | 6 ||
|| https://testpalm.ru/testcase/custombike-663 | Пожаловаться в карточке мото | 6 ||
|| https://testpalm.ru/testcase/custombike-924 | Диплинки на выдачу | 5 ||
|| https://testpalm.ru/testcase/custombike-946 | Смена региона | 5 ||
```
В вёрстке таблица будет выглядеть так:
| | | |
| --- | --- | --- |
| Ссылка на Testpalm | Название кейса | Количество проходов |
| https://testpalm.ru/testcase/custombike-994 | Диплинки facebook | 8 |
| https://testpalm.ru/testcase/custombike-1534 | Реклама в листинге | 8 |
| https://testpalm.ru/testcase/custombike-266 | Карточка мото | 7 |
| https://testpalm.ru/testcase/custombike-607 | Геосаджест | 7 |
| https://testpalm.ru/testcase/custombike-1286 | Опция турбо | 7 |
| https://testpalm.ru/testcase/custombike-1564 | Опция продвижение | 7 |
| https://testpalm.ru/testcase/custombike-1922 | Опция поднятие | 7 |
| https://testpalm.ru/testcase/custombike-567 | Реклама в карточке мото | 6 |
| https://testpalm.ru/testcase/custombike-663 | Пожаловаться в карточке мото | 6 |
| https://testpalm.ru/testcase/custombike-924 | Диплинки на выдачу | 5 |
| https://testpalm.ru/testcase/custombike-946 | Смена региона | 5 |
Теперь понятно, с чего начинать автоматизацию, и актуальная статистика всегда будет под рукой. Круто! Но по мере автоматизации мы столкнулись с тем, что в статистику попадают кейсы, которые уже автоматизированы, или те, которые, наоборот, по какой-то причине нет смысла автоматизировать. Решение проблемы было простым — мы добавили ещё два тега:
* automation — для кейсов, которые уже автоматизированы,
* without\_automation — для кейсов, которые мы не хотим автоматизировать.
Их мы исключили из статистики. Пример кода:
```
# Проверяем, есть ли автотесты для данного кейса
if attributes_automation in item['attributes']:
# Проверяем, есть ли автотесты для данной платформы
if platform in " ".join(item['attributes'][attributes_automation]).lower(): continue
# Проверяем, есть ли ключ "without_automation" для данного кейса
if attributes_without_automation in item['attributes']:
# Проверяем, есть ли ключ "without_automation" для данной платформы
if platform in " ".join(item['attributes'][attributes_without_automation]).lower(): continue
```
Теперь табличка стала чище, и в ней остались только те кейсы, на которые нужно обратить внимание и завести задачи на автоматизацию. Для удобства добавили ещё один столбец — «Задача на автоматизацию». Пример кода:
```
print("#|")
print("|| Ссылка на пальму | Название кейса | Количество проходов | Задача на автоматизацию ||")
for item in cases_list:
print("|| " + item["link"] + " | " + item["name"] + " | {}".format(item["count"]) + " |" + " ||")
print("|#")
```
Пример таблички в вёрстке:
| | | | |
| --- | --- | --- | --- |
| Ссылка на Testpalm | Название кейса | Количество проходов | Задача на автоматизацию |
| https://testpalm.ru/testcase/custombike-266 | Карточка мото | 7 | |
| https://testpalm.ru/testcase/custombike-607 | Геосаджест | 7 | |
| https://testpalm.ru/testcase/custombike-1286 | Опция турбо | 7 | |
| https://testpalm.ru/testcase/custombike-1564 | Опция продвижение | 7 | |
| https://testpalm.ru/testcase/custombike-1922 | Опция поднятие | 7 | |
| https://testpalm.ru/testcase/custombike-567 | Реклама в листинге | 6 | |
| https://testpalm.ru/testcase/custombike-663 | Пожаловаться в карточке мото | 6 | |
| https://testpalm.ru/testcase/custombike-924 | Диплинки на выдачу | 5 | |
| https://testpalm.ru/testcase/custombike-946 | Смена региона | 5 | |
Так как у нас помимо приложения Custom Bike есть и другие проекты, каждый из которых поддерживает iOS и Android, нужно было сделать скрипт формирования статистики более гибким. Мы ещё немного доработали код, и теперь при запуске скрипта можно передавать в него проект и платформу, получая статистику для нужного приложения. Пример запуска скрипта:
```
python3 get_statistics.py custombike android
```
Чтобы в табличке был только топ самых используемых кейсов, мы добавили чувствительность, которую также можно передавать в скрипт. Пример запуска скрипта:
```
python3 get_statistics.py custombike android -m=6
```
Пример таблички:
| | | | |
| --- | --- | --- | --- |
| Ссылка на Testpalm | Название кейса | Количество проходов | Задача на автоматизацию |
| https://testpalm.ru/testcase/custombike-266 | Карточка мото | 7 | |
| https://testpalm.ru/testcase/custombike-607 | Геосаджест | 7 | |
| https://testpalm.ru/testcase/custombike-1286 | Опция турбо | 7 | |
| https://testpalm.ru/testcase/custombike-1564 | Опция продвижение | 7 | |
| https://testpalm.ru/testcase/custombike-1922 | Опция поднятие | 7 | |
| https://testpalm.ru/testcase/custombike-567 | Реклама в листинге | 6 | |
| https://testpalm.ru/testcase/custombike-663 | Пожаловаться в карточке мото | 6 | |
Вот теперь всё стало по красоте!
### Заключение
Когда есть понимание, что именно автоматизировать, сделать это можно быстро, потому что перед вами не стоит мучительный вопрос о приоритетах. На выходе вы получите результаты в виде покрытого тестами смоука или сокращения количества кейсов в кастомных смоуках, а также покроете тестами основные части проекта.
В смоуке, как правило, все кейсы разные, и с помощью нашего подхода мы перекрываем большую часть уникальных сценариев, что позволяет наработать хорошую кодовую базу. С ней можно двигаться дальше и писать тесты по образу и подобию уже имеющихся. Ещё хочется отметить, что такой подход подойдёт как устоявшимся проектам, так и стартапам. И не забываем про хорошую и понятную отчётность — будет что показать руководителю и менеджерам. Кроме того, отчётность позволит легко ориентироваться в тестовом покрытии — с этой задачей отлично справится Allure.
Надеюсь, статья показалась вам интересной. Если у вас остались вопросы или есть собственные идеи по поводу автоматизации — пишите в комментарии, обсудим. | https://habr.com/ru/post/585628/ | null | ru | null |
# Отличный консольный irc клиент «Weechat»
Крайне давно, я использую замечательный консольный IRC клиент [WeeChat](http://weechat.org). У него очень много достоинств, на пример для него можно написать расширения на пяти(!) языках: perl, ruby, python, lua, tcl). Русскоязычной документации по нему почти нету, и на хабре ни единого упоминания про него. Именно поэтому, я решил сделать копипасту со своего блога сюда, в хабрахабр.
Не так давно, после двух лет разработки, и принятия около 1000 патчей и улучшений, вышла версия 0.3. Все ждали появления jabber плагина, и он там появился, но крайне сырой. Кстати сам по себе weechat, не умеет работать с сетями (IRC/etc), он умеет выводить только информацию через ncurses (в разработке GUI на QT, GTK и Tcl). Все его возможности осуществляют плагины (IRC, aspell, charset etc обо всем этом чуть ниже).
И так приступим:
#### Получение weechat
Weechat сейчас входит в состав почти всех распространенных дистрибутивов. Так что вы можете его установить оттуда. Если его в них нет, или вы хотите самую свежую версию, то можете скачать и собрать из git:
`git clone git://git.sv.gnu.org/weechat.git`
#### Добавление и настройка сервера
Для того, чтобы подключиться к irc сети, необходимо ее добавить:
`/server add dalnet irc.avtograd.ru/6667`
Здесь я добавляю сервер irc.avtograd.ru с подключением к 6667 порту,
и даю ему имя dalnet.
Далее установим свои ники =)
`/set irc.server.dalnet.nicks «ник1,ник2,ник3,ник4,ник5″`
Теперь имя пользователя, и ваше реальное имя
`/set irc.server.dalnet.username "Имя_пользователя"`
`/set irc.server.dalnet.realname "Реальное_имя"`
Если вы хотите автоматически подключатся к сети при включении, то пишем:
`/set irc.server.dalnet.autoconnect on`
Для автовхода на каналы:
`/set irc.server.dalnet.autojoin "#channel1,#channel2"`
Если вам необходимо выполнить какую либо команду после подключения к серверу, на пример для идентификации ника NickServ используем команду:CE
`/set irc.server.dalnet.command "/msg nickserv identify xxxxxx"`
Сохраняем:
`/save`
После всего этого пишем /connect dalnet или если установили автоподключение при запуске, то перезапускаемся и радуемся! ;)
#### Настройка кодировки
Кодировка это на мой взгляд сильная сторона этого клиента. В нем она настраивается легко, и не принужденно. При чем очень гибко.
Если сервер использует CP1251 (какой не православный сервер ;) ) то пишем:
`/charset CP1251`
Это установит для входящих и исходящих сообщений одну кодировку – CP1251.
Если необходимо разные кодировки для входящих и исходящих сообщений, то служат параметры decode и encode
`/charset decode UTF-8`
`/charset encode CP1251`
А теперь главное: Чтобы установить кодировку для конкретного сервера, необходимо выполнить команду /charset в ее буфере. Допустим, чтобы установить глобальную кодировку, необходимо выполнить:.
`/set charset.default.decode UTF-8`
`/set charset.default.encode UTF-8`
#### Проверка орфографии
Пожалуй, уже не один линуксоид не может жить без проверки орфографии :) В weechat для его настройки используется плагин aspell и требует установленного в системе aspell.
Посмотреть все словари которые есть в системе, можно командой:
`/aspell dictlist`
Вывод команды будет показан в буфере сервера.
Чтобы глобально установить русскую проверку орфографии необходимо установить соответствующий параметр в нужное значение:
`/set aspell.check.default_dict "ru"`
Чтобы в определенном буфере установить определенный словарь, необходимо в его буфере установить его. Т.е. допустим чтобы установить для англоязычного канала #awesome английский словарь, просто переходим в его буфер и пишем:
`/aspell enable en`
Кстати, вы всегда можете глобально установить несколько языков для проверки:
`/set aspell.check.default_dict "ru, en"`
#### Базовые понятия
В weechat существуют буферы и окна (buffers\window). По умолчанию, когда вы подключитесь к серверу и зайдете на канал, то у вас будет одно окно, с одним буфером, и небольшое вертикальное окна со списком всех присутствующих. В каждом буфере, не более одного чата. Окно вы можете поделить на две или более частей как вам угодно. На пример, для разделения окна на половину по вертикали надо написать:
`/window spitv 33`
В каждом из окон может быть свой независимый буфер. Для перемещения между окон, используйте клавиши F7\F8.
Для перемещения между буферами, можно использовать команду /buffer и указать номер буфера. На пример команда /buffer 3 перейдет на третий буфер.
#### Плагины
Как я уже выше писал, в weechat очень большая возможность к расширяемости. Написать дополнения к нему можно на пяти(!) языках: python, ruby, lua, perl и tcl! Сейчас плагинов существует не так много как хотелось бы, но их вполне достаточно. Посмотреть все существующие плагины можно на этой странице – [weechat.org/plugins](http://weechat.org/plugins/)
Вообще, я бы рекомендовал скачать дополнение weeget.py С его помощью, можно просматривать и устанавливать дополнения прямо из самого weechat. И так, скачем и установим weeget. В консоли пишем:
`cd ~/.weechat/python/autoload`
`wget weechat.org/files/scripts/weeget.py`
Все плагины, weechat держит в своей папке в домашней директории. Для каждого языка своя папка. Для того, чтобы weechat загружал необходимые плагины при запуске, надо поместить еще и в папку autoload, что мы и сделали. У каждого языка своя папка autoload.Чтобы загрузить недавно добавленные в autoload плагины можно ввести имя языка, и следом команду autoload. На примере perl это может выглядеть так:
`/perl autoload`
Чтобы загрузить какой либо плагин, необходимо в зависимости от языка на котором он сделан положить в директорию, и написать примерно следующую конструкцию:
`/язык load имя_плагина.расширение`
На пример для плагина weeget.py
`/python load weeget.py`
Так же можно просмотреть все доступные с помощью параметра list или выгрузить с помощью unload
`/python list`
`/python unload weeget.py`
Для «установки» плагинов я чуть выше рекомендовал weeget. Пользоваться ее крайне просто. Идем в «командный» буфер и пишем следующее:
`/weeget list`
Появиться список всех плагинов которые есть на сайте. Если вы хотите отсортировать по слову, или тэгу, то просто добавьте его. На пример game:
`/weeget list game`
Чтобы установить плагин, необходимо использовать команду install:
`/weeget install имя_плагина`
На пример для плагина weetris.pl:
`/weeget install weetris`
Для удаления служит параметр remove:
`/weeget remove weetris`
Для получения дополнительной информации напишите:
`/help weeget`
Кстати, крайне полезен плагин buffers который выводит слева, список всех буферов с номерами.
#### Быстрые клавиши и часто-используемые команды
**Команды:**
\* /join #канал Войти на канал
\* /leave – покинуть- текущий канал
\* /buffer close – закрыть текущий буффер
\* /buffer clear – очистить буффер
\* /connect имя\_сервера – подключиться к определенному серверу
\* /connect -all – подключиться ко всем серверам
\* /disconnect -all – отключиться от всех серверов
\* /disconnect имя\_сервера – отключиться от определенного сервера
\* /quit – выход
**Клавиатурные сочетания**
\* ctrl+a – В начало строки
\* ctrl+e – В конец строки
\* ctrl+k – Удалить от позиции курсора, до конца командной строки
\* ctrl+u – Удалить от позиции курсора, до начала командной строки
\* ctrl+w – Удалить предыдущее слово командной строки
\* alt+d – удалить следущее слово командной строки
\* alt+r – Удалить все содержимое командной строки
\* ctrl-r – Поиск
\* ctrl+y – Вставить из буфера
\* alt+b – К предыдущему слову командной строки
\* alf+f – К следующему слову командной строки
\* alt+n – Прокрутить к следующему подсвеченному сообщению
\* alt+p – Прокрутить в предыдущему подсвеченному сообщению
\* alt+u – Перейти к первому непрочитанному сообщению
\* ctrl+n(F6) – Следующий буфер
\* ctrl+p(F5) – Предыдущий буфер
\* F12 – на одну страницу ников вниз
\* F11 – на одну страницу ников вверх
\* Alt+1-9 – на буфер с номером
\* Alt+a – Перейти к буферу с активностью(где написали ваш ник к примеру)
\* PageUp – пролистать буфер вверх
\* PageDown – пролистать буфер вниз
**Заключение:**
В заключении хочу написать что это еще далеко не все возможности weechat. Я просто описал то, что было бы не плохо настроить настроить и знать перед использованием. К тому же, в weechat крайне не плохая своя англоязычная справка, которую легко вызвать просто написав /help.
Напоследок скриншот:
[](http://itmages.ru/image/view/10975/995294)
**Полезные ссылки:**
\* [Документация weechat на нескольких языках](http://weechat.org/doc/)
\* [Страница с плагинами](http://weechat.org/plugins/)
\* [Weechat WiKi](http://wiki.flashtux.org/wiki/Main_Page)
\* IRC: irc.freenode.net каналы #weechat и #weechat-fr
\* [Пописка на рассылку](http://mail.nongnu.org/mailman/listinfo/weechat-support)
\* [Архив рассылки](http://mail.nongnu.org/archive/html/weechat-support)
\* Обратная связь с авторами – [email protected]
\* [Оригинал в моем блоге](http://the-bosha.ru/2009/10/07/weechat/)
Публикую в своем личном блоге, т.к. подходящего не нашел, и не знаю уместен ли подобный пост здесь. Предложения по публикации в определенный блог уместны, и буду им крайне рад =)
Кстати, этот пост, меня попросил написать мой хороший знакомый renya. Он давно читает хабр, но у него нету аккаунта здесь. Если есть добрые люди с инвайтом, поделитесь с ним — [email protected] =)
UPD: Перенес в \*nix. Более подходящего блога не нашел. | https://habr.com/ru/post/71875/ | null | ru | null |
# jQuery State form или простой контроль за формой
Доброго времени %username%!
Хочу представить на суд общественности один интересный плагин для контроля за состоянием формы.
Что такое «состояние формы»? Это слепок тех значений, которые были установлены в форме на момент её инициализации. В плагине нет ничего лишнего, никакого «преферанса и блудниц», только то, для чего он разрабатывался, а именно контроль за изменением значений в форме. Для чего это нужно? Ну, бывают всякие ситуации, например, для логирования изменений, которые были внесены в данные. Можно попробовать контролировать событие ухода со страницы, вдруг, пользователь что-то ввел, а сохранить забыл?
Кому интересно, можно поиграться на [jsfiddle](http://jsfiddle.net/Slavenin/3vk4k/1/).
Сам по себе плагин крайне прост. Инициализация:
```
$(document).ready(function() {
$('form').state_form();
});
```
или расширенные вариант:
```
$(document).ready(function() {
$('form').state_form({
//name input in form
inputName: 'changed_state', //is default
//add input with changes in form
insertInForm: 1, //is defaul
//function before form submit
//call if form has changes
ifChanged: function() { //is default
return true;
},
//field for excluded
exclude: ['field1', 'field2']
});
});
```
Проверка изменения состояния:
```
$('form').state_form('is_changed');
```
Получить изменённые поля:
```
$('form').state_form('get_changes');
```
На событие отправки формы навешивается обработчик, который перед этим собирает все изменения кодирует их в json, создает в форме поле, куда вставляет получившуюся строку и изменения отправляются на сервер. Данную возможность можно отключить.
UPD: обновил плагин до 0.0.3, где добавил методы работы с историей состояний. Спасибо [RubaXa](http://habrahabr.ru/users/rubaxa/) за пожелания и критику!
Исходный код [github.com/Slavenin/state\_form](https://github.com/Slavenin/state_form)
Буду рад комментариям и предложениям!
Благодарю за внимание! | https://habr.com/ru/post/207338/ | null | ru | null |
# Фильтр Блума на PHP
#### Что это?
[Википедия гласит:](http://ru.wikipedia.org/wiki/%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D0%91%D0%BB%D1%83%D0%BC%D0%B0)
> Это вероятностная структура данных, придуманная Бёртоном Блумом в 1970 году, позволяющая компактно хранить множество элементов и проверять принадлежность заданного элемента к множеству. При этом существует возможность получить ложно-положительное срабатывание (элемента в множестве нет, но структура данных сообщает, что он есть), но не ложно-отрицательное.
#### А попроще
Это способ проверки существования элемента в огромной выборке.
#### Как это работает?
Довольно просто. Мы имеем битовый объект определенной длины. Также определяем несколько уникальных хеш-функций. Каждое значение выборки проходит через каждую хеш-функцию, которая возвращает позицию в битовой строке и устанавливает в нее 1.
Позже, когда нам необходимо узнать, есть ли элемент в выборке, мы просто пропускаем его через все хеш-функции. Если на всех позициях битовой строки была 1, то объект «возможно присутствует», если хотя бы в одном месте был 0, то объекта нет.
На википедии приведена матмодель определения длины битовой строки и количества хеш-функций для определенного размера выборки и процента ложно-положительного срабатывания.
#### Где это можно применить?
Я применяю фильтр, чтобы проверить существования слова или фразу в словаре >10000000 слов. Гугл применяет его в своем поисковом движке.
Вообще положительный момент фильтра Блума в скорости его работы, когда соотношение операций Вставка/Проверка более 0.001 и проверок более 10000. Но это только если сравнивать со стандартным **in\_array** в PHP.
**Плюсы очевидны:** скорость, меньшая нагрузка на диск, меньшее потребление памяти.
**Минусы:** долгая загрузка значений, нет возможности удаления (есть решение)
#### Зачем еще один велосипед? Я уверен, уже делали фильтр Блума на php.
Да, делали. Я провел бенчмарки и моя реализация опередила по скорости и расходу памяти все, которые я смог завести. Об уникальности хеш-алгоритмов я вообще промолчу.
#### В чем соль?
На самом деле проблемы две.
**1. Как хранить битовую строку**
**2. Нужен уникальный хеш.**
**1.** Тут проблема скорее в том, как хранить битовую строку для варианта с удалением. В том случае используется счетчик и выставляется не 1, а инкремент при добавлении объекта. Я решил использовать алфавит. Но удаление штука не самая хорошая, удаляются элементы, на которые фильтр отвечает **«возможно присутствует»** и если это было ложно-положительное срабатывание, мы удалим несуществующий объект.
**2.** Я не специалист по хешам и подбирал функцию хеширования по 2м показателям.
**Скорость работы**, наверное самый важный показатель. **Уникальность**, при создании 1000 уникальных хешей, на одну и туже строку они должны выдать 1000 различных значений. Я, к сожалению, добился только 64% уникальности. У конкурентов выше 40% показатель не поднимался.
И это всего лишь:
```
abs( crc32( md5($this->seed[0] . $string) ) ) % $size;
```
Уникальность создается при помощи рандомной строки $this->seed[0].
#### Где попробовать?
Милости прошу на [Github](https://github.com/mrspartak/php.bloom.filter).
И пробуем:
```
include 'bloom.class.php';
$parameters = array(
'entries_max' => 2 //создаем Объект для выборки из 2х элементов, с дефолтной вероятностью ошибки 0.1%
);
$bloom = new Bloom($parameters);
//добавляем элемент, можно добавить массив элементов
$bloom->set('Some string');
//проверяем наличие элемента
echo $bloom->has('Some string'); //true
//удаление объекта, только если Bloom был инициирован с параметром counter
$bloom->delete('Some string');
```
Доступные параметры:
```
/*
//основные
entries_max (int) Размер выборки. По умолчанию: 100.
error_chance (float) (0;1) Шанс ошибки. По умолчанию: 0.001.
counter (boolean) Используется для включения режима счетчика, чтобы можно было удалять объекты. По умолчанию: false.
//на свой страх и риск
set_size (int) Размер битовой строки. По умолчанию: вычисляется.
hash_count (int) Количество уникальных хешей. По умолчанию: вычисляется.
//параметры для Хешей, вложенным массивом
['hash']
strtolower (boolean) Конвертировать строки в нижний регистр или нет. По умолчанию: true;
*/
```
Прилагаются примеры, юнит-тесты, и бенчмарки (сравнение с in\_array двумя способами и с тремя другими библиотеками). Многие из Вас и сами способны это написать, но возможно кому-то не захочется велосипедить.
**Бонус:** бенчмарк на 50 000 выборку с 25000 проверок против in\_array без счетчика и со счетчиком.
 | https://habr.com/ru/post/170705/ | null | ru | null |
# Фотосайт на MVC 4 для начинающих
[](http://www.bongiozzo.ru)
Если у кого-то есть желание сделать свой фотосайт или познакомиться с ASP.NET MVC на примере, возможно, пригодится мой опыт создания такого сайта и исходники лягут в основу собственного проекта.
Чтобы было понятно о чем пойдет речь, ссылка на сайт — [www.bongiozzo.ru](http://www.bongiozzo.ru).
А теперь, собственно, как это было сделано.
Что хотелось?
* Сделать портфолио в виде нескольких фотоальбомов и добавить контекст из соц сетей;
* Хотелось сделать что-то свое — я изначально не смотрел на готовые решения;
* В качестве хранилища фотографий сразу планировал использовать существующие сервисы фотохостинга с активным сообществом фотографов — у сервисов есть API, кроме того, фотографии публикуются для обратной связи, а получить ее можно, прежде всего, там;
* По той же причине, прикрутить к фотографиям кнопки Facebook и Twitter;
* Для просмотра фотографий планировалось обзавестись стильной галереей, которая будет хорошо выглядеть на планшетах;
* Ну и в завершении, хотелось все это выложить на оптимальный, с точки зрения соотношения стоимость/сервис, хостинг.
Задача поставлена, поехали…
##### Определяемся со средой разработки и framework
Первым делом [свободно скачал](http://www.microsoft.com/visualstudio/11/en-us) и установил Visual Studio 2012 RC. Для разработки веб сайтов доступны Web Forms и MVC — мои симпатии всецело лежат на стороне MVC, т.к. этот паттерн использовал для создания сайтов на Perl, когда ещё Web Forms и в помине не было :).
По поводу версии MVC тоже особых раздумий не было — раз уж все новое (VS 2012 на Windows 8), то и разрабатывать буду на последней версии MVC 4.
##### Главное — контент
Pro аккаунт на [Flickr](http://www.flickr.com) у меня уже был, хотя это абсолютно необязательное условие. Автоматическая группировка и сортировка фотографий по альбомам на Flickr у меня уже тоже была настроена с помощью сервиса [SmartSetr](http://ericappel.net/smartsetr). Поэтому первым делом открыл Nuget Package Manager и, введя Flickr, получил в проекте поддержку Flickr API c помощью библиотеки Flickr.NET.
*Возможно позднее рассмотрю перенос CMS на [500px](http://www.500px.com), а может кто-то это сделает быстрее меня.*
Идея использования Flickr как CMS была простой — фотоальбомы с ключевым словом Project в описании будут отображаться на моем сайте (во Flickr они называются Photoset). Фотографии в альбоме будут отсортированы по популярности, определяемой пользователями Flickr.
Вот какие несложные методы получились для модели формирования данных FlickrModel.
```
public List GetProjects(string language)
{
PhotosetCollection flickrPhotosets = flickr.PhotosetsGetList(Properties.Settings.Default.FlickrUserId);
Regex reg\_Project = new Regex(@"^Project\s+([^\|].\*)\s+\|\s+(.\*)");
Match m;
List returnProjects = new List();
foreach (Photoset item in flickrPhotosets)
{
m = reg\_Project.Match(item.Description);
if (m.Success)
{
FlickrProject prj = new FlickrProject();
prj.Description = getDescription(item.Description, language);
prj.PhotosetId = item.PhotosetId;
prj.Photos = GetPhotosetPhotos(item.PhotosetId, language);
prj.PrimaryPhoto = prj.Photos.ToList().Find(
delegate(Photo ph)
{ return ph.PhotoId == item.PrimaryPhotoId; });
returnProjects.Add(prj);
}
}
return returnProjects;
}
public PhotosetPhotoCollection GetPhotosetPhotos(string photosetId, string language)
{
PhotosetPhotoCollection photos = flickr.PhotosetsGetPhotos(photosetId, PhotoSearchExtras.Description );
foreach (Photo item in photos)
{
item.Title = getTitle(item.Title, language);
item.Description = getDescription(item.Description, language);
}
return photos;
}
```
Не сложнее выглядят модели для последних публикаций [Twitter](http://www.twitter.com) и оценок на фильмы с [Kinopoisk](http://www.kinopoisk.ru).
Если вы обратили внимание — метод возвращает названия и описания фотографий на разных языках.
##### Называть фотографии для своих или на английском?
Был у меня такой вопрос некоторое время назад. Я решил, что буду дублировать названия на русском и английском, разделяя их вертикальной чертой |. Теперь такое именование стало возможным использовать на сайте лучшим образом — если посетитель по умолчанию использует Русский в настройках браузера — показывать ему родные названия, иначе английские. В отличие от сайтов фотохостинга на моем сайте это будет выглядеть естественно, без всяких разделительных палок.
В MVC есть механизм фильтров, которые применяются ко всем или отдельным запросам. Для этой задачи был реализован фильтр LocalizationAware, который будет отрабатывать на запросах к основным страницам сайта и выставлять нужную языковую культуру в зависимости от настроек браузера:
```
public class LocalizationAwareAttribute : ActionFilterAttribute
{
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
var httpContext = filterContext.HttpContext;
string language = "en";
HttpCookie langCookie = httpContext.Request.Cookies["lang"];
if (langCookie == null)
{
if (httpContext.Request.UserLanguages != null &&
httpContext.Request.UserLanguages[0].IndexOf("ru", StringComparison.OrdinalIgnoreCase) != -1)
language = "ru";
httpContext.Response.AppendCookie(createCookie(language));
}
else
if (langCookie.Value == "ru")
language = "ru";
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(language);
}
public static HttpCookie createCookie(string language)
{
HttpCookie cookie = new HttpCookie("lang", language);
cookie.Expires = DateTime.Now.AddYears(1);
return cookie;
}
}
```
Конечно же, есть возможность поменять язык, если выбор по умолчанию не устраивает:
```
public ActionResult setLanguage(string id)
{
id = id == "ru" ? "ru" : "en";
Response.AppendCookie(LocalizationAwareAttribute.createCookie(id));
return Redirect("/");
}
```
Помимо названий фотографий, все элементы страницы — заголовки и тексты теперь тоже автоматически переключаются на выбранный язык благодаря выставленной языковой культуре и наличие в проекте двух ресурсных файлов — Resources.resx и Resources.ru.resx. Что-то кодировать дополнительно для этого не потребовалось — этот функционал встроенный.
##### Быстродействие и кэширование
Плюсы сетевых сервисов очевидны, однако эти преимущества будут сведены на нет, если отклик будет небыстрым, особенно в пиковые нагрузки. Очевидно, ответы от Flickr, Twitter и других систем требуется кэшировать.
Сделать это просто — достаточно подключить соответствующий фильтр, указав перед методом атрибут OutputCache.
Для формирования страницы у меня используется несколько Actions — основной запрос (Index, например) и несколько ChildActions для рендера частей страницы, содержащих ответы от разных внешних систем. Для каждого типа контента можно использовать свою продолжительность хранения в кэше, в зависимости от динамики изменений.
```
[LocalizationAware]
[OutputCache(Duration = 20 * 60, Location = System.Web.UI.OutputCacheLocation.Server, VaryByCustom = "lang")]
public ActionResult Index()
{
return View(bag);
}
[ChildActionOnly]
[OutputCache(Duration = 10*60*60)]
public ActionResult GetProjects(string language)
{
HomeViewBag bag = new HomeViewBag();
FlickrContext flickr = new FlickrContext();
bag.FlickrProjects = flickr.GetProjects(language);
return View(bag);
}
[ChildActionOnly]
[OutputCache(Duration = 60 * 60)]
public ActionResult GetLastPhotos(string language)
{
HomeViewBag bag = new HomeViewBag();
FlickrContext flickr = new FlickrContext();
bag.LastPhotos = flickr.GetLastPhotos(5, language, 1).ToList();
return View(bag);
}
```
ASP.NET MVC сам разделяет закэшированные копии результатов в зависимости от значений входных параметров. Для ChildActions входные параметры в виде языка явно определены, однако для основных запросов потребуется разделять кэш в зависимости от языка сессии и этот параметр явно не присутствует в параметрах. Это реализуется с помощью атрибута VaryByCustom = «lang» и специального метода GetVaryByCustomString. Теперь в кэше не должно быть наложений.
```
public override string GetVaryByCustomString(HttpContext context, string arg)
{
if (arg.ToLower() == "lang")
{
string langParam = context.Request.QueryString["lang"];
HttpCookie langCookie = context.Request.Cookies["lang"];
if (langParam != null)
return langParam == "ru" ? "ru" : "en";
else
if (langCookie != null)
return langCookie.Value == "ru" ? "ru" : "en";
return "";
}
return base.GetVaryByCustomString(context, arg);
}
```
##### Дизайн и фотогалерея
Т.к. задача изначально ставилась — сделать сайт самостоятельно, а сам я совсем не дизайнер, было сразу решено сделать вид сайта максимально простым и ограничиться выразительными способностями CSS3 и HTML5. Тем более, что на фотосайте основной акцент должен идти на фотографии и их подачу.
Поэтому я поискал доступные для использования галереи и остановился на стильном решении [Galleria](http://galleria.io/). Галерея написана на jQuery, имеет свой API, базовая редакция, достаточная для расширения — бесплатна и доступна для использования. То, что нужно.
Помимо незначительных корректировок в модуль инициализации галереи добавил свои элементы навигации и интеграцию с соц сетями:
```
this.append({ 'stage': ['closeBG', 'socialBG'] });
this.$('socialBG').html('');
this.$('closeBG').bind("click", function (e) { window.location = "/"; });
```
Наполнение галереи фотографиями выглядит как заполнение массива в JSON формате данными, полученными из FlickrModel.
Формирование JSON в Controller:
```
private string getJSON(List list, string p)
{
List json = new List();
foreach (Photo pht in list)
json.Add(new PhotoJSON
{
thumb = pht.ThumbnailUrl,
image = pht.LargeUrl,
title = pht.Title,
description = pht.Description,
link = pht.WebUrl,
url = Settings.Default.SiteURL + Url.Action("Gallery", new { controller = "Home", id = pht.PhotoId, photoset = p })
});
JavaScriptSerializer serializer = new JavaScriptSerializer();
return serializer.Serialize(json);
}
```
JavaScript во Viewer:
```
var data = @Html.Raw(Model.PhotosJSON);
Galleria.loadTheme('/galleria/themes/bongiozzo/galleria.bongiozzo.js');
Galleria.run('#galleria', {
show: @Model.IndexOfCurrentPhoto,
transition: 'slide',
initialTransition: 'fade',
dataSource: data });
```
##### Вешаем твиты и лайки
На событие переключения фотографии в галерее вешаем обновление кнопок Facebook и Twitter.
```
this.bind("image", function (e) {
document.title = galleria.getData().title;
$('#div-fblike').html('');
$('#div-twitter').html('[Tweet](https://twitter.com/share)');
try {
FB.XFBML.parse(document.getElementById('div-fblike'));
twttr.widgets.load();
} catch(ex) {}
});
```
И не забываем заполнить OpenGraph теги для корректного отображения в Facebook и других OG совместимых системах.
```
"))" />
```
##### Где хостить проект?
К моменту когда фотосайт можно было запускать, очень кстати стал доступен облачный хостинг [Windows Azure с 10 бесплатными Shared сайтами](https://www.windowsazure.com/en-us/pricing/calculator/). Есть отдельная стоимость за базу данных и траффик, однако, учитывая, что базы данных у меня нет и сами фотографии хранятся на Flickr, а, соответственно, нет и траффика — хостинг видится практически бесплатным. При этом, в случае c Azure, у меня нет вопросов касательно качества и доступности сервиса, что немаловажно. Управление сервисом понятное и простое — перед Azure я рассматривал хостинг от других провайдеров и это особенно бросилось в глаза на контрасте запутанного интерфейса, переписки и общения по телефону со службами поддержки.
Есть, к сожалению, одно НО — нельзя привязать свое доменное имя к этому Shared сайту. Для тех, кому собственное доменное имя пока не сильно нужно и устраивает URL типа bongiozzo.azurewebsites.net — это, действительно, оптимальный вариант.
Однако, [есть надежда](https://twitter.com/scottgu/status/210972290719031298), что это временное ограничение для Shared сайтов. Поэтому пока я перевел сайт в режим Reserved, в котором такую привязку сделать можно. В любом случае пока работает 90 дневный Trial и у меня есть MSDN подписка с включенной предоплатой определенного количества сервисов Azure.
Выйдет следующая версия Azure Web Sites — буду смотреть, возможно переведу на минимальный хостинг [Infobox.ru](http://infobox.ru/hosting/winplans/), [Parking.ru](http://parking.ru/shared/win/) и т.д., или [XS экземпляр облачных служб](http://www.windowsazure.com/en-us/pricing/calculator/?scenario=cloud), а пока работает, работает отлично и денег не стоит.
##### В качестве заключения
* Проект оказался несложным — в самый раз для знакомства или разминки. Ушло с десяток вечеров на знакомство с ASP.NET MVC 4, CSS3, jQuery и Azure;
* Исходники можно взять здесь — [bongiozzo.codeplex.com](https://bongiozzo.codeplex.com/);
* Буду рад вопросам, конструктивным пожеланиям и комментариям — [@bongiozzo](https://twitter.com/#!/bongiozzo/); | https://habr.com/ru/post/146216/ | null | ru | null |
# Используем Webex в Linux
#### Проблема
Webex использует 32битные Linux библиотеки для своей работы, поэтому работать в 64битной системе (а такие сейчас практически все десктопные Linux) отказывается.
```
% file ~/.webex/12_1324/libwelsvp.so
/home/user/.webex/12_1324/libwelsvp.so: ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV), dynamically linked, stripped
```
Выражается это в том, что вы не слышите и вас не слышат. Ошибка «The Audio Device is Unaccessible Now» — это с большой долей вероятности оно.
Обращение в службу поддержки компании Cisco и их ответ дали мне некоторую пищу для размышлений
> Hello Andrey,
>
> Thank you for contacting the Corporate Support Team!
>
> This is to inform about the Linux support base with we webex meetings will not be supported with 64 bit. yes
Поразмышлял об индусском английском немного.
О том, что Cisco положило болт на пользователей Linux, размышлять не хотелось, и так очевидно.
#### Решение
Решение после всего этого достаточно очевидно. Поставить ~~винду~~ и настроить 32битные версии браузера (я буду рассматривать Firefox) и Java и запускать Webex-конференции в этой связке.
Рассматриваемый дистрибутив — Ubuntu, для других дистрибутивов решение будет отличаться только установкой 32битных библиотек.
##### Firefox
Создаем в home директорию 32bit, куда мы и поставим все наше добро.
```
% mkdir ~/32bit
% cd ~/32bit
```
Скачиваем и распаковываем последнюю 32битную версию Firefox (на 24.12.2012 это 17.0.1.)
```
% wget http://releases.mozilla.org/pub/mozilla.org/firefox/releases/latest/linux-i686/ru/firefox-17.0.1.tar.bz2
% tar -jxf firefox-17.0.1.tar.bz2
```
Сразу создадим директорию для плагинов
```
% mkdir ~/32bit/firefox/plugins
```
Ставим 32битные библиотеки (для вашего дистрибутива команда может отличаться)
```
% sudo apt-get install ia32-libs
```
Если при старте firefox сыпет в консоль ошибки вида
```
(firefox:7106): Gtk-WARNING **: Failed to load type module: /usr/lib/gtk-2.0/2.10.0/menuproxies/libappmenu.so
/usr/lib/gtk-2.0/2.10.0/menuproxies/libappmenu.so: неправильный класс ELF: ELFCLASS64
```
то поставьте еще 32битный appmenu-gtk (для вашего дистрибутива команда может отличаться)
```
% sudo apt-get install appmenu-gtk:i386
```
Дальнейшие шаги нужны тем, кто использует Firefox в качестве основного браузера (как я). Мы создадим новый профиль и будем запускать его для webex.
Запускаем отдельный инстанс Firefox и менеджер профилей, чтобы создать новый профиль.
```
% firefox/firefox --no-remote -P
```
В появившемся окне создаем профиль 32bit.
В дальнейшем мы будем запускать 32битный Firefox командой
```
% firefox/firefox --no-remote -P 32bit
```
###### Предварительные проверки
В запущенном Firefox стоит проверить:
* about:plugins — должно быть пусто
* about:buildconfig — Build platform target должен быть i686-pc-linux-gnu
##### Java
Скачиваем в ~/32bit и распаковываем 32битную версию JDK 6 с сайта Oracle на странице
[www.oracle.com/technetwork/java/javase/downloads/jdk6u38-downloads-1877406.html](http://www.oracle.com/technetwork/java/javase/downloads/jdk6u38-downloads-1877406.html)
Нам нужен Linux x86 файл — в настоящий момент это jdk-6u38-linux-i586.bin
Скажу сразу, начал я с 7ой версии, но webex упорно не видел библиотеку libjawt.so, а когда я ему подсовывал ее насильно — просто падал. Если у вас нет девушки — попробуйте его уговорить, но 6ая версия более податливая.
```
% sh ./jdk-6u38-linux-i586.bin
```
Устанавливаем Java-плагин в браузер
```
% cd ~/32bit/firefox/plugins
% ln -s ~/32bit/jdk1.6.0_38/jre/lib/i386/libnpjp2.so .
```
##### Скрипт для запуска
Создаем файл ~/32bit/firefox.sh с содержанием
```
#!/bin/bash
export ENV_HOME=~/32bit
export FIREFOX_HOME=$ENV_HOME/firefox
export MOZ_PLUGIN_PATH=$FIREFOX_HOME/plugins
export JDK_HOME=$ENV_HOME/jdk1.6.0_38
export JAVA_HOME=$JDK_HOME/jre
export PATH=$JAVA_HOME/bin:$JDK_HOME/bin:$PATH
$FIREFOX_HOME/firefox --no-remote -P 32bit
```
Делаем исполняемым
```
% chmod +x ~/32bit/firefox.sh
```
Запускаем ~/32bit/firefox.sh, проверяем
about:plugins — видим Java плагин
Установка закончена, звук в webex должен заработать.
##### Удаление
Если вам хочется вернуть систему в первоначальный вид, то нужно сделать два шага.
* Удалить профиль 32bit из Firefox
* Удалить директорию ~/32bit
##### 14.04
В 14.04 надо будет установить еще libxmu6:i386 | https://habr.com/ru/post/163771/ | null | ru | null |
# Хранение настроек в памяти Базового устройства
Привет! Если Вам посчастливилось подержать в руках микроконтроллер **ESP32** (мне посчастливилось больше и у меня в руках **M5Stack**) от китайской компании **ESPRESSIF**, то этот пост, возможно, будет полезен.
Бывает ситуация, когда необходимо сохранить какие-то параметры в энергонезависимой памяти (например: подсчитывать количество включений устройства за всё время или сохранять настройки Wi-Fi). Это можно сделать с лёгкостью с помощью библиотеки **Preferences**.
Объявим экземпляр класса **Preferences**, а там видно будет...
Первое, что мы должны сделать — это **создать** связку ключей путём вызова метода **begin** с парой аргументов (но можно только с одним первым): именем связки и флагом "только для чтения".
Чтобы **сохранить** строковое значение в памяти, нужно передать ключ и само значение в метод, имя которого состоит из двух частей: первой — **put** и второй — имени типа, например: **String**. Всё ясно и понятно. Правда, есть ещё "сырые" байты ~~без обжарки~~, которым никто не хочет присвоить тип. В таком случае метод принимает ещё и третий аргумент с количеством этих байтов. С этой процедурой вроде всё.
После того, как значение было записано, можно его **прочесть** с помощью метода (имя которого аналогично предыдущему), где первая часть будет **get**. Данный метод возвращает значение для ключа соответственного типа. Помните про случай с байтами? Если Вы не знаете (или не помните) сколько байт лежит по ключу, то дёргайте метод **getBytesLength** с единственным аргументом — ключом, она всё посчитает и вернёт количество в **size\_t**.
Если Вы хотите **удалить** определённый ключ из связки, то отдайте его единственным аргументом методу **remove**.
Хотите навести настоящий марафет и **очистить ВСЮ связку**? Вызывайте без всяких аргументов метод **clear**!
Когда Вы пожелаете **завершить** работу со связкой, то вызовите метод **end** без каких-либо аргументов.
В общем поддерживаются следующие типы: **Char**, **UChar**, **Short**, **UShort**, **Int**, **UInt**, **Long**, **ULong**, **Long64**, **ULong64**, **Float**, **Double**, **Bool**, **String** и **Bytes**.
Понимаю, что хочется ~~чего-то~~ кода, поэтому вот скетч. Скетч подсчитывает количество включений устройства и выводит его на дисплей:
```
#include
#include
Preferences preferences;
const char\* key = "OnOff";
uint32\_t count;
void setup() {
m5.begin();
preferences.begin("MyKeyChain");
count = preferences.getUInt(key);
preferences.putUInt(key, count + 1);
M5.Lcd.setTextSize(3);
M5.Lcd.setTextColor(TFT\_WHITE);
M5.Lcd.println("Hello, Habr!");
M5.Lcd.setTextSize(2);
M5.Lcd.println("M5Stack Turned On:");
M5.Lcd.setTextSize(3);
M5.Lcd.setTextColor(TFT\_RED);
M5.Lcd.println(count);
M5.Lcd.setTextColor(TFT\_WHITE);
M5.Lcd.setTextSize(2);
M5.Lcd.println("times");
}
void loop() { }
```
Ссылочка на библиотеку [прилагается](https://github.com/espressif/arduino-esp32/tree/master/libraries/Preferences). | https://habr.com/ru/post/476492/ | null | ru | null |
# MEX (Minimum EXcluded) Алгоритм поиска минимального отсутствующего числа
Добрый день. Сегодня хочется поговорить о том, как найти MEX (минимальное отсутствующие число во множестве).
Мы разберем три алгоритма и посмотрим на их производительность.
Добро пожаловать под cut
Предисловие
-----------
Перед тем как начать, хотелось бы рассказать — почему я вообще за этот алгоритм взялся?
Всё началось с задачки на OZON.
Как видно из задачи, в математике результатом работы функции MEX на множестве чисел является наименьшим значением из всего набора, который не принадлежит этому множеству. То есть это минимальное значение набора дополнений. Название «MEX» является сокращением для «Minimum EXcluded» значение.
И покопавшись в сети, оказалось, что нет общепринятого алгоритма нахождения MEX…
Есть решения в лоб, есть варианты с дополнительными массивами, графами, но, как-то всё это раскидано по разным углам интернета и нет единой нормальной статьи по этому поводу. Вот и родилась идея — написать эту статью. В этой статье мы разберем три алгоритма нахождения MEX и посмотрим, что у нас получиться по скорости и по памяти.
Код будет на языке C#, но в целом там не будет специфичных конструкций.
Базовый код для проверок будет таким.
```
static void Main(string[] args)
{
//MEX = 2
int[] values = new[] { 0, 12, 4, 7, 1 };
//MEX = 5
//int[] values = new[] { 0, 1, 2, 3, 4 };
//MEX = 24
//int[] values = new[] { 11, 10, 9, 8, 15, 14, 13, 12, 3, 2, 0, 7, 6, 5, 27, 26, 25, 4, 31, 30, 28, 19, 18, 17, 16, 23, 22, 21, 20, 43, 1, 40, 47, 46, 45, 44, 35, 33, 32, 39, 38, 37, 36, 58, 57, 56, 63, 62, 60, 51, 49, 48, 55, 53, 52, 75, 73, 72, 79, 77, 67, 66, 65, 71, 70, 68, 90, 89, 88, 95, 94, 93, 92, 83, 82, 81, 80, 87, 86, 84, 107, 106, 104 };
//MEX = 1000
//int[] values = new int[1000];
//for (int i = 0; i < values.Length; i++) values[i] = i;
//Импровизированный счетчик итераций
int total = 0;
int mex = GetMEX(values, ref total);
Console.WriteLine($"mex: {mex}, total: {total}");
Console.ReadKey();
}
```
И еще один момент в статье я часто упоминаю слово «массив», хотя более правильным будет «множество», то заранее хочу извиниться перед теми, кому будет резать слух данное допущение.
*Примечание 1 на основе комментариев: Многие придрались к O(n), мол все алгоритмы O(n) и по фигу, что «O» везде разное и не даёт фактически сравнить количество итераций. То для душевного спокойствия поменяем O на T. Где T более-менее понятная операция: проверка или присвоение. Так, как я понимаю, всем будет проще*
*Примечание 2 на основе комментариев: мы рассматриваем случай когда исходное множество **НЕ**упорядоченное. Ибо сортировка это множества — тоже требует времени.*
1) Решение в лоб
----------------
Как нам найти «минимальное отсутствующие число»? Самый простой вариант – сделать счетчик и перебирать массив до тех пор, пока не найдем число равное счетчику.
```
static int GetMEX(int[] values, ref int total)
{
for (int mex = 0; mex < values.Length; mex++)
{
bool notFound = true;
for (int i = 0; i < values.Length; i++)
{
total++;
if (values[i] == mex)
{
notFound = false;
break;
}
}
if (notFound)
{
return mex;
}
}
return values.Length;
}
}
```
Максимально базовый случай. Сложность алгоритма составляет T(n\*cell(n/2))… Т.к. для случая { 0, 1, 2, 3, 4 } нам нужно будет перебрать все числа т.к. совершить 15 операций. А для полностью заполного ряда из 100 числе 5050 операций… Так себе быстродейственность.
2) Просеивание
--------------
Второй по сложности вариант в реализации укладывается в T(n)… Ну или почти T(n), математики хитрят и не учитывают подготовку данных… Ибо, как минимум, — нам нужно знать максимальное число во множестве.
С точки зрения математики выглядит так.
Берется битовый массив S длинной m (где m – длина массива V) заполненный 0. И в один проход исходному множеству (V) в массиве (S) ставятся 1. После этого в один проход находим первое пустое значение. Все значения больше m можно просто игнорировать т.к. если в массиве «не хватает» значений до m, то явно будет меньше длины m.
```
static int GetMEX(int[] values, ref int total)
{
bool[] sieve = new bool[values.Length];
for (int i = 0; i < values.Length; i++)
{
total++;
var intdex = values[i];
if (intdex < values.Length)
{
sieve[intdex] = true;
}
}
for (int i = 0; i < sieve.Length; i++)
{
total++;
if (!sieve[i])
{
return i;
}
}
return values.Length;
}
```
Т.к. «математики» – хитрые люди. То они говорят, что алгоритм T(n) ведь проход по исходному массиву всего один…
Вот сидят и радуются, что такой крутой алгоритм придумали, но правда такова.
Первое — нужно пройтись по исходному массиву и отметить это значение в массиве S T1(n)
Второе — нужно пройтись по массиву S и найти там первую попавшеюся свободную ячейку T2(n)
Итого, т.к. все операции в целом не сложные можно упростить все расчеты до T(n\*2)
Но это явно лучше решения в лоб… Давайте проверим на наших тестовых данных:
1. Для случая { 0, 12, 4, 7, 1 }: *В лоб*: 11 итераций, *просеивание*: 8 итераций
2. Для случая { 0, 1, 2, 3, 4 }: *В лоб*: 15 итераций, *просеивание*: 10 итераций
3. Для случая { 11,…}: *В лоб*: 441 итерация, *просеивание*: 108 итерация
4. Для случая { 0,…,999}: *В лоб*: 500500 итераций, *просеивание*: 2000 итераций
Дело в том, что если «отсутствующее значение» является небольшим числом, то в таком случае — решение в лоб оказывается быстрее, т.к. не требует тройного прохода по массиву. Но в целом, на больших размерностях явно проигрывает просеиванию, что собственно неудивительно.
С точки зрения «математика» – алгоритм готов, и он великолепен, но вот с точки зрения «программиста» – он ужасен из-за объема оперативной памяти, израсходованной впустую, да и финальный проход для поиска первого пустого значения явно хочется ускорить.
Давайте сделаем это, и оптимизируем код.
```
static int GetMEX(int[] values, ref int total)
{
var max = values.Length;
var size = sizeof(ulong) * 8;
ulong[] sieve = new ulong[(max / size) + 1];
ulong one = 1;
for (int i = 0; i < values.Length; i++)
{
total++;
var intdex = values[i];
if (intdex < values.Length)
{
sieve[values[i] / size] |= (one << (values[i] % size));
}
}
var maxInblock = ulong.MaxValue;
for (int i = 0; i < sieve.Length; i++)
{
total++;
if (sieve[i] != maxInblock)
{
total--;
for (int j = 0; j < size; j++)
{
total++;
if ((sieve[i] & (one << j)) == 0)
{
return i * size + j;
}
}
}
}
return values.Length;
}
```
Что мы тут сделали. Во-первых, в 64 раза уменьшили количество оперативной памяти, которая необходима.
```
var size = sizeof(ulong) * 8;
ulong[] sieve = new ulong[(max / size) + 1];
```
Во-вторых, оптимизировали финальную проверку: мы проверяем сразу блок на вхождение первых 64 значений: *if (sieve[i] != maxInblock)* и как только убедились в том, что значение блока не равно бинарным 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111, только тогда ищем уже вхождение на уровне блока: *((sieve[i] & (one << j)) == 0*
В итоге алгоритм просеивание нам дает следующие результат:
1. Для случая { 0, 12, 4, 7, 1 }: *просеивание*: 8 итераций, *просеивание с оптимизацией*: 8 итераций
2. Для случая { 0, 1, 2, 3, 4 }: *просеивание*: 10 итераций, *просеивание с оптимизацией*: 11 итераций
3. Для случая { 11,…}: *просеивание*: 108 итерация, *просеивание с оптимизацией*: 108 итерации
4. Для случая { 0,…,999}: *просеивание*: 2000 итераций, *просеивание с оптимизацией*: 1056 итераций
Так, что в итоге в теории по скорости?
T(n\*3) мы превратили в T(n\*2) + T(n / 64) в целом, чуть увеличили скорость, да еще объём оперативной памяти уменьшили аж в 64 раза. Что хорошо)
3) Сортировка
-------------
Как не сложно догадаться, самый простой способ найти отсутствующий элемент во множестве – это иметь отсортированное множество.
Самый быстрый алгоритм сортировки — это «quicksort» (быстрая сортировка), которая имеет сложность в T1(n log(n)). И итого мы получим теоретическую сложность для поиска MEX в T1(n log(n)) + T2(n)
```
static int GetMEX(int[] values, ref int total)
{
total = values.Length * (int)Math.Log(values.Length);
values = values.OrderBy(x => x).ToArray();
for (int i = 0; i < values.Length - 1; i++)
{
total++;
if (values[i] + 1 != values[i + 1])
{
return values[i] + 1;
}
}
return values.Length;
}
```
Шикарно. Ничего лишнего.
Проверим количество итераций
1. Для случая { 0, 12, 4, 7, 1 }: *просеивание с оптимизацией*: 8, *сортировка*: ~7 итераций
2. Для случая { 0, 1, 2, 3, 4 }: *просеивание с оптимизацией*: 11 итераций, *сортировка*: ~9 итераций
3. Для случая { 11,…}: *просеивание с оптимизацией*: 108 итерации, *сортировка*: ~356 итераций
4. Для случая { 0,…,999}: *просеивание с оптимизацией*: 1056 итераций, *сортировка*: ~6999 итераций
Здесь указаны средние значения, и они не совсем справедливы. Но в целом: сортировка — не требует дополнительной памяти и явно позволяет упростить последний шаг в переборе.
*Примечание: values.OrderBy(x => x).ToArray() – да я знаю, что тут выделилась память, но если делать по уму, то можно изменить массив, а не копировать его…*
Вот у меня и возникла идея оптимизировать quicksort для поиска MEX. Данный вариант алгоритма я не находил в интернете, ни с точки зрения математики, и уж тем более с точки зрения программирования. То код будем писать с 0 по дороге придумывая как он будет выглядеть :D
Но, для начала, давайте вспомним как вообще работает quicksort. Я бы ссылку дал, но нормальное пояснение quicksort на пальцах фактически нет, создается ощущение, что авторы пособий сами разбираются в алгоритме пока его рассказывают про него…
Так вот, что такое quicksort:
У нас есть неупорядоченный массив { 0, 12, 4, 7, 1 }
Нам потребуется «случайное число», но лучше взять любое из массива, — это называется опорное число (T).
И два указателя: L1 – смотрит на первый элемент массива, L2 смотрит на последний элемент массива.
0, 12, 4, 7, 1
L1 = 0, L2 = 1, T = 1 (T взял тупа последние)
**Первый этап итерации**:
Пока работам только с указателем L1
Сдвигаем его по массиву вправо пока не найдем число больше чем наше опорное.
В нашем случае L1 равен 8
**Второй этап итерации**:
Теперь сдвигаем указатель L2
Сдвигаем его по массиву влево пока не найдем число меньше либо равное чем наше опорное.
*В данном случае L2 равен 1. Т.к. я взял опорное число равным крайнему элементу массива, а туда же смотрел L2.*
**Третей этап итерации**:
Меняем числа в указателях L1 и L2 местами, указатели не двигаем.
И переходим к первому этапу итерации.
Эти этапы мы повторяем до тех пор, пока указатели L1 и L2 не будет равны, не значения по ним, а именно указатели. Т.е. они должны указывать на один элемент.
После того как указатели сойдутся на каком-то элементе, обе части массива будут всё еще не отсортированы, но уже точно, с одной стороны «обединённых указателей (L1 и L2)» будут элементы, которые меньше T, а со второй больше T. Именно этот факт нам и позволяет разбить массив на две независимые группы, которые можно сортировать в разных потоках в дальнейших итерациях.
[Статья на wiki, если и у меня непонятно написанно](https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0)
Напишем Quicksort
```
static void Quicksort(int[] values, int l1, int l2, int t, ref int total)
{
var index = QuicksortSub(values, l1, l2, t, ref total);
if (l1 < index)
{
Quicksort(values, l1, index - 1, values[index - 1], ref total);
}
if (index < l2)
{
Quicksort(values, index, l2, values[l2], ref total);
}
}
static int QuicksortSub(int[] values, int l1, int l2, int t, ref int total)
{
for (; l1 < l2; l1++)
{
total++;
if (t < values[l1])
{
total--;
for (; l1 <= l2; l2--)
{
total++;
if (l1 == l2)
{
return l2;
}
if (values[l2] <= t)
{
values[l1] = values[l1] ^ values[l2];
values[l2] = values[l1] ^ values[l2];
values[l1] = values[l1] ^ values[l2];
break;
}
}
}
}
return l2;
}
```
Проверим реальное количество итераций:
1. Для случая { 0, 12, 4, 7, 1 }: *просеивание с оптимизацией*: 8, *сортировка*: 11 итераций
2. Для случая { 0, 1, 2, 3, 4 }: *просеивание с оптимизацией*: 11 итераций, *сортировка*: 14 итераций
3. Для случая { 11,…}: *просеивание с оптимизацией*: 108 итерации, *сортировка*: 1520 итераций
4. Для случая { 0,…,999}: *просеивание с оптимизацией*: 1056 итераций, *сортировка*: 500499 итераций
Попробуем поразмышлять вот над чем. В массиве { 0, 4, 1, 2, 3 } нет недостающих элементов, а его длина равна 5. Т.е. получается, массив в котором нет отсутствующих элементов равен длине массива — 1. Т.е. m = { 0, 4, 1, 2, 3 }, Length(m) == Max(m) + 1. И самое главное в этом моменте, что это условие справедливо, если значения в массиве переставлены местами. И важно то, что это условие можно распространить на части массива. А именно вот так:
{ 0, 4, 1, 2, 3, 12, 10, 11, 14 } зная, что в левой части массива все числа меньше некого опорного числа, например 5, а в правой всё что больше, то нет смысла искать минимальное число слева.
Т.е. если мы точно знаем, что в одной из частей нет элементов больше определённого значения, то само это отсутствующие число нужно искать во второй части массива. В целом так работает алгоритм бинарного поиска.
В итоге у меня родилась мысль упростить quicksort для поиска MEX объединив его с бинарным поиском. Сразу скажу нам не нужно будет полностью отсортировывать весь массив только те части, в которых мы будем осуществлять поиск.
В итоге получаем код
```
static int GetMEX(int[] values, ref int total)
{
return QuicksortMEX(values, 0, values.Length - 1, values[values.Length - 1], ref total);
}
static int QuicksortMEX(int[] values, int l1, int l2, int t, ref int total)
{
if (l1 == l2)
{
return l1;
}
int max = -1;
var index = QuicksortMEXSub(values, l1, l2, t, ref max, ref total);
if (index < max + 1)
{
return QuicksortMEX(values, l1, index - 1, values[index - 1], ref total);
}
if (index == values.Length - 1)
{
return index + 1;
}
return QuicksortMEX(values, index, l2, values[l2], ref total);
}
static int QuicksortMEXSub(int[] values, int l1, int l2, int t, ref int max, ref int total)
{
for (; l1 < l2; l1++)
{
total++;
if (values[l1] < t && max < values[l1])
{
max = values[l1];
}
if (t < values[l1])
{
total--;
for (; l1 <= l2; l2--)
{
total++;
if (values[l2] == t && max < values[l2])
{
max = values[l2];
}
if (l1 == l2)
{
return l2;
}
if (values[l2] <= t)
{
values[l1] = values[l1] ^ values[l2];
values[l2] = values[l1] ^ values[l2];
values[l1] = values[l1] ^ values[l2];
break;
}
}
}
}
return l2;
}
```
Проверим количество итераций
1. Для случая { 0, 12, 4, 7, 1 }: *просеивание с оптимизацией*: 8, *сортировка MEX*: 8 итераций
2. Для случая { 0, 1, 2, 3, 4 }: *просеивание с оптимизацией*: 11 итераций, *сортировка MEX*: 4 итераций
3. Для случая { 11,…}: *просеивание с оптимизацией*: 108 итерации, *сортировка MEX*: 1353 итераций
4. Для случая { 0,…,999}: *просеивание с оптимизацией*: 1056 итераций, *сортировка MEX*: 999 итераций
Итого
-----
Мы получили разные варианты поиска MEX. Какой из них лучше — решать вам.
В целом. Мне больше всех нравится *просеивание*, и вот по каким причинам:
У него очень предсказуемое время выполнения. Более того, этот алгоритм можно легко использовать в многопоточном режиме. Т.е. разделить массив на части и каждую часть пробегать в отдельном потоке:
```
for (int i = minIndexThread; i < maxIndexThread; i++)
sieve[values[i] / size] |= (one << (values[i] % size));
```
Единственное, нужен lock при записи *sieve[values[i] / size]*. И еще — алгоритм идеален при выгрузке данных из базы данных. Можно грузить пачками по 1000 штук например, в каждом потоке и всё равно он будет работать.
Но если у нас строгая нехватка памяти, то сортировка MEX – явно выглядит лучше.
#### P.S.
Я начал рассказ с конкурса на OZON в котором я пробовал участвовать, сделав «предварительный вариант» алгоритма просеиванья, приз за него я так и не получил, OZON счел его неудовлетворительным… По каким именно причинам — он так и не сознался… Да и кода победителя я тоже не видел. Может у кого-то есть идеи как можно решить задачу поиска MEX лучше? | https://habr.com/ru/post/562594/ | null | ru | null |
# PHP-Дайджест № 82 – интересные новости, материалы и инструменты (14 – 27 марта 2016)
Предлагаем вашему вниманию очередную подборку со ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
* [PhpStorm 2016.1](http://blog.jetbrains.com/phpstorm/2016/03/phpstorm-2016-1-is-released/)
* [Phalcon 2.1.0 RC1](https://blog.phalconphp.com/post/phalcon-2-1-0-RC1-released) — Ожидается LTS-релиз с поддержкой PHP 7. Прислал [igusev](https://habrahabr.ru/users/igusev/).
* [Codeception 2.2 Beta](http://codeception.com/03-26-2016/codeception-2.2-beta#.VvaVIhJ94p8)
### PHP
* [RFC: Typed Properties](https://wiki.php.net/rfc/typed-properties) — Предлагается реализовать типизированные свойства:
```
class Foo {
public int $int = 1;
public float $flt = 2.2;
public array $arr = [];
public bool $bool = false;
public string $string;
public callable $callable;
public stdClass $std;
public OtherThing $other;
public $mixed;
}
```
* [Трекер PHP RFC](https://why-cant-we-have-nice-things.mwl.be/) — Ресурс агрегирует информацию по всем RFC, а также доступна статистика контрибьюторов.
* [php.internals: Add spaceship assignment operator](http://news.php.net/php.internals/91907) — Ироничное сообщение от Никиты Попова по поводу предложений добавить операторы [??=](https://wiki.php.net/rfc/null_coalesce_equal_operator) и [?:=](https://wiki.php.net/rfc/short_ternary_equal_operator). Для консистентности Никита предлагает добавить еще следующие сокращенные операторы:
```
$a <=>= $b;
// эквивалентно
$a = ($a <=> $b);
$a ==== $b;
// эквивалентно
$a = ($a === $b);
```
### Инструменты
* [Ocramius/PSR7Csrf](https://github.com/Ocramius/PSR7Csrf) — Генератор/валидатор CSRF-токенов на PSR-7 без хранилища данных.
* [ratchetphp/Pawl](https://github.com/ratchetphp/pawl) — Асинхронный WebSocket клиент.
* [spatie/menu](https://github.com/spatie/menu) — Генератор HTML меню. [Пост](https://murze.be/2016/03/a-modern-package-to-generate-menus/) в поддержку.
* [producerphp/producer.producer](https://github.com/producerphp/producer.producer) — CLI-инструмент для автоматизации процесса релиза PHP-пакетов. [Пост](http://paul-m-jones.com/archives/6301) от автора в поддержку.
* [Swader/nofw](https://github.com/swader/nofw) — Скелет приложения без фреймворков.
* [kelunik/acme-client](https://github.com/kelunik/acme-client) — Сервис [Let's Encrypt](https://letsencrypt.org/) позволяет бесплатно генерировать подтвержденные SSL-сертификаты. По ссылке PHP-клиент для Let's Encrypt для тех кому не подходит оригинальный на Python. [Пост](http://blog.kelunik.com/2016/03/13/letsencrypt-php-client.html) об использовании.
* [sitepoint/Rauth](https://github.com/sitepoint/Rauth) — ACL для классов и методов на основе аннотаций. [Туториал](http://www.sitepoint.com/control-user-access-to-classes-and-methods-with-rauth/) по использованию.
* [lcobucci/jwt](https://github.com/lcobucci/jwt) — Простая библиотека для работы с JSON Web Token.
* [ptlis/conneg](https://github.com/ptlis/conneg) — Content Negotiation для PHP.
* [niklongstone/regex-reverse](https://github.com/niklongstone/regex-reverse) — Генерирует строку на основе регулярного выражения.
* [Fakerino/Fakerino](https://github.com/Fakerino/Fakerino) — Генератор тестовых данных, альтернатива [Faker](https://github.com/fzaninotto/Faker).
* [jobbyphp/jobby](https://github.com/jobbyphp/jobby/) — Продвинутый менеджер cron-задач.
* [Codeception/AspectMock 1.0](https://github.com/Codeception/AspectMock) — Библиотека для создания тестовых двойников, позволяющая делать моки буквально для всего.
* [php-composter/php-composter](https://github.com/php-composter/php-composter) — Управление Git-хуками с помощью Composer.
### Материалы для обучения
* ##### Symfony
+ [Руководство по Symfony — Пример API](https://gnugat.github.io/2016/03/24/ultimate-symfony-api-example.html)
+ [Руководство по Symfony — Skeleton](https://gnugat.github.io/2016/03/16/ultimate-symfony-skeleton.html)
+ [Новое в Symfony 3.0](http://symfony.com/blog/new-in-symfony-3-0)
+ [Бенчмарки Symfony: PHP-FPM vs. PHP-PM (на PHP 7 и HHVM)](https://www.symfony.fi/entry/symfony-benchmarks-php-fpm-vs-php-pm-on-php-7-and-hhvm)
+  [Асинхронные контроллеры в Symfony](http://ahrameev.ru/article/going-async-in-symfony-controllers.html)
* ##### Yii
+ [Interactive Yii 2.0 shell](https://github.com/yiisoft/yii2-shell)
+ Новые рецепты из Yii 2.0 Cookbook: [Canonical URLs](https://yii2-cookbook.readthedocs.org/canonical-urls/), [CSRF](https://yii2-cookbook.readthedocs.org/csrf/), [XSS](https://yii2-cookbook.readthedocs.org/xss/)
+  [Q&A про Yii #1](http://rmcreative.ru/blog/post/qa-pro-yii-1)
+  [Мартовские релизы официальных расширений Yii 2.0](https://habrahabr.ru/post/279637/)
+  [Используем миграции Yii2 для работы с несколькими базами данных](https://habrahabr.ru/post/279701/)
+  [Работа со связанными моделями в Yii2 на примере каталога](http://www.elisdn.ru/blog/89/related-models-on-yii2)
+  [Сервис на Yii2: Публикация Composer-расширений на GitHub и Packagist](http://www.elisdn.ru/blog/88/seo-service-on-yii2-composer-extensions)
+  [Cервис на Yii2: Добавление RBAC](http://www.elisdn.ru/blog/87/seo-service-on-yii2-adding-rbac)
* ##### Laravel
+  [Про Laravel](https://medium.com/@kotchuprik/%D0%BF%D1%80%D0%BE-laravel-c32101bcf8b#.orm4yc3kx)
+  [Недостатки Laravel](http://amdy.su/%d0%bd%d0%b5%d0%b4%d0%be%d1%81%d1%82%d0%b0%d1%82%d0%ba%d0%b8-laravel/)
+  [Laravel TestTools — запись тестов для Laravel прямо из браузера Chrome](https://habrahabr.ru/post/279843/)
+  [Работа с событиями в Laravel. Рассылка push уведомлений при публикации статьи](https://habrahabr.ru/post/279385/)
+  [Число прописью в Laravel 5](https://habrahabr.ru/post/279293/)
+  [Дерево разделов неограниченной вложенности и URL](https://habrahabr.ru/post/279233/)
+  [Создание беспарольной аутентификации в Laravel, используя только email](https://habrahabr.ru/post/279173/)
+  [Декодирование типа данных JSON MySQL](https://habrahabr.ru/post/279155/)
+ [Вопрос-ответ с Taylor Otwell](https://hashnode.com/ama/with-taylor-otwell-cilmj90zh000k6t53il0rdgqp)
+ [dingo/api](https://github.com/dingo/api) — RESTful API для Laravel и Lumen.
+ [tylercd100/lern](https://github.com/tylercd100/lern) — Пакет для Laravel 5, который сохраняет информацию о возникших исключениях в базу и уведомляет по Email, Pushover или Slack.
+  [Горизонтальное масштабирование Laravel при помощи Docker](https://laravel-news.ru/blog/tutorials/docker-laravel)
* [Почему PHP-разработчики думают, что MVC — это архитектура приложения?](http://paul-m-jones.com/archives/6288)
* [Туториал по созданию плагина для Composer](http://www.sitepoint.com/drunk-with-the-power-of-composer-plugins/)
* [Макросы в PHP для развлечения и пользы](http://www.sitepoint.com/php-macros-for-fun-and-profit/) — Об использовании препроцессора [marcioAlmada/yay](https://github.com/marcioAlmada/yay).
*  [PHP для начинающих. Подключение файлов](http://anton.shevchuk.name/php/php-for-beginners-include-files/)
*  [PHP для начинающих. Обработка ошибок](http://anton.shevchuk.name/php/php-for-beginners-error-handling/)
*  [Введение в PHP 7: Что добавлено, что убрано](https://habrahabr.ru/post/280071/)
*  [Прекрати злоупотреблять массивами в PHP](https://habrahabr.ru/post/279917/)
*  [Настройка редактора Visual Studio Code для разработки на PHP](https://habrahabr.ru/company/microsoft/blog/279947/)
*  [SoftMocks: наша замена runkit для PHP 7](https://habrahabr.ru/company/badoo/blog/279617/)
*  [Деплой на shared-хостинг: боль и страдания или простая рутина?](https://habrahabr.ru/post/279555/)
*  [О чем говорят тренды PHP в 2016-м году?](https://habrahabr.ru/company/infopulse/blog/279461/)
*  [DI плагины в Magento 2](https://habrahabr.ru/post/279413/)
*  [Мультиисключение или Хочу поделиться одним интересным архитектурным приемом](https://habrahabr.ru/post/279501/)
*  [Как использовать именованные конструкторы в PHP](https://habrahabr.ru/post/279919/)
*  [Когда использовать статические методы](https://habrahabr.ru/post/279921/)
### Аудио и видеоматериалы
*  [Что может RabbitMQ сделать для вас](https://www.youtube.com/watch?v=4lDSwfrfM-I)
*  [Hacking on PHP 7](https://www.youtube.com/watch?v=_arORgEVl-M), [2](https://www.youtube.com/watch?v=f9N-v-JUbTQ) — PHP core-разработчик Joe Watkins рассказывает об устройстве PHP на примере добавления новой функции в интерпретатор. Также доступен [пост](http://blog.krakjoe.ninja/2016/03/hacking-php-7.html).
*  [PHP Roundtable: 042: Staying Relevant For Web Development](https://www.phproundtable.com/episode/staying-relevant-in-an-ever-changing-web-development-world)
*  [5 способов ускорить PhpStorm](https://www.youtube.com/watch?v=aXxPq1MrgK4)
*  [PHP UK Conference 2016](https://www.youtube.com/playlist?list=PL_aPVo2HeGF91PL_05g00Y6s0BM3LkUX8) — Видеозаписи докладов.
*  [Building Extraordinary Packages](https://www.youtube.com/watch?v=jQwj--OMrJ0) — О пакетах [League](https://github.com/thephpleague).
### Занимательное
* [Подсчет слов на различных языках программирования](http://juditacs.github.io/2016/03/19/wordcount2.html?hello) — Реализация на PHP 7 по скорости заняла 4-е место.
* [tagua-vm/tagua-vm](https://github.com/tagua-vm/tagua-vm) — Виртуальная машина PHP реализованная на Rust.
* [Сервер PHP на Android](https://play.google.com/store/apps/details?id=com.esminis.server.php)
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](http://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:[email protected]) или в [твиттер](https://twitter.com/pronskiy).
[Присылайте ссылки](http://bit.ly/php-digest-add-link) на интересные статьи или полезные инструменты, которых [не было в PHP-Дайджестах](http://pronskiy.github.io/php-digest/), и ваше имя будет рядом с присланной ссылкой в выпуске.
[Прислать ссылку](http://bit.ly/php-digest-add-link)
[Быстрый поиск по всем дайджестам](http://pronskiy.github.io/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 81](https://habrahabr.ru/company/zfort/blog/279167/) | https://habr.com/ru/post/280278/ | null | ru | null |
# Многопоточный сервер на C# за 15 минут
C# довольно простой и гибкий язык. Вместе с .NET поставляется довольно много уже готовых классов, что делает его еще проще. Настолько, что вполне можно написать простой многопоточный HTTP-сервер для отдачи статического содержимого всего за 15 минут. Можно было бы использовать уже готовый класс [HttpListener](http://msdn.microsoft.com/library/system.net.httplistener.aspx) и управиться еще быстрее, но цель этой статьи — показать, как вообще можно сделать нечто подобное в C#.
Для начала создадим новый консольный проект:
> `Copy Source | Copy HTML1. using System;
> 2. using System.Collections.Generic;
> 3. using System.Text;
> 4.
> 5. namespace HTTPServer
> 6. {
> 7. class Server
> 8. {
> 9. static void Main(string[] args)
> 10. {
> 11.
> 12. }
> 13. }
> 14. }
> 15.`
В .NET можно очень легко создать TCP-сервер при помощи класса TcpListener, чем мы и воспользуемся:
> `Copy Source | Copy HTML1. class Server
> 2. {
> 3. TcpListener Listener; // Объект, принимающий TCP-клиентов
> 4.
> 5. // Запуск сервера
> 6. public Server(int Port)
> 7. {
> 8. // Создаем "слушателя" для указанного порта
> 9. Listener = new TcpListener(IPAddress.Any, Port);
> 10. Listener.Start(); // Запускаем его
> 11.
> 12. // В бесконечном цикле
> 13. while (true)
> 14. {
> 15. // Принимаем новых клиентов
> 16. Listener.AcceptTcpClient();
> 17. }
> 18. }
> 19.
> 20. // Остановка сервера
> 21. ~Server()
> 22. {
> 23. // Если "слушатель" был создан
> 24. if (Listener != null)
> 25. {
> 26. // Остановим его
> 27. Listener.Stop();
> 28. }
> 29. }
> 30.
> 31. static void Main(string[] args)
> 32. {
> 33. // Создадим новый сервер на порту 80
> 34. new Server(80);
> 35. }
> 36. }`
Если сейчас запустить приложение, то уже можно будет подключиться к порту 80 и… все. Соединение будет лишь простаивать впустую, так как отсутствует его обработчик и оно не закрывается со стороны сервера.
Напишем самый простой обработчик:
> `Copy Source | Copy HTML1. // Класс-обработчик клиента
> 2. class Client
> 3. {
> 4. // Конструктор класса. Ему нужно передавать принятого клиента от TcpListener
> 5. public Client(TcpClient Client)
> 6. {
> 7. // Код простой HTML-странички
> 8. string Html = "It works!
> =========
>
> ";
> 9. // Необходимые заголовки: ответ сервера, тип и длина содержимого. После двух пустых строк - само содержимое
> 10. string Str = "HTTP/1.1 200 OK\nContent-type: text/html\nContent-Length:" + Html.Length.ToString() + "\n\n" + Html;
> 11. // Приведем строку к виду массива байт
> 12. byte[] Buffer = Encoding.ASCII.GetBytes(Str);
> 13. // Отправим его клиенту
> 14. Client.GetStream().Write(Buffer, 0, Buffer.Length);
> 15. // Закроем соединение
> 16. Client.Close();
> 17. }
> 18. }`
Чтобы передать ему клиента, нужно изменить одну строчку в классе Server:
> `Copy Source | Copy HTML1. // Принимаем новых клиентов и передаем их на обработку новому экземпляру класса Client
> 2. new Client(Listener.AcceptTcpClient());`
Теперь можно запустить программу, открыть в браузере адрес [127.0.0.1](http://127.0.0.1) и увидеть большими буквами «It works!»
Перед тем, как приступить к написанию парсера HTTP-запроса, сделаем наш сервер многопоточным. Для этого есть два способа: создавать вручную новый поток для каждого клиента или воспользоваться [пулом потоков](http://habrahabr.ru/blogs/net/109705/). У обоих способов есть свои преимущества и недостатки. Если создавать по потоку на каждого клиента, то сервер может не выдержать высокой нагрузки, но можно работать с практически неограниченным количеством клиентов одновременно. Если использовать пул потоков, то количество одновременно работающих потоков будет ограничено, но нельзя будет создать новый поток, пока не завершатся старые. Какой из способов вам больше подойдет, я не знаю, поэтому приведу пример обоих.
Напишем простую процедуру потока, которая будет лишь создавать новый экземпляр класса Client:
> `Copy Source | Copy HTML1. static void ClientThread(Object StateInfo)
> 2. {
> 3. new Client((TcpClient)StateInfo);
> 4. }`
Для использования первого способа нужно заменить только содержимое нашего бесконечного цикла приема клиентов:
> `Copy Source | Copy HTML1. // Принимаем нового клиента
> 2. TcpClient Client = Listener.AcceptTcpClient();
> 3. // Создаем поток
> 4. Thread Thread = new Thread(new ParameterizedThreadStart(ClientThread));
> 5. // И запускаем этот поток, передавая ему принятого клиента
> 6. Thread.Start(Client);`
Для второго способа нужно проделать то же самое:
> `Copy Source | Copy HTML1. // Принимаем новых клиентов. После того, как клиент был принят, он передается в новый поток (ClientThread)
> 2. // с использованием пула потоков.
> 3. ThreadPool.QueueUserWorkItem(new WaitCallback(ClientThread), Listener.AcceptTcpClient());`
Плюс надо установить максимальное и минимальное количество одновременно работающих потоков. Сделаем это в процедуре Main:
> `Copy Source | Copy HTML1. // Определим нужное максимальное количество потоков
> 2. // Пусть будет по 4 на каждый процессор
> 3. int MaxThreadsCount = Environment.ProcessorCount \* 4;
> 4. // Установим максимальное количество рабочих потоков
> 5. ThreadPool.SetMaxThreads(MaxThreadsCount, MaxThreadsCount);
> 6. // Установим минимальное количество рабочих потоков
> 7. ThreadPool.SetMinThreads(2, 2);`
Максимальное количество потоков должно быть не меньше двух, так как в это число входит основной поток. Если установить единицу, то обработка клиента будет возможна лишь тогда, когда основной поток приостановил работу (например, ожидает нового клиента или была вызвана процедура Sleep).
Итак, теперь переключимся целиком на класс Client начнем обрабатывать HTTP-запрос. Получим текст запроса от клиента:
> `Copy Source | Copy HTML1. // Объявим строку, в которой будет хранится запрос клиента
> 2. string Request = "";
> 3. // Буфер для хранения принятых от клиента данных
> 4. byte[] Buffer = new byte[1024];
> 5. // Переменная для хранения количества байт, принятых от клиента
> 6. int Count;
> 7. // Читаем из потока клиента до тех пор, пока от него поступают данные
> 8. while ((Count = Client.GetStream().Read(Buffer, 0, Buffer.Length)) > 0)
> 9. {
> 10. // Преобразуем эти данные в строку и добавим ее к переменной Request
> 11. Request += Encoding.ASCII.GetString(Buffer, 0, Count);
> 12. // Запрос должен обрываться последовательностью \r\n\r\n
> 13. // Либо обрываем прием данных сами, если длина строки Request превышает 4 килобайта
> 14. // Нам не нужно получать данные из POST-запроса (и т. п.), а обычный запрос
> 15. // по идее не должен быть больше 4 килобайт
> 16. if (Request.IndexOf("\r\n\r\n") >= 0 || Request.Length > 4096)
> 17. {
> 18. break;
> 19. }
> 20. }`
Далее осуществляем парсинг полученных данных:
> `Copy Source | Copy HTML1. // Парсим строку запроса с использованием регулярных выражений
> 2. // При этом отсекаем все переменные GET-запроса
> 3. Match ReqMatch = Regex.Match(Request, @"^\w+\s+([^\s\?]+)[^\s]\*\s+HTTP/.\*|");
> 4.
> 5. // Если запрос не удался
> 6. if (ReqMatch == Match.Empty)
> 7. {
> 8. // Передаем клиенту ошибку 400 - неверный запрос
> 9. SendError(Client, 400);
> 10. return;
> 11. }
> 12.
> 13. // Получаем строку запроса
> 14. string RequestUri = ReqMatch.Groups[1].Value;
> 15.
> 16. // Приводим ее к изначальному виду, преобразуя экранированные символы
> 17. // Например, "%20" -> " "
> 18. RequestUri = Uri.UnescapeDataString(RequestUri);
> 19.
> 20. // Если в строке содержится двоеточие, передадим ошибку 400
> 21. // Это нужно для защиты от URL типа http://example.com/../../file.txt
> 22. if (RequestUri.IndexOf("..") >= 0)
> 23. {
> 24. SendError(Client, 400);
> 25. return;
> 26. }
> 27.
> 28. // Если строка запроса оканчивается на "/", то добавим к ней index.html
> 29. if (RequestUri.EndsWith("/"))
> 30. {
> 31. RequestUri += "index.html";
> 32. }`
Ну и наконец осуществим работу с файлами: проверим, есть ли нужный файл, определим его тип содержимого и передадим его клиенту.
> `Copy Source | Copy HTML1. string FilePath = "www/" + RequestUri;
> 2.
> 3. // Если в папке www не существует данного файла, посылаем ошибку 404
> 4. if (!File.Exists(FilePath))
> 5. {
> 6. SendError(Client, 404);
> 7. return;
> 8. }
> 9.
> 10. // Получаем расширение файла из строки запроса
> 11. string Extension = RequestUri.Substring(RequestUri.LastIndexOf('.'));
> 12.
> 13. // Тип содержимого
> 14. string ContentType = "";
> 15.
> 16. // Пытаемся определить тип содержимого по расширению файла
> 17. switch (Extension)
> 18. {
> 19. case ".htm":
> 20. case ".html":
> 21. ContentType = "text/html";
> 22. break;
> 23. case ".css":
> 24. ContentType = "text/stylesheet";
> 25. break;
> 26. case ".js":
> 27. ContentType = "text/javascript";
> 28. break;
> 29. case ".jpg":
> 30. ContentType = "image/jpeg";
> 31. break;
> 32. case ".jpeg":
> 33. case ".png":
> 34. case ".gif":
> 35. ContentType = "image/" + Extension.Substring(1);
> 36. break;
> 37. default:
> 38. if (Extension.Length > 1)
> 39. {
> 40. ContentType = "application/" + Extension.Substring(1);
> 41. }
> 42. else
> 43. {
> 44. ContentType = "application/unknown";
> 45. }
> 46. break;
> 47. }
> 48.
> 49. // Открываем файл, страхуясь на случай ошибки
> 50. FileStream FS;
> 51. try
> 52. {
> 53. FS = new FileStream(FilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
> 54. }
> 55. catch (Exception)
> 56. {
> 57. // Если случилась ошибка, посылаем клиенту ошибку 500
> 58. SendError(Client, 500);
> 59. return;
> 60. }
> 61.
> 62. // Посылаем заголовки
> 63. string Headers = "HTTP/1.1 200 OK\nContent-Type: " + ContentType + "\nContent-Length: " + FS.Length + "\n\n";
> 64. byte[] HeadersBuffer = Encoding.ASCII.GetBytes(Headers);
> 65. Client.GetStream().Write(HeadersBuffer, 0, HeadersBuffer.Length);
> 66.
> 67. // Пока не достигнут конец файла
> 68. while (FS.Position < FS.Length)
> 69. {
> 70. // Читаем данные из файла
> 71. Count = FS.Read(Buffer, 0, Buffer.Length);
> 72. // И передаем их клиенту
> 73. Client.GetStream().Write(Buffer, 0, Count);
> 74. }
> 75.
> 76. // Закроем файл и соединение
> 77. FS.Close();
> 78. Client.Close();`
Также в коде упоминалась пока не описанная процедура SendError. Напишем и ее:
> `Copy Source | Copy HTML1. // Отправка страницы с ошибкой
> 2. private void SendError(TcpClient Client, int Code)
> 3. {
> 4. // Получаем строку вида "200 OK"
> 5. // HttpStatusCode хранит в себе все статус-коды HTTP/1.1
> 6. string CodeStr = Code.ToString() + " " + ((HttpStatusCode)Code).ToString();
> 7. // Код простой HTML-странички
> 8. string Html = ""
> =
>
> + CodeStr + "";
> 9. // Необходимые заголовки: ответ сервера, тип и длина содержимого. После двух пустых строк - само содержимое
> 10. string Str = "HTTP/1.1 " + CodeStr + "\nContent-type: text/html\nContent-Length:" + Html.Length.ToString() + "\n\n" + Html;
> 11. // Приведем строку к виду массива байт
> 12. byte[] Buffer = Encoding.ASCII.GetBytes(Str);
> 13. // Отправим его клиенту
> 14. Client.GetStream().Write(Buffer, 0, Buffer.Length);
> 15. // Закроем соединение
> 16. Client.Close();
> 17. }`
На этом написание простого HTTP-сервера окончено. Оно работает в несколько потоков, отдает статику, имеет простую защиту от плохих запросов и ругается на отсутствующие файлы. На все это можно навесить дополнительные примочки: возможность конфигурирования, обработку доменов, изменение адресов наподобие mod\_rewrite, даже поддержку CGI. Но это будет уже совсем другая история :-)
[Исходник (через ThreadPool)](http://test.nizarium.com/httpserver/source.html)
[Исходник (через Thread)](http://test.nizarium.com/httpserver/source2.html)
[Архив с исходником (через ThreadPool, вариант через Thread закомментирован)](http://test.nizarium.com/httpserver/HTTPServer.zip)
[Архив с откомпилированной версией (через ThreadPool)](http://test.nizarium.com/httpserver/HTTPServerCompiled.zip) | https://habr.com/ru/post/120157/ | null | ru | null |
# Триггернутые, или Как безболезненно встроить нагрузочное тестирование в ваш пайплайн
В жизни каждого тестировщика наступает момент, когда он больше не успевает тестировать все задачи, которые на него падают. Нагрузочники не являются исключением. Сначала одна пушка, потом вторая, потом их уже десять — и все надо поддерживать и запускать на очередной версии сервиса, выкатка каждые пару часов. Времени на запуски вручную не хватает, поэтому их нужно автоматизировать.
Меня зовут Саша, я работаю в команде тестирования Ozon Fintech. [В прошлый раз](https://habr.com/ru/company/ozontech/blog/662800/) я рассказывала о типах нагрузочного тестирования (НТ) и о том, как создавать пушки под свои нужды. Сегодня же научу запускать НТ по кнопочке в CI. Статья будет полезна тем, кто уже имеет наработки по НТ, но ещё не автоматизировал их или ищет способы запускать тесты не по крону.
Наша команда финтеха в последнее время сильно разрослась. Сервисов стало много, и тестировщиков стало не хватать. Иногда стали возникать ситуации, когда разработчики просят нагрузить новую версию сервиса, но у QA на это нет времени, быстро проверить не получается.
Чтобы не зависеть от нас, команда разработки попросила создать простой инструмент, который бы позволил им самостоятельно проводить весь цикл нагрузочного тестирования из CI. Иными словами, **они попросили добавить в CI кнопку,** при нажатии на которую всё само работает. Вся подкапотная магия — автоматическая генерация свежих патронов, загрузка их на сервер, билд пушки, загрузка пушки на сервер, сборка актуального конфига, загрузка конфига на сервер, запуск всего этого добра из консольки на сервере — их не интересует.
Мы рассматривали три варианта реализации этой идеи:
1. Сам репозиторий для нагрузки создавался как проект-библиотека для хранения шаблонов патронов и пушек: в нём не предусматривается работающий сервис, он нигде не поднимается и не крутится. Поэтому как раз первой мыслью было сделать из него сервис, добавить в него ручки, по которым всё будет генериться и стреляться. Но это оказалось слишком сложно в рамках текущего проекта.
2. В тестируемый сервис добавить файл с методами, которые будут обращаться к нагрузочному репозиторию как к библиотеке, всё создавать и запускать тесты. Но тогда владельцам самого тестируемого сервиса надо будет за всем следить. Это расходится с принципом «Просто нажать на кнопку — и оно само будет работать».
3. Создать триггеры для нагрузки, по которым на стороне нагрузочного репозитория с помощью простых команд будет выполняться алгоритм всей этой генерации и запуска нагрузки, а к тестируемому сервису этот триггер будет просто подключаться.
Да здравствуют триггеры!
------------------------
В GitLab можно [создавать многопроектные пайплайны](https://docs.gitlab.com/ee/ci/pipelines/multi_project_pipelines.html), когда действие в одном пайплайне запускает пайплайн в другом проекте. **Триггер — это тип джобы, которая вызывается в одном проекте, но запускает выполнение действий в другом.**
В нашем примере будет два сервиса:
1. Сервис, который мы тестим (в терминологии триггеров — upstream-сервис), назовём его `SUT` (system under test).
2. Сервис НТ, который стреляет (он же downstream-сервис), назовём его `LOAD`.
Так как много всего завязано на ветки гита, то в нашем примере у `SUT` ветка будет называться `my-upstream-branch`, а у `LOAD` — `my-downstream-branch`. В рамках примера мы хотим, чтобы по триггеру из проекта `SUT` ветки `my-upstream-branch` запускался пайплайн в проекте `LOAD` ветки `my-downstream-branch`.
Таким образом, для создания многопроектного пайплайна у нас есть три элемента:
* **тесты,** которые мы гоняем (`LOAD`);
* **триггер**, по которому они запускаются;
* **сервис,** который использует этот триггер, чтобы запустить тесты (`SUT`).
В коде это выглядит немного иначе:
1. Есть тесты, которые мы запускаем через обычный пайплайн, описанный в gitlab-ci.
2. Есть файл, который содержит описание джобы с триггером.
3. Есть gitlab-ci в тестовом сервисе, который наследует эту джобу.
Приступим! В `LOAD` создаём триггер в отдельном файле `.trigger.yml`:
```
.run_load_tests:
stage: build
allow_failure: true
trigger:
project: load
strategy: depend
branch: my-downstream-branch #downstream branch pipeline
```
Обязательно пушим изменения на сервер, иначе `SUT` не даст сделать изменения в себе. В `SUT` добавляем шаг, в котором наследуется джоба с триггером, в `.gitlab-ci.yaml`:
```
load tests:
extends: .run_load_tests
allow_failure: true
include:
- project: load
ref: my-downstream-branch #downstream branch trigger file
file: .trigger.yml
```
и тоже пушим.
Важно: в `SUT` в include:ref прописывается ветка, из которой мы будем считывать настройки триггера; в `LOAD` в trigger:branch указывается название ветки, прогон которой будет активирован.
МультивселеннаяЕще раз: в `.gitlab-ci.yml` сервиса `SUT` указывается ветка, из которой брать условие запуска тестов, а в `.trigger.yml` сервиса `LOAD` — кодовая база для прогона.
МультивселеннаяТаким образом, у **нас появляется кнопка для запуска LOAD-тестов в пайплайне**.
Скрипт нагрузки: добавим логики
-------------------------------
Кнопка есть, но никакие действия для downstream-проекта не прописаны. В описание джобы с триггером даже нельзя закинуть [script](https://docs.gitlab.com/ee/ci/pipelines/multi_project_pipelines.html#trigger-job-configuration-keywords) для выполнения, ведь такого ключа нет в списке разрешённых.
В случае попытки добавить это ключевое слово вылезет [ошибка](https://gitlab.com/gitlab-org/gitlab/-/issues/34501#note_531116115):
> CI lint invalid: [jobs:lnl tests config contains unknown keys: trigger]
>
>
Что же тогда будет выполняться?
Суть в том, что триггер запускает пайплайн целиком, а не конкретную задачу. Причём пайплайн ветки, заданной в описании триггера `.run_load_tests:trigger:branch: my-downstream-branch.`
Если в gitlab-ci нет никаких шагов, то вылезает такая ошибка:
Поэтому следующим шагом добавляем и сам `.gitlab-ci.yml`, если его ещё нет, и шаги в него, например:
```
any_job:
stage: generate
when: always
script:
- echo "hello world"
```
В результате при использовании триггера срабатывает пайплайн из нужной ветки:
Дальше закидываем в .gitlab-ci.yml все стейджи и шаги, которые нам нужны для запуска пушки (полные файлы будут в конце статьи):
```
stages:
- generate
- upload
- config
- shoot
generate-ammo:
stage: generate
script:
- make generate-ammo service=sut
upload-ammo:
stage: upload
script:
- make upload-ammo service=sut
generate-config:
stage: config
script:
- make generate-config service=sut
shoot:
stage: shoot
script:
- make shoot service=sut
```
Кастомизация
------------
Такой хардкод с названием сервиса `service=sut` подходит для одного тестового сервиса, но мы тут делаем универсальный инструмент. Один и тот же пайплайн хочется запускать как из сервиса `sut`, так и из сервиса `another-sut`, у которых под капотом будут разные патроны, разные пушки, да просто разные адреса и условия нагрузки.
Для этого настройки пайплайна на стороне `LOAD` будем определять через переменные окружения. В триггер будем передавать CI-переменную `${CI_PROJECT_NAME}`, на основании которой изменять настройки:
```
.trigger.yml
.run_load_tests:
stage: build
allow_failure: true
variables:
TEST_SERVICE: ${CI_PROJECT_NAME} #название upstream-сервиса
trigger:
project: load
strategy: depend
branch: my-downstream-branch
```
А в `.gitlab-ci.yml` добавим ещё один шаг aim, на котором будем определять, куда стрелять:
```
.gitlab-ci.yml
stages:
- aim
- generate
- upload
- config
- shoot
load-tests:
extends: .load-tests
.load-tests:
stage: aim
rules:
- if: $TEST_SERVICE == "sut"
variables:
TARGET: "sut.service.stg:82"
MAX_RPS: "49"
- if: $TEST_SERVICE == "another-sut"
variables:
TARGET: "another-sut.service.stg:82"
MAX_RPS: "16"
script:
- echo "testing service $TEST_SERVICE"
- echo "TARGET=$TARGET" >> build.env #save TARGET for later stages
- echo "MAX_RPS=$MAX_RPS" >> build.env #save MAX_RPS for later stages
artifacts:
reports:
dotenv: build.env
generate-ammo:
stage: generate
script:
- make generate-ammo service=$TEST_SERVICE
```
Важно обратить внимание на **необходимость артефактов и на переменные окружения**.
Переменной TEST\_SERVICE присваивается значение `${CI_PROJECT_NAME}` на уровне upstream-проекта; в downstream-проекте она является переменной окружения и доступна со своим значением из любого места в пайплайне. А вот переменные, которые мы определяем в .load-tests:rules:variables, являются локальными и доступны только в рамках шага, выполняемого в этот момент. Поэтому их надо записать в [артефакт dotenv](https://docs.gitlab.com/ee/ci/yaml/artifacts_reports.html#artifactsreportsdotenv), а в последующих шагах этот артефакт считывать:
```
.gitlab-ci.yml
script:
- echo "TARGET=$TARGET" >> build.env #save TARGET for later stages
artifacts:
reports:
dotenv: build.env
generate-ammo:
stage: generate
script:
- make generate-ammo service=$TEST_SERVICE addr=$TARGET rps=$MAX_RPS
artifacts:
reports:
dotenv: build.env
```
Какие ещё подводные камни могут встретиться?
--------------------------------------------
#### Во-первых, повседневная разработка нагрузочного проекта.
На текущий момент в пайплайне нет никаких ограничений на запуск. Грубо говоря, при разработке новой фичи на каждый коммит будет триггериться падающий пайп, потому что в шаге .load-tests нет правила для нашего репозитория. Значение $TEST\_SERVICE в рамках запуска проекта `LOAD` равно пустой строке ””.
Каждый коммит будет сопровождаться вот таким безысходным зрелищем:
Поэтому можно добавить ещё правил для пайпа с нагрузкой — запускать его, только если сработал триггер.
Для этого в триггер добавляем ещё одну переменную LOAD\_PIPE: "true":
```
.trigger.yml
.run_load_tests:
stage: build
allow_failure: true
variables:
LOAD_PIPE: "true" #запускает именно тестовый пайп
LNL_TEST_SERVICE: ${CI_PROJECT_NAME}
```
А на шагах, которые мы хотим запускать по триггеру, добавляем условие
```
.gitlab-ci.yml:
generate-ammo:
rules:
- if: $LOAD_PIPE == "true"
```
Это позволяет добавить пайплайн для разработки. Ведь в нашем проекте НТ тоже должны быть тесты и линтер, которые повышают качество кода, и мы хотим их запускать на всех ветках, кроме мастера. Например:
```
.gitlab-ci.yml
test:
extends: .go
stage: build
script:
- go test ./...
except:
refs:
- master
allow_failure: false
```
#### Во-вторых, повседневная разработка тестируемого проекта.
НТ не требуется в каждом возможном коммите. В наших проектах мы решили его запускать уже после релиза на стейдж-окружение. То есть сначала код должен пройти юнит-тесты, функциональные тесты, ревью на merge request, интеграционные тесты — несколько проверок, позволяющие с большой уверенностью предположить, что изменения в коде сделаны нормально. Всё-таки НТ — ресурсозатратный процесс, с помощью которого хочется проверять более или менее готовый продукт. Поэтому в триггер мы добавили ограничение на тип веток: НТ может быть запущено только в релизных ветках на стадии пост-деплоя, то есть когда сервис уже раскатан, и только вручную:
```
.trigger.yml
.load_tests:
stage: post-deploy #upstream stage
when: manual
only: #запускать только в релизных ветках
refs:
- "/^release\\/.+$/"
```
#### В-третьих, права пользователей.
Чтобы иметь возможность запустить downstream-джобу, надо иметь [достаточно прав](https://docs.gitlab.com/ee/ci/pipelines/multi_project_pipelines.html#define-multi-project-pipelines-in-your-gitlab-ciyml-file) для запуска пайплайна в downstream-проекте. То есть людей, которые будут запускать пайплайн с тестами, необходимо добавить к себе в репозиторий с необходимыми правами.
#### В-четвёртых, можно запутаться в ветках: upstream, downstream…
Напомню, что в изначальной концепции был акцент на простоте — пользователям тестируемого сервиса нужно было делать минимум телодвижений или минимум изменений в своём проекте. Поэтому на уровне тестируемого upstream-проекта мы просто добавляем шаг, который наследует триггер.
В проекте `LOAD` пишем весь код для функционирования пушки, добавляем его в мастер — и после этого считаем, что актуальный код для НТ лежит там и нигде больше.
Финал
-----
#### Итак, финальные варианты файлов.
В проекте `LOAD`:
```
.trigger.yml
.run_load_tests:
stage: post-deploy #upstream stage
when: manual #НТ запускается вручную
allow_failure: true # НТ не влияет на прохождение пайплайна тестируемого сервиса
variables:
LOAD_PIPE: "true" #флаг запуска именно тестового пайпа
TEST_SERVICE: ${CI_PROJECT_NAME} # название upstream-проекта
SOME_OTHER_VAR:
value: "some_data"
description: "другие данные из upstream-проекта"
only: # запускать только в релизных ветках
refs:
- "/^release\\/.+$/"
trigger: # вызов тестов из другого репозитория
project: load #имя тестового репозитория НТ
strategy: depend #upstream pipe ждёт, пока пройдут все downstream-процессы
branch: master # при триггере запускается пайплайн из этой downstream-ветки
```
```
.gitlab-ci.yml
include:
- project: 'my/project/that/allows/to/use/golang'
ref: '0.0.5'
file:
- '/templates/go/.go.gitlab-ci.yml'
- local: '/.universal-ci.yml'
variables:
GO_VERSION: "1.17"
LOAD_PIPE:
value: "false"
description: "true if you want to start a load test"
stages:
- build
- aim
- generate
- upload
- config
- shoot
linter:
extends: .go
stage: build
script:
- make lint
except: # запускать только в релизных ветках
refs:
- master
allow_failure: true
test:
extends: .go
stage: build
script:
- go test ./...
except: # запускать только в релизных ветках
refs:
- master
allow_failure: true
# AIM
# описание джобы вынесено в /.universal-ci.yml для лучшей читаемости
load-tests:
extends: .load-tests
# GENERATE
generate-ammo:
stage: generate
script:
- make generate-ammo service=$TEST_SERVICE addr=$TARGET rps=$MAX_RPS
rules:
- if: $LOAD_PIPE == "true"
artifacts:
reports:
dotenv: build.env
# UPLOAD
upload-ammo:
stage: upload
script:
- make upload-ammo service=$TEST_SERVICE addr=$TARGET rps=$MAX_RPS
rules:
- if: $LOAD_PIPE == "true"
artifacts:
reports:
dotenv: build.env
#CONFIG
generate-config:
stage: config
script:
- make generate-config service=$TEST_SERVICE addr=$TARGET rps=$MAX_RPS
- make save-config-to-artifact
rules:
- if: $LOAD_PIPE == "true"
artifacts:
reports:
dotenv: build.env
paths:
- ./configs
expire_in: 1 day
#SHOOT
shoot:
stage: shoot
script:
- make shoot service=$TEST_SERVICE config=./configs
rules:
- if: $LOAD_PIPE == "true"
artifacts:
paths:
- ./configs
expire_in: 1 day
```
Описание джобы load-tests берётся из '/.universal-ci.yml', который указан в include в начале файла.
```
.universal-ci.yml
.load-tests:
stage: aim
rules:
- if: $TEST_SERVICE == "sut" #определение переменных для проекта sut
variables:
TARGET: "sut.service.stg:82"
MAX_RPS: "49"
- if: $TEST_SERVICE == "another-sut" #определение переменных для проекта another-sut
variables:
TARGET: "another-sut.service.stg:82"
MAX_RPS: "16"
script:
- echo "testing service $TEST_SERVICE"
- echo "TARGET=$TARGET" >> build.env #save TARGET for later stages
- echo "MAX_RPS=$MAX_RPS" >> build.env #save MAX_RPS for later stages
artifacts:
reports:
dotenv: build.env
```
В сервисе `SUT` мы дополняем только `.gitlab-ci.yml`:
```
include:
- project: load
ref: master #берётся версия триггера из мастера
file:
- .trigger.yml
LOAD tests:
extends: .run_load_tests
variables:
SOME_OTHER_VAR: "If you need it downstream"
```
Если нужно на уровне `SUT` переопределить, например, TARGET, то это можно просто добавить в описание джобы:
```
load tests:
extends: .run_load_tests
variables:
SOME_OTHER_VAR: "If you need it downstream"
TARGET: $GIBSON_TARGET #change it if you want to test custom release
```
На выходе получаем систему с таким устройством:
АрхитектураКак вы могли заметить, в **.gitlab-ci.yml** в шагах генерации патронов, конфигов и пушек скрипты создания самих сущностей указаны верхнеуровнево. Для того чтобы все эти генерации работали для всех проектов, нужно и пушки с генераторами патронов сделать универсальными. Обе эти вещи выходят за пределы сегодняшней темы, поэтому и описаны без подробностей.
Вывод
-----
Триггеры позволяют быстро автоматизировать процесс добавления функционала НТ в конечные сервисы. Регулярные обстрелы помогают определить, не уменьшилась ли пропускная способность сервиса, не ломаются ли интеграции с соседними сервисами при длительном взаимодействии, насколько оптимально работает железо. При таком встраивании НТ в жизненный цикл сервисов удаётся сэкономить время на генерации патронов и запуске вручную, а также тестировать сервис сразу после выкатки, а не ждать ночных стрельб по крону (если они вообще есть).
Но такие строгие шаги в пайплайне требуют единообразия всех генераторов. Патроны, пушки, конфиги должны создаваться одинаковым образом для разных сервисов, иметь консистентную структуру файлов. С другой стороны, это позволяет автоматизировать и их генерацию, а разработчику остаётся самое приятное — использовать своё воображение и реализовывать свои навыки под всей этой инкапсуляцией.
В этой статье я постаралась рассказать, как безболезненно встроить НТ в свой проект, как настроить и репозиторий с пушками, и репозиторий с тестируемым сервисом. Теперь вам известно, какие проблемы могут возникнуть при таком подходе и как их избежать.
Надеюсь, моя статья облегчит вам жизнь и поможет быстрее настроить окружение для НТ, автоматизировать запуск тестов и улучшить качество ваших проектов. Stay tuned! | https://habr.com/ru/post/669518/ | null | ru | null |
# Middleware и возможности Pipeline в Laravel
**Laravel** — это поистине большая и сложная система, которая старается решить большинство бытовых задач веб разработчика максимально элегантным способом и собрать в себе как можно больше инструментов и, что очень важно — с как можно более человеческим интерфейсом.
И сегодня речь пойдет об одном из таких инструментов, а точнее о его использовании и реализации со стороны программиста. Отсутствие полноценной документации, а также отсутствие русскоязычных статей и очень малое количество статей иностранных — подтолкнуло меня к решению раскрыть некую завесу тайны об этой интересной возможности фреймворка и выбору этой темы в качестве моей первой статьи на Хабре.
#### Middleware
> В этой статье предполагается, что читатель уже знаком с базовым использованием этого функционала фреймворка, поэтому долго останавливаться на этом пункте не буду.
Из коробки Laravel предоставляет нам достаточно мощный функционал фильтрации входящих HTTP запросов к нашему приложению. Речь идет о всеми любимых (или нет) [Middleware](https://laravel.com/docs/middleware) — с данными классами разработчик на пути освоения Laravel сталкивается достаточно быстро, еще на этапе чтения «The Basics» (Основы) пункта официальной документации, и это не удивительно — Middleware является одним из основных и важнейших кирпичиков, на основе которых строится вся система.
Примерами стандартных юз-кейсов этого компонента в Laravel являются: *EncryptCookies/RedirectIfAuthenticated/VerifyCsrfToken*, а в пример пользовательской реализации можно привести middleware локализации приложения (установки требуемой локализации на основе определенных данных запроса), перед передачей запроса дальше.
Глубже в бездну
---------------
#### Оставь надежду, всяк сюда входящий
Ну что же, теперь, когда с основными моментами покончено — мы можем углубиться в страшное для многих место — в альфа и омега, начало и конец — в [исходники Laravel](https://github.com/laravel/framework). Те, кто потянулся сразу закрывать статью — не торопитесь. На самом деле в исходном коде этого фреймворка почти нет чего-то действительно сложного с концептуальной стороны — создатели явно стараются не только создать ясный и удобный интерфейс работы со своим детищем, но и очень стараются делать тоже самое непосредственно на уровне исходного кода, что не может не радовать.
Я постараюсь максимально просто и доступно объяснить концепцию работы *Middleware* и *Pipeline* на уровне кода и логики, и постараюсь не углубляться туда — куда не нужно в рамках статьи. Так что, если в комментариях найдутся люди, знающие все строчки исходников наизусть — попрошу воздержаться от критики моего поверхностного повествования. Но любые рекомендации и исправления неточностей — лишь приветствуются.
#### Middleware — по ту сторону баррикад
Я верю, что изучение чего бы то ни было всегда дается проще, когда предоставляются хорошие примеры. Поэтому изучить этого таинственного зверя под именем *Pipeline* я предлагаю нам с вами вместе. Если действительно найдутся такие храбрецы — то перед дальнейшим чтением нам потребуется установить пустой проект Laravel версии 5.7 — версия обусловлена лишь тем, что она последняя на момент написания статьи, всё перечисленное должно быть идентично как минимум до версии 5.4. Те же, кто хочет просто узнать суть и выводы статьи — можете смело пропускать эту часть.
Что может быть лучше, чем изучение поведения какого-либо компонента, кроме как не изучение поведения уже встроенного в систему? Возможно что-то и может, но мы обойдемся без излишних усложнений и начнем наш разбор со стандартного Middleware — а именно с самого простого и понятного из всей банды — **RedirectIfAuthenticated**:
**RedirectIfAuthenticated.php**
```
class RedirectIfAuthenticated
{
/** Выполнить действия со входящим запросом
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @param string|null $guard
* @return mixed
*/
public function handle($request, Closure $next, $guard = null)
{
if (Auth::guard($guard)->check()) {
return redirect('/');
}
return $next($request);
}
}
```
В любом классическом middleware классе существует главный метод, который непосредственно и должен обработать запрос, и передать обработку следующему в цепочке — в нашем случае — это метод *handle*. В этом конкретном классе обработка запроса достаточно проста — «если пользователь авторизован — то перенаправить его на главную страницу и, тем самым, прекратить выполнение цепочки».
Если мы посмотрим на регистрацию этого Middleware в *app/Http/Kernel.php*, то мы увидим, что он зарегистрирован в 'route middleware'. Чтобы нам узнать как же система работает с этим middleware — перейдем в класс, от которого наш *app/Http/Kernel* наследуется — а наследуется он от класса *Illuminate\Foundation\Http\Kernel*. На данном этапе мы с вами непосредственно открываем врата в ~~ад~~ исходный код нашего фреймворка, а точнее — в самую важную и основную его часть — в ядро работы с HTTP. Кстати, кому интересно — Laravel базируется на многих компонентах [Symfony](https://symfony.com/), конкретно в этой части — на [HttpFoundation](https://github.com/symfony/http-foundation) и [HttpKernel](https://github.com/symfony/http-kernel).
Определение и реализация наших middleware в конструкторе ядра происходит следующим образом:
**Illuminate\Foundation\Http\Kernel(Application $app, Router $router)**
```
/** Создать новый объект HTTP Kernel класса.
* Create a new HTTP kernel instance.
*
* @param \Illuminate\Contracts\Foundation\Application $app
* @param \Illuminate\Routing\Router $router
* @return void
*/
public function __construct(Application $app, Router $router)
{
$this->app = $app;
$this->router = $router;
$router->middlewarePriority = $this->middlewarePriority;
foreach ($this->middlewareGroups as $key => $middleware) {
$router->middlewareGroup($key, $middleware);
}
foreach ($this->routeMiddleware as $key => $middleware) {
$router->aliasMiddleware($key, $middleware);
}
}
```
Код достаточно простой и понятный — для каждого middleware в массиве мы регистрируем его с алиасом/индексом в нашем роутере. Сами методы aliasMiddleware и middlewareGroups нашего Route класса — это простое добавление middleware в один из массивов объекта роутера. Но это не входит в контекст статьи, поэтому пропустим данный момент и двинемся дальше.
Что нас действительно интересует, так это метод **sendRequestThroughRoute**, дословно переводящийся, как **отправитьЗапросЧерезРоут**:
**Illuminate\Foundation\Http\Kernel::sendRequestThroughRouter($request)**
```
/** Отправить конкретный запрос через middleware / router.
* Send the given request through the middleware / router.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\Response
*/
protected function sendRequestThroughRouter($request)
{
// * пропущена часть кода *
return (new Pipeline($this->app))
->send($request)
->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
->then($this->dispatchToRouter());
}
```
В качестве параметра данный метод получает запрос. На данном моменте нам следует снова заглянуть в код нашего **RedirectIfAuthenticated**. В методе *handle* нашего middleware мы тоже получаем запрос, эта заметка нам понадобится немного позже.
Код выше имеет очень понятный и читаемый интерфейс — *«Трубопровод», который отправляет запрос через каждый из зарегистрированных middleware, а затем «передает» его в роутер*. Прелестно и замечательно. Я думаю на этом этапе мы не будем пытаться декомпозировать данный участок кода дальше, я лишь вкратце опишу роль этого участка во всей системе:
Перед попаданием запроса в ваш контроллер — проходит достаточно много действий, начиная от простого парсинга самой url, и заканчивая инициализацией класса [Request](https://laravel.com/api/5.7/Illuminate/Http/Request.html). Middleware в этой **цепочке** действий также участвует. Непосредственно классы middleware реализуют (почти) паттерн проектирования [Цепочка обязанностей или Chain of Responsibility](https://ru.wikipedia.org/wiki/%D0%A6%D0%B5%D0%BF%D0%BE%D1%87%D0%BA%D0%B0_%D0%BE%D0%B1%D1%8F%D0%B7%D0%B0%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B5%D0%B9), таким образом каждый конкретный класс midleware — это лишь звено в этой цепочке.
Выше мы не просто так вернулись в наш изначально рассматриваемый класс **RedirectIfAuthenticated**. Запрос «циркулирует» по цепи, в том числе он проходит и через все, требуемые для роута middleware. Этот момент поможет нам с работой со своими собственными звеньями своей собственной цепи, об этом дальше.
### Pipeline — канализация нашего приложения
Один из примеров реализации *Pipeline* мы видели выше. Но целью статьи было не только объяснение работы этого компонента на уровне интеграции с Laravel, а и объяснение базового принципа работы с этим классом в нашем собственном коде.
Сам класс можно найти по его полному определению с неймспейсом:
> Illuminate\Pipeline\Pipeline
Применений данному компоненту может быть достаточно много, в зависимости от конкретной задачи, которую вам требуется решить, но одной из самых очевидных мотиваций является требование создания своей собственной цепи обработчиков запроса, которая не вмешивается в процессы всей системы и определяется исключительно на уровне вашей бизнес логики. Также интерфейс класса имеет достаточный уровень абстракции и имеет достаточную для реализации разного вида очередей функциональность.
#### Пример реализации в Laravel
Реализуем максимально простую и отдаленную от реальности цепочку запросов. В качестве данных мы будем использовать строку " HELLO WORLD", и с помощью двух обработчиков мы сформируем из нее строку «Hello User». Код намеренно упрощен.
Перед непосредственной реализацией нашей собственной «Трубы», нам нужно определить элементы этой трубы. Элементы пишутся по аналогии с middleware:
**Определение обработчиков**StrToLowerAction.php:
```
use Closure;
class StrToLowerAction
{
/**
* Handle an incoming request.
*
* @param string $content
* @param Closure $next
* @return mixed
*/
public function handle(string $content, Closure $next)
{
$content = strtolower($content);
return $next($content);
}
}
```
SetUserAction.php:
```
use Closure;
class SetUserAction
{
/**
* Handle an incoming request.
*
* @param string $content
* @param Closure $next
* @return mixed
*/
public function handle(string $content, Closure $next)
{
$content = ucwords(str_replace('world', 'user', $content));
return $next($content);
}
}
```
Затем мы создаем «трубопровод», определяем что за данные мы хотим по нему отправить, определяем через какую коллекцию обработчиков мы хотим эти данные отправить, а также определяем callback, который получает в качестве аргумента наши данные, пройденные через всю цепочку. В том случае, когда данные на протяжении цепочки у нас остаются неизменными — часть с callback'ом можно опустить:
```
$pipes = [
StrToLowerAction::class,
SetUserNameAction::class
];
$data = 'Hello world';
$finalData = app(Pipeline::class)
->send($data) // Данные, которые мы хотим пропустить через обработчики
->through($pipes) // Коллекция обработчиков
->then(function ($changedData) {
return $changedData; // Возвращаются данные, пройденные через цепочку
});
var_dump($finalData); // Возвращенные данные записаны в переменную $finalData
```
Также, если у вас есть желание или потребность определить свой собственный метод в обработчиках, интерфейс Pipeline предоставляет специальный метод *via('method\_name')*, тогда обработка цепи может быть написана таким образом:
```
$finalData = app(Pipeline::class)
->send($data)
->through($pipes)
->via('handle') // Здесь может быть любое название метода, вы должны гарантировать его наличие во всех обработчиках
->then(function ($changedData) {
return $changedData;
});
```
Непосредственно данные, которые мы проводим через обработчики — могут быть абсолютно любыми, как и взаимодействие с ними. Тайп хинтинг и установка типа возвращаемого в цепочке объекта поможет избежать ошибок с целостностью данных.
Заключение
----------
Laravel предоставляет большое количество встроенных классов, и гибкость многих из них позволяет с достаточной простотой вести разработку чего-то сложного. В этой статье была рассмотрена возможность создания простых очередей для запросов на основе встроенного в Laravel класса Pipeline. Реализации этого класса в конечном коде могут быть абсолютно разными, а гибкость этого инструмента позволяет избавиться от многих лишних действий при построении определенных алгоритмов.
Как конкретно использовать данную возможность фреймворка — зависит от поставленных перед вами задач. | https://habr.com/ru/post/429214/ | null | ru | null |
# Личный опыт: переход с низкоуровневой разработки на C к программированию на Java
Статья отражает личный опыт автора – заядлого программиста микроконтроллеров, которому после многолетнего опыта микроконтроллерной разработки на языке С (и немного на С++) довелось участвовать в крупном Java-проекте по разработке ПО для ТВ-приставок под управлением Android. В ходе этого проекта удалось собрать заметки об интересных различиях языков Java и C/C++, оценить разные подходы к написанию программ. Статья не претендует на роль справочника, в ней не рассматривается эффективность и производительность Java-программ. Это скорее сборник личных наблюдений. Если не указано иное, то речь идет о версии Java SE 7.
Различия в синтаксисе и управляющие конструкции
-----------------------------------------------
Если говорить кратко – различия минимальные, синтаксис очень похож. Блоки кода также формируются парой фигурных скобок {}. Правила составления идентификаторов – такие же, как и для языка C/С++. Список ключевых слов почти такой же, как в языке C/С++. Встроенные типы данных – подобны таковым в C/С++. Массивы – все также объявляются с помощью квадратных скобок.
Управляющие конструкции if-else, while, do-while, for, switch тоже почти полностью идентичные. Примечательно, что в Java остались знакомые C-программистам метки (те, которые используются с ключевым словом goto и применение которых категорически не рекомендуется). Однако из Java исключили возможность перехода на метку с помощью goto. Метки следует использовать только для выхода из вложенных циклов:
```
outer:
for (int i = 0; i < 5; i++) {
inner:
for (int j = 0; j < 5; j++) {
if (i == 2) break inner;
if (i == 3) continue outer;
}
}
```
Для улучшения читаемости программ в Java добавлена интересная возможность разделять разряды длинных чисел символом подчеркивания:
```
int value1 = 1_500_000;
long value2 = 0xAA_BB_CC_DD;
```
Внешне программа на Java не сильно отличается от программы на знакомом C. Главное визуальное отличие – Java не допускает «свободно» расположенных в исходном файле функций, переменных, определений новых типов (структур), констант и прочего. Java – объектно-ориентированный язык, поэтому все программные сущности должны принадлежать какому-либо классу. Еще одно значительное отличие – отсутствие препроцессора. Об этих двух различиях подробнее рассказано ниже.
Объектный подход в языке C
--------------------------
Когда мы пишем на языке C большие программы, по сути нам приходится работать с объектами. Роль объекта здесь выполняет структура, которая описывает некую сущность «реального мира»:
```
// Объявление структуры – «класса»
struct Data {
int field;
char *str;
/* ... */
};
```
Также в C есть методы обработки «объектов»-структур – функции. Однако функции по сути не объединены с данными. Да, их обычно помещают в один файл, но в «типовую» функцию каждый раз необходимо передавать указатель на обрабатываемый объект:
```
int process(struct Data *ptr, int arg1, const char *arg2) {
/* ... */
return result_code;
}
```
Пользоваться «объектом» можно только после выделения памяти для его хранения:
```
Data *data = malloc(sizeof(Data));
```
В программе на C обычно определяют функцию, которая отвечает за начальную инициализацию «объекта» перед первым его использованием:
```
void init(struct Data *data) {
data->field = 1541;
data->str = NULL;
}
```
Тогда жизненный цикл «объекта» в C обычно такой:
```
/* Выделить память для "объекта" */
struct Data *data = malloc(sizeof(Data));
/* Инициализировать "объект" */
init(data);
/* Изменить состояние "объекта" */
process(data, 0, "string");
/* Освободить память, занимаемую "объектом" когда он уже не нужен. */
free(data);
```
Теперь перечислим возможные ошибки времени выполнения, которые могут быть допущены программистом в жизненном цикле «объекта»:
1. Забыть выделить память для «объекта»
2. Указать неверный объем выделяемой памяти
3. Забыть проинициализировать «объект»
4. Забыть освободить память после окончания использования объекта
Выявить подобные ошибки может быть крайне сложно, так как они не определяются компилятором и проявляются во время работы программы. Более того, их эффект может быть очень разнообразным и сказываться на других переменных и «объектах» программы.
Объектный подход Java
---------------------
Сталкиваясь с ООП – объектно-ориентированным программированием, вы наверняка слышали об одном из китов ООП – инкапсуляции. В Java, в отличие от C, данные и методы их обработки объединены вместе и представляют собой «истинные» объекты. В терминах ООП это называют инкапсуляцией. Класс – это описание объекта, ближайший аналог класса в C – определение нового типа с помощью typedef struct. В терминах Java те функции, которые принадлежат классу, называют методами.
```
// Описание класса
class Entity {
public int field; // Поле данных
public String str; // Поле данных
// Метод
public int process(int arg1, String arg2) {
/* ... */
return resultCode;
}
// Конструктор
public Entity() {
field = 1541;
str = "value";
}
}
```
В основе идеологии языка Java лежит утверждение «все есть объект». Поэтому не удивительно, что Java запрещает создавать как методы (функции), так и поля данных (переменные) отдельно от класса. Даже привычный метод main(), с которого начинается выполнение программы, должен принадлежать одному из классов.
Описание класса в Java – это аналог объявления структуры в C. Описав класс, вы ничего не создаете в памяти. Объект данного класса появляется в момент своего создания оператором new. Создание объекта в Java – это аналог выделения памяти в языке C, но, в отличие от последнего, во время создания автоматически вызывается специальный метод – конструктор объекта. Конструктор берет на себя роль начальной инициализации объекта – аналог функции init(), рассмотренной ранее. Имя конструктора обязательно должно совпадать с именем класса. Конструктор не может возвращать значение.
Жизненный цикл объекта в программе на Java выглядит следующим образом:
```
// Создать объект (выделить память и инициализировать, вызвав конструктор)
Entity entity = new Entity();
// Изменить состояние объекта
entity.process(123, "argument");
```
Заметьте, что количество возможных ошибок в программе на Java значительно меньше, чем в программе на C. Да, по-прежнему можно забыть создать объект перед первым использованием (что впрочем приведет к легко отлаживаемому исключению NullPointerException), но то что касается остальных ошибок, присущих программам на C, ситуация коренным образом меняется:
1. В Java отсутствует оператор sizeof(). Компилятор Java сам рассчитывает объем памяти для хранения объекта. Следовательно, невозможно указать неверный размер выделяемой области.
2. Инициализация объекта происходит в момент создания. Невозможно забыть о проведении инициализации.
3. Память, занимаемую объектом, не нужно освобождать, эту работу выполняет сборщик мусора. Невозможно забыть удалить объект после использования – меньше вероятность появления эффекта «утечки памяти».
Итак, все в Java является объектом того или иного класса. Исключением являются примитивы, которые были добавлены в язык для улучшения производительности и потребления памяти. Подробнее о примитивах – ниже.
Память и сборщик мусора
-----------------------
В Java сохранены знакомые C/C++-программисту понятия кучи и стека. При создании объекта оператором new память для хранения объекта заимствуется из кучи. Однако ссылка на объект (ссылка – аналог указателя), если созданный объект не входит в состав другого объекта, размещается в стеке. В куче хранятся «тела» объектов, а в стеке – локальные переменные: ссылки на объекты и примитивные типы. Если куча существует на протяжении выполнения программы и доступна для всех потоков программы, то стек относится к методу и существует только во время его выполнения, а также недоступен для других потоков программы.
В Java нет необходимости и даже более того – нельзя вручную освободить память, занимаемую объектом. Эту работу выполняет сборщик мусора в автоматическом режиме. Среда выполнения следит, можно ли из текущего места программы достигнуть каждого объекта в куче, переходя по ссылкам от объекта к объекту. Если нет – то такой объект признается «мусором» и становится кандидатом на удаление.
Важно отметить, что само удаление происходит не в момент, когда объект «перестал быть нужен» – решение об удалении принимает сборщик мусора, и удаление может откладываться сколько угодно, вплоть до момента окончания работы программы.
Разумеется, работа сборщика мусора требует накладных расходов процессорного времени. Но взамен он избавляет программиста от большой головной боли, связанной с необходимостью освобождать память после окончания использования «объектов». Фактически мы «берем» память, когда нам это нужно и пользуемся ей, не думая, что ее надо после себя освобождать.
Говоря о локальных переменных, следует вспомнить подход Java к их инициализации. Если в C/C++ неинициализированная локальная переменная содержит случайное значение, то компилятор Java попросту не позволит оставить ее неинициализированной:
```
int i; // Неинициализированная переменная.
System.out.println("" + i); // Ошибка компиляции!
```
Ссылки – замена указателям
--------------------------
В Java отсутствуют указатели, соответственно у Java-программиста нет возможности совершить одну из множества ошибок, возникающих при работе с указателями. Когда вы создаете объект, вы получаете ссылку на этот объект:
```
// Переменная entity – ссылочный тип.
Entity entity = new Entity();
```
В языке C у программиста был выбор: как передавать, скажем, структуру в функцию. Можно было передавать по значению:
```
// Передача структуры по значению.
int func(Data data);
А можно было – передавать через указатель:
// Передача структуры через указатель.
void process(Data *data);
```
Передача по значению гарантировала, что функция не изменит данные в структуре, но была неэффективной с точки зрения быстродействия – в момент вызова функции создавалась копия структуры. Передача через указатель гораздо более эффективна: фактически в функцию передавался адрес в памяти, где расположена структура.
В Java оставили только один способ передачи объекта в метод – по ссылке. Передача по ссылке в Java – аналог передачи через указатель в C:
* копирования (клонирования) памяти не происходит,
* фактически передается адрес размещения данного объекта.
Однако, в отличии от указателя языка C, ссылку Java нельзя инкрементировать/декрементировать. «Бегать» по элементам массива с помощью ссылки на него в Java не получится. Все, что можно сделать со ссылкой, это присвоить ей другое значение.
Безусловно отсутствие указателей как таковых уменьшает количество возможных ошибок, однако в языке остался аналог нулевого указателя – нулевая ссылка, обозначаемая ключевым словом null.
Нулевая ссылка – это головная боль Java-программиста, т.к. вынуждает перед использованием ссылки на объект либо проверить ее на null, либо обрабатывать исключения NullPointerException. Если этого не делать, то произойдет крах программы.
Итак, все объекты в Java передаются через ссылки. Примитивные же типы данных (int, long, char...) – передаются по значению (подробнее о примитивах – ниже).
Особенности ссылок в Java
-------------------------
Доступ к любому объекту в программе осуществляется через ссылку – это однозначно положительно сказывается на производительности, но может преподнести сюрприз новичку:
```
// Создать объект, пусть ссылка entity1 указывает не него.
Entity entity1 = new Entity();
entity1.field = 123;
// Создать ссылку entity2, которая указывает на объект entity1.
// Новый объект не создается! Память не выделяется!
Entity entity2 = entity1;
// Теперь ссылки entity1 и entity2 указывают на один и тот же объект в памяти.
entity2.field = 777;
// Теперь entity1.field равно 777.
System.out.println(entity1.field);
```
Аргументы методов и возвращаемые значения – все передается через ссылку. Кроме преимуществ в этом кроется недостаток по сравнению с языками C/С++, где мы можем явно запретить функции менять значение, переданное через указатель с помощью квалификатора типа const:
```
void func(const struct Data* data) {
// Ошибка компиляции!
// Попытка записи в объект, доступный только для чтения!
data->field = 0;
}
```
То есть язык C позволяет отследить эту ошибку на этапе компиляции. В Java так же есть ключевое слово const, но оно зарезервировано для будущих версий и сейчас вообще не используется. Его роль в некоторой степени призвано выполнять ключевое слово final. Однако оно не позволяет защитить передаваемый в метод объект от изменений:
```
public class Main {
void func(final Entity data) {
// Компилятор не выдает ошибок.
// Не смотря на final, значение поля успешно обнуляется.
data.field = 0;
}
}
```
Все дело в том, что ключевое слово final в данном случае применяется к ссылке, а не к объекту, на который эта ссылка указывает. Если применить final к примитиву, то компилятор ведет себя так, как и ожидается:
```
void func(final int value) {
// Ошибка на стадии компиляции.
value = 0;
}
```
Ссылки Java очень похожи на ссылки языка C++.
Примитивы Java
--------------
Каждый объект Java помимо полей данных содержит вспомогательную информацию. Если мы хотим оперировать, например, отдельными байтами и каждый байт представлен объектом, то в случае массива байт накладные расходы памяти могут многократно превысить полезный объем.
Чтобы Java оставалась достаточно эффективной и в случаях, описанных выше, в язык была добавлена поддержка примитивных типов – примитивов.
| Примитив | Вид | Разрядность, бит | Возможный аналог в C |
| --- | --- | --- | --- |
| byte | Целочисленные | 8 | char |
| short | 16 | short |
| char | 16 | wchar\_t |
| int | 32 | int (long) |
| long | 64 | long |
| float | Числа с плавающей точкой | 32 | float |
| double | | 64 | double |
| boolean | Логический | - | int (C89) / bool (C99) |
Все примитивы имеют свои аналоги в языке C. Однако стандарт C не определяет точный размер целочисленных типов, вместо этого фиксируется диапазон значений, которые может хранить данный тип. Зачастую программист хочет обеспечить одинаковую разрядность для разных машин, что приводит к появлению в программе типов наподобие uint32\_t, хотя все библиотечные функции как раз таки требуют аргументов типа int.
Этот факт никак нельзя отнести к преимуществам языка.
Целочисленные примитивы в Java, в отличии от C, имеют фиксированную разрядность. Таким образом, можно не заботиться о реальной разрядности машины, на которой выполняется Java-программа, а также о порядке байт («сетевой» или «интеловский»). Этот факт помогает реализовать принцип «написано однажды – выполняется везде».
Кроме этого, в Java все целочисленные примитивы – знаковые (в языке отсутствует ключевое слово unsigned). Это исключает трудности при совместном использовании знаковых и беззнаковых переменных в одном выражении, присущие языку C.
В завершение, порядок байт в многобайтных примитивах в Java фиксированный (младший байт по младшему адресу, Little-endian, обратный порядок).
К недостаткам реализации операций с примитивами в Java можно отнести тот факт, что здесь, как и в программе на C/C++, может произойти переполнение разрядной сетки, причем никаких исключений при этом не возбуждается:
```
int i1 = 2_147_483_640;
int i2 = 2_147_483_640;
int r = (i1 + i2); // r = -16
```
Итак, данные в Java представлены двумя видами сущностей: объектами и примитивами. Примитивы нарушают концепцию «все есть объект», но в некоторых ситуациях слишком эффективны, чтобы их не использовать.
Наследование
------------
Наследование является еще одним китом ООП, о котором вы наверняка слышали. Если ответить кратко на вопрос «зачем наследование вообще нужно», то ответом будет «повторное использование кода».
Допустим, вы программируете на C, и у вас есть хорошо написанный и отлаженный «класс» – структура и функции для ее обработки. Далее возникает необходимость создать подобный «класс», но с расширенной функциональностью, причем базовый «класс» все еще остается нужен. В случае языка C для решения такой задачи у вас есть единственный путь – композиция. Речь идет о создании новой расширенной структуры-»класса», которая должна содержать указатель на базовый «класс»-структуру:
```
struct Base {
int field1;
char *field2;
};
void baseMethod(struct Base *obj, int arg);
struct Extended {
struct Base *base;
int auxField;
};
void extendedMethod(struct Extended *obj, int arg) {
baseMethod(obj->base, 123);
/* ... */
}
```
Java как объектно-ориентированный язык позволяет расширять функциональность имеющихся классов с помощью механизма наследования:
```
// Базовый класс
class Base {
protected int baseField;
private int hidden;
public void baseMethod() {
}
}
// Производный класс - расширяет функциональность базового.
class Extended extends Base {
public void extendedMethod() {
// Полный доступ к public и protected полям и методам базового класса.
baseField = 123;
baseMethod();
// ОШИБКА! Доступ к private полям запрещен!
hidden = 123;
}
}
```
Необходимо отметить, что Java ни в коем разе не запрещает использовать композицию как способ расширения функциональности уже написанных классов. Более того, во многих ситуациях композиция оказывается предпочтительнее наследования.
Благодаря наследованию классы в Java выстраиваются в иерархическую структуру, каждый класс обязательно имеет одного и только одного «родителя» и может иметь сколько угодно «детей». В отличие от C++, класс в Java не может наследовать более чем от одного родителя (таким образом решается проблема «ромбовидного наследования»).
При наследовании производный класс получает в свое расположение все public и protected поля и методы своего базового класса, а также базового класса своего базового класса и так далее вверх по иерархии наследования.
На вершине иерархии наследования находится общий прародитель всех Java классов – класс Object, единственный, кто не имеет родителя.
Динамическая идентификация типа
-------------------------------
Одним из ключевых моментов языка Java является поддержка динамической идентификации типов (RTTI). Если говорить простыми словами, то RTTI позволяет подставлять объект производного класс там, где требуется ссылка на базовый:
```
// Ссылка на базовый класс
Base link;
// Ссылке на базовый класс присвоить объект производного класса
link = new Extended();
```
Имея ссылку во время выполнения программы, можно определить истинный тип объекта, на который данная ссылка ссылается – с помощью оператора instanceof:
```
if (link instanceof Base) {
// false
} else if (link instanceof Extended) {
// true
}
```
Переопределение методов
-----------------------
Под переопределением метода или функции понимается замена его или ее тела на этапе выполнения программы. Программистам C известна возможность языка изменить поведение функции во время выполнения программы. Речь идет об использовании указателей на функции. Например, в состав структуры можно включить указатель на функцию и присваивая указателю различные функции менять алгоритм обработки данных этой структуры:
```
struct Object {
// Указатель на функцию.
void (*process)(struct Object *);
int data;
};
void divideByTwo(struct Object *obj) {
obj->data = obj->data / 2;
}
void square(struct Object *obj) {
obj->data = obj->data * obj->data;
}
struct Object obj;
obj.data = 123;
obj.process = divideByTwo;
obj.process(&obj); // 123 / 2 = 61
obj.process = square;
obj.process(&obj); // 61 * 61 = 3721
```
В Java, как и в других языках ООП, переопределение (overriding) методов неразрывно связано с наследованием. Производный класс получает доступ к public- и protected-методам базового класса. Кроме того, что он может их вызывать, можно изменить поведение одного из методов базового класса, не меняя при этом его сигнатуру. Для этого достаточно определить в производном классе метод с точно такой же сигнатурой:
```
// Производный класс - расширяет функциональность базового.
class Extended extends Base {
// Переопределенный метод.
public void method() { /* ... */ }
// Этот же метод не переопределен!
// Eго сигнатура отличается от метода базового класса.
// Это самостоятельный метод производного класса.
public void method(int i) { /* ... */ }
}
```
Очень важно, чтобы сигнатура (имя метода, возвращаемое значение, аргументы) с точностью совпадали. Если имя метода совпадает, а аргументы отличаются, то происходит перегрузка (overloading) метода, подробнее о которой ниже.
Полиморфизм
-----------
Как инкапсуляция и наследование, третий кит ООП – полиморфизм – также имеет в некотором роде аналог в процедурно-ориентированном языке C.
Допустим у нас есть несколько «классов»-структур, с которыми требуется выполнять однотипное действие, причем функция, выполняющая это действие, должна быть универсальной – должна «уметь» работать с любым «классом» в качестве аргумента. Возможное решение выглядит так:
```
/* Идентификаторы классов */
enum Ids {
ID_A, ID_B
};
struct ClassA {
int id;
/* ... */
}
void aInit(ClassA obj) {
obj->id = ID_A;
}
struct ClassB {
int id;
/* ... */
}
void bInit(ClassB obj) {
obj->id = ID_B;
}
/* klass - указатель на ClassA, ClassB, ... */
void commonFunc(void *klass) {
/* Получить идентификатор */
int id = (int *)klass;
switch (id) {
case ID_A:
ClassA *obj = (ClassA *) klass;
/* ... */
break;
case ID_B:
ClassB *obj = (ClassB *) klass;
/* ... */
break;
}
/* ... */
}
```
Решение выглядит громоздко, но цель достигнута – универсальная функция commonFunc() принимает в качестве аргумента «объект» любого «класса». Обязательное условие – «класс»-структура в первом поле должна содержать идентификатор, по которому определяется действительный «класс» объекта. Такое решение возможно благодаря использованию аргумента с типом «void \*». Однако такой функции можно передать указатель любого типа, например, «int \*». Ошибок компиляции это не вызовет, но во время выполнения программа будет вести себя непредсказуемо.
Теперь рассмотрим, как полиморфизм выглядит в Java (впрочем, как и в любом другом языке ООП). Пусть у нас есть множество классов, которые должны однотипно обрабатываться некоторым методом. В отличие от решения для языка С, представленного выше, этот полиморфный метод ОБЯЗАН входить в состав всех классов данного множества, и все его версии ОБЯЗАНЫ иметь одинаковую сигнатуру.
```
class A {
public void method() {/* ... */}
}
class B {
public void method() {/* ... */}
}
class C {
public void method() {/* ... */}
}
```
Далее необходимо заставить компилятор вызывать именно ту версию метода, которая принадлежит соответствующему классу.
```
void executor(_set_of_class_ klass) {
klass.method();
}
```
То есть метод executor(), который может быть где угодно в программе, должен «уметь» работать с любым классом из множества (A, B или C). Надо каким-то образом «сказать» компилятору, что \_set\_of\_class\_ обозначает наше множество классов. Здесь и пригождается наследование – необходимо сделать все классы из множества производными некоторого базового класса, который будет содержать полиморфный метод:
```
abstract class Base {
abstract public void method();
}
class A extends Base {
public void method() {/* ... */}
}
class B extends Base {
public void method() {/* ... */}
}
class C extends Base {
public void method() {/* ... */}
}
Тогда метод executor() будет выглядеть так:
void executor(Base klass) {
klass.method();
}
```
И теперь ему можно передавать в качестве аргумента любой класс, который является наследником Base (благодаря динамической идентификации типа):
```
executor(new A());
executor(new B());
executor(new C());
```
В зависимости от того, объект какого класса передан в качестве аргумента, будет вызван метод, принадлежащий этому классу.
Ключевое слово abstract позволяет исключить тело метода (сделать его абстрактным, выражаясь терминами ООП). Фактически мы говорим компилятору, что этот метод должен быть обязательно переопределен в классах наследниках. Если это не так, возникает ошибка компиляции. Класс, содержащий хотя бы один абстрактный метод, также называют абстрактным. Компилятор требует помечать такие классы также ключевым словом abstract.
Структура проекта на Java
-------------------------
В Java все файлы с исходным кодом имеют расширение \*.java. Отсутствуют как заголовочные файлы \*.h, так и прототипы функций или классов. Каждый файл с исходным кодом Java должен содержать хотя бы один класс. Имя класса принято записывать, начиная с заглавной буквы.
Несколько файлов с исходным кодом могут объединяться в пакет (package). Для этого должны быть выполнены следующие условия:
1. Файлы с исходным кодом должны находиться в одной директории в файловой системе.
2. Имя этой директории должно совпадать с именем пакета.
3. В начале каждого файла с исходным кодом должен быть указан пакет, к которому этот файл относится, например:
```
package com.company.pkg;
```
Чтобы обеспечить уникальность имен пакетов в пределах земного шара предлагается использовать «перевернутое» доменное имя компании. Однако это не является требованием и в локальном проекте можно использовать любые имена.
Рекомендуется также задавать имена пакетов в нижнем регистре. Так их можно легко отличить от имен классов.
Сокрытие реализации
-------------------
Еще один аспект инкапсуляции – разделение интерфейса и реализации. Если интерфейс доступен для внешних частей программы (внешних по отношению к модулю или классу), то реализация скрыта. В литературе часто проводят аналогию с черным ящиком, когда снаружи «не видна» внутренняя реализация, но «видно» то, что подается на вход ящика и что он выдает на выходе.
В языке C сокрытие реализации выполняют внутри модуля, помечая функции, которые не должны быть видны извне, ключевым словом static. Прототипы функций, которые составляют интерфейс модуля, выносятся в заголовочный файл. Под модулем в языке C понимается пара: файл с исходным кодом с расширением \*.c и заголовочный с расширением \*.h.
В Java также есть ключевое слово static, но оно не влияет на «видимость» метода или поля извне. Для управления «видимостью» предназначены 3 модификатора доступа: private, protected, public.
Поля и методы класса, помеченные как private, доступны только внутри его самого. Поля и методы protected доступны также наследникам класса. Модификатор public означает, что помеченный элемент доступен извне класса, то есть является частью интерфейса. Также возможно отсутствие модификатора, в этом случае доступ к элементу класса ограничен пакетом, в котором данный класс находится.
Рекомендуют в процессе написания класса изначально помечать все поля класса как private и расширять права доступа по мере возникновения необходимости.
Перегрузка методов
------------------
Одной из раздражающих черт стандартной библиотеки C является наличие целого зоопарка функций, выполняющих по сути одно и тоже, но различающихся типом аргумента, например: fabs(), fabsf(), fabsl() – функции для получения абсолютного значения для double, float и long double типов соответственно.
Java (а также С++) поддерживает механизм перегрузки методов – внутри класса может быть несколько методов с полностью идентичным именем, но различающихся между собой типом и количеством аргументов. По количеству аргументов и их типу компилятор сам выберет нужную версию метода – очень удобно и улучшает читаемость программы.
В Java в отличии от C++ нельзя перегружать операторы. Исключение составляют операторы «+» и «+=», которые изначально перегружены для строк String.
Символы и строки в Java
-----------------------
В языке C приходится работать с нуль-терминальными строками, представленными указателями на первый символ:
```
char *str; // строка ASCII символов
wchar_t *strw; // строка из "широких" символов
```
Такие строки обязаны завершаться нулевым символом. Если его случайно «затереть», то строкой будет считаться последовательность байт в памяти до первого нулевого символа. То есть если в памяти после строки размещаются другие переменные программы, то после модификации такой поврежденной строки их значения могут быть (и скорее всего будут) искажены.
Конечно же C-программист не обязан использовать классические нуль-терминальные строки, а применить стороннюю реализацию, но тут надо иметь ввиду, что все функции из стандартной библиотеки требуют в качестве своих аргументов именно нуль-терминальные строки. Кроме этого, стандарт C не определяет используемую кодировку, этот момент также должен контролировать программист.
В Java примитивный тип char (а также «обертка» Character, об «обертках» – ниже) представляют один символ согласно стандарту Unicode. Используется кодировка UTF-16, соответственно один символ занимает в памяти 2 байта, что позволяет закодировать практически все символы используемых в настоящее время языков.
Символы можно задавать по их Unicode:
```
char ch1 = '\u20BD';
```
Если Unicode символа превышает максимальный 216 для типа char, то такой символ должен быть представлен типом int. В строке же он будет занимать 2 символа по 16 бит, но опять-таки символы с кодом, превышающем 216, используются крайне редко.
Строки Java реализованы встроенным классом String и хранят 16-битные символы char. В классе String собрано все или почти все, что может потребоваться для работы со строками. Здесь не надо думать о том, что строка должна обязательно заканчиваться нулем, здесь невозможно незаметно «затереть» этот нулевой завершающий символ или обратиться к памяти за пределы строки. И вообще, работая со строками в Java, программист не задумывается о том, в каком виде строка хранится в памяти.
Как говорилось выше, Java не допускает перегрузки операторов (как в С++), однако класс String является исключением – только для него изначально перегружены операторы слияния строк «+» и «+=».
```
String str1 = "Hello, " + "World!";
String str2 = "Hello, ";
str2 += "World!";
```
Примечательно, что строки в Java неизменны – будучи один раз созданы, они не допускают своего изменения. Когда мы пытаемся поменять строку, например, так:
```
String str = "Hello, World!";
str.toUpperCase();
System.out.println(str); // Будет выведено "Hello, World!"
```
Tо исходная строка на самом деле не меняется. Вместо этого создается измененная копия исходной строки, которая в свою очередь так же является неизменной:
```
String str = "Hello, World!";
String str2 = str.toUpperCase();
System.out.println(str2); // Будет выведено "HELLO, WORLD!"
```
Таким образом каждое изменение строки в реальности оборачивается созданием нового объекта (на самом деле в случаях слияния строк компилятор может оптимизировать код и использовать класс StringBuilder, о котором будет рассказано позже).
Бывает, что в программе необходимо часто изменять одну и ту же строку. В таких случаях в целях оптимизации быстродействия программы и потребления памяти можно предотвратить создание новых объектов-строк. Для этих целей следует использовать класс StringBuilder:
```
String sourceString = "Hello, World!";
StringBuilder builder = new StringBuilder(sourceString);
builder.setCharAt(4, '0');
builder.setCharAt(8, '0');
builder.append("!!");
String changedString = builder.toString();
System.out.println(changedString); // Будет выведено "Hell0, W0rld!!!"
```
Отдельно стоит сказать о сравнении строк. Типичная ошибка начинающего Java-программиста, это сравнение строк с помощью оператора «==»:
```
// Если пользователь ввел "Yes"
// ОШИБКА!
if (usersInput == "Yes") {
// Если строки равны
}
```
Такой код формально не содержит ошибок на стадии компиляции или ошибок времени выполнения, но работает он иначе, чем это можно было бы ожидать. Так как все объекты и строки, в том числе в Java, представлены ссылками, то сравнение оператором «==» дает сравнение ссылок, а не значений объектов. То есть результат будет true только если 2 ссылки действительно ссылаются на одну и ту же строку. Если же строки – разные объекты в памяти, и необходимо сравнить их содержимое, то надо использовать метод equals():
```
if (usersInput.equals("Yes")) {
// Строки ДЕЙСТВИТЕЛЬНО равны
}
```
Самое удивительное, что в некоторых случаях сравнение с помощью оператора «==» работает правильно:
```
String someString = "abc", anotherString = "abc";
// Будет выведено "true":
System.out.println(someString == anotherString);
```
Так происходит из-за того, что в действительности ссылки someString и anotherString указывают на один и тот же объект в памяти. Компилятор помещает одинаковые строковые литералы в пул строк – происходит так называемое интернирование. Тогда каждый раз, когда в программе появляется такой же строковый литерал, используется ссылка на строку из пула. Интернирование строк как раз-таки и возможно благодаря свойству неизменности строк.
Хотя сравнение содержимого строк допускается только методом equals(), в Java есть возможность корректно использовать строки в switch-case конструкциях (начиная с версии Java 7):
```
String str = new String();
// ...
switch (str) {
case "string_value_1":
// ...
break;
case "string_value_2":
// ...
break;
}
```
Любопытно, что любой объект Java можно преобразовать в строку. Соответствующий метод toString() определен в базовом для всех классов классе Object.
Подход к обработке ошибок
-------------------------
Программируя на C, вы могли встречать следующий подход к обработке ошибок. Каждая функция какой-либо библиотеки возвращает тип int. Если функция выполнена успешно, то этот результат равен 0. Если же результат отличен от нуля – это свидетельствует об ошибке. Чаще всего код ошибки передают через возвращаемое функцией значение. Так как функция может вернуть лишь одно значение, и оно уже занято кодом ошибки, то действительный результат функции приходится возвращать через аргумент в виде указателя, например, так:
```
int function(struct Data **result, const char *arg) {
int errorCode;
/* ... */
return errorCode;
}
```
Кстати, это один из случаев, когда в программе на C возникает необходимость в использовании указателя на указатель.
Иногда используют другой подход. Функция возвращает не код ошибки, а непосредственно результат своего выполнения, обычно в виде указателя. Ошибочная ситуация индицируется при этом нулевым указателем. Тогда библиотека обычно содержит отдельную функцию, которая возвращает код последней ошибки:
```
struct Data* function(const char *arg);
int getLastError();
```
Так или иначе, при программировании на C код, выполняющий «полезную» работу, и код, отвечающий за обработку ошибок, перемежает друг друга, что явно не делает программу легко читаемой.
В Java при желании можно использовать подходы, описанные выше, однако здесь можно применить совершенно иной способ работы с ошибками – обработка исключений (впрочем, как и в C++). Преимущество обработки исключений состоит в том, что в этом случае «полезный» код и код, отвечающий за обработку ошибок и нештатных ситуаций, логически отделены друг от друга.
Достигается это с помощью конструкций try-catch: в секции try размещается «полезный» код, а в секции catch – код обработки ошибок.
```
// При открытии файла может возникнуть ошибка
try (FileReader reader = new FileReader("path\\to\\file.txt")) {
// При чтении файла - также возможна ошибка.
while (reader.read() != -1){
// ...
}
} catch (IOException ex) {
// Все ошибки обрабатываются здесь
}
```
Бывают ситуации, когда правильно обработать ошибку в месте ее возникновения не представляется возможным. В таких случаях в сигнатуру метода помещают указание, что метод может вызывать данный вид исключений:
```
public void func() throws Exception {
// ...
}
```
Теперь вызов данного метода должен обязательно быть обрамлен в блок try-catch, или вызывающий метод также должен быть помечен, что он может вызывать это исключение.
Отсутствие препроцессора
------------------------
Как бы ни был удобен знакомый C/C++-программистам препроцессор, в языке Java он отсутствует. Разработчики Java вероятно решили, что он используется только для обеспечения переносимости программ, а так как Java выполняется везде (почти) то и препроцессор в ней не нужен.
Компенсировать отсутствие препроцессора можно использованием статического поля-флага и проверять его значение в программе, где это необходимо.
Если же речь идет об организации тестирования, то здесь возможно применение аннотаций в совокупности с отражением (рефлексией).
Массив – это тоже объект
------------------------
При работе с массивами на C, выход индекса за границы массива представляет собой очень коварную ошибку. Компилятор ни коем образом не сообщит о ней, а во время выполнения программа не будет остановлена с соответствующим сообщением:
```
int array[5];
array[6] = 666;
```
Скорее всего программа продолжит выполнение, но значение переменной, которая располагалась следом за массивом array в примере выше, окажется искаженным. Отладка подобного рода ошибки может оказаться не простым делом.
В языке Java программист защищен от подобного рода труднодиагностируемых ошибок. При попытке выйти за границы массива возбуждается исключение ArrayIndexOutOfBoundsException. Если не был запрограммирован перехват исключения с помощью конструкции try-catch, программа аварийно завершается, а в стандартный поток ошибок отправляется соответствующее сообщение с указанием файла с исходным кодом и номера строки, где произошел выход за границы массива. То есть диагностика подобных ошибок становится тривиальным делом.
Такое поведение Java-программы стало возможным благодаря тому, что массив в Java представлен объектом. Массив Java не может менять размер, его размер жестко задается в момент выделения памяти. Во время выполнения же получить размер массива проще простого:
```
int[] array = new int[10];
int arraySize = array.length; // 10
```
Если говорить о многомерных массивах, то по сравнению с языком C в Java открывается интересная возможность организовать «лестничные» массивы. Для случая двумерного массива размер каждой отдельной строки может отличаться от остальных:
```
int[][] array = new int[10][];
for (int i = 0; i < array.length; i++) {
array[i] = new int[i + 1];
}
```
Как и в C, элементы массива располагаются в памяти один за другим, поэтому доступ к массиву считается самым эффективным. Если же требуются выполнять операции вставки/удаления элементов, или создавать более сложные структуры данных, то необходимо использовать коллекции, такие как множество (Set), список (List), карта (Map).
За отсутствием указателей и невозможностью инкрементировать ссылки доступ к элементам массива возможен с помощью индексов.
Коллекции
---------
Зачастую функциональности массивов оказывается недостаточно – тогда необходимо использовать динамические структуры данных. Так как стандартная библиотека C не содержит готовой реализации динамических структур данных, то приходится пользоваться реализацией в исходных кодах или в виде библиотек.
В отличии от C, стандартная библиотека Java содержит богатый набор реализаций динамических структур данных или коллекций, выражаясь терминами Java. Все коллекции делятся на 3 больших класса: списки, множества и карты.
Списки – динамические массивы – позволяют добавлять/удалять элементы. Множества не обеспечивают порядка добавленных элементов, но гарантируют отсутствие дубликатов элементов. Карты или ассоциативные массивы оперируют парами «ключ – значение», причем значение ключа уникально – в карте не может быть 2 пары с одинаковыми ключами.
Для списков, множеств и карт существует множество реализаций, каждая из которых оптимизирована для определенной операции. Например, списки реализованы классами ArrayList и LinkedList, причем ArrayList обеспечивает лучшую производительность при доступе к произвольному элементу, а LinkedList – более эффективен при вставке/удалении элементов в середину списка.
В коллекциях могут храниться только полноценные Java-объекты (фактически – ссылки на объекты), поэтому создать непосредственно коллекцию примитивов (int, char, byte и др.) нельзя. В этом случае следует использовать соответствующие классы-«обертки»:
| Примитив | Класс-«обертка» |
| --- | --- |
| byte | Byte |
| short | Short |
| char | Character |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
К счастью, программируя на Java, нет необходимости следить за точным совпадением примитивного типа и его «обертки». Если метод получает аргумент, например, типа Integer, то ему можно передавать тип int. И наоборот, где требуется тип int, смело можно использовать Integer. Это стало возможным благодаря наличию в Java встроенного механизма упаковки/распаковки примитивов.
Из неприятных моментов следует упомянуть, что стандартная библиотека Java содержит старые классы коллекций, которые были неудачно реализованы в первых версиях Java и которые не следует использовать в новых программах. Речь идет о классах Enumeration, Vector, Stack, Dictionary, Hashtable, Properties.
Обобщения
---------
Коллекции обычно используют как обобщенные типы данных. Суть обобщений в этом случае заключается в том, что мы задаем основной тип коллекции, например, ArrayList, а в угловых скобках указываем тип-параметр, который в данном случае определяет тип хранимых в списке элементов:
```
List list = new ArrayList();
```
Это позволяет компилятору отследить попытку добавления в такой список объекта иного типа, нежели указанный тип-параметр:
```
List list = new ArrayList();
// ОШИБКА КОМПИЛЯЦИИ!
list.add("First");
```
Очень важно, что во время выполнения программы тип-параметр стирается, и нет никакой разницы между, например, объектом класса
```
ArrayList
```
и объектом класса
```
ArrayList.
```
Как следствие нет возможности узнать тип элементов коллекции во время выполнения программы:
```
public boolean containsInteger(List list) {
// ОШИБКА КОМПИЛЯЦИИ!
if (list instanceof List) {
return true;
}
return false;
}
```
Частичным решением может быть следующий подход: брать первый элемент коллекции и определять его тип:
```
public boolean containsInteger(List list) {
if (!list.isEmpty() && list.get(0) instanceof Integer) {
return true;
}
return false;
}
```
Но такой подход не сработает, если список пуст.
В этом плане обобщения Java значительно уступают обобщениям C++. Обобщения Java фактически служат для «отсечения» части потенциальных ошибок на стадии компиляции.
Перебор всех элементов массива или коллекции
--------------------------------------------
Программируя на С часто приходится перебирать все элементы массива:
```
for (int i = 0; i < SIZE; i++) {
/* ... */
}
```
Ошибиться здесь проще простого, достаточно указать неверный размер массива SIZE или поставить «<=» вместо «<».
В Java помимо «обычной» формы оператора for существует форма для перебора всех элементов массива или коллекции (в других языках часто называемая foreach):
```
List list = new ArrayList<>();
// ...
for (Integer i : list) {
// ...
}
```
Здесь мы гарантировано переберем все элементы списка, исключены ошибки, присущие «обычной» форме оператора for.
Коллекции разнородных элементов
-------------------------------
Так как все объекты наследуются от коренного Object, то в Java есть интересная возможность создавать списки с различными фактическими типами элементов:
```
List list = new ArrayList<>();
list.add(new String("First"));
list.add(new Integer(2));
list.add(new Double(3.0));
Узнать фактический тип элементов списка можно используя оператор instanceof:
for (Object o : list) {
if (o instanceof String) {
// ...
} else if (o instanceof Integer) {
// ...
} else if (o instanceof Double) {
// ...
}
}
```
Перечисления
------------
Сравнивая C/C++ и Java невозможно не заметить, насколько функциональнее в Java реализованы перечисления. Здесь перечисление – это полноценный класс, а элементы перечисления – объекты этого класса. Это позволяет одному элементу перечисления задать в соответствие несколько полей любого типа:
```
enum Colors {
// Объявление каждого элемента перечисления - это вызов конструктора.
RED ((byte)0xFF, (byte)0x00, (byte)0x00),
GREEN ((byte)0x00, (byte)0xFF, (byte)0x00),
BLUE ((byte)0x00, (byte)0x00, (byte)0xFF),
WHITE ((byte)0xFF, (byte)0xFF, (byte)0xFF),
BLACK ((byte)0x00, (byte)0x00, (byte)0x00);
// Поля перечисления.
private byte r, g, b;
// Приватный конструктор.
private Colors(byte r, byte g, byte b) {
this.r = r;
this.g = g;
this.b = b;
}
// Метод перечисления.
public double getLuma() {
return 0.2126 * r + 0.7152 * g + 0.0722 * b;
}
}
```
Как полноценный класс перечисление может иметь методы, а с помощью приватного конструктора можно задавать значения полей отдельных элементов перечисления.
Штатно присутствует возможность получить строковое представление элемента перечисления, порядковый номер, а также массив всех элементов:
```
Colors color = Colors.BLACK;
String str = color.toString(); // "BLACK"
int i = color.ordinal(); // 4
Colors[] array = Colors.values(); // [RED, GREEN, BLUE, WHITE, BLACK]
```
И наоборот – по строковому представлению можно получить элемент перечисления, а также вызывать его методы:
```
Colors red = Colors.valueOf("RED"); // Colors.RED
Double redLuma = red.getLuma(); // 0.2126 * 255
```
Естественно перечисления можно использовать в конструкциях switch-case.
Выводы
------
Безусловно, языки C и Java предназначены для решения совершенно разных задач. Но, если все-таки сравнить процесс разработки ПО на этих двух языках, то, по субъективным впечатлениям автора, язык Java значительно превосходит C по удобству и скорости написания программ. Немалую роль в обеспечении удобства играет среда разработки (IDE). Автор работал с IDE IntelliJ IDEA. Программируя на Java, не приходится постоянно «бояться» допустить ошибку – зачастую среда разработки подскажет, что надо исправить, а иногда сделает это за вас. Если же возникла ошибка времени выполнения, то в логе всегда указан тип ошибки и место ее возникновения в исходном коде – борьба с такими ошибками становится тривиальным делом. С-программисту для перехода на Java не надо прилагать нечеловеческих усилий, и все благодаря тому, что синтаксис языка изменился незначительно.
Если этот опыт будет интересен читателям, в следующей статье мы расскажем об опыте использования механизма JNI (запуск нативного C/C++-кода из Java-приложения). Механизм JNI незаменим, когда требуется управлять разрешением экрана, Bluetooth-модулем и в других случаях, когда возможностей сервисов и менеджеров Android оказывается недостаточно. | https://habr.com/ru/post/412775/ | null | ru | null |
# Менеджер паролей с GPG шифрованием: настройка PASS на iOS + Git
Наверняка многим из вас знакомы работы [Филиппа Циммерманна](https://www.philzimmermann.com/RU/background/index.html), а в частности, самая известная из них — PGP (*Pretty Good Privacy — Почти Полная Конфиденциальность*), опубликованная в далеком 1991 году. Изначально PGP как пакет программного обеспечения предназначался для шифрования электронной почты и до сегодняшнего момента алгоритм(ы) шифрования, заложенные в PGP еще не были взломаны.
[](https://habr.com/ru/company/ruvds/blog/566042/)
В этом году [PGP исполняется 30 лет](https://habr.com/ru/news/t/561842/) и в связи с этой знаменательной датой я с вашего позволения напишу свой опыт взаимодействия с PGP в качестве основы для менеджера паролей.
> **Небольшая ремарка:** *PGP был отжат корпоратами и стал проприетарным, а альтернативная версия с открытым исходным кодом стала носить имя [GnuPG](https://ru.wikipedia.org/wiki/GnuPG) (сокр. GPG). Далее в этой статье буду пользоваться аббревиатурой GPG.*
Предисловие
===========
Каждый из вас наверняка пользуется менеджером паролей, а если не пользуется, то точно слышал об этом.
**Если у вас нет менеджера паролей, то вы наверняка:**
* запомнили пару десятков паролей с изменяющейся структурой мастер-пароля и вам хватает
* количество сервисов и вариативности пароля не достигло предела :)
* не заботитесь об анонимности и приватности (не знаете, для чего это нужно)
* не знаете как выбрать из многообразия парольных менеджеров
У меня все эти проблемы были, и, количество сервисов, на которых я регистрировался, разрослось до более чем 357. Я Осознал — надо что-то менять…
Начал задумываться о категоризации всего этого хозяйства.
Пароли у меня хранились в памяти, в e-mail сообщениях в черновиках, на обрывках бумажек, отрывных блокнотиках, листках формата А4, сложенных вдвое, на флешках в файлах \*.txt и т.д.
#### ▍У меня было несколько требований:
* менеджер паролей должен быть OpenSource с внушительным Community
* поддерживать бесшовную синхронизацию и кроссплатформенность
* иметь возможность хранения всей базы паролей на своем сервере/локальном компьютере/флешке/диске
* возможность делать быстрый backup паролей
* сильное шифрование без бэкдоров
* возможность выбора алгоритма или связки алгоритмов шифрования
* легкая и понятная структура хранения паролей с категоризацией
▍Что такое PASS
---------------
[PASS](https://www.passwordstore.org/) — это небольшой bash-скрипт, созданный Джейсоном Доненфельдом, хранящий пароли в обычных текстовых файлах, зашифрованных с помощью GPG. Официальный сайт — [www.passwordstore.org](https://www.passwordstore.org/)
Может хранить в зашифрованном виде не только логины/пароли, но и любую текстовую информацию.
Шифрование всей информации производится с помощью GPG, запросы паролей осуществляет gpg-agent, за контроль версий и поддержку удаленного репозитория отвечает Git, а сама утилита написана на языке bash. Таким образом, у вас есть возможности, за которые можно не беспокоиться. На самом деле, если вы хотите, вы можете получить доступ к репозиторию Git и файлам Gnupg напрямую, вообще не используя PASS.
#### ▍Пререквизиты для GPG, PASS, Pass for iOS:
* PC с OS на ядре Linux
* смартфон с iOS с установленным [Pass for iOS](https://mssun.github.io/passforios/)
* прямые руки
На официальном сайте PASS [www.passwordstore.org](https://www.passwordstore.org/) есть множество клиентов под разные OS.
#### ▍Пререквизиты для Gitea:
* самый дешевый VPS или одноплатник
Для того, чтобы настроить и развернуть связку PASS и Git, я использовал **[Gitea](https://gitea.io/en-us/)** (свободный аналог github, gitlab).
Для разворачивания Gitea достаточно будет самых минимальных требований, например можно взять тариф [**Старт Хит**](https://ruvds.com/cheap_vps/) (240р/мес. на момент написания статьи) на [ruvds.com](http://ruvds.com/). К тому же у них есть услуга — 3 дня VPS на тест бесплатно. Можно развернуть Gitea на одноплатниках, хоть на ~~малинке~~ RaspberryPi (2,3,4 версий), хоть на ~~банане~~ Banana PI.
Подробно останавливаться в этой статье на установке Gitea не будем, есть подробнейшая документация со всевозможными способами установки:
*Документация Gitea — варианты установки*
Привязку Gitea к собственному домену, установку SSL-сертификата в этой статье рассматривать не буду. Укажу лишь отличный бесплатный вариант, который я использовал:
* бесплатные домены 2-го уровня [my.freenom.com](https://my.freenom.com)
* установка бесплатного ssl-сертификата Let’s Encrypt через certbot — [certbot.eff.org/lets-encrypt/debianstretch-nginx](https://certbot.eff.org/lets-encrypt/debianstretch-nginx)
> **Используемые данные Gitea в статье:**
>
> *Gitea установлен на [zil02.ml](https://zil02.ml)
>
> login: gitlog
>
> e-mail, указанный при создании gpg связки ключей: [email protected]*
▍Настройка, установка GPG (GnuPG):
----------------------------------
На странице со списком свободных OS можно выбрать приглянувшуюся —
[www.gnu.org/distros/free-distros.html#for-pc](https://www.gnu.org/distros/free-distros.html#for-pc) я установил Dragora как основную Linux систему. У вас это может быть любая OS на ядре Linux. Самая распространенная Ubuntu, но это не значит, что самая безопасная. В Ubuntu на уровне ядра есть проприетарные компоненты, которые противоречат философии свободного программного обеспечения.
Итак, открываем терминал. Обновим репозитории и установим gpg и gnupg:
```
sudo apt update && sudo apt upgrade -y
sudo apt install gpg
sudo apt install gnupg
```
Смотрим версию установленного GPG:
```
gpg --version
```
*У меня версия gpg (GnuPG) 2.2.12*
Для того чтобы посмотреть публичный и приватный ключи:
```
gpg -k #публичный ключ
gpg -K #приватный ключ
```
*Убеждаемся, что ключей нет*
Теперь давайте их создадим. Делается это командой:
```
gpg --full-generate-key
```
Выбираем — 1 (default)
Ставим максимальную длину — 4096
Не ограничиваем валидность ключа временем: ставим 0
*Подтверждаем свой выбор.*
*Вводим Имя, Фамилию, e-mail. Подтверждаем выбор.*
**Далее Вас спросят придумать мастер-пароль**
*Это главный пароль для доступа в Вашей связке ключей! Делайте его максимально сложным и запомните, запишите в надежном месте.*
*Введя легкий пароль, вы увидите сообщение:*
*Ваш ключ создался!*
▍Установим менеджер паролей PASS
--------------------------------
Установим PASS:
```
apt install -y pass
```
Посмотрим, где у нас лежит PASS (в /usr/bin/pass):
```
which pass
```
Проинициализируем хранилище паролей, всю связку ключей, созданных ранее с e-mail: [email protected]:
```
pass init [email protected]
```
Создалась директория /.password-store
В этой директории будет лежать скрытый файл .gpg-id в нем будет одна строчка с идентификатором ключа. Именно им и будут шифроваться все ваши пароли.
Попробуем добавить любую информацию в наш менеджер паролей PASS из консоли, для лучшего понимания!
PASS использует для хранения каждого пароля к сервису отдельный файл. Это очень удобно!
Например, добавим пароль на email:
```
pass insert Email/gmail.com
```
где Email — это папка, через ‘/’ gmail.com — текстовый файл с паролем.
Введем для примера пароль 1234
Создался зашифрованный бинарник gmail.com.gpg в директории /root/.password-store/Email
Для просмотра зашифрованного пароля вводим свой мастер-пароль от gpg ключа:
```
pass Email/gmail.com
```
*Проверим через редактор в WinCSP*
```
Бинарник имеет нечитаемый вид
в PASS есть возможность сохранять пароли в ASCII.
В настройках Pass for iOS это Settings-> Advanced
включить опцию "Encrypt in ASCII-Armored"
```
*Тогда зашифрованные данные примут человеческий вид*
#### ▍Настройка Gitea:
Теперь нам нужно настроить Git (Gitea) на локальной машине, берем user и email из настроек gitea выше:
```
git config --global user.name “gitlog”
git config --global user.email “[email protected]”
```
На всякий случай указываем правильный путь до gpg:
```
git config --global gpg.program gpg2
```
вместо “gpg2” у вас может быть просто “gpg”
И тестируем, подписываются ли наши сообщения:
```
echo “test” | gpg --clearsign
```
*Если сообщения не подписываются, и возникает ошибка “gpg: signing failed: Inappropriate ioctl for device”*
**Немного погуглив, исправляем так:**
Решение проблемы [ru.stackoverflow.com/questions/791317/gpg-signing-failed-inappropriate-ioctl-for-device](https://ru.stackoverflow.com/questions/791317/gpg-signing-failed-inappropriate-ioctl-for-device)
Добавить в ~/.gnupg/gpg.conf:
```
use-agent
pinentry-mode loopback
```
Добавить в ~/.gnupg/gpg-agent.conf:
```
allow-loopback-pinentry
```
Затем перезапуск:
```
echo RELOADAGENT | gpg-connect-agent
```
Справедливо для linux и osx.
*Отлично! Продолжаем:*
Добавляем первоначальный конфиг в /root/.gnupg/gpg.conf:
```
keyid-format 0xlong
throw-keyids
no-emit-version
no-comments
```
Теперь выбираем, каким ключом будут подписываться наши коммиты
проверяем:
```
gpg -k
```
возьмем rsa4096/0x4B0659102A08305B:
```
git config --global user.signingkey 0x4B0659102A08305B
git config --global commit.gpgsign true
```
Создадим git репозиторий
#### ▍Настроим связку PASS-Gitea на локальной машине
Инициализируем гит:
```
pass git init
```
Добавляем тот путь, который нам показал Gitea после установки Gitea (заменив дефолтный путь 127.0.0.1:22022 на имя домена):
```
pass git remote add origin https://zil02.ml/gitlog/habr_ruvds.git
```
Коммитим изменения. Для того чтобы закачать изменения, пользуемся стандартным методом.
```
cd .password-store/
git add .
git commit -m “123”
git push -u origin master
```
Если все сделали правильно, должно получиться следующее:
Открываем репозиторий:
**Ура! Все изменения из нашего православного менеджера паролей PASS синхронизировались с нашим Gitea.** (Все содержимое папки \* /.password-store)
#### ▍Установим Pass for iOS
Официальный сайт приложения — [mssun.github.io/passforios](https://mssun.github.io/passforios/)
Экспортнем public и secret ключ и перенесем на iPhone:
```
gpg --export -a 0x4B0659102A08305B > 8305Bpub.gpg
gpg --export-secret-keys -a 0x4B0659102A08305B > 8305Bsecret.gpg
```
**Пропишем настройки git репозитория:**
**Детальные скриншоты с настройками**
Обновим табу Passwords и увидим нашу папку Email с файлом gmail.com
**Поздравляю Вас, мы справились на Отлично!**
В этой пошаговой статье мы с Вами установили собственный git репозиторий, пакет GPG и менеджер паролей PASS на локальную систему (Linux) и на iPhone (Pass for iOS). Теперь мы можем создавать, изменять пароли с PC, айфона, синхронизировать изменения через git, использовать автозаполнение логинов-паролей на iPhone в браузерах для входа в различные онлайн сервисы.
Можем хранить любые данные помимо паролей.
Очень простой формат организации и хранения паролей дает нам достаточно широкие возможности:
* мы можем просматривать и редактировать пароли
* мы можем писать свои скрипты для работы с паролями
* мы можем хранить все изменения паролей в системе контроля версий git и синхронизировать пароли на разных компьютерах через неё же.
Менеджер паролей PASS имеет большую поддержку со стороны сообщества. Есть бесшовная синхронизация через git между экземплярами PASS на компе, ноутах, телефонах. Существуют реализации программы для Android и iOS, плагины для веб-браузеров Chrome и Firefox, графические клиенты для Windows, Mac и Linux, расширения для Alfred, dmenu, rofi и Emacs, скрипты для импорта паролей из других менеджеров паролей!
PASS покрывает возможность хранения всей базы паролей на своем сервере/локальном компьютере/флешке/диске.
Поддерживается возможность делать быстрый backup паролей. Вы вольны выбирать какой тип шифрования использовать для сокрытия ваших паролей и любой другой приватной информации!
Вы можете придумать и реализовать свою структуру хранения паролей с категоризацией!
В первую очередь этой статьей хотел вызвать интерес к открытому программному обеспечению и правильному хранению Вашей персональной информации! Хранить пароли в месте, защищенном от хитрого взора корпораций, считаю хорошей практикой!
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=halsoi&utm_content=menedzher_parolej_s_gpg_shifrovaniem:_nastrojka_pass_na_ios_+_git) | https://habr.com/ru/post/566042/ | null | ru | null |
# DeepPavlov: «Keras» для обработки естественного языка помогает отвечать на вопросы про COVID-2019
В такой области глубокого обучения, как обработка изображений, библиотека Keras играет ключевую роль, радикально упрощая обучение transfer learning и использование предварительно обученных моделей. В области обработки естественного языка (NLP) для решения достаточно сложных задач, таких как ответы на вопросы или классификация намерений, приходится комбинировать серию моделей. В этой статье мы расскажем, как библиотека [DeepPavlov](http://deeppavlov.ai/?utm_source=habr&utm_medium=article&utm_campaign=odqa_covid) упрощает построение цепочек моделей для NLP. На основе [DeepPavlov](http://deeppavlov.ai/?utm_source=habr&utm_medium=article&utm_campaign=odqa_covid) и с помощью [Azure ML](https://docs.microsoft.com/azure/machine-learning/?WT.mc_id=aiapril-blog-dmitryso) мы построим вопросно-ответную нейросеть, обученную на наборе данных COVID-19.
За последние пару лет мы стали свидетелями значительного прогресса во многих задачах, связанных с обработкой естественного языка, в основном благодаря новым архитектурам, таким как [трансформеры](https://medium.com/inside-machine-learning/what-is-a-transformer-d07dd1fbec04) и [BERT](https://towardsdatascience.com/bert-explained-state-of-the-art-language-model-for-nlp-f8b21a9b6270). BERT, например, может эффективно использоваться в задачах классификации текста, извлечения именованных сущностей, контекстного прогнозирования маскированных слов и ответов на вопросы.
Обучение модели BERT с нуля [очень ресурсоемко](https://medium.com/@ranko.mosic/googles-bert-nlp-5b2bb1236d78), поэтому большинство приложений используют предварительно обученные модели, применяют BERT в качестве извлекателей признаков или для более тонкого дообучения. Часто бывает так, что исходная задача обработки естественного языка, которую мы решаем, может быть разложена на **последовательность** из более простых шагов, один из которых — извлечение признаков, другой — токенизация, применение TF-IDF ранжирования к набору документов или (на последнем этапе) обычная классификация.
Эту последовательность можно рассматривать как **конвейер**, каждый этап в котором реализуется различными нейросетевыми моделями. Взяв за пример задачу классификации текста, мы можем выделить следующие этапы:
* препроцессор BERT, который извлекает признаки
* классификатор, который определяет класс документа
Эта серия шагов может быть объединена в одну нейронную архитектуру и обучена на наборе текстовых данных.
Библиотека DeepPavlov
---------------------
[DeepPavlov](http://deeppavlov.ai/?utm_source=habr&utm_medium=article&utm_campaign=odqa_covid) как раз позволяет строить и обучать такие конвейеры нейросетевых моделей. Её стоит использовать по ряду причин:
* поставляется с предварительно обученными моделями;
* позволяет декларативно описывать конвейер обработки текста как последовательность шагов, используя **config**-файлы;
* предоставляет ряд предопределенных конфигов, которые можно использовать для решения типовых задач;
* можно выполнять обучение конвейера и применять его посредством Python SDK или из интерфейса командной строки.
Библиотека поддерживает несколько способов взаимодействия с NLP моделями. Существует возможность запускать ее в режиме REST API или в качестве коннектора для [Microsoft Bot Framework](https://docs.microsoft.com/ru-ru/azure/bot-service/?view=azure-bot-service-4.0&WT.mc_id=aiapril-blog-dmitryso). В этой статье мы сосредоточимся на основной функциональности, которая делает библиотеку [DeepPavlov](http://deeppavlov.ai/?utm_source=habr&utm_medium=article&utm_campaign=odqa_covid) столь же полезной для обработки естественного языка, как Keras для обработки изображений.
Познакомиться с основной функциональностью DeepPavlov проще всего с помощью веб-демонстрации на [demo.deeppavlov.ai](https://demo.deeppavlov.ai).
BERT классификация с использованием DeepPavlov
----------------------------------------------
Вернемся к задаче классификации текста с использованием BERT. [DeepPavlov](https://github.com/deepmipt/DeepPavlov) содержит несколько предобученных конфигураций для этой задачи, например, [классификация настроений в Twitter](https://github.com/deepmipt/DeepPavlov/blob/master/deeppavlov/configs/classifiers/sentiment_twitter_bert_emb.json). В этом файле раздел `chainer` описывает конвейер, который состоит из следующих шагов:
* `simple_vocab` используется для преобразования ожидаемого вывода (`y`), который является именем класса, в числовой идентификатор (`y_ids`);
* `transformers_bert_preprocessor` принимает входной текст `x` и выдает набор данных для последующей сети BERT;
* `transformers_bert_embedder` создает BERT-эмбеддинги для входного текста
* `one_hotter` кодирует `y_ids` в *one-hot encoding*, необходимое для финального слоя классификатора;
* `keras_classification_model` — модель классификации, представляющая собой многослойную CNN с определенными параметрами;
* `proba2labels` — финальный слой, преобразующий выходные данные сети в соответствующую метку.
В конфигурации также определяются:
* в разделе `dataset_reader` — описание формата и пути к входным данным;
* в разделе `train` — параметры обучения;
* а также некоторый другие характеристики.
Определив конфигурацию, мы можем обучить соответствующий конвейер из командной строки следующим образом:
```
python -m deeppavlov install sentiment_twitter_bert_emb.json
python -m deeppavlov download sentiment_twitter_bert_emb.json
python -m deeppavlov train sentiment_twitter_bert_emb.json
```
Команда `install` устанавливает все необходимые зависимости (например, `Keras`, `transformers` и т.д.), `download` скачивает все необходимые файлы предварительно обученных моделей, а последняя строка непосредственно выполняет обучение.
Как только модель обучилась, мы можем взаимодействовать с ней с помощью командной строки:
```
python -m deeppavlov interact sentiment_twitter_bert_emb.json
```
Также можно использовать обученную модель с помощью Python SDK:
```
model = build_model(configs.classifiers.sentiment_twitter_bert_emb)
result = model(["This is input tweet that I want to analyze"])
```
Ответы на вопросы на открытом домене: ODQA
------------------------------------------
Одна из наиболее интересных задач, которую можно реализовать с помощью архитектуры BERT, называется **[Ответы на вопросы на открытом домене](https://en.wikipedia.org/wiki/Question_answering)** или, если коротко, ODQA (*Open Domain Question Answering*). ODQA в идеале должен давать конкретные ответы на общие вопросы по большому объему текстового материала, наподобие Wikipedia. Основная проблема связана с тем, что мы ссылаемся не на один-единственный документ, а на очень обширную область знаний. Сеть BERT же способна генерировать ответы по достаточно коротким документам.
Для решения этой проблемы, ODQA чаще всего работает в два этапа:
* сначала отдельная модель пытается найти наиболее подходящий к запросу документ из коллекции, т.е. решается **задача поиска**;
* затем найденный документ обрабатывается с помощью BERT-модели, чтобы получить конкретный ответ из него — решается задача **машинного понимания**.
Подробное руководство по реализации ODQA с помощью DeepPavlov [содержится в блоге](https://medium.com/deeppavlov/open-domain-question-answering-with-deeppavlov-c665d2ee4d65), однако для реализации второго этапа в описанном примере используется R-NET, а не BERT. Как мы увидим, это не даёт достаточно хороших результатов, поэтому в этой заметке мы опишем ODQA на основе BERT. В качестве "подопытного" датасета будем использовать [COVID-19 OpenResearch Dataset](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge/), который содержит более 52 000 научных статей по COVID-19. Это позволит нам построить нейросетевую модель, которая умеет отвечать на вопросы про коронавирус.
Получение данных с помощью Azure ML
-----------------------------------
Для обучения мы будем использовать [Azure Machine Learning](https://docs.microsoft.com/azure/machine-learning/?WT.mc_id=aiapril-blog-dmitryso), в частности имеющиеся в её составе [Notebooks](https://docs.microsoft.com/azure/machine-learning/tutorial-1st-experiment-sdk-setup/?WT.mc_id=aiapril-blog-dmitryso). Самый простой способ получить данные в AzureML — создать **Dataset**. Все доступные в исходном датасете данные по COVID-19 можно найти [на странице Semantic Scholar](https://pages.semanticscholar.org/coronavirus-research). Мы будем использовать некоммерческую выборку, расположенную [здесь](https://ai2-semanticscholar-cord-19.s3-us-west-2.amazonaws.com/latest/noncomm_use_subset.tar.gz) в виде упакованного набора JSON-документов.
Для начала определим *Azure ML Dataset*. Проще всего это сделать через [Azure ML Portal](http://ml.azure.com/?WT.mc_id=aiapril-blog-dmitryso), перейти в раздел **Datasets** и выбрать создание нового датасета **from web files**. В качестве типа выберем **file**, поскольку данные в нашем случае слабо структурированы. В случае файлов табличного формата мы могли бы выбрать **tabular**, и сразу получить табличное представление. В заключение создания датасета мы вводим URL, по которому набор находится в интернете.
[](https://habrastorage.org/webt/pn/bc/re/pnbcrenwq15v6dcnbxwwx4db0ik.png)
Файловый датасет, который мы определили, содержит в себе запакованные данные. Чтобы подготовить их к использованию, нам потребуется **notebook** и **compute**, на котором мы будем выполнять вычисления. Поскольку задача ODQA довольно затратна и требуется много памяти, мы сразу рекомендуем создать в Azure ML вычислительный узел на основе виртуальной машины типа **[NC12](https://docs.microsoft.com/azure/virtual-machines/nc-series/?WT.mc_id=aiapril-blog-dmitryso)** с 112 Гб оперативной памяти. Процесс создания вычислительного ресурса и ноутбука [описан здесь](https://docs.microsoft.com/azure/machine-learning/tutorial-1st-experiment-sdk-setup/?WT.mc_id=aiapril-blog-dmitryso).
Для доступа к датасету нам потребуется следующий код:
```
from azureml.core import Workspace, Dataset
workspace = Workspace.from_config()
dataset = Dataset.get_by_name(workspace, name='COVID-NC')
```
Датасет содержит один сжатый файл `.tar.gz`. Чтобы распаковать его, мы смонтируем датасет как каталог и выполним команду UNIX:
```
mnt_ctx = dataset.mount('data')
mnt_ctx.start()
!tar -xvzf ./data/noncomm_use_subset.tar.gz
mnt_ctx.stop()
```
Теперь все данные распакованы в наше текущее хранилище. Весь текст содержится в каталоге `noncomm_use_subset` в виде файлов`.json`, которые содержат абстракт и полный текст статьи в полях `abstract` и`body_text`. Чтобы извлечь только текст в отдельный файл, исполним следующий несложный Python-код:
```
from os.path import basename
def get_text(s):
return ' '.join([x['text'] for x in s])
os.makedirs('text',exist_ok=True)
for fn in glob.glob('noncomm_use_subset/pdf_json/*'):
with open(fn) as f:
x = json.load(f)
nfn = os.path.join('text',basename(fn).replace('.json','.txt'))
with open(nfn,'w') as f:
f.write(get_text(x['abstract']))
f.write(get_text(x['body_text']))
```
Теперь мы имеем каталог с именем `text`, содержащий все статьи в текстовом виде. Избавимся от оригинального каталога:
```
!rm -fr noncomm_use_subset
```
Настройка модели ODQA
---------------------
Прежде всего, давайте настроим предварительно обученную модель ODQA от [DeepPavlov](http://deeppavlov.ai/?utm_source=habr&utm_medium=article&utm_campaign=odqa_covid). Загрузим конфигурацию с именем `en_odqa_infer_wiki`:
```
import sys
!{sys.executable} -m pip --quiet install deeppavlov
!{sys.executable} -m deeppavlov install en_odqa_infer_wiki
!{sys.executable} -m deeppavlov download en_odqa_infer_wiki
```
Загрузка занимает довольно много времени. За это время вы поймете, как вам повезло, что вы используете облачные ресурсы, а не свой собственный компьютер. Загрузка в облако происходит намного быстрее!
Чтобы взаимодействовать с моделью, нам просто нужно построить модель из файла конфигурации и задать вопрос:
```
from deeppavlov import configs
from deeppavlov.core.commands.infer import build_model
odqa = build_model(configs.odqa.en_odqa_infer_wiki)
answers = odqa([ "Where did guinea pigs originate?",
"When did the Lynmouth floods happen?" ])
```
В ответ мы получим:
```
['Andes of South America', '1804']
```
В данном случае мы используем модель, обученную на тексте Wikipedia. Поэтому мы можем задавать достаточно общие вопросы, и можем попробовать спросить о коронавирусе:
* What is coronavirus? — *a strain of a particular virus*
* What is COVID-19? — *nest on roofs or in church towers*
* Where did COVID-19 originate? — *northern coast of Appat*
* When was the last pandemic? — *1968*
Конечно, далеко от идеала… Эти ответы взяты из старого текста Википедии, на котором обучалась исходная модель, поэтому она ничего не знает про текущую эпидемию. Теперь наша задача — переучить модель на наших собственных данных.
Обучение модели на собственных данных
-------------------------------------
Нам необходимо обучить ранжирующую модель (**ranker**), чтобы она генерировала ссылки на правильные документы. Процесс обучения на собственных данных описан в [блоге DeepPavlov](https://medium.com/deeppavlov/open-domain-question-answering-with-deeppavlov-c665d2ee4d65). Поскольку модель ODQA использует модель `en_ranker_tfidf_wiki`, мы можем загрузить ее конфигурацию отдельно и заменить путь`data_path`, который указывает на путь, где находятся файлы данных модели:
```
from deeppavlov.core.common.file import read_json
model_config = read_json(configs.doc_retrieval.en_ranker_tfidf_wiki)
model_config["dataset_reader"]["data_path"] = os.path.join(os.getcwd(),"text")
model_config["dataset_reader"]["dataset_format"] = "txt"
model_config["train"]["batch_size"] = 1000
```
Мы также уменьшаем размер батча, иначе процесс обучения не поместится в памяти.
Теперь обучим модель и посмотрим, как она работает:
```
doc_retrieval = train_model(model_config)
doc_retrieval(['hydroxychloroquine'])
```
Эта команда позволяет получить полный список файлов, которые имеют отношение к указанному ключевому слову.
Теперь запустим актуальную модель ODQA и посмотрим, как она работает:
```
# Download all the SQuAD models
squad = build_model(configs.squad.multi_squad_noans_infer, download = True)
# Do not download the ODQA models, we've just trained it
odqa = build_model(configs.odqa.en_odqa_infer_wiki, download = False)
odqa(["what is coronavirus?","is hydroxychloroquine suitable?"])
```
В ответ мы получим:
```
['an imperfect gold standard for identifying King County influenza admissions',
'viral hepatitis']
```
Все еще не идеально…
Использование BERT для Q&A
--------------------------
DeepPavlov [имеет две предобученные модели для ответов на вопросы](http://docs.deeppavlov.ai/en/master/features/models/squad.html), обученные на [Stanford Question AnsweringDataset](https://rajpurkar.github.io/SQuAD-explorer/) (SQuAD): [R-NET](https://www.microsoft.com/en-us/research/publication/mcr/) и BERT. В предыдущем примере использовалась модель с R-NET. Теперь мы переключим ее на BERT. Конфигурация `squad_bert_infer` является хорошей отправной точкой для построения вопрос-ответной модели на основе BERT:
```
!{sys.executable} -m deeppavlov install squad_bert_infer
bsquad = build_model(configs.squad.squad_bert_infer, download = True)
```
Если посмотреть на файл [конфигурации ODQA](https://github.com/deepmipt/DeepPavlov/blob/master/deeppavlov/configs/odqa/en_odqa_infer_wiki.json), то следующая его часть отвечает за ответы на вопросы:
```
{
"class_name": "logit_ranker",
"squad_model":
{"config_path": ".../multi_squad_noans_infer.json"},
"in": ["chunks","questions"],
"out": ["best_answer","best_answer_score"]
}
```
Изначально используется модель, задаваемая конфигурационным файлом `multi_squad_noans_infer`. Чтобы изменить механизм ответа на вопрос в модели ODQA, необходимо просто заменить поле `squad_model` в конфигурации на `squad_bert_infer`:
```
odqa_config = read_json(configs.odqa.en_odqa_infer_wiki)
odqa_config['chainer']['pipe'][-1]['squad_model']['config_path'] =
'{CONFIGS_PATH}/squad/squad_bert_infer.json'
```
Теперь попробуем взаимодействовать с моделью точно так же, как делали раньше:
```
odqa = build_model(odqa_config, download = False)
odqa(["what is coronavirus?",
"is hydroxychloroquine suitable?",
"which drugs should be used?"])
```
Ниже приведены некоторые вопросы и ответы, полученные с помощью обновленной модели:
| Вопрос | Ответ |
| --- | --- |
| what is coronavirus? | respiratory tract infection |
| is hydroxychloroquine suitable? | well tolerated |
| which drugs should be used? | antibiotics, lactulose, probiotics |
| what is incubation period? | 3-5 days |
| is patient infectious during incubation period? | MERS is not contagious |
| how to contaminate virus? | helper-cell-based rescue system cells |
| what is coronavirus type? | enveloped single stranded RNA viruses |
| what are covid symptoms? | insomnia, poor appetite, fatigue, and attention deficit |
| what is reproductive number? | 5.2 |
| what is the lethality? | 10% |
| where did covid-19 originate? | uveal melanocytes |
| is antibiotics therapy effective? | less effective |
| what are effective drugs? | M2, neuraminidase, polymerase, attachment and signal-transduction inhibitors |
| what is effective against covid? | Neuraminidase inhibitors |
| is covid similar to sars? | All coronaviruses share a very similar organization in their functional and structural genes |
| what is covid similar to? | thrombogenesis |
Заключение
----------
В этом посте мы описали, как использовать Azure Machine Learning вместе с NLP библиотекой [DeepPavlov](http://deeppavlov.ai/?utm_source=habr&utm_medium=article&utm_campaign=odqa_covid) для создания вопросно-ответной системы. [DeepPavlov](http://deeppavlov.ai/?utm_source=habr&utm_medium=article&utm_campaign=odqa_covid) можно использовать аналогичным образом для выполнения других задач на описанном датасете, например, для [извлечения именованных сущностей](http://docs.deeppavlov.ai/en/master/features/models/ner.html), разбвки статьи на тематические блоки или для умной индексации статей. Мы рекомендуем ознакомиться с [соревнованием COVID на Kaggle](https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge/) и посмотреть, сможете ли вы придумать оригинальную идею, которую можно реализовать с помощью [DeepPavlov](http://deeppavlov.ai/?utm_source=habr&utm_medium=article&utm_campaign=odqa_covid) и Azure Machine Learning. И не забывайте, что у DeepPavlov есть [форум](http://forum.deeppavlov.ai) – задавайте свои вопросы относительно библиотеки и моделей.
Azure ML и библиотека [DeepPavlov](http://deeppavlov.ai/?utm_source=habr&utm_medium=article&utm_campaign=odqa_covid) помогли выполнить описанный эксперимент всего за несколько часов. Взяв этот пример за основу, вы сможете достигнуть существенно лучших результатов. Попробуйте и поделитесь своими идеями с сообществом. Data Science может делать удивительные вещи, тем более, когда над задачей работает не один человек, а целое сообщество! | https://habr.com/ru/post/501782/ | null | ru | null |
# Android и кастомные шрифты или «Да здравствует API 26»
С приходом API 26 наконец-то закончилось время, когда мы были вынуждены извращаться и писать кастомные View когда дизайнер хотел использовать что-то помимо Roboto.
### Как было раньше. Краткий обзор
Если было много view где требовались нестандартные шрифты, то мы использовали что-то вроде такого:
#### view.xml
```
```
#### CustomFontTextView.class
```
Typeface myCustomFontBold = Typeface.createFromAsset(getAssets(), "fonts/myCustomFont-Bold.otf");
setTypeface(myCustomFontBold);
```
И это я пропустил огромный кусок который отвечает за то, чтобы не писать каждый раз путь к шрифту, а указывать
```
app:my_typeface="myCustomFontBold"
```
Ну, или шли на гитхаб и в результате находили [Calligraphy](https://github.com/chrisjenx/Calligraphy) (7000 звезд!)
Ни для кого не секрет что этот подход содержал много минусов как в огромном количестве boilerplate кода, так и в том, чтобы сделать это эффективно и где-нибудь не утечь по памяти запрашивая каждый раз Typeface.
Но все изменилось в API 26
--------------------------
Похоже, гугл наконец-то сдался и решил отказаться от навязывания Roboto и сделал удобное подключение сторонних шрифтов, за что ему огромное спасибо.
[Линк](https://developer.android.com/guide/topics/ui/look-and-feel/fonts-in-xml.html) для тех, кто любит читать в оригинале.
Теперь подключение состоит всего из нескольких несложных шагов:
1. Создаем папку **font** в **res**
Resource type выбираем **font**
2. Перетаскиваем в новую папку все нужные нам в проекте шрифты
3. Создаем файл для семейства шрифтов.
```
xml version="1.0" encoding="utf-8"?
```
Обратите внимание: я сразу добавил в пример то как должен выглядеть файл, если вы хотите поддерживать и более старые версии Андроида. (Начиная с 14). Если вам повезло и у вас таргет только на супер-новые девайсы, то ваш файл сократится в 2 раза
**Вариант для API >= 26****lobster.xml**
```
xml version="1.0" encoding="utf-8"?
```
Ну а дальше остается только наслаждаться сборкой
**Использование в TextView**
**Используем в стилях**
```
<item name="android:fontFamily">@font/lobster</item>
```
И у вас больше не болит голова об эффективности :) | https://habr.com/ru/post/341218/ | null | ru | null |
# Установка VMware ESXi 4.1 без KVM на примере hetzner.de
Как можно понять из заголовка, есть сервер Hetzner.de, а именно модель EQ4, 8 гигов памяти, заказчику надо развернуть на этом хосте ровно 3 виртуальние машины, 2 линукса и 1 виндовс, так как по сути 3 эти хоста не будут мега нагружены, то конфигурация в самый раз. На Hetzner.de присутствует возможность установки VMware ESXi 4.1, о чем они собственно и не скрывают (и не афишируют впрочем тоже ), просто при заказе сервера надо указать это, и к вашему счету вежливо добавят +45 евро, 24 за сетевую карту Intel, и еще 21 за KVM.
Данная инструкция не завязана на Hetzner.de, но реализована на его примере.
Мы заказали сетевую и все как положено, даже рейд железный, только так получилось что сервер нам подняли, а вот KVM не подключили, то ли конец рабочего дня был, то ли кто-то жестко ступил, не суть важно, но на руках у меня оказался вполне себе рабочий сервер (правда инициализировать рейд тоже забыли).
#### А тем временем
Спать совсем не хотелось, и я решил поколупать esxi на тему разных способов установки, как оказалось вариантов достаточно: * с диска
* с флешки
* с помощью PXE
Досадно только что ни один вариант для «белых» людей мне не подошел, впрочем полезное из этой микро разведки я тоже почерпнул.
Инсталятор ESXi основан на anaconda от RedHat и поддерживает kickstart, что в свою очередь дает возможность устанавливать гипервизор в unattended режиме и все это прекрасно работает для всех вышеперечисленных типов установки, помимо этого можно еще и нехило кастомизировать установочный образ, добавив в него, например поддержку железа, которое оригинальным установочным образом считается unsupported, ну и так по мелочи кой что еще добавить(ssh, ftp). И для всех этих манипуляций хорошие люди написали скрипт, скачать который можно [здесь](http://code.google.com/p/mkesxiaio/), а подробно почитать о нем [здесь](http://www.vm-help.com/forum/viewtopic.php?f=14&t=4). По последней ссылки Вы попадете на форум где просто много инфы по этому самому «моддингу».
Этот чудо скрипт ориентирован на debian-based системы (но работает и на других), посему недолго думая, я накатал на свежий сервер пятый Debian (забегая наперед скажу что раздел /boot я сделал размером 1ГБ). После установки, скачал скрипт, и оригинальный установочный образ, почитав доки как им пользоваться я остановился на варианте создания кастомного iso образа (почему iso я раскажу потом).
Целью было создать образ который молча установит гипервизор, попутно настроив сеть, установив рут пароль, хостнейм и также молча уйдет в ребут.
*Все операции я проводил под рутом и в его же домашней директории (да простят меня гуру)*
##### Создание кастомного установочного образа
для того что б включить ssh и ftp, я пошел [сюда](http://www.vm-help.com/esx40i/customize_oem_tgz.php), и скачал архив кастомизации (по названию угадаете какой, там же есть и много других кастомизаций) в /root, также после первого запуска скрипта, он создал каталог (/root/custom-esx и еще несколько других, впрочем как показала практика скрипт потом уберет за собой оставив только 2 директории /root/custom-esx и /root/save в который он бережно положит новый образ )
Первым делом я cоздал файл kickstart
ks.cfg с содержимым:
`vmaccepteula
rootpw mysupersecretpass
autopart --firstdisk --overwritevmfs
install url example.com/vm
network --bootproto=static --ip=192.0.2.4 --gateway=192.0.2.1 --hostname=esxi.example.com --device=vmnic0 --nameserver=192.0.2.98 --netmask=255.255.255.192
reboot`
И сохранил его в /root/custom-esx/etc/vmware/weasel/ks.cfg
[example.com/vm](http://example.com/vm) — внешний адрес по которому можно будет найти распакованный образ, почему не самого образа ставить спросите вы? Все просто — установка будет происходить мягко говоря странным образом (об этом потом)
Также я изменил конфиг загрузчика (оригинал можно найти в корне установочного образа под именем isolinux.cfg)
isolinux.cfg содержит:
`default menu.c32
menu title VMware VMvisor Boot Menu
timeout 5
label Kickstart debug
menu label ^ESXi Installer (default KS)
kernel mboot.c32
append vmkboot.gz ks=file:///etc/vmware/weasel/ks.cfg --- vmkernel.gz --- sys.vgz --- cim.vgz --- ienviron.vgz --- install.vgz --- oem.tgz`
Вот все нужные файлы подготовлены, теперь запускаем скрипт.
Выбираем:
1) ISO installation
дальше
[3] 4.1
И отвечаем на вопросы, когда дойдет до вопроса о редактировании proftpd.conf.
Открываем еще одну консоль и копируем isolinux.cfg в /root/esx-build с заменой оригинала, возвращаемся в первую консоль и продолжаем отвечать на вопросы, скрипт ругнется на отсутствие 2 файлов, просто пропустите их, это не критично. Ждем пока создастся образ.
Он будет в /root/save
С образом закончили, думаю не стоит напоминать что его надо будет распаковать на внешнем хосте, что б фалы были доступны по адресу [example.com/vm](http://example.com/vm)
##### Теперь собственно как это установить
Будем использовать GRUB, но так как груб не умеет грузить из iso образа, то понадобиться [дополнительная утилита](http://syslinux.zytor.com/wiki/index.php/MEMDISK)
надо её сохранить в /boot
Также подредактируем /boot/grub/menu.lst
Добавим секцию:
`title ESXi Installation from ISO
root (hd0,0)
kernel /boot/memdisk iso raw
initrd /boot/esxiсustom.iso`
**значение root зависит от разметки диска на вашем сервере**
изменяем параметр default на 1
копируем iso из /root/save/ в /boot/esxiсustom.iso
Ребутаем сервер:
*(пьем кофе/чай, курим, танцуем с бубном)*
Нужное подчеркнуть.
В качестве индикатора можно запустить пинг в другой консоли, после двух обрывов пинга можно коннектиться к свежему ESXi по ssh или через vSphere Client (только под винду).
Вот вобщем-то и все, строго не судите.
Комментарии приветствуются.
Надеюсь кому то пригодится.
Как видите iso монтируется через внешнюю приблуду, а инсталлятор круто умный, и не найдя физического диска ставить ничего не будет, так что приходиться подключать в эту эпопею внешний веб-сервер.
Так же была идея смухлевать и заставить скрипт поставить все на жесткий вместо юзб флеш карты, но тут умным уже оказался скрипт который дотошно вычисляет юзб-устройства, а колупаться в тоннах баш-кода желания не было (скрипт достаточно большой).
##### Источники
[benincosa.org/blog/?p=171](http://benincosa.org/blog/?p=171)
[blog.nettraptor.net/?p=26](http://blog.nettraptor.net/?p=26)
[www.vm-help.com](http://www.vm-help.com/)
**UPD1:**
В случае хетзнера, вам надо будет попросить для дополнительных ip адресов назначить MAC адреса с пометкой что это для vmware esxi, в этом случае вам удастся избежать гемора бриджингом и прочими фишками, если же вы закажете целую подсеть, то будьте готовы потратить 2 адреса (1 доп и один из подсети) для виртуального роутера
**UPD2:**
Выражаю огромную благодарность:
[thelostreason](https://habrahabr.ru/users/thelostreason/) [BigD](https://habrahabr.ru/users/bigd/) [helios](https://habrahabr.ru/users/helios/) [deniskin](https://habrahabr.ru/users/deniskin/) а также модераторам,
за поиск и устранение ошибок в форматировании, грамматике и пунктуации | https://habr.com/ru/post/109204/ | null | ru | null |
# Отладка в C++ геометрии и топологии
Генерация 3д объекта - как правило, многоэтапный процесс (например в булевых операциях сначала поиск графа пересечений, нахождение геометрии кривых пересечения и построение топологии результирующего тела). Закономерно возникает сложность с его отладкой. Положим при генерации что-то пошло не так и имеем наполовину готовый объект, который не может быть визуализирован разрабатываемой CAD системой. Что делать? Как локализовать место и момент ошибки? Анализировать глазами тысячи xyz координат промежуточных результатов и вспомогательных объектов на момент выдачи исключения? Или хуже, если отклонения желаемого результата от фактического незначительные, тогда и все числа внешне будут корректны. Работая С++ программистом в области 3Д моделирования и построения различных CAD/САПР систем, я регулярно сталкивался с проблемой визуализации вспомогательных/промежуточных сущностей.
Сформировал себе универсальный инструментарий [DumpSTL](https://github.com/KupchishinAB/DumpSTL), позволяющий с минимальными усилиями, в любом C++ проекте дампить в .stl файлы любые внутренние объекты в проекте.
Почему именно .stl? Так уж исторически сложилось. Много использовал чпу фрезера и 3д принтера, где основным и простейшим форматом моделей является .stl.
Суть использования сводится к однократной адаптации инструмента под структуры данных конкретного проекта, затем:
1) подключить один DumpSTL.h;
2) вызвать к необходимым данным метод `DUMP::save(...)`;
3) получить на выходе множество файлов с 3д моделями, которые можно открыть в любом 3д редакторе.
### Примеры использования
*Пример 1:* По ходу генерации 3д модели музыкального инструмента - флейты Пана
3д модель панфлейтыиспользуются аналитические функции для проецирования точек по определенным правилам, rоторые могут быть визуализированы поверхностями для лучшего понимания областей определения и итоговой геометрии.
Визуализация вспомогательных поверхностей*Пример 2:* Визуализация формы математических функций – сплайнов, по которым натягиваются некая внутренняя поверхность и формируется геометрия входного отверстия (это не просто круг и цилиндр, постарался показать синим и красным гипертрофированный изгиб).
Использование сплайновых кривыхПолучаемые при этом графики функций сплайнов в плоскости XY:
Кривые - сплайны в плоскости XY*Пример 3:* Обозначение ориентации кривых в пространстве, что бы понять где начало, а где конец.
Отображение ориентации UV поверхности### Адаптация под проект / геометрическое ядро
Покажу на примере библиотеки [MeshLib](https://github.com/MeshInspector/MeshLib).
1) Указать путь к папке, куда будут дампиться .stl файлы в глобальной переменной.`std::string_view folderSTL = "C:\\Repos\\STL\\"`
2) Подключить include в DumpSTL.h с необходимыми структурами, в данном примере это положим `MR::Mesh` (полная сетка 3д тело), `MR::FaceBitSet` (подмножество треугольников сетки).
3) Написать функции преобразования в `DUMP::Model3D` для каждого такого пользовательского типа (аргумент может быть не один):
а) `Model3D convert(const MR::Mesh&, const MR::FaceBitSet& );`
б) `Model3D convert(const MR::Mesh& );`
4) По необходимости написать преобразования пользовательских типов в множество точек `const std::vector& points`, которые могут быть использованы для дампа с особыми модификациями:
a) `Model3D direction(const std::vector& points)` – порождает по упорядоченному множеству точек ориентированную цепочку конусов (пирамидок);
б) `Model3D line(const std::vector& points)` – порождает по упорядоченному множеству точек отрезки;
в) `Model3D sphere(const std::vector& points)` – порождает по множеству точек низкополигональные сферы.
#### Пример реализации convert методов
`DUMP::Point3f convert( const MR::Vector3f& point )
{
return { point.x, point.y, point.z };
}`
`DUMP::Model3D convert( const MR::Mesh& mesh, const MR::FaceBitSet& faces)
{
DUMP::Model3D res;
for ( auto f : faces )
{
MR::Vector3f a, b, c;
if ( mesh.topology.hasFace( f ) )
{
mesh.getTriPoints( f, a, b, c );
res.addTriangle( convert(a), convert(b), convert(c));
}
}
return res;
}`
`DUMP::Model3D convert( const MR::Mesh& mesh )
{
return convert( mesh, mesh.topology.getValidFaces() );
}`
#### Как пользоваться
Применять методы ниже к стуктурам данным проекта и получать генерируемые 3д модели:
1) `void save(std::string_view fileName, Args... args)` – сохраняем один файл, где `fileName`– только название файла (нужная папка в `folderSTL`), `args`– передаем напрямую нужные нам объекты`save(“mesh”, my_mesh)`, `save(“mesh_part”, my_mesh, my_faceBitSet)`
2) `void saveInc(std::string_view fileName, Args... args)` – то же самое что и `save`, с той лишь разницей, что сохраняет всегда в новый файл. Если файл с указанным именем существует, приписывает цифру-счетчик еще не существующего файла. Так например если процесс итерационный, и на 135 итерации все взрывается, то есть возможность увидеть эволюцию 3д объекта во всех 135 итерациях, и увидеть, что было непосредственно перед падением приложения.
3) Использовать модификаторы `direction`/`line`/`sphere`: `save(“mesh”, direction(mesh))`, `save(“mesh_part”, direction(my_mesh, my_faceBitSet))`
4) Создовать напрямую объекты `Model3D`, используя напрямую его API `addTriangle`/`addPoint`/`addEdge`/`addCone`/`addQuad`/`addSphere` и дампить его так же `save(“model3D”, my_Model3D)`
#### Hello world
Пример использования и соответственно запускаемый "hello world" можно найти в соседнем проекте в репозитории [example](https://github.com/KupchishinAB/DumpSTL/tree/main/example). При запуске из коробки должны получаться следующие примитивы:
Кубик, тетраэдр, немного конусов, сферы...И вот такой набор файлов с 3д моделями: dumpStlExample\_cube.stl, dumpStlExample\_directionChain\_0.stl, dumpStlExample\_directionChain\_1.stl, dumpStlExample\_directionChain\_2.stl, dumpStlExample\_lineChain.stl, dumpStlExample\_points.stl, dumpStlExample\_spheres.stl, dumpStlExample\_tetraedr.stl
### Как устроена библиотека
1) Представляет из себя один подключаемый header only DumpSTL.h [репозиторий](https://github.com/KupchishinAB/DumpSTL)
а) В нем описаны тривиальные структуры `Point3`, `Triangle`, `Model3D` с сопутствующими методами
б) Функции для пользователя `save`, `saveInc` (incremental)
в) Модификаторы: `direction`, `sphere`, `line`
2) Проект под студию с примером использования и известным ожидаемым результатом example.sln
3) Скрипт clear\_stl.bat для автоматической чистки папки от накопившихся .stl файлов (их могут быть сотни)
4) Скрипт run\_blender.bat + blenderScrypt.py для автоматического открытия в 3д редакторе blender всех файлов в папке по маске \*.stl и фотографирования каждого с 4ех ракурсов и сохранением фото в эту же папку с припиской \_left.jpg, \_right.jpg, \_top.jpg, \_bottom.jpg. Может быть полезно при полуавтоматическом прогоне тестов и относительно быстрой проверки глазами, что ничего не попортилось путем быстрого пролистывания скриншотов. | https://habr.com/ru/post/683124/ | null | ru | null |
# Создаем свой сайт или блог на Ghost в образе Docker
Фишкой Ghost является то, что он использует на стороне бекенда сервер Node.js и язык JavaScript и дает альтернативный вариант для разработки.
В этом посте объясняется, как задеплоить свой личный блог на Ghost — движке с базой данных MariaDB с помощью docker.
В данном проекте мы будем использовать сервисы:
* [**Ghost**](https://ghost.org/) — платформу для блогинка на Node.js
* [**Nginx**](https://www.nginx.com/)**—**прокси сервер внешних запросов на внутренний порт блога
* [**MariaDB**](https://mariadb.org/) — реляционная БД с открытым исходным кодом
* [**Docker**](https://www.docker.com/) — контейнеризация сервисов
При развертке используется Docker и для этого нам нужен будет виртуальный сервер или личный ПК, на которых установлены Docker и Compose. Но подробно рассказывать я про это не буду, чтобы не утомлять и отходить от основной темы. Статья для тех, кто в курсе, что такое Docker и знает, как настроить Nginx, хотя, он не обязателен, если вам просто требуется запустить сайт локально.
### Настройка хоста
Перед тем, как переходить к рассмотрению кода, нам будет необходимо подготовить нашу систему, сервер или виртуальную машину на то, чтобы поднять образы и принимать внешние запросы. Я ж буду отталкиваться от того, что у меня Linux сервер на дистрибутиве **Ubuntu**. Для этого нам будет необходимо установить сервисы Docker, Compose, Nginx:
```
$ sudo apt install docker docker-compose nginx
```
Также, в дополнении, нам будет необходимо убедиться, что пользователь системы без полномочий **root** и что он находится в группе **docker**, чтобы иметь возможность запускать команды докера без проблем, хотя, все что нужно, работает и без этого, но на всякий случай:
```
$ sudo usermod username -aG docker
```
### Подготовка окружения
Для начала опишем все сервисы в файле **docker-compose.yml**
```
version: '3.3'
services:
mariadb:
container_name: project_mariadb
image: mariadb:${MARIADB_IMAGE_TAG}
environment:
MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
MYSQL_USER: ghost
MYSQL_PASSWORD: ${MYSQL_PASSWORD}
MYSQL_DATABASE: ghost_production
restart: always
volumes:
- type: bind
source: ${MYSQL_HOST_PATH}
target: /var/lib/mysql
ghost:
container_name: project_ghost
image: ghost:${GHOST_IMAGE_TAG}
ports:
- 8022:2368
environment:
url: ${BLOG_URL:-http://127.0.0.1}
database__client: mysql
database__connection__host: mariadb
database__connection__database: ghost_production
database__connection__user: ghost
database__connection__password: ${MYSQL_PASSWORD}
depends_on:
- mariadb
restart: always
volumes:
- type: bind
source: ${GHOST_HOST_PATH}
target: /var/lib/ghost/content
```
Исходя из выше описанного кода, видно, что мы используем 2 образа
* ghost
* mariadb
Ghost выведен наружу по порту **8022** и через вольюм пути исходного кода **source**, откуда он будет с хоста грузить себе в образ и выполнять.
Как видно, в файле используются переменные и они у нас выведены в файл окружения **.env**, чтобы иметь к ним отдельный доступ, в случае, если требуется использовать иные сервисы, да и легко это держать все настройки в отдельном файле. Выглядит он у нас так
```
# Тег для ghost образа
export GHOST_IMAGE_TAG=latest
# Тег для MariaDB образа
export MARIADB_IMAGE_TAG=latest
# Публичный url для блога ghost
export BLOG_URL=http://127.0.0.1:8022
# Root - пароль для MariaDB
export MYSQL_ROOT_PASSWORD=password
# User - пароль для ghost для соединения в БД
export MYSQL_PASSWORD=password
# Host - директории для образов, где будут храниться данные
export MYSQL_HOST_PATH=./mariadb
export GHOST_HOST_PATH=./www
```
Теперь, чтобы поднять контейнеры из образов, достаточно в корне, где файл docker-compose.yml запустит команду
```
$ docker-compose up -d
```
После чего наш сайт должен быть доступен по порту **localhost:8022**
Наш рабочий блог### Настройка Nginx
Локально наш сайт будет доступен по адресу **localhost:8022**, но чтобы он был доступен глобально, в случае, если у вас виртуальный сервер, к которому прикреплен домен, то придется все запросы перенаправлять с внешнего порта **80** или **443** на порт **8022**, для этого нам нужно описать данные моменты в конфигурационном файле сайта и добавить его в папку **/etc/nginx/sites-available/site.com.conf** и далее дать символьную ссылку данного файла в папку**/etc/nginx/sites-enabled**
```
$ ln -s /etc/nginx/sites-available/site.com.conf /etc/nginx/sites-enabled/site.com.conf
```
Данный файл, примерно, должен выглядеть следующим образом
```
server {
server_name site.com www.site.com;
error_log /var/www/site/logs/error.log;
access_log /var/www/site/logs/access.log;
location /{
proxy_pass http://localhost:8022;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host $host;
proxy_cache_bypass $http_upgrade;
}
}
```
Как видно, у нас, с внешнего порта 80 все запросы проксируются на порт нашего образа Ghost, тем самым, для внешних юзеров он выглядит как обычный сайт на привычном порту 80
После чего перезагружаем nginx
```
$ systemctl restart nginx
```
И после чего у нас должен быть доступен по домену site.com и на этом все. Исходный код лежит на [gist](https://gist.github.com/WebSofter/742f0a009ad61b7b4f2b8193b6e462e1).
Оригинальная статья также доступна у меня на [сайте](https://wsofter.ru/deploj-proekta-na-dvizhke-ghost-na-docker/). | https://habr.com/ru/post/567002/ | null | ru | null |
# Поговорим о Gmail: Как развивался популярный почтовый сервис
[](http://habrahabr.ru/company/pechkin/blog/275323/)
В нашем блоге на Хабре мы много пишем о [почтовых рассылках](https://pechkin-mail.ru/?utm_source=habr&utm_medium=referral&utm_campaign=gmail_history) и рассматриваем различные вопросы, связанные с их созданием. Мы уже писали о том, как делать [адаптивные письма](http://habrahabr.ru/company/pechkin/blog/263699/) в Gmail. Теперь же речь пойдет об истории этого популярного почтового сервиса.
По сравнению со своими конкурентами Gmail появился на рынке не так давно, но сразу стал очень популярен. Сегодня мы рассмотрим его отличительные качества, о которых [рассказал](https://www.quora.com/What-made-Gmail-unique-when-it-was-first-launched) один из инженеров компании.
Когда компания Google впервые запустила Gmail, объем его хранилища составлял всего 1 ГБ. Через год после запуска, 1 апреля 2005 года, он был увеличен вдвое. Джорджес Харик (Georges Harik), управляющий директор сервиса Gmail, пообещал «увеличивать этот объем до бесконечности».
24 апреля 2012 года Google анонсировала увеличение размеров почтового ящика с 7,5 ГБ до 10 ГБ в честь запуска Google Диск, отметив, что это далеко не предел.
13 мая 2013 года дисковые пространства Gmail, Google Диск и Google+ Фото были объединены, в результате чего пользователи получили 15 ГБ для бесплатного хранения файлов.
Кроме того, пользователи могут приобрести дополнительное пространство. В 2015 году бесплатный лимит в 15 Гб можно было увеличить до 30 ТБ за умеренную плату.
#### Лаборатория Gmail
Была запущена в работу 5 июня 2008 года. С её помощью пользователи могут тестировать новые функции в Gmail, такие как выделение важных писем или настройка «горячих клавиш». Более того, они могут выборочно включать и отключать различные опции, а также оставлять свои отзывы о каждой из них. Таким образом, разработчики Gmail определяют уровень популярности тех или иных функций и стараются усовершенствовать их. Некоторые полезные возможности, например «Отмена отправки письма», часто «выходят» из лаборатории Gmail и становятся постоянными.
Все функции в лаборатории Gmail являются экспериментальными и могут прекратить свое существование в любое время.
#### Вкладки во входящих письмах
В середине 2013 года в почтовом ящике Gmail появилась отключаемая функция, позволяющая распределять входящие письма по категориям. Есть 5 основных категорий, которые доступны и в мобильной версии Gmail.
#### Спам-фильтр
Система фильтрации спама в Gmail основана на анализе действий пользователей: вы помечаете определенное входящее письмо как спам, тем самым помогая системе распознать аналогичные письма для других пользователей. В настройках сервиса пользователи могут сами выбрать, как системе поступать со спамом.
Компания заверяет, что анализ содержания писем полностью автоматизирован и происходит без участия людей.
#### Gmail для мобильных устройств
Мобильная версия Gmail доступна более чем на 40 языках. Это бесплатный сервис, в котором многие функции оптимизированы для небольших экранов мобильных устройств. С 22 сентября 2009 года в Gmail поддерживается функция push-уведомлений на базе Google Sync для iPhone и iPod Touch.
#### Интеграция с социальными сетями
9 февраля 2010 года компания Google представила свой новый инструмент социальной сети под названием Google Buzz [в России – «Живая лента Google»], интегрированный с Gmail и позволяющий обмениваться ссылками, медиафайлами и статусами. Сервис был добавлен во все аккаунты автоматически, что вызвало волну недовольств пользователей, поэтому от идеи пришлось отказаться. Google Buzz прекратил работу 10 декабря 2011 года, а на смену ему пришел новый продукт – Google+. С января 2014 года в Gmail можно отправлять письма контактам из Google+ напрямую, без указания адреса электронной почты.
#### Телефонные звонки из Gmail
В августе 2010 года компания Google выпустила плагин для Google Talk, позволяющий звонить из Gmail на телефонные номера. С конца 2012 года пользователи Gmail могут бесплатно звонить на телефонные номера в США и Канаде, а также совершать международные звонки на платной основе. 26 августа 2010 года было зарегистрировано более миллиона звонков за сутки.
С помощью Google Voice пользователи из определённого списка стран могут бесплатно звонить на телефонные номера в США, Канаде и некоторых других странах. Видеоконференции и обмен документами в Google Voice в настоящее время интегрированы с Google Hangouts.
#### Поиск в Gmail
Функция поиска в Gmail позволяет не только искать информацию в Интернете, но и находить контакты, файлы на Google Диск, события в Google Календаре и информацию на Google Сайтах. 21 мая 2012 года в Gmail появилась функция автозавершения фраз при в вводе.
Как и поиск Google, Gmail не поддерживает поиск по подстроке, но применяет [стемминг](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BC%D0%BC%D0%B8%D0%BD%D0%B3), то есть распознает основу слова: например, по запросу «месяц» будут выданы результаты, содержащие слова «месяца», «месяцу» и т. д.
#### Язык
В октябре 2005 года в Gmail появилась возможность рукописного ввода текста на 75 языках. Помимо этого, сервис поддерживает транслитерацию и IME, а также имеет виртуальную клавиатуру.
5 августа 2014 года Gmail стал первым почтовым клиентом, в котором пользователи могут получать и отправлять тексты со знаками ударения в словах и буквами, не принадлежащими латинскому алфавиту.
#### Денежные переводы и платежи
На конференции Google I/O, состоявшейся 15 мая 2013 года, представители корпорации анонсировали функцию перевода денежных средств по электронной почте, интегрировав сервис Gmail с платежной системой Google Кошелек.
Позже компания дала разъяснения в блоге: «Теперь, благодаря интеграции Google Кошелька с Gmail, вы можете быстро и безопасно осуществлять денежные переводы друзьям и родным прямо из своего почтового ящика, даже если у них нет аккаунтов Gmail».
Корпорация также планировала начать выпуск собственных пластиковых карт, однако проект пришлось закрыть в связи с уходом главы подразделения Google Кошелек в начале мая 2013 года, а также по ряду других причин.
В ноябре 2013 года представители компании вновь заговорили о выпуске дебетовых карт для аккаунтов Google Кошелек в США (изначально речь шла о единой карте, которая могла бы объединить в себе все кредитные карты пользователя). Сайт Digital Trends описал новый продукт Google, как «обычную дебетовую карту для оплаты покупок через кошелек Google».
#### Безопасность
Изначально в Gmail использовалось незащищенное подключение, при котором шифровались только данные на странице входа в аккаунт. Однако, заменив URL «http://mail.google.com/mail/» на «https://mail.google.com/mail/» вручную, пользователи могли включить шифрование и снизить риск перехвата писем и контактов, которые передавались как текстовые данные JavaScript. В настоящее время защищенный протокол HTTPS используется по умолчанию, а доступ по протоколам POP3 и IMAP защищается криптографическими механизмами TLS.
Хотя почтовые клиенты, такие как Mozilla Thunderbird, используют протокол TLS для отправки почты, он не применяется при передаче сообщений Gmail на почтовые серверы целевого домена (если эта функция не поддерживается), поэтому на отдельных этапах доставки содержание письма может оказаться незашифрованным.
20 марта 2014 года компания Google объявила о повышении уровня безопасности Gmail. С того момента отправка и получение сообщений Gmail осуществляется по зашифрованному HTTPS-подключению, а «каждое отправленное или полученное письмо шифруется при передаче между внутренними серверами Google».
В 2007 году у Gmail возникли серьезные проблемы с безопасностью. Из-за размещения списков контактов на серверах Google и уязвимости главной страницы google.com информация в аккаунтах оказалась не защищена от XSS-атак. Уязвимость была устранена в скором времени после того, как информация о ней появилась в Интернете.
В Gmail спам фильтруется и автоматически удаляется через 30 дней, однако при желании эту функцию можно отключить. Из-за технических ограничений протокола POP3 пользователи почтовых клиентов могут проверять папку «Спам» только в веб-интерфейсе. В 2008 году около 75% входящих писем Gmail были отфильтрованы как спам.
По решению Пола Бакхейта (Paul Buchheit) с самого начала существования сервиса IP-адреса пользователей Gmail маскируются в целях безопасности.
Gmail автоматически проверяет все входящие и исходящие письма и прикрепленные к ним файлы на наличие вирусов. Если в файле, который пользователь попытается открыть, будет обнаружен вирус, система автоматически постарается его обезвредить. Gmail не позволит вам отправить письмо с вирусом, более того, пользователи не могут отправлять и получать письма с исполняемыми файлами, в том числе в архивах.
5 июня 2012 года в Gmail была добавлена защита от атак правительственных хакеров. В случае подозрительной активности Gmail высылает пользователю следующее сообщение: «Внимание! Мы считаем, что вашу учетную запись или компьютер, возможно, пытались взломать хакеры, спонсируемые государством».
С 2008 года Google оставляет за собой право удалять аккаунты Gmail в случае, если они не использовались более девяти месяцев. В других почтовых сервисах сроки могут отличаться. Так, например, аккаунты Yahoo! Mail удаляются через 12 месяцев.
#### Двухэтапная аутентификация
Gmail поддерживает двухэтапную аутентификацию, которая является разновидностью двухфакторной аутентификации. Когда она включена, при входе в аккаунт на новом устройстве, пользователь вводит не только логин и пароль, но и проверочный код. Как правило, это комбинация из шести цифр, которая отправляется на телефон по SMS. Кроме того, существуют специальные мобильные приложения для генерации кода при отсутствии сигнала сотовой сети, такие как Google Authenticator.
21 октября 2014 года компания Google объявила, что браузер Chrome поддерживает стандарт U2F, позволяющий использовать физический электронный ключ. Пользователи могут выбрать его в качестве основного метода двухэтапной аутентификации. По сравнению с шестизначным кодом этот метод надежнее защищает от фишинговых атак и не требует наличия мобильного устройства.
Блокировка на 24 часа
Если Gmail обнаруживает «необычную активность, свидетельствующую о возможном взломе аккаунта», доступ к нему может быть заблокирован на период от одной минуты до 24 часов. Как необычная активность может рассматриваться нижеследующее:
1. Получение, удаление или загрузка большого количества писем по протоколам POP или IMAP за короткий период времени.
2. Отправка большого количества писем, которые возвращаются из-за невозможности доставки.
3. Использование программного обеспечения для обмена файлами и их хранения, расширений браузера либо сторонних приложений с автоматическим входом в аккаунт.
4. Одновременное открытие аккаунта Gmail на нескольких устройствах.
5. Неполадки в браузере: постоянное обновление страницы.
#### Интерфейс
Это решение изначально было придумано компанией Google, но потом его начали использовать конкуренты. Письма на общую тематику группируются и отображаются в виде цепочки на одной странице. Дизайнер интерфейса Gmail, Кевин Фокс (Kevin Fox), хотел ускорить процесс поиска нужных писем.
В Gmail вместо традиционных папок используются тэги, которые позволяют создавать более гибкие механизмы обработки писем. Например, можно настроить фильтры на удаление или переадресацию входящих писем.
#### История
Первым об идее почтового сервиса Gmail заговорил Раджен Шет (Rajen Sheth) во время интервью с Google. Проект тогда носил кодовое название Caribou.
Изначально почтовый клиент был доступен только для внутреннего пользования сотрудников Google. Широкой публике он был представлен 1 апреля 2004 года. 7 июля 2009 года Gmail вышел из статуса бета-тестирования. 22 июня 2005 года был изменен URL сервиса: «http://gmail.google.com/gmail/» превратился в «http://mail.google.com/mail/».
#### Изменения кода
Интерфейс Gmail был переделан в середине 2007 года; новую версию запустили в работу 29 октября 2007 года: был изменён раздел контактов, панель быстрого доступа и всплывающее окно чата. Также были расширены возможности интеграции. В декабре 2007 года новый интерфейс был установлен как интерфейс по умолчанию.
Однако изменения коснулись только тех пользователей, у которых установлены браузеры Internet Explorer 7, Firefox 2, Google Chrome, Safari 3.0 или более поздние версии. Другие браузеры перенаправляют пользователей на базовую HTML-версию Gmail.
1 ноября 2011 года Google вновь изменила дизайн Gmail, сделав интерфейс максимально простым и минималистичным.
Достаточно долгое время браузеры, не поддерживающие технологию AJAX, могли получить доступ к новой версии сайта путем некоторых манипуляций с адресом или с помощью спуфинга. Однако теперь интерфейс Gmail стал более продвинутым, и найти подобные лазейки стало сложнее.
#### Gmail для мобильных устройств
Компания разработала приложение Gmail для iOS-устройств (в частности для iPhone, iPad и Pod Touch), а также устройств, работающих под управлением Android. На других устройствах приходится использовать веб-интерфейс или другие технологии, например POP3 и IMAP.
Версия приложения Gmail 5.0 для Android, выпущенная в ноябре 2014 года, разрешает отправку и получение электронных писем с адресов других почтовых клиентов (включая Yahoo! Mail и Outlook.com) через POP3 или IMAP.
#### Языковая поддержка
Интерфейс Gmail доступен на 72 языках. В их числе: английский, арабский, китайский (традиционный и упрошенный), французский, русский, а также зулу, иврит, хинди и другие.
#### Приложения
Специально для Gmail компания Google разработала несколько вспомогательных приложений. Программа Gmail Notifier – это официальный инструмент от Google, который уведомляет пользователя о наличии непрочитанных сообщений в почтовом ящике. Программа позволяла использовать Gmail как почтовый клиент по умолчанию для открытия ссылок на адреса электронной почты. 30 января 2014 поддержка приложения была прекращена.
2 ноября 2006 года стало доступно мобильное приложение Gmail, способное отображать цепочки писем, а также все вложенные фотографии и документы. Работать с почтой на телефоне гораздо удобнее через приложение, чем через веб-сервис Gmail.
31 августа 2011 года компания Google представила Gmail Офлайн – HTML5-приложение для доступа к Gmail в отсутствие Интернета. Приложение поддерживается браузером Google Chrome, а скачать его можно в официальном интернет-магазине.
11 мая 2011 года инженер Google Сундар Пичаи (Sundar Pichai) сообщил, что сотрудники компании на протяжении нескольких месяцев пользовались офлайн-версиями приложений Gmail, Google Календарь и Google Документы и готовы выпустить их летом 2011 года.
#### Google Apps
10 февраля 2006 года компания Google представила новый проект под названием «Gmail для вашего домена». Все компании, участвовавшие в бета-тестировании, получили возможность использовать Gmail с собственным доменным именем. Позже появился пакет Google Apps, куда вошли популярные веб-приложения Google Календарь, Google Документы и другие сервисы. Решение имеет несколько версий и используется как крупными организациями, так и небольшими компаниями. Среди существующих соглашений можно выделить: «Google Apps для интернет-провайдеров», «Google Apps для бизнеса» и «Google Apps для учебных заведений».
#### Награды
Сервис Gmail удостоился второго места в рейтинге журнала PC World «100 лучших продуктов 2005 года», уступив первое место Mozilla Firefox, а также получил поощрительную премию в конкурсе Bottom Line Design Awards 2005. В сентябре 2006 года журнал Forbes признал Gmail лучшим сервисом электронной почты для малого бизнеса.
#### Конкуренция
С запуском Gmail многие существующие почтовые сервисы увеличили объемы дисковых пространств. Так, например, Hotmail увеличил объем облачного хранилища для некоторых пользователей с 2 МБ до 25МБ, а еще через 30 дней – до 250 МБ. Объем хранилища для аккаунтов Hotmail Plus был увеличен до 2 ГБ. Разработчики Yahoo! Mail увеличили объем хранилища с 4 МБ до 100 МБ. Пользователи Yahoo! Mail Plus также получили 2 ГБ. Позже было обещано, что Yahoo! Mail предоставит своим пользователям «безлимит» уже в марте 2007 года. Компания сдержала свое слово, но лишь в мае.
Все эти усилия были направлены на то, чтобы удержать своих клиентов от перехода на Gmail, плюс общество вновь проявило интерес к почтовым сервисам, а это хорошая возможность заработать. Хорошую конкуренцию Gmail составила компания MSN, которая запустила Windows Live Hotmail – сервис, позволяющий хранить до 5 ГБ информации с возможностью дальнейшего увеличения дискового пространства.
Yahoo! Mail и Hotmail не только расширили дисковые пространства, но и обновили интерфейсы. В 2005 году указанные сервисы, взяв пример с Gmail, увеличили максимальный размер прикрепляемых файлов до 10 МБ и адаптировали технологию AJAX.
#### Критика автоматического сканирования содержания писем
Google автоматически сканирует электронные письма, чтобы добавлять контекстную рекламу и отфильтровывать спам. Защитники неприкосновенности личных данных выразили обеспокоенность тем, что компания анализирует частную переписку пользователей. Сканирование содержания писем, пусть даже и полностью автоматизированное, граничит с нарушением права на неприкосновенность частной жизни. Кроме того, компания сканирует электронные письма клиентов, которые не используют для работы почтовый сервис Gmail и не соглашались с условиями оказания услуг Gmail или его политикой конфиденциальности. Однако большинство почтовых сервисов сканируют содержание переписки для выявления спама, и, конечно, любая система обмена сообщениями должна иметь доступ к содержанию писем, просто чтобы отображать их пользователю.
Google отстаивает свою позицию, подчеркивая необходимость сканирования почты в интересах самих пользователей. Кроме того, компания говорит, что реклама не размещается в письмах, где упоминаются катастрофы, смерть или какие-либо трагедии.
В 2004 году тридцать одна организация по защите частной жизни и гражданских свобод обратилась к компании Google с требованием приостановить работу Gmail до тех пор, пока проблемы, связанные с конфиденциальностью, не будут урегулированы.
В обращении было указано требование разъяснить информационную политику корпорации в отношении способов обмена данными и их хранения. Также было отмечено, что изучение содержания личных писем для размещения таргетированной рекламы безусловно подрывает доверие пользователей к почтовому сервису.
В марте 2011 года бывший пользователь Gmail из Техаса подал в суд на компанию Google, утверждая, что сервис Gmail нарушает неприкосновенность частной жизни людей, сканируя их электронные письма. В июле 2012 года несколько жителей Калифорнии объединились и подали в суд на Google и Yahoo!.. Поводом для подачи искового заявления стал факт анализа содержания электронных писем, отправленных людьми, у которых нет аккаунтов в Yahoo! или Gmail. В 2013 году компания Microsoft выступила с аналогичными обвинениями.
В мае 2013 года представитель пресс-службы Google дал следующие разъяснения:
> «… со стороны пользователей не разумно рассчитывать на то, что отправляемые ими сообщения будут сугубо конфиденциальными. Вы же не удивляетесь, когда отправленное вами письмо коллеге вскрывает его помощник. Поэтому люди, которые пишут электронные письма, не должны удивляться тому, что почтовый сервис обрабатывает их сообщения в процессе доставки».
15 августа 2013 года представитель Google заявил, что корпорация «очень серьезно» относится к защите персональных данных и безопасности пользователей Gmail, а в апреле 2014 года компания обновила пользовательское соглашение, где постаралась объяснить, с какой целью выполняется сканирование писем. Новая редакция гласит: «Наши автоматизированные системы сканируют почту, чтобы отфильтровывать спам и выявлять вредоносные программы, а также отображать актуальные рекламные объявления и ссылки в поисковой выдаче. Анализ содержания писем осуществляется во время их отправки, получения и хранения». По словам представителей компании Google, корпорация хочет, чтобы ее политика была простой и понятной.
#### Другие проблемы, связанные с конфиденциальностью и безопасностью
Ранее в политике конфиденциальности Gmail было указано следующее: «Копии удаленных сообщений и аккаунтов удаляются с активных серверов в течение 60 дней, но они могут сохраниться на наших серверах резервного копирования». Однако в настоящее время этот пункт отсутствует. В 2007 году представители Google пообещали «удалять копии удаленных сообщений настолько быстро, насколько это возможно».
В декабре 2013 года Gmail изменил способ показа изображений в письмах. С целью защиты пользователей от вирусных атак, компания Google начала обрабатывать все изображения перед загрузкой на собственных прокси-серверах. Теперь получатели писем загружают изображения, пришедшие от Google, а не с внешнего сервера – больше не нужно нажимать на кнопку «показать изображения».
#### Технические ограничения
Пользователи Gmail не могут отправлять или получать исполняемые файлы даже в архивах, поскольку они могут содержать вредоносные коды. Еще Gmail не позволяет пользователю отправить письмо на свой ящик, если в нем уже содержится копия этого письма.
Gmail группирует письма в хронологические цепочки (так называемые треды), что может доставлять некоторые неудобства. Например, если пользователь отправляет одно письмо большому количеству людей сразу, то все ответы будут отображаться в одной неделимой переписке. При этом невозможно найти ответы одного конкретного пользователя, не пролистав переписку целиком. И хотя сервис позволяет удалять отдельные письма, большинство операций выполняются только над всем тредом. Цепочки писем нельзя разделять или объединять. В связи с многочисленными жалобами пользователей, Google предоставила возможность отключения тредов 29 сентября 2010 года, но только в веб-версии клиента.
#### Перебои в работе
Несколько раз в работе Gmail были зафиксированы сбои. Так, 24 февраля 2009 года, сервис был недоступен в течение двух с половиной часов, и миллионы пользователей по всему миру не могли получить доступ к своим ящикам. Особенно недовольны были люди, которые пользуются Gmail на работе.
Еще одна дата – это 1 сентября 2009 года. Вице-президент Google Бен Трейнор (Ben Treynor) объяснил, что сбой произошел во время проведения стандартных профилактических работ – часть маршрутизаторов оказалась перегружена и сервис отключился более чем на 100 минут. Трейнор написал: «Gmail имеет уровень доступности «три девятки», потому будем стараться, чтобы подобные инциденты оставались редкостью».
#### Отображение адреса отправителя
До июля 2009 года в любом электронном письме, отравленном через Gmail, в строке «отправитель» указывался адрес gmail.com, даже если это письмо было отправлено с другого домена. Выглядело это так:
`От [email protected] от имени user@[другое доменное имя].com`
Представители компании Google объяснили это тем, что указание адреса Gmail помогает не допустить перемещения писем в папку «Спам». Некоторые пользователи Gmail выразили недовольство по этому поводу и назвали такое решение непрофессиональным. 30 июля 2009 года проблема была разрешена. | https://habr.com/ru/post/275323/ | null | ru | null |
# Перезагружаемся в другую ОС без рукоприкладства
Я постоянно работаю в линуксе. Но бывают случаи, когда нужно перезагрузиться в винду. Просто так это сделать трудно, нужно подождать когда выскочит Grub и выбрать нужный пункт. Поэтому, отдохнуть или сходить куда-нибудь во время ребута вам не получится, сидите перед монитором. Попробуем облегчить страдания и сделать хоть что-нибудь.
#### Чего делать то?
Ну, первая мысль — менять флаг выбора пункта по умолчанию в самом grub. Однако, grub у нас на разделе с линем, а значит винда не сможет изменить конфиг файл. Ладно, вынесем grub на отдельный раздел с fat32. Я выделил 150 МБ, однако и 100 я думаю хватить должно.
Всё, теперь ставим туда grub. Я делал это из линукса, изобретать велосипед здесь смысла нету.
У меня раздел /dev/sda6, меняйте на свой.
```
sudo mkdir /mnt/GRUB
sudo mount /dev/sda6 /mnt/GRUB
sudo grub-install --force --no-floppy --root-directory=/mnt/GRUB /dev/sda6
```
Итак, grub установили, давайте создадим grub.cfg (я провтыкал, и не запомнил, может он по дефолту уже при установке создается).
```
sudo grub-mkconfig -o /mnt/GRUB/boot/grub/grub.cfg
```
Окей, не хватает узнать порядок пунктов в меню. Выполняем и считаем:
```
grep menuentry /mnt/GRUB/boot/grub/grub.cfg
```
Отсчет идет с 0, кстати. Я выбрал два пункта, один с linux (0), второй с windows (4)
##### Linux
Пошли дальше. Разберемся с ребутом линукса. Подойдет такой bash скрипт
```
#!/bin/bash
# Путь к разделу с grub
disk=/dev/sda6
# Пункт с linux
linmenu=0
# Пункт с windows
winmenu=4
mount $disk /mnt/GRUB
sed "s/set default=\"${linmenu}\"/set default=\"${winmenu}\"/g" -i /mnt/GRUB/boot/grub/grub.cfg
reboot
```
Изменяйте раздел и пункты с линьвином.
Для перезапуска я создал кнопку gksu sh ./путь-к-скрипту. А то кто это вам разрешит монтировать и ребутить без рут прав.
В данном скрипте просто заменяется set default на нужное.
Уже можно даже попробовать перезагрузится в винду через скрипт.
##### Windows
В винде, не мудрствуя лукаво, я поставил [sed](http://gnuwin32.sourceforge.net/packages/sed.htm), только перекинул файлы из bin в system32.
Получился такой .bat файл:
```
:: Путь к grub.cfg
set grubfile=e:\boot\grub\grub.cfg
:: Пункт с linux
set linmenu=0
:: Пункт с windows
set winmenu=4
sed -e "s/set default=\"%winmenu%\"/set default=\"%linmenu%\"/g" %grubfile% > %grubfile%.tmp
del %grubfile%
ren %grubfile%.tmp grub.cfg
shutdown -f -t 0 -r
```
Меняйте пути и пункты.
(sed с ключем -i мусорил, пришлось в темп кидать. Кто знает другой обход, напишите)
#### Вместо выводов
Да и всё, вроде. Имеем, кнопку на линуксе, которая перезагружает комп в винду автоматом и наоборот.
Грамотные люди меня поправят, где я не прав и где можно чего изменить. Умею как могу.
Экспериментируйте.
**UPD:** В комментах подсказали про grub-reboot, а также узнал про grub-set-default, однако менять конфиг файл они у меня не захотели (рут дирректорию тоже указывал). Прочитал, что настройка есть еще в /etc/default/grub, там и меняет, наверное. | https://habr.com/ru/post/152597/ | null | ru | null |
# Вариант Singleton на Java
Изучив предложенные в статьях [«Правильный Singleton в Java»](http://habrahabr.ru/blogs/java/129494/) и [«Реализация Singleton в JAVA»](http://habrahabr.ru/blogs/complete_code/27108/) варианты решений и «пораскинув мозгами», я предположил, что смогу представить еще два похожих друг на друга варианта создания Singleton'а, практически лишенных многих недостатков тех решений, которые были изложены ранее в упомянутых статьях. Но хочу начать с постановки задач, решение которых определит, добились ли мы желаемого результата.
*Требования:
1. Потокобезопасность
2. Сериализуемость изменений ссылки на объект-Singleton
3. Управляемость создания объекта в блоке try-catch
4. Создание объекта-Singleton вне конструктора
5. Несериализуемое получение ссылки на объект-Singleton, обеспечивающее лучшую производительность.
6. «Ленивая» инициализация объекта-Singleton*
*Вариант 1*
````
public class Singleton {
private static volatile Singleton instance;
static {
System.out.print("Singleton class Initializator\r\n");
try {
InitSingleton();
} catch (Exception e) {
System.out.print("Exception occurred\r\n");
}
}
private static synchronized void InitSingleton() {
if (instance == null) instance = new Singleton();
}
public Singleton() {
System.out.print("Singleton has been initialized\r\n");
}
public static Singleton getInstance() {
return instance;
}
}
````
В предложенном варианте, вызов синхронизируемого метода для создания ссылки на объект происходит из так называемого статического инициализатора объекта, который, по сути, выполняется на том же уровне, что и инициализация переменных-членов объекта, выполняется до вызова конструктора и должен быть сериализуем «by design». Но так как моя надежда на самосериализуемость блока-инициализатора не велика, я снабдил статическую ссылку на объект-Singleton модификатором **volatile**, обеспечивающим непротиворечивость значений статической переменной в разных потоках, а статический метод создания объекта-Singleton снабдил модификатором **synchronized**, гарантирующим одновременное выполнение данного метода только в одном потоке.
Второй вариант похож на первый тем, что использует тот же принцип инициализации — из блока-инициализатора, но отличен отсутствием модификатора **volatile** у статической ссылки на объект-Singleton в угоду производительности, а синхронизация создания объекта основывается на блокировке объекта-члена класса с ранее выполненной инициализацией. При этом использована идея, предложенная в комментариях к статье [«Правильный Singleton в Java»](http://habrahabr.ru/blogs/java/129494/).
*Вариант 2*
```
public class Singleton {
private static Singleton instance;
private static final Object lock = new Object();
private static boolean isInitialized = false;
static {
System.out.print("Singleton class Initializator\r\n");
try {
synchronized (lock) {
if (!isInitialized)
if (instance == null) {
instance = new Singleton();
isInitialized = true;
}
}
} catch (Exception e) {
System.out.print("Exception occurred\r\n");
}
}
public Singleton() {
System.out.print("Singleton has been initialized\r\n");
}
public static Singleton getInstance() {
return instance;
}
}
``` | https://habr.com/ru/post/134637/ | null | ru | null |
# О практической пользе transformer для торговли на бирже
### Введение
Многие datascientists, желающие использовать ML на финансовых рынках, прочитали толстые книжки об инвестировании, может даже создавали модели с учетом прочитанного. И наверняка знают как правильно оценить полученные модели с точки зрения ML. Разобраться с этим необходимо, чтобы не было мучительно больно, когда прекрасная модель на бумаге, превращается в генератор убытков при практическом использовании. Однако оценка эффективности модели ML на бирже, довольно специфическая область, тонкости которой раскрываются только когда вы погружаетесь в процесс. Под процессом я понимаю трейдинг с частотой совершения сделок гораздо чаще "пара сделок в месяц, в течении полугода". Существует множество подводных камней, о наличии которых вы даже не подозреваете, пока смотрите на трейдинг извне. Я попробую вольно изложить свои мысли на данную тему, я покажу метрики, условно разбив их на 3 группы и обьясню их смысл, покажу свои любимые и о чем нужно подумать, если вы хотите практически использовать модели, а не повесить их на стеночку в красивой рамочке. Представлю метрики в табличном и графическом виде, показав их взаимосвязь. Сравню показатели моделей в виде "какую модель выбираю я" и "что выбираете вы" и кто тут больше ошибается. Для любителей кодов, приведу реализацию всего подсчитанного, так что можно сразу применить прочитанное для оценки своих моделей. Я не буду тут говорить о борьбе с переобучением или регуляризации или стратегиях кросвалидации - оставлю это на потом. Здесь мы начинаем со списка уже спрогнозированных сделок, с помощью transformer о которой я писал в прошлой статье. Поэтому данный текст будет его логическим продолжением, где я оценю модель с точки зрения ее практического использования.
### 1. Раздел где я собрал все оценки моделей на бирже и разбил их на 3 группы.
Существует несколько способов оценки эффективности модели, которые можно условно разбить по степени вовлеченности в реальный трейдинг. Не очень вовлеченные часто останавливаются на **первом уровне, это метрики ML**, в частности для задачи классификации это будет accuraсy и ее производные. Прямо скажем эти показатели далеки от того что действительно интересует людей которые приходят на биржу. Там знаете ли, всех интересует финансовый результат. Языком ML это можно назвать бизнес метрикой - то что мы получим при использовании модели в денежном выражении. Я мало смотрю на показатели типа accuracy, сразу конвертируя прогнозы в финансовый результат, а если datascientist демонстрирует accursay, roc-auc итд, но упорно отказывается продемонстрировать сколько можно было бы заработать используя модель, то скорей всего это говорит, о сомнительном финрезультате или о недопонимании для чего все это нужно. Или например приводят фактический и спрогнозированный график цен и умиляются их близостью, хотя все что модель делает - прогнозирует на завтра сегодняшнюю цену. Такая вот хорошечность. Такой подлог даже вооружившись лупой можно не разглядеть, а с приведенным финансовым результатом все сразу становится на свои места. Даже если вы не шарлатан от машинного обучение, и все посчитали корректно, показатели ML не говорит практически ни о чем. Например будет ли прибыльной модель угадывающая 80% движений на тик или минуту вперед? Нет, потому что за тик или минуту, цена просто не проходит такое расстояние чтобы покрыть комиссию и проскальзывание.
Говоря о "бизнес метриках" надо понимать, что уже существует широкий набор показателей, продемонстрировавшие свою эффективность при выборе алгоритмических моделей. И нейронщикам ничего придумывать не нужно, просто берем заботливо создано задолго до нас. Если говорить о концепции лежащей в основе, то многие из них вертятся вокруг идеи измерения соотношения риск-доход, чем меньший риск Y мы принимаем для того чтобы получить доход X - тем лучше. Тут же рядом как феникс появляются "безрисковый доход", "дисконтирование", "будущая стоимость", "корреляция активов", "портфельное инвестирование" и другие понятия из экономтеории. На этих идеях построены классические модели инвестирования, разной сомнительности, за которые тем не менее были получены Нобелевские премии. При этом допустимое соотношение риск-доходность это выбор каждого человека, но имея для каждой модели такое вот соотношение их можно сравнивать между собой, приведя к одному основанию и говорить что модель 1 позволяет получить прибыль больше чем модель 2 при одинаковом уровне рисков.
Так вот, показателей из разряда бизнес - метрик (**которые я условно причислю к второй группе показателей**) очень много: Sharp Ratio, Profit Factor, Recovery Factor, Payoff Ratio, Maximum Drawdown %, Max Consecutive Losses (Winners), Average Time Held, Loss Rate, Win Rate, Average Profit (Loss), Exposure, Net Profit, Profit Distribution. Казалось, зачем так много показателей, если можно например взять число сделок, умножить на среднюю прибыльность сделки и получить Net Profit - то куда мы придем используя модель. На самом деле все не так, двигаться из А в сторону Б можно очень по разному, на пути может существовать точка невозврата С, попав в которую до никакого Б мы уже не дойдем. Например в силу катастрофических просадках по счету, достигающих более 50% по счету. Это простая арифметика - если вы упали от локального максимума по своему счету на - 50%, то чтобы вернуться к достигнутому максимуму вам понадобиться сделать уже не +50%, а +100%, и я не говорю о более сильных просадках, которые уж точно являются точками невозврата. Точка невозврата может быть связанна с таким психологическим состоянием трейдера, которое никак не совместимо с трейдингом. По показателю Net Profit мы это никогда не увидим, тут надо считать все эти показатели, либо строить кривую изменения вашего счета по времени - Equity. Правильно сгенерированная Equity дает исчерпывающий ответ о эффективности вашей модели, а весь тот большой набор данных, который я привел выше, описывает разные аспекты этой кривой. Еще один вариант, это взять наши сделки и сгенерировать много выборок меняя очередность сделок, а затем посчитать долю случаев в которых неблагоприятный период в виде подряд шедших убыточных сделок настолько затянулся, что привел к попаданию в точку невозврата, когда до хорошей серии сделок мы уже не доживем. Говоря языком матстатистики - выдвигаем гипотезу H0, альтернативную, выбираем уровень значимости, строим статистику на основе верности гипотезы H0 и принимаем или отвергаем ее. И тут опять может так получиться что вполне пристойные модели с точки зрения Net Profit, с точки зрения матстатистики окажутся не хороши, например модели с небольшим числом сделок. И тут мы переходим к третьей группе показателей эффективности модели.
**Третья группа**, под некоторые можно подвести теорию, некоторые проистекают из здравого смысла, из моего опыта, а некоторые не имеют ни одного ни второго ни третьего, но они соответствуют моему психотипу. Под последним можно понимать, порог чувствительности при просадках, готовность сидеть весь день за компьютером, отслеживая ситуацию, приемлемое для вас соотношение риск-доходность, частота прибыльных сделок итп итд. Модель может быть эффективной по бизнес-метрикам, но вы не сможете ее торговать, потому что она для вас некомфортна. Например мне не комфортно торговать модели, которые каждый год надо полностью переучивать, или модели типа "ловля ножей". Эти никак не оценить ни метриками ML, ни "бизнес метриками", ни строя кривые equity, это из другой оперы. Вот есть модель, а есть трейдер ее использующий и эффективность будет зависеть и от модели и от того кто ее использует и если модель не является продолжением трейдера - вы используете чужую модель, или сомневаетесь в ней, то ничего хорошего может не получиться, хотя по отдельности все вроде бы и хорошо. Некоторые пытаются обходить этот момент, самоустраняясь, перепоручая все роботу. Такая обезличенность в некотором смысле оправданна. Я могу привести множество примеров когда успешная или неуспешная сделка накануне, подсознательно влияла на принятие решения о следующей сделке. Поэтому я старательно пытаюсь стирать из памяти (и фигурально и фактически) все прошлые сделки.
Или например добавлю немножко "кота Шредингера". Это о вашем влияние на рынок. Частично именно этим можно обьяснить почему на тесте и при использовании модели, ваши результаты разьезжаются. И влияние этого фактора тем больше чем большее влияние вы оказываете на котировку акции своими сделками. Вы получили модель тестируя ее на торгах где вас не было - одна реальность, когда вы начинаете торговать, вы изменяете действительность. Если совершая сделку, вы двигаете цену на десятые доли процента, то поздравляю - вы манипулятор. Опять же это не история о абсолютном зле, экономика это вообще не история о каких то предельных понятиях, это история о балансе (баланс между инфляцией и экономическим ростом). Двигая рынок, вы вполне можете оказаться тем камушком который опрокинет рынок в нужную вам сторону, или не в нужную. Направление этого влияния мы скорей всего никак не замерим, зато можем оценить "ликвидную емкость модели" (термин самопридуманный), который позволяет оценить эффективность модели с условием что мы не меняем реальность. Это критерий эффективности модели из здравого смысла, который многие начинают учитывать только когда визуально наблюдают как не могут набрать позицию одним кликом.
### 2. Раздел, вывод которого о Equity как исчерпывающе характеризующим эффективность системы.
**Давайте начнем оценивать** transformer, начнем с бизнес-метрик, но сначала о данных. Обучив несколько вариантов transformer, я прогнал их на новых данных, получив поток сделок, к которым добавил столбец с прогнозом роста, от каждой модели, в виде вероятности. В итоге имеем pandas dataframe, со следующими столбцами: ['Date', 'Symbol', 'profit\_label', 'profit', forecast\_model1, forecast\_model2, ... forecast\_modelN']. Теперь надо разобраться что нам делать сразу с несколькими прогнозами. В моих функциях реализовано несколько стратегий стакинга (по максимальной уверенности среди всех моделей, по средней уверенности, по минимальной, по числу голосов с каким то порогом уверенности). Разница в результатах не принципиальная, но чтобы не путаться, все последующие результаты взяты из правила - "покупаем если по акции сработал сигнал с уверенностью выше 0,6, от более чем 1 модели".
Самый простой вариант финансового результата, это Net Profit с разбивкой по количеству сделок и средним профитом на сделку, и в группировке по годам.
Однако не все так просто. Мы ведь торгуем не в сферическом вакууме, у нас есть обьективные ограничения в виде размера счета (с учетом маржинальной позиции), мы не можем одновременно на каждую сделку выделить 100% возможных средств. Приведу предельный пример несуразицы, после которого станет все понятно. Допустим у вас есть модель которая генерирует 40 сигналов в год и каждая сделка приносит в среднем по 1%. А теперь представим что все сигналы по этой модели срабатывают одновременно. И теперь вместо модели которая генерирует 40% годовых, мы становимся гордыми обладателями модели которая генерирует 1% годовых. То есть мы говорим о **перекрещивание сделок.** Я изобразил это на рисунке, не то чтобы без него было непонятно, но рисунки разнообразят текст да и может здесь кроме любителей читать есть любители рассматривать картинки. На картинке ниже, в формате "каракули" я изобразил 7 сигналов : 1 и 2, 3 и 4, 5 и 6 - сигналы появились одновременно, причем 1, 3 и 4 сигналы, по отношению к сигналам 2, 4 и 5, приоритетные, то есть по ним модель более уверенна. Время удержания позиции - длина черты.
Пусть первая сделка принесла +1%, а каждая следующая на 1% больше (то есть номер сигнала совпадает с прибыльностью сделки), вопрос сколько мы заработали в % к нашему счету (без реинвестирования)? Если сигналы появились одновременно, то мы должны выбрать какую то одну или взять все, но прибыль считать как взвешенную по доле участия капиталом в каждой сделке. Пока мы не выйдем из предыдущей сделки, высвободив кэш, в новую не входим. Если входим равными долями, тогда получается 3 сделки (все сделки совершенные в одно время я буду считать одной сделкой): (0,5%+1%) + (2,5%+3%) + (3,5%). А если например мы входим на 100%, по самому перспективному сигналу, тогда 3 сделки: 1%+3%+5%. А если например степень уверенности конвертировать в долю участия по этому сигналу, то третий вариант, А если например учитывать ликвидность, то четвертый вариант, я его рассмотрю ниже. Варианты разные и каждый раз мы будем получать разные итоги. А если вообще не думать, то получится 7 сделок 1+2+3+4+5+6+7.
Мы не думать не будем, поэтому подкорректируем результат, случай когда берем среднюю по сделкам - размазываем капитал по акция в равных долях:
И результат когда входим на 100% входим в сделку с наивысшим приоритетом:
Убрав эффект перекрещивающихся сделок, видим что эффективность модели упала - число сделок уменьшилось и средняя прибыльность снизилась, но не катастрофически. Кодик для подсчета Net Profit в данном виде:
```
def trade_list(df_data_conect, for_treshold, treshold, mean__, count_tresh, time_time4_dtime, time_list, name_profit):
print(f'Profit: {name_profit}, Feature: {for_treshold}')
if mean__ == 'mean':
mean__1 = df_data_conect[for_treshold].mean(axis = 1)
elif mean__ == 'max':
mean__1 = df_data_conect[for_treshold].max(axis = 1)
elif mean__ == 'min':
mean__1 = df_data_conect[for_treshold].min(axis = 1)
elif mean__ == 'count':
mean__1 = (df_data_conect[for_treshold] > count_tresh).sum(axis = 1)
df_data_conect.Date = pd.to_datetime(df_data_conect.Date)
df_data_conect['mean__'] = np.array(mean__1)
pivo_lon1 = pd.pivot_table(df_data_conect[df_data_conect['mean__'] >= treshold],
index = [df_data_conect.Date.dt.date, 'Symbol'],
values = ['mean__', name_profit],
).T.drop_duplicates().T
pivo_lon1.reset_index(inplace=True)
pivo_lon1 = pivo_lon1.sort_values(['Date', 'mean__'], ascending = [True, False], ignore_index=True)
pivo_lon1['Date'] = pd.to_datetime(pivo_lon1['Date'])
pivo_lon1['long1'] = np.where(pivo_lon1['Date'].shift(0) != pivo_lon1['Date'].shift(1), 1, 0)
print('all_trades')
all_trades = pd.pivot_table(pivo_lon1,
index = pivo_lon1['Date'].dt.year,
values = [name_profit],
aggfunc = ['count', 'mean'],
margins = True
)
all_trades.columns = ['count_trades', 'profit%_per_trade']
display(all_trades)
print('long1')
only_long1 = pivo_lon1[pivo_lon1['long1'] == 1]
temp = pd.pivot_table(only_long1,
index = pivo_lon1['Date'].dt.year,
values = [name_profit],
aggfunc = ['count', 'mean'],
margins = True
)
temp.columns = ['count_day', 'profit%_day']
display(temp)
# Mean_day
only_mean = df_data_conect[(mean__1 >= treshold)]
pivo_long = pd.pivot_table(only_mean,
index = [df_data_conect.Date.dt.date],
values = [name_profit],
aggfunc = ['mean', 'count'],
margins = True
).T.drop_duplicates().T
pivo_long.reset_index(inplace = True)
pivo_long.columns = ['Date', 'mean', 'count']
pivo_long = pivo_long.iloc[:-1,:]
pivo_long['Date'] = pd.to_datetime(pivo_long['Date'])
print('mean')
mean_profit = (pd.pivot_table(pivo_long,
index = pivo_long.Date.dt.year,
values = 'mean',
aggfunc = ['count', 'mean'],
margins = True
))
mean_profit.columns = ['count_day', 'profit%_day']
display(mean_profit)
# List_trades and mean_day
print('List_trades')
pivo_long = pd.pivot_table(df_data_conect[df_data_conect['mean__'] >= treshold],
index = [df_data_conect.Date.dt.date, 'Symbol'],
values = [name_profit, 'mean__', 'Volume_mean_10bars'],
aggfunc = ['mean'],
margins = True
).T.drop_duplicates().T
pivo_long.columns = pivo_long.columns.get_level_values(1)
pivo_long.reset_index(inplace = True)
pivo_long.sort_values(by = ['Date', 'mean__'], ascending = [True, False], inplace = True)
display(pivo_long.tail(29))
return only_long1, only_mean
```
В аргументах функции trade\_list мы имеем возможность выбрать стратегию стакинга, после чего получаем все указанные выше таблички. Нужно сказать что в случаи c transformer код очень сильно упрощен, достаточно все отсортировать по времени и применить много, много pd.pivot\_table, так как для данного transformer время входа и выхода из позиции унифицирован. Если это не выполняется, то тут уже необходимо пробегаться в цикле по всем сделкам, расставляя флаги 0 (нет позиций), 1 (вход в позицию), 2 (удержание позиции), 3 (выход из позиции), и исходя их этого считать Net Profit, по крайней мере так поступал я.
Насколько перекрещивание сделок распространенно и насколько сильно учет их может ухудшить показатели модели?! Скажем так, в моей практике было несколько случаев когда я находил алгоритмы, которые а из разряда "перспективных" превращались в "неинтересные". Конечно пытливый ум человека сразу предлагал другой вариант - "если модель особо прибыльна когда по ней одновременно проходят сигналы по многим акциям, и таких случаев 10-12 раз а год, то может стоит глянуть что происходит на рынке после этого в среднесрочной перспективе?". Могу привести самый свежий пример по одному алгоритму, сигналы по которому я не использую, в силу большого числа перекрещивания. 18 января сего года по нему сработал сигнал сразу по 18 акциям. Смотрим на индекс МосБиржи и видим что это был локальное дно, после которого рынок перестал падать. 23 декабря прошлого года по этому алгоритму сработал сигнал сразу по 13 акциям. Смотрим на график индекса и видим - в следующие полторы недели рынок довольно активно рос. Отматываем историю дальше и опять видим такие случаи. Я такое не торгую, так как мало случаев, но может кому то идею подкину.
Eсли вы пользуетесь **Take Profit, Stop Loss,** может возникнуть следующий момент который может исказить эффективность вашей модели.В коде вы можете поставить приоритет Take Profit, но никакого приоритета он не имеет, приоритет имеет первое произошедшее по времени. Работая с баром, вы не знаете что первым наступит - первое или второе, а это большая разница когда вы выходите по Take Profit или закрываетесь по Stop Loss. Чем на большем таймфрейме вы тестируете систему, и чем меньше у вас разница между stop и take, тем больше вероятность попасть в ситуацию когда на одном баре происходит касание и линии take profit и линии stop loss. На рисунке я справа изобразил котировку в дневном представлении, а слева в 15 минутном
На левом баре мы не понимаем что сработало первым, на правом графике все понятно. Конечно и 15 минутного таймфремя может не хватить, абсолютное спасение это смотреть тики, но это какой то запредельный случай. Для моей модели это не актуально, но тем кто использует близкие стопы, стоит обратить внимание. То же самое касается цены открытия дня. Если кто то считает по ней входы-выходы, то он оперирует мифом, "цена открытия" это нечто иллюзорное, лучше вместо нее брать цену после 1 минуты торгов. Ну это так, к слову.
**Следующие показатели мы** будем рассматривать вместе с equity, по принципу "единство и борьба противоположностей". Как я уже писал, все бизнес метрики являются всего лишь табличным представлением особенностей кривой equity. Рассмотрев все вместе, мы лучше сможем понять что к чему и зачем. Многие сравнивают кривые equity с индексами, я от этого также не удержусь. Логика простая - существует класс участников биржи, которые называют себя гордым словом "инвесторы", они читают советы Уоррена Баффета и прочих гуру. Находятся в поиске "мало рискованных, стабильных, растущих компаний". Одним словом занимаются ерундой. Немножко поумнев, они бросают бесплодные занятие найти то чего нет и просто покупают какой то индекс, в расчете на общий рост рынка, и они правы, инфляция знаете ли. И сравнение equity какой то модели с индексом, это такое противопоставление активного и пассивного трейдинга (buy and hold). И если ваш активный трейдинг не позволяет опередить пассивный, если прибыль по нему меньше чем по пассивному, если просадки по нему глубже чем по пассивному, то к чему это вся суета с беготней по рынку?! Чтобы накормить комиссией брокера?! С другой стороны, есть момент некорректности в таком подходе, например если трейдер играет исключительно в шорт (такая у него специализация), то как сравнивать его результаты с buy and hold?! Ведь при buy and hold торговле вы получаете прибыль когда рынок растет, а по шортовой, чем глубже рынок падает, тем удачней вы реализуете шортовые стратегии. Или даже если не шортовые стратегии, а самые что ни на есть длинные. Кто сказал что найденные вами лонговые паттерны лучше всего отработают при бурно растущем рынке?! В общем есть тут обманка, натягивание совы на глобус, поэтому я уже давно не оцениваю свои модели сравнивая их с пассивным инвестированием, я оцениваю их с точки зрения собственных критериев, например возможности получения стабильно 50% в год при заданном уровне риска. Поэтому я буду наносить на один график equity и индекс IMOEX чтобы был понятен масштаб. Есть небольшой вопрос - как считать equity: с реинвестированием или без. Отсутствие реинвестирования здорово искажает результаты, однако с реинвестированием, кривая индекса растворяется где то внизу и наглядность теряется. Промежуточный вариант - с реинвестированием, но входим только на 50% от капитала:
Кусок кода, если кому хочетя проверить логику расчета:
```
from_year = 2012
comission = 0.1/100
share = 0.5
for i in range(len(equity)):
if i == 0:
equity[i] = 100 + share*100*(profit_hour_np_1[i]/100 - comission)
equity_reinvest[i] = 100 + share*100*(profit_hour_np_1[i]/100 - comission)
capital_year[i] = 100
equity_reinvest_year[i] = capital_year[i]*(1 + profit_hour_np_1[i]/100 - comission)
else:
equity[i] = equity[i-1] + 100*(profit_hour_np_1[i]/100 - comission)
equity_reinvest[i] = equity_reinvest[i-1] + share*equity_reinvest[i-1]*(profit_hour_np_1[i]/100 - comission)
if date_for_plot[i] == date_for_plot[i-1]:
capital_year[i] = capital_year[i-1]
equity_reinvest_year[i] = equity_reinvest_year[i-1] + capital_year[i]*(profit_hour_np_1[i]/100 - comission)
else:
per_last_year = (pivo_for_plot[pivo_for_plot.Date.dt.year == date_for_plot[i-1]][[enter_mean]].sum() - pivo_for_plot[pivo_for_plot.Date.dt.year == date_for_plot[i-1]][[enter_mean]].count()*comission)
capital_year[i] = capital_year[i-1]*(1 + per_last_year/100)
equity_reinvest_year[i] = equity_reinvest_year[i-1] + capital_year[i]*(profit_hour_np_1[i]/100 - comission)
```
Number of bars since last Equity High А теперь попробуем на этих графиках обозначить табличные данные. **Number of bars since last Equity High** (число баров с последнего обновленного максимума equity). Очень полезный показатель характеризующий способность вашей модели стабильно приносить прибыль. Черными линиями указал некоторые наиболее длительные промежутки, когда роста счета не было.
Maximum Drawdown %А вот на кривой equity мы обозначаем наиболее крупные показатель **Maximum Drawdown %**:Находим локальный максимум и считаем в процентах откат до локального минимума.
Конечно нас интересует не выборочно самые большие значения, а некая динамика, поэтому разнесем показатели по шкале времени, для обоих графиков:
1-MD, 2-Number Bar для transformer, 3-MD, 4-Number Bar для IMOEX По нижнему графику мы можем видеть как купив индекс ММВБ в январе 2020 года мы могли получить просадку по счету в размере -45%. По второму снизу, как купив индекс в 2012 году, нам бы пришлось ждать долгих 500 дней (3 года) пока наконец то не была бы получена первая прибыль. Верхние два демонстрируют что риски по transformer в разы ниже, а стабильность в получении прибыли в разы выше. Фрагмент кода для расчета этих показателей:
```
for i in range(len(equity_max)):
if i == 0:
equity_max[i] = equity_from_plot[i]
else:
equity_max[i] = (equity_from_plot[:i+1]).max()
for_plot['equity_max'] = equity_max
ddown_bar = []
for i in range(len(for_plot)):
if i == 0:
k = 0
elif equity_max[i] == equity_max[i - 1]:
k += 1
else:
k = 1
ddown_bar.append(k)
for_plot['Number_bar'] = ddown_bar
for_plot['DrawDown_%'] = (for_plot['equity_max'] / equity_from_plot - 1) * 100
```
Показатели соединяющие прибыль и риск: **Recovery Factor -** отношение прибыли в течении какого то временного промежутка к максимальной просадке и **Profit Factor***-* рассчитывается как валовая прибыль, деленная на валовой убыток, таким образом, мы получаем число, которое показывает нашу прибыль, рассчитанную на единицу риска.
На графике с equity берем какой то интервал времени, например год, и делим годовую прибыль (зеленый столбик) на максимальную просадку (красный столбик).
То есть что такое Maximum Drawdown? Это показатель максимальных потер которые вы понесете если войдете в рынок в какой то промежуток времени (в данном случаи в 2015 году). В чем логика? Логика в том что мы не знаем в какое время мы попадем на рынок, поэтому берем самый неблагоприятный вариант. Если бы берем рынок с 2008 года, то Maximum Drawdown для пассивной торговли будет где то под -80%, именно столько бы вы потеряли если вас угораздило купить индекс летом 2008 года. Так что если у вас что то чешется глядя на биржевые индексы, выросшие на 50 - 100% за год, не забывайте и про год когда все упадет на 80%, а он неминуем, это только вопрос времени. Поэтому тем "математикам", которые строят оптимистические кривые роста, показывая как начав даже с небольшой суммы и даже имея всего 20% годовых, благодаря сложным процентом, вы неминуемо разбогатеете через каких то 20-25 лет, хочу напомнить, что по мере роста длины цепочки, вероятность получить год когда все рухнет, похоронив вашу цепочку - равна 100%. И про небольшой баг в расчете Maximum Drawdown - правильно было бы посчитать показатель с учетом просадок во время удержания позиции, в моем случаи я этот момент игнорирую.
Откуда взялись показатели сопоставляющие потери с прибылью, я уже писал, теперь напишу практическую ценность. Представим у вас есть две equity, разбив их по годам, мы получили средние по годам Net Profit 60% и 30% со средним Maximum Drawdown в 30% и 10% соответственно. Мы можем привести эти торговые системы в соответствие, перенормировав одну к другой, чтобы их максимальные просадки стали одинаковыми (или приравняв прибыли), после чего окажется что 2 модель эффективней. И это не только теория, мы это можем реализовать на практике воспользовавшись возможностями маржинальной торговли. Используя леверидж, мы можем реализовать модель с хорошим Recovery Factor или Profit Factor, пусть и небольшим Net Profit.
И в завершении раздела, некоторые показатели для Transformer и Buy and Hold:
```
import plotly.graph_objects as go
def table_culc(equity_reinvest, only_long1, for_plot):
NetProfit = round(100*(equity_reinvest[-1]/equity_reinvest[0] - 1), 2)
NumberofTrade = len(only_long1)
win_rate = round(np.where(only_long1 >= 0, 1, 0).mean()*100,2)
loss_rate = round(100 - win_rate, 2)
Profit_trade = round(only_long1.mean(), 2)
Average_profit = round(only_long1.mean(), 2)
Average_profit_win = round(only_long1[only_long1 > 0].mean(), 2)
Average_loss = round(only_long1[only_long1 <= 0].mean(), 2)
profit_factor = (only_long1[only_long1 > 0].sum()/-only_long1[only_long1 <= 0].sum()).round(2)
MMd = round(for_plot['DrawDown_%'].max(), 2)
Recovery_factor = round((NetProfit / 100 - 1) * 100 / MMd, 2)
Payoff_ratio = round(Average_profit/-Average_loss, 2)
return [NetProfit, NumberofTrade, Average_profit, win_rate, Average_profit_win, loss_rate, Average_loss, MMd, profit_factor, \
Recovery_factor, Payoff_ratio]
date_tr = [NetProfit, NumberofTrade, Average_profit, win_rate, Average_profit_win, loss_rate, Average_loss, MMd, profit_factor, \
Recovery_factor, Payoff_ratio]
values = [['Net Profit %', 'Number of Trades', 'Average Profit %', 'Win Rate', 'Average_profit_win', 'Loss Rate', 'Average Loss %', 'Maximum Drawdown %','Profit Factor', \
'Recovery Factor', 'Payoff Ratio'],
date_tr, date_bh]
fig = go.Figure(data=[go.Table(
columnorder = [1,2,3],
columnwidth = [5,5],
header = dict(
values = [['**NAME**'],
['**Transformer**'], ['**Buy & Hold**']],
line_color='darkslategray',
fill_color='royalblue',
align=['left','center'],
font=dict(color='white', size=12),
height=10
),
cells=dict(
values=values,
line_color='darkslategray',
fill=dict(color=['paleturquoise', 'white']),
align=['left', 'center'],
font_size=12,
height=25)
)
])
fig.show()
```
### 3. Неочевидные, но полезные показатели
Наконец показатели из третьей группы. Для меня одним из таких показателем является **число сделок**. Это можно увидеть на equity - если у вас сделок мало и большую часть времени вы находитесь вне рынка, то и кривая у вас будет со многими горизонтальными линиями. Для меня алгоритм генерирующий пару десятков сделок в год, это весьма сомнительное предприятие. Слов нет, по мере роста эффективности рынка, число сделок может уменьшится. Это не вопрос что за паттерном с небольшим числом реализаций ничего не стоит, вопрос в невозможности при небольшом числе сделок как то адекватно оценить практическую полезность алгоритма. Поэтому тестируя паттерн я всегда смотрю на число сделок, их не должно быть меньше 50-100 случаев за год. Обоснование можно найти в матстатистике. Допустим у нас есть фактическая вероятность, которую мы не знаем, но видим ее реализацию в виде выборки - наших сигналах. Это можно сгенерировать с помощью Монте-Карло, а можно воспользоваться формулой Бернулли для биноминального распределения. Чем длиннее выборка, тем "стройней" наша плотность распределения, тем меньше "случайности в случайности". Поэтому вероятность P(получить набор из 200 примеров с accuracy|при истинной вероятности 0,5) << P(получить набор из 50 примеров с accuracy|при какой то истинной вероятности 0.5). Можно высказаться еще проще - подкидывая монетку сериями много, много раз (описываем процесс поиска алгоритма, настраивания модели итп), вероятность получить 70% орлов при подкидывании монетки выше при меньшей длине серий. Мы начинаем сильней играть в рандом, получая более случайную оценку нашего истинного распределения, и это обязательно вылезет со временем. Обычно это не заставляет себя ждать, и как только вы выходите со своим паттерном с небольшим числом сделок в реальный трейдинг, вас сразу наказывают. **Равномерность результата по акциям**. Это дискуссионное, так как многие строят модели отдельно для каждой акции, и я никак не обсуждаю, не критикую, не осуждаю, но сам предпочитаю чтобы была стабильность в разрезе акций.
Показатели transformer в разрезе акций с убранным фильтром по объему.Таким образом я борюсь с рандомом и тешу себя надеждой что нахожу более стабильные паттерны, которые будут существовать дольше, так как любой занимающийся алготрейдингом знает что найти работающий паттерн это четверть дела, еще половина дела найти паттерн который будет работать в какой то среднесрочной перспективе, и еще четверть дела вовремя соскочить когда неэффективность начинает исчезать. У меня есть несколько моделей, которые я не использую в виду большого влияния на результат, 3-4 фишек. Например на какой то Мечел приходится 15% сделок, а средняя прибыльность по нему в разы превосходила среднюю прибыльность по всем остальным акциям. Наверно можно было стать "специалистом по Мечелу" и торговать его, раз его движения так хорошо ловятся моделями, но я пас. **Стабильность по годам (кварталам, месяцам)**, конечно чем меньше интервал тем лучше, но как минимум я буду добиваться положительного результата в разрезе годов. Если вы тестируете модель и видите что она из года в год (а лучше из месяц в месяц генерирует прибыль) то прекрасно. По ровности роста equity вы это сразу увидите или на графике "время в днях с последнего максимума". Почему это так важно? Ну вот представим перенеслись вы в 20.. год, тот самый, в который ваша, в целом прибыльная модель, стояла на месте. Допустим в этот самый год вы взяли кредит, чтобы большей суммой торговать, сосед вам дал денег, крупная компания в вас поверила итп итд. И по прошествии этого года возникает вопрос - что вы будете говорить заинтересованным людям, как будете возвращать кредит и какое будет ваше психологическое состояние после целого года стояния счета на одном месте? А потеряв психическую уверенность вы можете следующий год вообще не торговать, пропустив удачный 20..+1 год. А такое случается постоянно, ведь на рынке никто никому ничего не обещал и важно сохранить уверенность, поэтому для меня, модель которая регулярно, год от года (а еще лучше от месяца к месяцу) генерирует прибыль, пусть в среднем даже меньшую чем другая система, но по принципу "то густо то пусто", обладает большей привлекательностью. Торгующие, отлично понимают этот момент, для не торгующих это может показаться чем то абстрактным, ненужным, неважным...до момента пока они сами не начнут торговать. **"Ликвидная емкость модели"** не имеет значения, если вы мелкий трейдер. Во всех остальных случаях может возникнуть проблема: вы или просто не сможете сформировать нужную вам позицию, либо понесете дополнительные расходы которые связанные с проскальзыванием, которые мы можем выразить в процентах. Если при нехватке ликвидности вы формируете позицию увеличивая проскальзывание, то полбеды что надо как то учесть это при оценке эффективности модели, надо еще держать в голове кота Шредингера - ведь вы двигая цену своими заявками меняете реальность. Поэтому я выберу другой вариант оценки ликвидной эффективности модели, гораздо более жесткий - мы будем набирать позицию до тех пор пока остаемся "невидимыми" - как только новый лот потребует двигать цену, мы прекращаем формировать позицию. От чего будет зависеть "ликвидная емкость модели"? От доли ликвидных бумаг, количества акций по которому будет срабатывать сигнал на покупку, так же он будет зависеть от времени срабатывания сигнала, так как в первый и последний час торгов ликвидность максимальна, в разы превосходя ликвидность в обеденное время. В идеальном случаи лучше оперировать реальными лотами, которые стояли в стакане на момент сделки. Таких данных нет, в их отсутствии, мы воспользуемся проторгованными оборотами накануне, как некое отражение возможности остаться незаметным. Давайте посмотрим как будет уменьшаться прибыльность системы при увеличении размера счета, с этим условием. Осталось только придумать реализацию. У меня она выглядит следующим образом. Допустим в момент t сработал сигнал на покупку k бумаг. Мы начинаем формировать позицию начиная с ценной бумаги в которой модель наиболее уверенна, в размере не более 0,5% от оборота по этой акции за последние 10 часов (цифра в 0,5% дискуссионная, видел например цифру в 0,3%, но так как сделки совершаются в наиболее ликвидную часть торгов, округлим до этой цифры). Если позиция не сформирована в желаемом размере (100% от свободных денежных средств), спускаемся к следующему сигналу итд итп.
```
def liq(pivo, init_count):
data_for_liq = pivo.iloc[:-1,:].copy()
data_for_liq['Date'] = pd.to_datetime(data_for_liq['Date'])
shape_ = data_for_liq.shape[0]
Signal_liquidity = np.array(data_for_liq['Volume_mean_10bars']*10*0.5/100)
Day = np.array(data_for_liq['Date'].dt.date)
Profit = np.array(data_for_liq['profit_1hour'])
Cash_flow = np.zeros(shape=shape_)
Entry_eqiuty = np.zeros(shape=shape_)
Profit_toEquity = np.zeros(shape=shape_)
Profit_toEquity_sum = np.zeros(shape=shape_)
Equity = np.zeros(shape=shape_)
for i in range(data_for_liq.shape[0]):
if i == 0:
Cash_flow[i] = init_count
Entry_eqiuty[i] = min(Signal_liquidity[i], Cash_flow[i])
Profit_toEquity[i] = Profit[i] * Entry_eqiuty[i]/init_count
Profit_toEquity_sum[i] = Profit_toEquity[i]
else:
if Day[i] == Day[i-1]:
Cash_flow[i] = Cash_flow[i-1] - Entry_eqiuty[i-1]
Entry_eqiuty[i] = min(Signal_liquidity[i], Cash_flow[i])
Profit_toEquity[i] = Profit[i] * Entry_eqiuty[i]/init_count
Profit_toEquity_sum[i] = Profit_toEquity_sum[i-1] + Profit_toEquity[i]
else:
Cash_flow[i] = init_count
Entry_eqiuty[i] = min(Signal_liquidity[i], Cash_flow[i])
Profit_toEquity[i] = Profit[i] * Entry_eqiuty[i]/init_count
Profit_toEquity_sum[i] = Profit_toEquity[i]
names = ['Cash_flow', 'Entry_eqiuty', 'Profit_toEquity', 'Profit_toEquity_sum', 'Signal_liquidity', 'Equity']
arrays_ = [Cash_flow, Entry_eqiuty, Profit_toEquity, Profit_toEquity_sum, Signal_liquidity, Equity]
for name, array in zip(names, arrays_):
data_for_liq[str(name)] = array
data_for_liq = data_for_liq[data_for_liq['Cash_flow'] != 0]
data_for_liq.drop_duplicates(subset=['Date'], keep = 'last', inplace = True)
return data_for_liq
```
Данная функция позволяет построить кривую эффективности системы в зависимости от размера счета при условии "невидимости". Меняется число сделок, средняя прибыль на сделку, а в итоге кривая equity. Все предыдущие результаты шли с фильтром по обьему в 400 млн рублей за последние 10 часов, то есть все прежние результаты были справедливы для размера счета до 2\*400\*0,5/100 = 4 млн рублей, ну и учетом курса 10 лет назад и сейчас средневзвешенную можно принять за 7-8 млн..
По Oy прибыль нарастающим итогом в процентах Для разных размеров счета получились следующие кривые:
Что они показывают? Они показывают накопленные проценты прибыли при предельном размере счета, то есть если вы начали с 10 миллионов, то чтобы сохраниться на красной кривой вам нужно все прибыль свыше 10 млн выводить со счета, иначе придется опуститься на более низкую кривую. В лоб это использовать нельзя, но если у вас несколько моделей, то сопоставив их графики вы можете сделать вывод что одна модель более зависима от ликвидности, а другая менее.
### Бонус.
Бонусом для моих читателей (как оказалось у меня уже появляются постоянные читатели, для которых я становлюсь источником некоторых оригинальных идей) напишу как я представляю процесс ценообразования на фондовых рынках. Недавно у меня была беседа в ходе которой был задан такой вопрос. Подозреваю мой ответ был несколько сумбурен, я начал приводить какие то аналогии с машиной, сейчас на спокойную голову я готов пофилософствовать на эту тему более подробно, на том же примере. Мы все знаем что существуют новости, на которые реагируют цены, есть реальная экономика, есть противоположно направленная денежно-кредитная политика центральных банков и министерств финансов (развития), есть люди которые приходят на фондовый рынок, причем с разными целями. Кто то покупает акции в целях извлечения прибыли, кто то выступает в качестве стратегических инвесторов. Для последних, прибыль не является целью, они будут держать акции даже при уверенности в падающих ценах. Ведь обладание акциями дает право голосовать на собраниях акционеров, и какие-нибудь условные немцы будут держать акции какого то условного Газпрома, в каком-нибудь условном 2008 году, потому что это необходимо для их геоэкономических стратегий по обеспечению национальной безопасности. Есть биржа - финансовый институт, который исполняет функцию перераспределения ресурсов, дублируя коммерческие банки, так по крайней мере нам рассказывали в финансовых Вузах. Есть страна где точно такое происходит - это США, где фондовый рынок действительно является, чем то большим чем в России, или любой другой стране мира, и изза истории и изза процента вовлеченных в торговлю населения, и изза активного перераспределения ресурсов. Я намешал все в кучу - новости, реальная экономика, биржа как институт, агенты действующие на рынке (причем у всех интересы разные), экономическая политика государства, регулирующие органы. Где тут причина, где следствие, как это все взаимодействует и где нужно искать прибыль? Представим машину - колеса эти котировки, двигатель это новости, и кабина, в которой сидит стратег. Стратег это тот кто и создает рынок своими решениями, в руках у него коробка передач, дергая рычаги он может подать движение двигателя на колеса или нет. А может подать, но в обратную сторону. А почему так может быть? Стратег точно также видит какую то неожиданную положительную новость, и при выходе ее у него возможность присоединиться к покупкам, но это затруднительно, потому что ему не хватит ликвидность, и тогда зачем ему вместе со всеми вставать в покупку чтобы по итоге набрать на 3% от своего капитала, задрав цену? Поэтому он может остаться в стороне, не подав движение от двигателя на колеса, а может подать реверсивно и рынок не вырастет, а упадет. Я уж не говорю о стратеге-инсайдере, который заранее знает о положительной новости и заранее был в рынке. На положительной новости он будет фиксировать свою прибыль, используя ту ликвидность которую создают мелкие игроки, пытающиеся отыграть положительную новость. Люди желающие торговать на новостях следят за двигателем, они оценивают его мощность, насколько он блестит, как там у него с маслицем и делают вывод что если двигатель в хорошем состоянии, то и колеса будут хорошо двигаться в нужную сторону. А для меня информативней подглядывать в кабину наблюдая за стратегом, потому что там принимается решение. Кроме того состояние двигателя знают все, а во вторых есть такое понятие подгонка решения под задачу - и торгующий на новостях задним числом всегда сможет подогнать под движение на рынке какую то новость, поэтому часто создается ложная иллюзия - "торговать на новостях можно, просто я неправильно проанализировал". Знающих какой то действительно важный инсайд очень мало, все остальные оперируют общедоступной информацией, а общедоступная информация не стоит ничего. А теперь по поводу стратега в кабине - нет никакого стратега, это упрощение, все мы сидим в этой кабине и все передаем движение двигателя на колеса. У кого то большой депозит у кого то маленький, у кого то один уровень страхов и притязаний, у кого то другой, и все слушают новости, перерабатывают их (или думают что перерабатывают), смотрят на котировки, и взаимодействуют друг с другом, с целью извлечения прибыли. Так что не сидит кабине какой то один большой манипулятор, который покручивает усик и думает как бы всех обмануть, все мы там сидим и все изменяем реальность своими действиями. И все наши желания, страхи, невежество перемешиваются и выливают в котировочки. Так что рынок это о теории игр. | https://habr.com/ru/post/651607/ | null | ru | null |
# What's new in CUBA 7
What's new in CUBA 7
====================
Three years ago we announced the second publicly available major version of the framework. [CUBA 6](https://www.cuba-platform.com/blog/whats-new-in-cuba-platform-6-0-and-studio-2-0) was the game-changing version — the licensing was turned from proprietary to Apache 2.0. Those days we couldn't even guess where it was going to bring the framework in long term. CUBA community started to grow exponentially, so we have learned a lot of possible (and sometimes impossible) ways of how developers use the framework. Now we are happy to announce [CUBA 7](https://www.cuba-platform.com/blog/cuba-7-the-new-chapter), which, we hope, will make development more coherent and joyful for all community members from those just starting their journey in CUBA and Java to skilled enterprise developers and Java experts.
Development Tools
-----------------
Obviously, a great part of CUBA success we owe to [CUBA Studio](https://www.cuba-platform.com/development-tools). It has remarkably simplified the overwrought Java enterprise routine, in many places grounding it down to making trivial configurations in the visual designers: no need to know Persistence API or Gradle or even Spring to develop a complete and feature rich CRUD application — Studio will do it for you.
The Studio was a separate web application and this fact caused some significant limitations:
* First of all, Studio was not a fully featured IDE, so developers had to switch between the Studio and IntelliJ IDEA or Eclipse to develop business logic and benefit from convenient navigation, code completion and other essential things, which was annoying.
* Secondly, this magical simplicity was built over massive source code parsing and generation. Improving the code generation capabilities would mean moving towards development of a fully featured IDE — a too ambitious undertaking.
We decided to lean on another giant's shoulder to overcome these limitations. Studio was merged into IntelliJ IDEA by JetBrains. Now you can install it as a plugin for your IntelliJ IDEA or download as a separate standalone bundle.
This opens new horizons:
* Other JVM languages support (and Kotlin in the first place)
* Improved hot deploy
* Intuitive navigation through the entire project
* Smarter hints and code generators
Currently new Studio is under active development: we are porting features from the old version. The short term plan is also to re-implement web based designers using native IntelliJ UI and improve project navigation experience.
Stack Upgrade
-------------
Traditionally, the underlying stack has also been majorly upgraded, e.g. Java 8/11, Vaadin 8, Spring 5.
By default new projects use Java 8, but you can specify the version of Java by adding the following clause to the build.gradle file:
```
subprojects {
sourceCompatibility = JavaVersion.VERSION_11
targetCompatibility = JavaVersion.VERSION_11
}
```
Upgrade to Vaadin 8 was a big challenge because of massive breaking changes in the Vaadin data binding API. Fortunately, CUBA abstracts developers from Vaadin internals by wrapping it into its own API layer. CUBA team did a great job reimplementing internals keeping its own API untouched. This means that compatibility is fully saved and you can benefit from Vaadin 8 right after migrating a project to CUBA 7 without any refactoring.
The full list of updated dependencies is available in the official [release notes](http://files.cuba-platform.com/cuba/release-notes/7.0/#upd_dep).
New Screens API
---------------
This section could also be named "The first screens API" — as CUBA has never had any officially declared API in the web client tier. It comes from the history of the framework and certain assumptions that were made at the first stage:
* Declarative-centric approach — everything that can be described declaratively, should be declared in a screen descriptor and not coded in its controller
* Standard screens (Browser and Editor) provide concrete generic functionality and there is no need to modify it
Since the first thousand members joined our community we realized how wide the variety of requirements for "standard" CRUD screens is — way beyond the initially-designed set of features. Nevertheless, for a long time we were able to handle requests for custom behavior even without an API layer — thanks to another first stage assumption — Open Inheritance. Effectively Open Inheritance means that you can override any public or protected method of an underlying class to tailor its behavior to what you need. This might sound like a cure for all diseases, but in fact it doesn't give you even a short-term contract: what if the overridden method will be renamed, deleted or simply never used in the future versions of the framework?
So, in response to the growing demand from the community we decided to introduce a new screens API. The API provides clear and long-term extension points with no hidden declarative magic, flexible and very easy to use.
### Screen Declaration
In CUBA 7 screen declaration is extremely simple:
```
@UiController("new-screen") // screen id
public class NewScreen extends Screen {
}
```
From the example above we can see that screen identifier is explicitly defined right above the controller class. In other words, screen id and controller class now uniquely correspond to each other. So, good news, now screens can be addressed directly by their controller class in a safe way:
```
@Inject
private ScreenBuilders screenBuilders;
@Subscribe
private void onBeforeClose(BeforeCloseEvent event) {
screenBuilders.screen(this)
.withScreenClass(SomeConfirmationScreen.class)
.build()
.show();
}
```
Screen descriptor becomes a complementary part instead of mandatory. The layout can be created programmatically or declared as an xml screen descriptor, which is defined by the @UiDescriptor annotation over the controller class. This makes controllers and layouting much easier to read and understand — this approach is very similar to the one used in Android development.
Before, it was also required to register a screen descriptor in the web-screens.xml file and assign an identifier to it. In CUBA 7 this file is kept due to compatibility reasons, however, creating screens in a new way does not require such registration.
### Screens Lifecycle
The new API introduces clear and self-explanatory screen lifecycle events:
* Init
* AfterInit
* BeforeShow
* AfterShow
* BeforeClose
* AfterClose
All screen-related events in CUBA 7 can be subscribed as follows:
```
@UiController("new-screen")
public class NewScreen extends Screen {
@Subscribe
private void onInit(InitEvent event) {
}
@Subscribe
private void onBeforeShow(BeforeShowEvent event) {
}
}
```
Comparing new API with the old approach you can see that we are not overriding hook-methods, which are obscurely called in the hierarchy of parent classes, but define logic in clear predefined points of the screen lifecycle.
### Event Handling and Functional Delegates
In the previous section we learned how to subscribe to the lifecycle events, so, what about other components? Should we still scatter all required listeners on screen initialization as it was in 6.x versions? The new API is very uniform, so subscribing to other events is absolutely similar to the lifecycle ones.
Let's take a simple example with two UI elements: a button and a currency field, so its xml descriptor looks like:
```
xml version="1.0" encoding="UTF-8" standalone="no"?
```
By clicking the button we call middleware service returning a number, which goes to the currency field. The currency field should change its style depending on the price value.
```
@UiController("demo_MyFirstScreen")
@UiDescriptor("my-first-screen.xml")
public class MyFirstScreen extends Screen {
@Inject
private PricingService pricingService;
@Inject
private CurrencyField currencyField;
@Subscribe("calcPriceBtn")
private void onCalcPriceBtnClick(Button.ClickEvent event) {
currencyField.setValue(pricingService.calculatePrice());
}
@Subscribe("currencyField")
private void onPriceChange(HasValue.ValueChangeEvent event) {
BigDecimal price = pricingService.calculatePrice();
currencyField.setStyleName(getStyleNameByPrice(price));
}
private String getStyleNameByPrice(BigDecimal price) {
...
}
}
```
In the example above we can see two event handlers: one is invoked when the button is clicked and another one gets executed when the currency field changes its value — as simple as that.
Now, let's imagine that we need to validate our price and check that its value is positive. The straightforward way would be to add a validator while screen initialization:
```
@UiController("demo_MyFirstScreen")
@UiDescriptor("my-first-screen.xml")
public class MyFirstScreen extends Screen {
@Inject
private CurrencyField currencyField;
@Subscribe
private void onInit(InitEvent event) {
currencyField.addValidator(value -> {
if (value.compareTo(BigDecimal.ZERO) <= 0)
throw new ValidationException("Price should be greater than zero");
});
}
}
```
In real world applications a screen entry point usually becomes littered with this kind of screen element initializers. To address this issue CUBA provides the useful annotation `@Install`. Let's see how it can help in our case:
```
@UiController("demo_MyFirstScreen")
@UiDescriptor("my-first-screen.xml")
public class MyFirstScreen extends Screen {
@Inject
private CurrencyField currencyField;
@Install(to = "currencyField", subject = "validator")
private void currencyFieldValidator(BigDecimal value) {
if (value.compareTo(BigDecimal.ZERO) <= 0)
throw new ValidationException("Price should be greater than zero");
}
}
```
In fact we delegate validation logic from our currency field to the *currencyFieldValidator* method in our screen. This might look a bit complicated, however, developers adopt this feature surprisingly fast.
### Screen Builders / Notifications / Dialogs
CUBA 7 also introduces a set of useful components with fluent APIs:
* **ScreenBuilders** combines fluent factories to generate standard lookups, editors and custom screens. The example below shows how you can open one screen from another. Note, that the *build()* method returns the screen instance of the right type, without a need to unsafely cast it.
CurrencyConversions currencyConversions = screenBuilders.screen(this)
.withScreenClass(CurrencyConversions.class)
.withLaunchMode(OpenMode.DIALOG)
.build();
currencyConversions.setBaseCurrency(Currency.EUR);
currencyConversions.show();
* **Screens** component provides a lower level abstraction to creating and showing screens rather than *ScreenBuilders*. It also provides access to the information about all opened screens in your CUBA application (*Screens#getOpenedScreens*) in case if you need to iterate through them.
* **Notifications** and **Dialogs** components both introduce convenient self-explanatory interfaces. Here is an example for creating and showing a dialog and a notification:
dialogs.createOptionDialog()
.withCaption("My first dialog")
.withMessage("Would you like to thank CUBA team?")
.withActions(
new DialogAction(DialogAction.Type.YES).withHandler(e ->
notifications.create()
.withCaption("Thank you!")
.withDescription("We appreciate all community members")
.withPosition(Notifications.Position.MIDDLE\_CENTER)
.withHideDelayMs(3000)
.show()),
new DialogAction(DialogAction.Type.CANCEL)
)
.show();
### Data Binding
CUBA enables extremely fast development of backoffice UIs not only by providing advanced visual tooling with extensive code-generation capabilities, but also by a rich set of data-aware components available right out of the box. Such components just need to know what data they work with and the rest will be managed automatically, e.g. lookup lists, picker fields, various grids with CRUD operations and so on.
Before version 7 data binding was implemented via so-called datasources — objects that wrap a single entity or a collection of entities to reactively tie them with data-aware components. This approach worked very well, however, implementation-wise it was a monolith. The monolithic architecture typically causes problems with its customization, so in CUBA 7 this solid boulder was split into 3 data components:
* **Data loader** is a data provider for data containers. Data loaders don't keep data, they just pass all required query parameters to a data store and feed data containers with the resulting data set.
* **Data container** keeps the loaded data (a single entity or a number of entities) and provides it to the data-aware components in a reactive manner: all changes of the wrapped entities get exposed to the corresponding UI components and visa versa, all changes in the UI components will lead to the corresponding changes in its data container.
* **Data context** is a powerful data modification manager that tracks changes and commits all modified entities. An entity can be merged into a data context, so it will provide a copy of the original entity with the only, but very important difference: all modifications of the resulting entity and all entities it references (including collections) will be tracked, stored and committed accordingly.
Data components can be declared in screen descriptors or instantiated programmatically using a specialized factory — *DataComponents*.
### Miscellaneous
Ufff, the most significant parts of the new screens API are described, so let me briefly list other important features in the web client tier:
* **URL History and Navigation**. This feature solves a very common problem of SPA with “go back” button in a web browser, provides an easy way to assign routes to application screens and enables an API to reflect a current state of a screen in its URL.
* **Form instead of FieldGroup**. [FieldGroup](https://doc.cuba-platform.com/manual-6.10/gui_FieldGroup.html) is a data-aware component to show and modify fields of a single entity. It infers the actual UI shown for a field in runtime. In other words, if you have a *Date* field in your entity it will be shown as a *[DateField](https://doc.cuba-platform.com/manual-6.10/gui_DateField.html)*. However, if you would like to operate with this field programmatically, you will need to inject this field to the screen controller and cast it to the right type manually (*DateField in our example*). Later on we change our field type to some other and our application crashes at runtime… Form addresses this issue by explicit field type declaration. Find more information about this new component [here](https://doc.cuba-platform.com/manual-7.0/gui_Form.html).
* **Third party JavaScript components integration** is significantly simplified, follow [the documentation](https://doc.cuba-platform.com/manual-7.0/jsComponent.html) to embed custom JavaScript components into a CUBA application.
* **HTML / CSS** attributes now can be easily defined right from the xml screen descriptor or set programmatically. Find more information [here](https://doc.cuba-platform.com/manual-7.0/gui_attributes.html#gui_attr_css).
Middleware Features
-------------------
The previous block about the new screens API was larger than I expected, so in this section I'll try to be neat!
### Entity Changed Event
Entity Changed Event is a Spring application event that is fired when your entity made its way to a data store, got physically inserted and is within an inch of being committed. Here you can provide some additional checks (e.g. check product availability in stock before confirming an order) and modify it (e.g. recalculate totals) right before it will be visible for other transactions (of course with read committed isolation level). You can also use this event as the last chance to interrupt the transaction from being committed by throwing an exception — which might be useful in some corner cases.
There is also a way to catch the Entity Changed Event right after commit has happened.
Follow [this chapter](https://doc.cuba-platform.com/manual-7.0/entityChangedEvent.html) of the documentation to see an example.
### Transactional Data Manager
When developing an application we normally operate with detached entities — the ones which are not managed by any transaction. However, working with detached entities is not always possible, especially when trying to meet ACID requirements — this is the case when you can use the transactional data manager. It looks very similar to the ordinary data manager, but differs in the following aspects:
* It can join existing transaction (in case it is called under transactional context) or create its own transaction.
* It has no *commit* method, but there is the save method, which doesn't lead to immediate commit, but waits until the attached transaction will be committed.
Find an example of using it [here](https://doc.cuba-platform.com/manual-7.0/transactionalDataManager.html).
### JPA Lifecycle Callbacks
Finally, CUBA 7 supports JPA lifecycle callbacks. To not replicate a well-written information about what these callbacks can be used for, let me just share [this link](https://docs.oracle.com/cd/E16439_01/doc.1013/e13981/undejbs003.htm#CIHCJGGJ), which fully covers the subject.
What about Compatibility?
-------------------------
A fair question for any major release, especially when there are so many seemingly breaking changes! We have designed all these new features and APIs keeping in mind the backward compatibility:
* The old screens API is supported in CUBA 7 and is implemented via the new one under the hood :)
* We have also provided adapters for the old data binding, which keep working for the old fashioned screens.
So, good news, the migration path from version 6 to 7 should be quite straightforward.
Conclusion
----------
Concluding this technical overview I would like to mention that there are other important innovations, especially with licensing:
* The 10 entities limit for Studio is now gone
* Reporting, BPM, Charts and Maps and Full text search addons are now free and open source.
* The commercial version of Studio brings extra development comfort with visual designers for entities, screens, menus, and other platform elements, while the free version focuses on working with code
* Please not that for 6.x and older versions of the Platform and Studio licensing terms remain the same!
Finally, let me thank the community members again for all the support and feedback. I hope you will love version 7! The full list of changes is traditionally available in the [release notes](http://files.cuba-platform.com/cuba/release-notes/7.0/). | https://habr.com/ru/post/444558/ | null | en | null |
# Как создать несколько магазинов, используя одну установку Magento
Это вольный перевод [вот этой статьи](http://www.crucialwebhost.com/blog/how-to-setup-multiple-magento-stores/). Статья предназначена для людей, знакомых с Magento, поэтому многие элементарные вещи из оригинальной статьи были опущены. Существует несколько реализаций решения этой задачи:
* Как поддиректории основного сайта, например,
+ mall.com/shoes
+ mall.com/shirts
* Использование разных доменных имен, например,
+ shoes.com
+ shirts.com
* Использование поддоменов основного сайта, например,
+ mall.com
+ shoes.mall.com
+ shirts.mall.com
В результате получится несколько магазинов, использующих один и тот же код, и управляемых из одной админки.
Добавление еще одного магазина в Magento
----------------------------------------
Для начала необходимо создать корневую категорию для нового магазина, сделать ее активной и установить значение атрибута **Is Anchor** в **Yes**. Далее переходим в раздел админки **System -> Manage Stores** и создаем новые **Website**, **Store** и **Store View**. Подробней на примере:
**Website:**
* Имя – Shoes
* Код – shoes
**Store:**
* Имя – Main Store
* Из списка Website выбираем Shoes
* Из списка Root Category выбирает корневую категорию, созданную ранее.
**Store View:**
* Из списка Store выбираем Main Store
* Имя — English (не принципиально, можно написать, что угодно)
* Код – shoes\_en
* Status – Enabled
Дополнительные магазины создаются аналогично.
Теперь необходимо указать базовые URL’ы для нового магазина. Переходим в раздел **System -> Configuration**. **Current Configuration Scope** (расположен слева вверху) меняем значение **Default Config** на **Shoes**. На вкладке **Web** в секциях **Secure** и **Unsecure** указываем **Base URL**. Для каждого случая этот URL будет различным, для примера:
* Поддиректории – http://mall.com/shoes/
* Для доменных имен 2-го уровня http://shoes.com/
* Для доменных имен 3-го уровня http://shoes.mall.com/
Завершающий слеш в каждом URL’е обязателен.
Для того, чтобы можно было уже обращаться по этим URL’ам нужно сделать следующее:
Поддиректори
------------
Итак, нужно, чтобы наш магазин находился в подиректории основного сайта.
Для этого необходимо в корне Magento создать подкаталог shoes и скопировать туда файлы *.htaccess* и *index.php* из корневого каталога Magento. После чего нужно отредактировать файл *index.php*. Ищем строку *$mageFilename = 'app/Mage.php'* и указываем правильный путь к файлу *Mage.php*. В данном случае это *$mageFilename = '../app/Mage.php'*. Еще необходимо добавить два параметра в вызов метода *Mage::run()*.
Исправляем
*Mage::run();*
на
*Mage::run('shoes', 'website');*
После этого можно обращаться к магазину Shoes по адресу http://mall.com/shoes/.
Очень подробно эта часть обьясняется в следующих 2-х видео:
* <http://www.magentocommerce.com/magento-on-the-fly/multiple-sites/>
* [http://www.magentocommerce.com/magento-on-the-fly/multiple-sites2/](http://www.magentocommerce.com/magento-on-the-fly/multiple-sites2)
Доменные имена
--------------
Так как, по сути, у нас будет несколько доменных имен, привязанных к одному серверу, на котором установлена Magento, то придется править уже оригинальный файл index.php. Итак, заменим строку
*Mage::run();*
на
> `1. switch($\_SERVER['HTTP\_HOST']) {
> 2. case 'shoes.com':
> 3. case 'www.shoes.com':
> 4. Mage::run('shoes', 'website');
> 5. break;
> 6. default:
> 7. Mage::run();
> 8. break;
> 9. }`
Для большего количества магазинов нужно код изменить следующим образом:
> `1. switch($\_SERVER['HTTP\_HOST']) {
> 2.
> 3. // Shoes.com
> 4. case 'shoes.com':
> 5. case 'www.shoes.com':
> 6. Mage::run('shoes', 'website');
> 7. break;
> 8.
> 9. // Hats.com
> 10. case 'hats.com':
> 11. case 'www.hats.com':
> 12. Mage::run('hats', 'website');
> 13. break;
> 14.
> 15. // Shirts.com (default store)
> 16. default:
> 17. Mage::run();
> 18. break;
> 19. }`
В общем-то и все. После этих манипуляций магазин будет доступен по адресу http://shoes.com/.
Поддомены
---------
У нас есть основной домен mall.com, нужно поднять 2-й магазин на поддомене shoes.mall.com. Я надеюсь, что все необходимое для конфигурации поддомена уже сделано на хостинге, поэтому перейдем к созданию магазина на этом поддомене.
Как на этапе с поддиректориями необходимо скопировать файлы .htaccess и index.php из корневого каталога Magento в корневой каталог поддомена, после чего можно приступить к редактированию файла *index.php*. Первое, что нужно сделать – это указать в файле *index.php*, где лежить файл *Mage.php*. Итак, заменим в файле *index.php*, строку
*$mageFilename = 'app/Mage.php';*
на
*$mageFilename = '../public\_html/app/Mage.php';*
У вас этот путь может быть другим, все зависит от расположения каталогов доменов на вашем хостинге оносительно друг друга.
Далее нужно заменить код *Mage::run()* на *Mage::run('shoes', 'website')*, чтобы движок Magento знал, какой из магазинов нужно запускать. И последнее, что нужно сделать – создать символьные ссылки на все основные директории Magento:
> ln -s ../public\_html/404/ ./404
>
> ln -s ../public\_html/app/ ./app
>
> ln -s ../public\_html/includes/ ./includes
>
> ln -s ../public\_html/js/ ./js
>
> ln -s ../public\_html/media/ ./media
>
> ln -s ../public\_html/report/ ./report
>
> ln -s ../public\_html/skin/ ./skin
>
> ln -s ../public\_html/var/ ./var
>
>
Теперь магазин будет доступен по адресу http://shoes.mall.com/.
В итоге мы получаем несколько магазинов, управляемых одной установленной системой с любым содержимым, т.е. контент этих магазинов может быть связан между собой, либо не иметь ничего общего. Каждый может использовать тот метод, который ему удобней, результат, в конечном итоге, будет идентичным. Основное преимущество тут – это удобство управления несколькими магазинами и экономия времени менеджеров магазинов. | https://habr.com/ru/post/91611/ | null | ru | null |
# ActivityLifecycleCallbacks — слепое пятно в публичном API
С детства я люблю читать инструкции. Я вырос, но меня до сих пор удивляет то, как взрослые люди безалаберно относятся к инструкциям: многие из них считают, что все знают, и при этом пользуются одной-двумя функциями, в то время как их намного больше! Кто из вас пользовался функцией поддержания температуры в микроволновке? А она есть почти в каждой.
Однажды я решил почитать документацию к различным классам Android framework. Пробежался по основным классам: View, Activity, Fragment, Application, — и меня очень заинтересовал метод [Application.registerActivityLifecycleCallbacks()](https://developer.android.com/reference/android/app/Application.html#registerActivityLifecycleCallbacks(android.app.Application.ActivityLifecycleCallbacks)) и интерфейс [ActivityLifecycleCallbacks](https://developer.android.com/reference/android/app/Application.ActivityLifecycleCallbacks.html). Из примеров его использования в интернете не нашлось ничего лучше, чем логирование жизненного цикла Activity. Тогда я начал сам экспериментировать с ним, и теперь мы в Яндекс.Деньгах активно используем его при решении целого спектра задач, связанных с воздействием на объекты Activity снаружи.
Что такое ActivityLifecycleCallbacks?
=====================================
Посмотрите на этот интерфейс, вот как он выглядел, когда появился в API 14:
```
public interface ActivityLifecycleCallbacks {
void onActivityCreated(Activity activity, Bundle savedInstanceState);
void onActivityStarted(Activity activity);
void onActivityResumed(Activity activity);
void onActivityPaused(Activity activity);
void onActivityStopped(Activity activity);
void onActivitySaveInstanceState(Activity activity, Bundle outState);
void onActivityDestroyed(Activity activity);
}
```
**Начиная с API 29 в него добавили несколько новых методов**
```
public interface ActivityLifecycleCallbacks {
default void onActivityPreCreated(
@NonNull Activity activity,
@Nullable Bundle savedInstanceState) { }
void onActivityCreated(
@NonNull Activity activity,
@Nullable Bundle savedInstanceState);
default void onActivityPostCreated(
@NonNull Activity activity,
@Nullable Bundle savedInstanceState) { }
default void onActivityPreStarted(@NonNull Activity activity) { }
void onActivityStarted(@NonNull Activity activity);
default void onActivityPostStarted(@NonNull Activity activity) { }
default void onActivityPreResumed(@NonNull Activity activity) { }
void onActivityResumed(@NonNull Activity activity);
default void onActivityPostResumed(@NonNull Activity activity) { }
default void onActivityPrePaused(@NonNull Activity activity) { }
void onActivityPaused(@NonNull Activity activity);
default void onActivityPostPaused(@NonNull Activity activity) { }
default void onActivityPreStopped(@NonNull Activity activity) { }
void onActivityStopped(@NonNull Activity activity);
default void onActivityPostStopped(@NonNull Activity activity) { }
default void onActivityPreSaveInstanceState(
@NonNull Activity activity,
@NonNull Bundle outState) { }
void onActivitySaveInstanceState(
@NonNull Activity activity,
@NonNull Bundle outState);
default void onActivityPostSaveInstanceState(
@NonNull Activity activity,
@NonNull Bundle outState) { }
default void onActivityPreDestroyed(@NonNull Activity activity) { }
void onActivityDestroyed(@NonNull Activity activity);
default void onActivityPostDestroyed(@NonNull Activity activity) { }
}
```
Возможно, этому интерфейсу уделяют так мало внимания, потому что он появился только в Android 4.0 ICS. А зря, ведь он позволяет нативно делать очень интересную вещь: воздействовать на все объекты Activity снаружи. Но об этом позже, а сначала внимательнее посмотрим на методы.
Каждый метод отображает аналогичный метод жизненного цикла Activity и вызывается в тот момент, когда метод срабатывает на какой-либо Activity в приложении. То есть если приложение запускается с MainActivity, то первым мы получим вызов ActivityLifecycleCallback.onActivityCreated(MainActivity, null).
Отлично, но как это работает? Тут никакой магии: Activity сами сообщают о том, в каком они состоянии. Вот кусочек кода из Activity.onCreate():
```
mFragments.restoreAllState(p, mLastNonConfigurationInstances != null
? mLastNonConfigurationInstances.fragments : null);
}
mFragments.dispatchCreate();
getApplication().dispatchActivityCreated(this, savedInstanceState);
if (mVoiceInteractor != null) {
```
Это выглядит так, как если бы мы сами сделали BaseActivity. Только коллеги из Android сделали это за нас, еще и обязали всех этим пользоваться. И это очень даже хорошо!
В API 29 эти методы работают почти так же, но их Pre- и Post-копии честно вызываются до и после конкретных методов. Вероятно, теперь этим управляет ActivityManager, но это только мои догадки, потому что я не углублялся в исходники достаточно, чтобы это выяснить.
Как заставить ActivityLifecycleCallbacks работать?
--------------------------------------------------
Как и все callback, сначала их надо зарегистрировать. Мы регистрируем все ActivityLifecycleCallbacks в Application.onCreate(), таким образом получаем информацию обо всех Activity и возможность ими управлять.
```
class MyApplication : Application() {
override fun onCreate() {
super.onCreate()
registerActivityLifecycleCallbacks(MyCallbacks())
}
}
```
Небольшое отступление: начиная с API 29 ActivityLifecycleCallbacks можно зарегистрировать еще и изнутри Activity. Это будет [локальный callback](https://developer.android.com/reference/android/app/Activity.html#registerActivityLifecycleCallbacks(android.app.Application.ActivityLifecycleCallbacks)), который работает только для этого Activity.
Вот и все. Но это вы можете найти, просто введя название ActivityLifecycleCallbacks в строку поисковика. Там будет много примеров про логирование жизненного цикла Activity, но разве это интересно? У Activity много публичных методов (около 400), и все это можно использовать для того, чтобы делать много интересных и полезных вещей.
Что с этим можно сделать?
-------------------------
А что вы хотите? Хотите динамически менять тему во всех Activity в приложении? Пожалуйста: метод setTheme() — публичный, а значит, его можно вызывать из ActivityLifecycleCallback:
```
class ThemeCallback(
@StyleRes val myTheme: Int
) : ActivityLifecycleCallbacks {
override fun onActivityCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
activity.setTheme(myTheme)
}
}
```
**Повторяйте этот трюк ТОЛЬКО дома**
Какие-то Activity из подключенных библиотек могут использовать свои кастомные темы. Поэтому проверьте пакет или любой другой признак, по которому можно определить, что тему этой Activity можно безопасно менять. Например, проверяем пакет так (по-котлиновски =)):
```
class ThemeCallback(
@StyleRes val myTheme: Int
) : ActivityLifecycleCallbacks {
override fun onActivityCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
val myPackage = "my.cool.application"
activity
.takeIf { it.javaClass.name.startsWith(myPackage) }
?.setTheme(myTheme)
}
}
```
Пример не работает? Возможно, вы забыли зарегистрировать ThemeCallback в Application или Application в AndroidManifest.
Хотите еще интересный пример? Можно показывать диалоги на любой Activity в приложении.
```
class DialogCallback(
val dialogFragment: DialogFragment
) : Application.ActivityLifecycleCallbacks {
override fun onActivityCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
if (savedInstanceState == null) {
val tag = dialogFragment.javaClass.name
(activity as? AppCompatActivity)
?.supportFragmentManager
?.also { fragmentManager ->
if (fragmentManager.findFragmentByTag(tag) == null) {
dialogFragment.show(fragmentManager, tag)
}
}
}
}
}
```
**Повторяйте этот трюк ТОЛЬКО дома**
Конечно же, не стоит показывать диалог на каждом экране — наши пользователи не будут нас любить за такое. Но иногда может быть полезно показать что-то такое на каких-то конкретных экранах.
А вот еще кейс: что, если нам надо запустить Activity Тут все просто: Activity.startActivity() — и погнали. Но что делать, если нам надо дождаться результата после вызова Activity.startActivityForResult()? У меня есть один рецепт:
```
class StartingActivityCallback : Application.ActivityLifecycleCallbacks {
override fun onActivityCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
if (savedInstanceState == null) {
(activity as? AppCompatActivity)
?.supportFragmentManager
?.also { fragmentManager ->
val startingFragment = findOrCreateFragment(fragmentManager)
startingFragment.listener = { resultCode, data ->
// handle response here
}
// start Activity inside StartingFragment
}
}
}
private fun findOrCreateFragment(
fragmentManager: FragmentManager
): StartingFragment {
val tag = StartingFragment::class.java.name
return fragmentManager
.findFragmentByTag(tag) as StartingFragment?
?: StartingFragment().apply {
fragmentManager
.beginTransaction()
.add(this, tag)
.commit()
}
}
}
```
В примере мы просто закидываем Fragment, который запускает Activity и получает результат, а потом делегирует его обработку нам. Будьте осторожны: тут мы проверяем, что наша Activity является AppCompatActivity, что может привести бесконечному циклу. Используйте другие условия.
Усложним примеры. До этого момента мы использовали только те методы, которые уже есть в Activity. Как насчет того, чтобы добавить свои? Допустим, мы хотим отправлять аналитику об открытии экрана. При этом у наших экранов свои имена. Как решить эту задачу? Очень просто. Создадим интерфейс Screen, который сможет отдавать имя экрана:
```
interface Screen {
val screenName: String
}
```
Теперь имплементируем его в нужных Activity:
```
class NamedActivity : Activity(), Screen {
override val screenName: String = "First screen"
}
```
После этого натравим на такие Activity специальные ActivityLifecycleCallback’и:
```
class AnalyticsActivityCallback(
val sendAnalytics: (String) -> Unit
) : Application.ActivityLifecycleCallbacks {
override fun onActivityCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
if (savedInstanceState == null) {
(activity as? Screen)?.screenName?.let(sendAnalytics)
}
}
}
```
Видите? Мы просто проверяем интерфейс и, если он реализован, отправляем аналитику.
Повторим для закрепления. Что делать, если надо прокидывать еще и какие-то параметры? Расширим интерфейс:
```
interface ScreenWithParameters : Screen {
val parameters: Map
}
```
Имплементируем:
```
class NamedActivity : Activity(), ScreenWithParameters {
override val screenName: String = "First screen"
override val parameters: Map = mapOf("key" to "value")
}
```
Отправляем:
```
class AnalyticsActivityCallback(
val sendAnalytics: (String, Map?) -> Unit
) : Application.ActivityLifecycleCallbacks {
override fun onActivityCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
if (savedInstanceState == null) {
(activity as? Screen)?.screenName?.let { name ->
sendAnalytics(
name,
(activity as? ScreenWithParameters)?.parameters
)
}
}
}
}
```
Но это все еще легко. Все это было только ради того, чтобы подвести вас к по-настоящему интересной теме: нативное внедрение зависимостей. Да, у нас есть Dagger, Koin, Guice, Kodein и прочее. Но на небольших проектах они избыточны. Но у меня есть решение… Угадайте какое?
Допустим, у нас есть некоторый инструмент, вроде такого:
```
class CoolToolImpl {
val extraInfo = "i am dependency"
}
```
Закроем его интерфейсом, как взрослые программисты:
```
interface CoolTool {
val extraInfo: String
}
class CoolToolImpl : CoolTool {
override val extraInfo = "i am dependency"
}
```
А теперь немного уличной магии от ActivityLifecycleCallbacks: мы создадим интерфейс для внедрения этой зависимости, реализуем его в нужных Activity, а с помощью ActivityLifecycleCallbacks найдем его и внедрим реализацию CoolToolImpl.
```
interface RequireCoolTool {
var coolTool: CoolTool
}
class CoolToolActivity : Activity(), RequireCoolTool {
override lateinit var coolTool: CoolTool
}
class InjectingLifecycleCallbacks : ActivityLifecycleCallbacks {
override fun onActivityCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
(activity as? RequireCoolTool)?.coolTool = CoolToolImpl()
}
}
```
Не забудьте зарегистрировать InjectingLifecycleCallbacks в вашем Application, запускайте — и все работает.
И не забудьте протестировать:
```
@RunWith(AndroidJUnit4::class)
class DIActivityTest {
@Test
fun `should access extraInfo when created`() {
// prepare
val mockTool: CoolTool = mock()
val application = getApplicationContext()
application.registerActivityLifecycleCallbacks(
object : Application.ActivityLifecycleCallbacks {
override fun onActivityCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
(activity as? RequireCoolTool)?.coolTool = mockTool
}
})
// invoke
launch(Intent(application, DIActivity::class.java))
// assert
verify(mockTool).extraInfo
}
}
```
Но на больших проектах такой подход будет плохо масштабироваться, поэтому я не собираюсь отбирать ни у кого DI-фреймворки. Куда лучше объединить усилия и достигнуть синергии. Покажу на примере Dagger2. Если у вас в проекте есть какая-то базовая Activity, которая делает что-то вроде AndroidInjection.inject(this), то пора ее выкинуть. Вместо этого сделаем следующее:
1. по инструкции внедряем DispatchingAndroidInjector в Application;
2. создаем ActivityLifecycleCallbacks, который вызывает DispatchingAndroidInjector.maybeInject() на каждой Activity;
3. регистрируем ActivityLifecycleCallbacks в Application.
```
class MyApplication : Application() {
@Inject lateinit var dispatchingAndroidInjector: DispatchingAndroidInjector
override fun onCreate() {
super.onCreate()
DaggerYourApplicationComponent.create().inject(this);
registerActivityLifecycleCallbacks(
InjectingLifecycleCallbacks(
dispatchingAndroidInjector
)
)
}
}
class InjectingLifecycleCallbacks(
val dispatchingAndroidInjector: DispatchingAndroidInjector
) : ActivityLifecycleCallbacks {
override fun onActivityCreated(
activity: Activity,
savedInstanceState: Bundle?
) {
dispatchingAndroidInjector.maybeInject(activity)
}
}
```
И такого же эффекта можно добиться с другими DI-фреймворками. Попробуйте и напишите в комментариях, что получилось.
Подведем итоги
--------------
ActivityLifecycleCallbacks — это недооцененный, мощный инструмент. Попробуйте какой-нибудь из [этих примеров](https://github.com/yandex-money/android-activitylifecyclecallbacks-example), и пусть они помогут вам в ваших проектах так же, как помогают Яндекс.Деньгам делать наши приложения лучше. | https://habr.com/ru/post/482476/ | null | ru | null |
# Аудит информационной безопасности. XCCDF и OVAL
> Серия статей об автоматизации аудита безопасности.
>
> [1. Аудит информационной безопасности. SCAP ликбез](https://habr.com/ru/post/537974/)
>
> **2. Аудит информационной безопасности. XCCDF и OVAL**
>
> 3. OpenSCAP. Настройка и использование. *Ожидается.*
>
>
Аудит информационной безопасности — это оценка состояния системы. Аудитор ищет уязвимости и проверяет, насколько система соответствует требованиям. Аудит сложный и долгий процесс: эксперту нужно проверить сотни параметров в сотнях систем. К счастью, аудит можно автоматизировать.
Проблема в том, что требования к системам создает человек. Рабочая группа или руководитель пишет документ. В обычном случае аудитор читает документ и вручную проверяет систему. Для автоматизации нужны четкие инструкции, но бумажный документ не понятен программе.
В 2009 году NIST разработал спецификацию SCAP. Спецификация описывает, как перевести высокоуровневые требования в формализованный вид. Формализованные требования или SCAP-контент состоит из двух основных элементов: языки XCCDF и OVAL. Языки XCCDF и OVAL понятны машине. С использованием SCAP-контента систему проверяет специальное приложение — SCAP-интерпретатор.
> Далее на основе CIS Benchmark разберем документы XCCDF и OVAL. Некоторые детали я намеренно опущу. Это позволит упростить изложение, но базовой логики не нарушит.
>
> Рисунок ниже представляет структуру этих документов. Обращайтесь к нему по ходу чтения.
>
>
Схема XCCDF и OVAL в CIS BenchmarkeXtensible Configuration Checklist Description Format
-----------------------------------------------------
Язык XCCDF выполняет две функции: описывает контрольные списки настроек безопасности и связывает другие компоненты SCAP.
Контрольные списки состоят из элементов — чекбоксов. Один элемент контрольного списка — это одно требование к системе. XCCDF не содержит инструкций для выполнения SCAP-интерпретатором, поэтому каждая запись из контрольного списка ссылается на другие компоненты SCAP, которые инструкции содержат.
Документ XCCDF состоит из трех элементов: групп, правил и значений. Каждый элемент содержит два информационных поля: заголовок и описание. Эти поля дают понять, для чего элемент предназначен.
### Эталон (Benchmark)
Типичная структура эталонаЭталон — это контейнер для групп, правил и значений. В документе XCCDF эталон содержится в одном экземпляре. Поэтому документ и эталон тождественны.
В примере ниже эталон предназначен для аудита Windows 7 по требованиям STIG.
```
Win7 Audit
The Windows 7 Security Technical Implementation Guide (STIG) is published as a tool to improve the security of Department of Defense (DoD) information systems. The requirements were developed from DoD consensus, as well as the Windows 7 Security Guide and security templates published by Microsoft Corporation.
--- data omitted ---
```
### Профиль (Profile)
Профиль объединяет требования конкретного стандарта или политики. Например «Аудит журналов» или «Стандартный профиль безопасности системы для Ubuntu».
Каждый профиль наполняют ссылки на группы. Профиль соответствует стандарту в зависимости от указанных в нем групп.
В примере ниже профиль имеет только одну группу idref="V-15706″. Этот же профиль в полном CIS Benchmark — 266 групп.
> Обратите внимание на selected="true". Этот селектор включает и исключает группы из проверки. В примере группа V-15706 должна быть проверена при аудите по профилю MAC-3\_Sensitive.
>
>
```
III - Administrative Sensitive
ProfileDescription
```
Группа ниже оценивает управление питанием. В частности, проверяет запрос пароля при пробуждении системы. Для проверки группа содержит правило SV-25168r1\_rule.
```
Power Mgmt – Password Wake When Plugged In
GroupDescription
--- data omitted ---
```
### Правило (Rule)
Правило детализирует проверку. Правило SV-25168r1\_rule ниже содержит три ссылки: переменная password-require внутри документа, экспортируемая переменная var:381700 и определение def:3817 в связанном документе OVAL.
Значение внутренней переменной password-require должно быть присвоено экспортируемой переменной var:381700.
```
Password is required on resume from sleep (plugged in).
This check verifies that the user is prompted for a password on resume from sleep (Plugged In)
Configure the policy value for Computer Configuration - Administrative Templates > System > Power Management > Sleep Settings “Require a Password When a Computer Wakes (Plugged In)” to “Enabled”.
```
Важное поле — fixtext. Оно информирует от том, что делать при невыполнении правила.
Поле fixtext выше указывает, что требуется установить значение «Enabled» в Administrative Templates > System > Power Management > Sleep Settings «Require a Password When a Computer Wakes (Plugged In)».
### Переменная (Value)
```
1
0
1
```
Внутренняя переменная принимает значения по умолчанию или в зависимости от селектора в профиле. В примере выше переменная равна единице, потому что селектор указывал selected="true". Это значит, что переменная var:381700 также равна единице.
Документы XCCDF и OVAL связаны. Их связывают две вещи: ссылки на конкретные определения и экспортируемые переменные. В примере — это ссылка на определение def:3817 и переменная var:381700.
> После обработки интерпретатором документа XCCDF — очередь OVAL. В документе OVAL интерпретатор разберет определения, перечисленные в профиле XCCDF.
>
>
Open Vulnerability and Assessment Language
------------------------------------------
Структура документа OVALOVAL (Open Vulnerability and Assessment Language) — декларативный язык логических утверждений. OVAL описывает уязвимости и необходимое состояние конфигурации системы.
OVAL состоит из пяти элементов: определений, критериев, тестов, объектов и состояний.
### Определение (Definition)
Определение — главный элемент. Определение включает остальные элементы: критерии, тесты, объекты и состояния.
Следующий элемент в иерархии — критерии. Критерии — логические выражения, которые с помощью булевой логики (И, ИЛИ, НЕ) оценивают результаты включенных тестов.
Тесты возвращают результаты булева типа (true/false), поэтому определения также будут возвращать результаты булева типа.
Логический оператор И (operator="AND") в примере ниже не играет никакой роли, потому что определение содержит только один тест tst:381700.
> Для формализации сложных требований нужны сложные логические выражения. Такие выражения строятся с помощью иерархии критериев и тестов.
>
> Еще более сложные требования формализуются с помощью [языка OCIL](https://csrc.nist.gov/Projects/Security-Content-Automation-Protocol/Specifications/ocil). Язык предполагает участие человека в проведении тестов.
>
>
```
"Require a Password when a Computer Wakes (Plugged)"
Microsoft Windows 7
"Require a Password when a Computer Wakes (Plugged)"
```
### Тест (Test)
Главная задача теста — сопоставление текущего состояния объекта с требуемым.
> Объекты, тесты и состояния бывают различных типов. Типы определены спецификацией и зависят от проверяемой системы.
>
> Например. Тип group\_sid для Windows анализирует пользователей и подгруппы по SID идентификатору. А тип dpkginfo для Linux находит информацию о заданном DPKG пакете. Тип textfilecontent не зависит от системы и проверяет содержимое текстового файла.
>
>
В примере ниже указан тип registry. Этот тип работает с записями реестра Windows.
Тест registry\_test ссылается на объект obj:381700 и состояние ste:381700. Для получения результатов теста нужно проверить все указанные объекты (check="all"), при этом хотя бы один должен существовать (check\_existence="at\_least\_one\_exists").
```
```
### Объект (Object)
Перечень возможных объектов многообразен. Перечень включает записи в реестре, идентификаторы пользователя и маркеры доступа, события аудита и т.д.
В примере ниже registry\_object это конкретное значение в реестре Windows: HKEY LOCAL MACHINE > Software\Policies\Micro… > ACSettingIndex.
```
HKEY\_LOCAL\_MACHINE
Software\Policies\Microsoft\Power\PowerSettings\0e796bdb-100d-47d6-a2d5-f7d2daa51f51
ACSettingIndex
```
### Состояние (State)
Этот компонент задает требуемое состояние объекта. Состояние может быть задано статически или определяться через переменную.
В примере ниже состояние определяется переменной var:381700.
Каждый объект специфичен. Это значит, что объект registry\_object возможно сравнить только с состоянием registry\_state с помощью теста registry\_test.
```
reg\_dword
```
### Переменная (Variable)
Переменная хранит некоторое значение. Значение задается статически или определяется динамически из XCCDF.
В примере ниже значение [переменной var:381700](#2) экспортировано из XCCDF и равно единице.
```
0
1
```
Итог
----
Стандарты формализации высокоуровневых требований помогают автоматизировать аудит безопасности. Требования интерпретируются однозначно, поэтому результаты аудита не зависят от конкретного сканера. Оценка становятся понятной, а причины несоответствия — очевидными.
Процесс автоматизации аудита читайте в [первой статье цикла](https://habr.com/ru/post/537974/).
#### P.S.
Рассмотренные документы в сборе под спойлером. Полные версии ищите на [сайте CIS](https://www.cisecurity.org/).
Win7Audit\_Benchmark-xccddf.xml
```
Win7 Audit
The Windows 7 Security Technical Implementation Guide (STIG) is published as a tool to improve the security of Department of Defense (DoD) information systems. The requirements were developed from DoD consensus, as well as the Windows 7 Security Guide and security templates published by Microsoft Corporation.
III - Administrative Sensitive
ProfileDescription
Power Mgmt – Password Wake When Plugged In
GroupDescription
Password is required on resume from sleep (plugged in).
This check verifies that the user is prompted for a password on resume from sleep (Plugged In)
Configure the policy value for Computer Configuration - Administrative Templates > System > Power Management > Sleep Settings “Require a Password When a Computer Wakes (Plugged In)” to “Enabled”.
1
0
1
```
Win7Audit\_Benchmark-oval.xml
```
Require a Password when a Computer Wakes (Plugged)
Microsoft Windows 7
Require a Password when a Computer Wakes (Plugged)
HKEY\_LOCAL\_MACHINE
Software\Policies\Microsoft\Power\PowerSettings\0e796bdb-100d-47d6-a2d5-f7d2daa51f51
ACSettingIndex
reg\_dword
0
1
``` | https://habr.com/ru/post/538764/ | null | ru | null |
# Немного OSM и OpenLayers для корпоративных систем
Привет Хабр, сегодня я расскажу немного про использование osm для предприятий и b2b.
А именно, как и зачем перейти от google maps api к osm, openlayers и счастью.
##### Первый вопрос, который непременно возникнет: зачем?
Начнем с того, что использование google maps api для непубличных сервисов ограничено условиями предоставления сервиса. Второе: апи карт гугл — это именно апи карт гугл, а не апи для отображения всего, что напоминает карту. Т.е. если вам захотелось отображать другую подложку или добавить растровый слой, отрисовываемый сервером в локальной сети предприятия, готовтесь лепить костыли. Ну и просто будьте готовы, что если чего-то в апи нет, добавлять будет мучительно. Третье: вы не можете получить данные карты, соответсвенно, вы не можете создать локальный картографический сервис для сотрудников предприятия. То есть с каждой клиентской машины должны быть доступны карты гугл. Звучит диковато, но далеко не всегда сотрудникам открыт доступ во внешние сети.
##### Предположим, я вас убедил. С чего начать?
Первое, подключаем карту в openlayers. Тут все просто и мало чем отличается от google, yandex, leaflet.
```
// создаем карту, использовав в качестве контейнера элемент с id='map'
var map = new OpenLayers.Map('map');
// создаем слой с типом OSM и именем "OSM mapnik"
var layer = new OpenLayers.Layer.OSM('OSM mapnik');
//добавляем слой на карту
map.addLayer(layer);
//выставляем зум и центр карты, таким образом, чтобы поместился весь мир.
map.zoomToMaxExtent();
```
Крупные компании зачастую могут себе позволить купить картографический сервер и карты и раздавать их в локальной сети через wms или tms. WMS и TMS — это стандарты, по которым вы можете получить кусочки изображения карт. Основное отличие: по wms вы можете запросить произвольный кусочек карты произвольного масштаба, по tms — набор масштабов и деление карты на квадратики, которые могут быть получены фиксированно.
Соответсвенно, меняем строку создания слоя для wms на
```
//Создаем новый слой типа WMS
var wms = new OpenLayers.Layer.WMS(
//имя слоя для контрола выбора слоев
"NASA Global Mosaic",
//адрес wms сервера
"http://wms.jpl.nasa.gov/wms.cgi",
//параметры специфичные для wms:
//набор слоев, которые wms сервер склеит в картинку перед тем, как вернуть вам результат
{layers: "modis,global_mosaic"}
);
```
для tms:
```
//Создаем новый слой типа TMS
var layer = new OpenLayers.Layer.TMS(
//Имя для контролла выбора слоев
"My TMS Layer",
//путь до TMS сервера
"http://tilecache.osgeo.org/wms-c/Basic.py/",
//параметры специфичные для TMS:
//набор слоев и тип картинки, которую вы желаете получить (png/jpeg/gif)
{layername: "basic", type: "png"}
);
```
Также никто не мешает вам добавить все 3 слоя на карту и переключаться между ними, или добавить один из слоев поверх других.
##### Проекции
Теперь пару слов о граблях, на которые вы скорее всего наступите.
Допустим вы добавили один слой с мапником с osm.org (OpenLayers.Layer.OSM), но хотите, чтобы карта открывалась отзуммированной на Московскую область, а не на весь мир. Смотрим широту и долготу Москвы и вместо
```
map.zoomToMaxExtent
```
пишем
```
map.moveTo(
//Примерные координаты центра Москвы
new OpenLayers.LonLat(37.16, 55.604),
//зум
9
);
```
И попадаем в океан. Все дело в системе координат. Для слоя мапника родная система координат EPSG:900913. Точкой отсчета координат в ней является пересечение гринвичского меридиана и экватора, а единицами измерения являются метры. Соответсвенно, мы попали на 37 метров восточнее и на 55 метров севернее точки отсчета.
Привычные всем долгота и широта подразумевают, что заданы они в EPSG:4326. Соответсвенно, надо пересчитать координаты.
```
map.moveTo(
//пересчитать координаты точки
new OpenLayers.LonLat(37.16, 55.604).transform(
//из системы координат EPSG:4326
new OpenLayers.Projection('EPSG:4326'),
//в систему координат карты (EPSG:900913)
map.getProjectionObject()
),
9
);
```
О том, что систем координат на свете много, лучше помнить при задании любых координат в openlayers. Это добавляет головной боли, но позволяет работать с данными клиентов, если они используют нечто экзотическое, к примеру, Пулково 42.
Для этого подключаем proj4js ( [trac.osgeo.org/proj4js/wiki/Download](http://trac.osgeo.org/proj4js/wiki/Download) ) и добавляем строчку
```
Proj4js.defs['EPSG:28403'] = '+proj=tmerc +lat_0=0 +lon_0=39 +k=1 ' +
'+x_0=500000 +y_0=0 +no_defs +a=6378140 +rf=298,257223563 +units=m ' +
'+towgs84=28.000,-130.000,-95.000 +to_meter=1';
```
Тепперь вы можете при пересчете координат указывать новую проекцию.
Это не совсем Пулково 42, но, немного поподбирав параметры, можно добиться нормального отображения данных поверх слоев в других системах координат.
Теперь, когда с добавлением и отображением слоев мы разобрались, перейдем к маркерам, линиям и обработке событий.
##### Маркеры
В леерсах их 2 типа:
HTML (OpenLayers.Marker) и векторные (OpenLayers.Geometry.Point). Чуть позже я объясню, что здесь имеется ввиду под маркером и почему point.
HTML маркер создает один или несколько дивов, в который помещает картинку и располагает над картой в соответсвии с координатами. Если вы когда-нибудь смотрели фаербагом или другим отладчиком как устроен маркер на карте гугл, вам все будет знакомо. К ним относительно легко подключаются попапы, с ними легко (т.к. есть html объект) работать из jQuerry, и тем не менее создатели библиотеки не рекомендуют ими пользоваться. Почему? Они несколько тяжеловесны: когда у вас 1 маркер — все хорошо, когда тысяча — плохо. Они выбиваются из общей концепции хранения и отображения данных принятой в ol. Ну и из практических соображений: когда я начинал работать с леерсами, для таких маркеров не было drag контрола. Впрочем, его и сейчас нет.
Тем не менее, немного кода для добавления маркеров на карту:
```
//создаем слой с маркерами
var markers = new OpenLayers.Layer.Markers( "Markers" );
//добавляем его на карту
map.addLayer(markers);
//координаты, куда добавляем маркер
var lonLat = new OpenLayers.LonLat( 0, 0 );
//создаем маркер с дефолтной картинкой с координатами 0, 0
//идобавляем его в слой
markers.addMarker(new OpenLayers.Marker(lonLat));
```
Да, слоев с маркерами может быть несколько. Да, вы можете управлять видимостью слоев и прятать группы маркеров по своему усмотрению.
Теперь о том, кто такие векторные маркеры и о «концепции хранения и отображения данных».
Мало кого сейчас устроит возможность просто показывать разные растровые слои с картами. Основная прелесть в отображении своих уникальных данных поверх них. Итак, предположим, мы хотим отображать поверх карты оптические кабели, медные кабели и колодцы/опоры, через которые это добро проходит. Каждый объект будет содержать геометрическую информацию (как собственно проходит кабель / где располагается опора или колодец) и атрибутивную (тип кабеля, количество жил кабеля, затухание сигнала, высота опоры… список можно пополнять до бесконечности). Собственно эта идея напрямую реализуется в леерсах:
Объект — «OpenLayers.Feature.Vector», хранится вместе со своими атрибутами, геометрией и, опционально, стилем отображения.
Для точечных объектов:
```
new OpenLayers.Feature.Vector(
//Геометрия - точка с координатами x, y (x -longitude, y - latitude)
new OpenLayers.Geometry.Point(x, y),
//Атрибуты: тип, высота
{'type':'pillon', 'height':100},
//Стиль, в соответсвие с правилами которого мы хотим отображать объект.
//В данном случае будет использован тиль по умолчанию
null
);
```
Пару слов про стили.
В стилях можно задать, как именно отображать геометрию, используя атрибуты объекта. В зависимости от типа можно использовать различные иконки, например, колодцы рисовать кружками, а опоры — столбиками. Можно определить цвет заливки, толщину и цвет обводки. На основе атрибутов можно выводить текстовые подписи к объектам и т.д. Можно задать стиль конкретному объекту, можно, например, назначить стиль для слоя, чтобы все объекты слоя отображались в соответсвии с ним.
И все же к маркерам:
```
//Создаем слой с маркерами.
//Markers - имя для отображения в списке слоев.
//Передав в конструктор вторым атрибутом {showInLayerSwitcher: false}
//можно спрятать слой из контролла выбора слоев.
var markers = new OpenLayers.Layer.Vector('Markers');
//добавляем его на карту
map.addLayer(markers);
//объект, для которого рисуем маркер
var marker = new OpenLayers.Feature.Vector(
//долгота/широта
new OpenLayers.Geometry.Point(0, 0),
//данные по вкусу
{},
//Стиль, как отрисовывать
{
//рисуем картинку
externalGraphic:'http://someware.com/my_favorite_marker_icon.png',
//вот такой ширины
graphicWidth:16,
//вот такой вышины *
graphicHeight:16,
//сместив картинку на 8 пикселей влево
//относительно координат геометрии
graphicXOffset:-8,
//и на 16 пикселей вверх
graphicYOffset:-16,
//с милой подписью (подпись будет выводиться прямо на карту)
label:'Мой самый любимый маркер',
//с базовой точкой текста подписи посередине-сверху текста
labelAlign: 'ct',
//сдвинув текст на 5 пикселей вниз
labelYOffset: '5'
}
);
markers.addFeatures([marker]);
```
\*Дорогой grammar-nazi, это была аллюзия к детской песенке.
Если вам надо добавить несколько маркеров с одним стилем, достаточно использовать один объект стиля, но важно помнить при этом что изменения в инстансе стиля отразятся на всех маркерах.
Итак, маркер мы добавили. Теперь давайте добавим возможность его перемещать, кликать по нему, и реагировать на прочие события. Собственно обработкой событий леерсы сильнее всего отличаются от остальных библиотек, с которыми довелось поработать (внимательный читатель, который прочтет всю статью, не пропуская абзацы, узнает, что, в первую очередь, это google и чуток leaflet с яндексом).
Добавляем драг:
```
//Создаем контрол для слоя с маркерами, который позволяет перемещать объекты по карте.
var drag = OpenLayers.Control.DragFeature(markers);
//Если у вас много слоев с объектами, можно добавить их внутрь
//OpenLayers.Layer.Vector.RootContainer и передать его
//контролу
//добавляем контрол на карту
map.addControl(drag);
//включить контрол
//(при добавлении на карту должен включиться автоматом, но вдруг...)
drag.activate();
```
Если память меня не подводит, вы, наконец, добъетесь перемещения маркеров по карте.
Или добавим нашему маркеру попап по клику:
```
selectControl = new OpenLayers.Control.SelectFeature(markers, {
//колбэк на клик по маркеру
onSelect: onFeatureSelect,
//колбэк на клик вне маркера
onUnselect: onFeatureUnselect
});
function onFeatureSelect(feature) {
popup = new OpenLayers.Popup.FramedCloud("chicken",
feature.geometry.getBounds().getCenterLonLat(),
null,
"Привет Habr!",
null, true, onPopupClose
);
feature.popup = popup;
map.addPopup(popup);
}
function onFeatureUnselect(feature) {
map.removePopup(feature.popup);
feature.popup.destroy();
feature.popup = null;
}
```
Можно посмотреть пример вот тут: [openlayers.org/dev/examples/select-feature-openpopup.html](http://openlayers.org/dev/examples/select-feature-openpopup.html)
Большие проблемы начинаются, когда вам одновременно нужно:
* иметь возможность двигать маркеры
* отображать hover (т.е. обрабатывать onmousein и onmouseout)
* обрабатывать клик, даблклик по объекту
* обрабатывать клик, даблклик вне объекта
Это решаемая беда, но решение, пожалуй, заслуживает отдельной статьи.
##### Геокодирование
Фуф, мы добавили OSM на сайт и научились отображать свои данные поверх. Но все же значительная часть api гугла (яндекса) осталась за бортом. А именно геокодирование (получение координат по адресу и адреса по координатам) и прокладка маршрутов.
Про маршрутизацию по картам в осм я расскажу в другой раз, сейчас пару слов о геокодировании. Я не делал обратный геокодинг (адрес по координатам), поэтому остановлюсь пока на поиске координат по адресу.
Тут есть несколько вариантов: использовать готовый поиск от nominatim или openstreetmap.ru, написать свой велосипед. Пару слов о том, почему вам может понадобиться свой геокодер.
1. К примеру, вас интересует только Москва, соответсвенно, данные будет импортировать проще, и поисковые запросы будут простыми, без указания города.
2. По каким-то причинам вы не можете дать доступ во внешку ни с клиентских машин, ни с сервера.
3. Вам нужен геокодер по собственной базе адресов клиента.
Что же, никакой магии нет: самый простой вариант — использовать Solr или Sphynx. По сути я просто сохраняю в solr документы с полным адресом и координатами объекта.
Чтобы получить список адресов, можно к примеру взять интересующий вас регион в shp формате, загрузить в postgis, после чего достать адреса запросом вида:
```
select bldng.osm_id, bldng."A_STRT", bldng."A_SBRB", bldng."A_HSNMBR",
settle."NAME", ST_AsText(ST_Centroid(bldng.geom))
from building-polygon bldng
join settlement-polygon settle on ST_Within(bldng.geom, settle.geom)
```
На сегодня все. В следующий раз постараюсь подробнее рассказать про систему событий в openlayers.
##### Ссылки
Документация к openlayers — [dev.openlayers.org/docs/files/OpenLayers/Map-js.html](http://dev.openlayers.org/docs/files/OpenLayers/Map-js.html)
Там же песочница с примерами — [openlayers.org/dev/examples](http://openlayers.org/dev/examples/)
Proj4js — [trac.osgeo.org/proj4js](http://trac.osgeo.org/proj4js/)
Сайт с описанием различных систем координат в разных форматах,
в том числе в формате proj4 — [spatialreference.org](http://spatialreference.org/) | https://habr.com/ru/post/145552/ | null | ru | null |
# Java Stored Procedure в субд Oracle на примере формирования PDF-файла
Всем доброго времени суток!
Недавно имел опыт создания функций (хранимых процедур) на языке Java в СУБД Oracle (Java Stored Procedures). Постараюсь описать шаги по созданию таких функций, расмотрев пример работы с pdf-файлом.
Вот, что для этого потребуется:
* СУБД Oracle (в моем случае версии 10)
* библиотеки iText (версия 1.4.8)
* Java-код, реализующий требуемые функции
Важно знать, что, в зависимости от версии СУБД Oracle, с ней (с системой) может быть уставлена различная версия JVM (Java Virtual Machine). В 10-ой версии СУБД установлена JVM 1.4. А это значит, что при написании кода Java версию языка нужно использовать такую же.
### Загрузка библиотек в СУБД
Код на языке Java оперирует существующими методами классов библиотеки iText. В связи с этим, мы должны сначала загрузить библиотекe в субд. В этом нам поможет команда loadjava. Сами библиотеки должны быть скомпилированы с использованием java версии 1.4. Поэтому я и выбрал itext 1.4.8. Кроме это требовалось загрузить сопутствующие библиотеки. Вот последовательность загрузки библиотек iText:
* loadjava -resolve -verbose -thin -user user/password@ip-addres:port:TNS\_NAME bcprov-jdk14-149.jar
* loadjava -resolve -verbose -thin -user user/password@ip-addres:port:TNS\_NAME bcpkix-jdk14-149.jar
* loadjava -resolve -verbose -thin -user user/password@ip-addres:port:TNS\_NAME bcmail-jdk14-149.jar
* loadjava -resolve -verbose -thin -user user/password@ip-addres:port:TNS\_NAME itext-1.4.8.jar
Сделать это можно удаленно. Для этого указываются пользовательские данные и параметры соединения с сервером.
### Загрузка нашего Java-кода
До того, чтобы создать функции в базе данных мы должны загрузить наш собственный код в СУБД. В примере я открываю существующий файл, добавляю изображения и сохраняю в новый файл. Вот код:
```
create or replace and compile java source named "MyJavaPdf" as
import java.io.FileOutputStream;
import java.io.IOException;
import com.lowagie.text.Annotation;
import com.lowagie.text.DocumentException;
import com.lowagie.text.Image;
import com.lowagie.text.pdf.PdfContentByte;
import com.lowagie.text.pdf.PdfReader;
import com.lowagie.text.pdf.PdfStamper;
public class PdfGenerator{
public static final float LLX1 = 50;
public static final float LLY1 = 50;
public static final float W1 = 100;
public static final float H1 = 100;
public static final float LLX2 = 200;
public static final float LLY2 = 50;
public static final float W2 = 100;
public static final float H2 = 100;
public static final float LLX3 = 350;
public static final float LLY3 = 50;
public static final float W3 = 100;
public static final float H3 = 100;
public static String addSignsToPdf(String path, String input,
String output, String imm1, String imm2, String imm3) {
String result = null;
try {
System.out.println("PDF Editing: START...");
System.out.println("Files path: " + path);
System.out.println("Input file: " + input);
PdfReader reader = new PdfReader(path + input);
System.out.println("Output file: " + output);
PdfStamper stamper = new PdfStamper(reader,
new FileOutputStream(path + output));
PdfContentByte canvas = stamper.getOverContent(1);
canvas.saveState();
canvas.setRGBColorFill(0xFF, 0xFF, 0xFF);
canvas.rectangle(LLX1, LLY1, W1, H1);
canvas.rectangle(LLX2, LLY2, W2, H2);
canvas.rectangle(LLX3, LLY3, W3, H3);
canvas.fill();
canvas.restoreState();
System.out.println("Image 1: " + imm1);
System.out.println("Image 2: " + imm2);
System.out.println("Image 3: " + imm3);
putImage(canvas, Image.getInstance(path + imm1),
"IMMAGINE 1", LLX1, LLY1, W1, H1);
putImage(canvas, Image.getInstance(path + imm2),
"IMMAGINE 2", LLX2, LLY2, W2, H2);
putImage(canvas, Image.getInstance(path + imm3),
"IMMAGINE 3", LLX3, LLY3, W3, H3);
stamper.close();
result="OK";
System.out.println("PDF Editing: TERMINATED.");
sendStaffMailWithAttachment(path + output);
} catch (IOException e) {
result="ERROR";
for(int i=0; i
```
«compile» дает указание скомпилировать данный код в класс. Кроме такого варианта можно использовать имеющийся файл \*.class
### Создание функции, использующей java-класс
Теперь мы можем создать функцию на основе нашего java-класса. Это достаточно просто:
```
create or replace function createPdf( files_path in VARCHAR2,
input_file in VARCHAR2,
output_file in VARCHAR2,
picture1 in VARCHAR2,
picture2 in VARCHAR2,
picture3 in VARCHAR2)
return VARCHAR2
as language java
name 'PdfGenerator.addSignsToPdf(java.lang.String, java.lang.String,
java.lang.String, java.lang.String, java.lang.String, java.lang.String)
return java.lang.String';
/
```
Указываем здесь входные параметры и тип возвращаемого значения.
### Настройка доступа к директориям
Исходный и сформированный файлы хранятся на сервере СУБД, поэтому мы должны создать директорию в Oracle и раздать права на нее:
```
create directory PDFDIR as '/home/oracle/PDF' ;
commit;
grant ALL on directory PDFDIR to PUBLIC;
exec dbms_java.grant_permission('SchemaUser','java.util.PropertyPermission','*','read,write');
exec dbms_java.grant_permission('SchemaUser','java.net.SocketPermission','*','connect, resolve');
exec dbms_java.grant_permission('SchemaUser', 'SYS:java.io.FilePermission', '/home/oracle/PDF/*', 'read,write');
commit;
/
```
### Пример использования функции
Теперь мы можем использовать данную функцию:
```
select createPdf('/home/oracle/PDF/', 'INPUT.PDF', 'OUTPUT.PDF', 'picture1.jpg', 'picture2.jpg', 'picture3.jpg') from dual;
```
Надеюсь, что кому-то данный пример пригодится. Не судите строго, это мой первый пост на хабре.
#### Желаю всем успехов! Спасибо за внимание! | https://habr.com/ru/post/197940/ | null | ru | null |
# Кто же такой этот многорукий бандит?
1. Поговорим о модели
---------------------
Представьте на секунду, что вы очень азартный игрок, который только что попал в казино и не может выбрать, за какой игровой автомат ему сесть. Или один муравей из колонии, выбирающий по какому пути ему пойти на поиски пищи. Или даже вы – это целый маркетплейс, который думает, какую же цену, ему поставить на тот или иной товар!
На первый взгляд может показаться, что все эти странные ситуации никак не связаны. Но это только на первый взгляд. Если откинуть всю необычность ситуации, то перед нами дилемма исследования-использования. Посудите сами: как азартный игрок, вы хотите найти автомат, дающий больше всего денег – это использование, но вы не знаете, какой это автомат и ищите его, дергая ручки и сравнивая выигрыши – это исследование. Как часто вам нужно подходить к игровому автомату, который, по вашему мнению, самый прибыльный, а как часто нужно сомневаться в этом и пробовать другие? Как часто муравью нужно идти по тому пути, где товарищи-муравьи уже протоптали тропинку, а как часто стоит рискнуть и пойти своей дорогой? Как часто нужно менять цену, чтобы поспевать за инфляцией и спросом пользователей, а еще при этом максимизировать прибыль?
Откинем красивые слова и перед тем, как кинуться в море алгоритмов и сбора данных, и формально опишем нашу модель:
![E\left[R\left(a\right)\right]\rightarrow \max_a \\a\ \in \{ a_1,a_2,\ldots,\ a_n \}](https://habrastorage.org/getpro/habr/upload_files/ad2/06e/484/ad206e484c8349b6effc1ae763a0756c.svg)Посмотрим на эту формулу внимательнее: во-первых, поскольку мы имеем дело со случайными явлениями (автоматы в казино, объемы продаж), то мы хотим максимизировать математическое ожидание. Это обозначает, что мы хотим найти такое действие *a* из множества действий *{a1, a2, …, an}*, которое будучи повторенным большое количество раз давало бы нам выигрыш больше, чем любое другое действие. То есть, если бы существовало много вселенных, в которых мы бы пробовали разные действия, то мы хотим жить в той, где в итоге выиграли больше всего! Но поскольку вселенная у нас только одна, то мы хотим понять, какое действие будет наилучшим за кратчайший срок. То есть, сравнивая различные подходы к этой задаче, мы можем сравнивать их на основе того, как быстро мы поймем какое действие верное, можем сравнивать, какая награда у нас оказалась «на руках» спустя некоторое количество попыток, или сколько мы потеряли из-за того, что выбирали не «оптимальное» действие. Это называется *метрики,* и о них мы поговорим чуть позже.
Теперь, когда мы избавились от излишних описаний ситуации и перешли к абстрактной (обобщенной) задаче, можно нырнуть в изучение различных подходов к решению этой задачи!
2. Как понять, какой подход лучше?
----------------------------------
Как уже было сказано, нам нужны некоторые метрики, которые позволят нам сравнивать различные подходы к решению этой задачи. Больше того – внутри различных подходов к решению этой задачи существуют различные параметры, влияющие на эффективность данного подхода. По этой причине метрики очень важны!
Наиболее популярными являются 4 метрики, которые мы и будем использовать для сравнения подходов. Во-первых, это вероятность выбора оптимального действия:
При первом взгляде на данную метрику кажется немного странным, что мы просто берем единицу или нолик в зависимости от того, какое действие мы выбрали. Но эта метрика начинает быть по-настоящему полезной, когда мы можем очень много раз повторить эксперимент, а затем усреднить полученные результаты (спойлер: так мы и будем делать). В таком случае мы получим реальную скорость нахождения оптимальной ручки, «отчищенную» от случайности, что, конечно же, очень полезно!
Но с другой стороны, мы все еще живем в единственной вселенной и зачастую у нас нет возможности много-много раз повторить эксперимент с нуля (да и не хочется, если от этого зависит наше благосостояние, как в случае с казино). В этом нам помогут еще три метрики. Они конечно тоже зависят от случайности и, если мы их усредним, будут более гладкими и отражающими ситуацию «в среднем», но и в случае с единственным экспериментом они помогут нам что-то понять о результатах этого эксперимента.
Следующие две метрики довольно тесно связаны между собой — это среднее вознаграждение за действие:
И суммарное вознаграждение:
R*i* – это награда, полученная за *i*-ое действие.
С данными метриками все понятно – первый показывает, сколько в среднем получаем за одно действие (и чем быстрее растет этот показатель – тем для нас лучше). А второй показывает сколько мы уже получили к некоторому моменту времени (и чем он больше в определенный момент времени – тем лучше).
И последняя, но не по значению, метрика — это метрика потерь (иногда английское слово *regret* переводится как сожаление):
Ropt – это средняя награда от выбора оптимального действия, то есть сколько бы мы получили, если бы изначально знали, какое действие будет наилучшим. Данная метрика показывает, сколько мы потеряли из-за того, что не знали, какое действие оптимальное. Понятно, как использовать эту метрику, если мы сами придумали эксперимент и знаем какая ручка оптимальная и сколько она дает в среднем. Но что же делать когда мы этого не знаем? Обычно, когда наступает время считать метрики, у нас уже есть некоторое представление, какое действие является оптимальным и какую награду мы в среднем получаем от этого действия. Отмечу так же, что эта метрика не так жестока, если у нас имеется действие очень близкое к оптимальному. В таком случае, если мы сойдемся к неоптимальному, но близкому к нему действию, то получим не сильно отличающееся значение потерь, чего нельзя сказать о вероятности выбора оптимального действия (первая метрика)
Теперь, когда у нас есть целых 4 инструмента для сравнения различных подходов к решению этой задачи, можно начать изучать и сами подходы!
3. Немного кода
---------------
Мне очень нравится фраза: «Пока ты не реализовал какой-то алгоритм в коде – ты не понял этот алгоритм». Так что здесь и далее будут приведены куски кода на языке Python, которые помогут лучше разобраться в данной теме!
Во-первых, зададим environment (окружающую среду), которая будет получать от нас действие, а в ответ на это действие будет с некоторой вероятностью выдавать определенную награду. Можно сделать более сложную и похожую на казино окружающую среду, например, чтобы награда выдавалась случайно из некоторого вероятностного распределения). Но такая награда выбрана, во-первых, из-за ее простоты, а во-вторых, потому что при большом количестве действий суммарная награда все равно будет распределена практически нормально.
```
import numpy as np
class BanditEnv():
def __init__(self, probs, reward):
self.probs = probs
self.reward = reward
self._optimal_action = np.argmax(list(map(lambda x,y: x*y, probs, reward)))
self._optimal_reward = np.max(list(map(lambda x,y: x*y, probs, reward)))
def step(self, action):
return self.reward[action] if np.random.rand(1).item() < self.probs[action] else 0
env = BanditEnv([0.3, 0.2, 0.1, 0.2, 0.9], [1, 1, 1, 1, 2])
```
В данном случае наша среда env создается с помощью класса BanditEnv в котором у нас 5 действий: с вероятностью 0.3 первое действие принесет награду 1, с вероятностью 0.2 второе действие принесет награду 1 и так далее. Очевидно, что наилучшим действием в данном случае является пятое, которое в среднем будет приносить награду 1.8.
Кроме этого, нам надо придумать стратегию, чтобы всегда выигрывать больше (это будет скелет нашего подхода к решению задачи). В этом нам поможет *абстрактный класс*. Он будет иметь общие для всех стратегий методы (*\_\_init\_\_, update, reset*), чтобы не переписывать их раз за разом. С помощью декоратора *abstractmethod* мы опишем метод, который должен быть реализован в каждой стратегии под тем же именем. Это поможет нам переиспользовать один и тот же код для разных методов.
```
from abc import ABC, abstractmethod
class Strategy(ABC):
def __init__(self, n_arms, epsilon):
self.Q = np.zeros(n_arms)
self.n = [0 for _ in range(n_arms)]
self.epsilon = epsilon
self.n_arms = n_arms
@abstractmethod
def make_action(self):
pass
def update(self, action, reward):
self.n[action] += 1
self.Q[action] = (self.Q[action] * (self.n[action]-1) + reward)/self.n[action]
def reset(self):
self.__init__(self.n_arms, self.epsilon)
```
Мы будем хранить среднюю награду за действие каждого действия в атрибуте Q, количество раз, когда мы предпринимали каждое действие в списке n, а epsilon – это некоторый параметр, который регулирует поведение алгоритма. Для каждого подхода этот параметр свой и мы будем обсуждать его смысл в каждом подходе. Метод update обновляет информацию, полученную в результате действия, а метод reset помогает сбрасывать все знания о среде, для чистоты следующего эксперимента.
Далее идут несколько непримечательных функций, которые прогоняют эпизоды, принимают решения на основе стратегий, собирают статистику и рисуют красивые графики, которые будут использоваться далее.
Технические функции
```
from tqdm import tqdm
import matplotlib.pyplot as plt
def run_n_episodes(env, strategy, n_episodes):
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = [],[],[],[]
w_opt_times, total_reward, reg = 0, 0, 0
for episode in range(1, n_episodes+1):
action = strategy.make_action()
reward = env.step(action)
strategy.update(action, reward)
w_opt_stat.append(1 if action==env._optimal_action else 0)
total_reward += reward
r_total_stat.append(total_reward)
r_avg_stat.append(total_reward/episode)
reg += env._optimal_reward - reward
reg_stat.append(reg)
return w_opt_stat, r_avg_stat, r_total_stat, reg_stat
def run_n_times(n_repeat, env, n_episodes, strategy):
w_opt_stat_full, r_avg_stat_full = [],[]
r_total_stat_full, reg_stat_full = [],[]
for _ in tqdm(range(n_repeat)):
strategy.reset()
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_episodes(env,
strategy,
n_episodes)
w_opt_stat_full.append(w_opt_stat)
r_avg_stat_full.append(r_avg_stat)
r_total_stat_full.append(r_total_stat)
reg_stat_full.append(reg_stat)
return np.array(w_opt_stat_full).mean(axis=0), np.array(r_avg_stat_full).mean(axis=0),\
np.array(r_total_stat_full).mean(axis=0), np.array(reg_stat_full).mean(axis=0)
def plot_stats(w_opt_stat, r_avg_stat, r_total_stat, reg_stat, legends = False):
plt.figure(figsize=(12, 7))
plt.subplot(2, 2, 1)
for i in w_opt_stat:
plt.plot(i)
plt.xlabel('t')
plt.ylabel('w_opt')
if legends: plt.legend(legends)
plt.subplot(2, 2, 2)
for i in r_avg_stat:
plt.plot(i)
plt.xlabel('t')
plt.ylabel('r_avg')
if legends: plt.legend(legends)
plt.subplot(2, 2, 3)
for i in r_total_stat:
plt.plot(i)
plt.xlabel('t')
plt.ylabel('r_total')
if legends: plt.legend(legends)
plt.subplot(2, 2, 4)
for i in reg_stat:
plt.plot(i)
plt.xlabel('t')
plt.ylabel('reg')
if legends: plt.legend(legends)
```
4. Сначала изучим, затем используем
-----------------------------------
Первой идеей, которая может возникнуть для решения этой задачи – давайте сначала просто случайно изучим все действия (пройдемся по всем игровым автоматам), а затем посмотрим, какой в среднем дает наибольшую награду и потом будем делать это действие не переставая!
И здесь возникает вопрос - а сколько раз мы будем изучать эти действия до того, как начнем пользоваться? Ну для начала попробуем разное количество попыток. Например, 50 раз будем случайно выбирать действие. Давайте посмотрим, что же из этого получится!
Во-первых, напишем стратегию которая будет первые epsilon раз выбирать действие случайно, а затем выбирать то, которое в среднем нам давало лучшее решение. Для этого мы наследуемся от родительского класса Strategy, чтобы не писать уже готовые методы лишний раз и напишем, как должны приниматься решения в данной стратегии. В коде это выглядит следующим образом:
```
class RandomСhoiceStrategy(Strategy):
def make_action(self):
if sum(self.n) < self.epsilon:
return np.random.randint(self.n_arms)
return np.argmax(self.Q)
```
А затем просто вызываем уже готовые функции для сбора статистики и отрисовки графиков
Код для отрисовки графиков
```
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(100, env, 250, RandomСhoiceStrategy(5, 50))
plot_stats([w_opt_stat], [r_avg_stat], [r_total_stat], [reg_stat])
```
В результате получаются очень ожидаемые графики – до 50 действия вероятность выбора оптимального действия 20% или 1 раз из 5. Но потом мы вполне уверенно говорим, какое же действие оптимальное. Наша награда после 50-го действия начинает быстро расти, а потери до 50-го действия линейно растет, а затем становится постоянным, потому что мы перестаем выбирать неоптимальные действия:
Random Choice StrategyНо может быть 50 это слишком много? Давайте попробуем разные количества и посмотрим, к чему это приведет.
Код для отрисовки графиков
```
w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full = [],[],[],[]
epsilons = [5, 10, 20, 30, 50]
for epsilon in epsilons:
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(500, env, 250, RandomСhoiceStrategy(5, epsilon))
for f, l in zip([w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full],
[w_opt_stat, r_avg_stat, r_total_stat, reg_stat]):
f.append(l)
plot_stats(w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full, epsilons)
```
Random Choice Strategy parameters Получается, что 5 и 10 — это слишком мало, поэтому не всегда наш алгоритм правильно успевает понять, какое же действие оптимальное. 20 раз тоже не дотягивает до чуть-чуть до 1, зато 30 и 50 оказались достаточными. С другой стороны, 20 первых попыток показывает наименьшую функцию потерь после 250 действий. С увеличением количества возможных действий это число очевидно будет расти. В теории, зная количество действий и распределение наград за эти действия можно рассчитать оптимальное количество случайных действий. Это уже будет что-то похожее на A/B, A/B/C и тд. тестирование. Но наша проблема в том, что мы изначально не знаем, ничего о распределении наград за каждое действие. Можно усовершенствовать алгоритм – пусть он собирает некоторые знания о наградах, а когда наступит некоторого рода уверенность, полученная из данных, можно только использовать оптимальное действие. Примерно на такой идее строятся более продвинутые варианты решения данной проблемы, о которых мы и поговорим дальше!
5. Жадность не порок
--------------------
Еще из простых идей сразу напрашивается следующая – давайте будем просто жадно использовать то действие, которое прямо сейчас кажется наилучшим. Ну а чтобы не зацикливаться исключительно на одном действии – с некоторой вероятностью будем исследовать случайную ручку, вдруг она окажется лучше! Эта идея отражена в эпсилон-жадной стратегии. В виде кода это выглядит вот так:
```
class EpsilonGreedyStrategy(Strategy):
def make_action(self):
if np.random.random() > self.epsilon:
return np.argmax(self.Q)
return np.random.randint(self.n_arms)
```
Попробуем с эпсилон равным 0.1. Это значит, что случайное действие будет выбираться в 10% случаев, а в противном случае будем выбирать действие, которое кажется наилучшим!
Код для отрисовки графиков
```
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(1000, env, 250, EpsilonGreedyStrategy(5, 0.1))
plot_stats([w_opt_stat], [r_avg_stat], [r_total_stat], [reg_stat])
```
Epsilon Greedy StrategyНа графике вероятности выбора оптимального действия видно, что с течением времени мы приближаемся к отметке 0.9. И это логично – когда наш алгоритм уже разобрался что к чему и какое действие оптимальное, он в 90% случаев будет выбирать его. Функция потерь в данном случае чуть хуже, чем у предыдущей стратегии. Но посмотрим, что будет, если попробовать другие параметры эпсилон
Код для отрисовки графиков
```
w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full = [],[],[],[]
epsilons = [0.1, 0.2, 0.3, 0.5]
for epsilon in epsilons:
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(500, env, 250, EpsilonGreedyStrategy(5, epsilon))
for f, l in zip([w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full],
[w_opt_stat, r_avg_stat, r_total_stat, reg_stat]):
f.append(l)
plot_stats(w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full, epsilons)
```
Epsilon Greedy Strategy parametersВидно, что вероятность выбора оптимальной ручки сходится к 1 -эпсилон. То есть даже после большого количества времени мы не будем всегда выбирать только оптимальное действие. С одной стороны это плохо, потому что мы очевидно теряем награду, а с другой стороны вдруг в мире что-то поменялось и наше действие перестало быть наилучшим. В таком случае у нас есть возможность найти новое наилучшее действие. Как говорил Рене Декарт: *«сомневаться нужно во всём, кроме собственного существования»*. Если же судить по метрике потерь – то наилучшим вариантом кажется эпсилон равный 0.2 – к моменту времени 250 она находится где-то на уровне 75, что уже сопоставимо с предыдущей стратегией!
6. Мягкий максимум
------------------
Очевидно, что у эпсилон-жадного алгоритма есть недостаток. Во-первых, не пользуемся всей, полученной информацией, а только думаем, какое же на данный момент нам действие кажется нам наилучшим. Во-вторых, не уменьшаем объем исследований после большого числа. Исправить эти недочеты пытается следующее семейство алгоритмов – *softmax* алгоритмы. Они основаны на функции softmax, знакомой многим исследователям данных. Она принимает на вход вектор и выглядит она вот так:
Ее смысл в том, что она приводит любой вектор к вектору вероятностей и чем больше число в векторе, тем больше соответствующая ему вероятность. Соответственно, чем больше разрыв между числами, тем больше будет разрыв между вероятностями. Этим можно пользоваться, например, умножая или деля весь вектор на число, чтобы получить больший или меньший разрыв в вероятностях. А уже эти сами вероятности использовать для принятия решений о действии. Код новой стратегии выглядит так:
```
def softmax(x):
return np.exp(x)/np.sum(np.exp(x))
class SoftMaxStrategy(Strategy):
def make_action(self):
probs = softmax(self.Q/self.epsilon)
return np.random.choice(self.n_arms, p=probs)
```
Мы определяем функцию softmax, а затем просто пользуемся ей для нахождений вероятностей действий в зависимости от того, сколько в среднем они нам приносили.
Код для отрисовки графиков
```
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(200, env, 250, SoftMaxStrategy(5, 0.1))
plot_stats([w_opt_stat], [r_avg_stat], [r_total_stat], [reg_stat])
```
Soft Max StrategyВидно, что такой подход дает результаты лучше чем предыдущие подходы! Вероятность выбора оптимальной ручки стремиться к единице, а наша функция потерь останавливается примерно в районе 30! Но можно изучить влияние различных параметров на результат:
Код для отрисовки графиков
```
w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full = [],[],[],[]
thetas = [0.1, 0.2, 0.3, 0.5]
for theta in thetas:
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(100, env, 250, SoftMaxStrategy(5, theta))
for f, l in zip([w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full],
[w_opt_stat, r_avg_stat, r_total_stat, reg_stat]):
f.append(l)
plot_stats(w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full, thetas)
```
Soft Max Strategy parametersДля данного эксперимента наилучшими оказались параметры 0.2 и 0.3. Они показывают похожие результаты, как в вероятности выбора оптимальной ручки, так и для метрики потерь.
Кроме того, существует прием, который называется «симуляция отжига». Это пошло из физики, где функцию softmax (правда под другим именем) использовали для изучения горения и нагревания. Так вот, этот прием предлагает снижать коэффициент исследования в течение времени. Зачем нам исследовать, когда мы уже и так практически все знаем! В таком случае код будет выглядеть вот так:
```
class AnnealingSoftMaxStrategy(Strategy):
def make_action(self):
theta = 1/np.log(np.sum(self.n)+2)
probs = softmax(self.Q/theta)
return np.random.choice(self.n_arms, p=probs)
```
Код для отрисовки графиков
```
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(300, env, 250, AnnealingSoftMaxStrategy(5, 0))
plot_stats([w_opt_stat], [r_avg_stat], [r_total_stat], [reg_stat])
```
Annealing Soft Max StrategyРезультат налицо – мы довольно быстро перестаем исследовать, так как понимаем, что к чему и получаем очень хорошие метрики! И приятный бонус – нам не нужно задумываться о том, какой параметр брать!
7. Доверительные интервалы
--------------------------
Следующий подход к решению нашей задачи является одним из наиболее популярных, потому что у него есть некоторое доказательство его оптимальности. А если быть точнее, то доказано, что метрика потерь растет со скоростью О(log(t)). Здесь я не буду приводить доказательство и выводы, поэтому особо любопытных отсылаю к более академическим и лучше англоязычным источникам.
Данный метод называется – алгоритм верхней доверительной границы или UCB по английский. Его суть заключается в том, что мы выбираем действие с наибольшей верхней доверительной границей, которая рассчитывается по формуле:
В данной формуле:
q – это среднее вознаграждение от использования *i*-ого действия
c – параметр, отвечающий за ширину доверительного интервала, а значит за то, как часто мы исследуем новые значения
t – момент времени наблюдения
ni – количество раз, когда мы использовали *i*-ое действие.
Логика такая – чем больше мы используем какое-то действие (знаменатель), тем меньше становится доверительный интервал. Мы становимся уверены, что знаем реальную среднюю награду за данное действие – верхняя доверительная граница снижается. В это же время для действий, которые мы не используем, доверительный интервал растет за счет роста знаменателя, но растет медленно, потому что логарифм. И в один момент может оказаться, что, то действие, которое нам казалось оптимальным, уже нам таким и не кажется, нас привлекают менее исследованные действия. И все по новой. Затем мы можем вернуться обратно к изначальному действию. Колесо Сансары дало оборот. И вот таким образом мы и решаем дилемму исследования-использования. Код для этой стратегии выглядит так:
```
class UBCStrategy(Strategy):
def make_action(self):
c = np.sqrt(self.epsilon * np.log(np.sum(self.n)+1)/(np.array(self.n)+1))
upper_bounds = self.Q + c
return np.argmax(upper_bounds)
```
Код для отрисовки графиков
```
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(400, env, 250, UBC1Strategy(5, 2))
plot_stats([w_opt_stat], [r_avg_stat], [r_total_stat], [reg_stat])
```
UBC StrategyНа графиках отчетливо видно, в какой момент в среднем наш алгоритм бросает использовать оптимальное действие, которое нашел до этого и довольно быстро, и начинает использовать другие. Это происходит где-то между 50 и 100 моментом времени. Но даже в таком случае он показывает хорошие результаты! А вот как он работает с другими параметрами.
Код для отрисовки графиков
```
w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full = [],[],[],[]
params = [1, 2, 3, 5]
for param in params:
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(100, env, 250, UBC1Strategy(5, param))
for f, l in zip([w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full],
[w_opt_stat, r_avg_stat, r_total_stat, reg_stat]):
f.append(l)
plot_stats(w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full, params)
```
UBC Strategy parametrsДля данной ситуации лучшим и наиболее стабильным является параметр c равный 1. Иногда параметр выносится в название алгоритма, и тогда пишут *UCB1, UCB2* и так далее. И данный подход к решению задачи о многоруком бандите является одним из двух наиболее частых и популярных!
8. Байесовские бандиты
----------------------
Вторым частым и популярным подходом к решению задачи о многоруком бандите является алгоритм Выборка Томпсона и основан данный алгоритм на байесовской статистике! Он более сложный для глубокого понимания, чем предыдущие, но зато в некоторых случаях дает просто потрясающие результаты. По этой причине нужно сделать лирическое отступление и очень коротко поговорить о байесовской статистике. Если это кажется излишним и хочется увидеть сам алгоритм и результаты, то можно просто пропустить следующую пару абзацев. Само собой здесь будет очень сжатый разговор про очень объемную тему, поэтому заинтересовавшихся отсылаю к замечательным книгам:
* Курт Уилл. Байесовская статистика: Star Wars, LEGO, резиновые уточки и многое другое - для начинающих;
* Освальдо Мартин. Байесовский анализ на Python - для продвинутых
В них дается хорошее понимание что такое байесовская статистика и чем она отличается от классической.
Но вернемся к нашей теме. Во-первых, постараемся понять, на каких идеях строится байесовская статистика. В первую очередь это теорема Байеса:
Буквой H обозначается гипотеза, буквой D – данные, полученные в результате наблюдения. Слева от знака равенства – вероятность того, что наша гипотеза верна, при условии полученных данных, или лучше сказать наша уверенность в гипотезе H (потому что байесовская статистика рассматривает вероятность как степень уверенности в чем-либо). Справа в знаменателе – вероятность получить такой результат, при условии, что наша гипотеза верная и наша уверенность в гипотезе до получения результатов. Знаменатель, грубо говоря, в такой интерпретации выступает просто поправочным коэффициентом (если говорить строго, то знаменатель это вероятность получить те результаты, которые мы получили, при всех возможных гипотезах). Вероятность P(H) называется априорной вероятностью – то, что мы думали до опыта, вероятность P(H|D) называется апостериорной вероятностью – то, что мы думаем после опыта, вероятность P(D|H) называется правдоподобием. По факту байесовская статистика предлагает нам формальный метод пересмотра своего мнения на основе полученных данных.
Разберем на примере. Вам на день рождения подарили монетку для принятия решений, но вы слишком хорошо знаете человека, который вам ее подарил – он постоянно пытается разыграть вас! Возможно в этот раз он подарил нечестную монетку, которая всегда будет выпадать орлом и вы решаете ее проверить! До того, как вы начали эксперимент вы совершенно не знаете, что ждать – монетка либо честная и дает орлов в 50% случаев, либо нечестная и орлы выпадают, например, в 90% случаев. Поэтому вероятность, что монетка честная для вас равна 50%. И вот после 5 бросков у вас есть 5 орлов подряд. Казалось бы все понятно – вас хотят разыграть! Но не будем спешить с выводами и воспользуемся теоремой Байеса. Априорная вероятность равна 0.5, вероятность выпадения 5 орлов при честной монетке равна (0.5)5 тогда числитель равен (0.5)6. Знаменатель равен ((0.5)5 + (0.9)5)\*0.5 (Здесь я отсылаю вас к учебникам по теории вероятностей или книгам, которые советовал ранее). В таком случае, вероятность, что монетка честная равна примерно 0,05 или 5%. Это наша апостериорная вероятность, того, что монетка честная. Конечно, мы почти уверены, что нас пытаются разыграть, но все равно на 5% мы верим нашему другу.
Это был простейший пример применения байесовской статистики. Априорные и апостериорные вероятности могут быть непрерывными, что не сильно меняет общую логику, но сильно усложняет вычисления. В общем случае от этого никуда не деться, но существуют частные случаи, которые помогают сильно упростить вычисления и код, они называются сопряженные вероятности (отсылаю любопытных к статье в Википедии: [Сопряжённое априорное распределение](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%BF%D1%80%D1%8F%D0%B6%D1%91%D0%BD%D0%BD%D0%BE%D0%B5_%D0%B0%D0%BF%D1%80%D0%B8%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5)). Если коротко, то при использовании сопряженных вероятностей априорное и апостериорное распределения имеют одну и ту же функцию распределения, но с разными параметрами.
Вернемся к основному объекту нашего разговора – задаче о многоруких бандитах, и на ее примере разберём, как используются сопряженные вероятности. Рассмотрим два вида алгоритма – в первом будем считать, что награда имеет распределение Бернулли (то есть либо 1 с вероятностью p, либо 0 с вероятностью 1-p), а во втором, что награда имеет нормальное распределение.
Итак, в первом случае мы имеем дело с наградой, которая распределена согласно закону Бернулли, а значит сопряженное с ним распределение – бета-распределение (это можно понять из таблички на страничке в википедии, на которую я дал ссылку выше!). Опять же, не буду подробно останавливаться на разговоре о бета-распределении (любопытным – книги), но скажу лишь, что это распределение находится от 0 до 1 (а значит задает вероятность), и зависит от 2 параметров: альфа и бета, которые интерпретируются как количество удачных (в нашем случае мы получили награду 1) и неудачных (получили награду 0) соответственно. Каждому действию присваивается свое распределение (изначально у всех одинаковые параметры), из этих распределений случайно делаем выборку в 1 элемент и сравниваем их между собой. В итоге - выбираем то действие, у которого наибольшее значение случайно выбранного числа, а потом, в зависимости от полученной награды, обновляем параметры распределения. Код выглядит вот так:
```
import scipy.stats as stats
class BayesianStrategy_Bin(Strategy):
def __init__(self, n_arms):
self.n_arms = n_arms
self.a = np.ones(n_arms)
self.b = np.ones(n_arms)
self.disr = stats.distributions.beta
def make_action(self):
samples = self.disr.rvs(self.a, self.b)
return np.argmax(samples)
def update(self, action, reward):
if reward:
self.a[action] += 1
else:
self.b[action] += 1
def reset(self):
self.__init__(self.n_arms)
```
А смысл у этих манипуляций такой: чем больше у бета-распределения параметр альфа (количество успешных действий), тем ближе распределение к 0, и наоборот – чем больше бета (количество неуспешных действий), тем ближе к 1. Кроме того, чем больше сумма альфа и бета, тем меньше дисперсия. Это выливается в то, что выборка из распределения, связанного с лучшим действием довольно быстро начнет выдавать выборку с большими значениями, а значит и выбирать это действие будут чаще!
Beta-распределениеНа гифке видно, что, после того как алгоритм немного исследовал все действия, фиолетовое распределении становится сконцентрированным справа, а значит выборки из него стабильно будут больше выборок из остальных распределений.
Для данного алгоритма нам нужно создать другую окружающую среду:
```
env = BanditEnv([0.3, 0.2, 0.1, 0.2, 0.9], [1,1,1,1,1])
```
А метрики работы данного алгоритма выглядят так:
Код для отрисовки графиков
```
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(150, env, 250, BayesianStrategy_Bin(5))
plot_stats([w_opt_stat], [r_avg_stat], [r_total_stat], [reg_stat])
```
Bayesian Strategy (Binary)Как по мне, очень крутые результаты!
С нормальным распределением очень похожая история: мы предполагаем, что выигрыш распределен нормально, сопряженное распределение для нормального распределение – нормальное (концентрация нормального в одном предложении зашкаливает). Параметры в нормальном распределении отвечают за центр распределение (μ – среднее) и за его ширину (σ – стандартное отклонение). Эти параметры и обновляются от результата эксперимента.
Нормальное распределениеЗдесь тоже отчетливо видно, как фиолетовое распределение очень быстро стало правее остальных. Кроме этого оно стало быстро стало довольно узким и выборки из него были больше всех остальных. С одной стороны, это здорово, потому что мы быстро перестали исследовать и начали использовать. Но с другой стороны, может быть мы недостаточно исследовали и на самом деле следует поискать еще? Чтобы увеличить время исследования и заставить алгоритм исследовать все действия используют следующий прием – ставят немного завышенное начальное значение. В таком случае в результате исследования мы будем больше узнавать о распределении награды и двигаться влево, давая тем самым алгоритму возможность исследовать другие действия. Визуально это выглядит вот так:
Нормальное распределение со смещениемВот так уверенность в том, что мы ничего не упустили намного больше!
О том как они обновляются призываю вас почитать на той же страницы в википедии, потому что формулы там дольно объемные. В результате код выглядит вот так:
```
class BayesianStrategy_Norm(Strategy):
def __init__(self, n_arms, sigma):
self.n_arms = n_arms
self.means = np.ones(n_arms) * 3
self.tay = 1/(np.ones(n_arms) * sigma)**2
self.tay_likelihood = 1/(sigma**2)
self.disr = stats.distributions.norm
self.sigma = sigma
def make_action(self):
samples = self.disr.rvs(self.means, np.sqrt(1/self.tay))
return np.argmax(samples)
def update(self, action, reward):
self.means[action] = (self.tay[action]*self.means[action] + self.tay_likelihood*reward)/(self.tay[action] + self.tay_likelihood)
self.tay[action] = self.tay[action] + self.tay_likelihood
def reset(self):
self.__init__(self.n_arms, self.sigma)
```
Здесь используется определение нормального распределения через тау, а не через сигму просто потому, что это упрощает расчёты.
Код для отрисовки графиков
```
env = BanditEnv([0.3, 0.2, 0.1, 0.2, 0.9], [1,1,1,1,2])
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(150, env, 250, BayesianStrategy_Norm(5, 2))
plot_stats([w_opt_stat], [r_avg_stat], [r_total_stat], [reg_stat])
```
Bayesian Strategy (Norm)Результаты не такие хорошие, как для распределения Бернулли, но это можно объяснить тем, что здесь и окружающая среда другая, и предположение о нормальности несколько натянуто за уши или параметры подобраны не очень хорошо, поэтому посмотрим на поведение алгоритма при других параметрах.
Код для отрисовки графиков
```
w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full = [],[],[],[]
params = [0.5, 1, 2, 5]
for param in params:
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(100, env, 250, BayesianStrategy_Norm(5, param))
for f, l in zip([w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full],
[w_opt_stat, r_avg_stat, r_total_stat, reg_stat]):
f.append(l)
plot_stats(w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full, params)
```
Bayesian Strategy (Norm) parametersВот теперь результаты на порядок лучше! Но все познается в сравнении, поэтому посмотрим на метрики различных решений на одном графике!
9. Все познается в сравнении
----------------------------
Теперь, когда мы рассмотрели все наиболее популярные алгоритмы решения задачи о многоруком бандите, настало время сравнить их. Так как в предыдущей части мы исследовали 2 различных окружающих среды. В одной среде награды распределены по закону Бернулли, а во второй предполагали, что награды распределены нормально, значит и сравнивать алгоритмы будем в 2 различных средах. Для начала посмотрим второй вариант:
Код для отрисовки графиков
```
env = BanditEnv([0.3, 0.2, 0.1, 0.2, 0.9], [1, 1, 1, 1, 2])
w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full = [],[],[],[]
params = [RandomСhoiceStrategy(5, 20), EpsilonGreedyStrategy(5, 0.2), AnnealingSoftMaxStrategy(5, 0),
UBC1Strategy(5, 1), BayesianStrategy_Norm(5, 0.5)]
for param in params:
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(300, env, 250, param)
for f, l in zip([w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full],
[w_opt_stat, r_avg_stat, r_total_stat, reg_stat]):
f.append(l)
plot_stats(w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full, ['random choice','eps greedy','soft max', 'UBC', 'Tompson'])
```
Сравнение различных алгоритмовВполне четко можно разделить все алгоритмы по их удачности – лучшие метрики в данном случае показали алгоритмы *softmax*, *UCB* и Выборка Томпсона, стратегия случайного исследования показали себя чуть хуже, а хуже всех с данной задачей справилась эпсилон-жадная стратегия. Теперь посмотрим, как поведет себя алгоритм в окружающей среде с наградой, распределенной по закону Бернулли.
Код для отрисовки графиков
```
env = BanditEnv([0.3, 0.2, 0.1, 0.2, 0.9], [1,1,1,1,1])
w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full = [],[],[],[]
params = [RandomСhoiceStrategy(5, 20), EpsilonGreedyStrategy(5, 0.2), AnnealingSoftMaxStrategy(5, 0),
UBC1Strategy(5, 1), BayesianStrategy_Bin(5)]
for param in params:
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(300, env, 250, param)
for f, l in zip([w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full],
[w_opt_stat, r_avg_stat, r_total_stat, reg_stat]):
f.append(l)
plot_stats(w_opt_stat_full, r_avg_stat_full, r_total_stat_full, reg_stat_full, ['random choice','eps greedy', 'soft max', 'UBC', 'Tompson'])
```
Сравнение различных алгоритмовВидно, что в этом случае выборка Томпсона проявила себя лучше всех! А такие задачи, когда награда равна либо нулю либо единице, довольно часто могут встретиться в реальной жизни – например, увеличение конверсий на сайте. В общем теперь у вас есть все оружия для решения данной задачи, а кроме этого у вас есть понимание мощности этих оружий! А с таким арсеналом можно уже много чего сделать!
10. Пара слов о контекстуальных бандитах
----------------------------------------
В завершение хочется рассказать про расширение бандитов, про которое не так часто говорят, но которое, на мой взгляд, очень сильно расширяет область применения данных алгоритмов, а также их глубину – это решение проблемы контекстуальных бандитов. Награда в случае с контекстуальным бандитом зависит не только от того, какое действие было выбрано, но и в каком состоянии системы оно было выбрано. Приведу пример: вы все еще очень азартный игрок, пришедший в казино, но теперь у вас есть друг, работающий в казино, который по секрету сказал вам, что в зависимости от дня недели выигрыши игровых автоматов меняются! Поменяется ли от этого ваша стратегия? Конечно! Это и значит, что от результат зависит не только от действия (какой автомат выбрать), но и от контекста (в какой день недели это происходит. Модель в данном случае будет выглядеть так:
![E\left[R\left(a,\ s\right)\right]\rightarrow\max_a \\ a\ \in \left\{a_1,a_2,\ldots,\ a_n\right\},\ s\ \in \left\{s_1,s_2,\ldots,\ s_n\right\}](https://habrastorage.org/getpro/habr/upload_files/02b/cff/581/02bcff581cf5828cb522599aaf15b9bc.svg)И решение такой задачи довольно простое и в то же время изящное: мы будем использовать разные реализации одного и того же алгоритма. То есть каждое состояние – это отдельный маленький эксперимент внутри одного большого. Аналогия с казино: в понедельник мы используем наш алгоритм, во вторник мы используем этот же (а можно и другой) алгоритм, но забывая, что было в понедельник, и так в течение недели. А в следующий понедельник опять вспоминаем все результаты из прошлого понедельника и так по новой.
Теперь рассмотрим это в коде. Зададим контекстуальный бандит, как просто набор из простых бандитов. Он будет случайно выбирать бандита и сообщать нам контекст – номер бандита которого он выбрал. Конечно, дни недели меняются не случайно, но в данной модели рассмотрим случайный выбор контекста (это не сильно меняет суть вещей).
```
class ContextualBandit():
def __init__(self, *bandits: BanditEnv, p=None):
self.n_context = len(bandits)
self.bandits = list(bandits)
self.p = p if p else np.ones(shape=(self.n_context,))/self.n_context
def get_context(self):
self.curr_context = np.random.choice(range(self.n_context),p=self.p)
self.curr_bandit = self.bandits[self.curr_context]
self._optimal_action = self.curr_bandit._optimal_action
self._optimal_reward = self.curr_bandit._optimal_reward
return self.curr_context
def step(self, action):
return self.curr_bandit.reward[action] if np.random.rand(1).item() < self.curr_bandit.probs[action] else 0
contextual_bandit = ContextualBandit(BanditEnv([0.3, 0.2], [1, 1]),
BanditEnv([0.1, 0.5], [1, 1]))
```
По сравнению с простым бандитом у нас появился метод get\_context, который выбирает одного из бандитов и возвращает номер выбранного бандита. Рассмотрим случай, когда у нас награда опять 0 или 1 с некоторой вероятностью, но в разных состояниях оптимальное действие будет различаться.
Немного изменим функцию для сбора статистики
```
def run_n_episodes(env, strategy, n_episodes):
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = [],[],[],[]
w_opt_times, total_reward, reg = 0, 0, 0
for episode in range(1, n_episodes+1):
curr_context = env.get_context()
action = strategy.make_action()
reward = env.step(action)
strategy.update(action, reward)
w_opt_stat.append(1 if action==env._optimal_action else 0)
total_reward += reward
r_total_stat.append(total_reward)
r_avg_stat.append(total_reward/episode)
reg += env._optimal_reward - reward
reg_stat.append(reg)
return w_opt_stat, r_avg_stat, r_total_stat, reg_stat
```
И посмотрим, как же обычный Байесовский алгоритм справится с контекстным бандитом:
Код для отрисовки графиков
```
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = run_n_times(500, contextual_bandit, 250, BayesianStrategy_Bin(2))
plot_stats([w_opt_stat], [r_avg_stat], [r_total_stat], [reg_stat])
```
Обычный алгоритм в контекстном окруженииКак и ожидалось, ничего хорошего. Вероятность выбора оптимальной ручки примерно равна 50%, а это значит, что мы в 50% случаев угадываем, а в 50% нет, а потери растут линейно и не собираются замедляться. Можно считать действуем наугад, а это никуда не годится.
Поэтому создадим класс для контекстуальной стратегии, которая тоже по факту является набором из базовых стратегий, которые выбираются в зависимости от контекста:
```
class ContextualStrategy(Strategy):
def __init__(self, n_context, strategy_base:Strategy, *args):
self.strategy_base = strategy_base
self.n_context = n_context
self.strategys = [strategy_base(*args) for _ in range(n_context)]
self.args = args
def make_action(self, context):
self.curr_strategy = self.strategys[context]
return self.curr_strategy.make_action()
def update(self, action, reward):
self.curr_strategy.update(action, reward)
def reset(self):
self.__init__(self.n_context, self.strategy_base, *self.args)
```
Важным отличием является то, что теперь в метод make\_action мы передаем еще и контекст. По этой причине нам снова нужно подправить функцию сбора статистики:
Немного изменим функцию для сбора статистики
```
def run_n_episodes(env, strategy, n_episodes):
w_opt_stat, r_avg_stat, r_total_stat, reg_stat = [],[],[],[]
w_opt_times, total_reward, reg = 0, 0, 0
for episode in range(1, n_episodes+1):
curr_context = env.get_context()
action = strategy.make_action(curr_context)
reward = env.step(action)
strategy.update(action, reward)
w_opt_stat.append(1 if action==env._optimal_action else 0)
total_reward += reward
r_total_stat.append(total_reward)
r_avg_stat.append(total_reward/episode)
reg += env._optimal_reward - reward
reg_stat.append(reg)
return w_opt_stat, r_avg_stat, r_total_stat, reg_stat
```
Код для отрисовки графиков
```
w_opt_stat_c, r_avg_stat_c, r_total_stat_c, reg_stat_c = run_n_times(250, contextual_bandit, 250,
ContextualStrategy(2, BayesianStrategy_Bin, 2))
plot_stats([w_opt_stat, w_opt_stat_c], [r_avg_stat, r_avg_stat_c], [r_total_stat, r_total_stat_c], [reg_stat, reg_stat_c], legends=['base', 'contextual'])
```
Сравнение контекстного подхода с обычнымРезультат, как говорится, на лицо. Очевидно, что контекстуальная стратегия уже улавливает какие-то закономерности и в целом гораздо лучше справляется с поставленной задачей.
Вот такое небольшое расширение задачи о многоруком бандите может привести к значительному углублению задачи! Теперь проект по многорукому бандиту это не просто 10 строчек кода на решение, теперь можно заниматься кластеризацией и сегментацией клиентов, определением контекста, настройки множества различных параметров для каждого отдельного алгоритма, чтобы улучшить метрики. В общем все то, что любят специалисты Data Science.
Спасибо большое, что прочитали данный довольно длинный текст. На самом деле на том, что написано здесь, многорукие бандиты далеко не заканчиваются. Мы практически не обсудили практические возможности применения многоруких бандитов. Не затронули тему возможной архитектуры на реальных проектах и частоту обновления данных. Кроме того, существуют куда более сложные и интересные расширения данной задачи, такие как, например, *Adversarial bandits* или Враждующие Бандиты на русском языке и всевозможные их расширения. Но как говорится: «*Дорогу осилит идущий!*»
*Даниил Трубин, Главный специалист направления технологий машинного обучения «Газпромнефть – Региональные продажи»* | https://habr.com/ru/post/689364/ | null | ru | null |
# По следам поста «Быстрая разработка веб-приложений на Java»
Мотивом написания данной статьи послужило прочтение поста [«Быстрая разработка веб-приложений на Java»](http://habrahabr.ru/blogs/java/126066/) и небольшой когнитивный диссонанс, возникший после прочтения и вопрос, который продолжает попрежднему мучать меня — Зачем такие сложности? Если есть WTP!
Далее я расскажу как я веду разработку под tomcat.
#### Локальная разработка
Для локальной разработки я использую WTP, это намного удобней постоянных запусков/перезапусков проекта, все обновления подхватываются на лету. И готов поспорить с [asolntsev](http://habrahabr.ru/users/asolntsev/) на тему тяжести плагина.
Настраивается все очень просто. В Eclipse File->New->Other...->Server, далее выбираем требуемый сервер и пусь, где локально установлена инстанция сервера (Например tomcat) и жмем Finish. Теперь во View «Servers» появился новый сервер, который можно запускать и на который можно публиковать веб-проекты.
Фактически Eclipse используется установленную инстанцию, но конфиги для работы берет из папки .metadata\.plugins\org.eclipse.wst.server.core\tmp[0]\, при желании их можно править напрямую.
Если проект maven — тоже ничего сложного в этом нет. Ставим plugin m2eclipse, добавляем plugin’s репозитарий [m2e-extras](http://m2eclipse.sonatype.org/sites/m2e-extras) и доустанавливаем «Maven Integration for WTP», после чего появляется возможность публиковать mvn веб-проекты в WTP.
Достоинства
* Не нужно перезапускать проект — изменения подхватываются на лету
* Избавляемся от ошибок связанных с особенностями контейнера
* Логи отображаются в консоли в Eclipse
Недостатки
* Иногда проект клинит и не обновляется — лечится правой кнопкой на сервере «Clean...»
#### Удаленная разработка
Когда проект по моему мнению готов, я выкладываю его на тестовый сервер запуском task в ant, для этого придется прописать в build-е пути к catalina-ant.jar, jasper-compiler.jar, jasper-runtime.jar, servlet-api.jar, commons-logging.jar. Почитать про настройку деплоя через ant можно например [тут](http://voituk.kiev.ua/2008/03/18/tomcat-app-deployment-using-ant/) .
```
```
Все — обновленная версия проекта ушла на сервер (или на несколько серверов).
Достоинства
* Простота использования
* Надежность обновления
Недостатки
* Перед публикацие требуется переcборка war
#### Заключение
Данные методы не претендуют на универсальность, но я не сталкивался c задачами, когда было бы невозможно использовать данную схему работы. Хотелось бы также услышать ваше мнение по поводу данных способов работ. | https://habr.com/ru/post/126791/ | null | ru | null |
# Аналог ip unnumbered в Mikrotik RouterOS
Сразу скажу, что на написание поста меня вдохновила аналогичная статья, [опубликованная](http://habrahabr.ru/post/71689/) на Хабре еще в 2009 году. Поэтому я не буду пересказывать ее содержимое и приводить конфигурацию Cisco-девайсов.
Сегодня, когда IPv4-адреса стали еще большим дефицитом, чем автомобиль «Москвич» во времена СССР, выделять клиенту сеть /30 или /31 — это преступление. В Cisco для обхода этих проблем есть режим «ip unnumbered», позволяющий назначить клиенту единственный адрес, не расходуя адреса впустую. Давайте посмотрим как это делается в Mikrotik RouterOS. Представим такую (сильно упрощенную) схему:
Наш шлюз (provider-gw) подключен интерфейсом ether1 к интернету посредством BGP (или другим способом, это не важно) и у нас есть собственная «большая» публичная сеть, например — 123.45.60.0/22. Первый клиент подключен к VLAN-интерфейсу vlan100, который, предположим, заведён в ether2. Второй — к vlan200.
`/interface vlan add disabled=no name=vlan100 vlan-id=100 interface=ether2 comment="Client 1"`
`/interface vlan add disabled=no name=vlan200 vlan-id=200 interface=ether2 comment="Client 2"`
Маршрутизатор должен иметь IP-адрес из нашей публичной сети. Допустим, 123.45.60.1 с маской /22. Этот адрес нужно назначить на любой свободный интерфейс или vlan, даже если они потом никак не будут использоваться. Пусть это будет vlan1000:
`/interface vlan add disabled=no name=vlan1000 vlan-id=1000 interface=ether2`
`/ip address add interface=vlan1000 address=123.45.60.1/22`
Теперь сделаем настройки на маршрутизаторе для наших клиентов. Для этого выделим им любые свободные IP из диапазона нашей публичной сети, допустим 123.45.60.5 и 123.45.60.6. Добавим статические маршруты для этих адресов, ведущие в соответствующие клиентские VLAN. При этом желательно указать preffered source адрес нашего маршрутизатора.
`/ip route add dst-address=123.45.60.5 gateway=vlan100 pref-src=123.45.60.1 comment="Static route to Client 1"`
`/ip route add dst-address=123.45.60.6 gateway=vlan200 pref-src=123.45.60.1 comment="Static route to Client 2"`
Настраиваем клиента №1:
IP: 123.45.60.5
Маска: 255.255.255.252 (или /22; да, тут мы указываем маску нашей «большой» публичной сети)
Шлюз: 123.45.60.1
Настраиваем клиента №2 аналогичным образом. Меняется только IP-адрес.
IP: 123.45.60.6
Маска: 255.255.255.252 (или /22)
Шлюз: 123.45.60.1
Всё. Этого достаточно. После этого IP клиентов будут доступны из интернета, без лишней траты адресов. Остальные клиенты включаются аналогичным образом, каждый — в свой VLAN. Но в данном случае у нас возникает такая ситуация: допустим, клиент №1 хочет передать ip-пакет клиенту №2. Поскольку адрес клиента №2 попадает под маску сети /22, клиент №1 считает что №2 находится с ним в одном широковещательном домене и попытается отправить пакет не через маршрутизатор, а напрямую, для чего попытается выяснить его MAC-адрес посредством протокола ARP. Само собой, у него это не выйдет, поскольку клиенты находятся в разных VLAN и не могут передавать друг другу ARP-запросы.
Если вам нужно изолировать клиентов друг от друга — можно оставить всё как есть, хотя с точки зрения интернета это неправильно (каждый узел должен иметь связь с другим узлом по протоколу IP). Решается такая ситуация включением proxy-arp на клиентских VLAN:
`/interface vlan set vlan100 arp=proxy-arp`
`/interface vlan set vlan200 arp=proxy-arp`
Теперь маршрутизатор будет отвечать на arp-запросы клиентов, подставляя свой MAC-адрес в ответе и клиенты смогут обмениваться IP-трафиком, словно находятся в одном сегменте.
Как вы могли догадаться, аналогичным образом можно назначать в один клиентский VLAN несколько IP-адресов или даже подсетей, просто создавая статические маршруты с соответствующим dst-address.
UPD:
Как показала практика, гораздо лучше создавать не статические маршруты в /ip route, а просто добавлять на интерфейс IP-адрес маршрутизатора с указанием в поле network нужного IP-адреса, маршрут будет создан автоматически. Пример:
`/ip address add network=123.45.60.5 interface=vlan100 address=123.45.60.1 comment="IPoE Client 1"`
`/ip address add network=123.45.60.6 interface=vlan100 address=123.45.60.1 comment="IPoE Client 2"` | https://habr.com/ru/post/213037/ | null | ru | null |
# Госпоиск состоялся: по Рунету начал ходить бот электронного правительства или госпоисковика
Roem.ru [обсуждает](http://roem.ru/2011/11/28/addednews39597/) теперь уже далеко не слух:
> За последние дни в несколько раз вырос входящий трафик. Логи показывают что сайт начал посещать некий бот именующий себя «SearchBot». IP-адрес указывает на то что это некий проект электронного правительства.
«Ведомости» около года назад [писали](http://www.vedomosti.ru/newspaper/article/248490/antigoogle_otmenyaetsya) ([копия статьи в открытом доступе](http://www.comnews.ru/index.cfm?id=57396)):
> Об идее «государственного поисковика» стало известно летом [2010 г.], когда сотрудники «Яндекса», Mail.ru и Rambler стали получать от некоей «окологосударственной» структуры предложения о переходе на работу в этот проект. Его цель, как объяснял высокопоставленный источник в Кремле, — стимулировать развитие отечественных технологий в перспективной сфере. Позднее советник президента Леонид Рейман заявил, что созданием поисковика занимаются частные компании, а Минкомсвязи лишь курирует проект. Министр же Игорь Щеголев всегда опровергал возможность господдержки для поисковой системы. Однако отсутствие финансирования национального поисковика в ФЦП еще не значит, что проект закрыт — возможно, деньги будут выделены из другого источника, предполагает руководитель одной из интернет-компаний.
Летом уже этого года те же «Ведомости» снова [освещали](http://www.vedomosti.ru/newspaper/article/2010/07/07/239777) давно тянущуюся эпопею:
> … недавно стало известно, что агентство по найму сотрудников Arthur Hunt Group переманивает разработчиков «Яндекса», Mail.ru и Rambler в новый проект, пользующийся поддержкой государства и сопоставимый по масштабу с «Яндексом». Такой проект готовится, сказал Рейман, только это не государственный заказ, а абсолютно «рыночная история»: поисковик разрабатывают частные компании — правда, при поддержке Минкомсвязи. Но в дальнейшем, когда продукт будет разработан, государство может принять участие в финансировании проекта, не исключил Рейман.
>
> По словам менеджеров интернет-компаний, сотрудников которых переманивает Arthur Hunt, **бюджет проекта составляет $100 млн, разработка должна начаться в течение трех месяцев, а заработать поисковик должен к концу 2011 г.** Какие именно компании участвуют в разработке, Рейман не уточнил. Представитель Минкомсвязи сообщил, что ему неизвестно о проекте создания поисковика, и добавил: в компетенцию министерства не входит реализация «рыночных проектов».
>
> Менеджеры интернет-компаний называют потенциальных подрядчиков — государственный «Ростелеком», компании ABBYY (разработчик систем распознавания текстов и электронных словарей) и «Ашманов и партнеры» (разработчик поисковых технологий).
[Комментарий](http://roem.ru/2011/10/17/addednews37458?c#message106738) лично г-на Ашманова на Roem.ru тоже указывает на вполне конкретных участников:
> … Там был Серёга Андреев из ABBYY со своей главной лингвисткой, кажется, и Владислав Рудников (КМ.ру) с Сергеем Татевосяном — главным разработчиком их поиска. Ну и я.
>
> Буквально с полуоборота Рудников с Татевосяном стали говорить министру, что Яндекс и Гугл почиют на лаврах, все инновации у них закончились давно, в 2006 году примерно, они стагнируют (то же самое словечко, что выше, кстати), вообще новых технологий поиска не выпускают. А вот КМ.ру, если дать ему эти планируемые 100 мегабаксов, даст невероятный инновационный проект. И обгонит Яндекс только так. То есть все инновации УЖЕ есть, проблема только с деньгами на технику.
>
> Причём это всё почему-то каким-то детским, наивным языком, как будто министр слабоумный ребёнок. Угар, в общем.
Все обращения бота происходит из подсети Ростелекома:
```
inetnum: 109.207.0.0 - 109.207.15.255
netname: Electronic-government
descr: OJSC Rostelecom
descr: Electronic government of the Russian Federation
country: RU
org: ORG-JR8-RIPE
admin-c: RTNC-RIPE
tech-c: RTNC-RIPE
status: ASSIGNED PI
mnt-by: RIPE-NCC-END-MNT
mnt-by: ROSTELECOM-MNT
mnt-lower: RIPE-NCC-END-MNT
mnt-routes: ROSTELECOM-MNT
mnt-domains: ROSTELECOM-MNT
source: RIPE # Filtered
route: 109.207.0.0/20
origin: AS196747
descr: Electronic-government
mnt-by: ROSTELECOM-MNT
source: RIPE # Filtered
```
P.S. Интересно, не связан ли случаем данный электронноправительственный поисковик с неким *«программно-аппаратным комплексом контроля информационно-коммуникационной сети интернет»*, который в этом году заказывал Роскомнадзор (см. журнал «Коммерсантъ Деньги», № 42 (849), 24.10.2011, статья «[Зарплата Большого брата](http://www.kommersant.ru/doc/1800370)»)? | https://habr.com/ru/post/133839/ | null | ru | null |
# Антипаттерны Vim
Когда вы находитесь в состоянии потока, Vim серьёзно ускоряет редактирование, будь то написание кода, поэзии или прозы. Но поскольку кривая обучения слишком крута для текстового редактора, то очень легко сохранить вредные привычки с тех времён, когда вы только осваивали редактор. Vim настолько ускоряет работу, что искоренить эти привычки особенно трудно, ведь их можно даже не заметить. Но это того стоит. Перечислю некоторые из наиболее распространённых антипаттернов.
#### Перемещение по одной строчке
Если вам нужно перепрыгнуть больше пары строк, то перемещение по одной строке клавишами `j` или `k` неэффективно. В Vim существует много [способов перемещения по вертикали](http://www.benorenstein.com/blog/jumping-long-distances-in-vim). Я считаю, что два наиболее полезных — прыжок по параграфам и по экранам. Это зависит от того, как далеко и как точно вам нужно двигаться.
* `{` — Перейти к началу предыдущего абзаца или блока кода.
* `}` — Перейти в конец следующего абзаца или блока кода.
* `Ctrl+F` — Перейти вперёд на один экран.
* `Ctrl+B` — Перейти назад на один экран.
Если вы точно знаете, куда нужно переместиться, то можно использовать навигацию через поиск: поиск вперёд клавишей `/`, а назад — `?`.
Также всегда полезно вернуться на предыдущее место, что достаточно легко сделать двумя кавычками или `gi`: возврат к последнему месту, где вы вводили текст. Если хотите, можно даже перемещаться между всеми местами, где вводился текст, с помощью `g;` и `g,`.
#### Перемещение по одному символу
Точно также и перемещение по одному символу клавишами `h` и `l` часто является пустой тратой времени, когда у нас есть `t` и `f`:
* `t` — Переместиться *вперёд до* следующего появления символа.
* `f` — Переместиться *вперёд за* следующее вхождение символа.
* `T` — Переместиться *назад до* предыдущего вхождения символа.
* `F` — Переместиться *назад за* предыдущее вхождение символа.
Перемещение по словам клавишами `w`, `W`, `b`, `B`, `e` и `E` тоже лучше. И здесь полезна навигация с поиском, и не забывайте, что вы можете *копировать, удалять и изменять текст* вперёд или назад к результату поиска:
> `y/search
>
> y?search
>
> d/search
>
> d?search
>
> c/search
>
> c?search`
#### Поиск слова под курсором
Не утруждайте себя набором слова или копированием/вставкой, просто нажмите `*` или `#`. Поразительно, насколько быстрее становится работа, когда освоишь эти горячие клавиши.
#### Удаление и вставка
Нет необходимости удалять текст с целью его замены, перейдя в режим вставки:
`d2wi`
Быстрее и аккуратнее использовать изменения клавишу `c`:
`c2w`
Так вся операция становится повторяемой с помощью точки (`.`).
#### Использование клавиш со стрелками
Vim позволяет использовать клавиши со стрелками для перемещения в нормальном режиме и в режиме вставки, но если вы привыкли использовать для навигации `hjkl`, то стрелки уже кажутся какими-то неуклюжими, потому что в течение всей сессии Vim пальцы находятся в [центре клавиатуры](https://en.wikipedia.org/wiki/Touch_typing), что удобно для слепой печати. Аналогично и клавиши Home и End: хотя они работают как в большинстве редакторов, но нет особой причины их использовать, когда ближе эквиваленты `^` и `$`.
Таким образом, целесообразно отучить себя от клавиш со стрелками, отключив их хотя бы временно:
`noremap
noremap
noremap
noremap`
Слепая печать центральными клавишами не только даёт преимущество скорости, но и позволяет лучше себя чувствовать, потому что запястья отдыхают перед клавиатурой и не перемещаются слишком далеко, а некоторых людям это даже [помогает уберечься от туннельного синдрома](https://www.reddit.com/r/vim/comments/mgt9q/vim_can_even_fix_my_body/).
#### Перемещение в режиме вставки
Дополнительное преимущество слепого набора в центральной строке в том, что вы избавляетесь от привычки перемещаться в режиме вставки: для этого предназначен нормальный режим. Как только нужно куда-то переместиться, вы переходите в нормальный режим и перемещаетесь гораздо более эффективно. Это также помогает сделать операции вставки более атомарными и, следовательно, более удобными для повтора.
#### Нажатие Esc
Клавиша Escape на современных клавиатурах намного дальше от центрального ряда, чем на [клавиатуре Билла Джоя](https://en.wikipedia.org/wiki/File:KB_Terminal_ADM3A.svg), когда он разрабатывал vi. Обычно нажатие Escape не требуется: `Ctrl+[` намного ближе и удобнее, вы довольно быстро измените свои привычки. Как вариант можно рассмотреть вопрос о сопоставлении в операционной системе на Esc довольно бесполезной клавиши Caps Lock или даже необычных сочетаний, таких как `jj`. Хотя это немного радикальное предложение, но хорошо работает для многих людей:
`inoremap jj`
#### Перемещение к началу или концу строки, затем вставка
Просто используйте `I` и `A`. К тому же, они делают действие повторяемым для других строк, где может понадобиться такая же операция.
#### Вход в режим вставки, затем создание новой строки
Используйте `o` и `O`, чтобы создать новую строку ниже и выше, соответственно, и одновременно войти в режим вставки на ней.
#### Вход в режим вставки для удаления текста
Здесь довольно очевидное противоречие. Вместо этого удалите текст, переместившись в него и используя `d` с соответствующим движением или текстовым объектом. Опять же, такое действие повторяемо и означает, что вы не удерживаете Backspace. Вообще, если вы удерживаете какую-то клавишу в Vim, вероятно, есть более быстрый способ.
#### Повтор команд или поисков
Просто введите `@:` для команды или n/N для поиска; Vim не забывает последний поиск. Если это была не самая последняя команда или поиск, но она точно есть в истории, введите `q:` или `q/`, найдите её в списке и нажмите Enter.
#### Повторные замены
Введите `&` для повтора на текущей строке последней замены. Можете повторить её на всех строках, набрав `g&`.
#### Повторный вызов макросов
Просто введите `@@`.
На самом деле это всего лишь несколько распространённых способов, чтобы увеличить скорость и общую эффективность работы с редактором без установки плагинов или существенных переназначений клавиш. См. также [вики с советами по Vim](http://vim.wikia.com/wiki/Vim_Tips_Wiki), там есть несколько других действительно полезных примеров. | https://habr.com/ru/post/442110/ | null | ru | null |
# Как поставить KDE на Simply Linux и помочь маме избавиться от проблем с Windows и зависимости от Microsoft
Мама у меня в прошлом - системный инженер БЭСМ-6 и ЕС ЭВМ. А вот с Windows 10 она сейчас хотя и дружит, но не так, чтобы уж очень.
Поэтому возникают инциденты, а я к ней приехать не всегда могу быстро.
Надо помогать маме удаленно, но прошлые эксперименты с TeamViewer оказались неудачны - маме, ввиду ее возраста, не очень просто понять, куда и какие коды вводить, какие цифры диктовать. Поэтому нужно решение, не требующее никаких действий со стороны пользователя.
Приехав в очередной раз, когда у компьютера "пропал звук" (а на самом деле, случайно была обнулена громкость), я увидел, что мамина Windows порядком устала — даже обновляться не хочет — процесс обновления висит-висит, и слетает. Да и браузер нахватал каких-то мерзопакостных всплывающих окон с рекламой... в общем, проще и быстрее ампутировать, чем лечить.
Поэтому я решил: устрою импортозамещение Windows, и поставлю российский ALT Linux. Действительно, там и терминал нормальный, и хотя с любимым маминым PL/1 туговато, но GNU Fortran и Algol68 в репозитории есть, можно порадовать маму, а еще настрою "удаленный помощник".
Сказано - сделаем! Провел лабораторную работу, и решение в итоге получилось таким:
— Домашние сети объединить через VPN-туннель, чтобы к маминому компьютеру всегда был доступ. Здесь ничего сложного нет, поэтому подробно останавливаться на этом вопросе не буду.
— А вот в качестве операционной системы на мамин компьютер в итоге решил поставить Simply Linux, самую последнюю версию - десятую, которую скачать можно [здесь](https://www.basealt.ru/simplylinux/download). Правда, там по умолчанию XFCE, который мне никогда не нравился, и я решил заменить его на более функциональный KDE.
В таком варианте лучше при установке снять все галочки приложений - это избыточно. И конечно же, не забыть настроить автоматический вход в систему для пользователя, под которым будет работать мама.
— Чтобы KDE был установлен корректно и его не пришлось впоследствии *патчить*(кто это делал под Free BSD, тот знает, что маму этим мучать точно не надо, и себя тоже незачем), в Simply Linux лучше всего использовать команду:
> `$ sudo apt-get install kde5-big`
>
>
(да, она поставит много лишнего, но лучше потом удалить отдельные ненужные приложения, чем ловить ошибки в настройках).
— После завершения установки KDE надо настроить сеанс по умолчанию. Для этого ставим wm-select:
> `$ sudo apt-get install wm-select`
>
>
Увы, после этого wm-select сразу не запустится. Идем в домашнюю папку и убиваем настроечный файл:
> `$ rm -f ~/.wm-select`
>
>
Теперь запускаем wm-select, ставим галочку и нажимаем кнопку кнопку Plasma со значком KDE.
Настраиваем графический рабочий стол по умолчанию(после этого я предпочел перезагрузиться, т.к. KDE запустился, но как-то кривовато)
— Далее, запускаем krfb — это приложение обеспечивает доступ к удаленному рабочему столу:
> `$ krfb`
>
>
Появится окно «Совместный доступ к рабочему столу». В нем нужно:
— Поставить обе галочки «Включить доступ к компьютеру» и «Разрешить доступ без подтверждения»
**(это не очень безопасно, но я пока решил, что в моем случае простота важнее, и потом, эту настройку всегда можно будет поменять)**
— Сохранить реквизиты для подключения (имя хоста, адрес, порт), которые отображаются в поле «Адрес» (они еще пригодятся)
Задать пароли в поле «Пароль» (кнопка с карандашом поможет поменять сгенерированный автоматически пароль) и по кнопке «Сменить пароль доступа» (для простоты я установил один и тот же пароль).
— Далее нужно обзавестись VNC-клиентом. Поскольку я собираюсь подключаться как удаленный помощник с Windows-хоста, то выбрал Tight VNC. У этого продукта есть свободная и проприетарная версия. Проприетарная для решаемой задачи не нужна, поэтому качаем свободную версию [отсюда](https://www.tightvnc.com/download/2.8.63/tightvnc-2.8.63-gpl-setup-64bit.msi).
(в Linux можно использовать любой VNC-клиент, например, Remmina)
При установке Tight VNC выбираем, конечно же, Custom режим и отключаем VNC -Server.
Экран установщика TightVNC Server(на этом месте внимательный читатель скажу же скажет: а зачем было ставить Simply Linux и KDE, если можно было поставить на мамин компьютер c Windows TightVNC Server? — Да, так тоже можно, но целью этой статьи является демонстрация того, как *избавиться* *от проблем с Windows и зависимости от Microsoft*, см. заголовок)
— После установки можно подключаться к удаленному VNC-серверу на мамином компьютере - его мы настроили раньше, в окне krfb.
Запускаем TightVNC Viewer и в поле Remote Host указываем ip:порт или имя\_хоста:порт (которые были в поле «Адрес» окна «Совместный доступ к рабочему столу» kfrb):
Экран клиента TightVNC ServerНажимаем Connect и вводим пароль для подключения в поле «Password» в окне Vnc Authentication:
Авторизуемся на мамином компьютереи подключаемся к удаленному рабочему столу в режиме «Удаленного помощника»:
Удаленный рабочий стол в Tight VNC— Теперь дело за малым — поставить мессенджеры для аудио/видеозвонков и Yandex Browser для комфортной работы в Интернет.
Эти сторонние приложения лучше всего установить при помощи стандартного приложения appinstall
> `$ appinstall`
>
>
Далее вводим пароль администратора и ставим нужные приложения отсюда:
Устанавливаем полезный софт(внимательный читатель обнаружит, что тут есть много еще интересного, и chromium-gost, и zoom, и даже Visual Studio Code, но зачем все это маме?)
После установки приложений остается закрепить их значки на панели задач и сделать ярлыки на рабочем столе. Теперь мама может спокойно работать, и мы можем ей помочь, подключившись по VNC.
Задача, кажется, решена полностью?... Но нет, оказывается, что подключение к krfb не удастся установить после перезагрузки маминого компьютера, и вообще, если будет остановлен соответствующий процесс.
Чтобы решить эту проблему, настраиваем автозапуск krfb в свернутом режиме. Для этого создаем в домашней папке файл shell-скрипта и делаем его исполняемым:
> `$ touch ~/krfb_launch.sh`
>
> `$ chmod +x ~/krfb_launch.sh`
>
>
Далее, открываем файл в любом текстовом редакторе, например, mcedit (он в Simply Linux ставится по умолчанию, как и mc - Midnight Commander) или KWrite и добавляем туда следующий bash код:
```
#!/bin/bash
sleep 15s && kstart5 --skiptaskbar --iconify krfb
```
Это решение немного костыльное. Поясню, что все это значит:
```
kstart5 --skiptaskbar --iconify krfb
```
обеспечивает вызов krfb в свернутом в иконку режиме, без отображения на панели задач. При этом приложение можно будет открыть из системного трея ("Состояния и уведомления", при настройках по умолчанию - меню между значком менеджера подключений и часами):
krfb в системном трее KDE 5А достаточно длительная задержка
```
sleep 15s
```
необходима для того, чтобы krfb запустился после инициализации всех прочих служб, включая сетевое подключение. В противном случае, VNC-сервер может запуститься на адресе 127.0.0.1, а нам это не нужно.
Теперь, чтобы скрипт `krfb_launch.sh` запускался автоматически при старте сессии KDE, открываем "Настройки" => "Параметры системы KDE 5", затем на вкладке "Запуск и завершение" выбираем "Автозапуск" => "Добавить", "Добавить приложение" и выбираем `krfb_launch.sh.` См. рисунок:
Настройка автозапуска приложенийТеперь krfb будет запускаться и после перезагрузки компьютера. | https://habr.com/ru/post/660009/ | null | ru | null |
# Прошивку терминала Starlink скачали и проанализировали
*Для прерывания процесса загрузки пользовательского терминала нужно ввести команду "‘falcon".*
Инженер из Бельгии по имени Леннерт Воутерс (Lennert Wouters) сумел [скачать и проанализировать](https://www.esat.kuleuven.be/cosic/blog/dumping-and-extracting-the-spacex-starlink-user-terminal-firmware/) прошивку спутникового терминала Starlink. В ходе своих изысканий он [сделал](https://hackaday.com/2021/07/07/starlink-terminal-unit-firmware-dumped/) несколько интересных наблюдений и обнаружил, что существуют разные версии терминала, включая отдельную версию оборудования для разработчиков, которая защищена флагом геозоны. Даже инженеры SpaceX не везде могут работать в режиме настройки такого оборудования.
Эксперт рассказал, что получил комплект Starlink в конце мая, успел за несколько дней провести начальные исследования оборудования, выгрузить и извлечь прошивку пользовательского терминала системы. Он также добавил, что SpaceX поощряет действия энтузиастов, которые могут найти уязвимости в спутниковом комплекте, открыла доступ к программе багбаунти на портале bugcrowd и дает за обнаруженные программные дыры в прошивке или работе устройств до $25 тыс.
После сборки и настройки комплекта Starlink Воутерс сначала обновил его до последней версии прошивки и провел тестирование скорости. Он получил 268 Мбит при скачивании и 49 Мбит при загрузке в сети.
После проведения штатных проверок и изучения работы и принципов разборки терминала по роликами на YouTube, Воутерс начал операцию по его вскрытию и получению доступа к центральному чипу на базе 4-ядерного SoC Cortex-A53.
В процессе разборки инженер нашел в корпусе терминала несколько разъемов — для кабеля Ethernet и управления двигателем, а также один дополнительный незадействованный четырехпиновый разъем интерфейса отладки по UART. К нему и подключился Воутерс для проверки механизма загрузки.
*Инженер обнаружил, что терминал использует загрузчик U-Boot, а для прерывания процесса загрузки нужно ввести команду "‘falcon", хотя это не поможет в текущей конфигурации, так как последовательный ввод в терминале настроен на nulldev.*
В процессе работы U-Boot загружает ядро, RAM-диск и Flattened Device Tree (FDT) из образа Flattened uImage Tree (FIT), который хранится на встроенной карте памяти MultiMediaCard (eMMC). При загрузке проверяется целостность (с помощью SHA256) и подлинность (по RSA 2048) кода ядра, RAM-диска и FDT. В системе реализована полная доверенная цепочка загрузки (TF-A) от начального загрузчика ROM до операционной системы Linux.
Оставшаяся часть процесса загрузки также содержит интересные фрагменты информации. Например, там можно видеть аргументы командной строки ядра, а также начальные адреса и длину некоторых разделов. Кроме того понятно, что SoC содержит 4 ядра.
*Наконец, когда терминал завершает процесс загрузки, появляется приглашение для входа в систему.*
Воутерс сделал несколько попыток угадать заводские учетные данные, но ничего не получилось. Он решил пойти глубже и начал разбирать антенну терминала для получения прямого доступа к центральному чипу и карте памяти устройства.
*Оказалось, что центральный чип в корпусе с flip-chip BGA с металлической крышкой имеет маркировку ST GLLCCOCA6BF. Он подключен к энергозависимому хранилищу DRAM и энергонезависимому флэш-хранилищу в виде микросхемы eMMC.*
Исследователь обнаружил, что встроенная карта памяти eMMC, содержащая флеш-память и контроллер, очень похожа на SD-карту, а ее микросхема Micron eMMC имеет маркировку JY976. Оказалось, что это микросхема MTFC4GACAJCN-1M с 4 ГБ флэш-памяти в корпусе BGA-153.
Воутерс решил не демонтировать чип памяти, что могло бы привести к его повреждению, а попытался сбросить внутрисхемный дамп eMMC.
*Инженер смог идентифицировать сигналы CLK, CMD и D0 по 10 контрольным точкам около центрального SoC. Это были линии CMD, CLK и 8 линий данных с чипа памяти.*
*Сигнал CLK был единственным повторяющимся сигналом, CMD — это сигнал, который был первым активным после того, как CLK начал переключаться, а D0 — это первая линия данных для отправки данных. К счастью, определение оставшихся 7 строк данных не нужно для дампа содержимого eMMC.*
*Подключение считывателя к карте памяти терминала.*
*Получение данных с карты памяти.*
После анализа скачанных данных и изучения [модификации U-Boot от SpaceX](https://github.com/SpaceExplorationTechnologies) на Github, Воутерс понял, что некоторые части прошивки хранятся в кастомном формате, который содержит в себе данные кода исправления ошибок (ECC). Исследователь решил убрать эти данные ECC с помощью скрипта Python и смог расшифровать файл spacex\_catson\_boot.h, в котором содержится информация о процессе загрузки терминала. Также инженер смог прочитать другие файлы системы и даже нашел возможность зайти в систему под root. Оказалось, что для этого нужна другая версия терминала. Текущая пользовательская версия терминала не имеет такой возможности и ее нельзя переделать.
Вдобавок исследователь обнаружил из ссылок в прошивке, что пользовательский терминал содержит защищенный элемент STMicroelectronics STSAFE. Назначение защищенного элемента не совсем понятно. Воутерс предположил, что SpaceX использует его для удаленной аутентификации терминала.
Инженер рассказал, что каждому ядру центрального чипа поставлена своя задача.
`############################
# System Information
############################
#
# The user terminal phased-array computers are Catson SoCs with a quad-core
# Cortex-A53.
#
# We dedicate one core to control, while leaving the other three to handle
# interrupts and auxiliary processes.
#
# CPU 0: Control process.
# CPU 1: Lower-MAC RX process.
# CPU 2: Lower-MAC TX process.
# CPU 3: PhyFW and utility core - interrupts, auxiliary processes, miscellaneous`
Воутерс подытожил, что он только начал работать с терминалом и продолжит изучать его внутренний код. В его планах рассказывать публично о новых открытиях после проверки всех данных.
9 февраля 2021 года Starlink [открыла](https://habr.com/ru/news/t/541726/) прием предзаказов на подключение к системе спутникового интернета. Компания принимает те запросы, где сейчас у нее есть разрешения на оказания услуг и технические возможности их предоставить в скорое время.
В январе энтузиаст безвозвратно [разобрал](https://habr.com/ru/news/t/537116/) антенну Starlink и изучил ее элементы под рентгеном.
В начале ноября прошлого года бета-тестеры Starlink [показали](https://habr.com/ru/news/t/526128/), как выглядит присланный им [комплект](https://imgur.com/a/1H07UqT) оборудования для спутникового интернета.
SpaceX с мая 2019 года выводит на орбиту группы мини-спутников в рамках проекта Starlink. SpaceX собирается [обеспечить](https://habr.com/ru/news/t/564070/) глобальное покрытие сети спутникового интернета Starlink к сентябрю этого года. | https://habr.com/ru/post/566820/ | null | ru | null |
# Pysa: как избежать проблем безопасности в коде Python
[](https://habr.com/ru/company/skillfactory/blog/519702/)
7 августа Facebook представил Pysa — ориентированный на безопасность статический анализатор с открытым исходным кодом, помогающий работать с миллионами строк в Instagram. Раскрыты ограничения, затронуты проектные решения и, конечно, средства, помогающие избегать ложных положительных срабатываний. Показана ситуация, когда Pysa наиболее полезен, и код, в котором анализатор неприменим. Подробности из блога Facebook Engineering под катом.
В прошлом году мы писали о том, как создавали [Zoncolan](https://engineering.fb.com/security/zoncolan/), инструмент статического анализа, который анализирует более 100 миллионов строк [кода Hack](https://hacklang.org/) и помогает инженерам предотвращать тысячи потенциальных проблем безопасности. Успех вдохновил на работу над [Pysa](https://pyre-check.org/docs/pysa-basics.html) — Python Static Analyzer. Анализатор построен на основе Pyre, инструмента Facebook для проверки типов Python. Pysa работает с потоком данных в коде. Анализ потоков данных полезен потому, что часто проблемы безопасности и конфиденциальности моделируются как данные, поступающие туда, где их не должно быть.
Pysa помогает выявлять много типов проблем. Анализатор проверяет, правильно ли код использует определённые внутренние структуры для предотвращения доступа или раскрытия пользовательских данных на основе технических политик конфиденциальности. Кроме того, анализатор обнаруживает распространенные проблемы безопасности веб-приложений, такие как XSS и SQL-инъекции. Как и Zoncolan, новый инструмент помог масштабировать усилия в сфере безопасности приложений на Python. Особенно это касается Instagram.
Pysa в Instagram
----------------
Самый большой репозиторий Python в Facebook — это миллионы строк на серверах Instagram. Когда Pysa запускается на предлагаемом разработчиком изменении кода, он предоставляет результаты примерно за час, а не за недели или месяцы, которые могут потребоваться для проверки вручную. Это помогает найти и предотвратить проблему достаточно быстро, чтобы она не проникла в кодовую базу. Результаты проверок поступают напрямую разработчику или инженерам по безопасности, в зависимости от типа проблемы и отношения сигнал/шум в конкретной ситуации.
Pysa и Open Source
------------------
[Исходный код Pysa](https://github.com/facebook/pyre-check/) и [множества определений для поиска проблем](https://github.com/facebook/pyre-check/tree/master/stubs/taint) открыт, чтобы другие разработчики анализировали код своих проектов. Мы работаем с серверными фреймворками с открытым кодом, такими как [Django](https://github.com/django/django) и [Tornado](https://github.com/tornadoweb/tornado), поэтому с первого запуска внутри Facebook Pysa находит проблемы безопасности в проектах, использующих эти фреймворки. Применение Pysa для фреймворков, покрытия для которых ещё нет, обычно не сложнее добавления нескольких строк конфигурации. Нужно просто сообщить анализатору, откуда данные поступают на сервер.
Pysa применялся для обнаружения таких проблем, как [CVE-2019-19775](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-19775), в проектах Python с открытым кодом. Мы также работали [с проектом Zulip](https://github.com/zulip/zulip) и включили Pysa в его кодовую базу.
Как это работает?
-----------------
Pysa разработан с учетом уроков, извлеченных из Zoncolan. Он применяет те же алгоритмы для выполнения статического анализа и даже делит код с Zoncolan. Как и Zoncolan, Pysa отслеживает потоки данных в программе. Пользователь определяет источники важных данных и приёмники, куда данные приходят. В приложениях безопасности наиболее распространенные виды источников — это точки, где контролируемые пользователем данные поступают в приложение, такие как словарь [HttpRequest.GET](https://docs.djangoproject.com/en/3.0/ref/request-response/#django.http.HttpRequest.GET) в Django. Приемники, как правило, гораздо более разнообразны и могут включать выполняющие код API. Например, `eval` или `os.open`. Pysa итерационно выполняет раунды анализа для построения сводок, чтобы определить, какие функции возвращают данные из источника, а какие имеют параметры, достигающие приемника. Когда анализатор обнаруживает, что источник в конечном итоге подключается к приемнику, то сообщает о проблеме. Визуализация этого процесса — дерево с проблемой на вершине и источниками и потоками в листьях:
Чтобы выполнять межпроцедурный анализ — следовать по потокам данных между вызовами функций — нужно иметь возможность сопоставлять вызовы функций с их реализациями. Для этого нужно использовать всю доступную информацию в коде, включая необязательные статические типы, если они присутствуют. Мы работали Pyre, чтобы разобраться с этой информацией. Хотя Pysa в значительной степени полагается на Pyre и оба инструмента совместно используют один репозиторий, важно отметить, что это отдельные продукты с отдельными приложениями.
Ложные срабатывания
-------------------
Инженеры по безопасности — основные пользователи Pysa в Facebook. Как и любой инженер, работающий с автоматизированными средствами обнаружения ошибок, мы должны были решить, как бороться с ложными положительными срабатываниями (проблемы нет, есть сигнал) и негативами (проблема есть, нет сигнала).
Дизайн Pysa направлен на то, чтобы избегать пропуска проблем и обнаруживать как можно больше реальных проблем. Однако уменьшение количества ложных сигналов может потребовать компромиссов, которые увеличивают количество бесполезных сигналов. Слишком много ложных положительных срабатываний вызывает усталость от тревоги и риск того, что действительно существующие проблемы будут упущены в шуме. В Pysa есть два инструмента для удаления лишних сигналов: санитайзеры и признаки.
[Санитайзер](https://pyre-check.org/docs/pysa-basics.html#sanitizers) — простой инструмент. Он сообщает анализатору не идти по потоку данных после того, как поток пройдёт через функцию или атрибут. Санитайзеры позволяют закодировать доменные знания о преобразованиях, которые всегда представляют данные в безопасной и конфиденциальной форме.
[Признаки](https://pyre-check.org/docs/pysa-features.html) работают тоньше: это небольшие фрагменты метаданных, которые Pysa присоединяет к потокам данных по мере отслеживания. В отличие от санитайзеров, признаки не удаляют проблемы из результатов анализа. Признаки и другие метаданные могут применяться для фильтрации результатов после анализа. Фильтры обычно пишутся для конкретной пары источник-приемник, чтобы игнорировать проблемы в случае, когда данные уже обработаны для определённого типа (но не для всех типов) приемника.
Чтобы понять, в каких ситуациях Pysa наиболее полезен, представьте, что для загрузки профиля пользователя работает такой код:
```
# views/user.py
async def get_profile(request: HttpRequest) -> HttpResponse:
profile = load_profile(request.GET['user_id'])
...
# controller/user.py
async def load_profile(user_id: str):
user = load_user(user_id) # Loads a user safely; no SQL injection
pictures = load_pictures(user.id)
...
# model/media.py
async def load_pictures(user_id: str):
query = f"""
SELECT *
FROM pictures
WHERE user_id = {user_id}
"""
result = run_query(query)
...
# model/shared.py
async def run_query(query: str):
connection = create_sql_connection()
result = await connection.execute(query)
...
```
Здесь потенциальная SQL-инъекция в load\_pictures не может эксплуатироваться: эта функция всегда получает валидный `user_id` из функции `load_user` в `load_profile`. При правильной настройке Pysa, вероятно, не сообщит о проблеме. Теперь представьте, что предприимчивый инженер, который пишет код на уровне контроллера, понял, что одновременная выборка данных пользователя и изображения возвращает результаты быстрее:
```
# controller/user.py
async def load_profile(user_id: str):
user, pictures = await asyncio.gather(
load_user(user_id),
load_pictures(user_id) # no longer 'user.id'!
)
...
```
Изменение может выглядеть безобидно, но на самом деле заканчивается объединением контролируемой пользователем строки `user_id` с проблемой SQL-инъекции в `load_pictures`. В приложении с большим количеством уровней между точкой входа и запросами базы данных инженер может не понять, что данные полностью контролируются пользователем, или что проблема инъекции скрывается в вызываемой функции. Это именно та ситуация, для которой написан анализатор. Когда инженер предлагает подобное изменение в Instagram, Pysa обнаруживает, что данные идут от управляемого пользователем ввода до SQL-запроса, и сообщает о проблеме.
Ограничения анализатора
-----------------------
[Невозможно написать идеальный статический анализатор](https://www.scientificamerican.com/article/why-is-turings-halting-pr/). Pysa имеет ограничения, связанные с областью применения, потоком данных и проектными решениями, компромиссом с производительностью ради точности и аккуратности. Python как динамический язык обладает уникальными особенностями, лежащими в основе некоторых из этих проектных решений.
Пространство проблемы
---------------------
Pysa создан для обнаружения только проблем безопасности, связанных с потоками данных. Не все проблемы безопасности или конфиденциальности моделируются как потоки данных. Посмотрите пример:
```
def admin_operation(request: HttpRequest):
if not user_is_admin():
return Http404
delete_user(request.GET["user_to_delete"])
```
Pysa — не тот инструмент, чтобы гарантировать, что проверка авторизации `user_is_admin` запущена перед привилегированной операцией `delete_user`. Анализатор может обнаружить данные из `request.GET`, направленные в `delete_user`, но эти данные никогда не проходят через проверку `user_is_admin`. Код можно переписать, чтобы сделать проблему моделируемой Pysa, или встроить проверку разрешений в административную операцию `delete_user`. Но этот код прежде всего показывает, какие проблемы не решает Pysa.
Ограничения ресурсов
--------------------
Мы приняли проектное решение об ограничениях, чтобы Pysa мог закончить анализ до того, как предлагаемые разработчиками изменения попадут в кодовую базу. Когда анализатор отслеживает потоки данных в слишком большом количестве атрибутов объекта, иногда приходится упрощать и рассматривать весь объект как именно содержащий эти данные. Это может привести к ложным срабатываниям.
Ещё одно ограничение — время разработки. Оно заставило пойти на компромисс в том, какие особенности Python поддерживаются. Pysa пока не включает декораторы в граф вызовов при вызове функций и поэтому пропускает проблемы внутри декораторов.
Python как динамический язык
----------------------------
Гибкость Python затрудняют статический анализ. Трудно отслеживать потоки данных через вызовы методов без информации о типе. В коде ниже невозможно определить, какая из реализаций `fly` вызывается:
```
class Bird:
def fly(self): ...
class Airplane:
def fly(self): ...
def take_off(x):
x.fly() # Which function does this call?
```
Анализатор работает в полностью нетипизированных проектах. Но [требуется небольшое усилие](https://pyre-check.org/docs/pysa-coverage.html), чтобы покрыть важные типы.
Динамическая природа Python накладывает ещё одно ограничение. Смотрите ниже:
```
def secret_eval(request: HttpRequest):
os = importlib.import_module("os")
# Pysa won't know what 'os' is, and thus won't
# catch this remote code execution issue
os.system(request.GET["command"])
```
Здесь ясно видна уязвимость выполнения, но анализатор пропустит её. Модуль `os` импортируется динамически. Pysa не понимает, что локальная переменная os представляет именно модуль `os`. Python позволяет динамически импортировать практически любой код и в любой момент. Кроме того, в языке можно изменять поведение вызова функции практически для любого объекта. Pysa может научиться анализировать os и обнаруживать проблему. Но динамизм Python означает, что существуют бесконечное множество примеров патологических потоков данных, которые анализатор не увидит.
Результаты
----------
В первой половине 2020 года на счету Pysa 44 процента всех обнаруженных в Instagram проблем. Среди всех типов уязвимостей в предлагаемых изменениях кода найдены 330 уникальные проблемы. 49 (15%) проблем оказались существенными, 131 из проблем (40%) реальны, но имели смягчающие обстоятельства. Ложные негативы зафиксированы в 150 (45%) случаев.
Мы регулярно рассматриваем проблемы, сообщаемые другими способами. Например, через программу Bug Bounty. Так мы убеждаемся, что исправляем все ложные отрицательные сигналы. Обнаружение каждого типа уязвимости настраивается. Благодаря постоянным уточнениям инженеры по безопасности перешли к более совершенным типам, чтобы сообщать о действительно существующих проблемах в 100 процентах случаев.
В целом мы довольны компромиссами, на которые пошли, чтобы помочь инженерам безопасности масштабироваться. Но всегда есть пространство для развития. Мы создали Pysa, чтобы постоянно повышать качество кода благодаря тесному сотрудничеству инженеров безопасности и программистов. Это позволило нам быстро выполнить итерации и создать инструмент, удовлетворяющий наши потребности лучше, чем любое готовое решение. Сотрудничество инженеров привело к дополнениям и уточнениям в механизмах Pysa. Например, изменился способ просмотра трассировки проблем. Теперь проще видеть ложные негативы.
[Документация анализатора Pysa](https://pyre-check.org/docs/pysa-basics.html) и [туториал](https://github.com/facebook/pyre-check/tree/master/pysa_tutorial).
> [](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
>
> Получить востребованную профессию с нуля или Level Up по навыкам и зарплате, можно, пройдя онлайн-курсы SkillFactory:
>
>
>
> * [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=PWS&utm_term=regular&utm_content=180920) (9 месяцев)
> * [Курс «Python для анализа данных»](https://skillfactory.ru/python-analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=PY&utm_term=regular&utm_content=180920) (2 месяца)
> * [Комплексный курс по глубокому обучению на Python](https://skillfactory.ru/deep-learning?utm_source=infopartners&utm_medium=habr&utm_campaign=DL&utm_term=regular&utm_content=180920) (10 недель)
>
>
>
>
> **Eще курсы**
> * [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=ML&utm_term=regular&utm_content=180920) (12 недель)
> * [Продвинутый курс «Machine Learning Pro + Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=MLDL&utm_term=regular&utm_content=180920) (20 недель)
> * [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=MATML&utm_term=regular&utm_content=180920) (20 недель)
> * [Обучение профессии Data Science с нуля](https://skillfactory.ru/data-scientist?utm_source=infopartners&utm_medium=habr&utm_campaign=DST&utm_term=regular&utm_content=180920) (12 месяцев)
> * [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=WEBDEV&utm_term=regular&utm_content=180920) (8 месяцев)
> * [Профессия аналитика с любым стартовым уровнем](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=SDA&utm_term=regular&utm_content=180920) (9 месяцев)
> * [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=DEVOPS&utm_term=regular&utm_content=180920) (12 месяцев)
> * [Профессия Java-разработчик с нуля](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=JAVA&utm_term=regular&utm_content=180920) (18 месяцев)
> * [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=FJS&utm_term=regular&utm_content=180920) (12 месяцев)
>
>
>
>
>
>
> | https://habr.com/ru/post/519702/ | null | ru | null |
# Как мы помогли cybersport.ru справиться с The International 10
Наш клиент [cybersport.ru](https://www.cybersport.ru/) — один из самых популярных информационно-новостных порталов про киберспорт в СНГ. По данным Similarweb, в октябре 2021 года у сайта было [16,5 млн посещений](https://www.similarweb.com/website/cybersport.ru/).
Обычно нагрузка на cybersport.ru даже во время значимых событий не превышает 400 RPS (requests per second). Так было до недавнего времени, точнее — до The International 10. Турнир вернулся после годичного перерыва из-за пандемии, что подогрело интерес к нему. Ажиотажа добавило и успешное выступление российских команд. В итоге во время турнира нагрузка достигала небывалых для сайта 2300 RPS.
Серверы и сайт выдержали в основном за счет оперативного масштабирования ресурсов. И в этом, конечно, нет ничего необычного — рядовая задача для инженеров эксплуатации. Однако, чтобы всё четко отработало во время The International 10, нашей команде пришлось провести подготовительные работы, в том числе кубернетизацию инфраструктуры cybersport.ru.
В этом посте расскажем:
* зачем cybersport.ru нужно было переезжать в Kubernetes и о сопутствующих трудностях;
* почему пришлось сменить IaaS-провайдера;
* почему было сложно во время The International 10, и как мы с этим справились;
* почему автоматическое масштабирование ресурсов — не лучший выход для cybersport.ru (и вообще, для веб-ресурсов с таким же характером нагрузки).
Переезд в Kubernetes
--------------------
Сайт cybersport.ru — часть киберспортивного холдинга ESforce, в который также входит самая титулованная киберспортивная команда России Virtus.pro. «Флант» уже более 3 лет поддерживает инфраструктуру ESforce.
Игрок Virtus.pro Тимур «buster» Тулепов (CS:GO)До того, как мы подключились к проектам ESforce, инфраструктура всех проектов, включая cybersport.ru, была развернута на облачных серверах одного из ведущих западных провайдеров. Простейший CI/CD был организован на базе Ansible и управлялся через Ansible Tower. Разработчикам не хватало гибкости инфраструктуры, она была плохо адаптирована к cloud native-среде. Поэтому мы предложили перенести все важные сервисы в Kubernetes, настроить CI/CD и организовать [review-окружения](https://habr.com/ru/company/flant/blog/571482/).
При миграции в K8s наши SRE-/DevOps-инженеры тесно взаимодействовали с разработчиками ESforce. Всё прошло без больших задержек и серьезных проблем. Небольшие трудности возникали только во время построения CI/CD-процесса, но они оперативно решались.
Чехарда с провайдерами
----------------------
Переезд в Kubernetes состоялся еще в облаке зарубежного поставщика, но от него в итоге пришлось отказаться. Основные причины:
* **конфликт Telegram и Роскомнадзора:** когда РКН стал блокировать пулы адресов, — включая те, что принадлежат провайдеру, — под угрозой оказались и сайты ESforce;
* **требования 152-ФЗ:** российские веб-проекты должны хранить данные на территории РФ;
* **дороговизна** по сравнению с ценами на российские облака.
### Этап 1. Переезд в российское облако
Благодаря унифицированной и кубернетизированной инфраструктуре, миграция к одному из российских провайдеров прошла легко и быстро. Однако впоследствии мы столкнулись с проблемой, которой не было у западного провайдера: CPU steal time.
Если кратко, CPU steal time — задержка, которая вызвана перегруженностью гипервизоров при [оверселлинге CPU](https://ru.wikipedia.org/wiki/%D0%9E%D0%B2%D0%B5%D1%80%D1%81%D0%B5%D0%BB%D0%BB%D0%B8%D0%BD%D0%B3#%D0%9E%D0%B2%D0%B5%D1%80%D1%81%D0%B5%D0%BB%D0%BB%D0%B8%D0%BD%D0%B3_%D0%BD%D0%B0_%D1%80%D0%B0%D0%B7%D0%BB%D0%B8%D1%87%D0%BD%D1%8B%D1%85_%D0%B2%D0%B8%D1%80%D1%82%D1%83%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F%D1%85). Виртуальные машины (ВМ) начинают конкурировать за выделение ресурсов; та ВМ, которая недополучает ресурсы, начинает сильно замедляться. Это в свою очередь приводит к проблемам в работе ОС и приложений.
Ниже — архивный график с данными нашей системы мониторинга. На нем видно, насколько высоким был уровень CPU steal time:
Проблема привела к тому, что инфраструктура стала нестабильной, постоянно сбоила; снизился SLA. Посыпались новые неприятности — даже такие, с которыми мы раньше не сталкивались. В такой обстановке не могло быть и речи об оптимизации инфраструктуры и кода, поскольку сложно было определить первопричину сбоев в работе приложения.
### Этап 2. Переезд на «железные» серверы
В 2019 году не все российские облачные поставщики гарантировали отсутствие CPU steal time. Поэтому мы решили переехать к другому провайдеру, на «железные» серверы.
После переезда, в ходе оптимизации инфраструктуры и приложения, обнаружился ряд узких мест.
**1. Redis**. Изучив данные APM-системы (Application Performance Monitoring), мы выявили некорректное взаимодействие приложения и Redis. Количество подключений к сервису достигало 1,2 млн запросов в минуту; объем Set/Get-операций был слишком высок. В итоге Redis отвечал долго, сайты работали медленно.
Ниже — графики с результатами нагрузочного тестирования:
В некоторые моменты в Redis поступало более 1 млн запросов в минутуВремя веб-транзакций доходило до 750 мс из-за медленных ответов RedisВремя ответа сервера при 300+ OPS (operations per second)Вместе с разработчикам нам удалось оперативно обнаружить причину. Оказалось, что дело в неправильно настроенном процессе кэширования, из-за которого в кэш помещались постоянно обновляемые данные.
**2. Нагрузка на PostgreSQL.** Приложение создавало сетевую нагрузку на Postgres в 1 Гбит/с. Это было потолком для «железных» серверов в текущей конфигурации и приводило к недоступности cybersport.ru.
Как мы решили проблему:
* Перевели проект на 10 Гбит/с;
* Оптимизировали запросы к БД со стороны кода.
### Этап 3. Обратно в облако
Популярность cybersport.ru росла, нагрузка — тоже. Сайту требовалось больше вычислительных ресурсов, которые можно было бы оперативно наращивать. Вдобавок, за соответствие 152-ФЗ у текущего поставщика приходилось доплачивать. То есть нужен был cloud-провайдер с гарантированным ресурсом по CPU и приемлемым ценником за 152-ФЗ. И в 2021 году cybersport.ru наконец-таки обосновались в облаке российского провайдера, который удовлетворял обоим критериям.
Влияние пандемии
----------------
К моменту переезда к новому провайдеру все более или менее значимые киберспортивные мероприятия отменили. У cybersport.ru не было реальной возможности оценить отказоустойчивость инфраструктуры во время пиковых нагрузок, кроме как с помощью синтетических тестов. Но для таких веб-сервисов синтетические тесты малополезны: они далеки от поведения реальных пользователей. Тем не менее, других вариантов не было, и мы готовились к The International 10 как могли — «в теории»…
И на старте турнира возникли некоторые проблемы.
The International 10. Проверка боем
-----------------------------------
В реальных условиях не всё пошло гладко. Сперва даже относительно невысокая нагрузка — в 600 RPS — приводила к тому, что сайт падал. Основные причины:
* «разумная экономия» и, как следствие, ограничение количества заказываемых ресурсов под возрастающую нагрузку;
* характер самой нагрузки, ее пиковость — мы быстро упирались в доступный объем ресурсов, а пока заказывали новые, серверы «пятисотили».
Пример пиков нагрузки во время The International 10### Небольшое отступление: автомасштабирование в Kubernetes
И в *идеальном* случае, т. е. когда нет финансовых и технических ограничений, желательно обеспечить несколько уровней горизонтального масштабирования и резервирования приложения — на уровне Pod’ов (количества экземпляров приложения) и на уровне кластера (количества узлов).
**Автомасштабирование Pod’ов:**
* выбираем метрику, на основе которой будут масштабироваться Pod’ы. В случае с PHP-приложениями ориентируемся на количество занятых php-fpm-процессов *(детальнее об этом — ниже)*;
* выбираем количество `min/maxReplicas` на основе предварительных нагрузочных тестов — если гипотетические уровни нагрузки еще неизвестны;
* настраиваем Cluster Autoscaler, где `min/max` также выставляется на основе тестов и с некоторым запасом по `max`.
**Автомасштабирование узлов:**
* используем [standby-узлы](https://deckhouse.io/ru/documentation/v1/modules/040-node-manager/faq.html#%D0%BA%D0%B0%D0%BA-%D1%83%D1%81%D0%BA%D0%BE%D1%80%D0%B8%D1%82%D1%8C-%D0%B7%D0%B0%D0%BA%D0%B0%D0%B7-%D1%83%D0%B7%D0%BB%D0%BE%D0%B2-%D0%B2-%D0%BE%D0%B1%D0%BB%D0%B0%D0%BA%D0%B5-%D0%BF%D1%80%D0%B8-%D0%B3%D0%BE%D1%80%D0%B8%D0%B7%D0%BE%D0%BD%D1%82%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%BC-%D0%BC%D0%B0%D1%81%D1%88%D1%82%D0%B0%D0%B1%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B8-%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B9) для ситуаций с резкими и непредсказуемыми всплесками трафика. Они вроде «горячего резерва», который позволяет пережить первый наплыв пользователей и не ждать дозаказа обычных узлов при масштабировании Pod’ов;
* настраиваем триггеры и алерты на желаемые значения, чтобы контролировать траты на дозаказ узлов.
Но случай с cybersport.ru был особый.
### Почему мы ограничили автомасштабирование
С помощью Kubernetes-платформы [Deckhouse](https://deckhouse.io/ru/) легко настраивать гибкое автоматическое масштабирование узлов. Более того, Deckhouse сама умеет заказывать дополнительные ВМ у провайдера. Однако в случае с cybersport.ru автомасштабирование оказалось не самым оптимальным решением.
В проекте была необходимость строго соблюдать бюджет на инфраструктуру. При этом нетипичная нагрузка на сайт приходит хотя и резко, но редко и прогнозируемо. Например, во время старта значимого турнира RPS всего за несколько секунд может вырасти с 300 до 2000.
Вместе с клиентом мы решили пойти на компромисс и выработали особый подход: масштабировать инфраструктуру с помощью изменения пары параметров в манифесте. При этом в 100% случаев изменение затрат на инфраструктуру — например, дозаказ ВМ — контролирует инженер (согласуя с менеджером проекта).
Суть в том, чтобы заранее выставить оправданные и достаточные min/max-значения для HPA/CA и подготовить нужное количество standby-узлов; это занимает буквально несколько минут, весь остальной процесс — автоматический. После чего запуск новых Pod’ов происходит самостоятельно и в достаточном объеме для приходящей нагрузки. Всё остальное время количество ВМ можно держать на минимуме, не переплачивая за простаивающие ВМ. По такой схеме мы и действовали во время The International 10 — правда, в чуть более стрессовом режиме, чем планировали, поскольку недооценили нагрузки, которые предстоит принять.
### Пример настройки HPA (Horizontal Pod Autoscaler)
Вот пример конфига, который отвечает за автомасштабирование Pod’ов — аналогичный тому, что мы использовали для Cybersport.ru:
```
apiVersion: deckhouse.io/v1alpha1
kind: PodMetric
metadata:
name: php-fpm-active-worker
spec:
query: round(sum by(<<.GroupBy>>) (phpfpm_processes_total{state="active",<<.LabelMatchers>>}) / sum by(<<.GroupBy>>) (phpfpm_processes_total{<<.LabelMatchers>>}) * 100)
---
kind: HorizontalPodAutoscaler
apiVersion: autoscaling/v2beta2
metadata:
name: backend-fpm-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: backend
minReplicas: {{ pluck .Values.global.env .Values.fpm_hpa.min_replicas | first | default .Values.fpm_hpa.min_replicas._default }}
maxReplicas: {{ pluck .Values.global.env .Values.fpm_hpa.max_replicas | first | default .Values.fpm_hpa.max_replicas._default }}
metrics:
- type: Pods
pods:
metric:
name: php-fpm-active-worker
target:
type: AverageValue
averageValue: 60
```
ПримечаниеВ документации Deckhouse есть примеры с настройками [кастомных метрик для HPA](https://deckhouse.io/ru/documentation/v1/modules/301-prometheus-metrics-adapter/usage.html#%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%D1%8B-%D1%81-%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%D0%BC-%D0%BA%D0%B0%D1%81%D1%82%D0%BE%D0%BC%D0%BD%D1%8B%D1%85-%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D0%BA-%D1%82%D0%B8%D0%BF%D0%B0-pods) и [конфигурации узлов кластера](https://deckhouse.io/ru/documentation/v1/modules/040-node-manager/usage.html#%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80-%D0%BE%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D1%8F-nodegroup).
Кратко — о ключевых параметрах этой конфигурации:
**1. Выбираем важные метрики.** Прежде всего, необходимо определиться со спецификой приложения, которое мы собираемся масштабировать. Многое зависит от того, как правильно определять его загруженность. В случае с PHP-приложением, которое работает на php-fpm, идеальная метрика — загруженность child’ов (количество idle или active). По этой метрике легко определить, сколько child’ов в запасе. Отталкиваясь от этого, решаем — увеличивать или уменьшать количество реплик.
**2. Настраиваем масштабирование**. Для HPA создаем специальную метрику, измеряющую процент занятых child’ов. Затем в самом манифесте HPA ссылаемся на эту метрику и выставляем желаемые пороги срабатывания (`averageValue`). В нашем случае 60% занятых процессов, приводят к появлению новых Pod’ов, чтобы снизить этот средний процент.
Также два ключевых параметра, которыми мы можем управлять, — это `minReplicas` и `maxReplicas`, то есть желаемое минимальное и максимальное количество Pod’ов.
Ну, и в конечном счете направляем действие HPA на нужный контроллер через спецификацию `scaleTargetRef`.
***Важный момент.*** *Сразу после запуска HPA необходимо забыть о ручной регулировке количества реплик через* `deployment scale`*. Если этот параметр не будет совпадать с «мнением» HPA, то вызовет ненужное создание или пересоздание Pod’ов — это может негативно сказаться на пользователях.*
### От 600 до 2300 RPS
Как выяснилось, 600 RPS — это не предел: нагрузка росла ежедневно и достигла пика в последний день The International — 17 октября.
То, что происходило с сайтом во время турнира, лучше всего описал **Павел Вирский**, тимлид команды разработки cybersport.ru (*приводим фрагмент поста Павла из корпоративного Slack’а нашей DevOps-команды*):
##### Павел Вирский, тимлид команды разработки cybersport.ru
«Закончился The International, который был большим испытанием для нашего сайта и серверов и не меньшим вызовом и для нас и для вас. Начиналось всё 8 октября, когда 600 rps укладывали сайт на лопатки. Затем рекорд побивали ещё несколько раз, но с каждым разом всё более подготовленными. И закончилось сегодня, когда при (невероятных для меня) 2300 rps сайт работал. А нагрузка в 1200-1400 стала настолько рядовой, что мы ~~спокойно~~ выкладывали обновления...»
Подытожим
---------
Сейчас инфраструктура cybersport.ru оптимизирована. Единственное, что требуется для принятия нагрузки, — своевременный дозаказ ресурсов. Но это не значит, что улучшать больше нечего. Что еще можно сделать:
* **Разместить Redis на выделенных узлах кластера.** Если во время резкого роста нагрузки Redis окажется на нагруженном узле, это может негативно повлиять на инфраструктуру: Redis будет «аффектиться» и вызывать проблемы в работе всех сайтов, которые с ним взаимодействуют. В идеале для сервиса нужно выделить отдельную группу узлов.
* **Увеличить количество slave-узлов для PostgreSQL.** Чтобы БД не «упиралась» по скорости чтения в возможности диска, для гипотетических ситуаций можно добавить slave-узлов. По сути, основная нагрузка во время мероприятий создается операциями чтения в базу. Она достаточно легко масштабируется добавлением новых slave-узлов для репликации и перераспределении нагрузки.
Сейчас cybersport.ru такая оптимизация не нужна, и в обозримом будущем потребность в ней вряд ли не возникнет.
Главное, что благодаря Kubernetes, отлаженному CI/CD, а также четкому взаимодействию инженеров «Фланта» и разработчиков наш клиент достиг важных для себя результатов:
* Инфраструктура стала надежнее: обновления можно деплоить даже под большой нагрузкой.
* … и гибче: нет технических ограничений для своевременного масштабирования.
* Появилась независимость от поставщика инфраструктуры: K8s-кластеры можно легко перенести в новое облако, на bare metal, куда угодно.
* Приложение оптимизировано и лучше адаптировано для работы в cloud native-среде.
P.S.
----
Читайте также в нашем блоге:
* «[Переехать в Kubernetes и платить за инфраструктуру вдвое меньше? История Adapty](https://habr.com/ru/company/flant/blog/587814/)»;
* «[Опыт миграции инфраструктуры клиента из AWS в Яндекс.Облако](https://habr.com/ru/company/flant/blog/568624/)». | https://habr.com/ru/post/590975/ | null | ru | null |
# Google Maps на iPhone без GoogleSDK
Google карты для iPhone вышли совсем недавно, и не так просто получить API ключ для SDK. Может метод, изложенный здесь, для многих покажется банальностью, но все же я напишу.
Основная идея — использование JavaScript API. Для примера я выбрал Direction API.
Создаётся 2 поля для ввода «откуда» и «куда» и «WebView» для отображение результата.
Шаблон для отображения в WebView я задал в отдельном файле, назвал его «map.html». Вот его содержимое:
```
html { height: 100% }
body { height: 100%; margin: 0; padding: 0 }
#map\_canvas { height: 100% }
var directionsDisplay;
var directionsService = new google.maps.DirectionsService();
var map;
function initialize() {
directionsDisplay = new google.maps.DirectionsRenderer();
var chicago = new google.maps.LatLng(41.850033, -87.6500523);
var mapOptions = {
zoom:7,
mapTypeId: google.maps.MapTypeId.ROADMAP,
center: chicago
}
map = new google.maps.Map(document.getElementById("map\_canvas"), mapOptions);
directionsDisplay.setMap(map);
calcRoute('chicago, il', 'st louis, mo');
}
function calcRoute(start, end) {
var request = {
origin:start,
destination:end,
travelMode: google.maps.TravelMode.DRIVING
};
directionsService.route(request, function(result, status) {
if (status == google.maps.DirectionsStatus.OK) {
directionsDisplay.setDirections(result);
}
});
}
```
Дальше все очень просто. В «viewDidLoad» вызывается «createMap», для инициализации карты. Код «createMap»:
```
- (void) createMap:(id)sender{
[map loadHTMLString:[self readFile:[[NSBundle mainBundle] pathForResource:@"map" ofType:@"html"]] baseURL:[NSURL URLWithString:@"google.com"]];
}
```
И на изменение поля «to» поставлен обработчик:
```
- (void) findOnMap:(id)sender{
[map stringByEvaluatingJavaScriptFromString:
[[[[@"calcRoute('" stringByAppendingString: from.text ] stringByAppendingString: @"', '"] stringByAppendingString: to.text] stringByAppendingString: @"');" ]
];
}
```
Таким образом можно выполнить любой API запрос к GoogleMaps. Это, конечно, временный метод, пока гугл не начнёт выдавать ключи к SDK сразу по запросу.
Вот как это выглядит:
 | https://habr.com/ru/post/165461/ | null | ru | null |
Subsets and Splits