text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# TensorRT 6.x.x.x — высокопроизводительный инференс для моделей глубокого обучения (Object Detection и Segmentation)
*Больно только в первый раз!*
Всем привет! Дорогие друзья, в этой статье я хочу поделиться своим опытом использования TensorRT, RetinaNet на базе репозитория [github.com/aidonchuk/retinanet-examples](https://github.com/aidonchuk/retinanet-examples) (это форк официальной репы от [nvidia](https://github.com/NVIDIA/retinanet-examples), который позволит начать использовать в продакшен оптимизированные модели в кратчайшие сроки). Пролистывая сообщения в каналах сообщества [ods.ai](https://ods.ai), я сталкиваюсь с вопросами по использованию TensorRT, и в основном вопросы повторяются, поэтому я решил написать *как можно более полное* руководство по использованию быстрого инференса на основе TensorRT, RetinaNet, Unet и docker.
**Описание задачи**
Предлагаю поставить задачу таким образом: нам необходимо разметить датасет, обучить на нём сеть RetinaNet/Unet на Pytorch1.3+, преобразовать полученные веса в ONNX, далее сконвертировать их в engine TensorRT и всё это дело запустить в docker, желательно на Ubuntu 18 и крайне желательно на ARM(Jetson)\* архитектуре, тем самым минимизируя ручное развертывание окружения. В итоге мы получим контейнер готовый не только к экспорту и обучению RetinaNet/Unet, но и к полноценной разработке и обучению классификации, сегментации со всей необходимой обвязкой.
**Этап 1. Подготовка окружения**
Здесь важно заметить, что в последнее время я полностью ушёл от использования и развертывания хоть каких-то библиотек на desktop машине, как впрочем и на devbox. Единственное, что приходится создавать и устанавливать — это python virtual environment и cuda 10.2 (можно ограничиться одним драйвером nvidia) из deb.
Предположим, что у вас свежеустановленная Ubuntu 18. Установим cuda 10.2(deb), подробно на процессе установки я останавливаться не буду, официальной документации вполне достаточно.
Теперь установим docker, руководство по установке докера можно легко найти, вот пример [www.digitalocean.com/community/tutorials/docker-ubuntu-18-04-1-ru](https://www.digitalocean.com/community/tutorials/docker-ubuntu-18-04-1-ru), уже доступна 19+ версия — ставим её. Ну и не забудьте сделать возможным использования docker без sudo, так будет удобнее. После того как всё получилось, делаем вот так:
```
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo systemctl restart docker
```
И можно даже не заглядывать в официальный репозиторий [github.com/NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker).
Теперь делаем git clone [github.com/aidonchuk/retinanet-examples](https://github.com/aidonchuk/retinanet-examples).
Осталось совсем чуть-чуть, для того чтобы начать пользоваться docker с nvidia-образом, нам потребуется зарегистрировать в NGC Cloud и залогиниться. Идём сюда [ngc.nvidia.com](https://ngc.nvidia.com/), регистрируемся и после того как попадаем внутрь NGC Cloud, жмём SETUP в левом верхнем углу экрана или преходим по этой ссылке [ngc.nvidia.com/setup/api-key](https://ngc.nvidia.com/setup/api-key). Жмём «сгенерить ключ». Его рекомендую сохранить, иначе при следующем посещении его придётся генерить заново и, соответственно, разворачивая на новой тачке, повторно производить эту операцию.
Выполним:
```
docker login nvcr.io
Username: $oauthtoken
Password: - сгенерированный ключ
```
Username просто копируем. Ну вот, считай, среда развернута!
**Этап 2. Сборка контейнера docker**
На втором этапе нашей работы мы соберем docker и познакомимся с его внутренностями.
Перейдём в корневую папку по отношению к проекту retina-examples и выполним
```
docker build --build-arg USER=$USER --build-arg UID=$UID --build-arg GID=$GID --build-arg PW=alex -t retinanet:latest retinanet/
```
Мы собираем docker пробрасывая в него текущего юзера — это очень полезно если вы будете что-то писать на смонтированный VOLUME с правами текущего юзера, иначе будет root и боль.
Пока собирается docker, давайте изучим Dockerfile:
```
FROM nvcr.io/nvidia/pytorch:19.10-py3
ARG USER=alex
ARG UID=1000
ARG GID=1000
ARG PW=alex
RUN useradd -m ${USER} --uid=${UID} && echo "${USER}:${PW}" | chpasswd
RUN apt-get -y update && apt-get -y upgrade && apt-get -y install curl && apt-get -y install wget && apt-get -y install git && apt-get -y install automake && apt-get install -y sudo && adduser ${USER} sudo
RUN pip install git+https://github.com/bonlime/pytorch-tools.git@master
COPY . retinanet/
RUN pip install --no-cache-dir -e retinanet/
RUN pip install /workspace/retinanet/extras/tensorrt-6.0.1.5-cp36-none-linux_x86_64.whl
RUN pip install tensorboardx
RUN pip install albumentations
RUN pip install setproctitle
RUN pip install paramiko
RUN pip install flask
RUN pip install mem_top
RUN pip install arrow
RUN pip install pycuda
RUN pip install torchvision
RUN pip install pretrainedmodels
RUN pip install efficientnet-pytorch
RUN pip install git+https://github.com/qubvel/segmentation_models.pytorch
RUN pip install pytorch_toolbelt
RUN chown -R ${USER}:${USER} retinanet/
RUN cd /workspace/retinanet/extras/cppapi && mkdir build && cd build && cmake -DCMAKE_CUDA_FLAGS="--expt-extended-lambda -std=c++14" .. && make && cd /workspace
RUN apt-get install -y openssh-server && apt install -y tmux && apt-get -y install bison flex && apt-cache search pcre && apt-get -y install net-tools && apt-get -y install nmap
RUN apt-get -y install libpcre3 libpcre3-dev && apt-get -y install iputils-ping
RUN mkdir /var/run/sshd
RUN echo 'root:pass' | chpasswd
RUN sed -i 's/PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config
RUN sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd
ENV NOTVISIBLE "in users profile"
RUN echo "export VISIBLE=now" >> /etc/profile
CMD ["/usr/sbin/sshd", "-D"]
```
Как видно из текста, мы берем все наши любимые либы, компилируем retinanet, накидываем базовых инструментов для удобства работы с Ubuntu и настраиваем сервер openssh. Первой строкой идет как раз наследование образа nvidia, для которого мы делали логин в NGC Cloud и который содержит Pytorch1.3, TensorRT6.x.x.x и еще кучу либ, позволяющих скомпилировать cpp исходники нашего детектора.
**Этап 3. Запуск и отладка контейнера docker**
Перейдем к основному кейсу использования контейнера и среды разработки, для начала запустим nvidia docker. Выполним:
```
docker run --gpus all --net=host -v /home/:/workspace/mounted\_vol -d -P --rm --ipc=host -it retinanet:latest
```
Теперь контейнер доступен по ssh @localhost. После успешного запуска, открываем проект в PyCharm. Далее открываем
```
Settings->Project Interpreter->Add->Ssh Interpreter
```
*Шаг 1*
*Шаг 2*
*Шаг 3*
Выбираем всё как на скриншотах,
```
Interpreter -> /opt/conda/bin/python
```
— это будет ln на Python3.6 и
```
Sync folder -> /workspace/retinanet
```
Жмём финиш, ожидаем индексирование, и всё, среда готова к использованию!
***ВАЖНО!!!*** Сразу после индексирования вытянуть из docker скомпилированные файлы для Retinanet. В контектсном меню в корне проекта выберем пункт
```
Deployment->Download
```
Появятся один файл и две папки build, retinanet.egg-info и \_С.so
Если ваш проект выглядит так, то среда видит все необходимые файлы и мы готовы, к обучению RetinaNet.
**Этап 4. Размечаем данные и обучаем детектор**
Для разметки я, в основном, использую [supervise.ly](https://supervise.ly/) — приятная и удобная тулза, в последнее време кучу косяков пофиксили и она стала существенно лучше себя вести.
Предположим что вы разметили датасет и скачали его, но сразу засунуть его в наш RetinaNet не выйдет, так как он в собственном формате и для этого нам необходимо сконвертировать его в COCO. Тулза для конвертации находится в:
```
markup_utils/supervisly_to_coco.py
```
Обратите внимание, что Category в скрипте это пример и вам необходимо вставить свои (категорию background добавлять не надо)
```
categories = [{'id': 1, 'name': '1'},
{'id': 2, 'name': '2'},
{'id': 3, 'name': '3'},
{'id': 4, 'name': '4'}]
```
Авторы оригинального репозитория почему-то решили, что ничего кроме COCO/VOC вы обучать для детекции не будете, поэтому пришлось немного подредактировать исходный файл
```
retinanet/dataset.py
```
Добавив тутда любимые аугментации [albumentations.readthedocs.io/en/latest](https://albumentations.readthedocs.io/en/latest/) и выпилить жёстко вшитые категории из COCO. Также есть возможность кропнуть большие области детекции, если вы на больших картинках ищите маленькие объекты, у вас маленький датасет =), и ничего не работает, но об этом в другой раз.
В общем train loop тоже слабенький, изначально он не сохранял чекпоинты, юзал какой-то ужасный scheduler и т.д. Но теперь вам осталось только выбрать backbone и выполнить
```
/opt/conda/bin/python retinanet/main.py
```
c параметрами:
```
train retinanet_rn34fpn.pth
--backbone ResNet34FPN
--classes 12
--val-iters 10
--images /workspace/mounted_vol/dataset/train/images
--annotations /workspace/mounted_vol/dataset/train_12_class.json
--val-images /workspace/mounted_vol/dataset/test/images_small
--val-annotations /workspace/mounted_vol/dataset/val_10_class_cropped.json
--jitter 256 512
--max-size 512
--batch 32
```
В консоле увидите:
```
Initializing model...
model: RetinaNet
backbone: ResNet18FPN
classes: 2, anchors: 9
Selected optimization level O0: Pure FP32 training.
Defaults for this optimization level are:
enabled : True
opt_level : O0
cast_model_type : torch.float32
patch_torch_functions : False
keep_batchnorm_fp32 : None
master_weights : False
loss_scale : 1.0
Processing user overrides (additional kwargs that are not None)...
After processing overrides, optimization options are:
enabled : True
opt_level : O0
cast_model_type : torch.float32
patch_torch_functions : False
keep_batchnorm_fp32 : None
master_weights : False
loss_scale : 128.0
Preparing dataset...
loader: pytorch
resize: [1024, 1280], max: 1280
device: 4 gpus
batch: 4, precision: mixed
Training model for 20000 iterations...
[ 1/20000] focal loss: 0.95619, box loss: 0.51584, 4.042s/4-batch (fw: 0.698s, bw: 0.459s), 1.0 im/s, lr: 0.0001
[ 12/20000] focal loss: 0.76191, box loss: 0.31794, 0.187s/4-batch (fw: 0.055s, bw: 0.133s), 21.4 im/s, lr: 0.0001
[ 24/20000] focal loss: 0.65036, box loss: 0.30269, 0.173s/4-batch (fw: 0.045s, bw: 0.128s), 23.1 im/s, lr: 0.0001
[ 36/20000] focal loss: 0.46425, box loss: 0.23141, 0.178s/4-batch (fw: 0.047s, bw: 0.131s), 22.4 im/s, lr: 0.0001
[ 48/20000] focal loss: 0.45115, box loss: 0.23505, 0.180s/4-batch (fw: 0.047s, bw: 0.133s), 22.2 im/s, lr: 0.0001
[ 59/20000] focal loss: 0.38958, box loss: 0.25373, 0.184s/4-batch (fw: 0.049s, bw: 0.134s), 21.8 im/s, lr: 0.0001
[ 71/20000] focal loss: 0.37733, box loss: 0.23988, 0.174s/4-batch (fw: 0.049s, bw: 0.125s), 22.9 im/s, lr: 0.0001
[ 83/20000] focal loss: 0.39514, box loss: 0.23878, 0.181s/4-batch (fw: 0.048s, bw: 0.133s), 22.1 im/s, lr: 0.0001
[ 94/20000] focal loss: 0.39947, box loss: 0.23817, 0.185s/4-batch (fw: 0.050s, bw: 0.134s), 21.6 im/s, lr: 0.0001
[ 105/20000] focal loss: 0.37343, box loss: 0.20238, 0.182s/4-batch (fw: 0.048s, bw: 0.134s), 22.0 im/s, lr: 0.0001
[ 116/20000] focal loss: 0.19689, box loss: 0.17371, 0.183s/4-batch (fw: 0.050s, bw: 0.132s), 21.8 im/s, lr: 0.0001
[ 128/20000] focal loss: 0.20368, box loss: 0.16538, 0.178s/4-batch (fw: 0.046s, bw: 0.131s), 22.5 im/s, lr: 0.0001
[ 140/20000] focal loss: 0.22763, box loss: 0.15772, 0.176s/4-batch (fw: 0.050s, bw: 0.126s), 22.7 im/s, lr: 0.0001
[ 148/20000] focal loss: 0.21997, box loss: 0.18400, 0.585s/4-batch (fw: 0.047s, bw: 0.144s), 6.8 im/s, lr: 0.0001
Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.52674
Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.91450
Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.35172
Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.61881
Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.00000
Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = -1.00000
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.58824
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.61765
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.61765
Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.61765
Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.00000
Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = -1.00000
Saving model: 148
```
Что бы изучить весь набор параметров посмотрите
```
retinanet/main.py
```
В общем они стандартные для детекции, и у них есть описание. Запустите обучение и дождитесь результатов. Пример инференса можно посмотреть в:
```
retinanet/infer_example.py
```
или выполнить команду:
```
/opt/conda/bin/python retinanet/main.py infer retinanet_rn34fpn.pth
--images /workspace/mounted_vol/dataset/test/images
--annotations /workspace/mounted_vol/dataset/val.json
--output result.json
--resize 256
--max-size 512
--batch 32
```
В репозитории уже встроен Focal Loss и несколько backbone, а так же легко впиливаются свои
```
retinanet/backbones/*.py
```
В табличке авторы приводят некоторые характеристики:
Также есть backbone ResNeXt50\_32x4dFPN и ResNeXt101\_32x8dFPN, взятый из torchvision.
Надеюсь с детекцией немного разобрались, но стоит обязательно прочитать официальную документацию, чтобы ***понять режимы экспорта и логирования***.
**Этап 5. Экспорт и инференс моделей Unet c энкодером Resnet**
Как вы, наверное, обратили внимание, в Dockerfile были установлены библиотеки для сегментации и в частности замечательная либа [github.com/qubvel/segmentation\_models.pytorch](https://github.com/qubvel/segmentation_models.pytorch). В пакете юнет можно найти примеры инференса и экспорта pytorch чекпоинтов в engine TensorRT.
Основная проблема при экспорте Unet-like моделей из ONNX в TensoRT — это необходимость задавать фиксированный размер Upsample или пользоваться ConvTranspose2D:
```
import torch.onnx.symbolic_opset9 as onnx_symbolic
def upsample_nearest2d(g, input, output_size):
# Currently, TRT 5.1/6.0 ONNX Parser does not support all ONNX ops
# needed to support dynamic upsampling ONNX forumlation
# Here we hardcode scale=2 as a temporary workaround
scales = g.op("Constant", value_t=torch.tensor([1., 1., 2., 2.]))
return g.op("Upsample", input, scales, mode_s="nearest")
onnx_symbolic.upsample_nearest2d = upsample_nearest2d
```
С помощью этого преобразования можно сделать это автоматически при экспорте в ONNX, но уже в 7 версии TensorRT эту проблему решили, и нам осталось ждать совсем немного.
**Заключение**
Когда я начал использовать docker у меня были сомнения на счёт его производительности для моих задач. В одном из моих агрегатов сейчас довольно большой сетевой трафик создаваемый несколькими камерами.
Разные тесты на просторах интернета говорили об относительно большом overhead на сетевое взаимодействие и запись на VOLUME, плюс ко всему неведомый и страшный GIL, а так как съемка кадра, работа драйвера и передача по сети кадра являются атомарной операцией в режиме *hard real-time*, задержки в сети для меня очень критичны.
Но всё обошлось =)
P.S. Остаётся добавить ваш любимый трейн луп для сегментации и в продакшен!
**Благодраности**
Спасибо сообществу [ods.ai](http://ods.ai), без него невозможно развиваться! Огромное спасибо [n01z3](https://habr.com/ru/users/n01z3/), надоумевшему меня заняться DL, за его бесценные советы и чрезвычайный профессионализм!
*Используйте в production оптимизированные модели!*
 Aurorai, llc | https://habr.com/ru/post/483074/ | null | ru | null |
# Синхронизация пользователей Zimbra Collaboration OSE на основе Active Directory
1. Предпосылки
--------------
Настраивая сервер zimbra столкнулся с проблемой синхронизации пользователей по группе в Active Directory (AD). Если мы создаем нового пользователя в AD, то он нормально добавлялся, но если мы делаем доступ к почтовому серверу по группе, то первый раз все пользователи синхронизируются. А вот потом, изменения в группе никак не влияют на изменения пользователей почтового сервера zimbra.
Что не понравилось в этих статьях, это использование скрипта на powershell (зачем, если есть ldapsearch) и постоянный вызов утилиты zmprov, и когда идет синхронизация большого количества пользователей, то скрипт выполняется продолжительное время
2. Исходные данные
------------------
ОС сервера: CentOS 7
Язык скрипта: bash
Домен Zimbra: test.ru
Сервер Zimbra: zimbra.test.local
Домен Active Directory: test.local
Группа AD для доступа к почте: mail
У пользователя может быть почта отличающаяся от его логина, такую почту вносим в AD в поле mail и по нему создаем алиас в zimbra (например вася пупкин входит в систему под логином vasia, но почту должен отправлять и получать еще как пользователь v.pupkin@test.ru)
3. Схема работы скрипта
-----------------------
1. Сохраняем в файл пользователей AD входящих в группу mail
2. Сохраняем в файл всех пользователей zimbra со всеми атрибутами
3. Разделяем файл со списком всех пользователей zimbra на файлы формата: имя файла — логин пользователя, содержание — атрибуты пользователя
4. Убираем из списка пользователей zimbra системные учетные записи (admin, gal,antivirus)
5. Сравниваем список пользователей AD и zimbra
6. Создаем файл с командами добавления, удаления (в моем случае блокировки пользователя), синхронизации и создания алиасов
7. Применяем данные действия в zimbra (один вызов zmprov)
8. Отправляем отчет на почту администратору (если есть что отправлять)
9. Удаляем временные файлы и каталоги
4. Скрипт синхронизации
-----------------------
У скрипта есть два режима работы — это запуск без параметров, тогда отработают только блокировка и добавление пользователей. И запуск с параметром «all», тогда будут синхронизированны все пользователи группы mail в AD.
Так же необходимо обратить внимание на использование утилиты декодирования base64 в функции синхронизации, ее необходимо использовать для полей AD в которых используются русские символы.
**Сам скрипт:**
```
#!/bin/bash
#
#1. Определение переменных
#
#1.1 Общие переменные
#Путь к рабочему каталогу
path="/mnt/zimbra/user-sync"
#Временная метка
timestamp=`date +%F-%H-%M`
#путь к временным файлам
tmp_dir=$path/tmp
#Путь к файлам с атрибутами пользователей zimbra
zim_us=$tmp_dir/zim-us
#путь к файлам логов
log_dir=$path/log
#имя лог-файла
log=$log_dir/grouplog_$timestamp.txt
#путь ко временному файлу со списком пользователей
usname=$tmp_dir/usname
#Путь к файлу со списком команд на пакетное выполнение утилитой zmprov
zmcmdfile=$tmp_dir/zmcmdfile
#путь ко временным файлам со списком атрибутов пользователей AD
userfil=$tmp_dir/userfil
#отправка почты
mutt="/usr/bin/mutt"
#
#1.2 переменные сервера zimbra
#имя домена Zimbra
domain="test.ru"
#путь к командлету zmprov
zmprov="/opt/zimbra/bin/zmprov"
#
#1.3 переменные доступа к AD по LDAP
#LDAP search
ldapsearch=/opt/zimbra/common/bin/ldapsearch
# Подключение к серверу (либо сервер, либо домен (если больше одного сервера))
ldap_server="ldap://test.local:389"
#Базовая OU поиска
basedn="DC=test,DC=local"
#Пользователь и пароль для доступа к AD по LDAP
binddn="CN=zimbra,CN=Users,DC=test,DC=local"
bindpw="qwe123" #user password
#Фильтр поиска - кто входит в группу mail
filter="(memberof=cn=mail,cn=users,dc=test,dc=local)"
#какие поля данных ищем (логин, почту и поле с не совпадающей с логином почтой для алиаса и подписи)
fields="sAMAccountName mail description displayName givenName cn sn department title"
#конец блока переменных
#Начинаем обработку
#Функции обработки
#Запись ошибки в лог
function err_log()
{
if [ $1 -eq 0 ]; then
#echo -n "$(tput hpa $(tput cols))$(tput cub 6)[OK]"
#echo
echo $2" [Ok]" >> $log
else
#echo -n "$(tput hpa $(tput cols))$(tput cub 6) [FAIL]"
#echo
echo $2" [Fail]" >> $log
fi
}
#Проверка существования каталога
function if_path ()
{
#Если каталог не существует то создаем его
if [ ! -d $1 ]; then
#Создание каталога для обработки
echo "Создание каталога $1..." >> $log
mkdir -p $1
err_log $? "Проверка каталога $1"
else
echo "Каталог обработки $1 существует" >> $log
fi
}
#Запись в файл списка пользователей из AD
function search_users_AD()
{
echo "Запись списка пользователей рассылки из AD..." >> $log
$ldapsearch -x -o ldif-wrap=no -H $ldap_server -D $binddn -w $bindpw -b $basedn $filter $fields |
grep sAMAccountName |
egrep -v '^#|^$' |
awk '{print $2}' |
sort > $usname.ad
echo "Found (Найдено) "`cat $usname.ad | wc -l`" Group in AD (групп в AD)" >> $log
}
function all_user_attr_zimbra()
{
#Создаем файл со списком всех пользователей и их атрибутов
$zmprov -l gaa -v $domain > $usname.gaa
#Переходим в папку где будут созданы файлы с атрибутами пользователей
cd $zim_us
#разбиваем файл со всеми пользователями на файлы, с атрибутами только одного пользователя
csplit $usname.gaa --prefix='user.' --suffix-format='%03d.zim' --elide-empty-files -s /"# name"/ '{*}'
#Переименовываем файлы по пользователям. имя берем из имени пользователя zimbra в файле
for i in $( ls $zim_us )
do
nam=`grep "# name" $zim_us/$i | awk '{ print $3}' | sed 's/@.*//g'`
mv -f $zim_us/$i $zim_us/$nam
done
cd $path
}
#Запись в файл списка пользователей из zimbra
function search_user_zimbra()
{
echo "Запись списка пользователей из zimbra..." >> $log
ls $zim_us | sort > $usname.tem
#Удаляем системные аккаунты из проверки. файл $path/system.acc содержит список системных пользователей
diff -u -i $usname.tem $path/system.acc | sed 1,3d | grep ^- | cut -c 2- | sort > $usname.zim
#rm -f $usname.tem
echo "Found (Найдено) "`cat $usname.zim | wc -l`" Group in Zimbra (групп в Zimbra)" >> $log
}
#Разница между списками пользователей (для добавления или блокировки
function diff_user_list()
{
diff -u -i $usname.zim $usname.ad | sed 1,3d | sed '/@.*/d' > $usname.diff
}
#добавление пользователей
function adduser()
{
#Проверяем существование пользователя на добавление
adddif=`grep ^+ $usname.diff | sed '1!d'`
if [ -n $adddif ];
then
for addus in $( grep ^+ $usname.diff | cut -c 2- )
do
# проверяем есть ли такой пользователь в zimbra (если есть - разблокируем, нет - создаем)
ifclos=`grep "zimbraAccountStatus:" $zim_us/$addus | awk '{print $2}' | cut -c -1`
if [ $ifclos = "c" ];
then
echo "ma $addus@$domain zimbraAccountStatus active" >> $zmcmdfile
echo "Пользователь $addus разблокирован" >> $tmp_dir/send.txt
if [ $addus != "" ];
then
sync_one_user $addus
fi
else
#123456 - пароль пользователя, необходим для создания пользователя. может быть любым, так как настроена проверка паролей в домене AD
echo "ca $addus@$domain 123456" >> $zmcmdfile
echo "Пользователь $addus создан" >> $tmp_dir/send.txt
if [ $addus != "" ];
then
sync_one_user $addus
fi
fi
done
fi
}
#блокировка пользователей перед отключением
function block_user()
{
deldif==`grep ^- $usname.diff | sed '1!d'`
if [ -n $deldif ];
then
for delus in $( grep ^- $usname.diff | cut -c 2- )
do
#zimbraAccountStatus closed
if [ $delus != "" ];
then
ifclos=`grep "zimbraAccountStatus:" $zim_us/$delus | awk '{print $2}'`
if [ "$ifclos" != "closed" ];
then
echo "user closed - $delus"
echo "ma $delus@$domain zimbraAccountStatus closed" >> $zmcmdfile
echo "Пользователь $delus заблокирован! Удалите его с сервера самостоятельно!" >> $tmp_dir/send.txt
echo $delus >> $path/close.1
cat $path/close.1 | sort > $path/close.diff
echo "$delus"
fi
fi
done
fi
}
#Функция проверки существования атрибута
function ifattr()
{
if1char=`echo $2 | cut -c -1`
if [[ -n $2 && $if1char != "" ]];
#if [ $2 != "" ];
then
#echo $2
echo -n " $1 \"$2\"" >> $zmcmdfile
fi
}
#функция синхронизации пользователя
function sync_one_user()
{
echo "Синхронизация пользователя $1..." >> $log
$ldapsearch -x -o ldif-wrap=no -H $ldap_server -D $binddn -w $bindpw -b $basedn "(sAMAccountName=$1)" $fields > $userfil/$1.ad
#Создаемначало строки атрибутов синхронизации
echo -n "ma "$1 >> $zmcmdfile
#samacc=`grep "sAMAccountName:" $userfil/$1 | awk '{print $2}'`
description=`grep "description:" $userfil/$1.ad | awk '{split ($0, a, ": "); print a[2]}'`
#echo $description
ifattr "description" "$description"
displayName=`grep "displayName:" $userfil/$1.ad | awk '{split ($0, a, ": "); print a[2]}' | base64 -d`
ifattr "displayName" "$displayName"
givenName=`grep "givenName:" $userfil/$1.ad | awk '{split ($0, a, ": "); print a[2]}' | base64 -d`
ifattr "givenName" "$givenName"
cn=`grep "cn:" $userfil/$1.ad | awk '{split ($0, a, ": "); print a[2]}'`
ifattr "cn" "$cn"
sn=`grep "sn:" $userfil/$1.ad | awk '{split ($0, a, ": "); print a[2]}' | base64 -d`
ifattr "sn" "$sn"
department=`grep "department:" $userfil/$1.ad | awk '{split ($0, a, ": "); print a[2]}' | base64 -d`
ifattr "company" "$department"
title=`grep "title:" $userfil/$1.ad | awk '{split ($0, a, ": "); print a[2]}' | base64 -d`
ifattr "title" "$title"
#Вставляем перевод строки в файле
echo >> $zmcmdfile
#Добавляем алиас
mailnew=`grep "mail:" $userfil/$1.ad | awk '{print $2}'`
if [ "$mailnew" != "" ];
then
# [ -n $mailnew ]
# echo $2
#Проверяем наличие алиаса у пользователя
#${1,,} - приводим все символы к нижнему регистру
useralias=`grep "zimbraMailAlias:" $zim_us/${1,,} | awk '{print $2}'`
if [ $useralias != $mailnew ];
then
echo "aaa \"$1@$domain\" \"$mailnew\"" >> $zmcmdfile
fi
fi
#ifattr "mail" $mailnew
# echo $mailnew
echo "Синхронизация пользователя $1 " >> $tmp_dir/send.txt
# echo "Пользователь $1 - $atrruser"
#echo "Found (Найдено) "`cat $usname.ad | wc -l`" Group in AD (групп в AD)" >> $log
}
#Выполнение скрипта
date +%F-%H-%M
#2.Проверка существования каталогов
#Корневой каталог обработки
if_path $path
#Каталог временных файлов
if_path $tmp_dir
#Каталог лог-файла
if_path $log_dir
#Каталог со списком групп
if_path $userfil
#каталог со файлами пользователей зимбра
if_path $zim_us
#Очищаем файл со списком команд на пакетное выполнение утилитой zmprov
:> $zmcmdfile
# Очищаем тело письма администратору
:> $tmp_dir/send.txt
#3.Создаем список групп рассылки из AD
search_users_AD
#4.Создаем список существующих в zimbra пользователей
all_user_attr_zimbra
#удаляем лишних (системных)
search_user_zimbra
#5.Сравниваем оба списка групп рассылки
diff_user_list
#Блокируем пользователей
block_user
#Создаем или разблокируем новых пользователей
adduser
#tckb скрипту передан параметр "all" при запуске, то синхронизируем всех пользователей находящихся в группе mail AD
if [[ -n $1 && $1 = "all" ]];
then
for us in $(cat $usname.ad );
do
# echo $us
sync_one_user $us
done
fi
# запускаем выполнение всех команд утилитой zmprov из файла
$zmprov -f $zmcmdfile
# дописываем в лог файл с командами
cat $zmcmdfile >> $log
#Отправляем письмо с изменениями админу (если они есть)
if [ -s $tmp_dir/send.txt ];
then
$mutt -s "Синхронизация списка пользователей $timestamp" admins@test.ru -a $log < $tmp_dir/send.txt
fi
#Удаляем временные файлы и каталоги
rm -R -f $tmp_dir
```
5. Заключение
-------------
В целом скрипт получился довольно шустрый, утилита zmprov используется всего два раза, остальные утилиты и функции отрабатывают намного быстрее.
6. Ссылки
---------
При создании данной статьи использовались идеи и статьи:
1. [Сысоева Андрея](https://habr.com/ru/post/443166/)
2. [DruGoeDeLo](http://www.ossportal.ru/technologies/zimbra/blogs/1060)
3. [Мой коментарий к статье 1) со скриптом для синхронизации списков рассылки](https://habr.com/ru/post/443166/#comment_21467824) | https://habr.com/ru/post/495688/ | null | ru | null |
# Звук в Java
Часто в приложениях желательно использовать какие-то вспомогательные звуковые эффекты, например пикнуть динамиком при ошибке или проиграть мелодию на новое письмо.
Не все знают что в любом компьютере имеющем звуковую карту встроена большая библиотека звуков. Все звуковые платы поддерживают **воспроизведение звука** по стандарту MIDI (см. [ru.wikipedia.org/wiki/MIDI](http://ru.wikipedia.org/wiki/MIDI)) а это 128 обычных и 40 ударных инструментов.
Что такое MIDI — это стандарт на команды управления синтезатором или другими устройствами воспроизведения звука. Т.е. в .mp3, например, хранится оцифрованный звук а в файлах .mid только ноты которые воспроизводит звуковая карта.
Я опубликовал библиотеку для простого доступа к воспроизведению MIDI-звука:
Исходный код с примером использования а так же скомпилированную библиотеку можно скачать на странице <http://code.google.com/p/easy-midi/>
**Преимущества MIDI**: есть в любом компе, содержит 128 обычных и 40 ударных инструментов воспроизводится муз.сопроцессором и не влияет на производительность воспроизводимую музыку можно интерактивно менять (если понимать чем диез от бемоля отличается).
**Недостатки**: звучание полностью зависит от звуковой карты и на разных компах может отличаться.
Пример простого вызова (играет в отдельном потоке):
```
Tools.playNote(Note.p93_7_La, Note.i127_Gunshot,127, 2000);
Tools.playDrum(Drum.d39_Hand_Clap, 127, 2000);
```
Названия нот и обычных инструментов для удобства заданы константами в файле Note.java, названия ударных инструментов в файле Drum.java.
Кроме воспроизведения отдельных нот, с помощью библиотеки можно проигрывать и небольшие музыкальные фрагменты. Пример небольшого риффа
```
int bassVoice=Note.i33_Electric_Bass_finger;
Drum hat=new Drum(4, Drum.d42_Closed_Hi_Hat,64);
Drum snare=new Drum(4, Drum.d38_Acoustic_Snare);
Drum bass=new Drum(4, Drum.d35_Acoustic_Bass_Drum);
Phrase p1=new Phrase()
.chord(new Chord(8).drum(hat).drum(bass) .note(8, Note.p28_2_Mi, bassVoice))
.chord(new Chord(8).drum(hat) .note(8, Note.p28_2_Mi, bassVoice))
.chord(new Chord(8).drum(hat).drum(snare) .note(8, Note.p28_2_Mi, bassVoice))
.chord(new Chord(8).drum(hat) .note(8, Note.p28_2_Mi, bassVoice))
.chord(new Chord(8).drum(hat).drum(bass) .note(8, Note.p28_2_Mi, bassVoice))
.chord(new Chord(8).drum(hat).drum(bass) .note(8, Note.p28_2_Mi, bassVoice))
.chord(new Chord(8).drum(hat).drum(snare) .note(8, Note.p34_2_La_Diese, bassVoice))
.chord(new Chord(8).drum(hat) .note(8, Note.p35_2_Si, bassVoice))
;
Ticker ti = new Ticker(120, p1);
ti.restart();
```
###### Описание классов
Tools — содержит методы playNote и playDrum для воспроизведения единичных звуков
Ticker — проигрыватель фраз
Phrase — музыкальная фраза, содержит набор аккордов
Chord — аккорд, содержит высоту и длительность нот обычных и ударных инструментов аккорда
Drum — описание ударного инструмента в аккорде
Note — описание обычного инструмента в аккорде | https://habr.com/ru/post/127840/ | null | ru | null |
# Использование V8
V8 — это движок JavaScript от Google, который используется в браузере Chrome. Он быстрый и доступен в исходных кодах (С++) для Linux (точнее для gcc) и под Windows.
В свете роста популярности использования V8 я решил поделиться своим (годичным) опытом его использования на платформе Windows в качестве серверного скриптового движка.
Часть 1. Введение и простейшая программа, использующая V8.
**— Установка, сборка и добавление в свой проект**
Итак, V8 — быстрый движок JavaScript (ECMA-262) от Google, используемый в браузере Chrome:
[code.google.com/p/v8](http://code.google.com/p/v8/)
V8 доступен в исходных кодах по лицензии BSD:
[code.google.com/intl/ru-RU/apis/v8/terms.html](http://code.google.com/intl/ru-RU/apis/v8/terms.html)
Я расскажу как его собрать под MS Visual Studio Express Edition 2008. Установка под Windows описана здесь:
[code.google.com/p/v8/wiki/BuildingOnWindows](http://code.google.com/p/v8/wiki/BuildingOnWindows)
Итак, устанавливаем:
python
[www.python.org/download/windows](http://www.python.org/download/windows/)
scons
[www.scons.org/download.php](http://www.scons.org/download.php)
subversion
например, [www.sliksvn.com/pub/Slik-Subversion-1.6.5-win32.msi](http://www.sliksvn.com/pub/Slik-Subversion-1.6.5-win32.msi)
Затем добавляем в PATH пути к бинарникам python, scons и subversion.
Скачиваем текущие исходники V8 из ветки trunk (стабильной):
`svn checkout v8.googlecode.com/svn/trunk v8`
В папке tools\visual studio находятся проекты V8 для Visual Studio.
В них удобно изучать код, но собирать V8 лучше из командной строки (из корневой папки где SConstruct), например, так:
`scons msvcltcg=off mode=release library=static snapshot=on env="INCLUDE:C:\Program Files\Microsoft SDKs\Windows\v6.0A\Include;C:\Program Files\Microsoft Visual Studio 9.0\VC\include,LIB:C:\Program Files\Microsoft SDKs\Windows\v6.0A\Lib;C:\Program Files\Microsoft Visual Studio 9.0\VC\lib"`
(пути к установке по умолчанию MS VS EE 2008).
msvcltcg это Link Time Optimization. Рекомендуется включать только для финальных релизов, иначе размер v8.lib увеличиться в 3-4 раза и скорость линковки вашего проекта упадет.
Как видно собираем мы статическую библиотеку v8.lib, которая скоро и появится в этой же папке.
Берем v8.h из папки include и v8.lib и добавляем к своему MS Visual Studio 2008 проекту.
Также не забудьте сделать в проекте:
`#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "winmm.lib")`
Иначе будут проблемы при линковке. Собственно, теперь движок V8 у нас доступен в проекте и можно начинать изучать Embedder's Guide
[code.google.com/intl/ru-RU/apis/v8/embed.html](http://code.google.com/intl/ru-RU/apis/v8/embed.html)
**— Введение в использование V8**
Открываем v8.h и изучаем.
V8 предоставляет свою функциональность с помощью C++ классов, которые объявлены в пространстве имен (namespace) v8. Все важные javascript-структуры обернуты с помощью соответствующего С++ класса. Например, класс v8::Integer представляет собой целое число (i64) в JavaScript.
v8.h
`...
class Context;
class String;
class Value;
class Utils;
class Number;
class Object;
class Array;
class Int32;
class Uint32;
class External;
class Primitive;
class Boolean;
class Integer;
class Function;
class Date;
...`
Самый важный класс — это контекст (v8::Context), то есть место, внутри которого компилируется и выполняется javascript-код. Фактически это же и место хранения глобального объекта javascript. Трудно представить взаимодействие с v8, которое не потребует контекста (но, наверное, можно).
Внутри себя V8 поддерживает свой собственный стек, где размещаются стековые объекты V8. Например, для использования контекста необходимо «войти в него». Для этого используется специальный класс C++ Context::Scope (подробнее ниже). Конструктор этого класса размещает на вершине стека V8 стековый объект V8 для входа в контекст. Вызов деструктора класса Context::Scope убирает соответствующий стековый объект с вершины стека V8. На стеке V8 размещаются также конструкции отлова исключений (TryCatch), пулы хранения временных хэндлов (HandleScope) и другие объекты V8. Все классы C++, которые управляют этими объектами, устроены одинаковы: в конструкторе размещаем объект на стек V8, в деструкторе — убираем.
V8 (как и любая javascript среда выполнения) содержит сборщик мусора, занимающийся удалением объектов V8, на которые никто не ссылается. Поэтому взаимодействие с объектами V8 из C++ кода происходит посредством хэндлов (v8::Handle), то бишь указателей на указатели. Упрощенно это можно представить так:
хэндл ---> ссылка ---> слот V8 (со счетчиком использования) --> объект V8
Реализованы хэндлы в виде template-классов C++: v8::Handle, v8::Local, v8::Persistent.
По времени жизни хэндлы делятся на временные (v8::Local) и постоянные (v8::Persistent).
Можно считать, что это аналоги C++ стековых и хиповых объектов, то есть время жизни временных хендлов привязано к стеку, а постоянные живут пока их явно не уничтожишь.
Далее я предполагаю, что мы находимся в пространстве имен v8 и STL («using namespace v8; using namespace std; „).
Итак, временные хэндлы V8 (v8::Local). Используются чаще всего. Сравним их время жизни со стековым объектом C++:
> `V8 C++
>
> { {
>
> HandleScope handle\_scope;
>
> Local a = Integer::New(1); int a = 1;
>
> } }
>
> // a нельзя использовать
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как видно, для хранения временных хендлов V8 понадобился объект HandleScope. Это стековый объект V8 для хранения тех самых ссылок на объекты V8. Упрощенно это аналог начала блока стековых переменных. Создание нового временного хендла всегда приводит к созданию ссылки в объекте HandleScope, который ближе всего к вершине стека (стека V8, разумеется). Нельзя создать временный хендл без HandleScope!
Вы будете использовать временные хендлы очень часто. Например, нам требуется преобразовать строку C++ в строку V8. Для строки в формате UTF-8 это делается следующим образом:
> `string some\_utf8\_string;
>
> Local<String> s = String::New(some\_utf8\_string.data(), some\_utf8\_string.size());
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Многие классы (например, Integer, String, Boolean, Date) предоставляют статический метод New (возвращающий временный хэндл), который позволяет создать новый объект V8 этого класса и занести в него данные из C++. Например (см. v8.h):
> `class String
>
> ...
>
> static Local<String> New(const char\* data, int length = -1);
>
> ...
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Однако, может возвращаться и объект типа Value:
> `...
>
> class V8EXPORT Date : public Value {
>
> public:
>
> static Local New(double time);
>
> ...
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Класс Value хранит произвольный тип V8. Это то, на что может указывать переменная javascript: число, строка, объект, функция, массив и пр. Value предоставляет методы для проверки своего типа (IsUndefined(), IsNull(), IsString(),IsFunction() и пр.). Преобразование Value в нужный тип осуществляется с помощью метода Cast интересующего нас класса. Например:
> `Local foo;
>
> Local bar;
>
>
>
> if (foo->IsFunction())
>
> bar = Handle::Cast(foo);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В то же время Value является базовым классом C++ для классов Integer, String и пр. Поэтому можно делать так:
> `Local foo = Local<String> bar;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
**— Постоянные хэндлы V8**
Есть несколько случаев, когда временные хэндлы не могут быть использованы. Иногда нам нужно самим управлять временем жизни объектов V8.
Первый случай: контекст V8. Контекст мы создаем сами и уничтожаем, когда он больше не нужен.
Второй случай: объект V8 использует экземпляр объекта C++ и содержит внутри себя ссылку на этот экземпляр. Ясно, что если сборщик мусора вдруг решит подчистить объект V8, то мы потеряем ссылку на объект C++ и произойдет утечка памяти. Однако, мы хотим, чтобы объекты V8 уничтожались! Нам просто необходимо уведомление о том, что это сейчас произойдет.
Все это возможно с помощью постоянных хэндлов V8 (Persistent).
Я приведу опять код для V8 и аналог (в смысле времени жизни) кода на C++.
> `Persistent p; int \*p = 0;
>
> { {
>
> HandleScope handle\_scope;
>
> Local a = Integer::New(1); int a = 1;
>
> p = Persistent::New(a); p = new int (a);
>
> } }
>
>
>
> Persistent q = p; int\* q = p;
>
> p.Dispose(); delete p;
>
> p.Clear(); p = 0;
>
>
>
> int a = q->Int32Value(); int a = \*q;
>
> // ОШИБКА! Уже уничтожено! // ОШИБКА! Ссылка уничтожена!
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Итак, основной способ получения постоянного хэндла (из временного) — это использование вызова Persistent::New(). Context является единственным классом, который при своем создании (New) сразу возвращает постоянный хэндл. Надеюсь, всем уже понятно — почему он так делает.
Вопрос получения уведомлений при уничтожении постоянных хэндлов мы отложим, а пока попробуем соорудить первую рабочую программу, которая выполняет javascript.
Для этого нам потребуется извлекать строки из объекта String V8 в C++ код. Мы воспользуемся простейшим способом — классом String::AsciiValue.
> `// получить строковое представление Value; если это невозможно, вернуть пустую строку
>
> string to\_string(Local v)
>
> {
>
> String::AsciiValue data(v);
>
> const char\* p = \*data;
>
> if (p == 0) return string();
>
> return string(p);
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Функция, которая выполняет произвольный javascript-код, будет выглядеть так:
> `string v8\_exec(const char\* javascript)
>
> {
>
> HandleScope handle\_scope; // стековый объект для хранения временных хэндлов
>
> Persistent context = Context::New(); // создаем контекст и сохраняем его постоянный хэндл
>
> Context::Scope context\_scope(context); // стековый объект "входа" в контекст; для компиляции и выполнения внутри контекста
>
> TryCatch try\_catch; // стековый объект для отлова javascript-исключений
>
> Local<String> source = String::New(javascript); // преобразуем строку с кодом в строку V8
>
> Local` | https://habr.com/ru/post/72474/ | null | ru | null |
# Go: Как использовать nil-значения без использования ссылочных типов
*Создано на базе изображений gopherize.me*
Довольно часто из Go кода нам приходится работать с различными HTTP API или самим выполнять роль HTTP сервиса.
Один из частых случаев: получаем данные в виде структуры из базы данных, отправляем структуру внешнему API, в ответ получаем другую структуру, как-то её преобразуем и сохраняем в базу.
Другими словами: такая обработка не требует множества отдельных операций со структурами запроса и ответа.
Для API нормальна ситуация, когда в структурах запроса и ответа есть поля, которые могут быть nil и могут принимать какие-то не-nil значения. Такие структуры выглядят обычно так
```
type ApiResponse struct {
Code *string json:"code"`
}
```
И, так как это ссылочный тип, то Go компилятор делает escape анализ и может перенести данную переменную в хип. В случае частого создания таких переменных — мы получаем лишнюю нагрузку на GC и даже можем получить "утечку памяти", если GC не успевает освободить всю использованную память.
Что можно сделать в такой ситуации:
* Изменить внешнее API так, чтобы не использовать nil значения. Иногда это допустимо, но изменение API — не всегда хорошая идея: во-первых, это лишняя работа, во-вторых — ошибки, которые могут появиться от такой переделки.
* Изменить наш Go код так, чтобы мы могли принять nil значения, но не использую для этого ссылочные типы.
Для начала, давайте сравним разницу между работой со ссылочными типами и передачей переменных "по значению"
-----------------------------------------------------------------------------------------------------------
Все бенчмарки воспроизводимы и размещены [здесь](https://github.com/kak-tus/nan/tree/master/bench).
В Go коде мы обычно используем такие структуры со ссылочными типами
```
type pointerSmall struct {
Field000 *string
Field001 *string
Field002 *string
Field003 *string
Field004 *string
Field005 *string
}
```
Давайте сравним их со структурами с типами, которые передаются по значению
```
type valueSmall struct {
Field000 string
Field001 string
Field002 string
Field003 string
Field004 string
Field005 string
}
```
Структура со ссылками обработана с 0 аллокаций, аналогично структуре со значениями.
Здесь мы даже видим, что структура со ссылками быстрее по времени обработки.
**Небольшое замечание**: в данном бенчмарке мы видим две механики Go, которые объясняют эти (для кого-то неожиданные) результаты.
Первое — инлайнинг функций. Это механизм, когда вызов функции заменяется на её тело. В данном случае для структур сработал этот механизм и это позволило избежать переноса структур в хип. Как результат — нет аллокаций. Во всех следующих бенчмарках мы не будем отключать этот механизм, т.к. хотим сравнить работу обычного Go кода.
Второе — копирование структур с типами, которые передаются по значению. На копирование структур тратится дополнительное время, что мы и видим в результатах теста.
```
BenchmarkPointerSmall-8 1000000000 0.295 ns/op 0 B/op 0 allocs/op
BenchmarkValueSmall-8 184702404 6.51 ns/op 0 B/op 0 allocs/op
```
Давайте сделаем бенчмарк с вызовом функций и передачей туда структур со ссылками и указателями. Как мы видим, структуры со ссылками обрабатываются всё-ещё быстрее структур со значениями и по-прежнему с нулевым количеством аллокаций.
```
BenchmarkPointerSmallChain-8 1000000000 0.297 ns/op 0 B/op 0 allocs/op
BenchmarkValueSmallChain-8 59185880 20.3 ns/op 0 B/op 0 allocs/op
```
В сервисах часто используется JSON кодирование и декодирование структур. Давайте сравним результаты кодирования и декодирования структур, используя jsoniter. В данном бенчмарке ситуация меняется. Структуры со значениями быстрее и лучше по использованию памяти на одну операцию, лучше по количеству аллокаций.
```
BenchmarkPointerSmallJSON-8 49522 23724 ns/op 14122 B/op 28 allocs/op
BenchmarkValueSmallJSON-8 52234 22806 ns/op 14011 B/op 15 allocs/op
```
Давайте попробуем улучшить результаты кодирования и декодирования, используя easyjson. Почти все результаты для обеих структур лучше, кроме чуть большего использования памяти на одну операцию.
```
BenchmarkPointerSmallEasyJSON-8 64482 17815 ns/op 14591 B/op 21 allocs/op
BenchmarkValueSmallEasyJSON-8 63136 17537 ns/op 14444 B/op 14 allocs/op
```
**Предварительный вывод**: если в вашем коде длинная цепочка обработки полученного значения с итоговым результатом, то иногда будет лучше использовать ссылочные типы. Но если цепочка обработки вашего кода короткая (кодирование/декодирование значения) — то лучше использовать структуры со значениями.
Пойдём дальше. Иногда структуры растут в размере
```
type pointerBig struct {
Field000 *string
...
Field999 *string
}
type valueBig struct {
Field000 string
...
Field999 string
}
```
Сделаем бенчмарк для этих структур. Далее мы видим, что для структуры со значениями обработка как и раньше даёт 0 аллокаций, но увеличилось время обработки (это нормально, т.к. структура стала больше). Так же, структура со ссылками потеряла преимущество: ненулевое количество аллокаций и значительно большее время обработки и использование памяти на одну операцию
```
BenchmarkPointerBig-8 36787 32243 ns/op 24192 B/op 1001 allocs/op
BenchmarkValueBig-8 721375 1613 ns/op 0 B/op 0 allocs/op
```
Попробуем передать данные структуры через цепочку вызовов функций. Для структур со ссылками ничего не изменилось. Для структур со значениями незначительно выросло время обработки (но всё ещё меньше, чем для структуры со ссылками).
```
BenchmarkPointerBigChain-8 36607 31709 ns/op 24192 B/op 1001 allocs/op
BenchmarkValueBigChain-8 351693 3216 ns/op 0 B/op 0 allocs/op
```
Попробуем сделать кодирование и декодирование. Структура со значениями лучше по всем параметрам
```
BenchmarkPointerBigJSON-8 250 4640020 ns/op 5326593 B/op 4024 allocs/op
BenchmarkValueBigJSON-8 270 4289834 ns/op 4110721 B/op 2015 allocs/op
```
Попробуем улучшить результат, используя easyjson. Структура со значениями лучше во всём. Структура со ссылками обрабатывается лучше, чем в jsoniter.
```
BenchmarkPointerBigEasyJSON-8 364 3204100 ns/op 2357440 B/op 3066 allocs/op
BenchmarkValueBigEasyJSON-8 380 3058639 ns/op 2302248 B/op 1063 allocs/op
```
**Итоговый вывод**: не делайте оптимизации на первом этапе разработки — лучше предпочесть использовать структуры со значениями, чем структуры со ссылками. И только когда производительность перестала устраивать — пройдите по цепочке обработки и попробуйте переключиться на передачу значений по ссылке в "горячих местах". Предпочтительно использовать кодогенераторы (easyjson и другие), чем обработку в коде — в большинстве случаев получим результаты лучше.
Переключение на структуры со значениями
---------------------------------------
Переключение выглядит просто — использовать Nullable типы. Пример из библиотеки sql — [sql.NullBool](https://pkg.go.dev/database/sql?tab=doc#NullBool), [sql.NullString](https://pkg.go.dev/database/sql?tab=doc#NullString) и другие.
Так же, для типа потребуется описать [функции кодирования и декодирования](https://godoc.org/encoding/json#example-package--CustomMarshalJSON)
```
func (n NullString) MarshalJSON() ([]byte, error) {
if !n.Valid {
return []byte("null"), nil
}
return jsoniter.Marshal(n.String)
}
func (n *NullString) UnmarshalJSON(data []byte) error {
if bytes.Equal(data, []byte("null")) {
*n = NullString{}
return nil
}
var res string
err := jsoniter.Unmarshal(data, &res)
if err != nil {
return err
}
*n = NullString{String: res, Valid: true}
return nil
}
```
Как результат избавления от ссылочных типов в API — я разработал [библиотеку nan](https://github.com/kak-tus/nan), с основными Nullable типами с функциями кодирования и декодирования для JSON, jsoniter, easyjson, gocql.
Удобство использования Nullable типов
-------------------------------------
И один из последних вопросов, которые можно задать про переключение на Nullable типы — удобно ли их использовать.
Моё личное мнение — удобно, у типов тот же паттерн использования что и у ссылок на переменые.
При использовании ссылки мы пишем
```
if a != nil && *a == "sometext" {
```
С Nullable типом мы пишем
```
if a.Valid && a.String == "sometext" {
``` | https://habr.com/ru/post/513216/ | null | ru | null |
# MAMP своими руками — собираем Apache под Mac OS X
Этот хабратопик будет из серии о том, как своими руками организовать MAMP (Mac OS X + Apache + MySQL + PHP) под Mac OS X.
Начнем с обновления Apache 2.
Думаю пользователям Mac OS X Leopard известно, что Apache (версии 2, начиная с 10.5.2) и так поставляется в комплекте с операционной системой. Но это совсем не означает, что умение самостоятельно обновить свой Apache бесполезен.
Примечание: для того, чтобы у вас все получилось, нужно установить Developer Tools
Поскольку организация файлов и т.п. на Mac OS отличается от принятых в остальных Unix системах (равняюсь на них из-за того, что работать мы будем через терминал) и расположение файлов того же предустановленного Apache отличается от стандартного, я буду давать инструкции по именно обновлению веб-сервера, без создания его лишних копий и с сохранением функции управления оным через Sharing в System Preferences.
Итак, приступим. Для начала скачаем пследнюю версию исходников Apache (на момент написания хабратопика — 2.2.8) — [тут](http://httpd.apache.org/download.cgi) (уточню, нам нужны Unix Source — вот [прямая ссылка](http://apache.rx-host.net/httpd/httpd-2.2.8.tar.gz)).
Распакуем оную куда-нибудь в сохранное место (замечу, что удалять мы эти сорцы не будем — наоборот, они буду лежать у нас для последующего добавления компонентов наименьшими усилиями — при таковой надобности).
Открываем Terminal (папка Utilities в Applications). Тулим к той папки коммандой, допустим она лежит в папке src, в домашней папке юзера:
`cd ~/src/httpd-2.2.8`
В этой папке открываем config.layout и дописываем в конец следующее:
`prefix: /usr
exec_prefix: ${prefix}
bindir: ${exec_prefix}/bin
sbindir: ${exec_prefix}/sbin
libdir: ${exec_prefix}/lib
libexecdir: ${exec_prefix}/libexec+
mandir: ${prefix}/share/man
sysconfdir: /etc+
datadir: /Library/Webserver
installbuilddir: ${prefix}/share/httpd/build
errordir: ${prefix}/share/httpd/error
iconsdir: ${prefix}/share/httpd/icons
htdocsdir: ${datadir}/Documents
manualdir: ${datadir}/share/httpd/manual
cgidir: ${datadir}/CGI-Executables
includedir: ${prefix}/include+
localstatedir: /var
runtimedir: ${localstatedir}/run
logfiledir: ${localstatedir}/log+
proxycachedir: ${runtimedir}/proxy`
Это — схема расположения файлов веб-сервера на нашей машинке. Она четко повторяет схему расположения родного Apache, который устанавливается системой Leopard.
Далее создадим тут же файлик conf.args:
`./configure \
--enable-layout=Leopard \
--enable-mods-shared=all \
--with-mpm=prefork \
--disable-static \
--disable-unique-id \
--disable-ipv6 \
--enable-dav \
--enable-cache \
--enable-proxy \
--enable-shared \
--enable-logio \
--enable-deflate \
--with-included-apr \
--enable-cgi \
--enable-cgid \
--enable-suexec`
Это конфигурационная команда, которая приготовит сорцы к компиляции под вашу систему и определит схему расположения файлов (--enable-layout=Leopard). Кроме того там указаны дополнительные настройки, которые использую локально лично я. Если вам надо еще что-то или чего-то не надо — редактированию подлежит.
В файлик мы ее положили, чтобы, когда что-то надо будет дополнить или изменить — был предыдущий вариант конфигурации.
Все, что осталось сделать, это выполнить кофигурационную команду — копируем ее целиком из файла, вставляем в консоль и жмем энтер. Пройдет некоторое время и команда завершит отработку.
Далее выполняем:
`make`
Ждем, а после:
`sudo make install`
В общем-то, сервер обновлен. :) Позднее добавлю как его в автозагрузку добавить.
И еще, я часто упоминал, что в последующем можно будет удалять или добавлять компоненты — делается это просто. На те же сорцы применяем .configure с новыми параметрами, потом make и sudo make install. Преимущество того, что вы делать это будете еще раз на те же сорцы в том, что конфигурация и make будет происходить значительно быстрее. | https://habr.com/ru/post/26012/ | null | ru | null |
# Что нового нас ожидает в Django 1.7
В данном посте представлен обзор новшеств и особенностей популярного среди Python разработчиков фреймворка Django 1.7. Релиз позиционируется как сообществом, так и основными разработчиками — как наиболее значимый релиз, с момента выхода в свет Django 1.0.
#### Новшества в версии 1.7
Прекращение поддержки Python 2.6. Теперь поддерживается версия Python 2.7 и выше. Заявлена поддержка Python 3.4.
Добавлена нативная поддержка [миграций](https://docs.djangoproject.com/en/dev/topics/migrations/) непосредственно в сам фреймворк. Можно поблагодарить за это автора популярной батарейки South — [Andrew Godwin-а](https://github.com/andrewgodwin).
Команда syncdb объявлена как устаревшая, и будет удалена в Django 1.9. До тех пор syncdb является псевдонимом команды migrate, которая обеспечивает как выполнение миграций, так и старое поведение syncdb.
Фикстуры initial\_data более не инициализируются по умолчанию для приложений с миграциями. Предлагается воспользоваться загрузкой фикстур на уровне самих миграций.
Механизм [загрузки приложения](https://docs.djangoproject.com/en/dev/ref/applications/) — был подвергнут полному рефакторингу. В результате можно отказаться от models.py, который ранее идентифицировал приложение и был обязательным.
Новые методы подклассов [Field](https://docs.djangoproject.com/en/dev/howto/custom-model-fields/#django.db.models.Field). Главная особенность — это обязательный метод deconstruct(). К сожалению в этом вина включения миграций в состав Django. Если Вы наследуетесь от стандартных полей и не переопределяете метод \_\_init\_\_, то заботиться Вам об этом не придется.
Появилась возможность вызовов [QuerySet-ов](https://docs.djangoproject.com/en/dev/topics/db/managers/#create-manager-with-queryset-methods) напрямую из менеджера:
```
class FoodQuerySet(models.QuerySet):
def pizzas(self):
return self.filter(kind='pizza')
def vegetarian(self):
return self.filter(vegetarian=True)
class Food(models.Model):
kind = models.CharField(max_length=50)
vegetarian = models.BooleanField()
objects = FoodQuerySet.as_manager()
Food.objects.pizzas().vegetarian()
```
Возможность указать необходимый менеджер при использовании связывания моделей:
```
class Blog(models.Model):
pass
class Entry(models.Model):
blog = models.ForeignKey(Blog)
objects = models.Manager() # Default Manager
entries = EntryManager() # Custom Manager
b = Blog.objects.get(id=1)
b.entry_set(manager='entries').all()
```
Новая система, для проверки проекта(System check), которая при запуске опеделяет проблемы и подсказывает что и как необходимо исправить. Для проверки, используется новая команда check, пришедшая на замену устаревшей команде validate.
Новый [Prefetch](https://docs.djangoproject.com/en/dev/ref/models/queries/#django.db.models.Prefetch) для продвинутых операций prefetch\_related. Теперь можно настроить предварительную выборку используя QuerySet-ы.
Поддержка текущего часового пояса в панели администратора, при работе с виджетом даты. Прежде использовался часовой пояс браузера. При расхождении времени в браузере и на сервере — выводится визуальная подсказка.
Курсор баз данных, теперь может использоваться в качестве контекст менеджера, что является сокращением для:
```
c = connection.cursor()
try:
c.execute(...)
finally:
c.close()
```
Возможность определения собственных [типов поиска](https://docs.djangoproject.com/en/dev/ref/models/custom-lookups/#django.db.models.Lookup), для фильтрации при использовании ORM.
```
from django.db.models import IntegerField
from django.db.models import Transform
class AbsoluteValue(Transform):
lookup_name = 'abs'
def as_sql(self, qn, connection):
lhs, params = qn.compile(self.lhs)
return "ABS(%s)" % lhs, params
IntegerField.register_lookup(AbsoluteValue)
# Использование
Experiment.objects.filter(change__abs=27)
# В результате получим
# SELECT ... WHERE ABS("experiments"."change") = 27
```
#### Другие интересные изменения
**django.contrib.admin**
* Появилась возможность реализовать [собственные](https://docs.djangoproject.com/en/dev/ref/contrib/admin/#django.contrib.admin.AdminSite.site_header) site\_header, site\_title, и index\_title, без необходимости переопределения шаблона.
* Метод [ModelAdmin.get\_fields()](https://docs.djangoproject.com/en/dev/ref/contrib/admin/#django.contrib.admin.ModelAdmin.get_fields) может быть преопределен, для настройки значений ModelAdmin.fields.
* В дополнение к существующему синтаксису admin.site.register, можно использовать новый [декоратор register()](https://docs.djangoproject.com/en/dev/ref/contrib/admin/#django.contrib.admin.register).
* Можно задать [ModelAdmin.list\_display\_links](https://docs.djangoproject.com/en/dev/ref/contrib/admin/#django.contrib.admin.ModelAdmin.list_display_links) = None, для того что бы отключить ссылки в grid-е
* Для контроля кнопки «Посмотреть на сайте», можно определить свой [ModelAdmin.view\_on\_site](https://docs.djangoproject.com/en/dev/ref/contrib/admin/#django.contrib.admin.ModelAdmin.view_on_site).
* Возможность указать сортировку для [ModelAdmin.list\_display](https://docs.djangoproject.com/en/dev/ref/contrib/admin/#django.contrib.admin.ModelAdmin.list_display), подставляя дефис в admin\_order\_field.
* Метод [ModelAdmin.get\_changeform\_initial\_data()](https://docs.djangoproject.com/en/dev/ref/contrib/admin/#django.contrib.admin.ModelAdmin.get_changeform_initial_data) может быть переопределен, для изменения данных формы.
**django.contrib.auth**
* \*\*kwargs передаваемые в [email\_user()](https://docs.djangoproject.com/en/dev/ref/contrib/auth/#django.contrib.auth.models.User.email_user), так же передаются и в [send\_mail()](https://docs.djangoproject.com/en/dev/topics/email/#django.core.mail.send_mail).
* декоратор [permission\_required()](https://docs.djangoproject.com/en/dev/topics/auth/default/#django.contrib.auth.decorators.permission_required) может получать на вход список разрешений или же только одно разрешение.
* возможно переопределить новый метод [AuthenticationForm.confirm\_login\_allowed()](https://docs.djangoproject.com/en/dev/topics/auth/default/#django.contrib.auth.forms.AuthenticationForm.confirm_login_allowed), для быстрой и легкой настройки политики авторизации.
* [django.contrib.auth.views.password\_reset()](https://docs.djangoproject.com/en/dev/topics/auth/default/#django.contrib.auth.views.password_reset) принимает необязательный параметр html\_email\_template\_name. Параметр используется для отправки html писем, при сбросе пароля .
* добавлен метод [AbstractBaseUser.get\_session\_auth\_hash()](https://docs.djangoproject.com/en/dev/topics/auth/customizing/#django.contrib.auth.models.AbstractBaseUser.get_session_auth_hash). Если пользовательская модель унаследована от [AbstractBaseUser](https://docs.djangoproject.com/en/dev/topics/auth/customizing/#django.contrib.auth.models.AbstractBaseUser), то изменение пароля пользователя приведет к сбросу его устаревших сесссий.
**django.contrib.sites**
* Новая мидлварь [django.contrib.sites.middleware.CurrentSiteMiddleware](https://docs.djangoproject.com/en/dev/ref/middleware/#django.contrib.sites.middleware.CurrentSiteMiddleware) позволяет установливать текущий сайт при каждом запросе.
**E-mail**
* В [send\_mail()](https://docs.djangoproject.com/en/dev/topics/email/#django.core.mail.send_mail) добавлен параметр html\_message, для отправки сообщений типа text/html.
* [SMTP бекенд](https://docs.djangoproject.com/en/dev/topics/email/#django.core.mail.backends.smtp.EmailBackend) получил возможность установить параметр [тайм-аута](https://docs.djangoproject.com/en/dev/topics/email/#django.core.mail.backends.smtp.EmailBackend.timeout).
**Загрузка файлов**
* Добавлен атрибут [UploadedFile.content\_type\_extra](https://docs.djangoproject.com/en/dev/ref/files/uploads/#django.core.files.uploadedfile.UploadedFile.content_type_extra), который содержит дополнительные параметры, передаваемые в заголовоке типа содержимого при загрузке файлов.
* Новая настройка [FILE\_UPLOAD\_DIRECTORY\_PERMISSIONS](https://docs.djangoproject.com/en/dev/ref/settings/#std:setting-FILE_UPLOAD_DIRECTORY_PERMISSIONS) позволяет задавать права на создаваемые директории при загрузке файлов. Ту же настройку непосредственно для файлов, выполняет [FILE\_UPLOAD\_PERMISSIONS](https://docs.djangoproject.com/en/dev/ref/settings/#std:setting-FILE_UPLOAD_PERMISSIONS).
* [FileField.upload\_to](https://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.FileField.upload_to) теперь является необязательным.
**Формы**
* Textarea теперь включает атрибут max\_length, если в модели определен max\_length.
* Field.choices позволяет задать value для пустого значения. По умолчанию "-------".
* В формах в методе clean() более не требуется возвращать self.cleaned\_data.
* Появилась возможность удалить поля из формы, путем установки их имени в None.
* Новый метод add\_error() позволяет задавать ошибки для конкретных полей.
* Добавлена возможность задавать и выводить ошибки к ограничителям вида unique, unique\_for\_date, и unique\_together.
**Интернационализация**
* Атрибут [django.middleware.locale.LocaleMiddleware.response\_redirect\_class](https://docs.djangoproject.com/en/dev/ref/middleware/#django.middleware.locale.LocaleMiddleware.response_redirect_class) позволяет настроить переадресацию.
* [LocaleMiddleware](https://docs.djangoproject.com/en/dev/ref/middleware/#django.middleware.locale.LocaleMiddleware) хранит выбранный язык пользователем язык в \_language. Получить доступ, можно используя константу LANGUAGE\_SESSION\_KEY.
* Тег [blocktrans](https://docs.djangoproject.com/en/dev/topics/i18n/translation/#std:templatetag-blocktrans) удаляет атрибут trimmed. Данная опция удаляет символы новой строки с начала и до конца, обьеденяя их через пробел. Что удобно для генерации файлов локали.
* Улучшен [makemessages](https://docs.djangoproject.com/en/dev/ref/django-admin/#django-admin-makemessages).
* Были добавлены следущие языковые константы: LANGUAGE\_COOKIE\_AGE, LANGUAGE\_COOKIE\_DOMAIN and LANGUAGE\_COOKIE\_PATH.
**Команды управления**
* Возможность отключить цветной вывод в консоль.
* Добавлена возможность дампа данных с первичными ключами при сериализации.
* Нет необходимости указывать название кеш таблицы при использовании createcachetable. Теперь Django это делает сама, с учетом настройки кеша в настройках проекта.
* Команда runserver была улучшена. Теперь при установленном pyinotify, скорость релоада стала выше, и меньше потребляет батарею на ноутах. Так же сервер релоадиться при использовании команды compilemessages. Выводятся в консоль все запросы к статике, которые прежде фильтровались.
**Модели**
* Новый метод [QuerySet.update\_or\_create()](https://docs.djangoproject.com/en/dev/ref/models/querysets/#django.db.models.query.QuerySet.update_or_create).
* Новая Meta опция [default\_permissions](https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.default_permissions), которая позволяет настроить операции создания/изменения/удаления.
* Обнаружение OneToOneField при наследовании в абстрактных классах.
* Добавлена возможность использовать None в качестве значения запроса при использовании [iexact](https://docs.djangoproject.com/en/dev/ref/models/querysets/#std:fieldlookup-iexact).
* Возможность использования единого списка в [index\_together](https://docs.djangoproject.com/en/dev/ref/models/options/#django.db.models.Options.index_together) при указании одного набора полей(не список в списках).
* Числовые поля теперь проверяются в зависимости от БД. Ранее могло приводить к ошибке.
**Запросы и ответы**
* Новый атрибут [HttpRequest.scheme](https://docs.djangoproject.com/en/dev/ref/request-response/#django.http.HttpRequest.scheme) определяет схему запроса (http или https).
* [redirect()](https://docs.djangoproject.com/en/dev/topics/http/shortcuts/#django.shortcuts.redirect) поддерживает относительный URL.
* Новый подкласс HttpResponse — [JsonResponse](https://docs.djangoproject.com/en/dev/ref/request-response/#django.http.JsonResponse).
**Утилиты**
* Улучшен [strip\_tags()](https://docs.djangoproject.com/en/dev/ref/utils/#django.utils.html.strip_tags).
Данный пост является вольным интерпретированием официальной документации находящейся в стадии разработки, и носит исключительно ознакомительный характер.
В него включены наиболее интересные вещи с точки зрения автора поста. Для более подробного и детального ознакомления, можно
перейти на страницу [документации](https://docs.djangoproject.com/en/dev/releases/1.7/). | https://habr.com/ru/post/224249/ | null | ru | null |
# Google Maps для iOS
Компания Google наконец-то выпустила приложение [Google Maps for iOS](https://itunes.apple.com/us/app/google-maps/id585027354?mt=8), сегодня утром оно появилось в App Store.
Удивительно, но программа работает быстрее, чем даже «родное» приложение Apple Maps, не говоря уже о наборе функций.
Google Maps предоставляет «полные и достоверные» карты со встроенным локальным поиском, режим Street View с панорамными фотографиями 360°, фотографии интерьера для более 100 тысяч крупных зданий по всему миру, маршруты общественного транспорта и информацию о пробках на дорогах в реальном времени, интерфейс на 29 языках, в том числе русском и украинском.
В Google Maps для iOS реализована интеграция с Google Account. После авторизации пользователь может синхронизировать с компьютером закладки, историю поиска, маршруты и проч.
Одновременно выпущен [Google Maps SDK](http://googlegeodevelopers.blogspot.com/2012/12/a-new-way-to-add-google-maps-to-your.html) для интеграции Google Maps в сторонние приложения под iOS. Обращение к картам возможно и через [простую схему URL](https://developers.google.com/maps/documentation/ios/urlscheme), без SDK, но с установленным приложением Google Maps. Например, следующий запрос возвращает карту, центрирование по Нью-Йорку, зум 14, с транспортным слоем.
```
comgooglemaps://?center=40.765819,-73.975866&zoom=14&views=traffic
```
P.S. Tip: если вы чем-то недовольны, карты работают плохо — потрясите телефон, чтобы отправить фидбек в компанию Google.
UPD. Через семь часов после выпуска Google Maps стало [самым популярным приложением в App Store](http://thenextweb.com/google/2012/12/13/google-maps-becomes-the-app-stores-most-popular-free-app-just-7-hours-after-launch/). | https://habr.com/ru/post/162445/ | null | ru | null |
# Переписываем Require.js с использованием Promise. Часть 2
В [прошлой части](http://habrahabr.ru/post/252783/) мы написали небольшую библиотеку, пожожую на require.js и позволяющую загружать AMD-модули. Настало время расширить ее возможности и сделать из нее полноценную замену оригинального require.js. Поэтому сегодня мы реализуем возможность настройки, аналогичную функции `require.config()` и поддержку плагинов, чтобы все дополнения к обычному require.js работали и здесь.
### Немного утилитарных функций
Require позволяет не только загружать и объявлять модули, у него есть еще несколько служебных функций для нашего удобства.
**toUrl** – довольно легкая функция, превращает имя модуля в путь до файла. Пока у нас нет поддержки многих фич require,
она выглядит просто:
```
function toUrl(name, appendJS) {
return './' + name + (appendJS ? '.js' : '');
}
```
Возможность добавить расширение используется исключительно внутри библиотеки, для пользователей этот флаг всегда равен false
```
require.toUrl = function(name) {
return toUrl(name, false);
};
```
А мы выставим `true` при вызове из функции `loadScript`:
```
el.src = toUrl(name, true);
```
Таким образом, мы предоставим пользователям возможность строить url по нашим правилам, но сохраним за собой монополию за
загрузку js-файлов.
**specified** – проверка, есть ли указанный модуль в списке загружаемых или загруженных
```
require.specified = function(name) {
return modules.hasOwnProperty(name);
};
```
**undef** – удаляет определение модуля из списка.
```
require.undef = function(name) {
delete modules[name];
};
```
**onError** – стандартный обработчик ошибок. Если вы не хотите видеть сообщение с ошибкой в консоли, вам нужно
переопределить его. Вынесем нашу обработку ошибок в эту функцию:
```
if(typeof errback === 'function') {
errback(reason);
}
+require.onError(reason);
-console.error(reason);
```
Осталась одна очень важная функция – `require.config`. Но она настолько значительная, что ей мы займемся позже.
[Смотреть код этого шага на Github](https://github.com/just-boris/requirejs/tree/step-7).
### Настройки загрузки
Не всегда стандартное поведение устроит всех. Require.js может настраиваться через функцию `require.config()`. Настало
время и нам поддержать её. У нас будет переменная config, в которую мы сможем записывать свои опции и использовать их
в работе. Функция будет принимать новые опции и добавлять их к существующим, например, используя библиотеку [deepmerge](https://github.com/nrf110/deepmerge),
найденную на просторах npm.
```
var config = {};
require.config = function(options) {
config = deepMerge(config, options);
}
```
Когда у нас есть механизм сохранения настроек, надо разобраться, какие опции нам нужно поддержать.
**baseUrl** – базовый путь до модулей, путь до всех модулей начинается с него. По умолчанию равен адресу текущей
страницы, то есть его значение `./`. Добавим его поддержку в функцию `require.toUrl()`.
```
toUrl = function(name, appendJS) {
- return './' + name + (appendJS ? '.js' : '');
+ return config.baseUrl + name + (appendJS ? '.js' : '');
}
```
Эта опция пригодится нам и для тестов, модули лежат в папке fixtures, и теперь мы сможем указать её один раз, а не
повторять всё время.
**urlArgs** – строка, добавляемая в конец url загружаемых модулей. Пригодится, чтобы сохранить определенную версию модулей
в кеш браузера.
**paths** – пути для тех файлов, которые находятся отдельно от остальных модулей. Обычно это популярные библиотеки,
например jQuery, которые есть на CDN, поэтому было бы неплохо объявить, что модуль `jquery` должен грузиться по url вида
`//code.jquery.com/jquery-2.1.3.min.js`. Поддержим наличие модуля в paths в нашем коде.
```
if(config.paths[name]) {
name = config.paths[name];
}
if(!/^([\w\+\.\-]+:)?\/.test(name)) {
name = config.baseUrl + name;
}
if(config.urlArgs) {
name += '?'+config.urlArgs;
}
```
Составление пути до модуля стало сложнее.
* Возьмем его из paths, если там есть.
* Добавим baseUrl, если наш путь не абсолютный
* Добавим GET-параметры, если требуется
Точно так же работает require, поэтому такие настройки дадут такой же результат и как и там.
**bundles** – недавнее нововведение, но полезное. Мы можем создать файл с несколькими модулями (bundle), он будет
загружаться, когда хотя бы один из указанных модулей будет вызван. Чтобы поддержать эту опцию, мы должны поискать модуль
в одной из пачек, а если найдем, то загрузим этот файл вместо исходного.
```
+var bundle = Object.keys(config.bundles).filter(function(bundle) {
+ return config.bundles[bundle].indexOf(name) > 0;
+});
+if(bundle) {
+ return require.toUrl(bundle);
+}
if(config.paths[name]) {
...
```
Если мы нашли модуль в пачке, то рекурсивно начнем вычислять url до этой пачки. Таким образом мы сможем даже находить
пачки пачек модулей, если такие понадобятся.
**shim** – прокладка для работы с кодом, не поддерживающим AMD. Каждое поле shim содержит объект с описанием, как
загрузить указанный модуль. Например:
```
require.config({
shim: {
'jquery.scroll': {
deps: ['jquery'], // зависимости библиотеки
exports: 'jQuery.fn.scroll', // глобальный объект с API библиотеки
init: function() {}, // код инициализации библиотеки, если нужен
exportsFn: function() {} // функция экспорта, используется вместо пары init и exports
}
}
});
```
Когда мы грузим модуль, для которого определен shim, мы должны подготовить заранее его зависимости и не ждать от него
вызова `define`. Вместо привычного механизма здесь вступит в дело функция `loadByShim()`
```
function loadByShim(name, path) {
var shim = config.shim[name];
return _require(shim.deps || [], function() {
return loadScript(name).then(shim.exportsFn || function() {
return (shim.init && shim.init()) || getGlobal(shim.exports)
});
}, null, path)
}
```
В случае, если у модуля есть зависимости, загрузим их, а потом подключим сам модуль. Загрузка значения из него идет или
через функцию `init`, а, если её нет или она ничего не вернула, то воспользуемся значением `exports`. Там не имя
переменной, а путь до неё, разделенный точками. Функция `getGlobal` довольно стандартный подход, его можно найти,
например, [в этом ответе со stackoverlow](http://stackoverflow.com/a/23143992/1297743).
Теперь мы можем настроить загрузчик на работу в самых разных условиях.
[Смотреть код этого шага на Github](https://github.com/just-boris/requirejs/tree/step-8).
### Специальные модули
Некоторые модули для своей работы хотят получить немного больше дополнительной информации об окружении. Для этого
предусмотрены специальные модули, встроенные в библиотеку.
**require** – функцию require можно получить как модуль. Она отличается от глобальной тем, что загружает все модули
относительно текущего модуля, в который её подключили.
**module** – информация о текущем модуле. Самое главное здесь – это возможность узнать свои настройки. Require.js умеет сохранять настройки для модулей в среди своих опций:
```
require.config({
config: {
'my-module': {
beAwesome: true
}
}
})
```
В случае, если `my-module` запросит модуль по имени `module`, его функция `config` будет возвращать информацию для него из
соответствующей секции конфигурации. Эта полезная возможность позволяет держать настройки всех используемых модулей в
одном месте, а также настраивать модули других разработчиков, если они предусмотрели это.
**exports** — объект для экспорта данных из модуля. Можно добавлять к нему свойства, чтобы они сохранились как значение модуля вместо использования return в функции.
Эти три модуля особенно полезны при использовании [CommonJS](http://commonjs) синтаксиса для модулей, но полноценная его поддержка выходит за рамки статьи, поэтому ограничимся только поддержкой этих сущностей как особых модулей.
Итак, теперь у нас будет новый место для поиска модулей – переменная `locals`:
```
+var currentModule = path.slice(-1)[0];
...
+if(locals[dependency]) {
+ return locals[dependency](currentModule);
+}
if(predefines[dependency]) {
```
Мы извлечем имя модуля из истории загрузки, чтобы по имени создать правильные локальные модули. Результат поиска для locals
не будет сохраняться, потому что у они каждого свои. Проще всего устроен модуль require – это будет копия глобальной функции.
```
locals.require = function() {
return require;
}
```
`module` должна собрать информацию о текущем модуле и передать ему.
```
locals.module = module: function(moduleName) {
var module = modules[moduleName];
if(!module) {
throw new Error('Module "module" should be required only by modules')
}
return (module.module = module.module || {
id: moduleName,
config: function () {
return config.config[moduleName] || {};
}
});
};
```
`exports` добавляет к определению модуля возвращаемое значение:
```
locals.exports = function(moduleName) {
return (locals.module(moduleName).exports = {});
}
```
Если мы захотим заменить exports целиком (например, вернуть функцию вместо объекта), то мы можем это сделать через
используя `module`:
```
module.exports = result;
```
По-другому перезаписать exports не выйдет, потому что агрументы функций в js нельзя перезаписать полностью, только
частично изменить.
Осталось научиться забирать себе результат из exports, если он там есть. Добавим проверку, что в него что-то написали:
```
})).then(function (modules) {
- return factory.apply(null, modules);
+ var result = factory.apply(null, modules);
+ return modules[currentModule].module && modules[currentModule].module.exports || result;
}, function(reason) {
```
Теперь модули в нашей системе смогут узнать о себе немного больше и возвращать значения как им удобно.
[Смотреть код этого шага на Github](https://github.com/just-boris/requirejs/tree/step-9).
### Поддержка плагинов
Чтобы загружать модули нестандартным путем, можно использовать плагины. В require, чтобы указать, что модуль грузится
плагином, к его имени добавляют префикс. Например, плагин `text` позволяет загрузить текстовые данные:
```
require(['text!template.html'], function(template) {
//do with template anything what you want
});
```
Мы можем использовать плагины к require.js, для этого нужно распознавать префикс плагинов и вызывать в этом случае правильный плагин. Наша логика загрузки приобретает новое условие:
```
if(dependency.indexOf('!') > -1) {
modules[dependency] = loadWithPlugin(dependency, newPath);
}
```
Функция `loadWithPlugin()` для начала разберет зависимость, чтобы отделить плагин от модуля:
```
var index = dependency.indexOf('!'),
plugin = dependency.substr(0, index);
dependency = dependency.substr(index+1);
```
Затем нужно загрузить сам код плагина. У нас уже есть стандартный механизм загрузки, воспользуемся им и здесь
```
return _require([plugin], function(plugin) {
//...
});
```
Функция require умеет кэшировать загружаемые модули, поэтому плагин загрузится лишь однажды, затем он будет браться
из кэша, и наш плагин будет сразу готов к работе.
Сам же плагин это модуль, имеющий функцию load, которая должна вызываться для загрузки. Вот примерный вид плагина:
```
define('text', function() {
return {
load: function(name, require, onLoad, config) {
//plugin logic
}
}
})
```
Функция `load` получает при вызвове определенные аргументы:
* **name** – имя модуля, уже без названия плагина в префиксе.
* **require** – специальная версия функции require для использования внутри плагина. У этой функции есть те же методы, что
и глобальной, которые мы рассматривали в разделе про утилитарные функции.
* **onLoad** – функция, которую следует вызвать по окончании загрузки модуля и передать его самого как аргумент. Для сообщения
об ошибке вызывается метод `onLoad.error`. Для особых случаев есть метод `onLoad.fromText`, который исполнит переданную ему строку как javascript. Этот метод используется в плагинах-процессорах, для загрузки CoffeeScript, например.
* **config** – объект с нашими настройками. Плагин может захотеть их прочесть, чтобы понять, как себя вести.
Поскольку у нас вся архитектура построена на promise, то и здесь логично обернуть загрузку в него. А внутри
promise-конструктора соберем все необходимые методы для работы плагина.
```
return _require([plugin], function(plugin) {
return new Promise(function(resolve, reject) {
resolve.error = reject;
resolve.fromText = function(name, text) {};
plugin.load(dependency, require, resolve, config);
});
});
```
В случае успеха, плагин вызовет `resolve()` у нашего promise и наполнит его правильным значением. Для остальных возможностей
нужно расширить функцию `resolve` дополнительными свойствами. Плагин сможет вызвать `reject` в случае ошибки, обратившись
к свойству error, как и предусмотрено в API require.js. Метод `fromText` предусмотрен на случай, если плагин
захочет вернуть не значение модуля напрямую, а исполнив строку как javascript-код. Так, например, поступает плагин для CoffeeScript, который загружает coffee-файлы преобразовывает их в js на лету и отдает результат на исполнениение.
```
resolve.fromText = function(name, text) {
if(!text) {
text = name;
}
var previousModule = pendingModule;
pendingModule = {name: dependency, resolve: resolve, reject: reject, path: path};
(new Function(text))();
pendingModule = previousModule;
};
```
Функция `fromText` имеет две формы вызова. Раньше передавалось имя модуля и код, а теперь предлагается передавать только
код. Первый метод хоть и объявлен устаревшим, но используется даже в официальных плагинах, поэтому надо поддерживать его.
Для исполнения кода воспользуемся конструктором `Funсtion()`, но перед этим нужно настроить переменную pendingModule.
В ней у нас хранится модуль, ожидающий своей загрузки. Во время исполнения, скорее всего, произойдет вызов define, который
начнет искать модуль и выбросит ошибку, если модуля не найдет. Подготовим модуль перед вызовом и аккуратно вернем на место
то, что там было до него. В это время мог грузиться другой модуль без плагина, и не стоит ему ломать загрузку.
Поддержка плагинов успешно протестирована на [require-text](https://github.com/requirejs/text) и [require-cs](https://github.com/requirejs/require-cs).
Но есть одно замечание по поводу работы с require-coffee. Плагин знает слишком много о внутренней структуре оригинального
require и делает странные действия [при загрузке](https://github.com/requirejs/require-cs/blob/0.5.0/cs.js#L306-313).
```
load.fromText(name, text);
parentRequire([name], function (value) {
load(value);
});
```
Сначала вызывается fromText, чтобы исполнить код модуля и вызвать в нем `define()`, затем происходит `require()`, чтобы
вызвать resolve еще раз. Однако promise так устроен, что сохраняет результат только первого вызова и игнорирует дальнейшие
вызовы обеих своих функций – resolve и reject.
Оставлен [pull-request](https://github.com/requirejs/require-cs/pull/69) с удалением нежелательного метода, а пока его не
приняли, стоит научиться игнорировать такие вызовы на своей стороне. Для этого добавим флаг resolved и будем однажды ставить
его в true и подавлять вызовы функции после этого.
После этого хака работа CoffeeScript плагина будет налажена.
[Смотреть код этого шага на Github](https://github.com/just-boris/requirejs/tree/step-10).
### Релизимся
Библиотека выглядит готовой к использованию. Большая часть требований к AMD-загрузчику выполнена. Осталось сделать удобным
подключение её для пользователей. Не все браузеры поддерживают Promise, которым мы активно пользуемся. А значит, нужно взять
его на борт своей библиотеки и использовать в случае, если в браузере его нет. Будем использовать этот
[es6-promise-polyfill](https://github.com/lahmatiy/es6-promise-polyfill), потому что он небольшой и не содержит ничего сверх стандарта, а также не требует дополнительной
сборки для работы в браузере, в отличии от, например, [этой реализации](https://github.com/jakearchibald/es6-promise),
которую еще придется подготовить.
Для сборки будем использовать Gulp, как наиболее популярную на сегодня систему сборки. У нее есть плагины для всех наших действий.
* проверим свой код через [gulp-jshint](http://gulp-jshint)
* соберем наш код вместе с Promise с помощью [gulp-include](http://gulp-include). Include позволит нам не просто склеить файлы, но еще и обернуть
их в замыкание, чтобы наши приватные функции не светились снаружи. Получится как-то так:
```
(function(global) {
//= include ../bower_components/es6-promise-polyfill/promise.js
//= include deepmerge.js
//= include core.js
global.define = define;
global.require = require;
global.requirejs = require;
})(window);
```
* пропустим код через [gulp-uglify](http://gulp-uglify) для сжатия. Кстати, полный упакованный размер библиотеки 5.8 Кб, без Promise остается
3 Kb. Require.js версии 2.16 весит 16.5 Кб.
* собранный код протестируем с помощью [karma](http://karma). Мы это делали и раньше, надо лишь интегрировать в сборку. Karma не требует
плагинов для сборки, интегрируется с gulp самостоятельно. Еще добавим PhantomJS, чтобы тестировать работу с polyfill, так
как Firefox уже поддерживает его у себя.
Осталось библиотеку назвать и написать красочный readme. Итак, встречайте – [require-mini](https://github.com/just-boris/require-mini)!
Минималистичная версия require.js с поддержкой только современных браузеров (IE9+). За счет отсутствия хаков имеет меньший
размер и более понятный код. Установка
```
bower install require-mini --save
```
Первый релиз готов!
### Что дальше?
На самом деле развитие не окончено. Require.js имеет еще много особенностей, некоторые из них могут быть полезны.
Каждая ссылка – issue в проекте на Github.
* [Поддержка CommonJS-модулей](https://github.com/just-boris/requirejs/issues/1)
* [Разбор относительных путей и нормализация](https://github.com/just-boris/requirejs/issues/4)
* [Fallback-урлы для модулей](https://github.com/just-boris/requirejs/issues/6)
* [Поддержка функции require.defined()](https://github.com/just-boris/requirejs/issues/7)
Еще может быть полезной [параллельная загрузка модулей](https://github.com/just-boris/requirejs/issues/5). Require.js такой
функциональности не имеет и это может стать нашим преимуществом. Не во всех браузерах это получится реализовать (везде,
кроме IE), но может принести существенную выгоду.
Спасибо за внимание! | https://habr.com/ru/post/252849/ | null | ru | null |
# Как написать проект для продакшена командой из одного человека (или небольшой командой)
Соло-разработка проекта ПО — непростая задача. Никто не будет подталкивать тебя, проверять код и обеспечивать руководство, ты сам по себе путешествуешь в неизведанное.
Чаще всего неопытные разработчики попадают в одну из следующих ловушек:
1. Пользуются этим как возможностью наплевать на стандарты качества кода и не уделять внимания формату кодинга.
2. Делают совершенно противоположное и переусложняют всё намного сильнее необходимого.
Однако в этой статье я попытаюсь показать, что оба подхода одинаково вредны. Без лишних предисловий перейдём к сути.
Примечание: если вы ищете практические советы, то сразу переходите к разделу **«Конкретные рекомендации»**.
Познай своих врагов
===================
Вам нужно избегать двух врагов, и большинство своих взглядов я основываю на этом. Можно даже рассматривать этот раздел как TL;DR статьи.
1. **Сила воли:** упрощаете процесс совершенствования
Это ваш враг как человеческого существа в целом. Мы слишком надеемся на свою силу воли, которая является очень нестабильным и ограниченным ресурсом. Вы будете писать хороший код, когда это проще, чем писать плохой код, аналогично тому, как ходили бы в спортзал чаще, если бы он находился на первом этаже вашего дома.
2. **Многословие:** писать меньше, достигать большего
Можно впустую потратить невообразимое количество времени на копирование бойлерплейт-кода, или если забыть добавить небольшое свойство, или если изменить строку, а спустя час обнаружить, что она вызывает странный баг, с которым вы боролись. Для соло-разработчика эта проблема временами может быть очень раздражающей, поскольку сильное многословие определённо влияет на вашу продуктивность.
Вам должно быть «комфортно»
===========================
Необходимо обеспечить себе комфортность нахождения в среде. Огромную помощь оказывает личный шаблон, используемый на начальных этапах проектов, однако он может быть неприменим, если вы пробуете себя в новых сферах разработки. Итак, вам нужно освоить искусство создания для себя комфортных условий.
*Небольшая помощь со стороны IDE запросто может сэкономить вам десятки минут в день*
Обычно первым делом мы выбираем IDE (если у нас ещё нет любимой среды). Совершенно необходимо иметь должную поддержку IDE. Вот список наиболее полезных функций IDE, достаточно важных для всех разработчиков и абсолютно необходимых в соло-разработке:
1. IntelliSense и проверка правописания
2. Распознавание ошибок и предложения для быстрого исправления
3. Автоматическая проверка соблюдения стандартов написания кода (linting)
4. Автоматическая генерация и рефакторинг фрагментов кода
5. Пошаговый отладчик (который может даже пошагово заходить в библиотеки)
6. Горячие клавиши для быстрой навигации и изменения кода (быстрый поиск, переименование, документирование и т.п.)
Разумеется, реализовать готовую для продакшена кодовую базу можно даже в vim! Но, увы, только лет через десять.
Автоматизация, автоматизация, автоматизация
===========================================
> Если процесс можно автоматизировать за время, которое меньше, чем время на ручное выполнение процесса в течение трёх месяцев, то автоматизируйте его.
Позвольте продемонстрировать последнее предложение на примере. Если при каждом развёртывании вам нужно тестировать конкретный критический сценарий использования и для этого требуется 5 минут, а вы выполняете развёртывание по 10 раз в месяц, то это стоит 50 минут в месяц (если вы не пропускаете или не забываете этот этап). Значит, за 3 месяца это будет стоить 150 минут, то есть абсолютно приемлемо потратить до 150 минут своего времени на написание автоматизированного сквозного тестирования для этого конкретного сценария, даже если придётся приостановить работу над другими важными делами.
Из всех профессионалов разработчики больше всего должны максимально пользоваться автоматизацией!
*Ты не потеряешь свою работу из-за автоматизации, если ты её и программируешь*
Ещё одна веская причина для написания автоматизированных тестов заключается в том, что когда ваш код никто не проверяет, у вас будет больше пространства для ошибок. И поскольку никто в здравом уме не хочет вручную тестировать каждую фичу приложения при каждом релизе новой версии, вам нужно много автоматизированных тестов. Эмпирическое правило: **«если нечто препятствует потоку взаимодействия пользователя с приложением, то напиши для этого тест»**. Не стоит писать тесты для эстетических фич, если только у вас нет для этого много свободного времени. Однако особо полезно использовать в юнит-тестировании снэпшоты UI, чтобы наблюдать, какие его части пропадают в процессе выполнения программы (например, [StoryShots](https://github.com/storybookjs/storybook/tree/master/addons/storyshots)).
Также у вас должна быть структура **конвейера автоматизированной сборки, релиза и развёртывания**. У вас попросту нет ресурсов делать всё это самостоятельно при каждом релизе. Это может быть шаблон, который применим для многократного использования в разных проектах, потому что правильное создание подобной схемы обычно занимает очень много времени, однако обычно она очень обобщена и её можно использовать много раз.
В дополнение к правильно организованному тестированию у вас должна быть некая промежуточная среда, как можно более близкая к среде продакшена. Выпуск непосредственно в продакшен в условиях отсутствия бета-тестеров и наличия немногочисленных ценных пользователей может стать катастрофическим событием. Если правильно настроить конвейер CI/CD, то можно легко будет развёртывать в промежуточной среде ветки фич и отлавливать баги, возникающие только в продакшене (проблемы сертификации TLS, неправильной конфигурации, ошибки CORS и т.п.).
Уделяйте внимание безопасности
==============================
Довольно часто вы будете совершать смертный грех, выполняя отладку с помощью используемых в продакшене API/баз данных. Даже если вы сейчас утверждаете, что этого не будет **никогда**, грешить всё равно будете, ведь это соблазнительно, а часто и практично. Из-за того, что нет других членов команды, способных вас пристыдить, это рано или поздно случится. Устранение неподдающегося бага, который невозможно построчно воссоздать в среде разработки — очень сильная приманка.
Поэтому убедитесь, что есть способ локального хранения паролей без их коммита в репозиторий. Конечно, их там никто не увидит, однако подчистка репозиториев, перепутанные хэши коммитов и метки версий — это совсем невесело. Кроме того, вдруг ваш сервис git когда-нибудь взломают? Что если вы случайно предоставите доступ тому, кто не должен видеть лишнего? Храните пароли на своей машине в среде, или файлах секретов, или даже в локальных переменных IDE.
Переусложняйте, но в правильную сторону
=======================================
Учитывая то, что переусложнение (over-engineering) проекта всегда угрожает соло-разработчику, ведь никто его не контролирует, и оно манит количеством времени, которое можно потенциально сэкономить (основная причина всякого переусложнения), давайте подумаем, как смягчить его влияние. Для одиночного разработчика существует два типа переусложнения.
**Плохой:** всё, что добавляет многословия.
**Хороший**: всё, что снижает многословие.
*Не создавайте подающего масло робота, который хочет, чтобы ему объяснили его предназначение*
Чем сильнее вы переусложняете структуру, тем более модульной она становится, и тем меньше логики присутствует в похожих модулях. В примере хорошего переусложнения получающийся модульный код должен быть **настолько мал, что его можно вводить по памяти** при создании нового модуля. Кроме того, нужно сделать так, чтобы простым поиском IDE часто можно было найти конкретную строку кода, которую вы хотите изменить, или хотя бы ту строку, которая к ней приведёт (как можно меньше повторений).
Очень хорошим примером, который вспоминается в первую очередь — это [Redux Saga](https://github.com/redux-saga/redux-saga) по сравнению [Vuex Proxy](https://github.com/michaelolof/vuex-class-component). Обе являются примерами очень обобщённых библиотек. Но если сравнить использование saga со всеми её многословными определениями и многочисленными слоями и proxy, которая генерирует по запросу мутации при доступе к состоянию… то можно понять, что из них лучше для соло-разработчика или небольшой команды.
Упорядочивайте всё
==================
Делайте всё модульным и стандартизированным, это относится и к самому коду, и к различным сервисам, из которых может состоять проект. Это позволяет сохранять ясность мышления и упрощает привыкание к коду. Вы будете удивлены, что многое сможете делать на автопилоте. Поэтому хороший стиль кода и использование контейнеризации (например, Docker) — ваши лучшие друзья.
Чего делать не нужно
====================
Давайте подробнее разберём то, чего стоит избегать соло-разработчику или небольшой команде:
1. Держитесь подальше от высокопроизводительных, но громоздких языков и/или фреймворков. Нужно поддерживать минимальный объём кода, потому что вы не можете позволить себе вводить/копировать десятки строк бойлерплейта для получения тривиальной функциональности. Также вам требуется простота отладки и пошагового выполнения любой строки кода. Если сервисом пользуется такое количество пользователей, что требуется подобное повышение производительности, то высока вероятность, что над проектом уже работает большая команда.
2. Не используйте языки **без** строгой типизации. Вам нужно как можно чаще замечать ошибки в разработке, и IntelliSense — это огромный плюс, от которого нельзя отказываться. Исключение составляют случаи, когда вы работаете в очень специфической области, в которой даёт выигрыш использование конкретного языка (например, связка машинного обучения и Python). Но даже в этом случае вы всё равно можете пользоваться преимуществами статической проверки типов.
3. Не переборщите с переусложнением. На мой взгляд, один из лучших способов сделать это — избавиться от всего переусложнения при подготовке проекта и создании самых простых требований к нему.
4. Не доверяйте своей памяти. Когда вы используете строку на bash или небольшой скрипт для выполнения какой-то задачи, сохраните его и задокументируйте. Можно, например, использовать wiki GitHub или просто файл README. Также удобно хранить в проекте папку «scripts» и использовать скрипты npm/yarn в проектах node.
5. Не слишком полагайтесь на силу воли.
Вот, например, мои проверенные временем скрипты для проектов node, которые могут послужить демонстрацией пунктов 4 и 5:
```
"git:commit": "git status && git add -N . && git add -p && sgc",
"git:stash": "git stash --all",
"git:nah": "git checkout . && git clean -df",
"git:amend": "git commit --amend --no-edit",
```
Конкретные рекомендации
=======================
Конвейеры данных/машинное обучение
----------------------------------
Используйте для проектов Docker и не очень полагайтесь на то, что ваша личная машина настроена правильно. Даже если вам нужно использовать личную машину (например, локальный GPU), это можно реализовать при помощи [локального кластера Kubernetes](https://thenewstack.io/build-a-machine-learning-testbed-based-on-kubernetes-and-nvidia-gpu/).
Бэкенд
------
Как я говорил выше, следует придерживаться языков со строгой типизацией и избегать многословия. Это означает, что Python или Go, вероятно, являются не лучшими вариантами. Лично мне нравится что-то типа C# с Entity Framework благодаря замечательной поддержке IDE (как Rider, так и VS), а также очень чёткой и читаемой архитектуре фреймворка. Если вы можете выполнять большинство задач интуитивно и с небольшой помощью IntelliSense, без необходимости гуглить или читать документацию, то это огромная победа для сочетания языка и фреймворка. Java тоже подходит, если вы мазохист (я сам не большой фанат Java).
Фронтенд (веб-приложения)
-------------------------
При работе в одиночку мне одинаково нравятся Vue и React, при условии, что проект создаётся на основе TypeScript. Однако если требуется серьёзный UI с большим объёмом динамической интеграции с API, и вы при этом работаете один, то определённо стоит выбирать Vue. Если вы используете компоненты классов и компоненты модулей Vuex (при помощи пакета [vuex-class-component](https://github.com/michaelolof/vuex-class-component)), то получение и сохранение данных при помощи API становится очень лёгким процессом. Для создания двусторонней привязки в любом компоненте достаточно задать свойство класса! Нет необходимости беспокоиться о мутациях, геттерах, сеттерах и boilerplate-коде. В сочетании с действиями hydrate/save/clear в модуле хранения (при необходимости с хэшем и временной меткой истечения срока действия для кэширования) — это всё, что нужно!
Архитектура
-----------
Поначалу это может показаться контринтуитивным, однако микросервисы, ставшие характерным признаком разработки в крупных командах, будут вашим другом.
* Вы будете единственным владельцем всех сервисов с полным контролем над тем, чем они являются и что они делают, и это уже позволяет избавиться от большой части проблем, связанных с микросервисами.
* Можно использовать один инстанс обобщённых сервисов для нескольких приложений (например, для почтовых или push-уведомлений).
* Если вы совершите где-то ошибку, и она проскользнёт через все меры контроля и войдёт в релиз (у вас ведь нет проектной команды или отдела QA), то не повлияет на целое приложение; прекратится работа или ухудшится производительность только одного сервиса.
* Можно создавать новые модули приложения, выполняющие другие задачи, не ставя при этом под угрозу стабильность существующих сервисов (допустим, вам нужно, чтобы чат-приложение имело возможность голосовых/видеовызовов).
Кроме того, нужно обеспечить готовность всех сервисов к Docker. Это не только будет означать, что вы запросто сможете развернуть их где угодно и получить копию среды продакшена в промежуточной среде или даже в среде разработки, но вы также можете использовать Kubernetes или AWS ECS, при необходимости масштабируя приложение!
Заключение
==========
Не забывайте, что эта статья основана на предположении о том, что вы работаете в одиночку или в небольшой команде, имея ограниченный промежуток времени. Большинство современных стандартов разработки ПО создано на основе разработки в крупных компаниях с огромными командами, поэтому не стоит ожидать, что правила для одиночек будут полностью совпадать с привычными.
---
#### На правах рекламы
[Виртуальные серверы](https://vdsina.ru/cloud-servers?partner=habr320) с процессорами AMD EPYC прекрасно подойдут для размещения и разработки крупных проектов, а также соло разработчикам. Частота ядра CPU до 3.4 GHz. Максимальная конфигурация позволит оторваться на полную — 128 ядер CPU, 512 ГБ RAM, 4000 ГБ NVMe.
[](https://vdsina.ru/cloud-servers?partner=habr320) | https://habr.com/ru/post/552260/ | null | ru | null |
# Распознавание образов в R с использованием сверточных нейронных сетей из пакета MXNet
Это подробная инструкция по распознаванию образов в R с использованием глубокой сверточной нейронной сети, предоставляемой пакетом [MXNet](https://github.com/dmlc/mxnet). В этой статье приведен воспроизводимый пример, как получить 97,5% точность в задаче распознавания лиц на R.
[](https://habrahabr.ru/company/infopulse/blog/307242/)
### Предисловие
Мне кажется, кое-какое предисловие все же нужно. Я пишу эту **инструкцию** исходя из двух соображений. Первое — предоставить всем полноценно воспроизводимый пример. Второе — дать ответы на уже возникшие ранее вопросы. Пожалуйста, примите во внимание, что это лишь мой способ подойти к решению этой проблемы, он точно не единственный и, определенно, не лучший.
### Требования
Я собираюсь использовать и **Python 3.x** (для получения и предварительной обработки данных), и **R** (собственно, решение задачи), поэтому имеет смысл установить оба. Требования к пакетам R таковы:
1. [MXNet](https://github.com/dmlc/mxnet/blob/master/docs/how_to/build.md). Этот пакет предоставит модель, которую мы собираемся использовать в этой статье, собственно, глубокую сверточную нейронную сеть. Вам не понадобится GPU-версия, CPU будет достаточно для этой задачи, хотя она может работать медленнее. Если это произойдет, воспользуйтесь GPU-версией.
2. [EBImage](https://bioconductor.org/packages/release/bioc/html/EBImage.html). Этот пакет имеет множество инструментов для работы с изображениями. С ним работа с изображениями — одно удовольствие, документация предельно понятна и довольно проста.
Что касается Python 3.x, установите и [Numpy](http://www.numpy.org/), и [Scikit-learn](http://scikit-learn.org/stable/). Возможно, стоит также установить и дистрибутив [Anaconda](https://www.continuum.io/downloads), в котором есть ряд предустановленных популярных пакетов для **анализа данных** и **машинного обучения**.
Как только у вас все это заработало, можно приступать.
### Набор данных
Я собираюсь использовать [набор лиц Olivetti](http://scikit-learn.org/stable/datasets/olivetti_faces.html). Этот набор данных — коллекция изображений 64 на 64 пикселя, в 0-256 градациях серого.
Набор данных содержит 400 изображений 40 людей. С 10 экземплярами для каждого человека обычно используют **неконтролируемые** или **полуконтролируемые** алгоритмы, но я собираюсь постараться и использовать конкретный **контролируемый** метод.
Для начала нужно масштабировать изображения по шкале от 0 до 1. Это делается автоматически функцией, которую мы собираемся использовать для загрузки набора данных, поэтому не стоит об этом беспокоиться, но нужно знать, что это уже сделано. Если вы собираетесь использовать свои собственные изображения, предварительно **масштабируйте** их по шкале от 0 до 1 (или по -1;1, хотя первое лучше работает с нейронными сетями, исходя из моего опыта). Ниже — скрипт на Python, который нужно выполнить, чтобы загрузить набор данных. Просто измените пути на ваши значения и выполните из IDE или терминала.
```
# -*- coding: utf-8 -*-
# Импорт
from sklearn.datasets import fetch_olivetti_faces
import numpy as np
# Загрузка набора лиц Olivetti
olivetti = fetch_olivetti_faces()
x = olivetti.images
y = olivetti.target
# Вывод информации о размерах и их изменение при необходимости
print("Original x shape:", x.shape)
X = x.reshape((400, 4096))
print("New x shape:", X.shape)
print("y shape", y.shape)
# Сохранение массивов numpy
np.savetxt("C://olivetti_X.csv", X, delimiter = ",")
np.savetxt("C://olivetti_y.csv", y, delimiter = ",", fmt = '%d')
print("\nDownloading and reshaping done!")
################################################################################
# ВЫВОД
################################################################################
#
# Original x shape: (400, 64, 64)
# New x shape: (400, 4096)
# y shape (400,)
#
# Downloading and reshaping done!
```
Фактически, этот кусочек кода делает следующее: загружает данные, изменяет размеры картинок по Х и сохраняет массивы numpy в файл .csv.
Массив х является тензором (тензор — красивое название многомерной матрицы) размера (400, 64, 64): это означает, что массив х содержит 400 экземпляров матриц 64 на 64 (считанных изображений). Если сомневаетесь, просто выведите первые элементы тензора и попробуйте разобраться в структуре данных с учетом того, что вы уже знаете. Например, из описания набора данных мы знаем, что у нас есть 400 экземпляров, каждый из которых — изображение 64 на 64 пикселя. Мы сглаживаем тензор х до матрицы размером 400 на 4096. То есть, каждая матрица 64 на 64 (изображение) теперь конвертируется (сглаживается) в горизонтальный вектор длиной 4096.
Что касается у, то это уже вертикальный вектор размером 400. Его не нужно изменять.
Посмотрите на получившийся файл .csv и убедитесь, что все преобразования понятны.
### Немного предварительной обработки в R
Теперь мы воспользуемся **EBImage**, чтобы изменить размер изображений до 28 на 28 пикселей, и сгенерируем обучающий и тестовый наборы данных. Вы спросите, зачем я изменяю размеры изображений. По какой-то причине моему компьютеру не нравятся картинки 64 на 64 пикселя, и каждый раз при запуске модели с данными возникает ошибка. Плохо. Но терпимо, поскольку мы можем получить хорошие результаты и с меньшими картинками (но вы, конечно, можете попробовать запустить и с 64 на 64 пикселя, если у вас нет такой проблемы). Итак:
```
# Этот скрипт нужен для изменения размера картинок с 64 на 64 до 28 на 28 пикселей
# Очистить рабочую среду
rm(list=ls())
# Загрузить библиотеку EBImage
require(EBImage)
# Загрузить данные
X <- read.csv("olivetti_X.csv", header = F)
labels <- read.csv("olivetti_y.csv", header = F)
# Массив данных картинок с измененным размером
rs_df <- data.frame()
# Основной цикл: для каждой картинки изменить размер и перевести в градацию серого
for(i in 1:nrow(X))
{
# Try-catch
result <- tryCatch({
# Изображение (как одномерный вектор)
img <- as.numeric(X[i,])
# Картинка 64x64 (объект EBImage)
img <- Image(img, dim=c(64, 64), colormode = "Grayscale")
# Изменить размер картинки на 28x28 пикселей
img_resized <- resize(img, w = 28, h = 28)
# Получить матрицу картинки (здесь должна быть другая функция, чтобы сделать это быстрее и аккуратнее!)
img_matrix <- img_resized@.Data
# Привести к вектору
img_vector <- as.vector(t(img_matrix))
# Добавить метки
label <- labels[i,]
vec <- c(label, img_vector)
# Поместить в rs_df с помощью rbind
rs_df <- rbind(rs_df, vec)
# Вывести статус
print(paste("Done",i,sep = " "))},
# Функция вывода ошибок (просто выводит ошибку). Но ошибок быть не должно!
error = function(e){print(e)})
}
# Задать имена. Первые столбцы - метки, остальные - пиксели.
names(rs_df) <- c("label", paste("pixel", c(1:784)))
# Разбиение на обучение и тест
#-------------------------------------------------------------------------------
# Простое разбиение на обучение и тест. Никаких перекрестных проверок.
# Установить начальное число для воспроизводимости
set.seed(100)
# Перемешанный df
shuffled <- rs_df[sample(1:400),]
# Разбиение на обучение и тест
train_28 <- shuffled[1:360, ]
test_28 <- shuffled[361:400, ]
# Сохранить обучающий и тестовый наборы данных
write.csv(train_28, "C://train_28.csv", row.names = FALSE)
write.csv(test_28, "C://test_28.csv", row.names = FALSE)
# Готово!
print("Done!")
```
Эта часть должна быть достаточно понятна, если вы не уверены, как выглядят выходные данные, стоит взглянуть на набор данных **rs\_df**. Это должен быть массив данных 400x785, приблизительно такой:
label, pixel1, pixel2, …, pixel784
0, 0.2, 0.3, … ,0.1
### Построение модели
Теперь самое интересное, давайте построим модель. Ниже скрипт, который был использован, чтобы обучить и протестировать модель. Ниже будут мои комментарии и пояснения к коду.
```
# Очистить рабочую область
rm(list=ls())
# Загрузить MXNet
require(mxnet)
# Загрузка данных и настройки
#-------------------------------------------------------------------------------
# Загрузить обучающий и тестовый наборы данных
train <- read.csv("train_28.csv")
test <- read.csv("test_28.csv")
# Определить обучающий и тестовый наборы данных
train <- data.matrix(train)
train_x <- t(train[, -1])
train_y <- train[, 1]
train_array <- train_x
dim(train_array) <- c(28, 28, 1, ncol(train_x))
test_x <- t(test[, -1])
test_y <- test[, 1]
test_array <- test_x
dim(test_array) <- c(28, 28, 1, ncol(test_x))
# Задать символьную модель
#-------------------------------------------------------------------------------
data <- mx.symbol.Variable('data')
# Первый сверточный слой
conv_1 <- mx.symbol.Convolution(data = data, kernel = c(5, 5), num_filter = 20)
tanh_1 <- mx.symbol.Activation(data = conv_1, act_type = "tanh")
pool_1 <- mx.symbol.Pooling(data = tanh_1, pool_type = "max", kernel = c(2, 2), stride = c(2, 2))
# Второй сверточный слой
conv_2 <- mx.symbol.Convolution(data = pool_1, kernel = c(5, 5), num_filter = 50)
tanh_2 <- mx.symbol.Activation(data = conv_2, act_type = "tanh")
pool_2 <- mx.symbol.Pooling(data=tanh_2, pool_type = "max", kernel = c(2, 2), stride = c(2, 2))
# Первый полностью связный слой
flatten <- mx.symbol.Flatten(data = pool_2)
fc_1 <- mx.symbol.FullyConnected(data = flatten, num_hidden = 500)
tanh_3 <- mx.symbol.Activation(data = fc_1, act_type = "tanh")
# Второй полностью связный слой
fc_2 <- mx.symbol.FullyConnected(data = tanh_3, num_hidden = 40)
# Вывод. Многопеременный логистический вывод, т.к. хотим получить какие-то вероятности.
NN_model <- mx.symbol.SoftmaxOutput(data = fc_2)
# Настройки до обучения
#-------------------------------------------------------------------------------
# Установить начальное значение для воспроизводимости
mx.set.seed(100)
# Используемое устройство. В моем случае CPU.
devices <- mx.cpu()
# Обучение
#-------------------------------------------------------------------------------
# Обучить модель
model <- mx.model.FeedForward.create(NN_model,
X = train_array,
y = train_y,
ctx = devices,
num.round = 480,
array.batch.size = 40,
learning.rate = 0.01,
momentum = 0.9,
eval.metric = mx.metric.accuracy,
epoch.end.callback = mx.callback.log.train.metric(100))
# Тестирование
#-------------------------------------------------------------------------------
# Предсказать метки
predicted <- predict(model, test_array)
# Присвоить метки
predicted_labels <- max.col(t(predicted)) - 1
# Получить точность
sum(diag(table(test[, 1], predicted_labels)))/40
################################################################################
# ВЫВОД
################################################################################
#
# 0.975
#
```
После загрузки обучающего и тестового набора данных я использую функцию `data.matrix`, чтобы превратить каждый набор данных в числовую матрицу. Помните, первый столбец данных — метки, связанные с каждой картинкой. Убедитесь, что вы удалили метки из `train_array` и `test_array`. После разделения меток и зависимых переменных нужно указать MXNet обработать данные. Это я делаю в строке 19 следующим кусочком кода: «dim(train\_array) < — c(28, 28, 1, ncol(train\_x))» для обучающего набора и в строке 24 для тестового. Таким образом мы фактически говорим модели, что обучающие данные состоят из ncol(train\_x) образцов (360 картинок) размером 28x28. Число 1 указывает, что картинки в градации серого, т.е., что у них только 1 канал. Если бы картинки были в RGB, 1 нужно было бы заменить на 3, именно столько каналов имели бы картинки.
Что касается структуры модели, это вариация модели LeNet, использующей гиперболический тангенс как активационную функцию вместо «Relu» (трансформированный линейный узел), 2 сверточных слоя, 2 слоя подвыборки, 2 полностью связных слоя и стандартный многопеременный логистический вывод.
Каждый **сверточный слой** использует ядро 5х5 и применяется к фиксированному набору фильтров. Посмотрите [это прекрасное видео](https://www.youtube.com/watch?v=BFdMrDOx_CM), чтобы празобраться со сверточными слоями. **Слои подвыборки** используют классический подход «максимального объединения».
Мои тесты показали, что **tanh** работает гораздо лучше, чем sigmoid и Relu, но вы можете попробовать и другие функции активации, если есть желание.
Что касается **гиперпараметров** модели, уровень обучения немного выше обычного, но работает нормально, пока количество периодов — 480. Размер серии, равный 40, тоже хорошо работает. Эти гиперпараметры получены путем проб и ошибок. Можно было сделать поиск по перекрывающимся полосам, но не хотелось переусложнять код, так что я воспользовался проверенным методом — проб и ошибок.
В конце вы должны получить точность 0.975.
### Заключение
В целом, эту модель было достаточно легко настроить и запустить. При запуске на CPU обучение занимает 4-5 минут: немного долго, если вы хотите поэкспериментировать, но все же приемлемо для работы.
Учитывая тот факт, что мы никак не работали с параметрами данных и выполнили только простые и самые обычные шаги предварительной обработки, мне кажется, что полученные результаты весьма неплохи. Конечно, если бы мы хотели добиться более высокой «настоящей» точности, нужно было бы сделать больше перекрестных проверок (что неизбежно заняло бы много времени).
Спасибо, что дочитали, и надеюсь, эта статья помогла вам понять, как настраивать и запускать эту конкретную модель.
Источник набора данных — набор лиц Olivetti, созданный AT&T Laboratories Cambridge. | https://habr.com/ru/post/307242/ | null | ru | null |
# Почему иногда React/Redux в текущем состоянии give me creeps
React существует достаточно давно, чтобы мажорные изменения в этой библиотеке, не ощущались температурой подогрева кресел разработчиков в холодные зимние вечера (не благодарите за лайфхак). Но Facebook сделали ход конем и в свое время выпустили не мажорную, а минорную версию и тем самым сняли с себя ответственность за нестабильность уже существующих миллионов репозиториев, как вы уже поняли я буду рассказывать про версию 16.8.0, а так как мы почти никогда не используем React без Redux в продакшн репозиторияx, то и про него скажу.
И сперва давайте поговорим про React. Почему была упомянута нестабильность после внесения “дополнений” 16.8.0, проблема в том что она произошла в головах разработчиков - легким движением руки Facebook сказал нам, знаете, ООП это конечно же хорошо, но функциональный подход лучше. И тут особо ярые и продвинутые ринулись кидать уже существующий подход Statefull Components и Stateless Components и дописывать новыe functional Components с его хуками useState, useCallback, useEffect etc. и только лишь иногда useContext.
Штош, в самих этих 4х функциях я ничего плохого и не вижу, в общем-то:
* Динамическое именование проперти стейта - Fine
* не нужно выстраивать структуру стейта и запоминать ее для обновления - Excellent
* Можно использовать хук для нескольких изолированных экземпляров стейта даже в одном и том же компоненте - Splendid
* А главное - это не нужно запоминать все примочки с Lifecycle - тут все сразу понятно - срабатывает сразу после рендера, а если добавишь clean-up возвращаемую функцию то она сработает сразу же перед удалением компонента из дерева, чего уже говорить про то что строк кода нужно писать меньше - Amazing (c) Тим Кук
И вот, читаешь это и глаз радуется и уже как бы и не злой ты на Фейсбук и тут находишь это (прим. с офф сайта):
```
import React, { useState, useEffect } from 'react';
function useFriendStatus(friendID) {
const [isOnline, setIsOnline] = useState(null);
function handleStatusChange(status) {
setIsOnline(status.isOnline);
}
useEffect(() => {
ChatAPI.subscribeToFriendStatus(friendID, handleStatusChange);
return () => {
ChatAPI.unsubscribeFromFriendStatus(friendID, handleStatusChange);
};
});
return isOnline;
}
```
А теперь давайте этот пример расширим до жизненных реалий (все хуки в разных файлах):
```
// useFriednStatus.js
import React, { useState, useEffect } from 'react';
import { useDispatch, useSelector } from 'react-redux';
import * as actions from 'actions';
import { getLoggedInUserSelector } from 'selectors';
function useFriendStatus(friendID) {
const [isOnline, setIsOnline] = useState(null);
function handleStatusChange(status) {
setIsOnline(status.isOnline);
}
useEffect(() => {
ChatAPI.subscribeToFriendStatus(friendID, handleStatusChange);
return () => {
ChatAPI.unsubscribeFromFriendStatus(friendID, handleStatusChange);
};
});
return isOnline;
}
// useBestFriendNotifier.js
import React, { useState, useEffect } from 'react';
import { useDispatch, useSelector } from 'react-redux';
import * as actions from 'actions';
import { getLoggedInUserSelector } from 'selectors';
function useBestFriendNotifier(currentUserId) {
const loggedInUser = useSelector(getLoggedInUserSelector);
const isBestFriendOnline = useFriendStatus(loggedInUser.bestFriendId);
const dispatch = useDispatch();
const notifyMeAboutBestFriendActivity = React.useCallback(() => {
dispatch(actions.notify(isBestFriendOnline));
}, [isBestFriendOnline]);
return notifyAboutBestFriendActivity;
}
// Notification.jsx
import { bestFriendOnlineSelector } from 'selectors';
function Notification(({ id }) => {
const notifier = useBestFriendNotifier(id);
const isOnline = useSelector(bestFriendOnlineSelector);
return (
Your Best friend is { isOnline ? 'Online' : 'Offline' }
);
});
```
Эта вложенность может быть и больше, а код уже нечитаемый, приходиться заниматься рекурсивным чтением чтобы понять что было в самом начале и откуда берётся значение, чтобы, например, найти в каком поле Store храниться текущий пользователь.
Как всегда выходит в данном случае, все что ты даешь разработчику написать самому может стать предметом долгих обсуждений. И можно сказать дискоммуникация, плохой лид, плохой разраб, отсутствие конвенции, но если так подумать: есть новый непроторенный ни лидом, ни другими разработчиками подход, и как бы и в официальной документации НЕ написано жирными буквами:
> **Please, do not use more then one level nesting of custom hooks**
>
>
И вот у тебя уже в проекте Stateful Componetns поверх Stateless Componetns, а некоторые перекочевали в function Components (правильно, с хуками, которые под Stateful) и просто function Components, а все потому что нам заботливо написали в документации.
> **We**[**don’t recommend**](https://reactjs.org/docs/hooks-intro.html#gradual-adoption-strategy)**rewriting your existing components overnight but you can start using Hooks in the new ones if you’d like.**
>
>
И часто не все разработчики, в силу опыта, а точнее его отсутствия видят картину целостно, то есть ты себе сидишь, пишешь рекурсивные вложенные хуки, код знаешь, место при надобности найдешь, да вот время идет, проекты меняются, а на твое место приходят новые разработчики, которые твой код видят в первый раз.
Все это осознание приходит позже, и что оно дает, правильно - новый подход, четвертый, более чистый - с одноуровневыми кастомными хуками, да только старый подход никуда не делся и если не следить за новым разработчиком который видит существующий легаси и думает - ну и так сойдет и через раз пописывает те самые рекурсивные кастомные хуки. А практика показывает - у лида, архитекторов, разработчиков и других людей заинтересованных смотреть пул реквесты и обновлять конвенцию, и так слишком много работы чтобы присматривать за уже состоявшимся и само-организованным участником Skrum команды, и подход будет плодиться.
Единственным решением в этой ситуации я вижу возможную в будущем пометку в офф. документации - чтоб не использовали вложенность больше одного уровня, а еще лучше прописать такую рулу в линтер, чтоб особо пытливые руки не дотянулись.
Ну и пару слов хочется сказать про redux-thunk, та же проблема - вложенные dispatch() в dispatch(), несколько dispatch() вызовов в одном action где один dispatch() может вызывать чистый action with type ... payload, а вот другие иметь больше вложенных dispatch() и даже с TypeScript не всегда удается отследить отправляемый пейлоад:
```
function App(() => {
dispatch(actions.init());
});
// actions.ts
export const init = (): ThunkAction => {
return async (dispatch, getState) => {
try {
const user = await getUser();
if (!user) {
dispatch(setNotLoggedInUserState());
}
dispatch(setLoggedInUserState(user));
} catch (e) {
dispatch(showErrorModal);
}
};
}
const setNotLoggedInUserState = (): ThunkAction => {
return async (dispatch, getState) => {
dispatch(setDefaults());
dispatch(showLoginModal());
};
}
const setLoggedInUserState = (user): ThunkAction => {
return async (dispatch, getState) => {
dispatch(wellcomeBackModal(user.name));
};
}
// ...
```
**Заключение**
Это всего лишь рассуждения на тему того что не всегда модное === лучшее, и возможно, стоило бы уступить место более понимаемому подходу если все равно профита в перфоманс приложения не наблюдается. Впрочем, сами разработчики Facebook в некоторых статьях признаются, что часто могут отказаться от понимаемого кода во имя минимизации строк, например. | https://habr.com/ru/post/565904/ | null | ru | null |
# Краткий обзор отличий LESS от SASS
Вчера пол дня потратил на подробное изучение [LESS](http://lesscss.org/) и его отличие от используемых нами [SASS/SCSS](http://sass-lang.com/).
Синтаксис SASS мне импонирует больше чем SCSS за его краткость. Но большая вложенность стилей в SASS может быстро ликвидировать все преимущества его краткости. В любом случае разницу между SASS и SCSS не принципиальна. LESS оказался ближе к SCSS чем к SASS. И, в общем, это тоже самое. Отличий не много, но парочка из них принципиально меняют расстановку сил.
#### 1. LESS — может client-side с использованием JS.
Точнее он не то чтобы может, он на это и расчитан. Обычная практика использования LESS-кода:
````
````
Это потом уже к нему прикрутили возможность компиляции на сервере (и на js и на ruby).
На первый взгляд какое-то странное свойство. Зачем компилить на стороне клиента, если можно отлично скомпилить на сервере и отдавать уже готовую ужатую CSS как мы привыкли с SASS?
Причина становится видна после изучения невзрачных самых [послених строках документации к LESS](http://lesscss.org/#-importing):
`@height: `document.body.clientHeight`;`
Вот такая маленькая одинокая строчка дает возможности о которых только мечтали верстальщики с начала освоения стилей. Вызов из CSS ява-скрипта на стороне клиента и учет фактических параметров браузера при создании стилей.
Тоесть у нас появилась возможность сначала загрузить DOM, а потом под него создать специальный CSS прямо на стороне клиента. Дальше сами думаейте какие возможности этот открывает.
Нужно ли это вашему проекту это вопросу другой. Понятно что все привыкли к клиентской неизвестности/независимости и верстке в стиле «делаем универсально, чтобы более-менее показывалось у всех на всех разрешениях». Но это не повод забывать что теперь такая возможность есть и с ней вы можете делать, к примеру, ну очень резиновую верстку.
#### 2. LESS, в отличии от SASS/SCSS не имеет логики.
В LESS нет if/then, for и т.п. Хотя, учитывая то, что в него легко встраивается JS думаю логику вполне возможно прикрутить. Не пробовал.
#### 3. В LESS проще миксинг + миксить можно классы.
Очень понравилось то, что в LESS можно включать в определение свойства других классов. Собственно класс и является миксином. Это еще одна особенность которой нет в SASS/SCSS. Вы можете включить в LESS обычный CSS файл и использовать его классы для определия своих свойств. Например:
`.wrap {
text-wrap: wrap;
white-space: pre-wrap;
white-space: -moz-pre-wrap;
word-wrap: break-word;
}
pre { .wrap }`
#### Резюме
За исключением 1-го пункта разница не велика и выбор большена любителя.
Лично для меня LESS выглядит более привлекательным из-за своей простоты. Циклы и условия в стилях мне еще никогда не были нужны. Классические утилиты типа «box-shadow, linear-gradient, darken' в LESS есть.
Да, под SASS написано уже множество готовых библиотек ([compass](http://compass-style.org/), [bourbone](https://github.com/thoughtbot/bourbon) и достаточно широкое сообщество), но под LESS есть тот же [Twitter Bootstrap](http://twitter.github.com/bootstrap/) и этого более чем достаточно.
P.S. Нашел старницу сравнения [SASS vs LESS](http://wrangl.com/sass-v-less) и вместе с ней открыл для себя любопытный сервис аргументированных сравнений [wrangl.com](http://wrangl.com/) | https://habr.com/ru/post/130886/ | null | ru | null |
# Обмен информацией между рабочими нитям без боли? CSP-шные каналы нам в помощь
Разработка многопоточного кода — это сложное занятие. Действительно сложное. К счастью для упрощения жизни разработчиков давным-давно придуманы высокоуровневые абстракции, например, task-based parallelism, map-reduce/fork-join, CSP, actors и т.д.
Но когда попадаешь на профильные форумы, где общаются C++ники, то складывается ощущение, что многие просто не в курсе наличия чего-то более простого и удобного, чем std::thread в купе с std::mutex+std::condition\_variable. Регулярно встречаются вопросы из категории: «Мне нужно запустить несколько рабочих потоков, в одном делается то-то, во втором то-то, а в третьем то-то. Я их запускаю вот так, а информацией между потоками обмениваюсь вот так. Правильно ли я делаю?»
Очевидно, что такие вопросы задают новички. Но, во-первых, количество неопытной молодежи в разработке софта всегда было велико, и с ростом привлекательности отрасли ИТ это количество только увеличивается. При этом печально, что новички знают про std::thread и std::mutex, но не знают про готовые инструменты, которые могли бы упростить им жизнь (вроде Intel TBB, HPX, QP/C++, Boost.Fiber, FastFlow, CAF, SObjectizer и т.д.).
И, во-вторых, среди ответов на такие вопросы довольно редко встречаются советы «возьмите вот этот готовый инструмент, ваша задача с его помощью решается всего в несколько строчек». Гораздо чаще люди обсуждают низкоуровневые детали самодельных реализаций thread-safe очередей сообщений.
Все это наводит на мысль о том, что имеет смысл на простых примерах показывать, как конкретный фреймворк может помочь в решении даже небольших и, казалось бы, несложных задач, связанных с многопоточностью. Поскольку мы развиваем [SObjectizer](https://github.com/eao197/so-5-5) как раз как инструмент для упрощения разработки многопоточных приложений на C++, то сегодня попробуем показать, как реализованные в SObjectizer-е [CSP](https://en.wikipedia.org/wiki/Communicating_sequential_processes)-шные каналы способны избавить разработчика от части головной боли при написании многопоточного кода.
Простой демонстрационный пример
===============================
В этой статье мы рассмотрим несложный демонстрационный пример. Маленькое тестовое приложение на главной нити которого ведется «диалог» с пользователем. Когда пользователь вводит слово «exit», работа приложения завершается.
В приложении есть два дополнительных рабочих потока. На одном имитируется периодический «опрос» некого датчика. На втором рабочим потоке «снятая» с датчика информация «записывается» в файл.
Естественно, никакой реальной работы с датчиком и файлами данных не выполняется, вместо этого в программе организуются задержки, блокирующие рабочую нить на некоторое время. Таким образом имитируется синхронная работа с внешними устройствами и файлами.
Пусть такая грубая имитация читателя не смущает. Цель статьи в том, чтобы показать взаимодействие между рабочими потоками через CSP-шные каналы (которые в SObjectizer называются [mchains](https://www.slideshare.net/YauheniAkhotnikau/dive-into-sobjectizer-55-ninth-part-message-chains)), а не в том, чтобы наполнить рабочие нити актуальным содержимым.
Принцип работы примера «на пальцах»
-----------------------------------
Итак, в нашем примере кроме главной нити есть еще две дополнительных рабочих нити.
Первая рабочая нить, которую мы будем называть meter\_reader\_thread, предназначена для «опроса» датчика. Этой нити нужно два mchain-а. Первый mchain будет использоваться для отсылки команд самой нити meter\_reader\_thread. В частности, в этот канал по таймеру будет помещаться сообщение типа acquisition\_turn, получив которое meter\_reader\_thread будет проводить «опрос».
Второй mchain нужен meter\_reader\_thread для того, чтобы передавать «снятую» с датчика информацию второй рабочей нити. Вторая рабочая нить, которую мы будем называть file\_writer\_thread, отвечает за «запись» информации в файл. Вторая рабочая нить читает из mchain команды на запись информации и «исполняет» их. Пока команд в mchain-е нет, нить file\_writer\_thread спит в ожидании новой команды.
Получается вот такая простая схема:
Работа обеих нитей завершается как только mchain-ы закрываются в главном рабочем потоке.
Разбор текста простого примера
------------------------------
[Полный исходный текст](https://github.com/eao197/so5-lor-two-thread-demo-ru/blob/201805081500/dev/two_thread_demo/main.cpp) простого примера можно посмотреть в созданном для иллюстрации [репозитории](https://github.com/eao197/so5-lor-two-thread-demo-ru). Мы же пойдем от простого к сложному. Начнем разбор с функций, выполняющих работу нитей file\_writer\_thread и meter\_reader\_thread, после чего посмотрим на реализацию функции main(), в которой нам придется учесть ряд фокусов, связанных с многопоточностью.
### Функция file\_writer\_thread()
Функция file\_writer\_thread() является самой простой в данном примере. Вот ее полный текст:
```
// Нить, которая будет записывать файлы.
void file_writer_thread(
// Канал из которого будут читаться команды на запись.
so_5::mchain_t file_write_ch) {
// Читаем все из канала до тех пор, пока канал не закроют.
// В этом случае произойдет автоматический выход из receive.
receive(from(file_write_ch),
// Этот обработчик будет вызван когда в канал попадет
// сообщение типа write_data.
[&](so_5::mhood_t cmd) {
// Имитируем запись в файл.
std::cout << cmd->file\_name\_ << ": write started" << std::endl;
std::this\_thread::sleep\_for(350ms);
std::cout << cmd->file\_name\_ << ": write finished" << std::endl;
});
}
```
Все, что делает file\_writer\_thread() — это висит внутри вызова receive(). Функция receive() ждет поступления сообщения в канал и, когда сообщение в канал поступает, ищет обработчик для этого сообщения среди тех обработчиков, которые переданы в receive().
В данном случае передается всего один обработчик — для сообщения типа write\_data. Когда сообщение такого типа поступает в канал, этот обработчик вызывается. Внутри данного обработчика, по сути, собрана вся «бизнес-логика», т.е. имитация записи прочитанных данных в файл.
У функции receive() в SObjectizer есть две версии. Первая версия, которую мы в данном примере не использовали, ждет и извлекает из канала всего одно сообщение. Вторая же версия, которая и показана выше, извлекает из канала все сообщения и возвращает управление только когда канал закрывается. Т.е. в данном случае выход из file\_writer\_thread() произойдет только когда завершит свою работу вызов receive(). А это случится когда кто-то закроет канал file\_write\_ch.
### Функция meter\_reader\_thread()
Функция meter\_reader\_thread несколько сложнее:
```
// Нить чтения данных с датчика.
void meter_reader_thread(
// Канал, который нужен этой нити.
so_5::mchain_t timer_ch,
// Канал, в который будут отсылаться команды на запись файла.
so_5::mchain_t file_write_ch) {
// Тип для периодического сигнала от таймера.
struct acquisition_turn : public so_5::signal_t {};
// Просто счетчик чтений. Нужен для генерации новых имен файлов.
int ordinal = 0;
// Запускаем таймер.
auto timer = so_5::send_periodic(timer\_ch, 0ms, 750ms);
// Читаем все из канала до тех пор, пока канал не закроют.
// В этом случае произойдет автоматический выход из receive.
receive(from(timer\_ch),
// Этот обработчик будет вызван когда в канал попадет
// сигнал типа acquire\_turn.
[&](so\_5::mhood\_t) {
// Имитируем опрос датчика.
std::cout << "meter read started" << std::endl;
std::this\_thread::sleep\_for(50ms);
std::cout << "meter read finished" << std::endl;
// Отдаем команду на запись нового файла.
so\_5::send(file\_write\_ch,
"data\_" + std::to\_string(ordinal) + ".dat");
++ordinal;
});
}
```
Здесь мы, во-первых, определяем тип сигнала acquisition\_turn, который будет к нам время от времени приходить для того, чтобы мы выполнили имитацию «опроса» датчика.
Во-вторых, мы запускаем этот самый периодический сигнал acquisition\_turn посредством вызова send\_periodic(). Благодаря этому SObjectizer раз в 750ms будет отсылать acquisition\_turn в timer\_ch.
Ну а дальше уже знакомый нам вызов receive() из которого мы выйдем только когда канал timer\_ch будет закрыт. Внутри receive() у нас реализован обработчик нашего сигнала acquisition\_turn. В этом обработчике мы имитируем «опрос» датчика, а затем даем команду на запись «собранных» данных нити file\_writer\_thread через отсылку сообщения write\_data в канал file\_write\_ch.
Так что получается, что meter\_reader\_thread спит все время внутри receive(), периодически просыпается при получении acquisition\_turn, после чего отсылает сообщение write\_data в file\_write\_ch (т.е. в нить file\_writer\_thread) и засыпает вновь до следующего acquisition\_turn. Либо же пока timer\_ch не будет закрыт.
### Функция main()
Прежде чем заглянуть в код main(), нужно описать несколько небольших тонкостей, без обсуждения которых может быть непонятна часть этого кода.
Главная проблема, которую приходится решать при работе с нитями и CSP-шными каналами — это корректное и своевременное завершение рабочих нитей. Т.е. если мы создаем экземпляр std::thread и запускаем с его помощью рабочую нить, то мы должны будем затем вызывать std::thread::join() чтобы дождаться завершения рабочей нити (detached threads здесь не используются). Самый простой способ — это вручную вызвать std::thread::join() в конце функции main(). Что-то вроде:
```
int main() {
...
std::thread file_writer{file_writer_thread};
...
file_writer.join();
}
```
Но плохо то, что такой наивный подход не защищает нас от исключений или других форм преждевременного выхода из скоупа (например, обычный return).
Тут нам мог бы помощь какой-то вспомогательный класс, который бы вызывал std::thread::join() в своем деструкторе. Например, мы могли бы сделать что-то вроде:
```
class auto_joiner {
std::thread & t_;
... // Запрет на копирование/перемещение.
public:
auto_joiner(std::thread & t) : t_{t} {}
~auto_joiner() { t_.join(); }
};
int main() {
...
std::thread file_writer{file_writer_thread};
auto_joiner file_writer_joiner{file_writer};
...
}
```
При использовании SObjectizer нет надобности писать такой auto\_joiner самостоятельно, поскольку в SObjectizer уже есть подобный инструмент. Мы как раз увидим его использование в коде main(). От показанного выше от отличается тем, что может вызывать join() не для одного объекта std::thread, а для нескольких.
Но кроме вызова std::thread::join() для корректного останова рабочей нити в нашем примере нужно учесть еще один нюанс: чтобы нить, внутри которой вызван receive(), завершила свою работу, следует закрыть mchain. Если этого не сделать, возврата из receive() не произойдет и мы навечно заснем на вызове std::thread::join().
Это значит, что мы должны позаботится об автоматическом закрытии mchain-ов при выходе из main(). И тут мы применим такой же подход, как и с вызовом std::thread::join(): воспользуемся вспомогательным объектом, который в своем деструкторе вызывает close() для mchain-а. Т.е. мы сделаем что-то вроде:
```
int main() {
...
auto ch = so_5::create_mchain(...);
auto_closer ch_closer{ch};
...
}
```
Опять же, свою реализацию этого вспомогательного класса auto\_closer нам делать не нужно, т.к. в SObjectizer уже есть готовая.
Мы уже разобрали как снять с себя заботы по вызову join() для рабочих нитей и автоматического закрытия mchain-ов. Но остался еще один очень важный момент: в каком именно порядке эти операции должны выполняться. Поскольку, если мы напишем вот такую самую простую и понятную последовательность:
```
int main() {
...
auto ch = so_5::create_mchain(...);
auto_closer ch_closer{ch};
...
std::thread work_thread{[ch]{ receive(from(ch), ...); }};
auto_joiner work_thread_joiner{work_thread};
...
}
```
то мы получим классический дедлок и зависание в деструкторе auto\_joiner-а.
Проблема в том, что деструктор auto\_joiner-а вызывается до деструктора auto\_closer-а. Т.е. мы попробуем сделать join для рабочей нити, которая висит на receive() из еще не закрытого mchain-а.
Поэтому для того, чтобы mchain-ы автоматически закрывались до того, как для рабочей нити будет вызван join(), нужно изменить порядок создания сущностей в программе:
```
int main() {
...
// Создаем объект рабочей нити. Но саму рабочую нить пока не стартуем.
std::thread work_thread;
auto_joiner work_thread_joiner{work_thread};
...
// Теперь можно создать канал для рабочей нити.
auto ch = so_5::create_mchain(...);
auto_closer ch_closer{ch};
...
// А вот теперь рабочую нить можно запустить.
work_thread = std::thread{[ch]{ receive(from(ch), ...); }};
...
}
```
И вот теперь, после объяснения основных нюансов, можно посмотреть на код самой функции main():
```
int main() {
// Запускаем SObjectizer.
so_5::wrapped_env_t sobj;
// Объекты-нити создаем заранее специально для того...
std::thread meter_reader, file_writer;
// ...чтобы можно было создать этот объект joiner.
// Именно он будет вызывать join() для нитей при выходе из
// main. При этом не важно, по какой причине мы из main выходим:
// из-за нормального завершения или из-за ошибки/исключения.
auto joiner = so_5::auto_join(meter_reader, file_writer);
// Создаем каналы, которые потребуются нашим рабочим нитям.
auto timer_ch = so_5::create_mchain(sobj);
auto writer_ch = so_5::create_mchain(sobj);
// Каналы должны быть автоматически закрыты при выходе из main.
// Если этого не сделать, то рабочие нити продолжат висеть внутри
// receive() и join() для них не завершится.
auto closer = so_5::auto_close_drop_content(timer_ch, writer_ch);
// Теперь можно стартовать наши рабочие нити.
meter_reader = std::thread(meter_reader_thread, timer_ch, writer_ch);
file_writer = std::thread(file_writer_thread, writer_ch);
// Программа продолжит работать пока пользователь не введет exit или
// пока не закроет стандартный поток ввода.
std::cout << "Type 'exit' to quit:" << std::endl;
std::string cmd;
while(std::getline(std::cin, cmd)) {
if("exit" == cmd)
break;
else
std::cout << "Type 'exit' to quit" << std::endl;
}
// Просто завершаем main. Все каналы будут закрыты автоматически
// (благодаря объекту closer), все нити также завершаться автоматически
// (благодаря объекту joiner).
return 0;
}
```
Надеюсь, что в основном этот код понятен. И пояснения могут потребоваться разве что для двух небольших моментов.
Во-первых, это создание экземпляра so\_5::wrapped\_env\_t в начале main-а. За этим экземпляром будет скрываться [SObjectizer Environment](https://habr.com/post/354508/). А SObjectizer Environment нам нужен как для создания mchain-ов, так и для обслуживания таймеров (вызов send\_periodic() в meter\_reader\_thread скрывает в себе обращение к SObjectizer-овскому таймеру).
Во-вторых, это вызов auto\_close\_drop\_content. С одной стороны, с ним понятно: данная функция возвращает объект auto\_closer, который автоматически закроет mchain-ы в своем деструкторе. Но, с другой стороны, что значит drop\_content в названии этой функции?
Дело в том, что в SObjectizer закрыть mchain можно в двух режимах. В первом режиме mchain закрывается с выбрасыванием всех находящихся в mchain-е сообщений, которые еще не были обработаны функциями receive(). Например, на момент вызова close() в mchain находится 100500 сообщений. Все эти сообщения будут уничтожены и к получателям они не попадут. Этот режим называется drop\_content и функция auto\_close\_drop\_content как раз создает auto\_closer, который закроет mchain в режиме drop\_content.
Второй режим закрытия mchain-а, напротив, сохраняет все сообщения в mchain-е. Что дает возможность функциям receive() завершить обработку содержимого mchain. Но вот новые сообщения в mchain добавить будет уже нельзя, т.к. mchain уже закрыт (для записи). Такой режим называется, соответственно, retain\_content.
Оба режима закрытия mchain-ов, drop\_content и retain\_content, хороши в разных ситуациях. В данном примере нам нужен drop\_content, поэтому-то и используется auto\_close\_drop\_content.
Результат работы первого примера
--------------------------------
Если мы запустим наш первый пример, то увидим вполне ожидаемую картину:
Мы тут видим последовательные «опросы» и «запись» результатов этих «опросов».
Усложнение простого примера: контролируем нагрузку на file\_writer\_thread
==========================================================================
> Полный исходный текст второго примера может быть найден [здесь](https://github.com/eao197/so5-lor-two-thread-demo-ru/blob/201805081500/dev/two_thread_demo_2/main.cpp).
Первая версия нашего примера получилась очень уж идеализированной: мы верим в то, что запись «снятых» с датчика данных всегда будет завершаться к следующему «опросу». Но в реальной жизни, скорее всего, время операций с внешними устройствами может «плавать» в довольно широких пределах. Это означает, что нам имело бы смысл позаботиться о ситуации, когда «запись» в файл займет больше времени и в mchain-е с сообщениями write\_data начнут скапливаться сообщения.
Для того, чтобы проимитировать подобную ситуацию слегка модифицируем уже показанные выше функции meter\_reader\_thread() и file\_writer\_thread(). В meter\_reader\_thread() всего лишь увеличим темп поступления сигнала acquisition\_turn:
```
auto timer = so_5::send_periodic(timer\_ch, 0ms, 300ms);
```
А вот в file\_writer\_thread() сделаем так, чтобы время операции «записи» выбиралось случайным образом из диапазона [295ms, 1s]. Т.е. иногда операция «записи» будет укладываться в интервалы между «опросами», но в большинстве случаев — не будет. Иногда не будет укладываться очень сильно. Итак, вот как мы модифицируем file\_writer\_thread():
```
// Нить, которая будет записывать файлы.
void file_writer_thread(
// Канал из которого будут читаться команды на запись.
so_5::mchain_t file_write_ch) {
// Вспомогательные инструменты для генерации случайных значений.
std::mt19937 rd_gen{std::random_device{}()};
// Значения для задержки рабочей нити будут браться из
// диапазона [295ms, 1s].
std::uniform_int_distribution rd\_dist{295, 1000};
// Читаем все из канала до тех пор, пока канал не закроют.
// В этом случае произойдет автоматический выход из receive.
receive(from(file\_write\_ch),
// Этот обработчик будет вызван когда в канал попадет
// сообщение типа write\_data.
[&](so\_5::mhood\_t cmd) {
// Выбираем случайную длительность операции "записи".
const auto pause = rd\_dist(rd\_gen);
// Имитируем запись в файл.
std::cout << cmd->file\_name\_ << ": write started (pause:"
<< pause << "ms)" << std::endl;
std::this\_thread::sleep\_for(std::chrono::milliseconds{pause});
std::cout << cmd->file\_name\_ << ": write finished" << std::endl;
});
}
```
Получается, что теперь в file\_write\_ch могут скапливаться необработанные сообщения write\_data. Возникает широко известная в узких кругах проблема перегрузки: это когда поставщик данных генерирует новые данные с большим темпом, нежели потребитель данных способен обработать. Проблема неприятная, с ней нужно бороться.
Например, можно реализовать механизм «back pressure». Т.е. когда поставщик данных начинает перегружать потребителя, то потребитель тем или иным способом дает поставщику об этом знать. В случае CSP-шных каналов вполне естественным способом реализации «back pressure» будет блокировка поставщика данных на операции записи в канал до тех пор, пока потребитель не освободится настолько, чтобы принять следующую порцию данных от поставщика.
> Кстати говоря, в этом плане Модель CSP в каких-то сценариях обработки данных сильно удобнее Модели Акторов. Ведь в Модели Акторов обмен данными между поставщиком и потребителем осуществляется только посредством асинхронных сообщений. Т.е. поставщик, отсылая очередное сообщение потребителю, не знает, насколько потребитель нагружен, приведет ли очередное сообщение к перегрузке и, если приведет, то сколько времени нужно подождать, прежде чем отсылать следующее сообщение. Тогда как в Модели CSP поставщика можно «усыпить» на операции записи в канал и «разбудить» поставщика после того как потребитель разобрался со своей нагрузкой.
Итак, мы бы хотели, чтобы поставщик, т.е. meter\_reader\_thread в нашем случае, засыпал, если file\_writer\_thread не успевает разбирать и обрабатывать ранее отосланные в file\_write\_ch сообщения. Могут ли SObjectizer-овские mchain-ы это нам обеспечить?
Да.
Для этого нужно задать дополнительные свойства mchain-а при создании mchain-а. В первой версии нашего примера мы создавали mchain самым простым способом, вот так:
```
auto writer_ch = so_5::create_mchain(sobj);
```
В этом случае создается «безразмерный» канал, в такой канал можно запихнуть столько сообщений, сколько позволяет размер свободной оперативной памяти.
Поскольку мы хотим «back pressure», то «безразмерный» канал нас не устраивает. Значит нам нужно ограничить количество сообщений, которые могут ждать в канале своей обработки.
Мы хотим так же, чтобы при попытке записи в заполненный канал поставщик информации «засыпал». С этим нет проблем, но в SObjectizer-е нужно задать верхнюю границу такого ожидания. Например, заснуть на попытке записи в канал, но спать не более пяти секунд (или пяти часов, это от задачи зависит).
SObjectizer требует от разработчика ограничить максимальное время ожидания на запись в заполненный канал потому, что без такого ограничения легко поймать дедлок. Скажем, нить T1 пытается записать сообщение в переполненный канал C1 для нити T2, которая в этот момент пытается записать сообщение в переполненный канал C2 для нити T3. А нить T3 в этот момент пытается записать сообщение в переполненный канал C0 для нити T1. В случае с ограничением на максимальное время ожидания такой дедлок будет со временем разорван автоматически.
Итак, мы задаем размер канала и максимальное время ожидания, но остается вопрос: «Что делать с операцией записи в переполненный канал, если место в канале не освободилось даже после ожидания?»
В SObjectizer можно выбрать, что делать, если место в канале не освободилось даже после ожидания. Например, можно выбросить самое старое сообщение, которое находится в канале. Или можно проигнорировать новое сообщение, которое мы попытались вставить в канал. Или можно сделать так, чтобы функция send() бросила в этом случае исключение.
В нашем примере мы используем такую реакцию, как выбрасывание самого старого сообщения. В данном случае это вполне логично, т.к. у нас уже есть «новые данные» с датчика, их запись актуальнее, чем сохранение старых данных. Поэтому в обновленном примере мы будем создавать канал для сообщений write\_data следующим образом:
```
// Канал для записи измерений будет ограничен по размеру, с паузой
// при попытке записать в полный mchain и с выбрасыванием самых старых
// команд, если канал даже после паузы не освободился.
auto writer_ch = so_5::create_mchain(sobj,
// Ждем освобождения места не более 300ms.
300ms,
// Ждать в mchain-е могут не более 2-х сообщений.
2,
// Память под mchain выделяем сразу.
so_5::mchain_props::memory_usage_t::preallocated,
// Если место в mchain-е не освободилось даже после ожидания,
// то выбрасываем самое старое сообщение из mchain-а.
so_5::mchain_props::overflow_reaction_t::remove_oldest);
```
Дополнительное пояснение можно дать разве что аргументу so\_5::mchain\_props::memory\_usage\_t::preallocated. Этот аргумент определяет, как будет выделяться память для организации очереди сообщений внутри самого канала. Т.к. канал у нас имеет фиксированный и небольшой размер, то место под очередь сообщений имеет смысл выделить сразу. Что мы и делаем в данном случае.
Ограничение для канала нити meter\_reader\_thread
-------------------------------------------------
Во втором примере мы ограничили размер канала для сообщений write\_data. Но ведь у нас так же есть канал для сигналов acquisition\_turn. Может имеет смысл его также ограничить?
Действительно, смысл есть. Нам вообще достаточно для acquisition\_turn иметь канал емкостью в одно сообщение. Если сигнал acquisition\_turn в канале уже есть, то новый добавлять туда нет смысла.
Поэтому мы модифицируем фрагмент кода, в котором мы создаем этот канал:
```
// Канал для периодических сигналов будет ограничен по размеру,
// без паузы при попытке записать в полный mchain и с выбрасыванием
// самых новых сообщений.
auto timer_ch = so_5::create_mchain(sobj,
// Отводим место всего под одно сообщение.
1,
// Память под mchain выделяем сразу.
so_5::mchain_props::memory_usage_t::preallocated,
// Если канал полон, то самое новое сообщение игнорируется.
so_5::mchain_props::overflow_reaction_t::drop_newest);
```
Мы здесь видим два важных отличия:
* во-первых, нет ожидания на попытке добавить сообщение в заполненный канал. Это ожидание лишено смысла. Кроме того, т.к. acquisition\_turn помещается в канал таймером SObjectizer-а. А этот таймер в принципе не может «засыпать» на попытке добавить сообщение в полный канал (иначе таймер не сможет нормально выполнять свою работу);
* во-вторых, в качестве реакции на переполнение мы предписываем игнорирование самого нового сообщения. Т.е. если таймер попробует добавить новый экземпляр сигнала acquisition\_turn в полный канал, то этот новый экземпляр будет проигнорирован, как будто его и не было вовсе.
Результат работы второго примера
--------------------------------
При запуске второго примера мы уже можем увидеть следующую картину:
Можно увидеть, что часть номеров из отладочной печати нити file\_writer\_thread исчезла. Например, после записи data\_24.dat следует запись data\_26.dat. А записи data\_25.dat нет. Это потому, что сообщение write\_data для data\_25.dat было выброшено из канала при его переполнении.
Кроме того, мы можем видеть, что когда нить file\_writer\_thread надолго «уходит» в запись, то за это время нить meter\_reader\_thread успевает провести несколько «опросов».
Усложняем пример еще раз: добавляем управление meter\_reader\_thread
====================================================================
> Полный исходный текст третьего примера может быть найден [здесь](https://github.com/eao197/so5-lor-two-thread-demo-ru/blob/201805081500/dev/two_thread_demo_3/main.cpp).
Нельзя отказать себе в соблазне усложнить пример еще раз: на этот раз добавить возможность управлять нитью meter\_reader\_thread. Действительно, почему бы не сделать возможность увеличивать или уменьшать период «опроса» датчика? Давайте это и сделаем.
Пусть главная нить сейчас в процессе диалога с пользователем понимает не только команду 'exit' (завершить работу приложения), но и команды 'inc' (удлинить период опроса в 1.5 раза) и 'dec' (сократить период опроса в 1.5 раза).
Главный вопрос, который нам в этом случае предстоит решить — это вопрос доставки команд inc и dec из главной нити приложения в нить meter\_reader\_thread. Но на самом деле — это не вопрос. Мы просто заведем два новых сигнала:
```
// Сигнал, который отсылается нити чтения данных с датчика для
// уменьшения периода опроса.
struct dec_read_period : public so_5::signal_t {};
// Сигнал, который отсылается нити чтения данных с датчика для
// увеличения периода опроса.
struct inc_read_period : public so_5::signal_t {};
```
Главная нить будет отсылать эти сигналы в соответствующий канал, когда пользователь вводит ту или иную команду:
```
// Программа продолжит работать пока пользователь не введет exit или
// пока не закроет стандартный поток ввода.
bool stop_execution = false;
while(!stop_execution) {
std::cout << "Type 'exit' to quit, 'inc' or 'dec':" << std::endl;
std::string cmd;
if(std::getline(std::cin, cmd)) {
if("exit" == cmd)
stop_execution = true;
else if("inc" == cmd)
so_5::send(control\_ch);
else if("dec" == cmd)
so\_5::send(control\_ch);
}
else
stop\_execution = true;
}
```
Но в какой именно канал мы будем отсылать эти сигналы? Вот этот вопрос гораздо интереснее.
В принципе, мы могли бы использовать один и тот же канал и для периодических acquisition\_turn, и для inc\_/dec\_read\_period. Но для того, чтобы показать, что еще умеет SObjectizer при работе с mchain-ами, мы будем использовать два разных канала для meter\_reader\_thread:
* первый канал, под условным названием control\_ch, будет использоваться для команд inc\_/dec\_read\_period. Это будет самый простой mchain без каких-либо ограничений;
* второй канал, под условным названием timer\_ch, будет использоваться для сигналов acquisition\_turn. Это уже будет канал с фиксированным размером и политикой игнорирования новых сообщений при переполнении.
Для простоты реализации третьего примера оба эти канала будут создаваться и закрываться в функции main(), а в функцию meter\_reader\_thread() они будет передаваться как параметры:
```
// Создаем каналы, которые потребуются нашим рабочим нитям.
// Управляющий канал для meter_reader_thread. Без каких-либо ограничений.
auto control_ch = so_5::create_mchain(sobj);
// Канал, который будет использоваться для отсылки acquisition_turn.
auto timer_ch = so_5::create_mchain(control_ch->environment(),
// Отводим место всего под одно сообщение.
1,
// Память под mchain выделяем сразу.
so_5::mchain_props::memory_usage_t::preallocated,
// Если канал полон, то самое новое сообщение игнорируется.
so_5::mchain_props::overflow_reaction_t::drop_newest);
...
// Каналы должны быть автоматически закрыты при выходе из main.
// Если этого не сделать, то рабочие нити продолжат висеть внутри
// receive() и join() для них не завершится.
auto closer = so_5::auto_close_drop_content(control_ch, timer_ch, writer_ch);
// Теперь можно стартовать наши рабочие нити.
meter_reader = std::thread(meter_reader_thread, control_ch, timer_ch, writer_ch);
...
```
Модифицированная версия функции meter\_reader\_thread()
-------------------------------------------------------
[Функция meter\_reader\_thread()](https://github.com/eao197/so5-lor-two-thread-demo-ru/blob/201805081500/dev/two_thread_demo_3/main.cpp#L28) существенно вырастет в размере, поскольку теперь она должна выполнять больше действий. И хотя мне самому не очень нравятся функции, текст которых не умещаются на один экран, в данном случае пришлось пойти на написание такой объемной функции, дабы не размазывать фрагменты бизнес-логики по вспомогательным функциям.
По сравнению с первым и вторым примерами, в третьем примере в meter\_reader\_thread произошло два принципиально важных изменения.
Во-первых, теперь период «опроса» датчика может изменяться. Из-за этого нам невыгодно запускать acquisition\_turn в качестве периодического сообщения. Придется каждый раз перезапускать его при изменении периода. Поэтому сейчас мы пойдем другим путем: при обработке очередного acquisition\_turn будем засекать время, потраченное на очередной «опрос» и отсылку write\_data. После чего либо сразу будем отсылать себе acquisition\_turn без задержки, если потратили на «опрос» слишком много времени. Либо же будем отсылать отложенное acquisition\_turn, при этом задержка в доставке будет дельтой между текущим периодом опроса и реально затраченным временем.
У нас получится следующий фрагмент по обработке acqusition\_turn:
```
// Этот обработчик будет вызван когда в канал попадет
// сигнал типа acquire_turn.
[&](so_5::mhood_t) {
// Нам потребуется узнать, сколько времени мы потратили на
// всю операцию. Поэтому делаем засечку.
const auto started\_at = std::chrono::steady\_clock::now();
// Имитируем опрос датчика.
std::cout << "meter read started" << std::endl;
std::this\_thread::sleep\_for(50ms);
std::cout << "meter read finished" << std::endl;
// Отдаем команду на запись нового файла.
so\_5::send(file\_write\_ch,
"data\_" + std::to\_string(ordinal) + ".dat");
++ordinal;
// Теперь можем вычислить сколько же всего времени было
// потрачено.
const auto duration = std::chrono::steady\_clock::now() - started\_at;
// Если потратили слишком много, то инициируем следующий
// опрос сразу же.
if(duration >= current\_period) {
std::cout << "period=" << current\_period.count()
<< "ms, no sleep" << std::endl;
so\_5::send(timer\_ch);
}
else {
// В противном случае можем позволить себе немного "поспать".
const auto sleep\_time = to\_ms(current\_period - duration);
std::cout << "period=" << current\_period.count() << "ms, sleep="
<< sleep\_time.count() << "ms" << std::endl;
so\_5::send\_delayed(timer\_ch,
current\_period - duration);
}
}
```
Во-вторых, нам теперь придется ждать сообщения не из одного канала, а из двух сразу. В какой канал сообщение первым пришло, из такого мы должны взять сообщение и обработать взятое сообщение.
Для этого мы будем использовать функцию so\_5::select(), которая похожа на ранее показанную so\_5::receive(). Но, в отличии от receive(), функция select() может ждать входящие сообщения из нескольких каналов.
В итоге, в meter\_reader\_thread мы делаем вот такой вызов select() (схематично, опуская детали реализаций обработчиков):
```
// Читаем все из каналов до тех пор, пока каналы не закроют.
so_5::select(so_5::from_all(),
// Обработчик для сигналов от таймера.
case_(timer_ch,
// Этот обработчик будет вызван когда в канал попадет
// сигнал типа acquire_turn.
[&](so_5::mhood_t) {
... // Код обработчика.
}),
// Обработчик сигналов из управляющего канала.
case\_(control\_ch,
// Обрабатываем увеличение интервала опроса.
[&](so\_5::mhood\_t) {
... // Код обработчика.
},
// Обрабатываем уменьшение интервала опроса.
[&](so\_5::mhood\_t) {
... // Код обработчика.
})
);
```
Т.е. мы говорим, что select() должен ждать сообщения из всех ниже перечисленных каналов до тех пор, пока все каналы не будут закрыты. Затем, в секциях case\_ идет перечисление каналов (по одному каналу на секцию) и список обработчиков для сообщений из каждого канала.
Так, из канала timer\_ch мы обрабатываем только сигнал acquisition\_time, а из канала control\_ch — сигналы inc\_read\_period и dec\_read\_period.
Получается, что в третьем примере функция meter\_read\_thread() возвращает управление только после того, как управление возвращает select(). А select() завершает свою работу когда и timer\_ch, и control\_ch будут закрыты. Что происходит в main()-е при завершении работы приложения.
Результат работы третьего примера
---------------------------------
При запуске третьего примера и выдачи нескольких команд inc мы можем увидеть следующую картину:
Заключение
==========
Мы развиваем SObjectizer как инструмент для упрощения разработки многопоточных приложений, а не как реализацию какого-то одного подхода к проблеме concurrent computing. Поэтому в SObjectizer можно найти следы и Модели Акторов, и Publish/Subscribe, и CSP. Ранее мы больше рассказывали именно про ту часть SObjectizer-а, которая относится к моделям Акторов и Pub/Sub. Сегодня же мы попытались коротко познакомить читателя и с CSP-шными каналами. Это уже вторая попытка, [первая была в прошлом году](https://habr.com/post/336854/).
Если в нашем рассказе что-то осталось непонятным, то мы с удовольствием ответим на вопросы в комментариях. Если кто-то хочет, чтобы мы проиллюстрировали что-то из рассказанного картинкой/схемой, то скажите что именно — мы постараемся сделать соответствующую иллюстрацию и добавить ее в текст.
Вполне возможно, что показанный пример кому-то покажется неинтересным и оторванным от жизни. Все-таки нашей целью была его понятность. Но, если кто-то из читателей сможет предложить другой, более жизненный пример для того, чтобы проиллюстрировать его решение с помощью CSP-шных каналов, то мы попробуем сделать решение предложенного читателями примера и описать это решение в последующих статьях.
Ну а в завершение статьи предлагаем всем желающим попробовать [SObjectizer](https://github.com/eao197/so-5-5) в деле и поделиться своими впечатлениями. Обратная связь для нас очень важна и именно ваши пожелания/замечания позволяют нам развивать SObjectizer и делать его мощнее и удобнее. | https://habr.com/ru/post/358120/ | null | ru | null |
# Understanding node.js
[Node.js](http://nodejs.org/) обычно вызывал у людей, которым я о нём рассказывал, две различные реакции. В основном они воспринимали его «как есть», однако многие были сбиты с толку.
Если вы относитесь ко второй группе, я попробую объяснить, что же такое Node.js:
* Это инструмент командной строки. Вы скачиваете архив, компилируете и устанавливаете его.
* Это позволит вам выполнять программы на JavaScript, набрав 'node my\_app.js' в терминале.
* JavaScript выполняется [движком V8](http://code.google.com/p/v8/) (тем самым, благодаря которому так быстро работает Google Chrome).
* Node.js предоставляет API для доступа к сети и файловой системе из JavaScript.
***«Но я могу сделать то, что мне необходимо, с помощью Python, Ruby, Java, PHP,… !».***
Да, это я уже слышал. И вы правы! Node не волшебный единорог, который придёт и сделает всё за вас. Это просто инструмент, и он, вероятно, не сможет заменить все остальные, по крайней мере не сейчас.
***«Ближе к делу!»***
Хорошо. Node хорошо применим тогда, когда нужно сделать несколько вещей одновременно. Вы когда-нибудь, написав очередной кусок кода, говорили: «Я хотел бы, чтобы это работало параллельно»? Так вот в Node всё выполняется параллельно, за исключением вашего кода.
***«Что?»***
Всё верно, *всё выполняется параллельно, за исключением вашего кода*. Чтобы понять это, представьте себе, что ваш код царь, а Node — его слуга.
Каждый день начинается с того, что **один** слуга будит короля и спрашивает, нужно ли ему что-нибудь. Царь дает слуге список задач и идет спать дальше. Слуга распределяет эти задачи среди всех слуг, и они идут работать.
Как только слуга завершает какую-то задачу, он приходит к царю и докладывает. Царь одновременно принимает у себя только одного слугу. Иногда после доклада царь даёт слуге другие задания.
Слуги выполняют задания одновременно, только докладывают о результатах по одному, так чтобы царь мог сосредоточиться. \*
***«Это замечательно, но не могли бы вы не говорить метафорами?»***
Конечно. Простая программа для Node выглядит следующим образом:
```
var fs = require('fs')
, sys = require('sys');
fs.readFile('treasure-chamber-report.txt', function(report) {
sys.puts("oh, look at all my money: "+report);
});
fs.writeFile('letter-to-princess.txt', '...', function() {
sys.puts("can't wait to hear back from her!");
});
```
Этот код даёт Node 2 задачи для чтения и записи файлов, а затем перейдет в режим сна. Когда Node завершит выполнение задачи, будет вызвана функция обратного вызова. Но одновременно может выполняться только одна такая функция, так что до окончания её выполнения остальные будут ждать своей очереди. Кроме того, нет никакой гарантии, в каком порядке будут выполнены функции обратного вызова для этих задач.
***«Значит не придется беспокоиться об одновременном доступе к данным из разных функций?»***
Вы это поняли! Да, это замечательное следствие дизайна однопоточного цикла событий в JavaScripts!
***«Очень хорошо, но почему я должен это использовать?»***
Одной из причин является эффективность. В веб-приложении ваше время отклика, как правило, в основном складывается из времени, необходимого для выполнения всех ваших запросов к базе данных. Используя Node вы можете выполнить все ваши запросы сразу, сокращая времени отклика до продолжительности самого медленного запроса.
Другая причина кроется в использовании JavaScript. Используя Node вы можете переиспользовать часть кода на стороне и сервера, и клиента. JavaScript развивается в сторону того, чтобы стать действительно универсальным языком. Неважно, если вы раньше использовали Python, Ruby, Java, PHP,…, но вы наверняка использовали при этом и JavaScript, не так ли?
И последняя причина в скорости. V8 постоянно расширяет границы нашего представления о скорости выполнения динамических языков. Я не могу вспомнить какой-либо другой язык, который бы становился быстрее настолько агрессивно, как это делает в настоящее время JavaScript. Кроме того, операции ввода/вывода в Node действительно хорошо оптимизированы и позволяют задействовать потенциал системы настолько, насколько это возможно.
***«Так вы говорите, я теперь должен писать свои приложения на Node?»***
И да, и нет. Как только вы научитесь пользоваться Node также хорошо, как молотком, все задачи начнут казаться гвоздями. Но если вы работаете над чем-то с конкретными сроками, вы можете выбрать (или не выбрать) Node, ответив на следующие вопросы:
* Важно ли малое время отклика? Node позволит вам достичь этого.
* Насколько велик проект? В небольшие проекты node великолепно впишется. В случае большого проекта требуется тщательная оценка (есть ли необходимые библиотеки, человеческие ресурсы для исправления ошибок и т.д.).
***«Работает ли Node на Windows?»***
Нет. Если вы используете Windows, вам нужна виртуальная машина (я рекомендую [VirtualBox](http://www.virtualbox.org/)) с Linux. Поддержка Windows планируется, но не стоит задерживать дыхание в течение следующих нескольких месяцев в ожидании, лучше помогите с портированием (**прим. пер.:** на данный момент Node должен работать в Windows+Cygwin).
***«Могу ли я получить доступ к DOM в Node?»***
Отличный вопрос! Нет, DOM определён в браузере отдельно от движка JavaScript (V8). Тем не менее, есть люди, работает над реализацией [DOM в качестве модуля Node](http://www.yuiblog.com/blog/2010/04/09/node-js-yui-3-dom-manipulation-oh-my/), что может открыть очень интересные возможности, такие как тестирование клиентского кода с помощью Node.
***«Действительно ли программировать на языках с событиями тяжело?»***
Это зависит от вас. Если вы уже научились жонглировать AJAX вызовами и пользовательскими событиями в браузере, не должно быть проблемой и привыкнуть к Node.
В любом случае, TDD может сильно помочь вам создавать легко обслуживаемые приложения.
***«Кто уже использует Node?»***
Неполный список есть в [вики](http://wiki.github.com/ry/node) (пролистайте до «Companies using Node»). [Yahoo](http://www.yuiblog.com/blog/2010/04/09/node-js-yui-3-dom-manipulation-oh-my/) экспериментирует с Node и YUI, [Plurk](http://www.plurk.com/) использует его для крупномасштабного Comet-сервера, а Paul Bakaus (из команды JQuery UI) пишет [умопомрачительных игровой движок](http://ajaxian.com/archives/aves-game-engine), который использует Node на бекэнде. [Joyent](http://www.joyent.com/) нанял автора Node и в значительной степени спонсирует её развитие.
Ах да, только что Heroku объявила (экспериментальную) [поддержку хостинга Node приложений](http://blog.heroku.com/archives/2010/4/28/node_js_support_experimental/).
***«Где я могу узнать больше?»***
Tim Caswell открыл замечательны блог [How To Node](http://howtonode.org/). Следите за [#nodejs](http://search.twitter.com/search?q=%23nodejs) в Твиттере. Подпишитесь на [рассылку](http://groups.google.com/group/nodejs). И приходите в IRC, *#node.js* (да, в имени точка).
Я также буду писать о Node в блоге [debuggable.com](http://debuggable.com/).
Это всё на сегодня. Не стесняйтесь комментировать, если у вас есть вопросы!
— Felix Geisendörfer
\*: Я, очевидно, утрирую, но найти аналог для понятия неблокирующего выполнения кода в реальности довольно трудно. | https://habr.com/ru/post/104171/ | null | ru | null |
# Загрузка картинок в фоне. Модуль на JavaScript
Некоторое время назад я начал писать большой проект с высокой нагрузкой, в котором широко использовались возможности JavaScript. За это время пришлось переосмыслить многие вещи и столкнуться с необычными проблемами и различными уловками для их решения. Об одной из таких уловок и пойдет речь далее.
##### Проблема:
Сайт состоит из одной страницы, на которой с помощью ajax запросов и большого количества скриптов генерируется вся информация. И с ростом функционала возросло количество верстки и картинок, которые шли изначально на загружаемой странице. Если добавить к этому функцию предугадывания действий пользователя и фоновой подгрузке контента – ситуация с первоначальным рендерингом страницы и временем отклика интерфейса становиться совсем печальной.
##### Решение:
Одним из мероприятий для решения проблемы стало написание модуля, который бы не только загружал картинки по мере необходимости, но и ставил бы заглушки в случае, если по какой-то причине загрузка не удастся.
##### Когда нужен скрипт:
* У вас сложный сайт
* Подгружаете информацию ajax`ом
* Много верстки, которая может быть не показана пользователю
Используя скрипт отложенной загрузки картинок, вы можете догружать контент по мере необходимости, тем самым уменьшая нагрузку на сервер и ускоряя работу сайта для пользователя.
##### Как это работает:
* У вас есть некая скрытая страница с картинками.
* Вместо них грузиться изображение в 1px.
* Скрипт пробегает по всем картинкам, разделяя их на группы.
* Если у вас есть свободное время без нагрузки — вы можете скриптом подгрузить картинки определенной группы (если предполагаете, что скоро они могут понадобиться пользователю).
* Если пользователь запросил вашу скрытую страницу — вы показываете картинки.
* Если вы указали неправильный адрес картинки — она просто оставит вашу заглушку в 1px и не будет менять изображение.
Скачать: [демо](http://rghost.ru/41226960), [сам модуль](http://rghost.ru/41225910)
##### Преимущества:
Модуль написан на нативном JavaScript.
Для его работы не нужны никакие библиотеки.
Сжат с помощью Google Compressor до 1.5 кб.
Поддерживает паттерн цепочек. То есть методы можно вызывать так:
lazyLoadingImages.show(«1»).load(«2»).load(«3»);
При желание можно пробросить в модуль ссылку на ваш объект или переменную и уйти от создания ещё одной глобальной переменной.
##### Использование:
В заголовок страницы вставьте:
```
```
Картинки в документе описывать таким образом:
```
```
###### Где:
src="./images/empty.png" — адрес картинки заглушки размером в 1px
url="./images/1200.jpg" — адрес оригинальной большой картинки
type=«group1»- ID группы, необязательный параметр
##### Интерфейс
По событию DOMContentLoaded (окончание загрузки DOM) глобальному объекту, проброшенному в модуль присваивается метод lazyLoadingImages (по умолчанию это window.lazyLoadingImages).
**lazyLoadingImages.update()** — обновит список картинок и запомнит их url для загрузки оригинальных изображений. Этот метод вызывается автоматически, при инициализации модуля. Может быть полезен, если DOM страницы изменился.
**lazyLoadingImages.load(type)** — загрузит картинки определенной группы (параметр type указывает какой именно). Параметр type — необязательный. По умолчанию загружает картинки, которым ID группы не задан.
**lazyLoadingImages.show(type)** — показать картинки определенной группы (параметр type указывает какой именно). Параметр type — необязательный. По умолчанию показывает картинки, которым ID группы не задан.
**UPD:**
В связи с тем, что rghost недоступен [ссылка на GitHub](https://github.com/bakhirev/lazyLoadingImages)
MechanisM спасибо за замечание, параметры переименовал. Теперь data-url и data-type.
##### О картинке заглушке
Когда вставляем картинки в документ (Например, выводим длинный список игроков через innerHTML) можно добавить небольшой трюк:
* Все картинки вставляем с свойством visibility = hidden (а лучше display: none)
* Навешиваем событие onload на все картинки
* Если onload произошёл — убираем visibility, если нет — оставляем как есть
Получается, что если картинки на сервере нет — у нас просто белый квадрат на её месте. Ещё рекомендую в стилях всем картинкам задать размер, чтобы если останется просто белый квадрат, он занял необходимую площадь. Если необходимо, в той же функции можно вставлять или убирать alt и title картинок в моменты до загрузки и после.
CSS
```
.visibility {
visibility: hidden;
}
```
JavaScript
```
utils.showAfterLoading: function(node) {
utils.removeClass(node, "visibility");
}
```
HTML
```
```
**UPD2:**
Добавил два метода согласно замечаниям DjOnline:
**lazyLoadingImages.onScroll(type)** — показать картинки определенной группы (необязательный параметр type указывает какой именно) при прокрутке страницы (а именно начать подгрузку изображения, когда до него останется «пол экрана»). По умолчанию показывает картинки, которым ID группы не задан.
**lazyLoadingImages.offScroll(type)** — отменяет показ картинки определенной группы (необязательный параметр type указывает какой именно) при прокрутке страницы (см. метод выше). По умолчанию сбрасывает onScroll картинкам, которым ID группы не задан.
Так что теперь модуль может догружать картинки при прокрутке. Вес: 2.7 kb
Демо: [тут](http://encom-spb.ru/habr/lli/demo.html) или [тут](http://htmlpreview.github.com/?https://github.com/bakhirev/lazyLoadingImages/blob/master/demo.html) | https://habr.com/ru/post/156589/ | null | ru | null |
# GSM Modem M95 от QUECTEL — опыт освоения
#### GSM Modem M95 от QUECTEL — опыт освоения
##### В начале
В первых строках своего поста хочу честно признаться что ранее опыта работы с GSM-модемами у меня не было, однако волею судьбы и служебной необходимостью набрел на сайт питерской конторы [«Сатрон»](http://satron.ru/) — официального представителя QUECTEL. На сей ресурс забрел в поисках очередной железки — подходящего мне по параметрам GSM-модема и бютжетного GPS-приемника. Так получилось что информацию о продукции в виде даташитов и прочих полезных файлов можно было получить только после регистрации. Так и сделал.
Получив подтверждение через сутки (почти расстроился так долго ждать), первым делом закачал документацию на заинтересовавший меня модуль. На следующий день мне поступил звонок с неизвестного номера, приятный женский голос сообщил что звонит менеджер фирмы «Сатрон» по поводу моей заинтересованности в их продукции. Девушка на том конце телефонного контакта поинтересовалась какой у меня статус — частное лицо, либо юридическое. На этот вопрос ответил вопросом — с какой целью интересуетесь? И случилось то, чего я в принципе не ожидал, девушка объяснила что если я представляю юридическое лицо, то выбранную мною продукцию мне вышлют для испытаний при условии что будет оплачена пересылка. Естественно я согласился, хотя девушка-менеджер сама мне порекомендовала продукцию в ответ на запрошенные параметры. В пожеланиях было получить самый примитивный но предельно дешёвый GSM-модем, с возможностью слать SMS-ки и голосовой связью. В ответ мне были порекомендованы список продукции, а на запрос по модему предложен довольно свежий продукт M95 по цене «примитива». Естественно цен на продукцию я приводить не буду, это наши с «Сатрон» отношения, но замечу что модемы и другие модули были высланы в кратчайший срок и в нескольких экземплярах.
Сразу мне показалось что такой подход несколько странный, с чего это такая щедрость. Однако далее мне стало многое понятно, и дружелюбный подход фирмы, и качественная круглосуточная поддержка, и невероятное качество работы девушки-менеджера.
##### Дело в том что:
Так не бывает! Весь мой опыт контактов с Российскими поставщиками компонентов вопил — это подстава и очередное «впаривание» гнилого «отстоя». Однако при беглом знакомстве с документацией на модем M95 у меня зародилось странное сомнение, уж очень прорывные характеристики у наглого представителя китайского электронпрома по сравнению с именитыми монстрами, а цена… Это уже совсем отдельная история, боюсь обвинят в рекламе.
Так вот, поскольку опыта работы с модемами у меня было ровным счетом полное зеро, а испытать и проверить соответствие заявленным характеристикам было нужно, пришлось состряпать в Altium-е схему с импульсником на 4.4 вольта а сам модем обвесить необходимой периферией включая разъемы для наушников и микрофона, кнопками ON/OFF и Emergence OFF. Антенну применил AMMAP 003. Вся конструкция согласовалась по FT232LR с USB портом персоналки, причем питание портов FT232LR взято с выхода самого модема (2.8В), так что согласовывать по уровням не пришлось.
Первый старт — порт обнаружен, настраиваю порт в программе CommTrack (пока сырая, писалась сугубо под задачу) и естественно ввожу в окне консоли «AT» и жму . Замечательно! Модем ответил эхом:
AT
OK
Далее начались непонятности. Вначале как это водится решил устроить «звонок другу» (то есть себе). Однако модем устойчиво откликался «NO CARRIER». Сказалась невнимательность при изучении доки — оказывается есть разница при вызове для голосового соединения и для цифрового подключения. К номеру нужно было подцепить ";". К моему стыду я задал вопрос контактному лицу и получил ответ от инженера в весьма краткой и доходчивой форме.
Так, звоню себе на мобильник-вижу вызов. Подтверждаю вызов и пытаюсь поговорить с самим собой — тишина. Оказывается нужно настроить канал аналоговых входов и выходов. Посылаю команду модему «AT+QAUDCH=2».
Следующая попытка дозвониться оказалась удачной, и мне удалось услышать себя же по телефону и в гарнитуре. Удивило невероятно высокое качество звука и четкость речи, отсутствие каких либо эхо и других спецэффектов дешевой связи. Громкость и чувствительность микрофона регулировались в широком диапазоне, однако заводские настройки оказались наиболее удачными.
Немного поигравшись с голосовой связью SMS-ками и освоив необходимый набор команд из арсенала терминальных и GSM, приступил к установке GPRS соединения.
##### IP-стек и простота в использовании
Естественно установить соединение с удаленным сервером мне помог человек, уже имевший опыт с настройкой профиля соединения, и локальная задача тестирования модема на время отклика и скорости обмена данными заданной размерности была выполнена «по шаблону». Для тех кто еще не сталкивался с M95 приведу фрагмент кода программы на VB.NET.
**Фрагмент кода**
```
Private Sub RunScript()
Dim sRet, sTemp As String
Dim timeStart As Date
Dim timeStop As Date
Dim nTime As Double = 0
Dim nCount As Integer
Dim tSpan As TimeSpan
Dim serialStatus As Boolean = SerialPortA.IsOpen
Dim seansOpen As Boolean = False
Dim sBlock440 As String = "operations$öûâðëéîð÷ñéðöâéîðó2837âí2àãïëöãéïàöëäî3ïðàëîöíóïàùã34ïàùãà4óíïùöãíï4àêãùíöïùøãí4ïàùãöóåïàêãöù4ïàùãø4íïàùöã4íïàêùö6å4ê6åïöøãíàïö4ùïåàöùàïöùãà4ïöùã47ïåàêùöïù4ãïàøöãàï4ùãï4àùãöïàùöãï4àøùã6ï4àùãö4ïåàøãöï64àøã46ïà6öïàø76ö4ïàäöãàïíöãøíïuiowq3ygrowg3fowrtgowufygbow4gfowueyfgco6wt4go68gfrwkuyfcgwkgy4ckuw4ygfouwygou4fgrfouwf4gow4grfw4yofgowu4ygfou4fgwo4uygfwy4gfow4g4gfowufgou4rgyfwuyfguwygf4uyg4f6gfiu4gklejhdkwehfewhrkferhiuht43iuhiur"
' Блок переменных для фиксации временных рараметров и отказов
Dim nDisconnect As Integer = 0
Dim nMinTimeA, nMinTimeB, nMaxTimeA, nMaxTimeB, nEvgTimeA, nEvgTimeB As Integer
Dim nSendAttemptA, nSendAttemptB, nLostPackA, nLostPackB As Integer
Dim nSendSuccA, nSendSuccB As Integer
Dim nLostConnect As Integer = 0
Dim timeSummary As Double = 0
Dim timeSummaryMin As Double = 0
Dim timeSummaryMax As Double = 0
Dim timeSummaryEvg As Double = 0
_allowRun = True
_allowEcho = True
_ReadBuff = ""
_lastClear = False
_lastLine = ""
nMinTimeA = 0
nMinTimeB = 0
nMaxTimeA = 0
nMaxTimeB = 0
nEvgTimeA = 0
nEvgTimeB = 0
nSendAttemptA = 0
nSendAttemptB = 0
nLostPackA = 0
nLostPackB = 0
nSendSuccA = 0
nSendSuccB = 0
'Настройка пула сообщений
MessPull.ClearMessage()
MessPull.AllowCMEErrorIntercept = True
MessPull.AllowFuncIntercept = True
MessPull.AllowSMSErrorIntercept = True
MessPull.DropCME_Error()
MessPull.DropSMS_Error()
' Начало операций
Dim record As New StreamWriter(Application.StartupPath & "\Default.log")
Me.WriteToConsole("Script started at " + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
record.WriteLine("Script started at " + DateTime.Now.ToLongTimeString + "!")
If Not SerialPortA.IsOpen Then
Try
SerialPortA.Open()
Catch
Me.WriteToConsole("Serial Port: " + SerialPortA.PortName + " is busy! Script stopped at: " + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
record.WriteLine("Serial Port: " + SerialPortA.PortName + " is busy! Script stopped at: " + DateTime.Now.ToLongTimeString + "!")
_allowRun = False
End Try
End If
' Инициаллизация модема
If _allowRun Then
nCount = 0
sTemp = ""
MessPull.ClearMessage()
While ((InStr(sTemp, "OK") = 0) And _allowRun)
nCount += 1
sTemp = MessPull.ExecuteAT(SerialPortA, "AT" + vbCrLf, 3000)
Me.WriteToConsole("Attempt: " + Str(nCount) + " Send: " + sTemp)
End While
Me.DisplayFunc()
' Включаем модем
Me.WriteToConsole("Turn on the modem!" + vbCrLf)
If Not MessPull.CheckAndSetup(SerialPortA, "AT+CFUN?", "CFUN", "1", , , , , "AT+CFUN=1", "Call Ready", 15000) Then
Me.WriteToConsole("Modem does not turn on! Script Aborted!" + vbCrLf)
_allowRun = False
Else
' Малозначимые настраиваем параметры
Me.WriteToConsole(MessPull.ExecuteAT(SerialPortA, "ATE1", 3000))
MessPull.CheckAndSetup(SerialPortA, "AT+CREG?", "CREG", "1", 0, ",", "OK", 1000, "AT+CREG=1", "OK", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+CGREG?", "CGREG", "1", 0, ",", "OK", 1000, "AT+CGREG=1", "OK", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+CRC?", "CRC", "0", 0, ",", "OK", 1000, "AT+CRC=0", "OK", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+QAUDCH?", "QAUDCH", "2", 0, ",", "OK", 1000, "AT+QAUDCH=2", "OK", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+QIFGCNT?", "QIFGCNT", "1", 0, ",", "OK", 1000, "AT+QIFGCNT=1", "OK", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+QICSGP?", "QICSGP", "1", 0, ",", "OK", 1000, "AT+QICSGP=" + _QICSGP, "OK", 5000)
End If
Me.DisplayFunc()
End If
While _allowRun
While _allowRun
If (MessPull.CheckAndSetup(SerialPortA, "AT+CREG?", "CREG", "1", 1) And
MessPull.CheckAndSetup(SerialPortA, "AT+CGREG?", "CGREG", "1", 1)) Then
Exit While
End If
Me.DisplayFunc()
End While
Me.DisplayFunc()
Me.WriteToConsole("Modem is registered on the home network at: " + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
record.WriteLine("Modem is registered on the home network at: " + DateTime.Now.ToLongTimeString + "!")
' Цикл установления соединения
While (_allowRun And (Not seansOpen = True))
Me.DisplayFunc()
Me.WriteToConsole(MessPull.ExecuteAT(SerialPortA, "AT+QISTAT", 2000) + vbCrLf)
'MessPull.WaitAnswer(SerialPortA, 5000, "", False)
'record.WriteLine("Request status at: " + DateTime.Now.TimeOfDay.ToString + "!")
sRet = MessPull.GetFuncValue("STATE")
Select Case sRet
Case "IP INITIAL"
MessPull.CheckAndSetup(SerialPortA, "AT+QISDE?", "QISDE", "0", 0, ",", "OK", 1000, "AT+QISDE = 0", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+QIMUX?", "QIMUX", "0", 0, ",", "OK", 1000, "AT+QIMUX = 0", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+QIMODE?", "QIMODE", "0", 0, ",", "OK", 1000, "AT+QIMODE=0", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+QIDNSIP?", "QIDNSIP", "0", 0, ",", "OK", 1000, "AT+QIDNSIP=0", 5000)
If Not InStr(MessPull.ExecuteAT(SerialPortA, "AT+QIREGAPP", 1000, "OK|ERROR"), "OK") > 0 Then
Me.WriteToConsole("Can not register application on network! Next Attempt!" + vbCrLf)
record.WriteLine("Can't Activate GPRS/CSD context! Next Attempt!")
End If
Case "IP START"
If Not InStr(MessPull.ExecuteAT(SerialPortA, "AT+QIACT", 1000, "OK|ERROR"), "OK") > 0 Then
Me.WriteToConsole("Can't Activate GPRS/CSD context! Next Attempt!" + vbCrLf)
record.WriteLine("Can't Activate GPRS/CSD context! Next Attempt!")
End If
Case "IP GPRSACT"
If Not InStr(MessPull.ExecuteAT(SerialPortA, "AT+QILOCIP", 2000, "."), ".") > 0 Then
Me.WriteToConsole("Can't Get local IP addres!" + vbCrLf)
record.WriteLine("Can't Get local IP addres!")
End If
Case "IP STATUS"
If Not InStr(MessPull.ExecuteAT(SerialPortA, "AT+QIOPEN=" + _QIOPEN, 5000, "OK"), "OK") > 0 Then
seansOpen = True
Else
Me.WriteToConsole("Can not estabilish connect!" + vbCrLf)
record.WriteLine("Can not estabilish connect!")
seansOpen = False
End If
Case "IP CLOSE"
MessPull.ExecuteAT(SerialPortA, "AT+QIDEACT", 5000, "DEACT OK")
Me.WriteToConsole("Deactivate GPRS/CSD context!" + vbCrLf)
record.WriteLine("Deactivate GPRS/CSD context!")
seansOpen = False
Case "CONNECT OK"
seansOpen = True
Me.WriteToConsole("Connection OK!" + vbCrLf)
record.WriteLine("Connection OK!")
Case "PDP DEACT"
Me.WriteToConsole("GPRS/CSD context was deactivated because of unknown reason. Reconnecting!" + vbCrLf)
record.WriteLine("GPRS/CSD context was deactivated because of unknown reason. Reconnecting!")
If Not InStr(MessPull.ExecuteAT(SerialPortA, "AT+QIACT", 1000, "OK|ERROR"), "OK") > 0 Then
Me.WriteToConsole("Can't Activate GPRS/CSD context! Next Attempt!" + vbCrLf)
record.WriteLine("Can't Activate GPRS/CSD context! Next Attempt!")
End If
Case "TCP CONNECTING"
Sleep(800)
Case Else
Me.WriteToConsole("Connection status: " + sRet + vbCrLf)
record.WriteLine("Connection status: " + sRet)
End Select
Me.WriteToConsole("Connection status: " + sRet + vbCrLf)
Me.DisplayFunc()
End While
While (seansOpen And _allowRun)
MessPull.ClearMessage()
MessPull.ExecuteAT(SerialPortA, "AT+QISTAT")
timeSummary = 0
nSendAttemptA += 1
timeStart = Now
sRet = Trim(MessPull.ExecuteAT(SerialPortA, "AT+QISEND=8", 3000, ">", False))
'Me.WriteToConsole("Time execution AT+QISEND=8" + MessPull.LastTimeRun.ToString + vbCrLf)
If InStr(sRet, ">") > 0 Then
sRet = MessPull.ExecuteAT(SerialPortA, "balance$", 3000, "SEND OK", False)
'Me.WriteToConsole("Time execution [balance$]" + MessPull.LastTimeRun.ToString + vbCrLf)
If InStr(sRet, "SEND OK") > 0 Then
_nCharWait = 40
sRet = MessPull.WaitAnswer(SerialPortA, 10000, "balance>................................", , False)
If sRet = "balance>................................" Then
Me.WriteToConsole(vbCrLf)
timeStop = Now
tSpan = timeStop.Subtract(timeStart)
nTime = tSpan.TotalMilliseconds
timeSummary = tSpan.TotalMilliseconds
nMinTimeA = IIf(nMinTimeA = 0, nTime, IIf(nMinTimeA > nTime, nTime, nMinTimeA))
nMaxTimeA = IIf(nMaxTimeA = 0, nTime, IIf(nMaxTimeA < nTime, nTime, nMaxTimeA))
nEvgTimeA = IIf(nEvgTimeA = 0, nTime, (nTime + nEvgTimeA) / 2)
nSendSuccA += 1
' Теперь пытаемся выслать пакет
nSendAttemptB += 1
timeStart = Now
sRet = Trim(MessPull.ExecuteAT(SerialPortA, "AT+QISEND=440", 3000, ">", False))
'Me.WriteToConsole("Time execution AT+QISEND=440" + MessPull.LastTimeRun.ToString + vbCrLf)
If InStr(sRet, ">") > 0 Then
MessPull.ClearMessage()
_nCharWait = 4
sRet = MessPull.ExecuteAT(SerialPortA, sBlock440, 5000, "SEND OK", False)
If InStr(sRet, "SEND OK") > 0 Then
sRet = MessPull.WaitAnswer(SerialPortA, 10000, "done", , False)
If InStr(sRet, "done") > 0 Then
timeStop = Now
tSpan = timeStop.Subtract(timeStart)
nTime = tSpan.TotalMilliseconds
timeSummary = timeSummary + tSpan.TotalMilliseconds
nMinTimeB = IIf(nMinTimeB = 0, nTime, IIf(nMinTimeB > nTime, nTime, nMinTimeB))
nMaxTimeB = IIf(nMaxTimeB = 0, nTime, IIf(nMaxTimeB < nTime, nTime, nMaxTimeB))
nEvgTimeB = IIf(nEvgTimeB = 0, nTime, (nTime + nEvgTimeB) / 2)
nSendSuccB += 1
Me.WriteToConsole(vbCrLf)
Me.WriteToConsole("Cycle Ok. Time: " + timeSummary.ToString + vbCrLf)
record.WriteLine("Cycle Ok. Time: " + timeSummary.ToString)
timeSummaryMin = IIf(timeSummaryMin = 0, timeSummary,
IIf(timeSummaryMin > timeSummary, timeSummaryMin, timeSummaryMin))
timeSummaryMax = IIf(timeSummaryMax = 0, timeSummary,
IIf(timeSummaryMax < timeSummary, timeSummary, timeSummaryMax))
timeSummaryEvg = IIf(timeSummaryEvg = 0, timeSummary, (timeSummary + timeSummaryEvg) / 2)
Else
nLostPackB += 1
Me.WriteToConsole("Not Answer (440 byte). Time: " + nTime.ToString + vbCrLf)
record.WriteLine("Not Answer (440 byte). Time: " + nTime.ToString)
End If
Else
Me.WriteToConsole("Unsuccessfully send Data Pack (440 byte). Time: " + nTime.ToString + vbCrLf)
record.WriteLine("Unsuccessfully send Data Pack (440 byte). Time: " + nTime.ToString)
End If
Else
timeStop = Now
tSpan = timeStop.Subtract(timeStart)
nTime = tSpan.TotalMilliseconds
Me.WriteToConsole("Error execute command AT+QISEND=440. Time: " + nTime.ToString + vbCrLf)
record.WriteLine("Error execute command AT+QISEND=440. Time: " + timeSummary.ToString)
End If
Else
timeStop = Now
tSpan = timeStop.Subtract(timeStart)
nTime = tSpan.TotalMilliseconds
nLostPackA += 1
Me.WriteToConsole("Unsuccessfully execute command [balance$]. Time: " + nTime.ToString + vbCrLf)
record.WriteLine("Unsuccessfully execute command [balance$]. Time: " + nTime.ToString)
End If
Else
Me.WriteToConsole("Unsuccessfully send command [balance$]. Time: " + nTime.ToString + vbCrLf)
record.WriteLine("Unsuccessfully send command [balance$]. Time: " + nTime.ToString)
MessPull.ExecuteAT(SerialPortA, "AT", 3000, "")
MessPull.ExecuteAT(SerialPortA, "AT", 3000, "")
timeStop = Now
tSpan = timeStop.Subtract(timeStart)
nTime = tSpan.TotalMilliseconds
End If
Else
MessPull.ExecuteAT(SerialPortA, "AT", 3000, "")
Me.WriteToConsole("Error execute command AT+QISEND=8!" + vbCrLf)
record.WriteLine("Error execute command AT+QISEND=8!")
End If
MessPull.SetFuncValue("CounterA", nSendAttemptA.ToString)
MessPull.SetFuncValue("CounterB", nSendAttemptB.ToString)
MessPull.SetFuncValue("AverageTimeA", nEvgTimeA.ToString)
MessPull.SetFuncValue("AverageTimeB", nEvgTimeB.ToString)
Me.DisplayFunc()
If Not MessPull.GetFuncValue("STATE") = "CONNECT OK" Then
nLostConnect += 1
seansOpen = False
Me.WriteToConsole("Connection lost at: " + DateTime.Now.ToLongTimeString + vbCrLf)
record.WriteLine("Connection lost at: " + DateTime.Now.ToLongTimeString)
Me.WriteToConsole("Attempt to reconnect." + vbCrLf)
record.WriteLine("Attempt to reconnect.")
End If
Sleep(2000)
End While
End While
MessPull.ExecuteAT(SerialPortA, "AT+QICLOSE", 5000, "CLOSE OK|ERROR")
MessPull.ExecuteAT(SerialPortA, "AT+QIDEACT", 5000, "DEACT OK|ERROR")
Me.WriteToConsole("Connection Closed and GPRS/CSD context was deactivated at: " + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
record.WriteLine("Connection Closed and GPRS/CSD context was deactivated at: " + DateTime.Now.ToLongTimeString + "!")
Me.WriteToConsole("---------------------------------------------------------------------------------------------" + vbCrLf)
record.WriteLine("---------------------------------------------------------------------------------------------")
Me.WriteToConsole("Execution repport:" + vbCrLf)
record.WriteLine("Execution repport:")
Me.WriteToConsole("[balance$] request MIN time (milliseconds): " + nMinTimeA.ToString + vbCrLf)
record.WriteLine("[balance$] request MIN time (milliseconds): " + nMinTimeA.ToString)
Me.WriteToConsole("[balance$] request MAX time (milliseconds): " + nMaxTimeA.ToString + vbCrLf)
record.WriteLine("[balance$] request MAX time (milliseconds): " + nMaxTimeA.ToString)
Me.WriteToConsole("[balance$] request AVERAGE time (milliseconds): " + nEvgTimeA.ToString + vbCrLf)
record.WriteLine("[balance$] request AVERAGE time (milliseconds): " + nEvgTimeA.ToString)
Me.WriteToConsole(vbCrLf)
record.WriteLine("")
Me.WriteToConsole("[440 byte pack] request MIN time (milliseconds): " + nMinTimeB.ToString + vbCrLf)
record.WriteLine("[440 byte pack] request MIN time (milliseconds): " + nMinTimeB.ToString)
Me.WriteToConsole("[440 byte pack] request MAX time (milliseconds): " + nMaxTimeB.ToString + vbCrLf)
record.WriteLine("[440 byte pack] request MAX time (milliseconds): " + nMaxTimeB.ToString)
Me.WriteToConsole("[440 byte pack] request AVERAGE time (milliseconds): " + nEvgTimeB.ToString + vbCrLf)
record.WriteLine("[440 byte pack] request AVERAGE time (milliseconds): " + nEvgTimeB.ToString)
Me.WriteToConsole(vbCrLf)
record.WriteLine("")
Me.WriteToConsole("Summary request MIN time (milliseconds): " + timeSummaryMin.ToString + vbCrLf)
record.WriteLine("Summary request MIN time (milliseconds): " + timeSummaryMin.ToString)
Me.WriteToConsole("Summary request MAX time (milliseconds): " + timeSummaryMax.ToString + vbCrLf)
record.WriteLine("Summary request MAX time (milliseconds): " + timeSummaryMax.ToString)
Me.WriteToConsole("Summary request AVERAGE time (milliseconds): " + timeSummaryEvg.ToString + vbCrLf)
record.WriteLine("Summary request AVERAGE time (milliseconds): " + timeSummaryEvg.ToString)
Me.WriteToConsole(vbCrLf)
record.WriteLine("")
Me.WriteToConsole("Total send attempt command [balance$]: " + nSendAttemptA.ToString + vbCrLf)
record.WriteLine("Total send attempt command [balance$]: " + nSendAttemptA.ToString)
Me.WriteToConsole("Total send attempt packet [440 byte]: " + nSendAttemptB.ToString + vbCrLf)
record.WriteLine("Total send attempt packet [440 byte]: " + nSendAttemptB.ToString)
Me.WriteToConsole("Total send succes [balance$]: " + nSendSuccA.ToString + vbCrLf)
record.WriteLine("Total send succes [balance$]: " + nSendSuccA.ToString)
Me.WriteToConsole("Total send succes [440 byte]: " + nSendSuccB.ToString + vbCrLf)
record.WriteLine("Total send succes [440 byte]: " + nSendSuccB.ToString)
Me.WriteToConsole(vbCrLf)
record.WriteLine("")
Me.WriteToConsole("Lost packet [balanse$]: " + nLostPackA.ToString + vbCrLf)
record.WriteLine("Lost packet [balanse$]: " + nLostPackA.ToString)
Me.WriteToConsole("Lost packet [440 byte]: " + nLostPackB.ToString + vbCrLf)
record.WriteLine("Lost packet [440 byte]: " + nLostPackB.ToString)
Me.WriteToConsole("---------------------------------------------------------------------------------------------" + vbCrLf)
record.WriteLine("---------------------------------------------------------------------------------------------")
Me.WriteToConsole("Script stopped at: " + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
record.WriteLine("Script stopped at: " + DateTime.Now.ToLongTimeString + "!")
record.Close()
'Восстановим состояние модема
If Not serialStatus Then
SerialPortA.Close()
End If
'Разрешим эхо в консоли
_allowEcho = True
End Sub
```
Это скучная часть тестирующей подпрограммы просто пояснит последовательность действий по установке соединения и настройке профиля на конкретном примере, в котором отсутствует адрес сервера и APN провайдера. Надеюсь с этим затруднений не будет.
Модем тестировался длительной поездкой по городу в подключенном режиме с посещением «мертвых» зон, где связь по телефону обрывается. Вот что удивительно, из более чем 860 пакетов, потеряно было только два, а IP-сессия вообще не прерывалась, не говоря уже о соединении. Модем тестировался в сравнении с довольно известной моделью BGS2 второй версии. Результаты тестов показали сокрушительный провал Cinterion BGS2 по устойчивости связи и скорости обмена в пользу M95. Надо сразу отметить что оба модема питались от USB порта ноутбука и имели одинаковые антенны AMMAP 003, однако для BGS2 требовался конденсатор по питанию 1000мФ, а M95 обошелся согласно документации 100 микрофарадами. При этом средний ток потребления M95 был на 46% ниже чем у BGS2. Весьма впечатляющие результаты, а если вспомнить что для написания тестовой программы для M95 у меня ушло два дня, а для BGS2 пришлось «потеть» четыре, то очевидные преимущества (по крайней мере для меня) налицо.
В общем мой первый опыт знакомства с продукцией QUECTEL в виде модема M95 весьма меня порадовал, я в первый раз столкнулся с продукцией которую делали именно для разработчиков, без абстрактного умничанья и соблюдения мертвых стандартов.
Да простят меня уважаемые читатели хабра за воспевание M95, но мне ничего подобного просто не встречалось в моей практике, и перелопаченные после этого восемь моделей совместимых GPRS модемов 12 класса убедили меня что лучше и главное дешевле, а также экономичнее и непритязательнее модема пока на российском рынке не представлено!
##### Сухой код
Для тех, кто пожелает использовать мои наработки, привожу сырой, но работоспособный код модуля с классом использовавшимся в примере приведенном выше а также полную версию кода формы.
**Код модуля содержащего класс:**
```
Imports System
Imports System.Object
Imports System.Collections
Imports System.Threading.Thread
Imports System.IO.Ports
Module ScriptRun
'Public Enum AnswerStatus As Integer
' Reciv_Nothing = 0
' Reciv_OK = 1
' Reciv_Send = 2
' Reciv_Func = 4
' Reciv_Mess = 8
' Reciv_CME_ERROR = 16
' Reciv_ERROR = 32
' Reciv_TimeOut = 256
'End Enum
Public Class MessPull
#Region "Declaration Block"
Private Shared msgList As String() = {} 'массив строк сообщений, заполняемый методами класса
'#Private Shared AnsModem As AnswerStatus 'статус ответа из перечисления AnswerStatus
Private Shared _funcTable As New Hashtable() 'возвращаемые параметры функций формата +ФУНКЦИЯ: ПАРАМЕТР
Private Shared _Recieved As Boolean 'если принята хоть одна строка - True
'#Private Shared _messTable As New Hashtable() 'таблица текстовых сообщений сообщение+количество поступлений
'разрешает перехват строк значений функций, перехваченная строка исключается из массива строк сообщений, вместо этого
'строка разбирается на пару ключ-значение и помещается в Хэш-таблицу _funcVal
Private Shared _funcIntercept As Boolean = True 'Разрешает перехват функций "+FUNC: VALUE"
Private Shared _EchoIntegcept As Boolean = True 'Разрешает перехват эхо команды от модема (программный аналог ATE0)
Private Shared _cmeIntercept As Boolean = True 'Разрешает перехват собщений об ошибке "+CME ERROR: XXX"
Private Shared _smsIntercept As Boolean = True 'Разрешает перехват сообщений об ошибке "+SMS ERROR: XXX"
Private Shared _cmeError As Boolean = False 'Статус - поступила "+CME ERROR: XXX"
Private Shared _smsError As Boolean = False 'Статус - поступила "+SMS ERROE: XXX"
Private Shared _cmeLastError As Integer = -1 'Номер последней "+CME ERROR:"
Private Shared _smsLastError As Integer = -1 'Номер последней "+SMS ERROR:"
Private Shared _lastCommand As String = "" 'Последняя команда переданная модему
' Блок измерения времени
Private Shared startTime, stopTime As Date 'время вхождения в TimeOut-функцию и время завершения
Private Shared tSpan As TimeSpan 'обработчик времени TimeOut, измеритель времени исполнения
Private Shared _lastTRun As Integer 'время последнего исполнения TimeOut-функции
Private Shared _timeOut As Boolean 'статус TimeOut последнего исполнения TimeOut-функции
'объект блокировки оператором SyncLock, для защиты данных от асинхронной записи
Private Shared blockSync As New Object
Public Shared URCMessageList() As String = {"RING", _
"MO RING", _
"MO CONNECTED", _
"Call Ready", _
"CCWV", _
"RDY", _
"NORMAL POWER DOWN", _
"UNDER_VOLTAGE WARNING", _
"UNDER_VOLTAGE POWER DOWN", _
"OVER_VOLTAGE WARNING", _
"OVER_VOLTAGE POWER DOWN"}
#End Region
#Region "Property definition Block"
Public Shared ReadOnly Property FuncTable As Hashtable
Get
SyncLock blockSync
Return _funcTable
End SyncLock
End Get
End Property
Public Shared ReadOnly Property MessageRecieved As Boolean
Get
SyncLock blockSync
Return _Recieved
End SyncLock
End Get
End Property
Public Shared ReadOnly Property LastTimeRun() As Integer
Get
SyncLock blockSync
Return _lastTRun
End SyncLock
End Get
End Property
Public Shared ReadOnly Property TimeOutState() As Boolean
Get
SyncLock blockSync
Return _timeOut
End SyncLock
End Get
End Property
Public Shared Property AllowFuncIntercept() As Boolean
Get
SyncLock blockSync
Return _funcIntercept
End SyncLock
End Get
Set(value As Boolean)
SyncLock blockSync
_funcIntercept = value
End SyncLock
End Set
End Property
Public Shared Property AllowEchoIntercept() As Boolean
Get
SyncLock blockSync
Return _EchoIntegcept
End SyncLock
End Get
Set(value As Boolean)
SyncLock blockSync
_EchoIntegcept = value
End SyncLock
End Set
End Property
Public Shared Property AllowCMEErrorIntercept() As Boolean
Get
SyncLock blockSync
Return _cmeIntercept
End SyncLock
End Get
Set(value As Boolean)
SyncLock blockSync
_cmeIntercept = value
End SyncLock
End Set
End Property
Public Shared Property AllowSMSErrorIntercept() As Boolean
Get
SyncLock blockSync
Return _smsIntercept
End SyncLock
End Get
Set(value As Boolean)
SyncLock blockSync
_smsIntercept = value
End SyncLock
End Set
End Property
Public Shared ReadOnly Property LastCME_Error() As Boolean
Get
SyncLock blockSync
Return _cmeLastError
End SyncLock
End Get
End Property
Public Shared ReadOnly Property LastSMS_Error() As String
Get
SyncLock blockSync
Return _smsLastError
End SyncLock
End Get
End Property
Public Shared Property LastCommand() As String
Get
SyncLock blockSync
Return _lastCommand
End SyncLock
End Get
Set(value As String)
SyncLock blockSync
_lastCommand = value
End SyncLock
End Set
End Property
#End Region
#Region "TimeOut-Function"
Public Shared Function CheckAndSetup(ByRef comPort As SerialPort,
ByVal sCheckCommand As String,
ByVal sFunc As String,
ByVal sValue As String,
Optional ByVal nIndex As Integer = 0,
Optional ByVal sDelim As String = ",",
Optional ByVal sCheckExpect As String = "OK",
Optional ByVal nCheckTimeOut As Integer = 1000,
Optional ByVal sSetCommand As String = "",
Optional ByVal sSetExpect As String = "OK",
Optional ByVal nSetTimeOut As Integer = 2000) As Boolean
'-----------------------------------------------------------------------------------
'Функция ChechAndSetup посылает AT-команду в последовательный порт и
'в течение определенного таймаута ожидает поступления строки содержащей
'терм "OK" или "0". После этого проверяется значение перехваченной функции
' по индексу на соответсвие параметру . Если остальные параметры
'отсутсвуют, то функция возвращает True в случае соответствия параметра иначе False.
'Если в качестве передана пустая строка или не открыт, функция завершится
'вернув False.
'---------------------------------
'При указании в качестве параметра не пустой строки, если результат сравнения
'в вышеописанном алгоритме дает False, то в последовательный порт передается
'комманда и производится ожидание поступление терма "OK" или "0" в
'течение времени . Если до достижения таймаута получен ожидаемый терм, функция
'выполняет проверку значения по индексу на соответсвие параметру .
'Функция возвращает результат проверки на соответсвие False или True.
'---------------------------------
'При возникновении таймаута функция прекращает все дальнейшие действия и всегда возврашает
'False выставляя состояние TimeOutState в True
'---------------------------------
'параметр определяет набор символов, который будет участвовать в парсинге
'параметра функции методом String.Split()
'-----------------------------------------------------------------------------------
Dim stTime As Date = Now
Dim sRet As String
Dim bCheck As Boolean
'
startTime = stTime
CheckAndSetup = False
\_timeOut = False
If (comPort.IsOpen And (sCheckCommand.Length > 0)) Then
SerialWriteLine(comPort, sCheckCommand)
sRet = WaitAnswer(comPort, nCheckTimeOut, sCheckExpect, False)
bCheck = CheckFuncValue(sFunc, sValue, sDelim, nIndex)
If ((Not bCheck) And (Not \_timeOut) And (sSetCommand.Length > 0)) Then
startTime = Now
SerialWriteLine(comPort, sSetCommand)
sRet = WaitAnswer(comPort, nSetTimeOut, sSetExpect, False)
If Not \_timeOut Then
CheckAndSetup = CheckFuncValue(sFunc, sValue, sDelim, nIndex)
End If
Else
CheckAndSetup = bCheck
End If
End If
stopTime = Now
tSpan = stopTime.Subtract(stTime)
\_lastTRun = Int(tSpan.TotalMilliseconds)
End Function
Public Shared Function SendData(ByRef comPort As SerialPort, \_
Optional sComm As String = "", \_
Optional ByVal tOut As Integer = 1000, \_
Optional sExpect As String = "OK|ERROR") As String
'-----------------------------------------------------------------------------------
'Функция посылает AT-команду модему подключенному к последовательному порту comPort и ждет
'отклика в течение времени определенным параметром sComm (в миллисекундах) или до появления
'терма в принимаемых строках определенного списком термов sExpect.
'------------------------------------
'Если параметр sComm = "" или опущен, то функция пропускает действие по отсылке AT-команды
'модему, но выполняет ожидание по времени и поиск терма в принимаемых строках.
'------------------------------------
'Если параметр tOut опущен, то таймаут по умолчанию составляет 1 секунду
'------------------------------------
'Термы подлежащие распознаванию 'разделяются вертикальной чертой. В состав терма могут
'входить любые символы 'исключая вертикальную черту "|". По обнаружении терма или термов
'в(составе) 'принятых строк, функция возвращает строку содержущую выбранные строки до
'появления 'одного или нескольких термов в составе любой из строк, включая строку содержащую
'обнаруженные термы. Выбранные строки соединяются последовательно, разделяемые символами
'"возврат каретки" + "перевод строки" - vbCrLf.
'По окончании заданного времени tOut, функция возвращает выбранные до этого момента
'строки, и выставляет состояние TimeOutState = True а в LastTimeRun заноситься общее
'время выполнения функции
'При нормальном завершении функции WaitAnswer, TimeOutState сбрасывается в False
'а в LastTimeRun заноситься время исполнения функции
'-----------------------------------------------------------------------------------
startTime = Now
If sComm.Length > 0 Then
SerialWrite(comPort, sComm)
End If
SendData = WaitAnswer(comPort, tOut, sExpect, False)
stopTime = Now
tSpan = stopTime.Subtract(startTime)
\_lastTRun = Int(tSpan.TotalMilliseconds)
End Function
Public Shared Function ExecuteAT(ByRef comPort As SerialPort, \_
Optional sComm As String = "", \_
Optional ByVal tOut As Integer = 1000, \_
Optional sExpect As String = "OK|ERROR", \_
Optional ByVal bSetCrLf As Boolean = True) As String
'-----------------------------------------------------------------------------------
'Функция посылает AT-команду модему подключенному к последовательному порту comPort и ждет
'отклика в течение времени определенным параметром sComm (в миллисекундах) или до появления
'терма в принимаемых строках определенного списком термов sExpect.
'------------------------------------
'Если параметр sComm = "" или опущен, то функция пропускает действие по отсылке AT-команды
'модему, но выполняет ожидание по времени и поиск терма в принимаемых строках.
'------------------------------------
'Если параметр tOut опущен, то таймаут по умолчанию составляет 1 секунду
'------------------------------------
'Термы подлежащие распознаванию 'разделяются вертикальной чертой. В состав терма могут
'входить любые символы 'исключая вертикальную черту "|". По обнаружении терма или термов
'в(составе) 'принятых строк, функция возвращает строку содержущую выбранные строки до
'появления 'одного или нескольких термов в составе любой из строк, включая строку содержащую
'обнаруженные термы. Выбранные строки соединяются последовательно, разделяемые символами
'"возврат каретки" + "перевод строки" - vbCrLf.
'По окончании заданного времени tOut, функция возвращает выбранные до этого момента
'строки, и выставляет состояние TimeOutState = True а в LastTimeRun заноситься общее
'время выполнения функции
'При нормальном завершении функции WaitAnswer, TimeOutState сбрасывается в False
'а в LastTimeRun заноситься время исполнения функции
'-----------------------------------------------------------------------------------
startTime = Now
If sComm.Length > 0 Then
comPort.WriteLine(Trim(sComm))
End If
ExecuteAT = WaitAnswer(comPort, tOut, sExpect, False)
stopTime = Now
tSpan = stopTime.Subtract(startTime)
\_lastTRun = Int(tSpan.TotalMilliseconds)
End Function
Public Shared Function WaitAnswer(ByRef commPort As SerialPort, \_
Optional tOut As Integer = 1000, \_
Optional sExpect As String = "OK|ERROR", \_
Optional ByVal bStTime As Boolean = True, \_
Optional ByVal bSetCrLf As Boolean = True) As String
'-----------------------------------------------------------------------------------
'Функция ожидает данных от модема подключенного к последовательному порту commPort в
'течение времени tOut в миллисекундах или до обнаружения терма в принятых строках
'объявленных в списке термов sExpect.
'------------------------------------
'Параметр bStTime определяет необходимость измерения старового времени функции,
'по(умолчанию - измерять)
'------------------------------------
'Если параметр tOut опущен, то таймаут по умолчанию составляет 1 секунду
'------------------------------------
'Термы подлежащие распознаванию 'разделяются вертикальной чертой. В состав терма могут
'входить любые символы 'исключая вертикальную черту "|". По обнаружении терма или термов
'в(составе) 'принятых строк, функция возвращает строку содержущую выбранные строки до
'появления 'одного или нескольких термов в составе любой из строк, включая строку содержащую
'обнаруженные термы. Выбранные строки соединяются последовательно, разделяемые символами
'"возврат каретки" + "перевод строки" - vbCrLf.
'По окончании заданного времени tOut, функция возвращает выбранные до этого момента
'строки, и выставляет состояние TimeOutState = True а в LastTimeRun заноситься общее
'время выполнения функции
'При нормальном завершении функции WaitAnswer, TimeOutState сбрасывается в False
'а в LastTimeRun заноситься время исполнения функции
'-----------------------------------------------------------------------------------
Dim sTemp, sText As String
Dim sTerminator As String = IIf(bSetCrLf, vbCrLf, "")
Dim aExpect As String() = {}
Dim bContinue As Boolean = True
\_timeOut = False
If bStTime Then
startTime = Now
End If
WaitAnswer = ""
If sExpect.Length > 0 Then
aExpect = sExpect.Split("|".ToCharArray)
Else
aExpect = {}
End If
While bContinue
While (MsgCount() < 1)
Sleep(5)
stopTime = Now
tSpan = stopTime.Subtract(startTime)
If tSpan.TotalMilliseconds > tOut Then
\_timeOut = True
\_lastTRun = Int(tSpan.TotalMilliseconds)
bContinue = False
Exit While
End If
End While
If bContinue Then
sTemp = ExtractMess()
WaitAnswer = IIf(WaitAnswer.Length > 0, WaitAnswer + sTemp + sTerminator, sTemp + sTerminator)
If aExpect.Length > 0 Then
For Each sText In aExpect
If InStr(sTemp, sText) > 0 Then
bContinue = False
Exit For
End If
Next sText
End If
Else
Exit While
End If
End While
stopTime = Now
tSpan = stopTime.Subtract(startTime)
\_lastTRun = Int(tSpan.TotalMilliseconds)
End Function
Public Shared Function WaitFunc(ByVal sKey As String,
Optional ByVal tOut As Integer = 1000,
Optional ByVal sDelim As String = ",",
Optional ByVal nIndex As Integer = -1) As String
'-----------------------------------------------------------------------------------
'Функция ожидает появления ключа sKey в хэш-таблице в течение времени tOut в
'миллисекундах. В случае орбнаружения ключа функция возвращает значение в зависимости
'от присутствия и значения параметра nIndex.
'------------------------------------
'Если параметр tOut опущен, то таймаут по умолчанию составляет 1 секунду
'------------------------------------
'Когда параметр nIndex передан функции, производится попытка поиска параметра по индеку
'используя в качестве разделителя группы sDelim. Если параметр nIndex опущен, функция
'возвращает всё значение ключа sKey или пустую строку в случае его отсутствия.
'-----------------------------------------------------------------------------------
Dim sTemp As String
\_timeOut = False
startTime = Now
WaitFunc = ""
While True
sTemp = GetFuncValue(sKey, sDelim, nIndex)
If sTemp.Length > 0 Then
WaitFunc = sTemp
Exit While
End If
stopTime = Now
tSpan = stopTime.Subtract(startTime)
If tSpan.TotalMilliseconds > tOut Then
\_timeOut = True
\_lastTRun = Int(tSpan.TotalMilliseconds)
Exit While
End If
Sleep(5)
End While
stopTime = Now
tSpan = stopTime.Subtract(startTime)
\_lastTRun = Int(tSpan.TotalMilliseconds)
End Function
#End Region
#Region "Public Methods ()"
Public Shared Sub SerialWrite(ByVal comPort As SerialPort, ByVal sComm As String)
If (comPort.IsOpen And (sComm.Length > 0)) Then
comPort.Write(sComm)
\_lastCommand = Trim(sComm)
End If
End Sub
Public Shared Sub SerialWriteLine(ByVal comPort As SerialPort, ByVal sComm As String)
If (comPort.IsOpen And (sComm.Length > 0)) Then
comPort.WriteLine(sComm)
\_lastCommand = Trim(sComm)
End If
End Sub
Public Shared Function IsCME\_Error() As Boolean
IsCME\_Error = \_cmeError
End Function
Public Shared Function IsSMS\_Error() As Boolean
IsSMS\_Error = \_smsError
End Function
Public Shared Sub DropCME\_Error()
\_cmeError = False
\_cmeLastError = -1
End Sub
Public Shared Sub DropSMS\_Error()
\_smsError = False
\_smsLastError = -1
End Sub
Public Shared Function AppendLines(ByVal aLines As String()) As Integer
'-------------------------------------------------------------------------------
' функция добавляет строки массива в массив сообщений
' возвращает общее количество элементов массива сообщений после добавления
' если в качестве аргумента указан пустой массив, то функция ничего не выполняет
Dim sText As String
If aLines.Length > 0 Then
For Each sText In aLines
AppendLines = AppendMess(sText)
Next
End If
End Function
Public Shared Function AppendMess(ByVal sText As String) As Integer
'-------------------------------------------------------------------------------
' функция добавляет строку сообщения в массив сообщений
' возвращает общее количество элементов массива сообщений после добавления
' если в качестве параметра указана пустая строка, добавления сообщения не происходит
Dim nCount As Integer = 0
If \_funcIntercept Then
sText = FuncIntercept(sText)
End If
If sText.Length > 0 Then
SyncLock blockSync
nCount = msgList.Length
ReDim Preserve msgList(nCount)
msgList(nCount) = Trim(sText)
nCount = msgList.Length
\_Recieved = True
End SyncLock
Else
SyncLock blockSync
nCount = msgList.Length
End SyncLock
End If
AppendMess = nCount
End Function
Public Shared Function Items() As String()
'-------------------------------------------------------------------------------
' функция возвращает копию всего списка (массива строк) сообщений
Dim aStr As String()
SyncLock blockSync
Dim nCount As Integer = UBound(msgList)
ReDim aStr(nCount)
Array.Copy(msgList, aStr, msgList.Length)
End SyncLock
Items = aStr
End Function
Public Shared Function MsgCount() As Integer
'-------------------------------------------------------------------------------
' возвращает количество строк в массиве сообщений
SyncLock blockSync
MsgCount = msgList.Length
End SyncLock
End Function
Public Shared Function ExtractMess() As String
'-------------------------------------------------------------------------------
' функция извлекает самое первое сообщение из списка и возвращет его
' при этом извлекаемое сообщение удаляется из списка, а список становится
' короче на одно сообщение
' если в списке нет ни одного сообщения, возвращается пустая строка
Dim nCount As Integer
ExtractMess = ""
SyncLock blockSync
If msgList.Length > 0 Then
ExtractMess = msgList(0)
nCount = UBound(msgList)
nCount -= 1
Array.Copy(msgList, 1, msgList, 0, msgList.Length - 1)
ReDim Preserve msgList(nCount)
End If
If msgList.Length = 0 Then \_Recieved = False
End SyncLock
End Function
Public Shared Sub ClearMessage()
'-------------------------------------------------------------------------------
' Процедура очищает список сообщений
SyncLock blockSync
msgList = {}
\_Recieved = False
End SyncLock
End Sub
Public Shared Function GetFuncValue(ByVal sKey As String,
Optional ByVal sDelim As String = ",",
Optional ByVal nIndex As Integer = -1) As String
Dim sVal As String = ""
Dim aVal As String() = {}
GetFuncValue = ""
SyncLock \_funcTable.SyncRoot
If \_funcTable.ContainsKey(sKey) Then
sVal = \_funcTable(sKey)
End If
End SyncLock
If (sVal.Length > 0) And (nIndex >= 0) Then
aVal = sVal.Split(sDelim.ToCharArray, StringSplitOptions.RemoveEmptyEntries)
If nIndex > UBound(aVal) Then
Exit Function
Else
GetFuncValue = aVal(nIndex)
End If
Else
GetFuncValue = sVal
End If
End Function
Public Shared Function CheckFuncValue(ByVal sFunc As String,
ByVal sValue As String,
Optional ByVal sDelim As String = ",",
Optional ByVal nIndex As Integer = 0) As Boolean
Dim aVal As String()
CheckFuncValue = False
If (sFunc.Length > 0) And (\_funcTable.Contains(sFunc)) Then
aVal = \_funcTable(sFunc).ToString.Split(sDelim.ToCharArray, StringSplitOptions.RemoveEmptyEntries)
If nIndex <= UBound(aVal) Then
CheckFuncValue = IIf(Trim(sValue) = Trim(aVal(nIndex)), True, False)
End If
End If
End Function
Public Shared Sub SetFuncValue(ByVal sKey, ByVal Value)
SyncLock \_funcTable.SyncRoot
\_funcTable(sKey) = Value
End SyncLock
End Sub
Public Shared Sub RemuveFunc(ByVal sKey)
SyncLock \_funcTable.SyncRoot
\_funcTable.Remove(sKey)
End SyncLock
End Sub
Public Shared Sub ClearFuncList()
SyncLock \_funcTable.SyncRoot
\_funcTable.Clear()
End SyncLock
End Sub
#End Region
#Region "Private Methods"
Private Shared Function FuncIntercept(ByVal sText As String) As String
'-------------------------------------------------------------------------------
'Функция "перехватчик" строк типа +CREG:1. Если функция обнаруживает что
'строка содержит именно комбинацию из лидирующего "+" и финиширующего
'имя функции ":", то строка разбивается на имя функции и возвращаемый
'параметр, следующий сразу после ":". Символы "+" и ":" удаляются при
'разборе строки.
'----------------
'Функция возвращает пустую строку в случае удачного перехвата или пустой
'строки переданной в качестве параметра, иначе возвращается переданная в
'качестве параметра строка.
'----------------
Dim i, n, m As Integer
Dim aLine As String()
Dim key As String = ""
Dim val As String = ""
' Грохнем лидирующие и завершающие пробелы
sText = Trim(sText)
If (\_EchoIntegcept And (sText = \_lastCommand)) Then
FuncIntercept = ""
Exit Function
End If
' Выставим по умолчанию возврат строки параметра
FuncIntercept = sText
i = InStr(sText, "+")
n = InStr(sText, ":")
m = InStr(sText, "^")
If ((i > 0) Or (n > 0) Or (m > 0)) Then
If sText.Length > 0 Then
aLine = sText.Split("+^:".ToCharArray, StringSplitOptions.RemoveEmptyEntries)
If aLine.Length = 0 Then
Exit Function
ElseIf aLine.Length = 1 Then
key = aLine(0)
val = ""
ElseIf aLine.Length = 2 Then
key = aLine(0)
val = aLine(1)
End If
If val = "CME ERROR" Then
\_cmeError = True
\_cmeLastError = Int(val)
If Not \_cmeIntercept Then
Exit Function
End If
ElseIf val = "SMS ERROR" Then
\_smsError = True
\_smsLastError = Int(val)
If Not \_smsIntercept Then
Exit Function
End If
End If
SyncLock \_funcTable.SyncRoot
\_funcTable(Trim(key)) = Trim(val)
End SyncLock
FuncIntercept = ""
End If
End If
End Function
#End Region
End Class
End Module
```
**Код событий и локальных процедур/функций формы:**
```
#Region "Import Namespace"
Imports System
Imports System.Text
Imports System.IO
Imports System.IO.Ports
Imports System.Threading
Imports System.Threading.Thread
Imports System.Collections
Imports System.Object
Imports System.ComponentModel
Imports System.Runtime.InteropServices
Imports System.Runtime.ConstrainedExecution
#End Region
Public Class CommCare
#Region "Declaration"
Shared SerialPortA As SerialPort
Shared _continue As Boolean ' False запрещает реакцию на изменение в ComboBox с данными настройки
Shared _readPort As Boolean ' False запрещает реакцию на изменение текстовых данных в консоли TextBoxM
Shared _lineCount As Integer ' переменная хранения количества строк в TextBoxM, если добавлена - последняя строка передается в порт
Shared _nCharWait As Integer = 0 ' переменная указывает на то, что ожидается прием _nCharWait символов не смотря vbCrLf
Shared _lastLine As String = "" ' хранит последние переданные в COM порт данные
Shared _lastRead As String = "" ' накопительная переменная, в которую помещаются данные принятые из COM порта
Shared _ReadBuff As String = "" ' перемнная в которую помещаются данные по асинхронному запросу из другого потока
Shared _lastClear As Boolean ' переменная указывающая что необходимо очистить _lastRead
Shared _lockRead As Boolean ' переменная межпотоковой блокировки опустошения или пополнения _lastRead
Shared _allowRun As Boolean ' переменная разрешающая продолжение исполнения скрипта, либо прерывающая (False) его исполнение
Shared _allowEcho As Boolean ' переменная разрешающая вывод на консоль обработчику событий приема данных из COM порта
Shared _timeOut As Boolean '
Shared _QICSGP As String ' переменная хранения настроек провайдера и сеанса связи
Shared _QIOPEN As String ' переменная хранения типа соединения и адреса сервера
Public hashToken As Hashtable ' публичная таблица ключевых слов AT-команд
Private ScriptThread As Thread = New Thread(AddressOf RunScript)
' Перечислитель элементов массива скрипта
Public Enum scNames
scKeyWord
scVarData
scLabel
scCodeData
scSubData
End Enum
' массив элементов скрипта
Public aScript As Array = {New Hashtable, New Hashtable, New Hashtable, New ArrayList, New ArrayList}
Public RunStack As Stack = New Stack
Private BaudList As String() = {"4800", "9600", "14400", "19200", "38400", "57600", "115200", "128000", "230400", "460800", "614400", "921600", "1228800"}
Private DataBitsList As String() = {"8", "7", "6", "5", "4"}
' API - функция чтения параметра из INI-файла
Private Declare Auto Function GetPrivateProfileString Lib "kernel32" _
(ByVal lpAppName As String, _
ByVal lpKeyName As String, _
ByVal lpDefault As String, _
ByVal lpReturnedString As StringBuilder, _
ByVal nSize As Integer, _
ByVal lpFileName As String) As Int32
' API - функция сохранения параметра в INI-файл
Private Declare Auto Function WritePrivateProfileString Lib "Kernel32" _
(ByVal Section As String, _
ByVal Key As String, _
ByVal putStr As String, _
ByVal INIfile As String) As Int32
' This delegate enables asynchronous calls for setting
' the text property on a TextBox control.
Delegate Sub SetTextCallback([text] As String, bClear As Boolean)
#End Region
#Region "COM Collectors"
' Recollect COM port setting
Private Sub Refresh_COMSetting()
_continue = False
' Dim readThread As Thread = New Thread(AddressOf Read)
' Create a new SerialPort object with default settings.
Call CollectParity()
Call CollectBaudRate()
Call DataBitsSet()
Call StopBitsSet()
Call FlowControlSet()
_continue = True
End Sub
' Collect list of available COM ports (registry info)
Private Sub CollectCOMM_List()
Dim listCOM As String() = IO.Ports.SerialPort.GetPortNames()
Dim port As String
' Clear list of COM Ports
ComboBoxCOM_List.Items.Clear()
' Get list of serial COM ports
' Fill ComboBox, names of COM
For Each port In listCOM
ComboBoxCOM_List.Items.Add(port)
Next port
ComboBoxCOM_List.SelectedIndex = 0
End Sub
' Fill ComboBox BaudRate value and set ComboBox to port value allready setted
Private Sub CollectBaudRate()
'Fill ComboBox_BaudList available speed list
Dim BaudRate As String
Dim DefBaud As Integer
Dim DefSel As Integer
Dim SelBox As Integer
ComboBox_BaudList.Items.Clear()
DefSel = 0
DefBaud = SerialPortA.BaudRate
For Each BaudRate In BaudList
Try
SerialPortA.BaudRate = Int(BaudRate)
If Int(BaudRate) = DefBaud Then
SelBox = DefSel
End If
DefSel = DefSel + 1
ComboBox_BaudList.Items.Add(BaudRate)
Catch ex As Exception
' Do nothing
End Try
Next
SerialPortA.BaudRate = DefBaud
ComboBox_BaudList.SelectedIndex = SelBox
End Sub
' Fill ComboBox DataBits value and set ComboBox to port value allready setted
Private Sub DataBitsSet()
Dim DefDataBits As Integer
Dim sBits As Integer
Dim BoxSel, nSel As Integer
ComboBox_DataBits.Items.Clear()
DefDataBits = SerialPortA.DataBits
nSel = 0
For Each sBits In DataBitsList
If Int(sBits) = DefDataBits Then
BoxSel = nSel
End If
nSel = nSel + 1
ComboBox_DataBits.Items.Add(sBits)
Next
ComboBox_DataBits.SelectedIndex = BoxSel
End Sub
' Fill ComboBox StopBits value and set ComboBox to port value allready setted
Private Sub StopBitsSet()
ComboBox_StopBits.Items.Clear()
Dim s As String
For Each s In [Enum].GetNames(GetType(StopBits))
ComboBox_StopBits.Items.Add(s)
Next s
ComboBox_StopBits.SelectedIndex = SerialPortA.StopBits
End Sub
' Fill ComboBox Parity value and set ComboBox to port value allready setted
Private Sub CollectParity()
Dim s As String
ComboBox_ParityList.Items.Clear()
For Each s In [Enum].GetNames(GetType(Parity))
ComboBox_ParityList.Items.Add(s)
Next s
ComboBox_ParityList.SelectedIndex = SerialPortA.Parity
End Sub
' Fill ComboBox Handshake value and set ComboBox to port value allready setted
Private Sub FlowControlSet()
Dim s As String
ComboBox_FlowControl.Items.Clear()
For Each s In [Enum].GetNames(GetType(Handshake))
ComboBox_FlowControl.Items.Add(s)
Next s
ComboBox_FlowControl.SelectedIndex = SerialPortA.Parity
End Sub
#End Region
#Region "Thread safe sub"
' Thread-Safe write to console TextBoxM
Private Sub WriteToConsole(ByVal [text] As String, Optional bClear As Boolean = False)
If Me.TextBoxM.InvokeRequired Then
Dim d As New SetTextCallback(AddressOf WriteToConsole)
Me.Invoke(d, New Object() {[text], bClear})
Else
_readPort = False
If bClear Then
Me.TextBoxM.Text = [text]
Else
Me.TextBoxM.AppendText([text])
End If
Me.CB_DataRecived.Checked = MessPull.MessageRecieved
End If
End Sub
' Thread-Safe write to console TextBox_Recieved
Private Sub WriteToRecieved(ByVal [text] As String, Optional bClear As Boolean = False)
If Me.TextBox_Recieved.InvokeRequired Then
Dim d As New SetTextCallback(AddressOf WriteToRecieved)
Me.Invoke(d, New Object() {[text], bClear})
Else
If bClear Then
Me.TextBox_Recieved.Text = [text]
Else
Me.TextBox_Recieved.AppendText([text])
End If
End If
End Sub
#End Region
#Region "Local procedure"
' Load token list from file
Private Sub LoadToken(ByVal fName As String)
Dim nCntr As Integer
Dim sToken As String
If File.Exists(fName) Then
Dim rdStream As New StreamReader(fName)
hashToken = New Hashtable
nCntr = 1
While Not rdStream.EndOfStream
sToken = rdStream.ReadLine()
hashToken.Add(sToken, nCntr)
nCntr += 1
End While
rdStream.Close()
End If
End Sub
' Write COM port configuration to file
Private Sub WriteConfig(ByVal fName)
WritePrivateProfileString("SERIAL1", "PortName", ComboBoxCOM_List.Text, fName)
WritePrivateProfileString("SERIAL1", "BaudRate", ComboBox_BaudList.Text, fName)
WritePrivateProfileString("SERIAL1", "Parity", Str(ComboBox_ParityList.SelectedIndex), fName)
WritePrivateProfileString("SERIAL1", "DataBits", ComboBox_DataBits.Text, fName)
WritePrivateProfileString("SERIAL1", "StopBits", Str(ComboBox_StopBits.SelectedIndex), fName)
WritePrivateProfileString("SERIAL1", "Handshake", Str(ComboBox_FlowControl.SelectedIndex), fName)
WritePrivateProfileString("DATE", "LastSaved", Date.Today, fName)
' Form Size & Position
WritePrivateProfileString("FORMPOS", "Y", Me.Location.Y.ToString(), fName)
WritePrivateProfileString("FORMPOS", "X", Me.Location.X.ToString(), fName)
WritePrivateProfileString("FORMPOS", "Height", Me.Height.ToString(), fName)
WritePrivateProfileString("FORMPOS", "Width", Me.Width.ToString(), fName)
' TabControl
WritePrivateProfileString("INTERNAL", "TabActive", TabControlA.SelectedIndex.ToString(), fName)
WritePrivateProfileString("SCRIPT", "QICSGP", TextBoxBearer.Text, fName)
WritePrivateProfileString("SCRIPT", "QIOPEN", TextBoxIP.Text, fName)
End Sub
' Load COM port configuration from file
Private Sub LoadConfig(ByVal fName)
Dim nLength As Integer
Dim sBuff As StringBuilder
Dim iniparam As String
Dim nIndex As Integer
Dim aPoint As Point
sBuff = New StringBuilder(500)
sBuff.Clear()
If File.Exists(fName) Then
nLength = GetPrivateProfileString("SERIAL1", "PortName", ComboBoxCOM_List.Text, sBuff, sBuff.Capacity, fName)
iniparam = sBuff.ToString()
nIndex = ComboBoxCOM_List.FindString(iniparam)
If nIndex >= 0 Then
ComboBoxCOM_List.SelectedIndex = nIndex
SerialPortA.PortName = ComboBoxCOM_List.Text
End If
sBuff.Clear()
'
nLength = GetPrivateProfileString("SERIAL1", "BaudRate", ComboBox_BaudList.Text, sBuff, sBuff.Capacity, fName)
iniparam = sBuff.ToString()
nIndex = ComboBox_BaudList.FindString(iniparam)
If nIndex >= 0 Then
ComboBox_BaudList.SelectedIndex = nIndex
SerialPortA.BaudRate = Int(ComboBox_BaudList.Text)
End If
sBuff.Clear()
'
nLength = GetPrivateProfileString("SERIAL1", "Parity", Str(ComboBox_ParityList.SelectedIndex), sBuff, sBuff.Capacity, fName)
iniparam = sBuff.ToString()
ComboBox_ParityList.SelectedIndex = Int(iniparam)
SerialPortA.Parity = Int(iniparam)
sBuff.Clear()
'
nLength = GetPrivateProfileString("SERIAL1", "DataBits", ComboBox_DataBits.Text, sBuff, sBuff.Capacity, fName)
iniparam = sBuff.ToString()
nIndex = ComboBox_DataBits.FindString(iniparam)
If nIndex >= 0 Then
ComboBox_DataBits.SelectedIndex = nIndex
SerialPortA.DataBits = Int(iniparam)
End If
sBuff.Clear()
'
nLength = GetPrivateProfileString("SERIAL1", "StopBits", Str(ComboBox_StopBits.SelectedIndex), sBuff, sBuff.Capacity, fName)
iniparam = sBuff.ToString()
ComboBox_StopBits.SelectedIndex = Int(iniparam)
SerialPortA.StopBits = Int(iniparam)
sBuff.Clear()
'
nLength = GetPrivateProfileString("SERIAL1", "Handshake", Str(ComboBox_FlowControl.SelectedIndex), sBuff, sBuff.Capacity, fName)
iniparam = sBuff.ToString()
ComboBox_FlowControl.SelectedIndex = Int(iniparam)
SerialPortA.Handshake = Int(iniparam)
' Form size & position
sBuff.Clear()
nLength = GetPrivateProfileString("FORMPOS", "Y", Me.Location.Y.ToString(), sBuff, sBuff.Capacity, fName)
aPoint.Y = Int(sBuff.ToString())
sBuff.Clear()
nLength = GetPrivateProfileString("FORMPOS", "X", Me.Location.X.ToString(), sBuff, sBuff.Capacity, fName)
aPoint.X = Int(sBuff.ToString())
Me.Location = aPoint
sBuff.Clear()
nLength = GetPrivateProfileString("FORMPOS", "Height", Me.Height.ToString(), sBuff, sBuff.Capacity, fName)
Me.Height = Int(sBuff.ToString())
sBuff.Clear()
nLength = GetPrivateProfileString("FORMPOS", "Width", Me.Width.ToString(), sBuff, sBuff.Capacity, fName)
Me.Width = Int(sBuff.ToString())
' Tab control
sBuff.Clear()
nLength = GetPrivateProfileString("INTERNAL", "TabActive", TabControlA.SelectedIndex.ToString(), sBuff, sBuff.Capacity, fName)
nLength = Int(sBuff.ToString())
TabControlA.SelectTab(nLength)
' Script process
sBuff.Clear()
nLength = GetPrivateProfileString("INTERNAL", "ScriptAutoLoad", "No", sBuff, sBuff.Capacity, fName)
If UCase(sBuff.ToString()) = "YES" Then
AutoLoadScriptToolStripMenuItem.Checked = True
sBuff.Clear()
Dim scriptPathName As String = sBuff.ToString()
nLength = GetPrivateProfileString("INTERNAL", "ScriptFile", "", sBuff, sBuff.Capacity, fName)
scriptPathName = sBuff.ToString()
Dim read As New StreamReader(scriptPathName)
TextBox_Script.Text = read.ReadToEnd.ToString
read.Close()
End If
' Load default token
nLength = GetPrivateProfileString("SCRIPT", "TokenFileName", Application.StartupPath & "\Default.tok", sBuff, sBuff.Capacity, fName)
Call LoadToken(sBuff.ToString())
sBuff.Clear()
nLength = GetPrivateProfileString("SCRIPT", "QICSGP", "1,""inet.bwc.ru""", sBuff, sBuff.Capacity, fName)
TextBoxBearer.Text = sBuff.ToString()
sBuff.Clear()
nLength = GetPrivateProfileString("SCRIPT", "QIOPEN", """TCP"",""46.254.241.3"",9999""", sBuff, sBuff.Capacity, fName)
TextBoxIP.Text = sBuff.ToString()
End If
End Sub
' Check native token
Private Function CheckNativeToken(ByVal sToken) As Boolean
CheckNativeToken = hashToken.Contains(sToken)
End Function
' Run script operation
Private Sub RunScript()
Dim sRet, sTemp As String
Dim timeStart As Date
Dim timeStop As Date
Dim nTime As Double = 0
Dim nCount As Integer
Dim tSpan As TimeSpan
Dim serialStatus As Boolean = SerialPortA.IsOpen
Dim seansOpen As Boolean = False
Dim sBlock440 As String = "operations$öûâðëéîð÷ñéðöâéîðó2837âí2àãïëöãéïàöëäî3ïðàëîöíóïàùã34ïàùãà4óíïùöãíï4àêãùíöïùøãí4ïàùãöóåïàêãöù4ïàùãø4íïàùöã4íïàêùö6å4ê6åïöøãíàïö4ùïåàöùàïöùãà4ïöùã47ïåàêùöïù4ãïàøöãàï4ùãï4àùãöïàùöãï4àøùã6ï4àùãö4ïåàøãöï64àøã46ïà6öïàø76ö4ïàäöãàïíöãøíïuiowq3ygrowg3fowrtgowufygbow4gfowueyfgco6wt4go68gfrwkuyfcgwkgy4ckuw4ygfouwygou4fgrfouwf4gow4grfw4yofgowu4ygfou4fgwo4uygfwy4gfow4g4gfowufgou4rgyfwuyfguwygf4uyg4f6gfiu4gklejhdkwehfewhrkferhiuht43iuhiur"
' Блок переменных для фиксации временных рараметров и отказов
Dim nDisconnect As Integer = 0
Dim nMinTimeA, nMinTimeB, nMaxTimeA, nMaxTimeB, nEvgTimeA, nEvgTimeB As Integer
Dim nSendAttemptA, nSendAttemptB, nLostPackA, nLostPackB As Integer
Dim nSendSuccA, nSendSuccB As Integer
Dim nLostConnect As Integer = 0
Dim timeSummary As Double = 0
Dim timeSummaryMin As Double = 0
Dim timeSummaryMax As Double = 0
Dim timeSummaryEvg As Double = 0
_allowRun = True
_allowEcho = True
_ReadBuff = ""
_lastClear = False
_lastLine = ""
nMinTimeA = 0
nMinTimeB = 0
nMaxTimeA = 0
nMaxTimeB = 0
nEvgTimeA = 0
nEvgTimeB = 0
nSendAttemptA = 0
nSendAttemptB = 0
nLostPackA = 0
nLostPackB = 0
nSendSuccA = 0
nSendSuccB = 0
'Настройка пула сообщений
MessPull.ClearMessage()
MessPull.AllowCMEErrorIntercept = True
MessPull.AllowFuncIntercept = True
MessPull.AllowSMSErrorIntercept = True
MessPull.DropCME_Error()
MessPull.DropSMS_Error()
' Начало операций
Dim record As New StreamWriter(Application.StartupPath & "\Default.log")
Me.WriteToConsole("Script started at " + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
record.WriteLine("Script started at " + DateTime.Now.ToLongTimeString + "!")
If Not SerialPortA.IsOpen Then
Try
SerialPortA.Open()
Catch
Me.WriteToConsole("Serial Port: " + SerialPortA.PortName + " is busy! Script stopped at: " + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
record.WriteLine("Serial Port: " + SerialPortA.PortName + " is busy! Script stopped at: " + DateTime.Now.ToLongTimeString + "!")
_allowRun = False
End Try
End If
' Инициаллизация модема
If _allowRun Then
nCount = 0
sTemp = ""
MessPull.ClearMessage()
While ((InStr(sTemp, "OK") = 0) And _allowRun)
nCount += 1
sTemp = MessPull.ExecuteAT(SerialPortA, "AT" + vbCrLf, 3000)
Me.WriteToConsole("Attempt: " + Str(nCount) + " Send: " + sTemp)
End While
Me.DisplayFunc()
' Включаем модем
Me.WriteToConsole("Turn on the modem!" + vbCrLf)
If Not MessPull.CheckAndSetup(SerialPortA, "AT+CFUN?", "CFUN", "1", , , , , "AT+CFUN=1", "Call Ready", 15000) Then
Me.WriteToConsole("Modem does not turn on! Script Aborted!" + vbCrLf)
_allowRun = False
Else
' Малозначимые настраиваем параметры
Me.WriteToConsole(MessPull.ExecuteAT(SerialPortA, "ATE1", 3000))
MessPull.CheckAndSetup(SerialPortA, "AT+CREG?", "CREG", "1", 0, ",", "OK", 1000, "AT+CREG=1", "OK", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+CGREG?", "CGREG", "1", 0, ",", "OK", 1000, "AT+CGREG=1", "OK", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+CRC?", "CRC", "0", 0, ",", "OK", 1000, "AT+CRC=0", "OK", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+QAUDCH?", "QAUDCH", "2", 0, ",", "OK", 1000, "AT+QAUDCH=2", "OK", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+QIFGCNT?", "QIFGCNT", "1", 0, ",", "OK", 1000, "AT+QIFGCNT=1", "OK", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+QICSGP?", "QICSGP", "1", 0, ",", "OK", 1000, "AT+QICSGP=" + _QICSGP, "OK", 5000)
End If
Me.DisplayFunc()
End If
While _allowRun
While _allowRun
If (MessPull.CheckAndSetup(SerialPortA, "AT+CREG?", "CREG", "1", 1) And
MessPull.CheckAndSetup(SerialPortA, "AT+CGREG?", "CGREG", "1", 1)) Then
Exit While
End If
Me.DisplayFunc()
End While
Me.DisplayFunc()
Me.WriteToConsole("Modem is registered on the home network at: " + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
record.WriteLine("Modem is registered on the home network at: " + DateTime.Now.ToLongTimeString + "!")
' Цикл установления соединения
While (_allowRun And (Not seansOpen = True))
Me.DisplayFunc()
Me.WriteToConsole(MessPull.ExecuteAT(SerialPortA, "AT+QISTAT", 2000) + vbCrLf)
'MessPull.WaitAnswer(SerialPortA, 5000, "", False)
'record.WriteLine("Request status at: " + DateTime.Now.TimeOfDay.ToString + "!")
sRet = MessPull.GetFuncValue("STATE")
Select Case sRet
Case "IP INITIAL"
MessPull.CheckAndSetup(SerialPortA, "AT+QISDE?", "QISDE", "0", 0, ",", "OK", 1000, "AT+QISDE = 0", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+QIMUX?", "QIMUX", "0", 0, ",", "OK", 1000, "AT+QIMUX = 0", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+QIMODE?", "QIMODE", "0", 0, ",", "OK", 1000, "AT+QIMODE=0", 5000)
MessPull.CheckAndSetup(SerialPortA, "AT+QIDNSIP?", "QIDNSIP", "0", 0, ",", "OK", 1000, "AT+QIDNSIP=0", 5000)
If Not InStr(MessPull.ExecuteAT(SerialPortA, "AT+QIREGAPP", 1000, "OK|ERROR"), "OK") > 0 Then
Me.WriteToConsole("Can not register application on network! Next Attempt!" + vbCrLf)
record.WriteLine("Can't Activate GPRS/CSD context! Next Attempt!")
End If
Case "IP START"
If Not InStr(MessPull.ExecuteAT(SerialPortA, "AT+QIACT", 1000, "OK|ERROR"), "OK") > 0 Then
Me.WriteToConsole("Can't Activate GPRS/CSD context! Next Attempt!" + vbCrLf)
record.WriteLine("Can't Activate GPRS/CSD context! Next Attempt!")
End If
Case "IP GPRSACT"
If Not InStr(MessPull.ExecuteAT(SerialPortA, "AT+QILOCIP", 2000, "."), ".") > 0 Then
Me.WriteToConsole("Can't Get local IP addres!" + vbCrLf)
record.WriteLine("Can't Get local IP addres!")
End If
Case "IP STATUS"
If Not InStr(MessPull.ExecuteAT(SerialPortA, "AT+QIOPEN=" + _QIOPEN, 5000, "OK"), "OK") > 0 Then
seansOpen = True
Else
Me.WriteToConsole("Can not estabilish connect!" + vbCrLf)
record.WriteLine("Can not estabilish connect!")
seansOpen = False
End If
Case "IP CLOSE"
MessPull.ExecuteAT(SerialPortA, "AT+QIDEACT", 5000, "DEACT OK")
Me.WriteToConsole("Deactivate GPRS/CSD context!" + vbCrLf)
record.WriteLine("Deactivate GPRS/CSD context!")
seansOpen = False
Case "CONNECT OK"
seansOpen = True
Me.WriteToConsole("Connection OK!" + vbCrLf)
record.WriteLine("Connection OK!")
Case "PDP DEACT"
Me.WriteToConsole("GPRS/CSD context was deactivated because of unknown reason. Reconnecting!" + vbCrLf)
record.WriteLine("GPRS/CSD context was deactivated because of unknown reason. Reconnecting!")
If Not InStr(MessPull.ExecuteAT(SerialPortA, "AT+QIACT", 1000, "OK|ERROR"), "OK") > 0 Then
Me.WriteToConsole("Can't Activate GPRS/CSD context! Next Attempt!" + vbCrLf)
record.WriteLine("Can't Activate GPRS/CSD context! Next Attempt!")
End If
Case "TCP CONNECTING"
Sleep(800)
Case Else
Me.WriteToConsole("Connection status: " + sRet + vbCrLf)
record.WriteLine("Connection status: " + sRet)
End Select
Me.WriteToConsole("Connection status: " + sRet + vbCrLf)
Me.DisplayFunc()
End While
While (seansOpen And _allowRun)
MessPull.ClearMessage()
MessPull.ExecuteAT(SerialPortA, "AT+QISTAT")
timeSummary = 0
nSendAttemptA += 1
timeStart = Now
sRet = Trim(MessPull.ExecuteAT(SerialPortA, "AT+QISEND=8", 3000, ">", False))
'Me.WriteToConsole("Time execution AT+QISEND=8" + MessPull.LastTimeRun.ToString + vbCrLf)
If InStr(sRet, ">") > 0 Then
sRet = MessPull.ExecuteAT(SerialPortA, "balance$", 3000, "SEND OK", False)
'Me.WriteToConsole("Time execution [balance$]" + MessPull.LastTimeRun.ToString + vbCrLf)
If InStr(sRet, "SEND OK") > 0 Then
_nCharWait = 40
sRet = MessPull.WaitAnswer(SerialPortA, 10000, "balance>................................", , False)
If sRet = "balance>................................" Then
Me.WriteToConsole(vbCrLf)
timeStop = Now
tSpan = timeStop.Subtract(timeStart)
nTime = tSpan.TotalMilliseconds
timeSummary = tSpan.TotalMilliseconds
nMinTimeA = IIf(nMinTimeA = 0, nTime, IIf(nMinTimeA > nTime, nTime, nMinTimeA))
nMaxTimeA = IIf(nMaxTimeA = 0, nTime, IIf(nMaxTimeA < nTime, nTime, nMaxTimeA))
nEvgTimeA = IIf(nEvgTimeA = 0, nTime, (nTime + nEvgTimeA) / 2)
nSendSuccA += 1
' Теперь пытаемся выслать пакет
nSendAttemptB += 1
timeStart = Now
sRet = Trim(MessPull.ExecuteAT(SerialPortA, "AT+QISEND=440", 3000, ">", False))
'Me.WriteToConsole("Time execution AT+QISEND=440" + MessPull.LastTimeRun.ToString + vbCrLf)
If InStr(sRet, ">") > 0 Then
MessPull.ClearMessage()
_nCharWait = 4
sRet = MessPull.ExecuteAT(SerialPortA, sBlock440, 5000, "SEND OK", False)
If InStr(sRet, "SEND OK") > 0 Then
sRet = MessPull.WaitAnswer(SerialPortA, 10000, "done", , False)
If InStr(sRet, "done") > 0 Then
timeStop = Now
tSpan = timeStop.Subtract(timeStart)
nTime = tSpan.TotalMilliseconds
timeSummary = timeSummary + tSpan.TotalMilliseconds
nMinTimeB = IIf(nMinTimeB = 0, nTime, IIf(nMinTimeB > nTime, nTime, nMinTimeB))
nMaxTimeB = IIf(nMaxTimeB = 0, nTime, IIf(nMaxTimeB < nTime, nTime, nMaxTimeB))
nEvgTimeB = IIf(nEvgTimeB = 0, nTime, (nTime + nEvgTimeB) / 2)
nSendSuccB += 1
Me.WriteToConsole(vbCrLf)
Me.WriteToConsole("Cycle Ok. Time: " + timeSummary.ToString + vbCrLf)
record.WriteLine("Cycle Ok. Time: " + timeSummary.ToString)
timeSummaryMin = IIf(timeSummaryMin = 0, timeSummary,
IIf(timeSummaryMin > timeSummary, timeSummaryMin, timeSummaryMin))
timeSummaryMax = IIf(timeSummaryMax = 0, timeSummary,
IIf(timeSummaryMax < timeSummary, timeSummary, timeSummaryMax))
timeSummaryEvg = IIf(timeSummaryEvg = 0, timeSummary, (timeSummary + timeSummaryEvg) / 2)
Else
nLostPackB += 1
Me.WriteToConsole("Not Answer (440 byte). Time: " + nTime.ToString + vbCrLf)
record.WriteLine("Not Answer (440 byte). Time: " + nTime.ToString)
End If
Else
Me.WriteToConsole("Unsuccessfully send Data Pack (440 byte). Time: " + nTime.ToString + vbCrLf)
record.WriteLine("Unsuccessfully send Data Pack (440 byte). Time: " + nTime.ToString)
End If
Else
timeStop = Now
tSpan = timeStop.Subtract(timeStart)
nTime = tSpan.TotalMilliseconds
Me.WriteToConsole("Error execute command AT+QISEND=440. Time: " + nTime.ToString + vbCrLf)
record.WriteLine("Error execute command AT+QISEND=440. Time: " + timeSummary.ToString)
End If
Else
timeStop = Now
tSpan = timeStop.Subtract(timeStart)
nTime = tSpan.TotalMilliseconds
nLostPackA += 1
Me.WriteToConsole("Unsuccessfully execute command [balance$]. Time: " + nTime.ToString + vbCrLf)
record.WriteLine("Unsuccessfully execute command [balance$]. Time: " + nTime.ToString)
End If
Else
Me.WriteToConsole("Unsuccessfully send command [balance$]. Time: " + nTime.ToString + vbCrLf)
record.WriteLine("Unsuccessfully send command [balance$]. Time: " + nTime.ToString)
MessPull.ExecuteAT(SerialPortA, "AT", 3000, "")
MessPull.ExecuteAT(SerialPortA, "AT", 3000, "")
timeStop = Now
tSpan = timeStop.Subtract(timeStart)
nTime = tSpan.TotalMilliseconds
End If
Else
MessPull.ExecuteAT(SerialPortA, "AT", 3000, "")
Me.WriteToConsole("Error execute command AT+QISEND=8!" + vbCrLf)
record.WriteLine("Error execute command AT+QISEND=8!")
End If
MessPull.SetFuncValue("CounterA", nSendAttemptA.ToString)
MessPull.SetFuncValue("CounterB", nSendAttemptB.ToString)
MessPull.SetFuncValue("AverageTimeA", nEvgTimeA.ToString)
MessPull.SetFuncValue("AverageTimeB", nEvgTimeB.ToString)
Me.DisplayFunc()
If Not MessPull.GetFuncValue("STATE") = "CONNECT OK" Then
nLostConnect += 1
seansOpen = False
Me.WriteToConsole("Connection lost at: " + DateTime.Now.ToLongTimeString + vbCrLf)
record.WriteLine("Connection lost at: " + DateTime.Now.ToLongTimeString)
Me.WriteToConsole("Attempt to reconnect." + vbCrLf)
record.WriteLine("Attempt to reconnect.")
End If
Sleep(2000)
End While
End While
MessPull.ExecuteAT(SerialPortA, "AT+QICLOSE", 5000, "CLOSE OK|ERROR")
MessPull.ExecuteAT(SerialPortA, "AT+QIDEACT", 5000, "DEACT OK|ERROR")
Me.WriteToConsole("Connection Closed and GPRS/CSD context was deactivated at: " + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
record.WriteLine("Connection Closed and GPRS/CSD context was deactivated at: " + DateTime.Now.ToLongTimeString + "!")
Me.WriteToConsole("---------------------------------------------------------------------------------------------" + vbCrLf)
record.WriteLine("---------------------------------------------------------------------------------------------")
Me.WriteToConsole("Execution repport:" + vbCrLf)
record.WriteLine("Execution repport:")
Me.WriteToConsole("[balance$] request MIN time (milliseconds): " + nMinTimeA.ToString + vbCrLf)
record.WriteLine("[balance$] request MIN time (milliseconds): " + nMinTimeA.ToString)
Me.WriteToConsole("[balance$] request MAX time (milliseconds): " + nMaxTimeA.ToString + vbCrLf)
record.WriteLine("[balance$] request MAX time (milliseconds): " + nMaxTimeA.ToString)
Me.WriteToConsole("[balance$] request AVERAGE time (milliseconds): " + nEvgTimeA.ToString + vbCrLf)
record.WriteLine("[balance$] request AVERAGE time (milliseconds): " + nEvgTimeA.ToString)
Me.WriteToConsole(vbCrLf)
record.WriteLine("")
Me.WriteToConsole("[440 byte pack] request MIN time (milliseconds): " + nMinTimeB.ToString + vbCrLf)
record.WriteLine("[440 byte pack] request MIN time (milliseconds): " + nMinTimeB.ToString)
Me.WriteToConsole("[440 byte pack] request MAX time (milliseconds): " + nMaxTimeB.ToString + vbCrLf)
record.WriteLine("[440 byte pack] request MAX time (milliseconds): " + nMaxTimeB.ToString)
Me.WriteToConsole("[440 byte pack] request AVERAGE time (milliseconds): " + nEvgTimeB.ToString + vbCrLf)
record.WriteLine("[440 byte pack] request AVERAGE time (milliseconds): " + nEvgTimeB.ToString)
Me.WriteToConsole(vbCrLf)
record.WriteLine("")
Me.WriteToConsole("Summary request MIN time (milliseconds): " + timeSummaryMin.ToString + vbCrLf)
record.WriteLine("Summary request MIN time (milliseconds): " + timeSummaryMin.ToString)
Me.WriteToConsole("Summary request MAX time (milliseconds): " + timeSummaryMax.ToString + vbCrLf)
record.WriteLine("Summary request MAX time (milliseconds): " + timeSummaryMax.ToString)
Me.WriteToConsole("Summary request AVERAGE time (milliseconds): " + timeSummaryEvg.ToString + vbCrLf)
record.WriteLine("Summary request AVERAGE time (milliseconds): " + timeSummaryEvg.ToString)
Me.WriteToConsole(vbCrLf)
record.WriteLine("")
Me.WriteToConsole("Total send attempt command [balance$]: " + nSendAttemptA.ToString + vbCrLf)
record.WriteLine("Total send attempt command [balance$]: " + nSendAttemptA.ToString)
Me.WriteToConsole("Total send attempt packet [440 byte]: " + nSendAttemptB.ToString + vbCrLf)
record.WriteLine("Total send attempt packet [440 byte]: " + nSendAttemptB.ToString)
Me.WriteToConsole("Total send succes [balance$]: " + nSendSuccA.ToString + vbCrLf)
record.WriteLine("Total send succes [balance$]: " + nSendSuccA.ToString)
Me.WriteToConsole("Total send succes [440 byte]: " + nSendSuccB.ToString + vbCrLf)
record.WriteLine("Total send succes [440 byte]: " + nSendSuccB.ToString)
Me.WriteToConsole(vbCrLf)
record.WriteLine("")
Me.WriteToConsole("Lost packet [balanse$]: " + nLostPackA.ToString + vbCrLf)
record.WriteLine("Lost packet [balanse$]: " + nLostPackA.ToString)
Me.WriteToConsole("Lost packet [440 byte]: " + nLostPackB.ToString + vbCrLf)
record.WriteLine("Lost packet [440 byte]: " + nLostPackB.ToString)
Me.WriteToConsole("---------------------------------------------------------------------------------------------" + vbCrLf)
record.WriteLine("---------------------------------------------------------------------------------------------")
Me.WriteToConsole("Script stopped at: " + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
record.WriteLine("Script stopped at: " + DateTime.Now.ToLongTimeString + "!")
record.Close()
'Восстановим состояние модема
If Not serialStatus Then
SerialPortA.Close()
End If
'Разрешим эхо в консоли
_allowEcho = True
End Sub
Private Sub InitialIpSession()
Dim sTemp As String
' Select a context as foreground context AT+QIFGCNT=1
sTemp = MessPull.ExecuteAT(SerialPortA, "AT+QIFGCNT=1", 3000)
If sTemp = "OK" Then
Me.WriteToConsole(sTemp + vbCrLf)
Else
Me.WriteToConsole("AT+QIFGCNT=1 Returns ERROR. Script stopped at:" + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
_allowRun = False
'Exit While
End If
'AT+QICSGP=1,"inet.bwc.ru"
sTemp = MessPull.ExecuteAT(SerialPortA, "AT+QICSGP=1,""inet.bwc.ru""", 3000)
If sTemp = "OK" Then
Me.WriteToConsole(sTemp + vbCrLf)
Else
Me.WriteToConsole("AT+QICSGP Returns ERROR. Script stopped at:" + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
_allowRun = False
'Exit While
End If
'AT+QIMUX=0
sTemp = MessPull.ExecuteAT(SerialPortA, "AT+QIMUX=0", 3000)
If sTemp = "OK" Then
Me.WriteToConsole(sTemp + vbCrLf)
Else
Me.WriteToConsole("AT+QIMUX=0 Returns ERROR. Script stopped at:" + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
_allowRun = False
'Exit While
End If
'AT+QIMODE=0
sTemp = MessPull.ExecuteAT(SerialPortA, "AT+QIMUX=0", 3000)
If sTemp = "OK" Then
Me.WriteToConsole(sTemp + vbCrLf)
Else
Me.WriteToConsole("AT+QIMODE=0 Returns ERROR. Script stopped at:" + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
_allowRun = False
'Exit While
End If
'AT+QIDNSIP=0
sTemp = MessPull.ExecuteAT(SerialPortA, "AT+QIDNSIP=0", 3000)
If sTemp = "OK" Then
Me.WriteToConsole(sTemp + vbCrLf)
Else
Me.WriteToConsole("AT+QIDNSIP=0 Returns ERROR. Script stopped at:" + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
_allowRun = False
'Exit While
End If
'AT+QIREGAPP
sTemp = MessPull.ExecuteAT(SerialPortA, "AT+QIREGAPP", 3000)
If sTemp = "OK" Then
Me.WriteToConsole(sTemp + vbCrLf)
Else
Me.WriteToConsole("AT+QIREGAPP Returns ERROR. Script stopped at:" + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
_allowRun = False
'Exit While
End If
'AT+QIACT
sTemp = MessPull.ExecuteAT(SerialPortA, "AT+QIACT", 3000)
If sTemp = "OK" Then
Me.WriteToConsole(sTemp + vbCrLf)
Else
Me.WriteToConsole("AT+QIACT Returns ERROR. Script stopped at:" + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
_allowRun = False
'Exit While
End If
'AT+QILOCIP
sTemp = MessPull.ExecuteAT(SerialPortA, "AT+QILOCIP", 3000)
If sTemp = "OK" Then
Me.WriteToConsole(sTemp + vbCrLf)
Else
Me.WriteToConsole("AT+QILOCIP Returns ERROR. Script stopped at:" + DateTime.Now.ToLongTimeString + "!" + vbCrLf)
_allowRun = False
'Exit While
End If
End Sub
'Возвращает последнюю цифру в из строки цифровых значений разделенных запятой
Private Function GetLastValue(ByVal sParam As String) As Integer
Dim aLine As String() = sParam.Split(",".ToCharArray)
GetLastValue = Int(aLine(UBound(aLine)))
End Function
' Тестовая функция, выводит все значения возвращаемых AT-функций в консоль принытых данных
Private Sub DisplayFunc()
Dim enumFunc As IDictionaryEnumerator = MessPull.FuncTable.GetEnumerator
Me.WriteToRecieved("Function parametr list:" + vbCrLf, True)
enumFunc.Reset()
While enumFunc.MoveNext
Me.WriteToRecieved(enumFunc.Key + "=" + enumFunc.Value.ToString + vbCrLf)
End While
End Sub
' Parse string
Private Function StringParse(ByVal sText As String, Optional ByVal sParser As String = " ") As String()
Dim sParam As Char() = sParser.ToCharArray()
StringParse = {}
If sText.Length > 0 Then
StringParse = sText.Split(sParam)
End If
End Function
Private Sub LoadKeyWord()
Dim htKeyWord As Hashtable
Dim aKeyToken As System.Delegate()
'aKeyToken.A()
htKeyWord = aScript(scNames.scKeyWord)
htKeyWord.Add("IF", 0)
End Sub
Private Sub SendToModem(ByVal sText)
If SerialPortA.IsOpen Then
SerialPortA.WriteLine(sText)
Else
TextBoxM.AppendText("Serial port: " + SerialPortA.PortName + " Is closed. Script Aborted!")
_allowRun = False
End If
End Sub
#End Region
#Region "Event Handler's"
' Procedure handler recept any change in TextBoxM. Send command string to COM-port
Private Sub TextBoxM_TextChanged(sender As System.Object, e As System.EventArgs) Handles TextBoxM.TextChanged
Dim LineNum As Integer
LineNum = Me.TextBoxM.Lines.Length
If LineNum > 1 Then
If (LineNum > _lineCount) Then
If _readPort Then
If SerialPortA.IsOpen Then
_lastLine = Me.TextBoxM.Lines(LineNum - 2)
_lastLine = Trim(_lastLine)
SerialPortA.WriteLine(_lastLine + vbCrLf)
Else
_readPort = False
Me.TextBoxM.AppendText("Serial port " + SerialPortA.PortName + " serial port is closed, open it first!" + vbCrLf)
End If
Else
_readPort = True
End If
_lineCount = Me.TextBoxM.Lines.Length
End If
Else
_lineCount = Me.TextBoxM.Lines.Length
End If
End Sub
' Clear text in TextBoxM on button click
Private Sub BtClearText_Click(sender As System.Object, e As System.EventArgs) Handles BtClearText.Click
TextBoxM.Clear()
TextBoxM.Refresh()
_lineCount = 0
End Sub
' Change port Name on ComboBox changes
Private Sub ComboBoxCOM_List_SelectedIndexChanged(sender As System.Object, e As System.EventArgs) Handles ComboBoxCOM_List.SelectedIndexChanged
If _continue Then
Call Refresh_COMSetting()
TSLabelCOM.Text = ComboBoxCOM_List.Text
SerialPortA.PortName = ComboBoxCOM_List.Text
End If
End Sub
' Change port Parity on ComboBox changes
Private Sub ComboBox_ParityList_SelectedIndexChanged(sender As System.Object, e As System.EventArgs) Handles ComboBox_ParityList.SelectedIndexChanged
If _continue Then
Try
SerialPortA.Parity = ComboBox_ParityList.SelectedIndex
Catch ex As Exception
'None
MsgBox("Can't set selected parity." + vbCrLf, MsgBoxStyle.Exclamation, AcceptButton)
End Try
End If
End Sub
' Change port Baud Rate on ComboBox changes
Private Sub ComboBox_BaudList_SelectedIndexChanged(sender As System.Object, e As System.EventArgs) Handles ComboBox_BaudList.SelectedIndexChanged
If _continue Then
SerialPortA.BaudRate = Int(ComboBox_BaudList.Text)
TSLabelSpeed.Text = ComboBox_BaudList.Text
End If
End Sub
' Change port Data Bits on ComboBox changes
Private Sub ComboBox_DataBits_SelectedIndexChanged(sender As System.Object, e As System.EventArgs) Handles ComboBox_DataBits.SelectedIndexChanged
If _continue Then
SerialPortA.DataBits = Int(ComboBox_DataBits.Text)
End If
End Sub
' Change port Stop Bits on ComboBox changes
Private Sub ComboBox_StopBits_SelectedIndexChanged(sender As System.Object, e As System.EventArgs) Handles ComboBox_StopBits.SelectedIndexChanged
If _continue Then
SerialPortA.StopBits = ComboBox_StopBits.SelectedIndex
End If
End Sub
' Change port Handshake on ComboBox changes
Private Sub ComboBox_FlowControl_SelectedIndexChanged(sender As System.Object, e As System.EventArgs) Handles ComboBox_FlowControl.SelectedIndexChanged
If _continue Then
SerialPortA.Handshake = ComboBox_FlowControl.SelectedIndex
End If
End Sub
' Check COM port setting & write text to TextBox
Private Sub BTCheck_Click(sender As System.Object, e As System.EventArgs) Handles BTCheck.Click
TextBox1.AppendText("Serial port name: " + SerialPortA.PortName + vbCrLf)
'TextBox1.AppendText("Serial port num: " + Str(_serialPort.PortName) + vbCrLf)
TextBox1.AppendText("Serial port status: " + IIf(SerialPortA.IsOpen, "Port Open", "Port Closed") + vbCrLf)
TextBox1.AppendText("Baud Rate: " + SerialPortA.BaudRate.ToString + vbCrLf)
TextBox1.AppendText("Parity: " + SerialPortA.Parity.ToString + vbCrLf)
TextBox1.AppendText("Parity Num: " + Str(SerialPortA.Parity) + vbCrLf)
TextBox1.AppendText("Data Bits: " + SerialPortA.DataBits.ToString + vbCrLf)
TextBox1.AppendText("Stop Bits: " + SerialPortA.StopBits.ToString + vbCrLf)
TextBox1.AppendText("Flow Control: " + SerialPortA.Handshake.ToString + vbCrLf)
TextBox1.AppendText("Read Timeout: " + SerialPortA.ReadTimeout.ToString + vbCrLf)
TextBox1.AppendText("Write Timeout: " + SerialPortA.WriteTimeout.ToString + vbCrLf)
TextBox1.AppendText("-------------------------" + vbCrLf + vbCrLf)
End Sub
' Clear text recieved in TextBox
Private Sub BTClearRecieved_Click(sender As System.Object, e As System.EventArgs) Handles BTClearRecieved.Click
TextBox_Recieved.Clear()
_lastRead = ""
End Sub
' Event handlers on form close.
Private Sub CommCare_FormClosed(sender As System.Object, e As System.Windows.Forms.FormClosedEventArgs) Handles MyBase.FormClosed
If SerialPortA.IsOpen Then SerialPortA.Close()
End Sub
' Open/Close serial port
Private Sub BtSerial_Click(sender As System.Object, e As System.EventArgs) Handles BtSerial.Click
If SerialPortA.IsOpen Then
Try
SerialPortA.DiscardInBuffer()
SerialPortA.DiscardOutBuffer()
SerialPortA.Close()
Catch ex As Exception
End Try
TSLastCommand.Text = "Serial port: " + SerialPortA.PortName.ToString + " closed!"
BtSerial.Text = "Open Port"
Else
Try
SerialPortA.Open()
SerialPortA.ReadTimeout = 1000
SerialPortA.WriteTimeout = 1000
If SerialPortA.IsOpen Then
BtSerial.Text = "Close Port"
TSLastCommand.Text = "Serial port: " + SerialPortA.PortName.ToString + " open successfully!"
Else
BtSerial.Text = "Open Port"
TSLastCommand.Text = "Can't open serial port: " + SerialPortA.PortName.ToString
End If
Catch ex As Exception
End Try
End If
End Sub
' Save COM port setting on menu click
Private Sub SaveSettingToolStripMenuItem_Click(sender As System.Object, e As System.EventArgs) Handles SaveSettingToolStripMenuItem.Click
Dim saveDialog As New SaveFileDialog
Dim fName As String
saveDialog.InitialDirectory = Application.StartupPath
saveDialog.Filter = "INI Files (*.ini)|*.ini"
saveDialog.FileName = "Setting.ini"
If saveDialog.ShowDialog = Windows.Forms.DialogResult.Cancel Then Exit Sub
fName = saveDialog.InitialDirectory & "\" & saveDialog.FileName
Call WriteConfig(fName)
End Sub
' Save at-protocol text from TextBox to file
Private Sub SaveATProtocolToolStripMenuItem_Click(sender As System.Object, e As System.EventArgs) Handles SaveATProtocolToolStripMenuItem.Click
Dim saveDialog As New SaveFileDialog
saveDialog.InitialDirectory = Application.StartupPath
saveDialog.Filter = "Log Files (*.log)|*.log|All Files (*.*)|*.*"
saveDialog.FileName = "CommCare.log"
If saveDialog.ShowDialog = Windows.Forms.DialogResult.Cancel Then Exit Sub
Dim record As New StreamWriter(saveDialog.FileName)
record.Write(TextBoxM.Text)
record.Close()
End Sub
' Load at-protocol text into TextBox from file
Private Sub LoapATProtocolToolStripMenuItem_Click(sender As System.Object, e As System.EventArgs) Handles LoapATProtocolToolStripMenuItem.Click
Dim openDialog As New OpenFileDialog
openDialog.InitialDirectory = Application.StartupPath
openDialog.Filter = "Log Files (*.log)|*.log|All Files (*.*)|*.*"
openDialog.FileName = "CommCare.log"
If openDialog.ShowDialog = Windows.Forms.DialogResult.Cancel Then Exit Sub
Dim read As New StreamReader(openDialog.FileName)
TextBoxM.Text = read.ReadToEnd.ToString
read.Close()
End Sub
' Load form Events. Proceed initialisation
Private Sub CommCare_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
Dim fName, defParam, retParam As String
_lastRead = "" ' Empty _lastRead
_allowEcho = True ' Permit echo the received data handler
CB_DataRecived.Checked = False ' Set visual data recieved check
' Collect serial port info adn declare it
_continue = False ' prevent reactions to fill ComboBox
SerialPortA = New SerialPort() ' Create serial port object
' Define handler to recieved data
AddHandler SerialPortA.DataReceived, AddressOf DataReceviedHandler
'SerialPortA.ReadTimeout = 1000 ' set Read timeout 1000mS
'SerialPortA.WriteTimeout = 1000 ' set Write timeout 1000mS
Call CollectCOMM_List() ' Collect COM port Names
' Set port name first line ComboBox
SerialPortA.PortName = ComboBoxCOM_List.Text
Call Refresh_COMSetting() ' Collect the remaining serial port settings
' Complete fragments of the status bar
TSLabelSpeed.Text = ComboBox_BaudList.Text
TSLabelCOM.Text = ComboBoxCOM_List.Text
_readPort = True ' Allow the reaction to the emergence of a new line in TextBoxM
' Read default config file
fName = Application.StartupPath & "\Default.ini"
Call LoadConfig(fName)
_continue = True ' Allow the reaction to changes in the ComboBox's
WritePrivateProfileString("INTERNAL", "ScriptSaved", "No", fName)
WritePrivateProfileString("INTERNAL", "ScriptSaved", "No", fName)
'
TextBox_Recieved.ReadOnly = True
End Sub
' Close form events. Execute finishing action
Private Sub CommCare_FormClosing(sender As System.Object, e As System.Windows.Forms.FormClosingEventArgs) Handles MyBase.FormClosing
Dim fName As String
fName = Application.StartupPath & "\Default.ini"
Call WriteConfig(fName)
If Not (ScriptThread.ThreadState = Threading.ThreadState.Unstarted) Then
ScriptThread.Abort()
ScriptThread.Join(1000)
End If
End Sub
' Load COM port setting from file
Private Sub OpenSettingToolStripMenuItem_Click(sender As System.Object, e As System.EventArgs) Handles OpenSettingToolStripMenuItem.Click
Dim openDialog As New OpenFileDialog
Dim fName As String
openDialog.InitialDirectory = Application.StartupPath
openDialog.Filter = "INI Files (*.ini)|*.ini"
openDialog.FileName = "Setting.ini"
If openDialog.ShowDialog = Windows.Forms.DialogResult.Cancel Then Exit Sub
fName = openDialog.InitialDirectory & "\" & openDialog.FileName
_continue = False
Call LoadConfig(fName)
_continue = True
End Sub
' Test button Parse click. Go parse testing string
Private Sub BT_Parse_Click(sender As System.Object, e As System.EventArgs) Handles BT_Parse.Click
Dim words() As String
Dim word As String
Dim textStr As String
Dim delim As Char()
Dim parseString As String
parseString = TB_InStr.Text
textStr = TB_Delimiters.Text
delim = textStr.ToCharArray()
words = parseString.Split(delim, StringSplitOptions.RemoveEmptyEntries)
For Each word In words
TB_Console.AppendText(word + vbCrLf)
Next
End Sub
' Test button Clear click. Clear TextBox text.
Private Sub BT_Clear_Click(sender As System.Object, e As System.EventArgs) Handles BT_Clear.Click
TB_Console.Clear()
End Sub
' CheckBox prevent manually changes
Private Sub CB_DataRecived_CheckedChanged(sender As System.Object, e As System.EventArgs) Handles CB_DataRecived.CheckedChanged
CB_DataRecived.Checked = MessPull.MessageRecieved
End Sub
' Load token from file
Private Sub LoadTokenToolStripMenuItem_Click(sender As System.Object, e As System.EventArgs) Handles LoadTokenToolStripMenuItem.Click
Dim openDialog As New OpenFileDialog
openDialog.InitialDirectory = Application.StartupPath
openDialog.Filter = "Token Files (*.tok)|*.tok|All Files (*.*)|*.*"
'openDialog.FileName = "Default.tok"
If openDialog.ShowDialog = Windows.Forms.DialogResult.Cancel Then Exit Sub
Call LoadToken(openDialog.FileName)
WritePrivateProfileString("SCRIPT", "TokenFileName", openDialog.FileName, Application.StartupPath & "\Default.ini")
End Sub
' Menu File-Exit
Private Sub ExitToolStripMenuItem_Click(sender As System.Object, e As System.EventArgs) Handles ExitToolStripMenuItem.Click
Application.Exit()
End Sub
' Script Save to file
Private Sub SaveTaskScriptToolStripMenuItem_Click(sender As System.Object, e As System.EventArgs) Handles SaveTaskScriptToolStripMenuItem.Click
Dim saveDialog As New SaveFileDialog
saveDialog.InitialDirectory = Application.StartupPath
saveDialog.Filter = """Go"" Script Files (*.gos)|*.gos|All Files (*.*)|*.*"
saveDialog.FileName = "Noname.gos"
If saveDialog.ShowDialog = Windows.Forms.DialogResult.Cancel Then Exit Sub
Dim record As New StreamWriter(saveDialog.FileName)
record.Write(TextBox_Script.Text)
record.Close()
WritePrivateProfileString("INTERNAL", "ScriptSaved", "Yes", Application.StartupPath & "\Default.ini")
WritePrivateProfileString("INTERNAL", "ScriptFile", saveDialog.FileName, Application.StartupPath & "\Default.ini")
End Sub
' Script Load from file
Private Sub LoadTaskScriptToolStripMenuItem_Click(sender As System.Object, e As System.EventArgs) Handles LoadTaskScriptToolStripMenuItem.Click
Dim openDialog As New OpenFileDialog
openDialog.InitialDirectory = Application.StartupPath
openDialog.Filter = """Go"" Script Files (*.gos)|*.gos|All Files (*.*)|*.*"
'openDialog.FileName = "CommCare.gos"
If openDialog.ShowDialog = Windows.Forms.DialogResult.Cancel Then Exit Sub
Dim read As New StreamReader(openDialog.FileName)
TextBox_Script.Text = read.ReadToEnd.ToString
read.Close()
WritePrivateProfileString("INTERNAL", "ScriptLoaded", "Yes", Application.StartupPath & "\Default.ini")
WritePrivateProfileString("INTERNAL", "ScriptFile", openDialog.FileName, Application.StartupPath & "\Default.ini")
End Sub
' Auto load script check/uncheck
Private Sub AutoLoadScriptToolStripMenuItem_Click(sender As System.Object, e As System.EventArgs) Handles AutoLoadScriptToolStripMenuItem.Click
AutoLoadScriptToolStripMenuItem.Checked = True
WritePrivateProfileString("INTERNAL", "ScriptAutoLoad", "Yes", Application.StartupPath & "\Default.ini")
End Sub
#End Region
#Region "COM port Handler's"
Private Sub DataReceviedHandler(sender As Object, e As SerialDataReceivedEventArgs)
Dim sp As SerialPort = CType(sender, SerialPort)
Dim aLine As String()
Dim nAt As Integer
Dim sParam As Char()
Dim sTemp As String
Dim indata As String = ""
indata = sp.ReadExisting()
'
sTemp = vbCrLf
sParam = sTemp.ToCharArray()
'
_lastRead = _lastRead + indata
'If _lastRead.Length > 1 Then
'If _lastRead = "> " Then
'MessPull.AppendMess(Trim(_lastRead))
'_lastRead = ""
'End If
'End If
nAt = InStr(_lastRead, vbCrLf)
While nAt > 0
MessPull.AppendMess(Mid(_lastRead, 1, nAt - 1))
_lastRead = Mid(_lastRead, nAt + 2)
nAt = InStr(_lastRead, vbCrLf)
End While
If (_nCharWait > 0) And (_lastRead.Length = _nCharWait) Then
MessPull.AppendMess(Trim(_lastRead))
_lastRead = ""
_nCharWait = 0
ElseIf _lastRead = "> " Then
MessPull.AppendMess(Trim(_lastRead))
_lastRead = ""
End If
'If nAt > 0 Then
'aLine = _lastRead.Split(sParam, StringSplitOptions.RemoveEmptyEntries)
'If aLine.Length > 0 Then
'MsPull.AppendLines(aLine)
'_lastRead = ""
'End If
'End If
'
If _allowEcho Then
Call Me.WriteToConsole(indata)
End If
End Sub
#End Region
Private Sub BTRunStop_Click(sender As System.Object, e As System.EventArgs) Handles BTRunStop.Click
If _allowRun Then
_allowRun = False
BTRunStop.Text = "Run Script"
Else
_lastRead = ""
CB_DataRecived.Checked = MessPull.MessageRecieved
_allowRun = True
BTRunStop.Text = "Stop Script"
ScriptThread = New Thread(AddressOf RunScript)
TimerA.Interval = 10000
TimerA.Enabled = True
_timeOut = False
ScriptThread.Start()
End If
End Sub
Private Sub TimerA_Tick(sender As System.Object, e As System.EventArgs) Handles TimerA.Tick
If Not _timeOut Then _timeOut = True
End Sub
Private Sub BTTestMsg1_Click(sender As System.Object, e As System.EventArgs) Handles BTTestMsg1.Click
Dim nCount As Integer = MessPull.AppendMess(TB_InStr.Text)
TSLastCommand.Text = "Message count: " + Str(nCount)
End Sub
Private Sub BTTestMsg2_Click(sender As System.Object, e As System.EventArgs) Handles BTTestMsg2.Click
Dim sText As String = TB_InStr.Text
Dim sParam As String = " ,.;:!@#$%&*()-=+|\/?<>"
Dim aParam As Char() = sParam.ToCharArray()
TSLastCommand.Text = "Message count: " + Str(MessPull.AppendLines(sText.Split(aParam, StringSplitOptions.RemoveEmptyEntries)))
End Sub
Private Sub BTTestMsg3_Click(sender As System.Object, e As System.EventArgs) Handles BTTestMsg3.Click
Dim alines As String() = MessPull.Items()
Dim sText As String
For Each sText In alines
TB_Console.AppendText(sText + vbCrLf)
Next
End Sub
Private Sub BTTestMsg4_Click(sender As System.Object, e As System.EventArgs) Handles BTTestMsg4.Click
TB_InStr.Text = MessPull.ExtractMess()
TSLastCommand.Text = "Message count: " + Str(MessPull.MsgCount())
End Sub
Private Sub BTTestMsgClear_Click(sender As System.Object, e As System.EventArgs) Handles BTTestMsgClear.Click
MessPull.ClearMessage()
End Sub
Private Sub TextBoxBearer_TextChanged(sender As System.Object, e As System.EventArgs) Handles TextBoxBearer.TextChanged
_QICSGP = TextBoxBearer.Text
End Sub
Private Sub TextBoxIP_TextChanged(sender As System.Object, e As System.EventArgs) Handles TextBoxIP.TextChanged
_QIOPEN = TextBoxIP.Text
End Sub
End Class
```
Всем наилучшего! Если вы найдете в исходном коде для себя полезные фрагменты — буду рад что оказался полезен! | https://habr.com/ru/post/180023/ | null | ru | null |
# Бот, играющий в Castlevania
Что это
=======
CastlevaniaBot — это плагин для [эмулятора NES Nintaco](https://nintaco.com/), который играет в Castlevania. Если запустить его на экране заставки, то плагин пройдёт всю игру от начала до конца. Или же можно запустить его в любом месте игры, чтобы он прошёл её часть.
В этой статье я расскажу, как создал бота, способного пройти Castlevania, и как вы можете создать нечто подобное для любой игры на NES.
---
Структура на основе знания
==========================
В этом проекте не использовалось машинное обучение. Скорее, разработку можно назвать «научением машины». Я знаю, как проходить Castlevania. Сложность заключалась в том, чтобы записать моё знание в компьютерную программу. Результатом стала система, симулирующая тот же процесс принятия решений, который выполняю я с контроллером в руках. Для её создания необходимо было чётко изложить подробные детали физики, управляющей битовым миром Саймона Бельмонта, и всех тактик, необходимых опытному охотнику на вампиров.
У CastlevaniaBot есть доступ к набору стратегий, позволяющих справляться с широким диапазоном ситуаций. Большинство из них предназначено для работы с конкретным типом игровых объектов. Например, существует стратегия борьбы со скелетами, ещё одна для людей-рыб, для разбивания свечей, для собирания сердец, и так далее.
CastlevaniaBot постоянно отслеживает состояние игры и по необходимости переключается между разными стратегиями. В процессе принятия решений используется функция приспособленности, ранжирующая все находящиеся на экране игровые объекты. На вершине списка находится основная цель, а когда она меняется, бот меняет стратегию. Например, CastlevaniaBot может готовиться ударить по свечам, когда в кадр влетает летучая мышь. В зависимости от расстояния до летучей мыши CastlevaniaBot может отреагировать, переключившись со стратегии свечей на стратегию летучих мышей. Уничтожив летучую мышь, он продолжит работать со свечами.
Перед принятием решения о переключении CastlevaniaBot рассматривает текущую цель и стратегию. Если ему это не удастся, он может застрять в бесконечном цикле, переключаясь туда и обратно между двумя целями с равным или почти равным приоритетом. Чтобы избежать этого, при появлении новой основной цели, которая только слегка выше по приоритету текущей цели, CastlevaniaBot может решить продолжить текущую стратегию.
Некоторые стратегии автоматически запускаются при попадании в определённую область. Обычно они предназначены для одновременной обработки нескольких игровых объектов. Например, в коридоре с кучей летающих голов медуз лучше всего просто идти вперёд, а не целиться в каждую голову по отдельности.
Некоторые стратегии могут изменяться в зависимости от текущего вторичного оружия и количества собранных сердец, в частности, в боях с боссами. CastlevaniaBot пытается принять наилучшее решение на основании имеющихся у него инструментов и текущей ситуации.
---
Составление плана 8-битного мира
================================
При работе над подобными проектами я в первую очередь стремлюсь упростить задачу. Я представил, на что была бы похожа Castlevania, если бы на уровнях не было врагов, свечей и собираемых предметов. Всё, что в таком случае было бы нужно — просто дойти от начала до конца уровня. Я задался вопросом — если мне удастся научить бота это делать, то насколько сложно будет уничтожить по пути несколько врагов?
Чтобы научить бота двигаться, мне нужны были тайловые карты фонов и понимание того, как организованы уровни. Игра состоит из шести уровней, каждый из которых заканчивается боссом.
Каждый уровень разделён на 3 или 4 этапа. Этапы обычно разделены деревянными дверями, которые со скрипом открываются и захлопываются за спиной игрока.
Двери являются контрольными точками (чекпоинтами). Если игрока убивают, то он возвращается к началу этапа, но только если у него не кончились жизни. Если продолжить игру после Game Over, то игрока отправляют в самое начало уровня.
Номер этапа обозначает общее количество чекпоинтов, пройденных с начала игры. Последний этап имеет номер 18. Но если убить Дракулу, то игра начинается с самого начала в сложном режиме (Difficult Mode), а номера этапов продолжают увеличиваться до 19 и дальше. Если пройти Difficult Mode, то третий цикл игры не становится сложнее, но номера этапов по-прежнему продолжают увеличиваться.
Каждый этап состоит из одной или более полосы фона с горизонтальным скроллингом, которые я называют «подэтапами». Если выйти за экран по ведущей вверх или вниз лестнице, то игра переходит от одного подэтапа к другому, а не скроллится вертикально.
Для отслеживания номера игрового цикла, номера этапа и номера подэтапа игра использует 3 байта. Игровой цикл в обычном режиме (Normal Mode) имеет значение 0; значения 1 и выше обозначают Difficult Mode. Вне зависимости от игрового цикла этапы всегда имеют нумерацию от 0 до 18. А подэтапы всегда имеют значение 0 или 1, потому что этапы никогда не содержат больше, чем 2 горизонтальных полосы. CastlevaniaBot отслеживает эти байты, чтобы знать, где он находится.
Для своего удобства я записал полосу фона каждого подэтапа в отдельный графический файл. Если мне необходимо было узнать точные координаты какого-то объекта, то я мог быстро их выяснить с помощью графического редактора. Файлы я записал с помощью встроенного в Nintaco инструмента Map Maker. Я включил его, а затем прошёл всю игру. Некоторые из получившихся изображений содержали соединённые вместе несколько подэтапов, которые было легко разбить на части.
Изучив изображения фонов, я понял, что единственными важными тайлами являются платформы и лестницы. Всё остальное можно считать пустым пространством. Лестницы бывают двух типов: ведущие вперёд или назад (их можно представить как левое и правое ребро равнобедренного треугольника). Иногда лестницы заканчиваются платформой, по которой может ходить игрок.
Существует всего 5 важных типов тайлов, и на каждом уровне они имеют разный внешний вид. Я скопировал и вставил их в отдельные графические файлы размером 16×16. Затем я написал программу, сравнивающую каждый тайл в каждом подэтапе с соответствующим набором изображений. Так я получил матрицы типов тайлов для всех подэтапов.
Матрицы можно было бы извлечь непосредственно из ROM, но я не смог найти документацию о том, как и где хранятся данные. Так как пространство ROM ограничено, данные уровней обычно представлены в сжатом виде, напоминающем формат векторной графики. В каждой игре используется собственный формат, поэтому я не посчитал необходимым проводить исследования, ведь у меня был Map Maker. Кроме того, мне всё равно были нужны графические изображения подэтапов. Если бы я не выполнил захват полос фонов, то мне бы пришлось писать программу, генерирующую изображения из матриц.
---
Поиск путей
===========
Создав матрицы, я захотел применить алгоритм поиска путей, а именно [алгоритм Флойда-Уоршелла](https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm), который даёт на выходе таблицу, содержащую кратчайшие пути между каждой из пар вершин ориентированного графа со взвешенными рёбрами. Идея заключалась в том, чтобы предварительно вычислить таблицы и записать их в файлы, а затем загрузить их в процессе выполнения игры. Имея таблицы в памяти, бот может выполнять поиск и мгновенно узнавать кратчайший путь между любыми двумя тайлами платформ.
Граф состоит из рёбер и вершин. Если тайлы платформ являются вершинами, то рёбра — это только те операции, которые может выполнять Саймон, чтобы перемещаться от одной платформы к другой. Операции, выполняемые в пределах только одного тайла, запрещены. Например, на плоскости из тайлов Саймон может переместиться только на один тайл влево или один тайл вправо.
Аналогично, если Саймон находится на лестнице, то он может перемещаться на один тайл в одном из двух возможных направлений.
Это допустимые операции. Но такие действия, как движение от средней точки тайла до края тайла оказываются слишком дробными, потому что они не соответствуют переходу из одной вершины графа в другую.
Кроме ходьбы влево-вправо, спуска-поднимания по ступенькам Саймон может перепрыгивать на другой тайл. И он может прыгать влево или вправо, начиная с любого из 16 пикселей поверхности тайла. Чтобы уменьшить количество рёбер в графе (и размер таблицы поиска) я рассматривал только пять возможных точек отталкивания:
Добавив операцию «ничего не делать», я получил 15 операций. Все они достаточно просты для того, чтобы бот мог легко определить последовательность нажатия кнопок, необходимое для их выполнения во время выполнения игры.
Чтобы построить полный граф, я создал очень простую симуляцию физики мира Саймона. В этой симуляции все 15 операций выполняются начиная с каждого тайла платформ. Граф строится простым наблюдением за тем, где окажется Саймон. Если конкретнее, то при задании начальных координат и операции симуляция даёт на выходе конечные координаты. Если конечных координат нет, например, когда Саймон пытается пройти в стену или в яму, то программа возвращает, что операция недопустима и это ребро не является частью графа.
Для создания этой симуляции потребовалось тщательное изучение Саймона Бельмонта. В отличие от других классических платформеров, где игрок может ускоряться от ходьбы к бегу, Саймон при движении по горизонтали всегда перемещается ровно на 1 пиксель за кадр. Это справедливо для ходьбы, прыжков, взбирания по лестницам и даже при отбрасывании назад при атаках врагов.
Ограничение горизонтальной скорости очень упрощает распознавание барьеров. Игра проверяет, есть ли стена в одном пикселе перед персонажем, и при необходимости останавливает движение. Проверка выполняется ниже уровня головы, что позволяет голове проходить под низкими потолками без помех горизонтальному движению.
С вертикальным движением всё немного сложнее. Если Саймон сходит с края платформы, он вместо постепенного ускорения мгновенно падает вниз со скоростью 8 пикселей на кадр. Так как каждый тайл имеет высоту 16 пикселей (что кратно 8), распознавание земли упрощается. Одновременно игрок сохраняет горизонтальную скорость в 1 пиксель на кадр в направлении, полученном непосредственно перед падением.
Ширина спрайта Саймона — 16 пикселей, и тем не менее, он может нависать над блоком максимум на ±4 пикселя от его средней точки. Если сдвинуться чуть больше, то он упадёт ниже.
Интересно, что если он сойдёт с платформы и упадёт ровно на 1 тайл со скоростью 1 горизонтальный и 8 вертикальных пикселей на кадр, то при приземлении не будет точно стоять на блоке. Одна из его ног будет оставаться внутри стены на глубину 2 пикселя.
После этого он сможет выйти из стены, но не зайти в неё.
Во время прыжка Саймон не может менять его направление. После нажатия на кнопку A он совершает фиксированный путь по параболе.
В верхней точке Саймон поднимается на 36 пикселей, что позволяет ему запрыгивать на платформы высотой 2 тайла. А вершина «параболы» на удивление плоская. Похоже, что он зависает в пространстве на 9 полных кадров, возможно для того, чтобы упростить удары хлыстом в воздухе. Если Саймону не на что приземлиться, то движение по параболе продолжается, пока он не вернётся на исходную высоту. После этого он начинает падать со скоростью 8 пикселей в кадр, то есть с той же постоянной скоростью падения с платформы.
Когда прямо над головой персонажа есть платформа, прыжки не допускаются.
В противном случае он частично «впрыгивает» в тайлы платформ.
Как говорилось раньше, если Саймон касается больше, чем верхушкой головы, он перестаёт двигаться по горизонтали. Это довольно раздражает в конце первого этапа уровня 4, когда игрок пытается выбраться из пещеры.
Лестницы позволяют свободно перемещаться по вертикали между платформами.
В одном из случаев Саймон поднимается по лестнице, проходя насквозь тайл платформы. Находясь на лестнице, он свободно может проходить через стену.
На подвижных платформах уровня 4 игрок обычно пригибается под низко висящими сталактитами. Однако можно подняться и упереться в них. В такой ситуации игра ограничивает горизонтальное движение, быстро утягивая Саймона в водную ловушку.
Симулятор физики, генерирующий ориентированные графы, считает Саймона прямоугольником. Движение этого прямоугольника ограничено описанными выше правилами перемещения. Чтобы бот не прыгал с места на место как кролик, рёбрам прыжков графа была назначена бОльшая стоимость, чем рёбрам ходьбы и движения по лестницам.
Таблица, сгенерированная алгоритмом поиска пути, содержит кратчайшее расстояние для каждого начального и конечного тайла (общую стоимость пути) и описание первого шага пути. В это описание входит первая операция, которую необходимо выполнить на этом пути, и тайл, на котором окажется персонаж после её выполнения. Весь путь можно воссоздать повторным поиском в таблице, каждый из которых даёт последующий шаг в направлении конечного тайла.
В некоторых подэтапах графы соединены не полностью. Например на уровне 4 единственным способом перебраться через пропасти являются платформы. В таких подэтапах таблица содержит способы перемещения по каждому из островов, но не между ними.
Внутри некоторых разрушаемых блоков содержатся скрытые предметы. И уничтожение блоков изменяет этот граф. Чтобы обойти эту проблему, к подэтапам был применён алгоритм поиска путей с разбиваемыми блоками и без них. Во время выполнения CastlevaniaBot наблюдает за состояниями разбиваемых блоков и использует соответствующую таблицу поиска.
---
Состояние игры
==============
CastlevaniaBot интегрируется в Nintaco через [его API](https://nintaco.com/api.html). Он регистрирует реализацию [`FrameListener`](https://nintaco.com/javadoc/index.html), чтобы получать в каждом кадре возврат. Так как эмулятор выполняется с частотой примерно 60 кадров в секунду, этот listener необходимо возвращать вовремя; длительные вычисления или простои замедлят или блокируют эмулятор. За короткий промежуток времени CastlevaniaBot считывает состояние игры, определяет свою основную цель, переключает стратегии, если цель изменилась и выполняет текущую стратегию.
CastlevaniaBot считывает текущее состояние Саймона Бельмонта непосредственно из ОЗУ процессора. Но я не могу определить, как представлены в памяти другие игровые объекты. Поэтому CastlevaniaBot выполняет считывание непосредственно из памяти атрибутов объектов (Object Attribute Memory, OAM) — области, хранящей список отображаемых спрайтов.
Эта техника работает и в общем случае применима к другим играм, но имеет множество недостатков. Порядок спрайтов в OAM постоянно меняется. Если на экране одновременно есть несколько экземпляров одного типа врага, то единственный способ отслеживать их — определение их близости, сопоставление последних координат спрайта с координатами из предыдущего кадра.
Некоторые игровые объекты состоят из повторяющихся спрайтов, например, костяные башни.
Подвижные платформы состоят из одного спрайта, повторяющегося 4 раза.
Для сортировки обоих этих случаев требуется дополнительная логика, которую реализовать совсем несложно. Апгрейды вторичного оружия и некоторые виды самого вторичного оружия используют одни и те же спрайты. Хуже того — на уровне 5 рыцари заимствуют спрайты вторичного оружия Саймона.
К счастью, за исключением святой воды, CastlevaniaBot использует вторичное оружие только там, где апгрейды обычно недоступны, например в боях с боссами. И спрайт апгрейда святой воды отличается от спрайта, используемого при её бросании.
Некоторые игровые объекты при создании мигают, например хрустальные шары в конце боёв с боссами, косы Смерти и тело Дракулы. Мигающие спрайты появляются и исчезают из OAM, поэтому для отслеживания этих объектов требуется дополнительная логика.
Также стоит заметить, что из-за аппаратных ограничений NES может отображать только 8 спрайтов на растровую строку. Так как приоритет спрайтов частично зависит от их индексов в OAM, порядок в каждом кадре произвольно перемешивается, чтобы избежать сдвига, делающего один спрайт невидимым постоянно. Несколько спрайтов мигает по очереди, постепенно изменяя свой приоритет. Это мигание не влияет на считывание спрайтов из OAM. Данные всё равно остаются там, но эмулируемое железо их не отображает. Это отличается от описанной выше ситуации с мигающими при создании спрайтами. Кроме того, в Nintaco есть опция, значительно снижающая аппаратное мигание.
И наконец, небольшая часть состояния игры считывается из таблиц имён PPU — области памяти, содержащей все данные фонов. К нему относится проверка разрушаемых блоков и слежение за позициями «давилок» на уровне 2.
---
Эвристические машины состояний
==============================
Стратегии — это машины состояний. CastlevaniaBot задаёт их как абстрактный класс с методами `init` и `step`. Метод `init` вызывается, когда CastlevaniaBot переключается на соответствующую стратегию, позволяя машине состояний выполнить сброс в исходное состояние. А метод `step` выполняет стратегию. Например метод `step` стратегии для людей-рыб проверяет, находится ли человек-рыба в пределах удара хлыстом, и если да, то бот ударяет хлыстом. В противном случае он проверяет, можно ли прыжком достичь расстояния удара, и если это так, то бот прыгает. И наконец, если бот стоит слишком близко к противнику, то отходит от него. Благодаря этим простым правилам CastlevaniaBot побеждает людей-рыб.
Чтобы максимально упростить написание стратегий, я создал библиотеку возможных выполняемых действий. Например вместо нажатия и отпускания кнопки A для прыжка бот просто вызывает из библиотеки метод прыжка. А перед этим он запрашивает библиотеку, находится ли Саймон на платформе и может ли прыгать.
Приближение и удаление от цели — это стандартные действия, выполняемые при помощи операций из таблицы, созданной алгоритмом поиска путей. Например, стратегия свечей использует библиотечный метод `routeAndFace`, который не только направляет Саймона в какие-то указанные координаты, но и поворачивает его влево или вправо после попадания в них. Кроме того, в зависимости от высоты расположения свечей стратегия выполняет перед ударом хлыстом прыжок или приседание. Выпавший из свечей предмет создастся в воздухе и упадёт или медленно опустится на землю. Стратегия поднимания предметов направляет Саймона к ближайшему тайлу непосредственно под ним ещё до того, как предмет коснётся земли.
Чтобы отодвигаться от врагов, библиотеке нужно знать, как двигаться влево или вправо, не падая в ямы. В общем случае это реализуется поиском путей к левому или правому краям подэтапа. Но в некоторых областях кратчайший путь к левому краю изначально требует двигаться вправо, и наоборот. Когда появились подобные проблемы, я добавил логику специально для подэтапов, направляющую Саймона к левому и правому краям текущей платформы.
---
Прохождение
===========
В этом разделе я подробно опишу используемые CastlevaniaBot стратегии, прокомментировав всё прохождение.
Игра начинается во дворе перед замком. Объекты в кадре проранжированы для выбора основной цели, которой в данном случае является колонна с пламенем. Стратегия работы с колоннами приказывает боту приблизиться к колонне и использовать хлыст, когда он будет в пределах досягаемости.
После удара хлыстом и уничтожения колонны создаётся предмет. Приоритет всех предметов выше, чем у колонн с пламенем. Следовательно, CastlevaniaBot реагирует на это, используя стратегию сбора появившегося предмета, прежде чем переходить к последующим колоннам.
При ранжировании объектов CastlevaniaBot всегда учитывает долговременную цель — прохождение уровня до того, пока кончится время. При создании списка потенциальных целей в него всегда добавляется дверь на следующий уровень. Двери назначается низкий приоритет, но после уничтожения всех колонн и сбора всех предметов она становится приоритетной. Только за одним исключением: CastlevaniaBot знает, как раскрывать все скрытые сокровища, и перепрыгивает через вход в замок, чтобы создать мигающий мешок с деньгами.
После входа в замок CastlevaniaBot видит призраков и свечи. Свечи и создаваемые предметы имеют больший приоритет, пока призраки не подберутся ближе.
Часто кажется, что хлыст уничтожает врагов, не касаясь их. Я нашёл в ROM игры таблицу прямоугольников коллизий, поэтому CastlevaniaBot точно знает, когда что-то находится в пределах действия хлыста. А поскольку прямоугольники коллизий часто слегка выдаются за границы спрайтов, хлыст может ударять «невидимой частью».
В большинстве случаев при уничтожении свечей CastlevaniaBot прыгает вертикально, а не вперёд. Это тактика избегания риска. Так как находясь в воздухе, изменить направление движения невозможно, толпа приближающихся врагов может усложнить безопасное приземление или сделать его невозможным. Кроме того, при вертикальном прыжке CastlevaniaBot остаётся на том же блоке; ему не нужно проверять, приведёт ли прыжок к падению на нижнюю платформу или дно ямы.
Когда не остаётся ни уничтожаемых свечей, ни собираемых предметов, CastlevaniaBot начинает преследовать призраков. Но «стратегия пантеры» приказывает ему стоять на месте, ожидая пока враг не попадёт в пределы удара хлыста.
Кроме того, что свечи служат источниками сердец и других предметов, они направляют игрока по пути через этап. Например на показанным ниже изображении свечи в верхнем правом углу «приглашают» игрока подняться по лестнице. Однако чтобы подняться вверх по ступеням, игроку изначально нужно пройти влево, из-за чего свечи пропадают с экрана. Так как решения CastlevaniaBot основаны на расстановке приоритетов видимых на экране предметов, эта ситуация может привести к бесконечному циклу, где бот попеременно выбирает кратчайший путь к свечам (влево) или кратчайший путь к двери выхода (вправо).
Подобные проблемы можно решить несколькими способами. Например, CastlevaniaBot можно оснастить запоминанием объектов, пониманием того, что объекты продолжают существовать, даже если их не видно. Но для этого всё равно изначально их нужно увидеть. Если бы свечи были ещё правее, то после их обнаружения нужно было бы возвращаться назад ещё дальше.
С учётом этого я добавил стимулы, подталкивающие CastlevaniaBot к исследованию областей этапа, которые он обычно бы игнорировал. Эти стимулы работают аналогично выходным дверям, привлекая CastlevaniaBot туда, куда ему нужно идти. Кроме того, я добавил правила, заставляющие его игнорировать свечи и предметы, находящиеся слишком далеко (по проходимому расстоянию, а не по прямой линии).
После поднятия по лестнице и уничтожения свечей создаётся святая вода — самое ценное из всего вторичного оружия. CastlevaniaBot выбирает его, обменивая на него кинжал.
Как и в случае с денежным мешком в начале игры, CastlevaniaBot знает обо всех разрушаемых блоках со скрытыми предметами, и для разрушения блоков хлыстом он использует стратегию, похожую на стратегию для свечей.
При дальнейшем движении CastlevaniaBot вы заметите, что он начинает использовать для уничтожения призраков и свечей святую воду. Это может показаться излишним, но служит важной цели. Castlevania вознаграждает игроков за использование вторичного оружия с двойным и тройным воздействием. Другими словами, CastlevaniaBot [гриндит](https://en.wikipedia.org/wiki/Grinding_(gaming)) апгрейды вторичного оружия.
После нажатия кнопки B существует задержка в 16 кадров до удара хлыста. Хлыст остаётся длинным в течение дополнительных 10 кадров, но действует только в первом из этих десяти. CastlevaniaBot использует этот факт для улучшения прицеливания. В частности, он отслеживает скорости всех объектов в кадре, предполагая, что основная цель будет продолжать двигаться по линейной траектории. Затем он нажимает кнопку B за 16 кадров до того, как цель должна встретиться с ударом хлыста. Враг всегда может изменить направление в течение этих 16 кадров, но обычно эта простая эвристика работает.
Однако после прохождения через дверь CastlevaniaBot встречает красных летучих мышей. Как и головы медуз, красные летучие мыши летают по экрану, пролетая по синусоиде сквозь платформы и лестницы. Чтобы предсказать, где будет красная летучая мышь спустя 16 кадров, я записал движение одной из них в таблицу. Во время выполнения игры CastlevaniaBot отслеживает летучих мышей и ждёт пиков или минимумов траектории, где вертикальная скорость меняет свой знак. Тогда он способен сопоставить координаты со значениями в заранее созданной таблице. Это позволяет соответствующей стратегии ударить красную летучую мышь хлыстом, наклониться или подпрыгнуть над ней.
При скоростном прохождении (спидранах) Castlevania игроки выполняют маневры, делающие игру как можно более детерминированной. Например, они обнаружили, что если в конце уровня 1 разрушить блок и подобрать апгрейд оружия в определённой временной последовательности, то босс будет вести себя в соответствии с желательным паттерном, позволяющим быстро его победить.
Какими бы опытными ни были люди, они не могут полностью приручить генератор случайных чисел. Тем не менее, поскольку CastlevaniaBot может контролировать нажатия кнопок с покадровой точностью, он может довести концепцию скоростного прохождения до её предела, каждый раз проходя игру абсолютно идентичным образом. Если бы он так делал, это бы ничуть не лучше прохождения [TAS](https://ru.wikipedia.org/wiki/Tool-assisted_speedrun). Поэтому CastlevaniaBot произвольно добавляет с помощью внешнего генератора случайных чисел в свои действия ошибки и задержки, чтобы избежать детерминированного геймплея. Например, когда он ударяет хлыстом находящуюся высоко свечу, то намеренно добавляет в прыжок и удар задержку на случайное количество кадров. Подобные крошечные изменения значительно влияют на прохождение игры.
Хотя CastlevaniaBot и стремится избежать детерминированности, он всё же позаимствовал у спидраннинга одну концепцию: [damage boosts](http://www.speedrunslive.com/faq/glossary/). В 50% случаев CastlevaniaBot полностью избегает прохождение подземелья людей-рыб, прыгая назад на красную летучую мышь, которая отбрасывает его на недостижимую иным способом платформу.
В другой половине случаев CastlevaniaBot выбирает сражаться с людями-рыбами. Их огненные шары имеют высокий приоритет и CastlevaniaBot ударяет их хлыстом, уклоняется или подпрыгивает в зависимости от ситуации.
Из-за непредсказуемости создания врагов и их огненных шаров большинство игроков обычно пробегает часть с людьми-рыбами. Но CastlevaniaBot тратит на них время, собирает все сердца и даже скрытое сокровище в самом правом краю. Бот точно знает, какие предметы содержатся в каждой свече, и поскольку он предпочитает пользоваться святой водой, то пропускает свечи, в которых скрыты хронометры. Однако если остаться в этой части и сражаться с людьми-рыбами, то иногда можно неизбежно подобрать хронометр.
Этапы часто завершаются крестами, уничтожающими всех врагов на экране. На случай, если вам любопытно, скажу — кресты не могут убивать боссов в конце уровня. На самом деле кресты иногда создаются даже во время боёв с боссами. Например, в битве с Медузой при уничтожении змей иногда появляются кресты. Но эти кресты могут убивать только других змей.
После прохождения через дверь CastlevaniaBot снова встречается с призраками. На показанном ниже скриншоте он хочет спрыгнуть на нижнюю платформу, но его движению препятствуют призраки. Когда созданная алгоритмом поиска путей таблица приказывает CastlevaniaBot прыгать, он изучает пространство вокруг целевой платформы. Если окажется, что он приземлится на врагов, то прыжок не выполняется. В данном случае этот механизм заставляет CastlevaniaBot дождаться, пока призраки освободят ему место.
Это правило «проверяй наличие врагов перед прыжком» иллюстрирует один из принципов структуры CastlevaniaBot: он должен управляться простыми, как можно более обобщёнными правилами. В некоторых частях игры необходимо использовать одноразовые стратегии, решающие очень конкретные задачи. Но в бОльшей части игры действия бота управляются многоразовыми эвристиками. Я не писал команду, заставляющую его остановиться в этой конкретной точке и ждать, пока призраки уйдут с пути. Это поведение возникло как результат эвристик.
CastlevaniaBot завершает уровень, убив Phantom Bat тройной святой водой. Но его стратегия атаки определяется его вторичным оружием. На самом деле, если бы у него не было вторичного оружия, он был готов к убийству босса с помощью одного кнута. Особо интересным случаем является убийство Phantom Bat с помощью топора. Аналогично случаю с красной летучей мышью, я записал в таблицу движение топора по параболе. Во время выполнения игры CastlevaniaBot выполняет смещение таблицы, сопоставляя её с каждым из тайлов пола. Это позволяет вычислить оптимальную точку для убийства босса топором.
Непосредственно перед подбиранием хрустального шара CastlevaniaBot бросает в разные стороны вторичное оружие, зная, что оно замрёт в воздухе после того, как он коснётся шара. Затем он случайным образом многократно прыгает и ударяет хлыстом, надеясь замереть в странной позе.
В начале уровне 2 CastlevaniaBot избегает первых свечей, в которых спрятан бумеранг. Стратегия работы с рыцарем-копейщиком похода на стратегии призраков или людей-рыб, однако это первый враг, для убийства которого нужны два удара. Чёрная летучая мышь дремлет, пока к ней не приблизишься, после чего она взлетает и движется достаточно линейно, чтобы её можно было убить хлыстом с помощью упомянутой выше простой эвристики.
Разрушив кирпичи стены, в 50% случаев CastlevaniaBot, похоже, уходит из комнаты, не подняв корону. Но так ли это? На самом деле в таких случаях он подбирает корону, воспользовавшись багом игры. Так как конец верхней лестницы совпадает по горизонтали с расположением короны, игрок при прохождении вверх и за экран на мгновение оказывается внизу. Если прислушаться к звуку или посмотреть на очки, то можно увидеть, что бот на самом деле берёт корону.
На уровне 2 враги не атакуют игрока, когда он находится на подвижной платформе. CastlevaniaBot просто должен подождать, пока платформа подъедет, зайти на платформу, дождаться, пока она доедет до другой стороны, а затем сойти с неё. Существует небольшая вариация для платформ, которые не касаются тайлов с другой стороны. В таких случаях CastlevaniaBot не сходит, а спрыгивает с платформы.
Дверь ведёт в коридор, заполненный летающими головами, и CastlevaniaBot реагирует на это, двигаясь вперёд. Как и в случае с подвижными платформами, CastlevaniaBot знает, что эту стратегию нужно применять на основе своего положения, а не расстановки приоритетов находящихся на экране игровых объектов. Однако как только все головы медуз пролетят, он снова переключается к этой технике, чтобы выбрать стратегию, которая будет использоваться дальше.
Ещё одна стратегия, зависящая от позиции, срабатывает после поднятия по следующей лестнице, ведущей в заполненную головами медуз область. В 50% случаев CastlevaniaBot намеренно прыгает на голову медузы, чтобы получить damage boost, подталкивающий его на верхнюю платформу рядом с дверью, ведущей к следующему этапу. Это единственные два damage boost, о которых знает CastlevaniaBot. В отличие от спидраннеров, он выполняет его не для экономии времени, это всего лишь ещё один вклад в недетерминированность прохождения.
Прохождение через «давилки» — это интересная стратегия на основе положения, повторяемая три раза. CastlevaniaBot ждёт, пока ближайшая «давилка» слева от него достигнет нужной позиции, после чего пробегает через неё. После её прохождения он останавливается, поворачивается, ударяет свечи хлыстом, подбирает созданный предмет и повторяет операцию с последующими «давилками». Одним из предметов потенциально может быть святая вода, поэтому он всегда уничтожает эти свечи.
После «давилок» впервые появляются привидения и костяные башни. В привидений очень просто прицелиться, но для их убийства нужно несколько попаданий. В костяные башни прицелиться ещё проще, потому что они не движутся. Для их огненных шаров используется та же стратегия, что и для шаров людей-рыб.
Уровень 2 обычно заканчивается тем, что CastlevaniaBot мгновенно убивает Медузу бесконечным потоком святой воды. Однако он готов работать и с любым другим типом вторичного оружия.
На уровне 3 появляются прыгуны. CastlevaniaBot реагирует на них тем, что ждёт, пока они впрыгнут в пределы действия кнута. Если прыгуны перепрыгивают игрока, то CastlevaniaBot перемещается в противоположном направлении и ударяет их хлыстом прежде, чем они коснутся земли.
Дальше появляются белые скелеты. Они имеют очень случайный паттерн. Кроме того, они кидаются костями. На уровне 3 CastlevaniaBot пытается избежать их попадания. Но я обнаружил, что на последующих уровнях кости только отвлекают, и эффективнее будет просто их игнорировать. Стратегия CastlevaniaBot для белых скелетов — просто бить их.
CastlevaniaBot ждёт, пока подлетят вороны. Затем на основании высоты ворона относительно игрока он точно вычисляет, когда ударить хлыстом после прыжка.
После перехода на следующий этап CastlevaniaBot самостоятельно ударяет свечи, из которых появляется хронометр, а потом ждёт, пока он не исчезнет. Немного впереди и за экраном находится ворон. Бот уничтожает свечи перед схваткой с вороном, чтобы снизить риск случайного удара по ним и получения нежелательного вторичного оружия.
Прямо перед местом появления мумий CastlevaniaBot идёт влево на платформу, чтобы вызвать появление скрытого мешка с деньгами. Он делает это просто ради интереса, потому что поднять его никак не сможет.
Далее CastlevaniaBot намеренно ударяет по свечам, из которых вываливается кинжал. Как и в случае с хронометром, он делает это, чтобы не подобрать его случайно во время последующих действий.
И наконец, мумии оказываются повержены дождём из святой воды.
Для борьбы со всеми боссами CastlevaniaBot готов использовать любое вторичное оружие. На самом деле, стратегии применения вторичного оружия совершенно меняются, если по какой-то причине оказывается разрушенным блок, содержащий кусок свинины. Без этого блока невозможно подняться на верхнюю платформу, из-за чего сражаться приходится на нижнем уровне.
На уровне 4 возвращаются подвижные платформы. И на этот раз есть вероятность, что на пути появятся красные летучие мыши. Чтобы снизить вероятность их нападения, он ждёт, чтобы прибытие платформы совпало по времени с уничтожением красной летучей мыши. Так как красные мыши появляются через фиксированные промежутки, это даёт CastlevaniaBot достаточно времени, чтобы пересечь водную яму без летучих мышей. Он готов иметь дело с летучими мышами и случайно появляющимися людьми-рыбами, пока находится на платформе, но это делает очень опасными прыжки на платформу и с неё. Применяемая CastlevaniaBot стратегия повышает вероятность его успеха.
Та же стратегия повторяется посередине этапа. На этот раз прыжок к подвижной платформе намного длиннее, поэтому критически важно перед прыжком уничтожить красную летучую мышь.
Как показано на скриншоте выше, свечи всегда расположены на расстоянии 64 пикселя друг от друга. Возможно, это артефакт того, что данные уровня представлены в ROM в похожем на векторную графику формате, экономящем пространство. Но по какой-то причине дизайнеры решили выровнять свечи не с центрами, а с краями тайлов. В данном случае свечи выровнены с обоими концами платформы. Поэтому после удара по ним появившийся предмет может упасть прямо в водную пропасть под ними.
Думаю, что на каком-то этапе дизайнеры осознали эту проблему. Но к тому времени смещение всей серии свечей на всех готовых уровнях, чтобы выровнять их с центрами тайлов, могло бы вызвать другие проблемы. Вместо этого они решили случайным образом смещать свечи на один пиксель вправо или влево от места их создания. Поэтому после удара по свечам в правой части скриншота есть вероятность в 50%, что содержащаяся в них святая вода упадёт на платформу. В остальной половине случаев она падает в воду.
CastlevaniaBot обычно полностью избегает этих свечей, потому что он достаточно успешно сохраняет святую воду. Но если она ему понадобится, то он встаёт очень близко к этим свечам, чтобы гарантированно подобрать выпавшую из них святую воду.
Далее CastlevaniaBot встречается с кучей прыгунов. В этой области после убийства прыгунов часто появляются топоры. CastlevaniaBot избегает их, потому что особо полезной при борьбе с боссом оказывается святая вода.
При переходе к последнему этапу уровня CastlevaniaBot полностью игнорирует костяного дракона.
Но от следующих двух он избавляется быстрыми ударами хлыста.
Чудовище Франкенштейна и Игорь уничтожаются постоянным потоком ударов хлыстом и святой воды. Как и в случае с другими боссами, CastlevaniaBot может справляться и другим вторичным оружием, или вовсе без него. Однако шансы на выживание без святой воды уменьшаются.
На уровне 5 CastlevaniaBot снова имеет дело с белыми скелетами. Но на этот раз он использует вариации стратегий, редко встречаемые на уровне 3. В зависимости от того, где они появляются, CastlevaniaBot бросает святую воду, а затем отходит назад, чтобы привлечь скелетов в пламя. Рядом с лестницами он проходит под скелетами, чтобы направить их туда, где они должны быть.
На уровне 5 впервые появляются возрождающиеся красные скелеты. CastlevaniaBot отслеживает время последнего удара по ним, чтобы знать, когда можно безопасно пройти по красным костям.
Первая комната этапа 14 полностью обрабатывается одной огромной стратегией. Сначала CastlevaniaBot убивает прыгуна. Затем он ждёт, пока нижний рыцарь метнёт топор, ударяет топор хлыстом и медленно поднимается по нижней лестнице. Это отталкивает нижнего рыцаря за экран, что приводит к его исчезновению. Затем он ждёт, пока верхняя область освободится от топоров, ударяет по свечам и собирает появившиеся предметы. Затем он приближается к основанию лестницы, ведущей к верхнему рыцарю. Когда верхний рыцарь бросает топор высоко, CastlevaniaBot бежит за ним. Это отталкивает верхнего рыцаря влево и почти полностью с экрана, но не уничтожает его. CastlevaniaBot нагибается под возвращающимся топором, а возможно и под вторым брошенным топором, а затем наконец подходит к лестнице на следующий подэтап. Ура!
Пройдя несколько лестниц, CastlevaniaBot снова встречает рыцаря с топором. Он использует святую воду, чтобы оглушить его, а потом добивает хлыстом. Если святой воды нет, он продолжает бить хлыстом, преследуя рыцаря до тех пор, пока тот не умрёт.
Двигаясь по лестницам уровня 5, CastlevaniaBot часто должен ждать, пока красный скелет отойдёт или от верхней, или от нижней части лестницы. Ближе к концу уровня костяная башня делает эту задачу ещё сложнее. В зависимости от того, как решат перемещаться скелеты, CastlevaniaBot ходит вниз и вверх по лестнице, пока не сможет пройти.
Для обработки групп красных скелетов требуется дополнительная логика, чтобы бот не попал в бесконечный цикл. Если CastlevaniaBot будет бить их хлыстом по отдельности, с таким интервалом, чтобы первый ударенный успевал возродиться, то он попадёт в цикл, где будет продолжать уничтожать бесконечно возрождающихся скелетов. Чтобы избежать этого, CastlevaniaBot не будет ударять хлыстом красного скелета, стоящего рядом с грудой красных костей. Это правило позволяет красным костям возродиться рядом с ещё живым красным скелетом, давая возможность ударить их двоих одновременно. Без интервала между их разрушением цикл создаваться не будет.
Чтобы избежать голов медуз в длинном коридоре, ведущем к Смерти, бот никогда не останавливается, оглушая обычно появляющихся на пути рыцарей. Он пользуется тем, что игрок может проходить сквозь оглушённых святой водой врагов, не получая урона.
Если святой воды нет, то прямо перед коридором CastlevaniaBot может взять бумеранг. При удачном стечении обстоятельств он использует его для уничтожения рыцарей, а также получения апгрейдов оружия.
CastlevaniaBot оглушает Смерть святой водой, прежде чем она начнёт бросать косы, быстро её убивая. Также он может победить Смерть тройным бумерангом, но для этого обычно требуется несколько попыток.
Принципиальная стратегия CastlevaniaBot прохождения моста в начале уровня 6 — продолжать двигаться. Он ударяет хлыстом огромных летучих мышей сверху, чтобы оглушить их, а затем подпрыгивает над огромными летучими мышами, появляющимися снизу. Кроме того, ему время от времени нужно уклоняться от кидаемых летучими мышами огненных шаров, или бить их хлыстом.
Прохождение по мосту не гарантировано. Всё зависит от того, насколько дружелюбными будут огромные летучие мыши.
На следующем подэтапе CastlevaniaBot два или более раз использует полученный на мосту хронограф, чтобы пройти сквозь орлов и прыгунов. Без хронографа он пытается проделать путь с помощью хлыста.
Когда CastlevaniaBot добирается до башни Дракулы, он может подниматься и опустаться по лестнице несколько раз, чтобы снова создавать свечи, что позволяет собрать как минимум 20 сердец.
Самые правые свечи в покоях Дракулы дают святую воду, которая необходима для борьбы со второй формой Дракулы.
Для победы над первой формой Дракулы требуется 16 ударов по голове. CastlevaniaBot несколько раз подходит к Дракуле, ждёт, пока тот выстрелит огненными шарами, а затем перепрыгивает шары и ударяет по голове Дракулы хлыстом.
Вторую форму Дракулы, которую прозвали Cookie Monster, бот оглушает святой водой и несколько раз ударяет хлыстом по голове. Время от времени Cookie Monster прыгает к игроку, при этом CastlevaniaBot уворачивается. Также Cookie Monster бросает огненные шары, которые обычно можно уничтожить святой водой и хлыстом. Иногда при этом можно получить апгрейд оружия. А двойная святая вода ловит Cookie Monster в постоянный цикл оглушения, ведущий к быстрой победе.
CastlevaniaBot не умеет проходить Difficult Mode, который начинается после финальных титров. Однако после повторного начала игры во дворе замка он сбрасывает байт цикла игры на ноль, переключая её в Normal Mode. Это позволяет CastlevaniaBot играть бесконечно.
---
Файлы
=====
[CastlevaniaBot\_2018-12-09.zip](https://meatfighter.com/castlevaniabot/CastlevaniaBot_2018-12-09.zip)
В файле `.zip` содержатся:
* `src` — дерево исходников.
* `CastlevaniaBot.jar` — скомпилированный двоичный файл.
* `lgpl-2.1.txt` — лицензия свободного программного обеспечения.
---
Запуск
======
Обязательные требования
-----------------------
* [Nintaco](https://nintaco.com/) — эмулятор NES.
* `Castlevania (U) (PRG1) [!].nes` — ROM игры.
Запуск плагина
--------------
1. Запустите Nintaco и откройте `Castlevania (U) (PRG1) [!].nes`.
2. Извлеките `CastlevaniaBot.jar` из скачанного `.zip`.
3. Откройте окно Run Program, выбрав Tools | Run Program...
4. Введите путь к файлу в поле JAR или выберите его, нажав на кнопку Find JAR....
5. Нажмите Load JAR, чтобы загрузить его.
6. Нажмите Run.
---
| |
| --- |
| Copyright © 2018 meatfighter.com
Данный проект является свободным программным обеспечением. Вы можете распространять его и/или модифицировать его на условиях лицензии LGPLv2.1. | | https://habr.com/ru/post/432784/ | null | ru | null |
# Пишем REST API на Vert.x. Часть 1: настройка окружения
Привет, харбаюзер. В этой серии статей мы напишем REST API с использованием Vert.x. Начнём с простого: установки самого vert.x-а и настройки запуска простого приложения в IDE.
##### Немного общей информации о фреймворке
Vert.x — этакий node.js из мира Java. Отличает его большой список поддерживаемых языков (на момент написания статьи: Java, JavaScript, CoffeeScript, Groovy, Python, Ruby, Clojure, Scala), а также наличие механизма запуска блокирующих операций и возможность использования нескольких потоков, сохраняя при этом принцип одного рабочего потока.
Больше информации о фреймворке:
[vertx.io/manual.html](http://vertx.io/manual.html) — Официальный мануал
[habrahabr.ru/post/181686](http://habrahabr.ru/post/181686/) — Единственный найденный мной пост на хабре о фреймворке
##### Установка фреймворка, настройка IDE и запуск примера проекта
Для начала установим сам vert.x, для этого перейдём [в раздел downloads на официальном сайте фреймворка](http://vertx.io/downloads.html). Распаковывем архив, добавляем директорию bin в PATH. Проверяем правильность установки, запуская следующую команду в терминале:
`vertx version`
И всё. Один из главных принципов фреймворка — простота конфигурации.
Далее при помощи apache maven сгенерируем пример проекта. Для этого выполним следующую команду в терминале:
`mvn archetype:generate -Dfilter=io.vertx:`
Выбираем среди найденных archetype-ов(на момент написания статьи их точно не более одного) io.vertx:vertx-maven-archetype и выбираем последнюю версию. Задаём в терминале следующие параметры будущего приложения: groupId, artifactId, версию и базовый package. Для примера проекта я задал их соответственно: com.example, vertx-example, 1.0.0-SNAPSHOT, com.example. Проверим, что проект успешно собирается, для этого выполним следующую команду в терминале:
`mvn install`
Если вы видите сообщение BUILD SUCCESS, значит всё сделано правильно, при этом структура проекта должна выглядеть примерно так:
Настроим запуск проекта. Я настраивал в IntelliJ IDEA, но уверяю вас с другими IDE проблем быть не должно.
Есть небольшая проблема с разрешением зависимостей из пакетов vertx-core, vertx-platform и vertx-hazelcast. В нашем проекте сейчас scope у них выставлен provided, что означает что они будут предоставлены окружением. Однако запускать наше приложение в IDE, которая не предоставляет этих пакетов, поэтому создадим два maven профиля: один для запуска в IDE, другой для сборки приложения, которое будет запускаться непосредственно на vert.x, который несёт в себе нужные зависимости. Для этого добавим следующий текст в наш pom.xml:
```
local
compile
deployment
provided
```
И изменим scope для пакетов vertx:
```
io.vertx
vertx-core
${vertx.version}
${vertx-scope}
io.vertx
vertx-platform
${vertx.version}
${vertx-scope}
io.vertx
vertx-hazelcast
${vertx.version}
${vertx-scope}
```
Для того чтобы запускать проект одним кликом создадим следующую конфигурацию запуска:
По сути мы запускаем программу с `org.vertx.java.platform.impl.cli.Starter` в качестве входной точки и аргументами `runmod com.example~vertx-example~1.0-SNAPSHOT`. Аргумент указывает на то, какой модуль запускать. Логика именования следующая: groupId~artifactId~version.
Теперь можно запускать наше приложение, если при запуске вывод в консоль похож на следующий, значит всё сделано правильно:
```
Apr 08, 2014 5:47:39 PM org.vertx.java.core.logging.impl.JULLogDelegate info
INFO: PingVerticle started
Apr 08, 2014 5:47:39 PM org.vertx.java.core.logging.impl.JULLogDelegate info
INFO: Succeeded in deploying module
```
Благодарю за внимание. В следующий раз мы разберём, что к чему в этом проекте и начнём писать собственное приложение.
Исходный код получившегося проекта доступен на GitHub: [github.com/X3H4/vertx-example](https://github.com/X3H4/vertx-example) | https://habr.com/ru/post/218733/ | null | ru | null |
# Каскадная инвалидация кэша. Часть 1
Вот уже несколько лет, как почти каждая статья о передовых подходах к кэшированию рекомендует пользоваться в продакшне следующими методиками:
* Добавление в имена файлов информации о версии содержащихся в них данных (обычно — в виде хэша данных, находящихся в файлах).
* Установка HTTP-заголовков `Cache-Control: max-age` и `Expires`, управляющих временем кэширования материалов (что позволяет исключить повторную валидацию соответствующих материалов для посетителей, возвращающихся на ресурс).
[](https://habr.com/ru/company/ruvds/blog/472860/)
Все известные мне средства для сборки проектов поддерживают добавление к именам файлов хэша их содержимого. Делается это с помощью простого конфигурационного правила (наподобие того, что показано ниже):
```
filename: '[name]-[contenthash].js'
```
Столь широкая поддержка этой технологии привела к тому, что подобная практика стала чрезвычайно распространённой.
Эксперты в сфере производительности веб-проектов, кроме того, рекомендуют пользоваться методиками [разделения кода](https://web.dev/reduce-javascript-payloads-with-code-splitting). Эти методики позволяют разбивать JavaScript-код на отдельные бандлы. Такие бандлы могут быть загружены браузером параллельно, или даже лишь тогда, когда в них возникнет необходимость, по запросу браузера.
Одним из многих преимуществ разделения кода, в частности, имеющих отношение к передовым методикам кэширования, называют то, что изменения, внесённые в отдельный файл с исходным кодом, не приводят к инвалидации кэша всего бандла. Другими словами, если для npm-пакета, созданного разработчиком «X», вышло обновление безопасности, и при этом содержимое `node_modules` разбито на фрагменты по разработчикам, то изменить придётся только фрагмент, содержащий пакеты, созданные «X».
Проблема тут заключается в том, что если всё это скомбинировать, то подобное редко приводит к повышению эффективности долговременного кэширования данных.
На практике изменения одного из файлов исходного кода почти всегда приводят к инвалидации более чем одного выходного файла системы сборки пакетов. И это происходит именно из-за того, что к именам файлов были добавлены хэши, отражающие версии содержимого этих файлов.
Проблема, касающаяся версионирования имён файлов
------------------------------------------------
Представьте, что вы создали и развернули веб-сайт. Вы воспользовались разделением кода, в результате большая часть JavaScript-кода вашего сайта загружается по запросу.
На следующей диаграмме зависимостей можно видеть точку входа кодовой базы — корневой фрагмент `main`, а также — три фрагмента-зависимости, загружаемых асинхронно — `dep1`, `dep2` и `dep3`. Есть здесь и фрагмент `vendor`, содержащий все зависимости сайта из `node_modules`. Все имена файлов, в соответствии с рекомендациями по кэшированию, включают в себя хэши содержимого этих файлов.
*Типичное дерево зависимостей JavaScript-модуля*
Так как фрагменты `dep2` и `dep3` импортируют модули из фрагмента `vendor`, то в верхней части их кода, сгенерированного сборщиком проекта, мы, скорее всего, обнаружим команды импорта, выглядящие примерно так:
```
import {...} from '/vendor-5e6f.mjs';
```
Теперь подумаем о том, что произойдёт, если изменится содержимое фрагмента `vendor`.
Если это произойдёт, то хэш в имени соответствующего файла тоже изменится. А так как ссылка на имя этого файла имеется в командах импорта фрагментов `dep2` и `dep3`, тогда нужно будет, чтобы изменились и эти команды импорта:
```
-import {...} from '/vendor-5e6f.mjs';
+import {...} from '/vendor-d4a1.mjs';
```
Однако так как эти команды импорта являются частью содержимого фрагментов `dep2` и `dep3`, то их изменение означает, что изменится и хэш содержимого файлов `dep2` и `dep3`. А значит — и имена этих файлов тоже изменятся.
Но на этом всё не заканчивается. Так как фрагмент `main` импортирует фрагменты `dep2` и `dep3`, а имена их файлов изменились, команды импорта в `main` тоже поменяются:
```
-import {...} from '/dep2-3c4d.mjs';
+import {...} from '/dep2-2be5.mjs';
-import {...} from '/dep3-d4e5.mjs';
+import {...} from '/dep3-3c6f.mjs';
```
И наконец, так как содержимое файла `main` изменилось, имя этого файла тоже должно будет измениться.
Вот как теперь будет выглядеть диаграмма зависимостей.
*Модули в дереве зависимостей, на которые повлияло единственное изменение в коде одного из листовых узлов дерева*
Из этого примера видно, как небольшое изменение кода, сделанное всего лишь в одном файле, привело к инвалидации кэша 80% фрагментов бандла.
Хотя и правда то, что не все изменения приводят к столь печальным последствиям (например, инвалидация кэша листового узла приводит к инвалидации кэша всех узлов вплоть до корневого, но инвалидация кэша корневого узла не вызывает каскадной инвалидации, доходящей до листовых улов), в идеальном мире нам не приходилось бы сталкиваться с любыми ненужными инвалидациями кэша.
Это приводит нас к следующему вопросу: «Можно ли получить преимущества, даваемые иммутабельными ресурсами и долговременным кэшированием, и при этом не страдать от каскадных инвалидаций кэша?».
Подходы к решению проблемы
--------------------------
Проблема, касающаяся хэшей содержимого файлов, находящихся в именах файлов, с технической точки зрения, заключается не в том, что хэши находятся в именах. Она заключается в том, что эти хэши появляются и внутри других файлов. В результате кэш этих файлов инвалидируется при изменении хэшей в именах файлов, от которых они зависят.
Решение этой проблемы заключается в том, чтобы, говоря языком вышеприведённого примера, сделать возможным импорт фрагмента `vendor` фрагментами `dep2` и `dep3` без указания информации о версии файла фрагмента `vendor`. При этом нужно гарантировать, чтобы загруженная версия `vendor` была бы правильной, принимая во внимание текущие версии `dep2` и `dep3`.
Как оказалось, существует несколько способов достижения этой цели:
* Карты импорта.
* Сервис-воркеры.
* Собственные скрипты для загрузки ресурсов.
Рассмотрим эти механизмы.
Подход №1: карты импорта
------------------------
[Карты импорта](https://github.com/WICG/import-maps) — это простейшее решение проблемы каскадной инвалидации кэшей. Кроме того, этот механизм легче всего реализовать. Но он, к сожалению, поддерживается лишь в Chrome (эту возможность, к тому же, нужно явным образом [включать](https://www.chromestatus.com/feature/5315286962012160)).
Несмотря на это я хочу начать именно с рассказа о картах импорта, так как уверен в том, что это решение станет в будущем наиболее распространённым. Кроме того, описание работы с картами импорта поможет объяснить и особенности других подходов к решению нашей проблемы.
Использование карт импорта для предотвращения каскадной инвалидации кэша состоит из трёх шагов.
### ▍Шаг 1
Нужно настроить бандлер так, чтобы он, при сборке проекта, не включал бы хэши содержимого файлов в их имена.
Если собрать проект, модули которого показаны на диаграмме из предыдущего примера, не включая в имена файлов хэши их содержимого, то файлы в выходной директории проекта будут выглядеть так:
```
dep1.mjs
dep2.mjs
dep3.mjs
main.mjs
vendor.mjs
```
Команды импорта в соответствующих модулях тоже не будут включать в себя хэши:
```
import {...} from '/vendor.mjs';
```
### ▍Шаг 2
Нужно воспользоваться инструментом, наподобие [rev-hash](https://www.npmjs.com/package/rev-hash), и сгенерировать с его помощью копию каждого файла, к имени которого добавлен хэш, указывающий на версию его содержимого.
После того, как эта часть работы выполнена, содержимое выходной директории должно будет выглядеть примерно так, как показано ниже (обратите внимание на то, что там теперь присутствует по два варианта каждого файла):
```
dep1-b2c3.mjs",
dep1.mjs
dep2-3c4d.mjs",
dep2.mjs
dep3-d4e5.mjs",
dep3.mjs
main-1a2b.mjs",
main.mjs
vendor-5e6f.mjs",
vendor.mjs
```
### ▍Шаг 3
Нужно создать JSON-объект, хранящий сведения о соответствии каждого файла, в имени которого нет хэша, каждому файлу, в имени которого хэш есть. Этот объект нужно добавить в HTML-шаблоны.
Этот JSON-объект и является картой импорта. Вот как он может выглядеть:
```
{
"imports": {
"/main.mjs": "/main-1a2b.mjs",
"/dep1.mjs": "/dep1-b2c3.mjs",
"/dep2.mjs": "/dep2-3c4d.mjs",
"/dep3.mjs": "/dep3-d4e5.mjs",
"/vendor.mjs": "/vendor-5e6f.mjs",
}
}
```
После этого всякий раз, когда браузер увидит команду импорта файла, находящегося по адресу, соответствующему одному из ключей карты импорта, браузер импортирует тот файл, который соответствует значению ключа.
Если воспользоваться этой картой импорта как примером, то можно выяснить, что команда импорта, ссылающаяся на файл `/vendor.mjs`, на самом деле выполнит запрос и загрузку файла `/vendor-5e6f.mjs`:
```
// Команда ссылается на `/vendor.mjs`, но загружает`/vendor-5e6f.mjs`.
import {...} from '/vendor.mjs';
```
Это означает, что исходный код модулей может совершенно спокойно ссылаться на имена файлов модулей, не содержащих хэшей, а браузер всегда будет загружать файлы, имена которых содержат сведения о версиях их содержимого. А, так как хэшей нет в исходном коде модулей (они присутствуют лишь в карте импорта), то изменения этих хэшей не приведут к инвалидации модулей, отличных от тех, содержимое которых действительно изменилось.
Возможно, вы сейчас задаётесь вопросом о том, почему я создал копию каждого файла вместо того, чтобы просто файлы переименовать. Это нужно для поддержки браузеров, которые не могут работать с картами импорта. В предыдущем примере подобные браузеры увидят лишь файл `/vendor.mjs` и просто загрузят этот файл, поступив так, как обычно поступают, встречая подобные конструкции. В результате и оказывается, что на сервере должны существовать оба файла.
Если вы хотите увидеть карты импорта в действии, то вот — [набор примеров](https://github.com/philipwalton/import-maps-caching-demos), демонстрирующих все способы решения проблемы каскадной инвалидации кэша, показанные в этом материале. Кроме того, взгляните на [конфигурацию сборки проекта](https://github.com/philipwalton/import-maps-caching-demos/blob/master/demos/import-maps-native/rollup.config.js), на тот случай, если вам интересно узнать о том, как я генерировал карту импорта и хэши версий для каждого файла.
Продолжение следует…
**Уважаемые читатели!** Знакома ли вам проблема каскадной инвалидации кэша?
[](https://ruvds.com/vps_start/)
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/472860/ | null | ru | null |
# Лучшие публикации социальных сетей
Мой телеграм канал: <https://t.me/winc0de>.
Здравствуйте. В свободное от работы время я занимаюсь социальными проектами. У меня и моих друзей есть достаточное количество «пабликов» в разных социальных сетях, что позволяет нам проводить различные эксперименты. Остро стоит вопрос нахождения актуального контента и новостей, которые можно публиковать. В связи с этим, пришла идея написать сервис, который будет собирать посты из самых популярных страниц и выдавать их по указанному фильтру. Для начального теста выбрал социальную сеть вконтакте и твиттер.
#### Технологии
Первым делом, нужно было определиться с хранилищем данных (к слову, сейчас количество сохраненных записей больше 2млн) и эта цифра растает каждый день. Требования были такие: очень частая вставка большого количества данных и быстрая выборка среди них.
До этого уже слышал о nosql-базах данных и захотелось их попробовать. Не буду описывать в статье сравнения баз, которые я проводил (mysql vs sqlite vs mongodb).
В качестве кеширования выбрал [memcached](http://ru.wikipedia.org/wiki/Memcached), позже объясню зачем и в каких случаях.
В качестве сборщика данных был написан демон на python, который параллельно обновляет все группы из базы.
#### MongoDB и демон
Первым делом, написал прототип сборщика публикаций из групп. Видел несколько проблем:
* Объем хранилища
* Ограничения API
Одна публикация со всеми метаданными занимает около 5-6КБ данных, а в средней группе около 20,000-30,000 записей, получается около 175МБ данных на одну группу, а этих самых групп очень много. Поэтому пришлось поставить задачу в фильтрации неинтересных и рекламных публикациях.
Слишком много выдумывать не пришлось, у меня есть всего 2 «таблицы»: **groups** и **posts**, первая хранит записи групп, которые нужно парсить и обновлять, а второе — scope всех публикаций всех групп. Сейчас мне кажется это излишним и даже плохим решением. Лучше всего было бы создавать по таблице на каждую группу, так будет проще происходить выборка и сортировка записей, хотя скорость даже с 2млн не теряется. Зато такой подход должен упростить общую выборку для всех групп.
#### API
В случаях, когда вам нужна серверная обработка каких-то данных из социальной сети вконтакте, создается standalone-приложение, которое может выдать токен на любое действие. Для таких случаев у меня сохранена заметка с таким адресом:
`http://oauth.vk.com/authorize?client_id=APP_ID&redirect_uri=https://oauth.vk.com/blank.html&response_type=token&scope=groups,offline,photos,friends,wall`
Вместо **APP\_ID** вставляете идентификатор вашего standalone-приложения. Сгенерированный токен позволяет в любое время обращаться к указанным действиям.
Алгоритм работы парсера такой:
Берем id группы, в цикле получаем все публикации, на каждой итерации производим фильтрацию «плохих» постов, сохраняем в базу.
Основная проблема — скорость. API vkontakte позволяет выполнить 3 запроса в секунду. 1 запрос позволяет получить всего 100 публикаций — 300 публикаций в секунду.
В случае с парсером это не так и плохо: группу можно «слить» за одну минуту, а вот с обновлением уже будут проблемы. Чем больше групп — тем дольше будет происходить обновление и, соответственно, выдача будет не так быстро обновляться.
Выходом стало использование метода execute, который позволяет собирать запросы к api в кучу и выполнять за раз. Таким образом я в одном запросе делаю 5 итераций и получаю 500 публикаций — 1500 в секунду, что дает «слив» группы за ~13 секунд.
Вот так выглядит файл с кодом, который передается в execute:
```
var groupId = -|replace_group_id|;
var startOffset = |replace_start_offset|;
var it = 0;
var offset = 0;
var walls = [];
while(it < 5)
{
var count = 100;
offset = startOffset + it * count;
walls = walls + [API.wall.get({"owner_id": groupId, "count" : count, "offset" : offset})];
it = it + 1;
}
return
{
"offset" : offset,
"walls" : walls
};
```
Код читается в память, делается замена токенов **replace\_group\_id** и **replace\_start\_offset**. В результате получаю массив публикаций, формат которых можете посмотреть на официальной странице VK API [vk.com/dev/wall.get](https://vk.com/dev/wall.get)
Следующий этап — фильтр. Я брал разные группы, просматривал публикации и придумывал возможные варианты отсеивания. Первым делом решил удалять все публикации с ссылками на внешние страницы. Почти всегда это реклама.
```
urls1 = re.findall('http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', text)
urls2 = re.findall(ur"[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)", text)
if urls1 or urls2:
# Игнорировать эту публикацию
```
Далее решил полностью исключить репосты — это в 99% реклама. Мало кто будет просто так делать репост чужой страницы. Проверить на репост очень просто:
```
if item['post_type'] == 'copy':
return False
```
item — очередной элеменрт из коллекции walls, которую вернул метод execute.
Также заметил, что очень много древних публикаций пустые, у них нет никаких вложений и текст пустой. Для фильтра достаточно првоерить что item['attachments'] и item['text'] пустые.
И последний фильтр, который я просто вывел со временем:
```
yearAgo = datetime.datetime.now() - datetime.timedelta(days=200)
createTime = datetime.datetime.fromtimestamp(int(item['date']))
if createTime <= yearAgo and not attachments and len(text) < 75:
# Игнорировать эту публикацию
```
Как и в предыдущем пункте, много старых публикаций были с текстом (описанием картинки во вложении), но сами картинки уже не сохранились.
Следующим шагом было очистка неудачных публикаций, которые просто «не зашли»:
```
db.posts.aggregate(
{
$match : { gid : GROUP_ID }
},
{
$group : { _id : "$gid", average : {$avg : "$likes"} }
}
)
```
Этот метод выполняется на таблицу posts, у которой есть поле likes (количество лайков у публикации). Он возвращает среднее арифметическое лайков по этой группе.
Теперь можно просто удалить все публикации старше 3 дней, у которых количество лайков меньше среднего:
```
db.posts.remove(
{
'gid' : groupId,
'created' : { '$lt' : removeTime },
'likes': { '$lt' : avg }
}
)
```
```
removeTime = datetime.datetime.now() - datetime.timedelta(days=3)
avg = результату предыдущего запроса, разделенного на два (методом подбора).
```
Результирующую и отфильтрованную публикацию добавляю в базу данных, на этом парсинг заканчивается. Разница между парсингом и обновлением групп я сделал только в одном пункте: обновление вызывается ровно 1 раз для группы, т.е. получаю только 500 последних записей (5 по 100 через execute). В общем этого вполне достаточно, учитывая, что вконтакте ввели лимит на количество публикаций: 200 в сутки.
##### Front-end
Не буду сильно подробно расписывать, javascript + jquery + isotope + inview + mustache.
* Isotope используется для современного вывода публикаций в виде плитки.
* Inview позволяет легко реагировать на события попадания во viewport опредлеенного элемента. (в моем случае — запоминаю просмотренные публикации, а новые выделяю особым цветом).
* Mustache позволяет строить dom-объекты по шаблону.
##### Фильтр публикаций по группе
Для вывода данных по группам был написан простой php-скрипт.
Это вспомогательная функция, которая по типу фильтра времени создавала объект, который можно использовать напрямую в запросе.
```
function filterToTime($timeFilter)
{
$mongotime = null;
if ($timeFilter == 'year')
$mongotime = new Mongodate(strtotime("-1 year", time()));
else if ($timeFilter == 'month')
$mongotime = new Mongodate(strtotime("-1 month", time()));
else if ($timeFilter == 'week')
$mongotime = new Mongodate(strtotime("-1 week", time()));
else if ($timeFilter == 'day')
$mongotime = new Mongodate(strtotime("midnight"));
else if ($timeFilter == 'hour')
$mongotime = new Mongodate(strtotime("-1 hour"));
return $mongotime;
}
```
А следующий код уже получает 15 лучших постов за месяц:
```
$groupId = 42; // Какой-то id группы
$mongotime = filterToTime('week');
$offset = 1; // Первая страница
$findCondition = array('gid' => $groupId, 'created' => array('$gt' => $mongotime));
$mongoHandle->posts->find($findCondition)->limit(15)->skip($offset * $numPosts);
```
##### Логика index страницы
Смотреть статистику по группе интересно, но куда интереснее построить общий рейтинг абсолютно всех групп и их публикаций. Если задуматься, задание очень сложное:
Мы можем строить рейтинг только по 3 факторам: количество лайков, репостов и подписчиков. Чем больше подписчиков — тем больше лайков и репостов, но это не гарантирует качество контента.
Большинство групп-миллионников публикуют часто и всякий мусор, который уже несколько лет бродит по интернету, и среди миллиона подписчиков постоянно находятся те, кто будет репостить и лайкать.
Построить рейтинг по голым цифрам легко, но полученный результат никак не можно назвать рейтингом публикаций по их качеству и уникальности.
Были идеи вывести коэффициент качества каждой группы: строить шкалу времени, смотреть активность пользователей за каждый промежуток времени и так далее.
К сожалению, адекватного решения я не придумал. Если у вас будут какие-то идеи, буду рад выслушать.
Первое, что я понял, было осознание того, что содержимое index-страницы нужно просчитывать и кешировать для всех пользователей, потому что это очень медленная операция. Здесь и приходит на помощь memcached. За самую простую логику был выбран следующий алгоритм:
1. Проходим циклом по всем группам
2. Берем все публикации i-й группы и выбираем 2 лучшие из них за указанный промежуток времени
Как результат, в выдаче от одной группы будет не более 2 публикаций. Конечно, это не самый правильный результат, но на практике показывает неплохую статистику и актуальность контента.
Вот как выглядит код потока, который раз в 15 минут генерирует index-страницу:
```
# timeDelta - тип фильтра по времени (hour, day, week, year, alltime)
# filterType - likes, reposts, comments
# deep - 0, 1, ... (страница)
def _get(self, timeDelta, filterTime, filterType='likes', deep = 0):
groupList = groups.find({}, {'_id' : 0})
allPosts = []
allGroups = []
for group in groupList:
allGroups.append(group)
postList = db['posts'].find({'gid' : group['id'], 'created' : {'$gt' : timeDelta}}) \
.sort(filterType, -1).skip(deep * 2).limit(2)
for post in postList:
allPosts.append(post)
result = {
'posts' : allPosts[:50],
'groups' : allGroups
}
# Этот код позволяет сгенерировать timestamp из mongotime, при конвертировании в json
dthandler = lambda obj: (time.mktime(obj.timetuple()) if isinstance(obj, datetime.datetime) or isinstance(obj, datetime.date) else None)
jsonResult = json.dumps(result, default=dthandler)
key = 'index_' +filterTime+ '_' +filterType+ '_' + str(deep)
print 'Setting key: ',
print key
self.memcacheHandle.set(key, jsonResult)
```
Опишу фильтры, которые влияют на выдачу:
Время: час, день, неделя, месяц, год, все время
Тип: лайки, репосты, комментарии
Для всех пунктов времени были сгенерированы объекты
```
hourAgo = datetime.datetime.now() - datetime.timedelta(hours=3)
midnight = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
weekAgo = datetime.datetime.now() - datetime.timedelta(weeks=1)
monthAgo = datetime.datetime.now() + dateutil.relativedelta.relativedelta(months=-1)
yearAgo = datetime.datetime.now() + dateutil.relativedelta.relativedelta(years=-1)
alltimeAgo = datetime.datetime.now() + dateutil.relativedelta.relativedelta(years=-10)
```
Все они по очереди передаются в функцию **\_get** вместе с разными вариациями фильтра по типу (лайки, репосты, комментарии). Еще ко всему этому, нужно сгенерировать по 5 страниц для каждой вариации фильтров. Как результат, в memcached проставляются следующие ключи:
> Setting key: index\_hour\_likes\_0
>
> Setting key: index\_hour\_reposts\_0
>
> Setting key: index\_hour\_comments\_0
>
> Setting key: index\_hour\_common\_0
>
> Setting key: index\_hour\_likes\_1
>
> Setting key: index\_hour\_reposts\_1
>
> Setting key: index\_hour\_comments\_1
>
> Setting key: index\_hour\_common\_1
>
> Setting key: index\_hour\_likes\_2
>
> Setting key: index\_hour\_reposts\_2
>
> Setting key: index\_hour\_comments\_2
>
> Setting key: index\_hour\_common\_2
>
> Setting key: index\_hour\_likes\_3
>
> Setting key: index\_hour\_reposts\_3
>
> Setting key: index\_hour\_comments\_3
>
> Setting key: index\_hour\_common\_3
>
> Setting key: index\_hour\_likes\_4
>
> Setting key: index\_hour\_reposts\_4
>
> Setting key: index\_hour\_comments\_4
>
> Setting key: index\_hour\_common\_4
>
> Setting key: index\_day\_likes\_0
>
> Setting key: index\_day\_reposts\_0
>
> Setting key: index\_day\_comments\_0
>
> Setting key: index\_day\_common\_0
>
> Setting key: index\_day\_likes\_1
>
> Setting key: index\_day\_reposts\_1
>
> Setting key: index\_day\_comments\_1
>
> Setting key: index\_day\_common\_1
>
> Setting key: index\_day\_likes\_2
>
> Setting key: index\_day\_reposts\_2
>
> Setting key: index\_day\_comments\_2
>
> Setting key: index\_day\_common\_2
>
> Setting key: index\_day\_likes\_3
>
> Setting key: index\_day\_reposts\_3
>
> ...
А на стороне клиента лишь генерируется нужный ключ и вытаскивается json-строка из memcached.
##### Twitter
Следующим интересным заданием было сгенерировать популярные твиты по странам СНГ. Задание тоже непростое, хотелось бы получать актуальную и не «трешовую» информацию. Я очень удивился ограничениям твиттера: не получится так просто взять и слить все твиты определенных пользователей. API очень ограничивает количество запросов, поэтому уже нельзя сделать так, как это делает вк: составить список популярных аккаунтов и постоянно парсить их твиты.
Через день пришло решение: создаем аккаунт в твиттере, подписываемся на всех важных людей, тематика публикаций которых нам интересна. Трюк в том, что почти в 80% случаев, кто-то из этих людей сделает ретвит какого-то популярного твита. Т.е. нам не нужно иметь в базе список всех аккаунтов, достаточно набрать базу из 500-600 активных людей, которые постоянно в тренде и делают ретвиты реально интересных и популярных твитов.
В API твиттера есть метод, который позволяет получить ленту пользователя, которая включает твиты тех, на кого мы подписаны и их репосты. Все, что нам нужно теперь — раз в 10 минут считывать по максимуму нашу ленту и сохранять твиты, фильтры и все остальное делаем так же, как и в случае с вконтакте.
Итак, был написан еще один поток внутри демона, который раз в 10 минут запускал такой код:
```
def __init__(self):
self.twitter = Twython(APP_KEY, APP_SECRET, TOKEN, TOKEN_SECRET)
def logic(self):
lastTweetId = 0
for i in xrange(15): # Цифра подобрана методом тыка
self.getLimits()
tweetList = []
if i == 0:
tweetList = self.twitter.get_home_timeline(count=200)
else:
tweetList = self.twitter.get_home_timeline(count=200, max_id=lastTweetId)
if len(tweetList) <= 1:
print '1 tweet, breaking' # Все, больше твитов API нам не выдаст
break
# ...
lastTweetId = tweetList[len(tweetList)-1]['id']
```
Ну а дальше обычный и скучный код: у нас есть tweetList, проходим циклом и обрабатываем каждый твит. Список полей в официальной документации. Единственное, на чем хочу акцентировать внимание:
```
for tweet in tweetList:
localData = None
if 'retweeted_status' in tweet:
localData = tweet['retweeted_status']
else:
localData = tweet
```
В случае с ретвитом, нам нужно сохранять не твит одного из наших подписчиков, а оригинальный. Если текущая запись это ретвит, то она содержит внутри по ключу 'retweeted\_status' точно такой же объект твита, только оригинального.
##### Финал
С дизайном сайта и версткой есть проблемы (сам я ни разу не веб-программист), но, надеюсь, кому-то будет полезная информация, которую я описал. Сам уже очень много времени работаю с соц. сетями и их API и знаю много трюков. Если у кого-то будут какие-то вопросы — буду рад помочь.
Ну и несколько картинок:
###### Index-страница:
###### Страница одной из групп, которую я постоянно мониторю:
###### Твиттер за день:
Спасибо за внимание.
— [88.198.106.150](http://88.198.106.150/) | https://habr.com/ru/post/238765/ | null | ru | null |
# Подключение и работа с MySQL в VB.NET
#### Предыстория. Выбор БД
Возникла необходимость подружить программу, написанную на VB, с сервером баз данных. Конечно, многочисленные сотоварищи — разработчики ПО могут поставить под сомнение мой выбор базы данных (и будут правы), назвав MSSQL самым простым и очевидным выбором. Но необходимо принять во внимание несколько фактов:
* кроме основной программы (VB), заказчик пожелал иметь возможность использовать и web-интерфейс (php)
* на сервере заказчика установлен MySQL
#### Настройка подключения к MySQL
Поскольку в VB нет стандартного механизма подключения к MySQL было принято решение использовать не [ODBC](http://dev.mysql.com/downloads/connector/odbc/), а [Connector/NET](http://dev.mysql.com/downloads/connector/net/).
Для начала необходимо подключить библиотеку коннектора.
По умолчанию в Solution Explorer'е существует пункт My Project. Его собственно и выбираем, далее переходим в References.
Должно выглядеть примерно [так](http://imgin.ru/images/b523dbf2fbd2b5c0f49f41eeffb76828.jpg), но соответственно без MySql.Data. У меня уже подключена эта библиотека.
Нажимаем [добавить](http://imgin.ru/images/f6344d4bd7a600df15d766d54d88aa9c.jpg) (add), выбираем вкладку Browser и ищем библиотеку. Находится она по следующему пути: путь\_куда\_вы\_ставили\_mysql\_connector/Assemblies/версия .net/MySql.Data.dll
После добавления библиотеки в проект обязательно измените параметр копировать локально (в Окне Свойств, Properties, при выделенном пункте списка) на true, иначе при запуске ПО на компьютере без MySQL Connector/NET приложение будет вываливаться с ошибкой dll.
После всего это можно спокойно приступать к написанию программы.
#### Подключение
Для начала импортируем типы строчкой Imports MySql.Data.MySqlClient. Ее необходимо разместить в области определения до создания каких либо классов/объектов. Это необходимо для того, чтобы избавить нас от необходимости каждый раз писать полный путь до типов при определении переменных.
```
Imports MySql.Data.MySqlClient
```
Для создания подключения необходимо создать объект типа MySqlConnection и задать ей ConnectionString (строка подключения — описывает необходимые параметры для подключения к серверу).
```
'User id пишется с пробелом, это не опечатка.
Dim conn As New MySqlConnection("Server=127.0.0.1;User id=test_user;password=test_pwd;database=test_db")
```
Таким образом, через conn программа будет подключаться к указанной базе на localhost'е, с указанными логином и паролем.
#### Выполнение запросов
Для исполнения запросов так же необходимо создать объект типа MySqlCommand.
```
Dim cmd As New MySqlCommand
```
Текст запроса при таком положении дел задается путем изменения свойства CommandText объекта cmd:
```
cmd.CommandText = "текст запроса"
```
Кроме того, важно не забыть указать, какое конкретно подключение использовать для выполнения запроса.
```
cmd.Connection = conn
```
Для выполнения различных запросов к базе данных в Connector/NET используются различные функции.
Так, например, для выполнения запросов, возвращающих только общее количество задействованных строк, используется функция ExecuteNonQuery, а для возвращающих данные (строки) — создается объект reader.
В итоге, на выходе мы имеем приложение, которое при загрузке выполняет запрос к базе данных.
```
Imports MySql.Data.MySqlClient
Public Class Form1
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
Dim conn As New MySqlConnection("Server=127.0.0.1;User id=test_user;password=test_pwd;database=test_db")
Dim cmd As New MySqlCommand
Try
conn.Open()
cmd.Connection = conn
'Для выполнения запросов типа insert, update возможно использование ExecuteNonQuery, которая возвращает количество задействованных строк
cmd.CommandText = "INSERT INTO `test_table` (`id`, `test_info`) VALUES (NULL, 'some text info for current id');"
Try
cmd.ExecuteNonQuery()
Catch ex As Exception
'описание того, что программа должна делать в случае возникновения каких-либо непредвиденных обстоятельств
End Try
'для получения данных из таблиц (запросы типа select) используется reader.
cmd.CommandText = "SELECT * FROM `test_table`"
Dim reader As MySqlDataReader
reader = cmd.ExecuteReader()
While reader.Read()
'получаем и сообщаем пользователю значения первого столбца базы данных для всех выбранных запросом строк
MsgBox(reader.GetValue(0))
End While
Catch ex As Exception
'описание действий при проблемах с подключением к БД
End Try
End Sub
End Class
``` | https://habr.com/ru/post/162329/ | null | ru | null |
# PHP-Дайджест № 192 (2 – 16 ноября 2020)
[](https://habr.com/ru/post/528256/)
Свежая подборка со ссылками на новости и материалы. В выпуске: Последний релиз-кандидат PHP 8.0 перед финальным релизом и свежие материалы по PHP 8, RFC и обсуждения из PHP Internals, порция полезных инструментов, стримы, подкасты, статьи.
Приятного чтения!
### Новости и релизы
* **[PHP 8.0 RC 4](https://www.php.net/archive/2020.php#2020-11-12-1)** — Последний релиз-кандидат перед финальным выпуском PHP 8, который намечен на 26 ноября.
Свежие материалы по PHP 8:
+ Обновление серии постов от Larry Garfield: [про атрибуты](https://platform.sh/blog/2020/php-8-0-feature-focus-attributes/) и [объявление свойств в конструкторе](https://platform.sh/blog/2020/php-80-feature-focus-constructor-property-promotion/).
+  [Видеокурс по основным фичам PHP 8 от Spatie](https://spatie.be/videos/front-line-php).
+ В PHP 8 [оператор `@` не будет подавлять фатальные ошибки](https://php.watch/versions/8.0/fatal-error-suppression), а именно ошибки типов: `E_ERROR`, `E_CORE_ERROR`, `E_COMPILE_ERROR`, `E_USER_ERROR`, `E_RECOVERABLE_ERROR`, `E_PARSE`.
+ [О WeakMap в PHP 8 с примерами реального применения](https://php.watch/articles/practical-weakmap).
+ [Как сконфигурировать JIT в PHP 8](https://stitcher.io/blog/php-8-jit-setup).
Кроме того, в PHP 8 по умолчанию удален PECL. Из-за этого могут поломаться Dockerfile, в которых с его помощью устанавливались расширения. Вместо PECL можно использовать [FriendsOfPHP/pickle](https://github.com/FriendsOfPHP/pickle).
**Скрытый текст**
```
RUN curl -L -o /tmp/pickle.phar https://github.com/FriendsOfPHP/pickle/releases/latest/download/pickle.phar; \
mv /tmp/pickle.phar /usr/local/bin/pickle; \
chmod +x /usr/local/bin/pickle; \
pickle install xdebug; \
RUN echo "extension=xdebug.so" >> $PHP_INI_DIR/conf.d/php.ini; \
```
Или так:
```
RUN mkdir -p /usr/src/php/ext/xdebug && \
curl -fsSL https://pecl.php.net/get/xdebug | \
tar xvz -C "/usr/src/php/ext/xdebug" --strip 1 && docker-php-ext-install xdebug
```
* **[phpcommunity.ru](https://phpcommunity.ru/)** — PHP-сообщества в России, Беларуси, Украине.
+ [Полезные привычки программиста после 30, MySQL vs Postgres и как поговорить об этом в субботу](https://habr.com/ru/company/skyeng/blog/527156/).
+ [Как обстоят дела с PHP в Краснодаре (и не только)](https://habr.com/ru/company/skyeng/blog/526146/).
Ближайшие митапы: [PHP-митап Иннополис онлайн, 19 ноября](https://oez-innopolis.timepad.ru/event/1471081/); [Online-митап по PHP от SimbirSoft, 20 ноября](https://simbirsoft.timepad.ru/event/1467649/).
### PHP Internals
* [[Draft] Closure self reference](https://wiki.php.net/rfc/closure_self_reference) — Ранний черновик на обсуждении. Предлагается в замыканиях добавить псевдопеременную `$lambda`, которая указывает на само замыкание. По аналогии с `$this` для классов.
```
$fibonacci = function (int $n) use (&$fibonacci) {
if ($n === 0) return 0;
if ($n === 1) return 1;
return $fibonacci($n-1) + $fibonacci($n-2);
};
// =>
$fibonacci = function (int $n) {
if ($n === 0) return 0;
if ($n === 1) return 1;
return $lambda($n-1) + $lambda($n-2);
};
```
* [[PR] Support for ::function syntax](https://github.com/adsr/php-src/commit/07bb24243022ccef5823f6977d231f3535a48a07) — Концепт синтаксиса `::function` (или `::fn`) для получения полного неймспейса и имени функции по аналогии с `::class`. Подобное предложение обсуждалось раньше и имеет [проблемы](https://externals.io/message/112201#112212), но вполне вероятно будет принято.
* [[Discussion] Alias for `int|float`](https://externals.io/message/112209) — Обсуждалась возможность ввести псевдоним `number` или `numeric` для объединенного типа `int | float`. В комментариях указали, что уж лучше позже сделать полноценные алиасы для типов как в TypeScript: `type Number = Foo|Bar;`.
### Инструменты
* [mnavarrocarter/php-fetch](https://github.com/mnavarrocarter/php-fetch) — Порт fetch WebApi на PHP без сторонних зависимостей. Лаконичный HTTP-клиент в одной функции:
**Скрытый текст**
```
use function MNC\Http\fetch;
$response = fetch('https://habr.com');
echo $response->status()->code(); // 200
echo buffer($response->body());
// or
while (($chunk = $response->body()->read()) !== null) {
echo $chunk;
}
```
* [themsaid/ibis](https://github.com/themsaid/ibis) — Поможет сгенерировать полноценную электронную книгу в PDF из markdown-файлов.
* [i582/phpstats](https://github.com/i582/phpstats) — Инструмент для сбора метрик кода и графов зависимостей для PHP. Реализован на базе [VKCOM/noverify](https://github.com/VKCOM/noverify), то есть на Go.
* [mihaeu/dephpend](https://github.com/mihaeu/dephpend) — Инструмент статического анализа, который поможет выявить проблемы в архитектуре путем анализа зависимостей классов.
* [httpsoft/http-message](https://github.com/httpsoft/http-message) — Строгая и быстрая реализация стандартов [#PSR-7](https://pronskiy.com/php-digest/?q=PSR-7) и [#PSR-17](https://pronskiy.com/php-digest/?q=PSR-17).
* [spatie/crypto](https://github.com/spatie/crypto) — Небольшая обертка над openssl для шифрования данных с помощью приватного/публичного ключа. Вводный [пост](https://freek.dev/1829-encrypting-and-signing-data-using-privatepublic-keys-in-php).
* [icanhazstring/systemctl-php](https://github.com/icanhazstring/systemctl-php) — PHP-обертка над systemctl.
### Symfony
*  [Symfony Panther: PHP-библиотека для тестирования из браузера и парсинга веб-страниц](https://phpprofi.ru/blogs/post/106).
* [Что нового будет в Symfony 5.2](https://symfony.com/blog/symfony-5-2-curated-new-features) .
*  [Несколько видеотуториалов по Symfony](https://www.youtube.com/playlist?list=PLQH1-k79HB39w7dmGtLj4JGJ7HoucbcMx).
* [Неделя Symfony #723 (9-15 ноября 2020)](https://symfony.com/blog/a-week-of-symfony-724-9-15-november-2020)
### Laravel
* [laravel/breeze](https://github.com/laravel/breeze) — Новый пакет от Тейлора. По сути, одна консольная команда для быстрого разворачивания приложения на Laravel + Tailwind CSS + контроллеры для аутентификации.  [Видеообзор пакета](https://www.youtube.com/watch?v=dofUcI1PkUA).
* [spatie/laravel-settings](https://github.com/spatie/laravel-settings) — Позволяет работать с конфигом приложения в типизированном стиле. Вводный [пост](https://freek.dev/1828-store-strongly-typed-settings-in-a-laravel-app).
* [ksassnowski/venture](https://github.com/ksassnowski/venture) — Инструмент позволяет строить сложные цепочки задач на основе системы очередей Laravel.
*  [Laravel Podcast S4:E17](https://laravelpodcast.simplecast.com/episodes/the-service-container-with-christoph-rumpel) — C Christoph Rumpel про сервис-контейнер Laravel.
*  Стрим [об обновлении пакета spatie/laravel-event-sourcing на PHP 8](https://www.youtube.com/watch?v=X3fmQ5Rs9GY).
*  [Обзор плагина Laravel Idea](https://www.youtube.com/watch?v=o5WJIS9yWCo) для PhpStorm.
*  [Laravel–Дайджест (2–8 ноября 2020)](https://habr.com/ru/post/526934/)
### Yii
*  [Новости Yii 2020, выпуск 7](https://habr.com/ru/post/527634/) — Релизы Yii 2, прогресс по Yii 3, важные вести о Yii 1 и другие новости.
### Async PHP
* [clue/reactphp-term](https://github.com/clue/reactphp-term) — Потоковый эмулятор терминала.
* [clue/reactphp-utf8](https://github.com/clue/reactphp-utf8) — Потоковый парсер UTF-8.
### phpstorm PhpStorm
* [PhpStorm 2020.3 EAP #6](https://blog.jetbrains.com/phpstorm/2020/11/phpstorm-2020-3-eap-6/) — В раннем доступе поддержка Tailwind CSS и Xdebug 3.
* [Подборка трюков и советов по PhpStorm в твитах](https://twitter.com/i/events/1268886882013917184).
* [IntelliJ плагин для Alpine.js](https://github.com/inxilpro/IntellijAlpine) — Добавляет автокомплит директив.
* [Elephpant Progress Bar](https://plugins.jetbrains.com/plugin/15291-elephpant-progress-bar) — Заменяет прогресс бары на слоника.
### Разное
*  [ВКонтакте снова выкладывает](https://habr.com/ru/company/vk/blog/527420/) [VKCOM/kphp](https://github.com/vkcom/kphp) — Ребята из ВКонтакте заопенсорсили свой компилятор PHP. Коротко было [в канале](https://t.me/phpdigest/193), а подробнее в [анонсе на Хабре](https://habr.com/ru/company/vk/blog/527420/).
* [Как разрабатывать на PHP 7.4 и деплоить на PHP 7.1](https://blog.logrocket.com/coding-in-php-7-4-and-deploying-to-7-1-via-rector-and-github-actions/) с помощью [rectorphp/rector](https://github.com/rectorphp/rector/) GitHub Actions. Когда хочется использовать новые фичи языка, но обновить целевую систему нет возможности.
* [О поддержке атрибутов PHP 8 в Psalm](https://psalm.dev/articles/php-8-attributes).
* [php-fig-rectified/fig-rectified-standards](https://github.com/php-fig-rectified/fig-rectified-standards) — Попытка создать альтернативные стандарты. В частности, сделан [PSR-2-R](https://github.com/php-fig-rectified/fig-rectified-standards/blob/master/PSR-2-R-coding-style-guide.md) с табами вместо пробелов и скобками для классов и методов на одной строке с декларацией.
### Аудио/Видео
* **PHP Internals News** — подкаст, в котором Derick Rethans (Xdebug) берет интервью у авторов RFC.
+  [Episode 69: Short Functions](https://phpinternals.news/69) — C [Larry Garfield](https://twitter.com/crell) про [однострочные именованные функции / методы](https://wiki.php.net/rfc/short-functions).
+  [Episode 70: Explicit Octal Literal](https://phpinternals.news/70) — C [George Peter Banyard](https://twitter.com/Girgias) про запись [восьмеричных чисел в PHP](https://wiki.php.net/rfc/explicit_octal_notation).
*  [ОНТИКО подкаст](https://anchor.fm/ontico/episodes/ep-em0h40) — В первом выпуске в гостях Александр Макаров.
*  PHPBenelux Virtual Meetup: [Damien Seguy — Modernize your PHP with Exakat](https://youtu.be/XKjiAWxwFR0?t=1643), [Wim Godden — Why and How of moving to PHP 8](https://youtu.be/XKjiAWxwFR0?t=6392).
*  [О создании дев-окружения для PHP с помощью Docker Compose](https://www.youtube.com/watch?v=BFJe-uxB_Nk).
*  Митап «Фреймворки и инструменты PHP»: [Александр Макаров – Yii: уроки прошлого и будущее](https://youtu.be/MuVMe7oMoyM?t=160), [Антон Титов – Cycle ORM и графы](https://youtu.be/MuVMe7oMoyM?t=3419), [Дмитрий Елисеев — Выбор фреймворка для ентерпрайза](https://youtu.be/MuVMe7oMoyM?t=5872).
### Занимательное
* [vincentpontier.com/elephpant/](https://www.vincentpontier.com/elephpant/) — Официальный магазин слоников снова доступен! Можно заказать розового и синего.
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку хабра](https://habrahabr.ru/conversations/pronskiy/) или [телеграм](https://t.me/pronskiy).
> Больше новостей и комментариев в Telegram-канале **[PHP Digest](https://t.me/phpdigest)**.
>
>
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Поиск ссылок по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 191](https://habr.com/ru/post/526098/) | https://habr.com/ru/post/528256/ | null | ru | null |
# XenApp: Опыт установки и настройки
Доброго времени суток, Хабровчане.
##### Преамбула
XenApp (читается «ЗенАп») придуман компанией Citrix для виртуализации и доставки приложений через тонкий клиент, посредством своего собственного протокола CIA. Надо сказать, что идея сама по себе хороша, потому что в теории избавляет от многих головняков, типа покупки лицензионного софта от Империи Зла и других, чуть менее жадных вендоров. Конечно, это интересно, только если брать приложения в аренду, потому что лицензии на XenApp стоят достаточно дорого. Хочется отметить, что XenApp работает только под Windows.
Не знаю, к сожалению или к счастью, но все крупнейшие производители самого потребляемого софта сейчас имеют свои полнофункциональные продукты, доступные либо через web-интерфейс, либо через тонкий клиент, поэтому мне кажется, что XenApp, как отдельный продукт, очень скоро станет неинтересен конечному потребителю, и останется в поле зрения у компаний, которые сами занимаются арендой приложений. Как раз на аренду приложений сделала ставку моя компания.
И после того, как я был озадачен этой интересной затеей, я понял, что гугль ничего внятного на русском языке про XenApp не выдаёт, а всё, что можно покурить — это обширный мануал на сайте Citrix.com на английском языке. Но разве для нас это проблема?
Руководствуясь чувством «помочь ближнему своему» я решил описать процесс установки и настройки XenApp, который мне пришлось расковыривать самостоятельно, используя англоязычный мануал и плохо знакомого человека, который лицензированный специалист Citrix.
**ВНИМАНИЕ!**
Для нормальной работы XenApp требуется наличие официальных лицензий от Citrix.
Получить их можно, связавшись с любым официальным представителем Citirx и рассказав о том, что мы хотим попробовать продукт, с целью стать партнёром, и оказывать услуги по аренде приложений. Так можно получить много лицензий сроком на девяносто дней, или сто лицензий сроком на 1 год.
**ЕЩЁ ВАЖНО ПОМНИТЬ:**
Лицензии выдаются на ИМЯ КОМПЬЮТЕРА, поэтому расходуйте их аккуратно. В целом про лицензирование скорее всего придётся писать отдельную статью, т.к. это не так тривиально, как может показаться.
##### Требования по железу
Если верить официально заявленному Систем Реквайременту компании Citrix, то чтобы установить XenApp, нам нужно примерно следующее:
*64-bit architecture with Intel Pentium Xeon family with Intel Extended Memory 64 Technology
AMD Opteron family AMD Athlon 64 family Compatible processor*
А так-же:
*Memory: 512MB RAM (minimum) Disk space: 32GB (minimum) TROLLFACE*
На русский язык я смог перевести только синонимами:
*— Процессор 64-битный, обязательно с поддержкой технологий виртуализации (Intel VT или Amd-V), ядрах так хотя-бы о двух.
— Памяти не менее двух гигабайт, а лучше конечно все шесть.
— HDD не менее 60 гигабайт, SATA.
— Сетевая карта, Intel Pro-серии, гигабитная.*
##### Требования по софту
Из софта нам потребуется:
— Windows Server 2008 R2 x64 DCE, хотя вполне сгодится и Enterprise, с установленными последними обновлениями.
— Дистрибутив XenApp 6.5 Platinum Edition (для скачивания с сайта Citrix потребуется регистрация).
— Microsoft NetFramework 3.5 (в нашем случае качать не нужно, XenApp его включит сам в роли IIS на Win2k8R2)
— Дистрибутивы доставляемых приложений (например, MS Office или 1C).
Так же дистрибутив XenApp установит нам для своей работы много софта, как то:
— Microsoft Visual C++ 2008 SP1 Redistributable (x64)
— Microsoft SQL Server 2008 Express R2
— Microsoft Primary Interoperability Assemblies 2005
— И т.д., нас это не должно волновать, пока не будет проблем :)
И поднимет роли:
— Web Server (IIS)
— Microsoft Terminal Services
Далее рекомендую быть очень внимательным, потому что неверная последовательность установки компонент Windows очень легко может привести к тому, что ничего не заработает, и Windows придётся сносить и ставить заново, потратив на это кучу времени.
**ВАЖНО!**
После установки и настройки Windows, установки последних обновлений, очень желательно сделать образ системы акронисом, или другой подобной программой, чтобы в случае неудачных действий можно было легко накатить чистую систему обратно и приступить к установке заново. В моём случае это облако, поэтому я тупо создал шаблон из полностью подготовленной системы.
Так же очень важно присвоить необходимое имя серверу заранее, перед началом установки XenApp.
По умолчанию, Citrix предполагает, что XenApp разворачивается на сервере, введённом в домен Windows. Т.е. предполагается наличие в сети конTROLLера домена. Но на самом деле XenApp легко ставится и без конTROLLера, и работает в рабочей группе не хуже, чем в сети с AD. Это решение сильно зависит от ваших конечных потребностей.
Так же предполагается, что сервер с XenApp находится за NAT-ом, который имеет какой-то конкретный внешний ip-адрес, выданный провайдером. Можно заранее переписать этот ip-адрес на бумажку, он нам ещё пригодится.
##### Установка
Методом проб и ошибок, а так же чтения мануала с похмелья да ещё и на пиндосском, была определена чёткая последовательность действий, которая гарантирует на 100%, что XenApp на вашем серваке совершенно точно поднимется и позволит себя настраивать. О продакшене мы пока молчим, до этого ещё надо дойти. Итак, секретная последовательность такая:
Перво-наперво ставим и обновляем Windows Server 2008 R2. Затем качаем Microsoft NetFramework 4, ставим, и снова обновляем систему. Затем заходим в папку с дистрибутивом XenApp (предполагается, что образ ISO уже разархивирован в отдельную папку на винте), и запускаем файл с названием autorun.exe :).
После этого установщик предложит нам установить NetFramework 3.5 с первым сервиспаком. Соглашаемся (жмём ОК).
Далее необходимо установить роли. Делается это путём нажатия кнопки с очевидной надписью Add server roles.
Мы нажимаем на эту кнопку, указываем Platinum Edition, принимаем Лиценз Агрыымент, и выбираем следующие роли:
*License server
XenApp
Web Interface*
Жмём «далее» на следующей вкладке выбираем
XML Service IIS Integration(обязательная компонента!).
Больше НИЧЕГО выбирать не надо!
Два раза жмём Next, Install и ждём, чем закончится. Можно выпить кофейку и курнуть.
После непродолжительной установки XenApp выдаст окно с кучей восклицательных знаков и кнопкой «Finish».
В этом нет ничего страшного, просто нужна перезагрузка. Закрываем все окна и перезагружаем сервак. После перезагрузки setup возобновит свою работу автоматически, нужно выбрать «Resume install», и ждать, когда же наконец-то уже всё.
ВНИМАНИЕ! Все компоненты должны установиться без ошибок!
Т.е. все пункты должны быть отмечены зелёной галочкой! В противном случае придётся сносить и ставить систему заново!
В итоге всех телодвижений у нас должно появиться окно установщика со списком установленных компонент, напротив каждой из которых появится слово «configure».
##### Настройка
Итак, XenApp установился и предлагает нам его настроить. В окне программы мы видим:
*XenApp — Specify Licensing
Web Interface — Configure
License Server — Configure*
Начать надо с License Server — Configure.
По умолчанию предполагается наличие у вас лицензий Citrix XenApp Platinum Edition. Жмём Configure. Он предлагает настроить порты:
*License Server Port: 2700
Vendor Daemon Port: 7279
Management Console Web Port: 8082*
Порты менять не следует!
Задаём пароль админа и жмём ОК. License Server помечен зелёной галочкой и перешёл в состояние Configured.
После этого нужно добавить лицензию в сервер лицензирования. Для этого идём Пуск — Все программы — Citrix — Management Consoles — License Administration Console.
В открывшемся Web-интерфейсе, справа в углу жмём Administration, и вводим пароль админа, который мы указали ранее. Затем слева внизу переходим в раздел Vendor Daemon Configuration, и жмём кнопку Import License. Выбираем наш файл лицензии, ставим галку Overwrite License File (ведь лицензия у нас только эта), и жмём Import License. Далее жмём ОК, в списке лицензий выбираем нашу лицензию, и жмём кнопку Reread License.
На этом настройка лицензий завершена. Закрываем Web-интерфейс и переходим обратно к установщику.
В установщике нам нужно нажать Specify Licensing, чтобы XenApp увидел сервер лицензий и рабочие лицензии.
Вводим имя компьютера (тот, на котором мы и производим установку), жмём Test Connection, и жмём Next.
Если XenApp распознал лицензии, то ничего менять не надо, он укажет параметры автоматом. Если не распознал — значит все предыдущие шаги нужно проделать заново. Жмём Apply и видим, что Specify Licensing перешло в состояние Configured и помечено зелёной галочкой. Теперь сконфигурируем сам сервер XenApp, нажав на Configure.
Т.к. это единственный и новый сервер XenApp в нашей сети, мы выбираем пункт Create a new server farm, т.е. создаём новую ферму серверов XenApp.
Указываем имя фермы, остальные параметры на этой вкладке оставляем по умолчанию. Дальше установщик предлагает выбор: Создать новую базу или использовать существующую. Т.к. предполагается, что никаких баз у нас нет, мы жмём New Database.
После этого вводим логин и пароль администратора сервера (только локального, даже если сервер в домене!), всё время жмём Next, оставляя параметры по умолчанию, и после нажатия Apply видим процесс настройки базы данных. Жмём Finish и Reboot.
После перезагрузки мы видим, что несконфигурированным у нас остался только Web-Interface. Перед его конфигурацией ОБЯЗАТЕЛЬНО нужно сделать следующее:
`cmd: altaddr /SET ВАШ_ВНЕШНИЙ_АЙПИ`
Сворачиваем установщик и запускаем:
Пуск — Все программы — Администрирование — Citrix — Management Consoles — CitrixApp Center
В открывшемся окне выбираем:
Disable Authenticode Signature Checking
Откроется окно настройки фермы XenApp, жмём Далее, снимаем галочку с позиции Single Sign-On, жмём Далее, жмём Add Local Computer — тут мы добавляем серверы, где установлен XenApp.
В нашем случае это локальный комп, его и добавляем.
Потом всё время далее, установщик дисковерит сеть и сервер на предмет соответствия всем указанным параметрам, и, если его всё устраивает, то предлагает нажать Apply. Жмём, и вот мы в консоли управления XenApp.
В целом на этом настройка самого XenApp закончена.
Ещё готовятся статьи о том, как подготавливать, публиковать и доставлять приложения клиентам. Так же отдельно будет рассмотрена доставка 1С v8.1.6. с HASP-ключём USB. | https://habr.com/ru/post/134334/ | null | ru | null |
# Аим-ассист в мультиплеерном шутере — как сделать правильно
Аим-ассист — вечная тема для споров среди игроков. Для одних это узаконенный чит, для других — инструмент комфортной игры. Этическую сторону вопроса сейчас обсуждать не будем, просто примем факт, что большинству пользователей неудобно целиться на геймпадах и тачскринах. И это проблема.
Пару лет назад в нашем онлайн-шутере вообще не было аим-ассиста и автострельбы. Даже в сторе было написано, что Pixel Gun 3D — «hardcore shooter». Нас это устраивало, пока не стало сложнее привлекать новую аудиторию. Даже несмотря на обучение и матчмейкинг, новичкам было сложно освоиться.
На рынке тогда уже были шутеры с автодоводкой, но она была слишком навязчивая, чересчур влияла на игровой опыт и скилл игрока. Нам предстояло разработать систему получше — чтобы не разозлить бывалых хардкорщиков и не отпугнуть новичков. Рассказываю под катом, что из этого вышло.
### Авто-аим и аим-ассист
Для начала на всякий случай определимся с терминами, чтобы не путать авто-аим и аим-ассист.
**Авто-аим (автонаведение).** Прицел жестко фиксируется на противнике, позволяя игроку расслабиться, зажать кнопку стрельбы и вообще не двигать стиком. Это, на удивление, до сих пор популярная система стрельбы, которая используется, например, в GTA V и Red Dead Redemption 2.
В мультиплеерных проектах подобное особенно фрустрирует. Почти всегда авто-аим можно отключить, но смысла в этом примерно никакого — у остальных игроков всегда будет преимущество.
**Аим-ассист (помощь в прицеливании).** Глобально он присутствует практически в любом шутере, даже на PC. Все эти маленькие хитрости разработчиков, когда пули примагничиваются к модельке противника даже если игрок на самом деле промазал на пару миллиметров, — тоже в каком-то смысле можно отнести к аим-ассисту. Например, такие лонгшоты в Battlefield были бы невозможны без помощи разработчиков:
Грамотно реализованную помощь в прицеливании пользователь может вообще не заметить. Система должна угадывать желание игрока — не выполнять что-то за него, а лишь помогать делать то, что он хочет. Именно с такими вводными мы начали думать над разработкой собственной системы помощи в прицеливании.
Выделили две концепции:
1. Когда прицел игрока попадает в область вокруг противника (обычно очень большую), то начинает примагничиваться к телу врага. Например, похожая система есть в Respawnables или Blitz Brigade на смартфонах.
Проблема в том, что она не всегда угадывает желание игрока. Допустим, он хотел перевести прицел влево, а рядом пробегал враг, «захватил» прицел и увел его в сторону. В итоге — неприятный игровой момент.
2. Другая концепция заключается в попытке предугадать поведение игрока с помощью считывания его действий. На ней и остановились.
Система отслеживает положение врага на экране и направление движения прицела игрока, пытаясь предугадать необходимые действия — провести прицел мимо или помочь навестись на цель.
Теперь подробнее о том, как это работает.
### Как устроен аим-ассист
Окей, мы решили предугадывать желание игрока и помогать ему в прицеливании. Теперь предстояло определиться, как это лучше всего сделать.
Когда игрок наводится на противника, он направляет на него прицел и движением стика (физического или сенсорного) старается удержать цель в фокусе. Концепция выглядит не такой уж и сложной — мы определяем момент движения прицела к противнику и ненавязчиво помогаем игроку. Но дьявол кроется в деталях.
Путем проб и ошибок пришли к системе из двух зон вокруг персонажа: внешней и внутренней.
1. **Внешняя зона** отвечает за помощь в доводке камеры, но не с помощью притягивания прицела к врагу, а благодаря высчитыванию изменения положения курсора внутри [ректа](https://docs.unity3d.com/ScriptReference/Rect.html) зоны.
Как это работает. Если прицел попал во внешнюю зону, а игрок движется вместе с противником, то его камера поворачивается так, чтобы прицел оставался на том же самом месте внутри этой зоны, где он был кадром ранее (плюс к этой позиции добавляется движение за счет инпута игрока). То есть мы не отбираем у игрока необходимость прицеливаться, а лишь помогаем его прицелу оставаться внутри внешней зоны.
Если резко включить ассист, то камера дернется и игрок воспримет это как вмешательство в управление. Поэтому при попадании прицела в эту зону включается специальный механизм приращения силы аим-ассиста. Назовем ее ***h***:
* ***h*** увеличивается со скоростью ***p***, если внутри зоны прицел двигается к противнику;
* ***h*** уменьшается со скоростью ***m***, если движение идет в сторону от противника;
* ***h*** уменьшается со временем.
Чтобы игрок мог легко убрать прицел из внешней зоны, ***m*** в 4 раза больше ***p*** (выведено эмпирически). Максимальное значение ***h***означает, что прицел железно закрепляется внутри ректа. Для поддержания этого значения нужно вести прицел к противнику, поэтому у нас нет ситуаций, когда игрок не ведет прицел к цели, но при этом чувствует какое-либо вмешательство. Дополнительно мы ограничили максимально разрешенную скорость доводки камеры и применили легкую интерполяцию.
Размер ректа на экране привязан к размеру противника, но не прямо пропорционально, а с поправкой на дистанцию. Даже если персонаж очень далеко, рект все равно будет занимать достаточную область экрана (если, конечно, игрок не вышел за максимальную дистанцию аим-ассиста).
Изначально наша помощь в прицеливании ограничивалась только внешней большой зоной, но этого было недостаточно. В Pixel Gun 3D персонажи перемещаются очень быстро, а интерполяция создает небольшое отставание помощи в прицеливании. Поэтому мы добавили внутрь вторую зону поменьше, которая всегда соответствует размеру персонажа на экране.
2. **Внутренняя зона**. В ней сила аим-ассиста *h* со временем не уменьшается, а растет. Также увеличивается максимальная разрешенная скорость доводки камеры (пока прицел находится внутри зоны).
Когда игрок удерживает прицел на враге, ***h*** достигает максимального значения — положение прицела «приклеивается» к внутренней зоне и меняется только инпутом самого игрока. При этом если прицел нужно отвести в сторону, то никакого сопротивления не будет за счет понижающего коэффициента ***m***.
В итоге получилась незаметная система помощи в прицеливании, абсолютно лишенная ощущения, что у игрока выхватывают управление из рук:
* доводка учитывает желания и подстраивается под пользователя;
* при неподвижном прицеле ассист не включается;
* при проведении прицела мимо врага нет сопротивления или замедления скорости камеры.
Это довольно общее описание работы аим-ассиста. Сейчас поговорим про нюансы.
### Выбор цели
Неправильно выбранная цель может сильно подпортить игровой опыт и заруинить не один матч. Например, в Call of Duty Warzone встречается проблема, когда перестреливаешься с противником, и тут внезапно второй противник, пробежавший через линию огня, уводит прицел за собой, что приводит к плачевным последствиям и разбитым геймпадам. Забегая вперед — у себя мы решили эту проблему.
В нашем проекте много сущностей. Игроки и разные противники: турели, зомби, роботы, а еще есть разрушаемые объекты. Мы создали интерфейс IAimHelp и реализовали его для каждого уничтожаемого объекта — поэтому аим-ассист работает на все, что можно убить или уничтожить.
У каждой сущности, реализующей IAimHelp, для считывания попаданий есть один или несколько коллайдеров (хитбоксов), к которым мы напрямую привязали размер зон ассиста. Это решило кучу проблем с настройкой зон под каждую сущность.
Во время игры нужно понять, попал ли прицел игрока внутрь одной или нескольких внешних зон объекта, реализующего IAimHelp. Если выстраивать ректы каждый кадр для каждой сущности, то уйдет очень много ресурсов, поэтому сначала вычисляется вектор от игрока до сущности, после чего, используя скалярное произведение векторов, отсекаются все сущности, которые не попадают в область видимости игрока.
Отсечение при помощи скалярного произведения векторов:
```
private bool IsTargetInCameraCone(Vector3 IAimHelpPos,ref Vector3 deltaVector)
{
deltaVector = IAimHelpPos - myCamera.position;
Vector3 direction = (deltaVector).normalized;
return Vector3.Dot(direction, myCamera.direction) > 0.7f;
}
```
Затем для каждой сущности сохраняется дистанция и отсеивается все, что дальше максимально разрешенного расстояния для аим-ассиста.
Дальше пробрасывается луч в каждую из целей, чтобы определить, есть ли препятствие между игроком и целью — остаются только цели в прямой видимости игрока. И уже после этого высчитываются ректы.
Просчет ректа зоны для прицеливания:
```
public static Rect AimHelpRect(Collider c, AimSettings settingsContainer, float fieldOfView, float distanceToTarget , Camera mainCamera )
{
var bounds = new Bounds();
bounds = c.bounds;
Vector3 screenPoint = mainCamera.WorldToScreenPoint(bounds.center);
float width = bounds.size.x / GetSizeFactorByFOV(fieldOfView) / distanceToTarget * Screen.width * settingsContainer.width;
float height = bounds.size.y / GetSizeFactorByFOV(fieldOfView) / distanceToTarget * Screen.height * settingsContainer.height;
Rect newRect = new Rect(new Vector3(screenPoint.x, Screen.height - screenPoint.y) - new Vector3(width, height) / 2, new Vector2(width, height));
return newRect;
}
```
При построении ректа очень важен угол обзора, так как снайперский прицел работает за счет его сужения, поэтому ректы должны правильно перестраиваться.
Отсюда формула влияния поля зрения на размер ректа на экране:
```
public static float GetSizeFactorByFOV(float fov)
{
if (lastFov == fov)
{
return lastFovFactor;
}
float factor = 1;
float halffov = fov / 2;
float angleY = 180f - 90f - halffov;
factor = Mathf.Abs(Mathf.Sin(halffov * Mathf.Deg2Rad) / Mathf.Sin(angleY * Mathf.Deg2Rad) * 2);
lastFov = fov;
lastFovFactor = factor;
return factor;
}
```
Дальше идет проверка попадает ли прицел игрока внутрь ректа. И, если да, то цель становится текущей:
```
if (rect.Contains(AimSupportController.CenterOfScreen))
{
SetTarget(enemyTarget);
}
```
После этого у активной цели каждый кадр строится рект и проверяется видимость при помощи RayCast. Цель перестает быть активной, если RayCast не достигает ее или если прицел не находится в ректе дольше секунды.
Этот алгоритм работает, если у игрока еще нет ни одной цели. Другая ситуация — если игрок решит навестись на другого соперника, чей рект перекрыт ректом текущей цели.
В этом помогает проброска луча в центр экрана — каждые несколько кадров луч летит через все объекты по направлению обзора игрока, и если он дольше определенного времени попадает в другой объект, доступный для аим-ассиста, то текущей целью будет выбран именно этот объект.
В результате мы получили удобную систему выбора цели: активная цель не сбрасывается, если ненадолго пропадет из видимости, пробегающие мимо враги не перехватывают ассист на себя, а когда игрок специально наводится на другую цель, то аим-ассист переключается на нее.
### Адаптивность
На силу помощи в прицеливании влияют сразу несколько факторов:
* дистанция до цели;
* уровень скилла игрока;
* настройки оружия.
Насчет дистанции все ясно — чем дальше, тем меньше помощи. Но на деле все немного сложнее — чем дальше противник, тем меньше его хитбокс. Поэтому если понижать силу аим-ассиста линейно, то он будет бесполезен для дальних целей. Чтобы настроить фактор снижения силы помощи в зависимости от дистанции, мы использовали редактируемую кривую. В Unity это AnimationCurve.
Аим-ассист — дополнительная возможность комфортной игры для новичков, но в руках хардкорных геймеров — оружие массового поражения. Если новички еще изучают игровые механики и даже с ассистом не всегда попадают в цель, то игроки-ветераны будут выкашивать целые сервера, раздавая хедшоты направо и налево. Чтобы это сгладить, мы ввели адаптивную шкалу помощи в прицеливании в зависимости от опыта игрока.
Разумеется, аим-ассист ощущается иначе в зависимости от типа оружия. Например, пользы от него на пулемете с большим разбросом гораздо меньше, чем на ваншотной снайперской винтовке. В скором времени планируем это доработать и добавить для каждого оружия индивидуальные параметры помощи в прицеливании.
### Как работает автострельба
Менее актуальная функция для PC и консолей, но часто необходимая в мобильных проектах — автострельба. Суть понятна из названия: когда игрок нацелился на игрока, то оружие автоматически начинает стрелять. Нужна она исключительно ради дополнительного удобства на мобильных девайсах, где нет физических кнопок.
Хотя умельцы из Китая уже понаделали множество специальных механических триггеров, которые крепятся на грань смартфонов и превращают его в подобие геймпада.
На AliExpress полным полно таких аксессуаров рублей за 200Но мы все же исходим из того, что 99% игроков используют только сенсорный экран смартфона. Поэтому с автострельбой есть свои фишки. Ее, конечно, при желании тоже можно отключить.
В любом шутере есть несколько видов оружия: автоматы, пулеметы, снайперские винтовки, дробовики. Если разрешить мощной пушке стрелять сразу же после наведения прицела — появится проблема так называемых «хитсканов». Игрок возьмет ваншотную снайперку, будет хаотично водить пальцем по экрану и всех убивать. От игры с таким соперником мало удовольствия (вспоминаем видео с Red Dead Online выше).
Поэтому мы привязали момент начала автострельбы к скорострельности пушки — чем она выше, тем быстрее начнется автострельба. Например, на скорострельных автоматах задержка минимальная, а на снайперках — максимальная. При этом на урон мы не смотрим, так как он изначально привязан к скорострельности.
Таймер рассчитать довольно просто, хватает лишь минимальной и максимальной задержки перед автострельбой и скорострельности самой пушки, умноженной на определенный коэффициент.
С тем, когда включать автострельбу разобрались, но появилась другая проблема. Игрок навелся из автомата, началась автострельба, враг убегает и прицел соскакивает с него. Должна ли автострельба прекратиться? Нет. Игроки привыкли, что с автоматическим оружием нужно «зажимать», водить прицел и поливать врагов пулями — это привычный сценарий использования.
Чтобы реализовать этот сценарий, мы добавили еще один параметр — таймер прекращения автострельбы после потери цели. Например, у автоматов он долгий, чтобы можно было стрелять с «зажимом», а у снайперских винтовок — короткий, чтобы лишний раз не промазать. В обоих случаях это положительный игровой опыт.
Также важно, чтобы игроку было понятно, когда у него сработает автострельба. На автоматах она начинается почти сразу и понять это не сложно. Но на снайперках из-за высокой задержки ситуация другая, поэтому научить игрока поможет UI и специальная индикация. Например, мы добавили внешние элементы прицела — они сходятся вместе и сигнализируют о начале стрельбы. Кроме того, у пушек разная дальность и игрок должен понимать, начнется ли автострельба вообще, поэтому прицел имеет дополнительную цветовую индикацию (красный — автострельба возможна, белый — нет).
### Реакция аудитории и метрики
Автодоводке и автострельбе в нашем проекте уже два года. Онлайн не упал, а жалоб от комьюнити практически не было. Немного были недовольны хардкорщики, которым не понравилось, что менее опытные игроки теперь получили шанс убивать.
При этом с самого выпуска апдейта, старых игроков на запуске приложения встречал экран, где объяснялось, что функции нужны для помощи новичкам. Прямо там же их можно было отключить не заходя в настройки. Это решение сильно помогло снизить негатив среди фанатов.
Если обратиться к метрикам, то распределение киллрейта игроков по [квартилям](https://ru.wikipedia.org/wiki/%D0%9A%D0%B2%D0%B0%D1%80%D1%82%D0%B8%D0%BB%D1%8C) поменялось. Игроков с очень низким киллрейтом среди новичков стало значительно меньше (как мы и хотели), но также значительно увеличилось количество игроков с высоким соотношением убийств к смертям на последних уровнях. Эту проблему уже позже решали настройкой значений задержки автострельбы и силы доводки в зависимости от уровня скилла.
Насколько же сильно помощь в прицеливании и автострельба повлияли на ключевые метрики (Retention, LT, ARPU) — однозначно сказать сложно. Они выходили вместе с батлроялем, о разработке которого я подробно рассказывал в двух статьях: про [графическую](https://habr.com/ru/company/lightmap/blog/563976/) и [сетевую](https://habr.com/ru/company/lightmap/blog/568848/) части.
В том же апдейте у нас впервые появились боевой пропуск, боты в матчах для новичков и многие другие фичи, да и сама воронка входа претерпела изменения. Вообще не стоит в одном апдейте смешивать много фич, направленных на одни и те же метрики, но порой приходится рисковать и ускоряться, чтобы сохранять должный уровень конкуренции. Самое главное, что совокупность всех усилий привела к тому, что метрики пошли вверх. Чего мы и добивались. | https://habr.com/ru/post/576812/ | null | ru | null |
# Виджет для Хабралюдей
Наверное кто-то обратил внимание, что вместо бокового баннера на главной Хабра появилось второе облако тегов. Тегов там конечно меньше, чем мы привыкли видеть, но зато облачко интерактивное. То есть, при клике по любому из них оно перестроится и покажет новые теги, которые тесно связаны с «кликнутым».
Это поисковый виджет по Хабрахабру. Простой, удобный и, надеюсь, полезный. Да, и главный момент. Специально для Хабралюдей ниже следует код виджета, который можно встроить себе на сайт или блог, чтобы в любой момент найти интересную статью на любимом Хабре.
Код (чтобы скопипейстить): | https://habr.com/ru/post/19306/ | null | ru | null |
# Народный мониторинг ESP8266 MQTT Micropython
Как быстро, без особых вложений, начать выкладывать метеоданные на народный мониторинг?
Опишу одно из решений на базе ESP8266.
Алгоритм работы простой: контроллер раз в пять минут подключается к wi-fi, соединяется с брокером, замеряет температуру и шлет её брокеру. В остальное время находится в режиме сна.
Данная статья не рассматривает вопросы установки micropython на esp8266 и физического подключения датчика. Это всё легко гуглится.
Начнем реализацию с отладки режима сна и периода включения.
```
import machine
rtc = machine.RTC()
rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP)
rtc.alarm(rtc.ALARM0, 5*60*1000)
#теперь при вызове deepsleep контроллер уснёт на 5 минут и загрузится заново, аналогично нажатию reset
#не забудьте припаять wake на reset, на плате LoLin: D0 и RST
machine.deepsleep()
```
Далее настроим подключение к wi-fi сети:
```
import network
sta_if = network.WLAN(network.STA_IF)
sta_if.active(True)
sta_if.connect('SSID', 'password')
while not sta_if.isconnected():
pass
```
Проверяем всё через REPL, что sta\_if.isconnected() возвращает True.
Теперь предлагаю узнать мак адрес esp8266, он пригодится далее:
```
import network
import ubinascii
ubinascii.hexlify(network.WLAN().config('mac'),':').decode()
```
Далее нужно зарегистрироваться на [сайте народного мониторинга](https://narodmon.ru)
Далее датчики -> добавить моё устройство -> вводим наш MAC.
Теперь самое интересное, отправка температуры по MQTT:
```
#подключение к брокеру
from umqtt.simple import MQTTClient
client=MQTTClient(client_id='01:02:03:04:05:06', server='narodmon.ru', port=1883, user='login', password='12345')
client.connect()
#замер температуры
import onewire
ow=onewire.OneWire(machine.Pin(0))
import ds18x20
ds=ds18x20.DS18X20(ow)
roms=ds.scan()
ds.convert_temp()
time.sleep_ms(750)
temperature=ds.read_temp(roms[0])
#отправка
client.publish('dinartal/esp8266/temperature', str(temperature))
#ожидание отправки
time.sleep(3)
```
Смотрим в лог через repl, если всё норм, то можно идти любоваться показаниями на народном мониторинге.
PS: Если собрать нормальную схему, без моста usb-uart, и линейного стаба с плохим кпд то от батареек такой девайс сможет показать хорошую автономность. | https://habr.com/ru/post/341716/ | null | ru | null |
# Работа с сокетами в Qt
#### Введение
Как-то несколько лет назад, на одном из форумов, я нашел такую замечательную фразу — «Каждый уважающий себя программист в жизни должен написать свой чат-клиент». Тогда мои знания не позволяли сделать это. Я просто улыбнулся и прошел мимо этой фразы. Но вот совсем недавно я столкнулся именно с данной проблемой — нужно было написать свой чат. Ну а так как последнее время мой интерес был направлен на изучение и разработку Qt-приложений, на чем будет сделан он, решилось само собой.
Работа с сетью в Qt осуществляется через QtNetwork. А для того чтобы проект начал поддерживать его, в .pro файле нужно дописать QT += network. Qt поддерживает несколько типов сокетного соединения. Основные это: QUdpSocket и QTcpSocket. QUdpSocket — это дейтаграммный сокет, для осуществления обмена пакетами данных. С помощью этого сокета данные отправляются без проверки дошли ли данные или нет. QTcpSocket же устанавливает связь точка-точка и предоставляет дополнительные механизмы, направленные против искажения и потери данных.
Оба класса наследованы от класса QAbstractSocket. Также есть класс QSslSocket, но мне он на тот момент был не нужен, поэтому затрагивать его не буду.
#### Чат
Когда начал проектировать архитектуру приложения, стал вопрос: «А собственно как будут взаимодействовать пользователи чата между собой?». Просто сам чат должен был поддерживать как общее окно чата, так и приват-сообщения с возможностью передачи файлов. Если с передачей файлов было все ясно — тут только TCP, так как должен быть контроль и проверка пришли ли пакеты, то вот с основным чатом были трудности. Ведь в чате нет четко выраженного сервера. Да и если взаимодействие их сделать через TCP, то для каждого пользователя нужно будет выделить порт, что немного накладно. Ну а раз не TCP, значит UDP! Он полностью подходит для этого. Прослушивая определенный порт, мы получаем сообщения от пользователя, который отправил их на тот же порт всем. И если какое-то сообщение чата потеряется, это будет не так страшно.
#### QUdpSocket
Как оказалось, работать с классом QUdpSocket не просто, а очень просто. Создаем объект класса, биндим на указанный порт, соединяем с сигналом класса QIODevice и ждем прихода сообщений на этот порт.
> `UdpChat(QString nick, int port) {
>
> nickname = nick;
>
> socket = new QUdpSocket(this);
>
> \_port = port;
>
> socket->bind(QHostAddress::Any, port);
>
> // тут еще какой то код конструктора //
>
> connect(socket, SIGNAL(readyRead()), SLOT(read()));
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Еще хотелось бы сказать перед следующим блоком кода, что в нашем случае чат не знает количество людей в сети. Мы будем делать просто широковещательный запрос. Но для того, чтобы сформировать список людей, будем отправлять что-то типа «Кто в сети?», на что получившие данное сообщение отправят «Я!». Таким образом у нас будет 3 типа сообщения:
1. обычное сообщения от пользователя
2. сообщения — пользователь в сети
3. сообщение — кто есть в сети?
В итоге получаем:
> `void send(QString str, qint8 type) {
>
> QByteArray data;
>
> QDataStream out(&data, QIODevice::WriteOnly);
>
> out << qint64(0);
>
> out << qint8(type);
>
> out << str;
>
> out.device()->seek(qint64(0));
>
> out << qint64(data.size() - sizeof(qint64));
>
> socket->writeDatagram(data, QHostAddress::Broadcast, \_port);
>
> }
>
>
>
> void read() {
>
> QByteArray datagram;
>
> datagram.resize(socket->pendingDatagramSize());
>
> QHostAddress \*address = new QHostAddress();
>
> socket->readDatagram(datagram.data(), datagram.size(), address);
>
>
>
> QDataStream in(&datagram, QIODevice::ReadOnly);
>
>
>
> qint64 size = -1;
>
> if(in.device()->size() > sizeof(qint64)) {
>
> in >> size;
>
> } else return;
>
> if (in.device()->size() - sizeof(qint64) < size) return;
>
>
>
> qint8 type = 0;
>
> in >> type;
>
>
>
> if (type == USUAL\_MESSAGE) {
>
> QString str;
>
> in >> str;
>
> // код по перенаправке сообщения в классы выше //
>
> } else if (type == PERSON\_ONLINE) {
>
> // Добавление пользователя с считанным QHostAddress //
>
> } else if (type == WHO\_IS\_ONLINE) {
>
> sending(nickname, qint8(PERSON\_ONLINE));
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Все прозрачно и ясно. Осталось прикрутить интерфейс, соединить все сигналы и основное окно чата готово.
#### QTcpSocket
Что же касается этого сокета, то он реализует модель «клиент-сервер». То есть в нашем случае каждый пользователь может стать как сервером, если он начнет кому-то первый писать приват-сообщение или отсылать файл. Или же клиентом, в случае если ему написали первому в приват.
С отправкой сообщения нет никаких сложностей. А вот для отправки файла сделаем классический трюк. Так как весь файл засунуть в поток не получится, то будет считывать данные из файла и порционно писать в поток, а затем отправлять их.
> `void sendFile(QString fileName) {
>
> if(sendFile != NULL){
>
> return;
>
> }
>
> sendFile = new QFile(fileName);
>
> if(sendFile->open(QFile::ReadOnly)){
>
> QByteArray data;
>
> QDataStream out(&data, QIODevice::WriteOnly);
>
> // подготовка данных для записи //
>
> clientSocket->write(data);
>
> clientSocket->waitForBytesWritten();
>
> connect(clientSocket, SIGNAL(bytesWritten(qint64)), this, SLOT(sendPartOfFile()));
>
> sendPartOfFile();
>
> } else{
>
> emit this->errorSendFile(QString("File not can open for read"));
>
> return;
>
> }
>
> }
>
>
>
> void sendPartOfFile() {
>
> char block[SIZE\_BLOCK\_FOR\_SEND\_FILE];
>
> if(!sendFile->atEnd()){
>
> qint64 in = sendFile->read(block, sizeof(block));
>
> qint64 send = clientSocket->write(block, in);
>
> } else{
>
> sendFile->close();
>
> sendFile = NULL;
>
> disconnect(clientSocket, SIGNAL(bytesWritten(qint64)), this, SLOT(sendPartOfFile()));
>
> emit endSendFile();
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Осталось рассмотреть чтение потока. Так как приходит всего 2 типа данных — MESSAGE и SENDFILE, то написать обычный парсер входного потока не составит никакого труда. Он идентичен методу класса реализующий UDP сокет. Интерес представляет чтение из потока передающегося файла.
> `void receiveFile(QString fileName) {
>
> QString savePath = "Downloads/";
>
> QDir dir;
>
> dir.mkpath(savePath);
>
> receiveFile = new QFile(savePath + fileName);
>
> sizeReceivedData = 0;
>
> receiveFile();
>
> }
>
>
>
> void receiveFile() {
>
> QDataStream in(clientSocket);
>
> if(!bufferForUnreadData.isEmpty()){
>
> receiveFile->write(bufferForUnreadData);
>
> sizeReceivedData += bufferForUnreadData.size();
>
> bufferForUnreadData.clear();
>
> }
>
> char block[SIZE\_BLOCK\_FOR\_SEND\_FILE];
>
> while(!in.atEnd()){
>
> qint64 toFile = in.readRawData(block, sizeof(block));
>
> sizeReceivedData += toFile;
>
> receiveFile->write(block, toFile);
>
> }
>
> if(sizeReceivedData == sizeReceiveFile){
>
> receiveFile->close();
>
> receiveFile = NULL;
>
> sizeReceiveFile = 0;
>
> sizeReceivedData = 0;
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Это суть работы приват-сообщения. Конечно здесь не хватает части сигналов, коннектов и специфичного кода. Например send- и recieve-файл — это только общий вид. Многое пропущено. Но если все добавить, прикрутить интерфейс, то можно получить вполне рабочий, написанный вами чат-клиент.
Целью же статьи было показать на примере, что работать с сокетами просто и легко. Надеюсь, что кому то данная статья поможет в будущем. Удачи. | https://habr.com/ru/post/111239/ | null | ru | null |
# Как перестать бояться и полюбить регулярные выражения
В работе и повседневной жизни мы буквально окружены текстами: книги и статьи, письма и чаты, веб-страницы и программный код. Да что там — сама биологическая жизнь основана на ДНК. И для эффективной работы по поиску или модификации текста уже давно был придуман мощный инструмент — регулярные выражения, или regex. Однако по ряду причин далеко не все их используют, или имеют дело с ними только ~~когда заставили~~ при крайней необходимости. В этой статье я попытаюсь исправить эту печальную ситуацию.
*Чтобы функции отыскать, воедино созвать и единою чёрною волей сковать.*
На Хабре уже есть ряд хороших статей, которые помогут разобраться в основах:
* [Регулярные выражения в Python от простого к сложному](https://habr.com/ru/post/349860/)
* [Регулярные выражения, пособие для новичков](https://habr.com/ru/post/115825/)
Мы не будем углубляться в работу регулярных выражений или пытаться в полном объёме покрыть все возможности, а рассмотрим на самых элементарных примерах, насколько просто начать пользоваться этим замечательным инструментом.
Иногда случается так, что регулярные выражения приходят в нашу жизнь совершенно неожиданно. Например, вы разбираетесь с валидацией пароля и сталкиваетесь со следующим:
```
^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#$&^()*])[a-zA-Zа-яА-Я0-9!@#$&^()*]{1,}$
```
после чего настроение неизменно падает. Даже если и удалось продраться через нагромождение символов, то желание возвращаться к регулярным выражениям наверняка сильно уменьшится. Человек же со стороны вообще может принять это за инопланетный язык и начать сторониться аки чумы: «Зачем мне ещё один язык программирования, да к тому же такой сложный?».
*Гэндальф ещё Серый, а потому боится использовать regex.*
Поиск
-----
Для экспериментов нам понадобится старый добрый [Властелин Колец](http://www.lib.ru/TOLKIEN/hran_1.txt) и любой текстовый редактор с поддержкой регулярных выражений. В данной статье будет использоваться [Notepad++](https://notepad-plus-plus.org/downloads/) (простой, удобный и расширяемый – очень рекомендую).
Копируем текст без оглавления в приложение, Ctrl+f, отмечаем «Regular expression» и вперёд!
*Пример окна поиска в Notepad++.*
### 1. Точное совпадение с фразой
Попробуем найти Исилдура (того, что у Саурона кольцо подрезал) на страницах «Властелина колец»
Поздравляю! Вы только что использовали регулярное выражение «**Исилдур**».
Тут всё просто – совпадение один к одному. Есть еще магия регистров букв (отмечаем галочку «Matсh Case»), но по умолчанию она обычно не включена. «**Исилдур**», «**исилдур**», «**ИсИлДУР**» дадут один и тот же результат. Если же мы знаем регистры букв искомого слова, то можем указать их и отбросить лишние результаты. Однако это может сыграть злую шутку, когда при последующем поиске может потеряться часть результатов. Убирайте галочку, если регистры букв могут быть разными.
Веб браузеры, текстовые редакторы, мессенджеры – все имеют такую функцию. Однако [не все об этом знают](https://habr.com/ru/post/126731/). Жаль, что у бумажных книг нет такой возможности.
Первый шаг сделан, и ничего не мешает двигаться дальше.
### 2. Символы подстановки
Еще одна распространённая возможность — это ***символ подстановки*** (wildcard) звёздочка «**\***». Она заменяет любое количество любых допустимых символов. Самый распространённый пример – поиск файлов.
Скажем, мы хотим найти фотографии отдыха на море. Для этого в строке поиска введём «**\*.png**» – и получим список всех фотографий в папке:
```
Скан паспорта.png
Море Испания.png
Тосса-де-Мар, море.png
Трудовые будни.png
Закатное море, Сант-Себастиа.png
```
Уже хорошо. А что будет, если мы добавим слово «море» до или после звездочки?
**море\*.png**
```
Море Испания.png
```
**\*море.png**
```
Тосса-де-Мар, море.png
```
Следующий вариант вернёт то, что нужно:
**\*море\*.png**
```
Море Испания.png
Тосса-де-Мар, море.png
Закатное море, Сант-Себастиа.png
```
«**\*море\*.png**» — наглядный пример ***шаблона поиска***, или ***маски*** – мы что-то знаем о структуре искомой строчки (в данном случае расширение «**.png**» в конце и где-то слово «**море**»), в остальных местах предполагаем любые символы.
Регулярные выражения, как развитие подстановочных символов, имеют в своём арсенале огромный набор разнообразных средств, с помощью которых мы можем более тонко составлять шаблон поиска. Но пока познакомимся с аналогом звёздочки — точка и звёздочка «**.\***».
### 3. Точка со звёздочкой **«.\*»**
Забудем о значении звёздочки в подстановочных символах – в регулярных выражениях она обозначает «любое количество, от 0 и до бесконечности». А точка обозначает «любой строковый символ». Вместе получаем «любое количество любых строковых символов».
Точка не включает в себя символ новой строки, поэтому поиск будет производится до конца строки, или, другими словами, абзаца. Посмотрим, как часто Фродо и Сэм оказывались вместе: для этого поищем по шаблонам «**Сэм.\*Фродо»** и «**Фродо.\*Сэм»**»:
215 совпадений. Кто бы сомневался…
Можно это сделать проще, одним запросом. Для этого используем специальный знак ИЛИ «**|**»: альтернативные варианты разделяются вертикальной чертой и окружаются скобками:
**(Фродо.\*Сэм|Сэм.\*Фродо)**
Можно заметить, что такой поиск выдал меньше совпадений — 213. Так получается, потому что, например, строчку «Рядом с Фродо шел всхлипывающий Сэм, да и сам Фродо безмолвно плакал.» раздельные запросы найдут два раза.
Чтобы узнать, как часто упоминается Гэндальф в полной форме, используем шаблон:
**Гэндальф (Серый|Белый)**
Всё. Имея на руках рассмотренное выше, можно начинать исследовать текстовые моря или болота логов. Начните с малого, исследуйте на возможность поиска те приложения, которыми вы часто пользуетесь. Задавайте поиску простые вопросы, и со временем вы сами почувствуете желание сделать поиск более сложным.
А если остались силы, то можно копнуть чуть глубже и взять на вооружение ещё два базовых понятия, изучив которые вы станете истинными начинающими regex-волшебниками.
*Саруман понимает, какая мощь в его руках, и не боится её. Поэтому он всегда в курсе всех дел.*
### 4. Количество повторений или квантификаторы
С одним ***квантификатором*** мы уже познакомились – звёздочка. Есть ещё несколько способов задать количество:
| | |
| --- | --- |
| **{4}** | точное количество |
| **{1,5}** | диапазон |
| **{2,}** | от числа до бесконечности |
| **{,7}** | от 0 до числа |
Некоторые часто используемые диапазоны имеют собственные символы:
| | |
| --- | --- |
| **\*** или **{0,}** | любое количество |
| **?** или **{0,1}** | ноль или один |
| **+** или **{1,}** | есть как минимум один |
Спросим, как часто упоминается одно и то же слово в одном абзаце:
Бильбо 2 раза — «**(Бильбо.\*){2}**» — упоминается в 7 случаях, а большее количество раз в абзаце — «**(Бильбо.\*){3,}**» — ни разу. Слово «Хоббит» встречается аж 3 раза в строке, как часть слов «Хоббиты» «хоббита» и «Хоббитании».
### 5. Представление символов
Точка (любой символ) — один из примеров ***представления символов***. Другими примерами являются цифра «**\d**», цифра или буква «**\w**», набор символов «**[abc],** «**[1-9],** «**[.,?:;]**».
Например, мы хотим узнать, как часто числа используются в книге:
«**\d+**» или «**\d{1,}**» – как минимум одна цифра подряд:
Находим номера глав и даты. Если не брать совсем уж легендарные времена (37г.), то рассказ ведётся о втором тысячелетии по летоисчислению хоббитов (Л. Х.) Оценим масштаб саги, для этого найдём 4 цифры подряд — **\d{4}**
Первая дата говорит нам о начале табаководства у хоббитов в 1070 году, а Фродо уплывает от нас на Запад в 1421 — 351 год.
С остальными представлениями символов предлагаю познакомиться самостоятельно.
Замена
------
Как только фамилию Бильбо не переводили: Сумникс, Беббинс, в нашем случае – Торбинс, но для меня есть только один вариант — Бэггинс. Однако это не проблема: почти всегда рядом с возможностью поиска есть возможность замены. Найденное слово можно заменить по всему тексту в одно действие. Для этого воспользуемся вкладкой «Replace»:
Теперь можно читать книгу с привычным переводом. Но будьте осторожны: шаблон поиска может подойти не только желаемому слову, но и более длинному, содержащему в себе искомое. Тогда при замене «дача» на «деревня» мы неожиданно можем получить «удеревня» или «телепередеревня». Желательно предварительно провести поиск по такому же шаблону и проверить результаты. Усложняйте шаблон для более точного поиска. В случае «дача» мы можем добавить пробел до слова и пробел или знаки препинания в конце: « **дача[ .,!?;:]**».
Практика использования
----------------------
Для создания, редактирования или исследования регулярных выражений советую использовать понравившийся вам онлайн-редактор. Для меня самым удобным оказался [**REGEX101**](https://regex101.com/):
*Кольцо находит все определения функций в [**ISO C99**](http://www.dii.uchile.cl/~daespino/files/Iso_C_1999_definition.pdf), и потому такое могущественное.*
В строке сверху мы вводим регулярное выражение, а снизу — текст, по которому производим поиск. Редактор автоматически подсвечивает найденные совпадения, при наведении на части выражения всплывают подсказки, объясняющие значение, и много других полезных функций. Для замены нужно выбрать «Substitution» в левой панели.
Заключение
----------
* Чаще пользуйтесь поиском для удобства и ускорения работы.
* Используйте звёздочку при поиске файлов, создавая простые шаблоны.
* Начните использовать простые регулярные выражения в повседневной работе, накапливая опыт и постепенно изучая новые возможности.
Конечно, в этой статье затронута лишь самая верхушка. Осталось без внимания множество как полезных возможностей, так и возможных проблем. Но если у вас появилось желание более основательно погрузиться в мир regex, помимо справочников и учебников в интернете, на Хабре можно почитать следующие статьи:
* [Квантификаторы в регулярных выражениях](https://habr.com/ru/post/68345/)
* [8 полезных регэкспов с наглядным разбором](https://habr.com/ru/post/66931/)
* [Некоторые ошибки при написании регэкспов](https://habr.com/ru/post/67158/)
Сегодня я уже не представляю свою работу без регулярных выражений, как и без слепого метода печати. А требовалось всего лишь начать использовать. Чего вам и желаю.
 | https://habr.com/ru/post/536912/ | null | ru | null |
# Как в PHP улучшить читаемость регулярных выражений
Регулярные выражения — очень мощный инструмент, однако согласно общепринятому мнению, после того как они написаны, их очень трудно понять, поэтому их поддержка — не самое приятное занятие. Здесь собраны советы, которые помогут сделать из более читаемыми.
PHP использует диалект регулярных выражений [PCRE](https://www.php.net/manual/ru/intro.pcre.php) — до версии PHP 7.3, и [PCRE2](https://www.php.net/manual/en/migration73.other-changes.php) — в более новых версиях. Поэтому в PHP можно использовать различные продвинутые приемы, помогающие писать читаемые, самодокументируемые и поддерживаемые регулярные выражения. При этом не надо также забывать и о наличии в PHP [функций фильтрации переменных](https://www.php.net/manual/en/function.filter-var.php), а также [семейства функций ctype\*](https://www.php.net/manual/en/book.ctype.php), позволяющих валидировать такие распространенные значения как URL-ссылки, адреса электронной почты и строки из букв и цифр — вообще без использований регулярный выражений. Во многих IDE есть подсветка регулярных выражений, помогающая их читать, а иногда даже и проверка выражений, с подсказками по их улучшению.
Но все же, для долговременной поддержки регулярных выражений лучше всего с самого начала писать их так, чтобы они были понятными и самодокументируемыми. Описанные ниже советы помогут в этом. Однако обратите внимание на то, что какие-то из них могут не сработать в старых версиях PHP (старше PHP 7.3). Кроме того, использование показанных здесь приемов может привести к ухудшению переносимости регулярных выражений под другие языки программирования. Например, именованные группы поддерживаются даже в старых версиях PHP, а вот в JavaScript они добавлены только, начиная с версии [ES2018](https://262.ecma-international.org/9.0/).
Вот какие приемы могут улучшить читаемость регулярных выражений:
* выбор подходящих символов-ограничителей;
* устранение избыточного экранирования символов;
* незахватывающие группы;
* именованные захватывающие группы;
* использование комментариев;
* именованные классы символов.
### Выбор подходящих символов-ограничителей
Любое регулярное выражение состоит из двух частей — собственно регулярного выражения и его флагов. Выражение расположено между двух специально выбранных символов-ограничителей, а флаги — опционально следуют за замыкающим ограничителем. Например:
```
/(foo|bar)/i
```
Здесь `(foo|bar)` — регулярное выражение, `i` — флаг, задающий его поведение, а символы `/` — ограничители. Прямой слэш `/` очень часто используют как ограничитель, однако эту роль может выполнять и другой символ. Например, это могут быть символы `~, !, @, #, $` и другие. А вот цифры, буквы, эмоджи и обратный слэш `\` — не могут ими быть. Ограничителями могут быть и парные скобки различных видов: `{}, (), [], и <>` Нередко с ограничителями в виде скобок регулярные выражения могут быть записаны намного понятнее, чем с использованием других символов ограничителей. Хотя, конечно, это, зависит и от содержания выражения. Выбор подходящего символа-ограничителя регулярного выражения важен потому, что все упоминания этого символа в контексте регулярного выражении должны быть экранированы. И, чем меньше экранирований будет в выражении, тем лучше оно будет читаться. Выбор ограничивающего символа не являющегося метасимволом языка регулярных выражений (таким, как `^, $,` скобки, и другие), поможет уменьшить количество экранированных символов в выражении. Также, лучше не использовать в качестве ограничителя и те символы, которые часто встречается в регулярном, выражении. Скажем, прямой слэш `/` очень часто используется в качестве ограничителя, но иногда это — не лучший выбор, например, когда выражение содержит URL-ссылки. Например:
```
preg_match('/^https:\/\/example\.com\/path/i', $uri);
```
Если же поменять ограничитель на “#”, регулярное выражение станет гораздо понятнее, так как в нем теперь будет только один экранированный символ:
```
preg_match('#^https://example\.com/path#i', $uri);
```
### Уменьшение количества экранированных символов
Кроме выбора подходящего символа-ограничителя есть и другие способы уменьшить количество экранирований в регулярном выражении. Некоторые метасимволы языка регулярных выражений не являются таковыми при использовании в задаваемом диапазоне символов в квадратных скобках. Например, это символы `.`, `*`, `+`, `$`. Поэтому, в выражении `/Username: @[a-z\.0-9]/` нет необходимости экранировать символ “.” , потому что в квадратных скобках он не работает как метасимвол.
Более того, некоторые метасимволы не требуют экранирования, если не являются частью выражения задания диапазона. В частности, это символ дефиса `-`. В позиции между двумя символами он является метасимволом, и указывает на то, что задается диапазон символов, в другом же контексте он перестает им быть, и становится обычным символом.
Например, в регулярном выражении `/[A-Z]/`, дефис означает диапазон символов между A и Z. Если же он экранирован `(/[A\-Z]/)`, то дефис — это просто символ для поиска, и такое выражение ищет символы A, Z и дефис. Таким образом, чтобы избавиться от необходимости экранирования дефиса, достаточно в выражении переместить его в конец набора символов, заданного в квадратных скобках. Например, выражение `/[AZ-]/` делает то же самое, что и `/[A\-Z]/`, но короче и понятнее.
Избыточное экранирование символов при компиляции регулярных выражений не вызывает ошибок (по крайней мере, по умолчанию), но существенно затрудняет их понимание человеком. Сравните, например:
```
/Price: [0-9\-\$\.\+]+/
```
и
```
/Price: [0-9$.+-]+/
```
Существует флаг `X`, выбрасывающий ошибку в том случае, если в регулярном выражении заэкранирован символ, не имеющий специального значения. К сожалению, он не учитывает контекста и не вызывает ошибку, например, в случае экранирования метасимвола при задании диапазона символов в квадратных скобках, где метасимвол перестает быть таковым. Вот пример использования этого флага — выполнение кода:
```
preg_match('/x\yz/X', ''); // символ "y" — заэкранирован, хотя он — не специальный
```
вызывает предупреждение:
```
Warning: preg_match(): Compilation failed: unrecognized character follows \ at offset 2 in ... on line ...
```
#### Незахватывающие группы
Как известно, круглые скобки `()` в регулярном выражении означают захватывающую группу символов, то есть, то, в случае соответствия строки регулярному выражению, ее часть, заключенная в скобки, будет записана отдельным элементом в результирующем списке найденных соответствий.
Рассмотрим код, получающий цену из строки вида “`Price: €24`”.
```
$pattern = '/Price: (£|€)(\d+)/';
$text = 'Price: €24';
preg_match($pattern, $text, $matches);
```
Здесь 2 захватывающие группы, первая получает символ валюты, в которой указана цена `((£|€))`, вторая — получает численное значение цены. При запуске такого кода, в переменной `$matches` окажутся соответствующая выражению строка, а также подстроки, соответствующим двум группам в круглых скобках:
```
var_dump($matches);
array(3) {
[0]=> string(12) "Price: €24"
[1]=> string(3) "€"
[2]=> string(2) "24"
}
```
Подобные группы можно применить и для повышения читаемости регулярного выражения, в котором не требуется получения подстрок. Для этого надо использовать незахватывающие группы, которые задаются все теми же круглыми скобками, но после открывающей скобкой должно идти сочетание символов `?:`. Такие группы учитываются компилятором регулярных выражений, но соответствующие им подстроки не захватываются, то есть не возвращаются в результате. Например, если в написанном выше выражении интересует только числовое значение цены, то первую группу `(£|€)`, захватывающую соответствующее ей значение, нужно заменить на незахватывающую: `(?:£|€)`.
```
$pattern = '/Price: (?:£|€)(\d+)/';
$text = 'Price: €24';
preg_match($pattern, $text, $matches);
var_dump($matches);
```
В результате работы такого кода в `$matches` будет содержаться только 1 подстрока — значение цены:
```
array(2) {
[0]=> string(12) "Price: €24"
[1]=> string(2) "24"
}
```
Таким образом, в регулярных выражениях с несколькими захватывающими группами, те группы, результаты которых далее не используются, имеет смысл задавать как незахватывающие, это устранит избыточные данные в результате выполнения выражения.
### Именованные захватывающие группы
Именованные захватывающие группы позволяют не только получить в результате соответствующие им подстроки, но и задать имена содержащим эти подстроки элементам результирующего массива. Что полезно не только с точки зрения получения именованных результатов, но и потому, что части регулярного выражения получат понятное название, что существенно улучшит его читаемость
Например, в рассмотренном выше выражении для цены, можно каждую из групп снабдить названием:
```
/Price: (?£|€)(?\d+)/
```
Как можно видеть, именованная захватывающая группа открывается символами `(?`, за которыми в угловых скобках следует имя группы, и закрывается все той же круглой скобкой. В примере выше, `(?£|€)` — именованная группа *currency*, а `(?\d+)` — группа под названием *price*. Такое написание с одной стороны позволяет читающему код регулярного выражения программисту понять, что делает каждая именованная группа, с другой — понятным образом именует элементы массива с результатами работы выражения. Например, выполнив код:
```
$pattern = '/Price: (?£|€)(?\d+)/';
$text = 'Price: €24';
preg\_match($pattern, $text, $matches);
var\_dump($matches);
```
Получим:
```
array(5) {
[0]=> string(12) "Price: €24"
["currency"]=> string(3) "€"
[1]=> string(3) "€"
["price"]=> string(2) "24"
[2]=> string(2) "24"
}
```
Таким образом, массив `$matches` теперь содержит подстроки, полученные захватывающими группами не только по индексам в порядке появления, эти значения также есть и в элементах ассоциативного массива именованных в соответствии с названиями групп.
Согласитесь, гораздо легче понять, чему соответствует элемент `["currency"]=> "€"`, чем `[1]=> "€"`.
По умолчанию в PHP в пределах регулярного выражения запрещены именованные группы с неуникальными названиями, их наличие приводит к ошибке уровня предупреждения:
```
Warning: preg_match(): Compilation failed: two named subpatterns have the same name (PCRE2_DUPNAMES not set) at offset ... in ... on line ....
```
Однако их можно разрешить, используя модификатор `J` (UPD: как модификатор поддерживается, начиная с PHP 7.2.0, в более старших версиях для того же эффекта нужно было добавлять в начало регулярного выражения [костыльную опцию](https://www.php.net/manual/en/reference.pcre.pattern.modifiers.php)`?J`):
```
/Price: (?£|€)?(?\d+)(?£|€)?/J
```
Здесь мы видим 2 захватывающие группы с одинаковым названием *currency*, и такое регулярное выражение не вызовет ошибки, потому что в нем использован модификатор `J`. В результате работы такого выражения, в именованном элементе массива *currency* будет возвращена подстрока, соответствующая самой последней группе с этим названием. При этом, в индексированных элементах массива будут подстроки, соответствующие каждой группе:
```
$pattern = '/Price: (?£|€)?(?\d+)(?£|€)?/J';
$text = 'Price: €24£';
preg\_match($pattern, $text, $matches);
var\_dump($matches);
array(6) {
[0]=> string(14) "Price: €24£"
["currency"]=> string(2) "£"
[1]=> string(3) "€"
["price"]=> string(2) "24"
[2]=> string(2) "24"
[3]=> string(2) "£"
}
```
### Использование комментариев
Нередко регулярные выражения становятся длинными, и разрастаются на много строк. Тогда, чтобы они не стали простыней нечитаемого текста, их разбивают на отдельные PHP-строки, содержащие самодостаточные части выражения, и пишут к ним комментарии. А при компиляции регулярного выражении — соединяют их в единую строку. Это улучшает читаемость и позволяет после правки таких выражений получить более лаконичные списки изменений кода в коммитах системы контроля версий.
Например, вместо:
```
$pattern = '/Price: (?£|€)(?\d+)/i';
```
Можно написать:
```
$pattern = '/Price: ';
$pattern .= '(?£|€)'; // Capture currency symbols £ or €
$pattern .= '(?\d+)'; // Capture price without decimals.
$pattern .= '/i'; // Flags: Case-insensitive
```
Комментарии можно добавлять и в сами регулярные выражения. Существует флаг `x`, с которым компилятор регулярных выражений начинает игнорировать в выражении все пробельные символы, в том числе и переносы строк. Это позволяет визуально разграничить части выражения и даже разбить его на несколько строк, не меняя его смысла. Сравните:
```
/Price: (?£|€)(?\d+)/i
```
и
```
/Price: \s (?£|€) (?\d+) /ix
```
Во втором случае, пробелы позволяет повысить читаемость выражения, при этом компилятор регулярных выражений их игнорирует за счет использования флага `x`. Пробелами можно выделить логические последовательности подшаблонов регулярного выражения, сделав, таким образом, его более понятным. Если же нужно, чтобы выражение искало пробелы, то нужно применить в нем специальную последовательность символов `\s`.
Кроме игнорирования пробелов флаг `x` также включает возможность добавления в тело регулярного выражения комментариев, начинающихся с символа `#`, и по синтаксису похожих на комментарии в PHP коде. Выражение можно сделать еще более читаемым, разбив его на несколько строк и добавив к ним комментарии. Например, вместо:
```
/Price: (?£|€)(?\d+)/i
```
Можно написать:
```
/Price: # Check for the label "Price:"
\s # Ensure a white-space after.
(?£|€) # Capture currency symbols £ or €
(?\d+) # Capture price without decimals.
/ix
```
Для записи отформатированного в таком виде выражения в виде строки PHP, лучше всего использовать [Heredoc](https://www.php.net/manual/en/language.types.string.php#language.types.string.syntax.heredoc)) или Nowdoc синтаксис. Таким образом, получим:
```
$pattern = <<£|€) # Capture currency symbols £ or €
(?\d+) # Capture price without decimals.
/ix # Flags: Case-insensitive
PATTERN;
preg\_match($pattern, 'Price: £42', $matches);
```
### Именованные классы символов
Регулярные выражения поддерживают предопределенные классы символов, которые облегчают написание выражений, в то же время, делая их более читаемыми. Вероятно, самый часто используемый именованный диапазон символов — это `\d` включающий в себя все цифровые символы и, при отключенном режиме Юникода, равнозначный диапазону символов `[0-9]`. Класс `\D` означает обратное, то есть — любой нецифровой символ, и равнозначен диапазону `[^0-9]`. Таким образом, чтобы, например, регулярное выражение искало цифру, за которой идет нецифровой символ, вместо:
```
/Number: [0-9][^0-9]/
```
можно написать:
```
/Number: \d\D/
```
Язык регулярных выражений поддерживает и другие [классы символов](https://en.wikipedia.org/wiki/Regular_expression#Character_classes), позволяющие еще больше улучшить читаемость. Вот наиболее часто используемые из них:
* `\w` — все символы, из которых обычно составлены слова, равнозначно диапазону `[A-Za-z0-9_]`,
Вместо
```
/[A-Za-z0-9_]/
```
можно написать лаконичное:
```
/\w/
```
* `[:xdigit:]` — символы встречающиеся в написании шестнадцатеричных символов, то есть диапазон `[A-Fa-f0-9]`,
Тогда вместо
```
/[a-fA-F0-9]/
```
пишем:
```
/[[:xdigit:]]/
```
* `\s` — все пробельные символы, диапазон `[ \t\r\n\v\f]`,
Вместо
```
/ \t\r\n\v\f/
```
Пишем гораздо более короткое и ясное
```
/\s/
```
Если регулярное выражение используется с флагом `/u`, включающим режим Юникода, то появляются дополнительные именованные классы символов Юникода. Они задаются в формате `\p{КЛАСС_СИМВОЛОВ}`, где `КЛАСС_СИМВОЛОВ` — соответственно название класса. Если же в `\p` буква "p" написана в верхнем регистре, например `\P{FOO}`, то такой диапазон наоборот — задает все остальные символы, без включения означенного класса. Среди дополнительных именованных классов есть и такие полезные, как, например, `\p{Sc}`, задающий весь диапазон символов для обозначения валюты, причем, как существующих, так и тех, что будут добавлены в таблицу символов в будущем. Кстати, есть и другой формат задания этого класса: `\p{Currency_Symbol}`, но он пока не поддерживается в регулярных выражениях PHP.
Вот пример выражения получающего из строки сумму и валюту:
```
$pattern = '/Price: \p{Sc}\d+/u';
```
На выходе получим:
```
$text = 'Price: ¥42';
```
Именованные классы символов позволяют задавать выражения для поиска и захвата подстроки, даже не зная конкретных символов для поиска. Например, как уже упоминалось выше, приведенное выражение для поиска валют в будущем сможет искать также и символы новых появившихся за это время валют, когда они будут добавлены в Юникод. Классы символов для Юникода включают в себя также и очень полезный набор классов, задающих диапазоны символов письменностей различных языков человечества. Например, выражение `\p{Sinhala}` соответствует диапазону символов письменности [Сингальского языка](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BD%D0%B3%D0%B0%D0%BB%D1%8C%D1%81%D0%BA%D0%B8%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA), то есть диапазону `\x{0D80}-\x{0DFF`}. Согласитесь, что:
```
$pattern = '/[\x{0D80}-\x{0DFF}]/u';
```
Намного менее понятно, чем:
```
$pattern = '/\p{Sinhala}/u';
```
Применив это выражение к строке на сингальском языке,
```
$text = 'පීඑච්පී.වොච්`;
$contains_sinhala = preg_match($pattern, $text);
```
мы видим, что даже, имея дело с незнакомым и экзотическим языком, мы можем с пользой применить регулярные выражения!
P.S. В процессе перевода статьи нашел в оригинале пару ошибок в примерах регулярных выражений — трудно все-таки они читаются. Написал автору, пусть исправит. | https://habr.com/ru/post/560460/ | null | ru | null |
# Проверяем уровень защищённости Linux с помощью утилиты Lynis
Разбираемся, как использовать одну из самых мощных свободно распространяемых утилит для аудита Linux-систем.
Вы когда-нибудь задумывались о том, насколько безопасна ваша Linux-система? Существует множество дистрибутивов Linux (каждый со своими настройками по умолчанию), на которых вы запускаете десятки программных пакетов с разными номерами версий. Кроме того, на вашей ОС в фоновом режиме работает множество сервисов, о которых вы порой не знаете или не думаете.
Чтобы получить информацию о системе, то есть проверить общее состояние программного обеспечения, сети и служб, работающих на вашем компьютере с установленной ОС Linux, достаточно выполнить несколько команд. Но что теперь делать с полученной информацией? Как в ней разобраться? Ведь объём данных, которые вам нужно проанализировать, огромен.
Было бы намного лучше, если бы вы могли просто запустить инструмент, который генерирует структурированный отчёт об уровне защищенности системы. Lynis — популярный инструмент с открытым исходным кодом, который позволяет провести аудит систем на базе Linux и Unix.
*«Он выполняет всестороннее сканирование настроек безопасности и запускается на самой системе. Основная цель — протестировать средства защиты и выдать рекомендации по дальнейшему повышению уровня защищённости системы. Он также сканирует общесистемную информацию, информацию об установленных пакетах и возможных ошибках конфигурации. Lynis [обычно] используют системные администраторы и специалисты по безопасности для оценки уровня защищённости систем»*, — говорится на сайте проекта.
Устанавливаем Lynis
-------------------
Для установки Lynis можно использовать менеджеры пакетов. При условии, что у вашей системы Linux с актуальностью версий в репозитории всё в порядке, утилиту можно установить так:
```
dnf install lynis
```
или так:
```
apt install lynis
```
Однако, если версия утилиты в вашем репозитории не самая последняя, лучше установить Lynis с GitHub (я использую систему Red Hat Linux, но аналогичные команды работают в любом дистрибутиве Linux):
```
$ cat /etc/redhat-release
Red Hat Enterprise Linux Server release 7.8 (Maipo)
$
$ uname -r
3.10.0-1127.el7.x86_64
$
$ git clone https://github.com/CISOfy/lynis.git
Cloning into 'lynis'...
remote: Enumerating objects: 30, done.
remote: Counting objects: 100% (30/30), done.
remote: Compressing objects: 100% (30/30), done.
remote: Total 12566 (delta 15), reused 8 (delta 0), pack-reused 12536
Receiving objects: 100% (12566/12566), 6.36 MiB | 911.00 KiB/s, done.
Resolving deltas: 100% (9264/9264), done.
$
```
Как только вы клонируете хранилище, зайдите в него и посмотрите, что вам доступно, найдите файл с именем lynis. На самом деле это shell-скрипт, так что вы можете открыть его и почитать, что он делает. Фактически, Lynis в основном и реализован с использованием скриптов:
```
$ cd lynis/
$ ls
CHANGELOG.md CONTRIBUTING.md db developer.prf FAQ include LICENSE lynis.8 README SECURITY.md
CODE_OF_CONDUCT.md CONTRIBUTORS.md default.prf extras HAPPY_USERS.md INSTALL lynis plugins README.md
$
$ file lynis
lynis: POSIX shell script, ASCII text executable, with very long lines
$
```
Запускаем Lynis
---------------
Начнём знакомство с Lynis, запустив справку с помощью флага **-h**:
```
$ ./lynis -h
```
Так вы можете ознакомиться с основными командами утилиты. Например, давайте узнаем её версию:
```
$ ./lynis show version
3.0.0
$
```
Чтобы получить полный список команд Lynis, введите:
```
$ ./lynis show commands
Commands:
lynis audit
lynis configure
lynis generate
lynis show
lynis update
lynis upload-only
$
```
Запускаем аудит Linux-системы
-----------------------------
Всё начинается со следующей команды:
```
$ ./lynis audit system
```
После запуска команды мы получим детальный отчёт. Не пугайтесь, мы в нём разберёмся чуть позже. Прочие результаты работы команд тоже сохраняются, так что и к ним вы можете вернуться позже.
Вот здесь Lynis хранит логи:
```
Files:
- Test and debug information : /var/log/lynis.log
- Report data : /var/log/lynis-report.dat
```
Вы можете проверить, были ли на самом деле созданы все необходимые файлы:
```
$ ls -l /var/log/lynis.log
-rw-r-----. 1 root root 341489 Apr 30 05:52 /var/log/lynis.log
$
$ ls -l /var/log/lynis-report.dat
-rw-r-----. 1 root root 638 Apr 30 05:55 /var/log/lynis-report.dat
$
```
Изучаем отчёты
--------------
Lynis предоставляет довольно подробные отчеты, поэтому я расскажу лишь о некоторых важных разделах. Самое первое, что делает Lynis при инициализации, — выясняет полную информацию об операционной системе, работающей на компьютере. Затем утилита проверяет, какие системные инструменты и плагины у вас установлены:
```
[+] Initializing program
------------------------------------
- Detecting OS... [ DONE ]
- Checking profiles... [ DONE ]
---------------------------------------------------
Program version: 3.0.0
Operating system: Linux
Operating system name: Red Hat Enterprise Linux Server 7.8 (Maipo)
Operating system version: 7.8
Kernel version: 3.10.0
Hardware platform: x86_64
Hostname: example
---------------------------------------------------
<>
[+] System Tools
------------------------------------
- Scanning available tools...
- Checking system binaries...
[+] Plugins (phase 1)
------------------------------------
Note: plugins have more extensive tests and may take several minutes to complete
- Plugin: pam
[..]
- Plugin: systemd
[................]
```
Отчёт делится на различные разделы, и каждый раздел начинается с **[+]**. Некоторые из разделов можно увидеть ниже
```
[+] Boot and services
[+] Kernel
[+] Memory and Processes
[+] Users, Groups and Authentication
[+] Shells
[+] File systems
[+] USB Devices
[+] Storage
[+] NFS
[+] Name services
[+] Ports and packages
[+] Networking
[+] Printers and Spools
[+] Software: e-mail and messaging
[+] Software: firewalls
[+] Software: webserver
[+] SSH Support
[+] SNMP Support
[+] Databases
[+] LDAP Services
[+] PHP
[+] Squid Support
[+] Logging and files
[+] Insecure services
[+] Banners and identification
[+] Scheduled tasks
[+] Accounting
[+] Time and Synchronization
[+] Cryptography
[+] Virtualization
[+] Containers
[+] Security frameworks
[+] Software: file integrity
[+] Software: System tooling
[+] Software: Malware
[+] File Permissions
[+] Home directories
[+] Kernel Hardening
[+] Hardening
[+] Custom tests
```
Для большей наглядности Lynis использует условные обозначения в виде цветов:
* зелёный: всё хорошо
* жёлтый: не нашёл всё необходимое, или возникла спорная ситуация
* красный: это проблема, стоит с ней разобраться
В моём случае большинство проблем (красных меток) было найдено в разделе Kernel Hardening. Ядро имеет различные настраиваемые параметры, которые определяют его работу, и некоторые из этих параметров отвечают за безопасность. Дистрибутив может не устанавливать их по умолчанию по разным причинам, но вы должны изучить каждый из них и посмотреть, нужно ли вам менять его значение в зависимости от ваших требований к безопасности:
```
[+] Kernel Hardening
------------------------------------
- Comparing sysctl key pairs with scan profile
- fs.protected_hardlinks (exp: 1) [ OK ]
- fs.protected_symlinks (exp: 1) [ OK ]
- fs.suid_dumpable (exp: 0) [ OK ]
- kernel.core_uses_pid (exp: 1) [ OK ]
- kernel.ctrl-alt-del (exp: 0) [ OK ]
- kernel.dmesg_restrict (exp: 1) [ DIFFERENT ]
- kernel.kptr_restrict (exp: 2) [ DIFFERENT ]
- kernel.randomize_va_space (exp: 2) [ OK ]
- kernel.sysrq (exp: 0) [ DIFFERENT ]
- kernel.yama.ptrace_scope (exp: 1 2 3) [ DIFFERENT ]
- net.ipv4.conf.all.accept_redirects (exp: 0) [ DIFFERENT ]
- net.ipv4.conf.all.accept_source_route (exp: 0) [ OK ]
- net.ipv4.conf.all.bootp_relay (exp: 0) [ OK ]
- net.ipv4.conf.all.forwarding (exp: 0) [ OK ]
- net.ipv4.conf.all.log_martians (exp: 1) [ DIFFERENT ]
- net.ipv4.conf.all.mc_forwarding (exp: 0) [ OK ]
- net.ipv4.conf.all.proxy_arp (exp: 0) [ OK ]
- net.ipv4.conf.all.rp_filter (exp: 1) [ OK ]
- net.ipv4.conf.all.send_redirects (exp: 0) [ DIFFERENT ]
- net.ipv4.conf.default.accept_redirects (exp: 0) [ DIFFERENT ]
- net.ipv4.conf.default.accept_source_route (exp: 0) [ OK ]
- net.ipv4.conf.default.log_martians (exp: 1) [ DIFFERENT ]
- net.ipv4.icmp_echo_ignore_broadcasts (exp: 1) [ OK ]
- net.ipv4.icmp_ignore_bogus_error_responses (exp: 1) [ OK ]
- net.ipv4.tcp_syncookies (exp: 1) [ OK ]
- net.ipv4.tcp_timestamps (exp: 0 1) [ OK ]
- net.ipv6.conf.all.accept_redirects (exp: 0) [ DIFFERENT ]
- net.ipv6.conf.all.accept_source_route (exp: 0) [ OK ]
- net.ipv6.conf.default.accept_redirects (exp: 0) [ DIFFERENT ]
- net.ipv6.conf.default.accept_source_route (exp: 0) [ OK ]
```
Посмотрите на SSH, например. Это важная часть системы, и она должна быть защищена. Здесь ничего не выделено красным, но у Lynis есть много предложений по повышению уровня защищённости службы SSH:
```
[+] SSH Support
------------------------------------
- Checking running SSH daemon [ FOUND ]
- Searching SSH configuration [ FOUND ]
- OpenSSH option: AllowTcpForwarding [ SUGGESTION ]
- OpenSSH option: ClientAliveCountMax [ SUGGESTION ]
- OpenSSH option: ClientAliveInterval [ OK ]
- OpenSSH option: Compression [ SUGGESTION ]
- OpenSSH option: FingerprintHash [ OK ]
- OpenSSH option: GatewayPorts [ OK ]
- OpenSSH option: IgnoreRhosts [ OK ]
- OpenSSH option: LoginGraceTime [ OK ]
- OpenSSH option: LogLevel [ SUGGESTION ]
- OpenSSH option: MaxAuthTries [ SUGGESTION ]
- OpenSSH option: MaxSessions [ SUGGESTION ]
- OpenSSH option: PermitRootLogin [ SUGGESTION ]
- OpenSSH option: PermitUserEnvironment [ OK ]
- OpenSSH option: PermitTunnel [ OK ]
- OpenSSH option: Port [ SUGGESTION ]
- OpenSSH option: PrintLastLog [ OK ]
- OpenSSH option: StrictModes [ OK ]
- OpenSSH option: TCPKeepAlive [ SUGGESTION ]
- OpenSSH option: UseDNS [ SUGGESTION ]
- OpenSSH option: X11Forwarding [ SUGGESTION ]
- OpenSSH option: AllowAgentForwarding [ SUGGESTION ]
- OpenSSH option: UsePrivilegeSeparation [ OK ]
- OpenSSH option: AllowUsers [ NOT FOUND ]
- OpenSSH option: AllowGroups [ NOT FOUND ]
```
На моей системе не запущен ни один контейнер и ни одна виртуальная машина. Так что, увы, тут почитать будет нечего.
```
[+] Virtualization
------------------------------------
[+] Containers
------------------------------------
```
Lynis проверяет привилегии некоторых файлов, так как это важно с точки зрения безопасности.
```
[+] File Permissions
------------------------------------
- Starting file permissions check
File: /boot/grub2/grub.cfg [ SUGGESTION ]
File: /etc/cron.deny [ OK ]
File: /etc/crontab [ SUGGESTION ]
File: /etc/group [ OK ]
File: /etc/group- [ OK ]
File: /etc/hosts.allow [ OK ]
File: /etc/hosts.deny [ OK ]
File: /etc/issue [ OK ]
File: /etc/issue.net [ OK ]
File: /etc/motd [ OK ]
File: /etc/passwd [ OK ]
File: /etc/passwd- [ OK ]
File: /etc/ssh/sshd_config [ OK ]
Directory: /root/.ssh [ SUGGESTION ]
Directory: /etc/cron.d [ SUGGESTION ]
Directory: /etc/cron.daily [ SUGGESTION ]
Directory: /etc/cron.hourly [ SUGGESTION ]
Directory: /etc/cron.weekly [ SUGGESTION ]
Directory: /etc/cron.monthly [ SUGGESTION ]
```
В конце отчёта Lynis вносит предложения по исправлению, основанные на результатах аудита. Каждое предложение начинается с описания, а рядом в скобках указывается тест (**TEST-ID**), который его сгенерировал. В следующей строке предлагается решение проблемы, если оно существует:
```
Suggestions (47):
----------------------------
* If not required, consider explicit disabling of core dump in /etc/security/limits.conf file [KRNL-5820]
https://cisofy.com/lynis/controls/KRNL-5820/
* Check PAM configuration, add rounds if applicable and expire passwords to encrypt with new values [AUTH-9229]
https://cisofy.com/lynis/controls/AUTH-9229/
```
Lynis даёт возможность найти дополнительную информацию о каждом предложении по исправлению с помощью команды **show details**, за которой следует номер теста **TEST-ID**:
```
./lynis show details TEST-ID
```
Например, чтобы узнать дополнительную информацию для теста SSH-7408 я ввожу **$ ./lynis show details SSH-7408** и получаю:
```
$ ./lynis show details SSH-7408
2020-04-30 05:52:23 Performing test ID SSH-7408 (Check SSH specific defined options)
2020-04-30 05:52:23 Test: Checking specific defined options in /tmp/lynis.k8JwazmKc6
2020-04-30 05:52:23 Result: added additional options for OpenSSH < 7.5
2020-04-30 05:52:23 Test: Checking AllowTcpForwarding in /tmp/lynis.k8JwazmKc6
2020-04-30 05:52:23 Result: Option AllowTcpForwarding found
2020-04-30 05:52:23 Result: Option AllowTcpForwarding value is YES
2020-04-30 05:52:23 Result: OpenSSH option AllowTcpForwarding is in a weak configuration state and should be fixed
2020-04-30 05:52:23 Suggestion: Consider hardening SSH configuration [test:SSH-7408] [details:AllowTcpForwarding (set YES to NO)] [solution:-]
```
Попытка не пытка
----------------
Так что, если вы хотите больше узнать о безопасности вашей Linux-системы, обратите внимание на Lynis. И, если вы хотите больше узнать о том, как работает эта утилита, как собирает всю эту информацию, — покопайтесь в её shell-скриптах. Как и в случае с другими утилитами, имеет смысл сначала опробовать её на виртуальной машине.
А какие инструменты используете вы? Поделитесь в комментариях.
---
#### На правах рекламы
[VDSina](https://vdsina.ru/pricing?partner=habr14) предлагает серверы на любой операционной системе — выбирайте одну из предустановленных ОС, либо устанавливайте из своего образа. Серверы с посуточной оплатой или уникальное на рынке предложение — вечные серверы!
[](https://vdsina.ru/eternal-server?partner=habr14) | https://habr.com/ru/post/503148/ | null | ru | null |
# 9 интересных новшеств в Laravel 9
иллюстрация © GOLTSЯ сразу, как только вышла новость о релизе, решил, что нужно посмотреть, пощупать и разобраться, чего же изменилось. Да-да, на днях, а именно 8 февраля 2022, вышел официальный релиз Laravel 9, который включает довольно много новых улучшений. Для тех же из нас, кто не боится таких слов, как alpha и beta, девятая версия фреймворка давно не новость и уже в работе.
Теперь эта версия будет поддерживаться дольше (LTS), и разработчики фреймворка пришли к решению не выпускать новые версии каждые 6 месяцев, а делать это раз в год - в феврале. Судя из [расписания](https://laravel.com/docs/master/releases#support-policy), эта версия останется актуальной год, а обновления безопасности будут выпускаться вплоть до 2025 года.
| | | | | |
| --- | --- | --- | --- | --- |
| **Версия** | **Язык** | **Дата релиза** | **Выпуск багфиксов** | **Выпуск патчей безопасности** |
| 6 (LTS) | 7.2 - 8.0 | 3 сен 2019 | 25 янв 2022 | 6 сен 2022 |
| 7 | 7.2 - 8.0 | 3 марта 2020 | 6 окт 2020 | 3 марта 2021 |
| 8 | 7.3 - 8.1 | 8 сен 2020 | 26 июля 2022 | 24 янв 2023 |
| 9 (LTS) | 8.0 - 8.1 | 8 фев 2022 | 8 фев 2024 | 8 фев 2025 |
| 10 | 8.0 - 8.1 | 7 фев 2023 | 7 авг 2024 | 7 фев 2025 |
Версия языка
------------
Новый Laravel работает только с php 8.0 и выше. Почему это так? Как мы увидим далее, разработчики воплотили в девятом фреймворке немало фишек последней версии языка, а значит, что использование php7 означало бы потерю именно этих нововведений.
```
composer create-project laravel/laravel example-app
```
Команда создала директорию, наполнила ее файлами нового проекта и установила зависимости, среди которых основным является `laravel/framework` версии *v9.0.2*. Как видим, релизную версию уже патчат.
Новые помощники
---------------
Представлены две новые функции-помощника, которые, выполняя уже встроенный ранее функционал, делают это гораздо удобнее.
Добавленная [функция](https://laravel.com/docs/9.x/helpers#method-str) **str** создает объект класса `Illuminate\Support\Stringable` для переданной строки. Это позволяет применять к тексту все методы манипуляции строкой, доступные данному классу. Такая возможность существовала и в 8 версии фреймворка и реализовывалась через `Str::of`, но теперь получается немного лаконичнее.
```
php
Route::get('/', function () {
return str('Hello, ') // Создаем класс из строки
-append('Max') // Метод добавления в конец строки
->upper(); // Метод делает все буквы строки заглавными
});
```
Функция **to\_route** создает редирект на существующий роут по его имени. Мы можем воспользоваться ей как в наших роутах, так и вернуть ее результат из метода контроллера.
```
php
// Главная страница
Route::get('/', function () {
return view('welcome');
})-name('home'); // Имя роута для главной страницы
// Старый способ редиректа по имени роута
Route::get('/test', function () {
return redirect()->route('home');
});
// Новый способ редиректа с помощью функции to_route
Route::get('/new_test', function () {
return to_route('home');
});
```
А еще мы можем передавать в новую функцию параметры роута, статус HTTP и дополнительные заголовки:
```
php
Route::get('/', function () {
return to_route('users.show', // Наименование роута
['user' = 1], // Параметры роута
302, // Код статуса редиректа
['X-Framework' => 'Laravel']); // Дополнительные заголовки
});
```
Также благодаря базированию на языке PHP 8, в классе `\Illuminate\Support\Str` добавилась поддержка таких функций для работы со строкой как `str_contains()`, `str_starts_with()` и `str_ends_with()`.
Страница исключений
-------------------
Встроенная в фреймворк страница сообщения об исключении была и раньше крайне удобной, информативной и симпатичной. Теперь в ней изменилось оформление. Добавлены возможность переключения темы на светлую/темную, настройка функционала "открыть в редакторе" и др.
Темное оформление мне понравилось даже больше, чем Dracula в IDEНиже видно, как можно менять тему, а также как отображаются данные о запросе, вызвавшем исключение доступное системе.
Тема меняется очень красивоАнонимные миграции
------------------
Возможность создавать миграции в виде анонимных классов появилось чуть ранее в Laravel 8.37. А затем в 9 - это стало своего рода стандартом, и при вызове консольной команды `php artisan make:migration` создается класс без названия, расширяющий Migration. Довольно таки небольшое изменение, но мне показалось достаточно интересным, чтобы отметить и его.
Миграция, добавляющаяся в database/migrations при создании проекта:
```
php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
return new class extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('password_resets', function (Blueprint $table) {
$table-string('email')->index();
$table->string('token');
$table->timestamp('created_at')->nullable();
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('password_resets');
}
};
```
Полнотекстовая индексация
-------------------------
Если мы пользуемся такими реляционными системами БД как MySQL или PostgreSQL, то можем прям в миграции добавить для текстовых полей полнотекстовую индексацию. При чем это делается всего лишь вызовом одного метода:
```
php
$table-text('bio')->fulltext();
```
По таким полям мы можем искать специальными методами полнотекстового поиска **whereFullText** и **orWhereFullText**, добавляя их как условие where. Эти методы преобразуются в SQL запросы поиска по индексу текста.
```
php
$users = DB::table('users')
-whereFullText('bio', 'php developer')
->get();
```
Общий контроллер
----------------
Используя методы роутера *controller* и *group,* появилась возможность объединять несколько роутов в одну группу с общим для них контроллером. Это довольно удобно и позволяет экономить на количестве кода, не указывая одно и тоже в нескольких строках. Если раньше нам пришлось бы писать как-то так:
```
php
use \App\Http\Controllers\UsersController;
Route::get('/users', [UsersController::class, 'index']);
Route::get('/users/{id}', [UsersController::class, 'showOne']);</code
```
То теперь можно это сгруппировать:
```
php
use \App\Http\Controllers\UsersController;
Route::controller(UsersController::class)-group(function () {
Route::get('/users', 'index');
Route::get('/users/{id}', 'showOne');
});
```
Scoped Bindings в роутерах
--------------------------
Благодаря усилиям разработчика из Амстердама Клаудио Деккера ([Claudio Dekker](https://dekker.io/)) была реализована и внедрена удобная возможность связывать параметры строки запроса между собой. Лично я не сразу смог понять, что за связанность такая, но на примере кода все становится "ясно-понятно".
Предположим, что мы создали таблицы с пользователями и статьями, причем каждая статья относится к определенному пользователю, как многое-к-одному. То есть у каждого пользователя есть статьи, которые он написал. И вот мы сделали url для вывода списка статей: `/users/{user}/posts`. Отсюда логично построить url для вывода отдельной статьи конкретного пользователя по следующей ссылке: `/users/{user}/posts/{post}`.
Мы используем два параметра независимых друг от друга для идентификаторов пользователя и статьи. Это позволит сопоставлять любого пользователя с любым постом. Конечно, этого нам не нужно, но и делать проверку вручную - идея так себе. Новый метод **scopeBindings** сделает это за нас.
```
php
use App\Models\Post;
use App\Models\User;
Route::get('/users/{user}/posts/{post}', function (User $user, Post $post) {
return $post;
})-scopeBindings();
```
Теперь, если мы попытаемся открыть статью несоответствующую пользователю (связь по внешнему ключу в таблице с другим пользователем), то получим страницу 404 ошибки:
Страница ошибка с оформлением по умолчаниюТакже есть возможность объединить в одну группу роуты, для которых важно соблюдение связывания параметров:
```
php
Route::scopeBindings()-group(function () {
Route::get('/users/{user}/posts/{post}', function (User $user, Post $post) {
return $post;
});
Route::get('/users/{user}/comments/{comment}', function (User $user, Comment $comment
return $comment;
});
});
```
Laravel Scout
-------------
Полнотекстовый поиск по отдельным параметрам Eloquent моделей, основанный на драйвере базы данных - вот, что представляет из себя этот Scout. Он отлично подходит для поиска по тексту в небольших и даже среднего размера базах. Если наша база вполне умещается на одном сервере, тогда мы можем не использовать такие драйверы как Algolia или MeiliSerach, а воспользоваться простым и удобным Scout с драйвером MySQL/PostgreSQL.
Для начала нужно установить Laravel Scout и выбрать его провайдер-класс для полнотекстового поиска:
```
composer require laravel/scout
php artisan vendor:publish
Which provider or tag's files would you like to publish?:
[0 ] Publish files from all providers and tags listed below
[1 ] Provider: Fruitcake\Cors\CorsServiceProvider
[2 ] Provider: Illuminate\Foundation\Providers\FoundationServiceProvider
[3 ] Provider: Illuminate\Mail\MailServiceProvider
[4 ] Provider: Illuminate\Notifications\NotificationServiceProvider
[5 ] Provider: Illuminate\Pagination\PaginationServiceProvider
[6 ] Provider: Laravel\Sail\SailServiceProvider
[7 ] Provider: Laravel\Sanctum\SanctumServiceProvider
[8 ] Provider: Laravel\Scout\ScoutServiceProvider
[9 ] Provider: Laravel\Tinker\TinkerServiceProvider
[10] Provider: Spatie\LaravelIgnition\IgnitionServiceProvider
[11] Tag: cors
[12] Tag: laravel-errors
[13] Tag: laravel-mail
[14] Tag: laravel-notifications
[15] Tag: laravel-pagination
[16] Tag: sail
[17] Tag: sail-bin
[18] Tag: sail-docker
[19] Tag: sanctum-config
[20] Tag: sanctum-migrations
> 8
Copied File [/vendor/laravel/scout/config/scout.php] To [/config/scout.php]
```
Был создан конфигурационный файл для Scout. И в нем мы можем установить нужный нам драйвер database.
Настройки посковика ScoutТеперь можно настраивать поиск по в классах - моделях, чтобы определить какие модели имеют поддержку полнотекстового поиска и по каким полям. И обязательно добавим трейт Searchable к модели, что позволит использовать все необходимые нам методы поиска. Как видно из скриншота ниже, кроме имени я добавил поиск и к нестандартному полю *bio* (биография).
Метод toSearchableArray возвращает массив полей для поискаПоищем всех пользователей, у которых в биографии есть упоминание обучения в ВУЗе.
```
php
Route::get('/', function () {
return \App\Models\User::search('институт')-get();
})->name('home');
```
Покрытие кода тестами
---------------------
В Laravel 9 мы теперь можем генерировать отчет о покрытии кода тестами с помощью консольной команды *php artisan test*. Давайте посмотрим, что отобразится, если запустить команду как и раньше.
Тесты успешно выполнилисьЕсли посмотрим подсказку по команде запуска тестов, то увидим 2 новых ключа `--coverage` и `--min[=MIN]`.
```
php artisan help test
Usage:
test [options]
Options:
--without-tty Disable output to TTY
--coverage Indicates whether code coverage information should be collected
--min[=MIN] Indicates the minimum threshold enforcement for code coverage
```
*Coverage* - указывает, следует ли собирать информацию о покрытии кода.
*Min* - минимальное пороговое значение для покрытия кода. Другими словами, это возможность указать, какой минимальный уровень покрытия кода тестами для нас удовлетворителен.
Я запускаю команду в консоли, но вижу ошибку.
Ошибка запуска командыНе установлен драйвер, но, думаю, это легко починить, установив Xdebug для php. Как несложно было догадаться по скриншотам, у меня MacOS, поэтому воспользуюсь встроенными утилитами для установки и перезапуска сервисов. Предположу, что на другие ОС установка не намного сложнее.
```
pecl install xdebug
brew services restart php
brew services restart nginx
```
После установки xdebug и перезагрузки сервисовКазалось бы, запускаем команду и радуемся результату, но нет, опять ошибка.
Xdebug ругается :(Xdebug ругается о том, что не установлен режим покрытия кода тестами. Это мы легко исправляем и видим красивое описание покрытия кода.
Пару слов в конце
-----------------
С публикацией нового релиза, мы увидели немало полезных новшеств, поддержку и реализацию возможностей последней версии языка. Мы уже увидели два патча, и возможно будет еще несколько, прежде чем фреймворк станет по-настоящему достоин продакшна. Но мои руки уже чешутся, чтобы обновиться на проектах до последней 9 версии Laravel. | https://habr.com/ru/post/651553/ | null | ru | null |
# Локализация расширений Google Chrome — необходимо и просто
Разнообразие и легкая доступность расширений сыграли значительную роль в популярности браузера Google Chrome. Вероятно, многие из вас имеют опыт их написания. Возможно, еще не опыт, но уже желание попробовать или даже конкретную идею. Осталось лишь начать.
Уже на этапе проектирования я предлагаю вам задуматься о мультиязычности. Большинству людей гораздо комфортней пользоваться продуктом на своем родном языке, даже если они знают английский, и особенно, если не знают.
Немалая польза и для вас: значительно вырастет потенциальная аудитория, увеличится число установок. Вы будете получать интригующий фидбэк:
В этом посте я расскажу о том, как перевел свое расширение «[Изображение по центру](https://chrome.google.com/webstore/detail/image-in-the-center/kcpejamelebpigblebnbabhndaaffjok)» на 11 языков, как организовал процесс и какие вспомогательные инструменты использовал для автоматизации скучной рутины.
#### Документация
В документации для разработчиков Google Chrome [подробно рассказывается](https://developer.chrome.com/extensions/i18n) о том, что именно нужно сделать, чтобы перевести интерфейс вашего расширения или приложения на более чем 50 языков. Не пугайтесь, на все 50 переводить не обязательно, вьетнамский можно пропустить, а то и вовсе оставить пару-тройку популярных, включая русский.
Отвлекся. Если вкратце, то:
1. Все переводы лежат внутри директории *\_locales*, расположенной в корне проекта.
2. Для каждого языка внутри *\_locales* создается папка, соответствующая идентификатору языка. Для русского *ru*, для английского *en* и так далее. Их полный список [есть в доках](https://developer.chrome.com/webstore/i18n?csw=1#localeTable).
3. Внутри директории с именем-локалью лежит файл *messages.json*. Перевод в нем.
Файл устроен нехитро — это список ключей, каждый из которых соответствует определенному слову, фразе, предложению или целому рассказу. По этим ключам кусочки текста будут браться из *messages.json* и добавляться в интерфейс. Каждый из них несет в себе три части:
* *message* — тот самый текст для вывода на экран, ради которого все затевалось.
* *description* — вспомогательный текст, позволяющий переводчику понять контекст использования *message*. Ведь одно и то же слово можно в зависимости от ситуации перевести по-разному. Так *«коса (идущая от берега узкая полоса земли)»* превратится в *«foreland»*, а *«коса (сельскохозяйственный инструмент)»* в *«scythe»*. Текст в *description* необязательный, его можно пропустить.
* *placeholders* — опциональное свойство, позволяющее передавать для фразы произвольный контекст. Например, для Паши показать заголовок *«Привет, Паша!»*, а для Маши *«Привет, Маша!»*. Подробно об использовании placeholder-ов можно почитать в соответствующем [разделе документации](https://developer.chrome.com/extensions/i18n-messages#placeholders).
К сожалению, группа разработки движка Chromium, лежащего в основе Google Chrome, не стала реализовывать «плюрализацию» (склонение слов в зависимости от числительного) на уровне структуры файлов локалей. Их можно понять. Из-за многообразия языков, из-за обилия специфичных правил сделать это было бы очень трудно. Взамен [они предлагают](https://www.chromium.org/developers/design-documents/extensions/how-the-extension-system-works/i18n#TOC-Plural-form) использовать обтекающие формулировки, например, *«Число доступных языков: 11»* вместо *«Переведено на 11 языков»*.
Когда вы решите добавить перевод на очередной язык, вам нужно будет создать еще одну директорию, поместить туда файл и аккуратно заполнить ключи, как в других полях, фраза за фразой.
А что, если в интерфейсе появилась еще одна кнопка? Не беда — последовательно открываем каждую директорию, потом каждый файл, добавляем туда новый ключ с названием кнопки, пишем перевод, сохраняем. Так, стойте, а в директорию *fr* добавили? Открываем файл, проверяем, сохраняем… А на испанский перевели? Открываем, проверяем, сохраняем…
А что, если в интерфейсе появилось пять новых элементов? А что, если десять? Вероятность возникновения ошибки очень высока.
Google дал разработчикам неплохие инструменты для интернационализации, но на практике ежедневная работа с вязанкой файлов неудобна и скучна. Даже если вы готовы смириться со скукой, человеческий фактор оставляет лазейку для ошибок. Их вероятность необходимо снижать при любой возможности.
Как же улучшить существующую схему?
#### Оптимизация
Решив, что лучше день потерять, а потом за пять минут долететь, я начал поиск более удобного решения. Врать не буду, искал недолго. Как любой другой разработчик, быстро сдался и взялся за свой велосипед.
Первое, что приходит на ум — гораздо удобнее хранить и редактировать фразы в одном месте, в одном файле. Так, чтобы всё и сразу было перед глазами.
Идеальный формат — таблица. Столбцы соответствуют языкам, строки — ключам с фразами. Можно использовать любой удобный редактор: Microsoft Excel, Numbers от Apple, что-то еще. Я остановился на таблицах из Google Docs. К примеру, вот так теперь выглядит фрагмент моего единственного файла:
С такой таблицей легко добавлять новые языки — копируем файл и отправляем переводчику. Он заполняет свою колонку и присылает обратно.
С такой таблицей легко добавлять новые фразы — создаем новую строку для очередного ключа и последовательно заполняем все колонки. Можно настроить в редакторе подсветку пустых ячеек тревожно-оранжевым цветом — теперь точно ничего не пропустим.
Плейсхолдеры добавляются тоже просто, группу оборачиваете в скобки, ключ и значение разделяете двоеточием ([см. пример](https://docs.google.com/spreadsheets/d/1ONVyE5iwe7Hjg74eUQ5WdJjQ7i8kWNcbfXI-uh3bvdc/edit#gid=0)).
Создание структуры, переписка с переводчиками, что-то своими силами — таблица готова. Что дальше?
#### Автоматизация
Для генерации всех необходимых директорий и файлов я написал npm-модуль [csv-locales](https://www.npmjs.com/package/csv-locales). Его ядром является другая, сторонняя утилита [csv-parse](https://www.npmjs.com/package/csv-parse). Название не врет, она парсит CSV-файл, преобразует его в json и передает результат мне. Сам CSV-файл мы получаем экспортом из нашей таблицы. Дальше документ анализируется и разбивается на фрагменты поменьше, на отдельные языки. Они в виде *messages.json* размещаются по целевым директориям. Всё происходит один в один, как я рассказывал чуть выше, но почти моментально и без ошибок *\*\*смех из зала\*\**.
Снизим наше участие до минимума, будем запускать процесс одной командой из консоли. Я обернул модуль в плагины для двух популярных систем сборки:
1. [grunt-csv-locales](https://www.npmjs.com/package/grunt-csv-locales)
2. [gulp-csv-locales](https://www.npmjs.com/package/gulp-csv-locales)
Всё, что требуется — это экспортировать ваш файл в формат CSV и натравить на него скрипт. В качестве основы для таблицы используем [этот образец](https://docs.google.com/spreadsheets/d/1ONVyE5iwe7Hjg74eUQ5WdJjQ7i8kWNcbfXI-uh3bvdc/edit?usp=sharing).
Пример настройки для grunt-а:
```
module.exports = function (grunt) {
grunt.initConfig({
csvLocales: {
all: 'source/locales.csv',
options: {
dirPath: '_locales'
}
}
});
grunt.loadNpmTasks('grunt-csv-locales');
};
```
Результат:
Ура! Добавление новых языков, новых текстовых элементов в интерфейс больше не вызывает депрессию. Автоматизация рутины позволяет сосредоточиться на действительно важных моментах, на более интересных задачах, без скучного *«открыл / отредактировал / закрыл / повторить»*.
Следует упомянуть, что команда Google предлагает заказать перевод вашего расширения прямо из панели инструментов разработчика. Вам надо лишь загрузить исходный *message.json*, выбрать языки и оплатить работу переводчиков. Я не пробовал. Эта услуга появилась относительно недавно, когда я в ней уже не нуждался. Плюс, по деньгам выйдет значительно дороже переводчиков-фрилансеров. Если у вас есть опыт подобного перевода, пожалуйста, расскажите о нем в комментарии.
Стандартным решением для локализации ПО является библиотека [gettext](http://www.gnu.org/software/gettext/manual/gettext.html). Для расширений Google Chrome она не используется, однако, [gettext-parser](https://www.npmjs.com/package/gettext-parser) в npm уже существует, а значит, при желании, реализовать поддержку PO-файлов мы сможем. Чем не планы на будущее?
Для тех, кто дочитал до конца, полезные ссылки:
* [grunt таск](https://www.npmjs.com/package/grunt-csv-locales)
* [gulp таск](https://www.npmjs.com/package/gulp-csv-locales)
* модуль [csv-locales](https://www.npmjs.com/package/csv-locales), лежащий в основе тасков
* [образец структуры таблицы](https://docs.google.com/spreadsheets/d/1ONVyE5iwe7Hjg74eUQ5WdJjQ7i8kWNcbfXI-uh3bvdc/edit?usp=sharing)
* [документация Google Chrome](https://developer.chrome.com/webstore/i18n) по переводу расширений и приложений на разные языки
* [смешная гифка с котом](https://habrastorage.org/files/ee9/7c1/ffc/ee97c1ffcbf04dbdb7757ff272fcc3a9.gif)
Буду рад ответить на ваши вопросы, услышать фидбэк. Расскажите о вашем опыте. Что используете? Что посоветуете мне? | https://habr.com/ru/post/267501/ | null | ru | null |
# Опыт использования jQuery/AJAX/Telerik Extensions for MVC
Недавно занимался портированием проекта с “обычного” ASP.NET на ASP.NET MVC. Решил в силу развития технологий попробовать сделать красиво и асинхронно. Этот пост о том, что и как я писал, и что из этого получилось.
### Выбор технологий
Сейчас почему-то все кому не лень переписывают сайты на MVC благо это выглядит изящнее и работает быстрее – последствие феномена Ajax а также всемирного распостранения jQuery. Столкнувшись с такой же задачей (а также весьма сжатыми сроками), я решил тоже попробовать. В плане технологий, я выбрал следующие:
* [Asp.Net MVC](http://asp.net/mvc) и дефолтный ViewEngine. Несмотря на то, что Spark это типа круто, де факто создание “богатого UI” все равно ложится на плечи серверной геренации, так что “красивость тегов” была бы уместна только если я бы генерировал, скажем, обычные таблички вместо Ajax-ориентированных.
* [jQuery](http://jquery.com/). Конечно есть тот же ASP.NET AJAX и интересности вроде Ajax.LinkAction() и т.д., но не имея особого опыта ни в том ни в другом, решил идти на поводу у толпы. Возможно будет время и на то, чтобы изучить варианты от Microsoft.
* [jQuery UI](http://jqueryui.com/). Супербиблиотечка для jQuery, которая делает весьма красивый пользовательский интерфейс. Мне лично нужен был календарик.
* [Telerik Extensions for ASP.NET MVC](http://www.telerik.com/products/aspnet-mvc/) для таблиц и tab-контрола. Почему Telerik? Мне понравился простой, понятный API и весьма неплохой по виду интерфейс. Также радует тот факт, что разработчики со статусом MVP получают бесплатные лицензии – у нас в команде из 3х человек таковых двое, так что получается неплохая экономия.
N.b.: для open source проектов эти компоненты можно использовать бесплатно.
Имея в доступе все компоненты, я приступил к сборке. Ниже я опишу самые ключевые и полезные аспекты, которые смогут пригодиться другим разработчикам.
### Работа с таблицами
Главной моей целью при работе со сторонними компонентами было получение асинхронного наполнения таблиц. В принципе, чтобы получить собственно данные для таблицы, нужно вытащить некий IEnumerable и передать его во вьюшку, так? Нет, не совсем.
Если что-то на странице забирает объекты через Ajax, то формат этих объектов должен быть весьма примитивным. Это не то же самое как если бы мы использовали сильнотипизированное представление. Все должно быть весьма примитивно.
Начнем с таблицы как таковой. Таблица (по крайней мере в подходе Telerik) создается с помощью хитрых C# конструктов во вьюшке.
> `<%= Html.Telerik().Grid().Name("PersonGrid").Columns(cs =>
>
>
> {
>
>
> cs.Add(i => i.Name).Title("Name");
>
>
> cs.Add(i => i.Gender).Title("Gender");
>
>
> }).Ajax(ajax => ajax.Enabled(true).Action("GetPeople", "Home"))
>
>
> .Pageable(pager => pager.PageSize(20).Position(GridPagerPosition.Bottom))
>
>
> %>`
Код выше определяет таблицу с двумя колонками, при этом для представления он использует не Person (это то что мы получаем из базы), а PersonRow, т.е. модельку которая из Person вытаскивает все что нужно и хранит – угадайте что – просто строки! Потому как никакой дополнительной логики мы добавить в код выше не сможем.
> `*// не транслируется в js, и тем самым не будет работать!*cs.Add(i => i.IsMale ? "Male" : "Female").Title("Gender");`
Так вот, наша табличка асинхронно забирает данные из метода контроллера. Этот метод, естественно, возвращает не IEnumerable а скромный ActionResult. Дабы все стало понятно, вот чуть-чуть кода:
> `[GridAction]
>
>
> public ActionResult GetPeople()
>
>
> {
>
>
> return View(new GridModel {
>
>
> Data = repository.GetPeople().Select(p => new PersonRow(p))
>
>
> });
>
>
> }`
Интересно что эти два кусочка кода (на странице и в контроллере) – фактически все, что нужно чтобы асинхронно загружать табличку. Будучи ajax-driven, табличку можно обновлять из того же jQuery. Делается это просто:
> `$('#PersonGrid').data('tGrid').ajaxRequest();`
### Вызов ajax-методов через jQuery
Поскольку я решил использовать jQuery, мне нужно было научиться вызывать методы страниц используя ajax. Мне нужно было и отсылать данные из формы, и получать данные. Для получения данных я воспользовался форматом json, т.е. мои методы на стороне контроллера принимали набор параметров (как обычные controller actions), а возвращали JsonResult.
> `public JsonResult FindPersonName(string id)
>
>
> {
>
>
> try
>
>
> {
>
>
> string name = repository.FindById(int.Parse(id)).Name;
>
>
> return Json(new {Result = Name, Success = true});
>
>
> }
>
>
> catch (Exception ex)
>
>
> {
>
>
> return Json(new {Result = "Could not find person. " + ex.Message, Success = false });
>
>
> }
>
>
> }`
Код выше возвращает результат вне зависимости от того, было исключение или нет, что проблематично для нас, т.к. нам нужно обрабатывать целых три разных ситуации:
* Запрос прошел успешно
* На стороне сервера было исключение и Success == false
* До сервера и дело не дошло, ajax-вызов упал на клиенте
Теперь собственно поговорим о вызове этого метода из jQuery. Тут у нас достаточно “пестрый” вызов, который показывает обработку нажатия пользователем на конкретный hyperlink:
> `$('#lnkFindName').click(function(event) {
>
>
> $.ajax({
>
>
> type: "POST",
>
>
> contentType: "application/x-www-form-urlencoded",
>
>
> url: "/Home/FindPersonName/",
>
>
> dataType: "json",
>
>
> data: {
>
>
> id: $('#personId').val()
>
>
> },
>
>
> success: function(msg, status) {
>
>
> if (msg['Success'] == true) {
>
>
> $('#personName').val(msg['Result']);
>
>
> }
>
>
> else {
>
>
> $('#statusBox').html(msg['Result']).fadeIn();
>
>
> }
>
>
> },
>
>
> error: function(msg, status) {
>
>
> $('#statusBox').html(msg.statusText).fadeIn();
>
>
> }
>
>
> });
>
>
> });`
Как видите, json идет в обе стороны, и весьма успешно – получив сообщение, мы вытаскиваем информацию через msg['key']. В примере выше обработаны все три варианта завершения запроса.
### Заключение
Должен заметить, что пользоваться инструментарием на основе jQuery – очень просто. И взаимодействие через ajax предельно понятно когда работаешь с грамотно спроектированными компонентами. Как не странно, мой первый ajax-блин комом не вышел. :) | https://habr.com/ru/post/79175/ | null | ru | null |
# Генерация версии android приложения из ревизии subversion и git
Когда пользователи сталкиваются с проблемами — всегда хочется точно знать какой именно версией ПО они пользуются. При использовании системы контроля версий и автоматической нумерации версий ПО, такую информацию можно предоставить пользователям, а в случае необходимости просто попросить продиктовать строку.
О том, как можно пронумеровать свой android проект написано [здесь](http://ballardhack.wordpress.com/2010/09/28/subversion-revision-in-android-app-version-with-eclipse/) и [здесь](http://www.nearinfinity.com/blogs/matt_wizeman/svn_revision_numbers_in_ant.html). В обоих статьях рассмотрен пример получения версии проекта с помощью 'svn info', причём в первой статье автор жалуется на отсутствие [SvnAnt](http://subclipse.tigris.org/svnant.html), а во второй статье автор замечает проблему, связанную с использованием 'svn info'. Проблема связана с тем, что 'svn info' выдаёт неточные сведения о ревизии рабочей копии.
Далее рассмотрен пример решения этой проблемы достаточно простым способом.
UPD: добавлен скрипт для git.
#### Проблема
Суть в том, что команда 'svn info' выдаёт last commit revision элементов указанного каталога.
Например:
```
$ svn info
Revision: 32
```
При этом:
```
$ svn info ./src/ru/bsrgin/myproject/MyActivity.java
Revision: 45
$ svn -r 32 -v log
Changed paths:
D /some-folder
$ svn -r 45 -v log
Changed paths:
M /src/ru/bsrgin/myproject/MyActivity.java
```
Авторы обоих упомянутых статей интерпретируют вывод утилиты как обычный property-файл.
Т.е. наличие строк вида *Revision: 32* позволяет им интерпретировать данные как параметры в Build And скрипте. Соответственно задача сильно усложняется, если выполнять 'svn -R info' и искать наиболее позднюю ревизию в выходном файле.
Запрос же 'svn -r HEAD info' выдаёт номер ревизии на сервере, а не в рабочей копии, что тоже неверно, т.к. не выполняется главное условие — генерация актуальной версии ПО. Аргументы BASE, COMMITTED и PREV также не дают ответ на вопрос — из файлов какой версии собран проект?
#### Решение
Я уже готов был отказаться от метода получения версии ПО, описанного в статье, но вовремя вспомнил про ещё одну утилитку 'svnversion'. Формат вывода данных этой утилитой такой:
```
4123:4168 mixed revision working copy
4168M modified working copy
4123S switched working copy
4123P partial working copy, from a sparse checkout
4123:4168MS mixed revision, modified, switched working copy
```
Т.е. если в моей рабочей копии запустить 'svnversion', то появится такой результат:
```
$ svnversion
32:46
```
А если ещё и модифицировать какой-нибудь файл, то:
```
$ svnversion
32:46M
```
Собственно говоря, утилита выдаёт полезную информацию, которую хотелось бы включить в версию приложения, но не подходит формат вывода данных. Пришлось немного разобраться с синтаксисом Build Ant скриптов…
Ниже даны инструкции как добавить в свой проект версию рабочей копии subversion или git.
#### Последовательность действий
Создаём файл *svn-revision.build.xml* в корне проекта. Вставляем в него следующее содержимое:
```
Revision: ${svnversion.Revision}
```
Подразумевается, что *AndroidManifest.xml* находится в том же самом каталоге, что и *svn-revision.build.xml*. Если это не так, то модифицируйте 22 строчку. Также подразумевается, что версия приложения выглядит как *1.2* или *1.2.3*. Если нет, то модифицируйте 23 строчку.
Далее создаём файл *.externalToolBuilders/AddSvnRevisionToVersion.launch* и добавляем в него следующие строчки.
```
xml version="1.0" encoding="UTF-8" standalone="no"?
```
Вместо *ANDROID-APP* вставляем название своего проекта (смотрим значение тэга в файле *.project*). Далее модифицируем файл *.project* — после тэга добавляем приведённый ниже скрипт:
```
org.eclipse.ui.externaltools.ExternalToolBuilder
full,incremental,
LaunchConfigHandle
/.externalToolBuilders/AddSvnRevisionToVersion.launch
```
В результате первым task-ом будет добавлен процесс, который модифицирует *AndroidManifest.xml* файл. Файл будет обновляться всякий раз, когда запускается build, также процесс будет запускаться всякий раз, когда собирается release пакет. Если сборка release пакета автоматизирована или вы не пользуетесь Eclipse, то надо настроить ваш сборщик на выполнение *svn-revision.build.xml*.
#### Git
Для получения аналогичного результата при использовании SCV git, заменяем файл *svn-revision.build.xml* на приведённый ниже *git-revision.build.xml*.
```
Revision: ${git.Revision}
```
Соответственно не забываем поправить файлы *AddSvnRevisionToVersion.launch* и *.project*.
#### Получение versionName программным способом
Теперь для того, чтобы получить версию ПО, можно воспользоваться таким методом:
```
public static getApplicationVersion()
{
try {
return getInstance().getApplicationContext().getPackageManager()
.getPackageInfo(getPackageName(), 0).versionName;
}
catch (NameNotFoundException e) {
return "App not installed!";
}
}
```
В результате в своём проекте я получил строчку *1.0.32:46M* (subversion) и *1.0.58c57+* (git). | https://habr.com/ru/post/132017/ | null | ru | null |
# Разработка измерительного прибора ИРИС
Приветствую, сообщество Хабра. Недавно наша компания выпустила на рынок контрольно-измерительный прибор ИРИС. Являясь главным программистом этого проекта, хочу рассказать вам про разработку прошивки прибора (По оценке руководителя проекта прошивка составляет не более 30% от общего объема работ от идеи до серийного производства). Статья в первую очередь будет полезна начинающим разработчикам в плане понимания трудозатрат на «реальный» проект и пользователям, которые желают «заглянуть под капот».
### Назначение прибора
ИРИС – многофункциональный измерительный прибор. Он умеет измеряет ток (амперметр), напряжение (вольтметр), мощность (ваттметр) и ряд других величин. КИП ИРИС запоминает их максимальные значения, пишет осциллограммы. С подробным описанием устройства можно ознакомиться на сайте компании.
Немножко статистики
-------------------
### Сроки
Первый коммит в SVN: 16 мая 2019.
Релиз: 19 июня 2020.
\*это календарное время, а не фулл-тайм разработка на протяжении всего срока. Были отвлечения на другие проекты, ожидания ТЗ, итераций железа и т.д.
### Коммиты
Количество в SVN: 928
Откуда столько?
1) Являюсь сторонником микрокоммитов при разработке
2) Дубли в ветках под железо и эмулятор
3) Документация
Так что, количество с полезной нагрузкой в виде нового кода (ветка trunk) не больше 300.
### Количество строк кода
Статистика собиралась утилитой [cloc](https://github.com/AlDanial/cloc) с дефолтными параметрами без учета исходников HAL’a STM32 и ESP-IDF ESP32.
Прошивка STM32: 38334 строк кода. Из них:
60870-5-101: 18751
ModbusRTU: 3859
Осциллограф: 1944
Архиватор: 955
Прошивка ESP32: 1537 строк кода.
Аппаратные компоненты (задействованная периферия)
-------------------------------------------------
Основные функции прибора реализованы в прошивке STM32. За связь по Bluetooth отвечает прошивка ESP32. Общение между чипами осуществляется по UART’у (см. рисунок в шапке).
NVIC – контроллер прерываний.
IWDG – сторожевой таймер для перезапуска чипа в случае зависания прошивки.
Timers – прерывания по таймеру обеспечивают сердцебиение проекта.
EEPROM – память для хранения производственной информации, уставок, показаний максиметра, калибровочных коэффициентов АЦП.
I2C – интерфейс для доступа к чипу EEPROM.
NOR – память для хранения осциллограмм.
QSPI – интерфейс для доступа к чипу NOR памяти.
RTC – часы реального времени обеспечивают ход времени после выключения прибора.
ADC – АЦП.
RS485 – последовательный интерфейс для подключения по протоколам ModbusRTU и 60870-101.
DIN, DOUT – дискретный вход и выход.
Button – кнопка на передней панели прибора для переключения индикации между измерениями.
Архитектура ПО
--------------
### Основные модули ПО
### Поток данных измерений
### Операционная система
С учетом ограничений объема флеш памяти (ОС вносит накладные расходы) и относительной простоты прибора было решено отказаться от использования операционной системы и обойтись прерываниями. Такой подход уже не раз освещался в статьях на хабре, поэтому приведу лишь блок-схемы задач внутри прерываний с их приоритетами.
#### Пример кода. Генерация отложенного прерывания в STM32.
```
// Инициализация прерывания с приоритетом 6
HAL_NVIC_SetPriority(CEC_IRQn, 6, 0);
HAL_NVIC_EnableIRQ(CEC_IRQn);
// Генерация прерывания
HAL_NVIC_SetPendingIRQ(CEC_IRQn);
// Обработчик
void CEC_IRQHandler(void) {
// user code
}
```
### ШИМ 7 сегментной индикации
В приборе две строки по 4 символа, всего 8 индикаторов. У 7-и сегментных индикаторов имеются 8 спараллеленных линий данных (A,B,C,D,E,F,G,DP) и по 2 линии выбора цвета (зеленый и красный) для каждого.
### Хранилище осциллограмм
Хранилище организовано по принципу циклического буфера со «слотами» по 64 КБ на осциллограмму (фиксированный размер).
### Обеспечение целостности данных при неожиданном выключении
В EEPROM данные пишутся в двух копиях с добавленной контрольной суммой в конце. Если в момент записи данных прибор будет выключен, то хотя бы одна копия данных останется целостной. Контрольной суммой также дополняется каждый срез данных осциллографа (значения измерений на входах АЦП), таким образом, невалидная контрольная сумма среза будет признаком окончания осциллограммы.
### Автоматическая генерация версии ПО
1) Создать файл version.fmt:
#define SVN\_REV ($WCREV$)
2) Перед сборкой проекта добавить команду (для System Workbanch):
SubWCRev ${ProjDirPath} ${ProjDirPath}/version.fmt ${ProjDirPath}/version.h
После выполнения этой команды будет создан файл version.h с номером последнего коммита.
Аналогичная утилита есть и для GIT’a: GitWCRev. /version.fmt ./main/version.h
#define GIT\_REV ($WCLOGCOUNT$)
Это позволяет однозначно сопоставлять коммит и версию ПО.
### Эмулятор
Т.к. разработка прошивки началась до появления первого экземпляра железа, то часть кода начал писать как консольное приложение на ПК.
Преимущества:
— разработка и отладка под ПК проще, чем непосредственно на железе.
— возможность генерации любых входных сигналов.
— возможность отладки клиента на ПК без железа. На ПК ставится драйвер com0com, который создает пару com-портов. На одном из них запускается эмулятор, а на другом подключается клиент.
— способствует красивой архитектуре, т.к. приходится выделять интерфейс аппаратно-зависимых модулей и писать две реализации
#### Пример кода. Две реализации чтения данных из eeprom.
```
uint32_t eeprom_read(uint32_t offset, uint8_t * buf, uint32_t len);
ifdef STM32H7
uint32_t eeprom_read(uint32_t offset, uint8_t * buf, uint32_t len)
{
if (diag_isError(ERR_I2C))
return 0;
if (eeprom_wait_ready()) {
HAL_StatusTypeDef status = HAL_I2C_Mem_Read(&I2C_MEM_HANDLE, I2C_MEM_DEV_ADDR, offset, I2C_MEMADD_SIZE_16BIT, buf, len, I2C_MEM_TIMEOUT_MS);
if (status == HAL_OK)
return len;
}
diag_setError(ERR_I2C, true);
return 0;
}
#endif
#ifdef _WIN32
static FILE *fpEeprom = NULL;
#define EMUL_EEPROM_FILE "eeprom.bin"
void checkAndCreateEpromFile() {
if (fpEeprom == NULL) {
fopen_s(&fpEeprom, EMUL_EEPROM_FILE, "rb+");
if (fpEeprom == NULL)
fopen_s(&fpEeprom, EMUL_EEPROM_FILE, "wb+");
fseek(fpEeprom, EEPROM_SIZE, SEEK_SET);
fputc('\0', fpEeprom);
fflush(fpEeprom);
}
}
uint32_t eeprom_read(uint32_t offset, uint8_t * buf, uint32_t len)
{
checkAndCreateEpromFile();
fseek(fpEeprom, offset, SEEK_SET);
return (uint32_t)fread(buf, len, 1, fpEeprom);
}
#endif
```
### Ускорение передачи данных (архивация)
Для увеличения скорости скачивания осциллограмм была реализована их архивация перед отправкой. В качестве архиватора использовалась библиотека [uzlib](https://github.com/pfalcon/uzlib). Распаковка этого формата на C# осуществляется в пару строк кода.
#### Пример кода. Архивация данных.
```
#define ARCHIVER_HASH_BITS (12)
uint8_t __RAM_288K archiver_hash_table[sizeof(uzlib_hash_entry_t) * (1 << ARCHIVER_HASH_BITS)];
bool archive(const uint8_t* src, uint32_t src_len, uint8_t* dst, uint32_t dst_len, uint32_t *archive_len)
{
struct uzlib_comp comp = { 0 };
comp.dict_size = 32768;
comp.hash_bits = ARCHIVER_HASH_BITS;
comp.hash_table = (uzlib_hash_entry_t*)&archiver_hash_table[0];
memset((void*)comp.hash_table, 0, sizeof(archiver_hash_table));
comp.out.outbuf = &dst[10]; // skip header 10 bytes
comp.out.outsize = dst_len - 10 - 8; // skip header 10 bytes and tail(crc+len) 8 bytes
comp.out.is_overflow = false;
zlib_start_block(&comp.out);
uzlib_compress(∁, src, src_len);
zlib_finish_block(&comp.out);
if (comp.out.is_overflow)
comp.out.outlen = 0;
dst[0] = 0x1f;
dst[1] = 0x8b;
dst[2] = 0x08;
dst[3] = 0x00; // FLG
// mtime
dst[4] =
dst[5] =
dst[6] =
dst[7] = 0;
dst[8] = 0x04; // XFL
dst[9] = 0x03; // OS
unsigned crc = ~uzlib_crc32(src, src_len, ~0);
memcpy(&dst[10 + comp.out.outlen], &crc, sizeof(crc));
memcpy(&dst[14 + comp.out.outlen], &src_len, sizeof(src_len));
*archive_len = 18 + comp.out.outlen;
if (comp.out.is_overflow)
return false;
return true;
}
```
#### Пример кода. Распаковка данных.
```
// byte[] res; // сжатые данные
using (var msOut = new MemoryStream())
using (var ms = new MemoryStream(res))
using (var gzip = new GZipStream(ms, CompressionMode.Decompress))
{
int chunk = 4096;
var buffer = new byte[chunk];
int read;
do
{
read = gzip.Read(buffer, 0, chunk);
msOut.Write(buffer, 0, read);
} while (read == chunk);
//msOut.ToArray();// обработать распакованный массив данных
}
```
### Про ~~постоянные~~ изменения в ТЗ
Мем с просторов интернета:
— Но вы же утвердили техническое задание!
— Техническое задание? Мы думали ТЗ — это «Точка зрения», и у нас их несколько.
#### Пример кода. Обработка клавиатуры.
```
enum {
IVA_KEY_MASK_NONE,
IVA_KEY_MASK_ENTER = 0x1,
IVA_KEY_MASK_ANY = IVA_KEY_MASK_ENTER,
}IVA_KEY;
uint8_t keyboard_isKeyDown(uint8_t keyMask) {
return ((keyMask & keyStatesMask) == keyMask);
}
```
Посмотрев такой кусочек кода вы можете подумать зачем он все это нагородил, если в приборе только одна кнопка? В первой версии ТЗ было 5 кнопок и с помощью них планировалось реализовать редактирование уставок непосредственно на приборе:
```
enum {
IVA_KEY_MASK_NONE = 0,
IVA_KEY_MASK_ENTER = 0x01,
IVA_KEY_MASK_LEFT = 0x02,
IVA_KEY_MASK_RIGHT = 0x04,
IVA_KEY_MASK_UP = 0x08,
IVA_KEY_MASK_DOWN = 0x10,
IVA_KEY_MASK_ANY = IVA_KEY_MASK_ENTER | IVA_KEY_MASK_LEFT | IVA_KEY_MASK_RIGHT | IVA_KEY_MASK_UP | IVA_KEY_MASK_DOWN,
}IVA_KEY;
```
Так что, если в коде вы обнаружили странность, то не нужно сразу же вспоминать предыдущего программиста нехорошими словами, возможно, на тот момент были причины такой реализации.
Некоторые проблемы при разработке
---------------------------------
### Закончилась флеш
В микроконтроллере имеется 128 Кб флеш памяти. В какой-то момент отладочная сборка превысила этот объем. Пришлось включать оптимизацию по объему -Os. Если же требовалась отладка на железе, то делалась специальная сборка с отключением некоторых программных модулей (модбас, 101-й).
### Ошибка данных по QSPI
Иногда, при чтении данных по qspi, появлялся «лишний» байт. Проблема пропала после увеличения приоритета прерываний qspi.
### Ошибка данных в осциллографе
Т.к. данные пересылает DMA, то процессор может их «не увидеть» и прочитать старые данных из кэша. Нужно выполнять валидацию кэша.
#### Пример кода. Валидация кэша.
```
// сброс данных из кэша в озу перед записью их в QSPI/DMA
SCB_CleanDCache_by_Addr((uint32_t*)(((uint32_t)&data[0]) & 0xFFFFFFE0), dataSize + 32);
// Обновление данных от ADC/DMA в кэше перед обращением из CPU
SCB_InvalidateDCache_by_Addr((uint32_t*)&s_pAlignedAdcBuffer[0], sizeof(s_pAlignedAdcBuffer));
```
### Проблемы с АЦП(разные показания от включения к включению)
От включения к включению в приборе появлялось разное смещение показаний тока (порядка 10-30 мА). Решение помогли найти коллеги из Компэла в лице Владислава Барсова и Александра Квашина за что им огромное спасибо.
#### Пример кода. Инициализация АЦП.
```
// Нужно запомнить параметры калибровки и выставлять их при включении
HAL_ADCEx_Calibration_SetValue (&hadc1, ADC_SINGLE_ENDED, myCalibrationFactor[0]);
HAL_ADCEx_Calibration_SetValue (&hadc1, ADC_DIFFERENTIAL_ENDED, myCalibrationFactor[1]);
HAL_ADCEx_LinearCalibration_SetValue (&hadc1, &myLinearCalib_Buffer[0]);
```
### Засветка индикации
На «пустых» 7-и сегментных индикаторах вместо полного отключения появлялась слабая засветка. Причина в том, что в реальном мире форма сигнала не идеальна, и если вы выполнили код gpio\_set\_level(0), то это еще не значит, что уровень сигнала сразу же изменился. Устранить засветку удалось добавлением ШИМа к линиям данных.
### Ошибка uart в HAL
После возникновения ошибки Over-Run UART переставал работать. Устранить проблему удалось патчем HAL’a:
### Пример кода. Патч для HAL’a.
```
--- if (((isrflags & USART_ISR_ORE) != 0U)
--- && (((cr1its & USART_CR1_RXNEIE_RXFNEIE) != 0U) ||
--- ((cr3its & (USART_CR3_RXFTIE | USART_CR3_EIE)) != 0U)))
+++ if ((isrflags & USART_ISR_ORE) != 0U)
{
__HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);
```
### Доступ к невыровненным данным
Ошибка проявлялась только на железе в сборке с уровнем оптимизации -Os. Вместо реальных данных клиент по модбас читал нули.
#### Пример кода. Ошибка чтения невыровненных данных.
```
float f_value;
uint16_t registerValue;
// Вместо реальных данных в registerValue оказывался 0
//registerValue = ((uint16_t*)&f_value)[(offsetInMaximeterData -
// offsetof(mbreg_Maximeter, primaryValue)) / 2];
// То же самое через memcpy работат корректно
memcpy(& registerValue, ((uint16_t*)&f_value) + (offsetInMaximeterData -
offsetof(mbreg_Maximeter, primaryValue)) / 2, sizeof(uint16_t));
```
### Поиск причин HardFault’ов
Один из инструментов локализации исключений которые я использую — это «точки наблюдения». Разбрасываю по коду точки наблюдения, а после появления исключения подключаюсь отладчиком и смотрю какую точку прошел код.
#### Пример кода. SET\_DEBUG\_POINT(\_\_LINE\_\_).
```
//debug.h
#define USE_DEBUG_POINTS
#ifdef USE_DEBUG_POINTS
//инструмент для поиска места хардфолтов SET_DEBUG_POINT1(__LINE__)
void SET_DEBUG_POINT1(uint32_t val);
void SET_DEBUG_POINT2(uint32_t val);
#else
#define SET_DEBUG_POINT1(...)
#define SET_DEBUG_POINT2(...)
#endif
//debug.c
#ifdef USE_DEBUG_POINTS
volatile uint32_t dbg_point1 = 0;
volatile uint32_t dbg_point2 = 0;
void SET_DEBUG_POINT1(uint32_t val) {
dbg_point1 = val;
}
void SET_DEBUG_POINT2(uint32_t val) {
dbg_point2 = val;
}
#endif
// В нескольких местах в коде:
SET_DEBUG_POINT1(__line__);
```
Советы новичкам
---------------
1) Заглянуть в примеры кода. Для esp32 примеры ставятся вместе с SDK. Для stm32 в хранилище HAL’a STM32CubeMX \STM32Cube\_FW\_H7\_V1.7.0\Projects\NUCLEO-H743ZI\Examples\
2) Гуглить: programming manual <ваш чип>, technical reference manual <ваш чип>, application note <ваш чип>, datasheet <ваш чип>.
3) Если возникли какие-то технические сложности и 2 верхних пункта не помогли, то не следует пренебрегать и обращением в поддержку, а лучше к дистрибьютерам, которые имеют прямой контакт с инженерами компании производителя.
4) Баги бывают не только в вашем коде, но и в HAL’e производителя.
Спасибо за внимание. | https://habr.com/ru/post/521572/ | null | ru | null |
# Сравнение анимации GIF, WebP, APNG, BPG
Чтобы создать эффект движения нужно повторить слегка измененную картинку с достаточно высокой скоростью. Например в кино эта скорость составляет 24 кадра в секунду. Чем она выше, тем движение выглядит плавнее.
[](http://habrahabr.ru/company/io/blog/261083/)
#### Как создается анимация
Соседние кадры не должны сильно отличаться. Когда мы снимаем на видеокамеру, то это получается само собой, а вот если рисовать в редакторе, то можно об этом забыть, и Мальвина будет ходить, как Буратино.
Этот принцип используется в анимированных графических файлах. Они содержат не одно изображение, а серию картинок-кадров. Каждый кадр знает, сколько миллисекунд он должен отображаться.
И тут есть одна проблема. Размер одной секунды анимации с 24 кадрами будет весить в 24 раза больше статической картинки. Чтобы исправить ситуацию, применяют сжатие изображения.
##### Пример абстрактного алгоритма сжатия
Итак, есть файл. В нем только два цвета – черный и синий. Тогда цвет можно закодировать одним битом. Размер по горизонтали — 20, по вертикали — 1. Всего он занимает 20х1х1 = 20 бит.
В строке первые семь точек имеют первый цвет, затем шесть точек — второй, и оставшиеся в строке точки опять окрашены в первый цвет. Записать можно так: повторить цвет 1 — 7 раз, цвет 2 – 6 раз, цвет 1 – 7 раз (1х7 2х6 1х7).
Выгода кажется не очевидной, но если растянуть файл-строку в 1000 раз до 20 килобит, то запись увеличится совсем незначительно: 1х7000 2х6000 1х7000. С увеличением размера исходного файла выгода от сжатия будет только расти.
Сжатие применяется для каждого кадра анимации. Если в секунде 24 кадра, то оно сработает 24 раза. Без этого файлы анимации были бы очень большими.
#### Форматы с возможностью анимации
##### GIF формат
Это очень старый формат. Его показывают все браузеры. У него есть прозрачный слой, т.е. под картинкой будет виден фон, на котором она лежит. Для анимации сохраняет серию полноценных картинок. Это минус. Файл с 24 кадрами будет в 24 раза больше исходного статичного. Частично можно исправить тем, что некоторые кадры могут содержать прозрачный слой плюс изменения предыдущего кадра.
GIF показывает только 256 цветов. Это можно исправить при помощи анимации. Мы создаем две картинки с разным набором цветов. Демонстрируем их с задержкой 0. В итоге получаем 256 + 256 = 512 цветов.
Формат хорошо сжимает изображение без потерь. Для маленьких картинок это важно.
##### APNG формат
Этот формат (Animated PNG) является расширением распространенного формата PNG. Однако разработчики последнего не включили это расширение в спецификацию. Получилось, что немногие программы могут его правильно отображать. Большинство браузеров покажет первый кадр статичной картинкой, а про анимацию забудет.
Маловероятно, что формат будет широко использоваться. Тем более, что появились новые мощные конкуренты.
##### WEBP формат
Этот формат появился в 2010 году. Разработчик, компания Google, позиционирует его как замену [GIF](https://onthe.io/learn+%D0%9A%D0%B0%D0%BA+%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D1%8C+%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82+GIF) и других форматов. [WEBP](https://onthe.io/learn+%D0%A7%D1%82%D0%BE+%D1%82%D0%B0%D0%BA%D0%BE%D0%B5+WebP) имеет все возможности GIF, но только в улучшенном варианте:
* Эффективней с прозрачными слоями.
* При анимации последующий кадр хранит только изменения предыдущего. А раз так, то размер анимированного файла уменьшается.
* Изображение сжимается эффективнее.
Формат поддерживается еще не везде. Например, Android умеет работать с ним, начиная с версии 4.0. браузеры Chrome – с версии 9, Opera – с версии 11.10. Другие браузеры пока формат не поддерживают (июнь 2015). Следить за его развитием можно [здесь](http://caniuse.com/#feat=webp) (список браузеров с поддержкой WEBP) и [здесь](https://developers.google.com/speed/webp/) (домашняя страница проекта).
##### BPG формат
[BPG](https://onthe.io/learn+%D0%A7%D1%82%D0%BE+%D1%82%D0%B0%D0%BA%D0%BE%D0%B5+%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82+BPG) — самый новый. Он был предложен в конце 2014 года. Формат позиционируется как замена JPEG со значительными улучшениями. Сжатие изображения будет эффективнее, чем у предка. Появится поддержка анимации (JPEG не умеет этого делать). Но формат только начинает свое развитие, рекомендовать его для использования еще нельзя, а вот следить за ним [можно](http://bellard.org/bpg).
#### Работа с GIF, APNG и WEBP в CLI
Есть два замечательных пакета [ImageMagick](http://www.imagemagick.org/script/index.php) и [GraphicsMagic](http://www.graphicsmagick.org/). С помощью [ImageМagic](https://onthe.io/learn+10+%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%B2%D1%8B%D1%85+%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%B9+ImageMagick) создается анимация из \*.gif картинок:
```
сonvert -delay 150 -loop 10 *.gif animated.gif
```
Команда convert подхватывает все файлы \*.gif в директории, сортирует их по алфавиту и последовательно вставляет в новый файл animated.gif.
Проверка (запустится маленький графический контейнер с мультиком):
```
animate animated.gif
```
Конвертация мультика в APNG формат:
```
convert animated.gif animated.apng
```
Если использовать [GraphicsMagic](https://onthe.io/learn+8+%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%B2%D1%8B%D1%85+%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%B9+GraphicsMagick), то команды такие:
```
gm convert -delay 150 -loop 100 *.gif animated.webp
gm animate animated.webp
```
На этот раз выходной формат WEBP. Аналогично обрабатывается и BPG.
Также возможно вытащить анимацию в GIF из видеофайлов. Например, с использованием пакета libav-tools импортируется видео из MP4:
```
avconv -i inputfile.mp4 -pix_fmt rgb24 output.gif
```
Посмотреть разницу между анимацией GIF, WebP и APNG в разных форматах можно [тут](https://i.onthe.io/compare_formats). А вот [пример](https://i.onthe.io/compare_formats?r=abc1f16165e61d231b2ccd730fe5f01a).
#### Конспект
1. Четыре формата поддерживают анимацию: GIF, APNG, WEBP и BPG.
2. Генерировать гифки можно с помощью ImageMagick и GraphicsMagick.
3. Пока лучше хранить анимацию в GIF и следить за развитием остальных форматов. | https://habr.com/ru/post/261083/ | null | ru | null |
# Что делать, если под рукой нет Android-устройства? Обзор Android-эмуляторов
#### Введение
Часто бывает необходимость проверить работу свеженаписанного приложения на устройстве. Но вполне может оказаться, что устройства под рукой нет. Или нет устройства с определенными параметрами (правда, это больше относится к размеру/разрешению экрана). Что же делать в этом случае?
К счастью, альтернативы есть. Android-сообщество и разные компании предлагают на выбор несколько вариантов замены android-устройств для разных целей.
Я кратко расскажу о следующих:
* Эмулятор в составе SDK
* Genymotion
* Android x86
* Bluestacks
Если интересно — добро пожаловать под кат (осторожно, достаточно много картинок)
#### Эмулятор в составе SDK
**Сайт:** <http://developer.android.com/sdk/index.html>
Самый очевидный способ подмены устройства. Если занимаешься разработкой под Android — эмулятор точно есть.
##### Использование
Для использвания достаточно открыть AVD Manager из эклипса или в консоли
```
/path/to/sdk/tools/android avd
```
создать свой AVD (Android Virtual Device) и запустить. Более подробно процесс описывать не буду, все достаточно просто.
Однако не обошлось без особенностей. ARM-эмуляторы до ужаса медленные. Что-то нормально проверить практически невозможно, особенно на не очень сильном железе (потому что эмуляция процессора с другой архитектурой). Тут на помощь может прийти технология [Intel HAXM](http://software.intel.com/en-us/android/articles/intel-hardware-accelerated-execution-manager), однако это чревато тем, что платформо-зависимый код (который должен работать под ARM) может не работать, поскольку используется x86.
**Скриншоты**AVD manager
Параметры запуска
Сам эмулятор
###### Плюсы
* Кроссплатформенное решение
* Входит в состав SDK, не нужны сторонние тулы
* Конфигурируемый (размер памяти, подключение камеры и т.д)
* [Доступ по telnet](http://developer.android.com/tools/devices/emulator.html#console) для настройки параметров сети, батареи и т.д.
* Плагин для Eclipse, легкий доступ через adb
* Обновляется сразу после выхода новой версии Android
###### Минусы
* Медленный, если не использовать HAXM
* Не ARM, если использовать HAXM
* Нет эмуляции Bluetooth, OTG, наушников и [некоторых других железных параметров](http://developer.android.com/tools/devices/emulator.html#limitations)
#### Genymotion
**Сайт:** <http://www.genymotion.com/>
Проприетарная реализация, выросшая из проекта AndroVM.
По сути, виртуальная машина на VirtualBox с дополнительными фишками вроде своих контролов, расширенной настройки и т.д.
Достаточно удобен, быстр, много возможность, коммандлайн тулы, Java API для тестов.
При создании устройства из сети выкачивается его образ.
APK можно устанавливать, перетянув их на окно с виртуалкой.
**Скриншоты**Окно работающего девайса
Создание виртуального девайса
Главное окно приложения
###### Плюсы
* Кроссплатформенное решение
* Быстрый
* Много дополнительных тулов (контроль заряда, акселерометра, API для тестов и т.д.)
* Плагин для Eclipse, легкий доступ через adb
###### Минусы
* Платный для компаний, и это главный минус
* Не ARM
* Достаточно долгий выход актуальных версий Android
#### Android x86
**Сайт:** <http://www.android-x86.org/>
Проект по портированию Android на платформу x86. Распространяется в виде образа iso, можно запустить/установить в виртуальной машине, при большом желании можно даже поставить на живую машину с x86 процессором (на ноутбук, например).
Работает быстро, но есть куча проблем из-за того, что это виртуальная машина. Например, привязывние мыши внутри окна виртуалки, доступ к adb только по сети и т.д.
Для использования в VirtualBox нужно отключать Mouse Integration, иначе в виртуальной машине не видно курсора.
Для подключения adb нужно выполнить
```
adb connect ip.add.res.s
```
IP-адрес можно узнать, нажав в машине Alt+F1 и введя netcfg. Вернуться в графический режим — Alt+F7.
**Скриншоты**Главное окно:
Консоль с IP-адресом:
###### Плюсы
* Кроссплатформенное решение (везде, где есть VirtualBox)
* Быстрый
###### Минусы
* Неудобный доступ к adb
* Минусы, связанные с использованием VM — привязка мыши, например
* Не ARM
* Очень долгий выход актуальных версий
#### Bluestacks
**Сайт:** [www.bluestacks.com](http://www.bluestacks.com)
Позиционируется как плеер приложений для Windows, Mac и TV. Умеет запускать приложения, имеет доступ к маркету. Неудобен для разработки и тестирования — apk ставятся тулом из комплекта, но доступ к adb можно получить. Однако для запуска приложений может быть полезен.
Для подключения через adb:
```
adb connect 127.0.0.1
```
**Скриншоты**Запуск:
Главное окно:
###### Плюсы
* Кроссплатформенное решение (правда, только Mac и Windows)
* Быстрый
###### Минусы
* Неудобно ставить приложения
* Непонятно, что с версиями android (2.3 под OS X, под Windows ставился 4.0)
* Нет под linux
#### Вывод
Получается, что для некоторых ситуаций можно обойтись и без девайса. Однако не стоит забывать, что во многих случаях железо эмуляторов отличается от реального, да и прошивки реальных устройств тоже могут подбросить сюрпризов. Поэтому эмуляторы — всего лишь для начальной проверки. | https://habr.com/ru/post/218739/ | null | ru | null |
# Оптимизация TensorFlow на современных архитектурах Intel
TensorFlow — современная платформа глубокого обучения и машинного обучения, дающая возможность извлекать максимальную производительность из оборудования Intel. Эта статья познакомит сообщество разработчиков искусственного интеллекта (ИИ) с методиками оптимизации TensorFlow для платформ на базе процессоров Intel Xeon и Intel Xeon Phi. Эти методики были созданы в результате тесного сотрудничества между специалистами корпораций Intel и Google. Представители обеих корпораций объявили об этом сотрудничестве на первой конференции Intel AI Day в прошлом году.
Мы описываем различные проблемы производительности, с которыми мы столкнулись в процессе оптимизации, и принятые нами решения. Также указан уровень повышения производительности для образца распространенных моделей нейросетей. Принятые методики оптимизации дают возможность повысить производительность на несколько порядков. Например, наши измерения зафиксировали повышение производительности в 70 раз для обучения и в 85 раз для влияния на процессорах Intel Xeon Phi 7250 (KNL). Платформы на базе процессоров Intel Xeon E5 v4 (BDW) и Intel Xeon Phi 7250 стали основной нового поколения решений корпорации Intel. В частности, следует ожидать повышения производительности процессоров Intel Xeon (Skylake) и Xeon Phi (Knights Mill), которые будут выпущены позднее в этом году.
При оптимизации производительности моделей глубинного обучения на современных ЦП возникает ряд проблем, достаточно близких к проблемам оптимизации других ресурсоемких приложений в области высокопроизводительных вычислений.
1. При переработке кода необходимо задействовать современные векторные инструкции. Это означает, что все основные примитивы, такие как свертка, умножение матриц и пакетная нормализация, перерабатываются в векторный код с использованием последней версии (AVX2 — для процессоров Intel Xeon и AVX512 — для процессоров Intel Xeon Phi).
2. Для достижения наивысшей производительности важно обратить особое внимание на эффективность использования всех доступных ядер. Для этого следует рассматривать как распараллеливание в пределах заданного уровня, так и работу и распараллеливание между разными уровнями.
3. Данные должны быть доступны всегда (если это возможно), когда они нужны исполняемым блокам. Это означает, что придется сбалансировать применение технологий упреждающей выборки, блокирования кэша и форматов данных, обеспечивающих локальность данных как в пространстве, так и во времени.
В корпорации Intel для решения этих задач разработали ряд оптимизированных примитивов глубинного обучения, которые можно использовать в разных платформах глубинного обучения для эффективной реализации общих готовых компонентов. Эти готовые компоненты, помимо умножения матриц и свертки, поддерживают следующие возможности.
* Прямая пакетная свертка
* Внутреннее произведение
* Опрос: максимум, минимум, среднее значение
* Нормализация: нормализация локального отклика по каналам (LRN), пакетная нормализация
* Активация: блок линейной ректификации (ReLU)
* Манипуляция данными: многомерная транспозиция (преобразование), разделение, сцепление, суммирование, пересчет
Дополнительные сведения об оптимизированных примитивах библиотеки Intel Math Kernel Library для глубоких нейросетей (Intel MKL-DNN) см. в [этой](https://software.intel.com/en-us/articles/introducing-dnn-primitives-in-intelr-mkl) статье.
В TensorFlow реализованы оптимизированные версии операций, использующие примитивы Intel MKL-DNN во всех возможных случаях. Это необходимо, чтобы воспользоваться масштабированием производительности на платформах с архитектурой Intel. Кроме того, реализованы и другие методики оптимизации. В частности, по соображениям производительности в Intel MKL используется формат, отличный от формата по умолчанию в TensorFlow. При этом потребовалось свести к минимуму издержки при преобразовании из одного формата в другой. Также нужно было позаботиться о том, чтобы пользователям TensorFlow не пришлось переделывать существующие модели нейросетей, чтобы воспользоваться оптимизированными алгоритмами.
Оптимизация графов
------------------
Мы реализовали ряд методов оптимизации графов.
1. Замена операций TensorFlow по умолчанию на оптимизированные версии Intel при работе на ЦП. Благодаря этому пользователи могут запускать существующие программы на Python с повышенной производительностью, не изменяя модели нейросетей.
2. Устранение ненужного и ресурсоемкого преобразования формата данных.
3. Объединение нескольких операций воедино для более эффективного использования кэша ЦП.
4. Обработка промежуточных состояний для ускоренного обратного распространения.
Эти меры оптимизации позволяют добиться более высокой производительности без увеличения нагрузки на программистов TensorFlow. Для оптимизации производительности первостепенное значение имеет оптимизация формата данных. Собственный формат TensorFlow зачастую не является наиболее эффективным для обработки определенных операций на ЦП. В таких случаях мы вставляем преобразование данных из формата TensorFlow во внутренний формат, выполняем операцию на ЦП, затем преобразуем данные обратно в формат TensorFlow. Такие преобразования приводят к издержкам производительности, их следует избегать. При оптимизации формата данных определяются подграфы, которые можно целиком выполнить с помощью операций, оптимизированных для Intel MKL, а преобразование формата в пределах подграфов исключено. Автоматически вставляемые узлы преобразования занимаются преобразованием формата данных на границах подграфов. Еще один полезный способ оптимизации — проход слияния, автоматически объединяющий операции, которые можно эффективно выполнить в рамках одной операции Intel MKL.
Прочие алгоритмы оптимизации
----------------------------
Мы также настроили ряд компонентов платформы TensorFlow, чтобы добиться наивысшей производительности ЦП для разных моделей глубинного обучения. На основе существующего распределителя пула в TensorFlow мы создали наш собственный распределитель. Он действует таким образом, что TensorFlow и Intel MKL вместе используют одни и те же пулы памяти (с помощью функциональности imalloc в Intel MKL), а память не возвращается операционной системе слишком рано. Это позволяет избежать снижения производительности при «промахе» мимо страниц памяти и при очистке страниц памяти. Кроме того, мы тщательно настроили библиотеки управления многопоточной работой (pthreads в TensorFlow и OpenMP в Intel MKL) таким образом, чтобы они могли работать вместе и не боролись друг с другом за ресурсы ЦП.
Эксперименты и оценка производительности
----------------------------------------
Примененные меры оптимизации позволили резко повысить производительность на платформах с процессорами Intel Xeon и Intel Xeon Phi. Для демонстрации прироста производительности мы описываем наши наиболее известные методы, а также показатели производительности при базовых и при оптимизированных настройках для трех распространенных [тестов ConvNet](https://github.com/soumith/convnet-benchmarks).
Следующие параметры важны для производительности процессоров Intel Xeon (Broadwell) и Intel Xeon Phi (Knights Landing). Мы рекомендуем настраивать их в соответствии с вашей конкретной моделью нейросети и используемой платформой. Мы тщательно настроили эти параметры, чтобы добиться наилучших результатов для тестов convnet на процессорах Intel Xeon и Intel Xeon Phi.
1. Формат данных: для достижения наивысшей производительности мы рекомендуем пользователям явным образом указывать формат NCHW для своих моделей нейросетей. Использующийся в TensorFlow по умолчанию формат NHWC не является наиболее эффективным с точки зрения обработки данных в ЦП, при его использовании образуются дополнительные издержки на преобразование.
2. Параметры inter-op/intra-op: мы также рекомендуем поэкспериментировать с этими параметрами TensorFlow, чтобы добиться оптимальной настройки для каждой модели и каждой платформы ЦП. Эти параметры влияют на распараллеливание в пределах одного уровня и между уровнями.
3. Размер пакета: это еще один важный параметр, влияющий как на доступное распараллеливание для задействования всех ядер, так и на размер рабочего набора и на общую производительность памяти.
4. *OMP\_NUM\_THREADS*: для наивысшей производительности требуется эффективно задействовать все доступные ядра. Этот параметр особенно важен для процессоров Intel Xeon Phi, поскольку с его помощью можно управлять уровнем гиперпоточности (от 1 до 4).
5. Транспозиция при умножении матриц: для матриц определенного размера транспозиция второй входной матрицы b обеспечивает более высокую производительность (более эффективное использование кэша) на уровне умножения матриц. Это справедливо для всех операций умножения матриц, использованных в показанных ниже трех моделях. Пользователям следует поэкспериментировать с этим параметром для других размеров матриц.
6. *KMP\_BLOCKTIME*: здесь можно попробовать разные настройки времени ожидания (в миллисекундах) каждого потока после завершения выполнения в параллельной области.
**Пример настроек для процессора Intel Xeon
(семейство Broadwell, 2 физических процессора, 22 ядра)**
**Пример настроек для процессора Intel Xeon Phi
(семейство Knights Landing, 68 ядер)**
**Результаты производительности на процессоре Intel Xeon
(семейство Broadwell, 2 физических процессора, 22 ядра)**
**Результаты производительности на процессоре Intel Xeon Phi
(семейство Knights Landing, 68 ядер)**
**Результаты производительности для различных размеров пакетов на процессорах Intel Xeon (Broadwell) и Intel Xeon Phi (Knights Landing) — обучение**
Установка TensorFlow с оптимизациями ЦП
---------------------------------------
Можно либо установить уже готовые двоичные пакеты с помощью pip или conda согласно инструкциям в статье Доступен оптимизированный для Intel пакет wheel TensorFlow, либо самостоятельно собрать пакеты из исходного кода по приведенным ниже инструкциям.
1. Запустите ./configure в папке исходного кода TensorFlow. При этом последняя версия пакета Intel MKL для машинного обучения будет автоматически загружена в tensorflow/third\_party/mkl/mklml, если выбрать использование Intel MKL.
2. Выполните следующие команды, чтобы создать пакет pip, с помощью которого можно установить оптимизированную сборку TensorFlow.
* PATH можно изменить так, чтобы указывать на определенную версию компилятора GCC.
`export PATH=/PATH/gcc/bin:$PATH`
* LD\_LIBRARY\_PATH также можно изменить, чтобы указывать на новую GLIBC.
`export LD_LIBRARY_PATH=/PATH/gcc/lib64:$LD_LIBRARY_PATH`
* Сборка для наивысшей производительности на процессорах Intel Xeon и Intel Xeon Phi.
`bazel build --config=mkl --copt=”-DEIGEN_USE_VML” -c opt //tensorflow/tools/pip_package:
build_pip_package`
3. Установите оптимизированный пакет wheel TensorFlow.
`bazel-bin/tensorflow/tools/pip_package/build_pip_package ~/path_to_save_wheel
pip install --upgrade --user ~/path_to_save_wheel /wheel_name.whl`
Конфигурация системы
--------------------
| BDW4 | KNL11 |
| --- | --- |
| Архитектура | x86\_64 | Архитектура | x86\_64 |
| Операционные режимы ЦП | 32-разрядный, 64-разрядный | Операционные режимы ЦП | 32-разрядный, 64-разрядный |
| Порядок байтов | Прямой | Порядок байтов | Прямой |
| Кол-во ЦП | 44 | Кол-во ЦП | 272 |
| Включенные ЦП | 0–43 | Включенные ЦП | 0–271 |
| Потоков на ядро | 1 | Потоков на ядро | 4 |
| Ядер на физический процессор | 22 | Ядер на физический процессор | 68 |
| Физических процессоров | 2 | Физических процессоров | 1 |
| Узлов NUMA | 2 | Узлов NUMA | 2 |
| ИД поставщика | Genuinelntel | ИД поставщика | Genuinelntel |
| Семейство ЦП | 6 | Семейство ЦП | 6 |
| Модель | 79 | Модель | 37 |
| Название модели | lntel® Xeon® E5-2699v4 2,20 ГГц | Название модели | lntel® Xeon Phi(TM) 7250 1,40 ГГц |
| Выпуск | 1 | Выпуск | 1 |
| Частота ЦП, МГц | 2426,273 | Частота ЦП, МГц | 1400 |
| BogoMIPS | 4397,87 | BogoMIPS | 2793,45 |
| Визуализация | VT-x | Кэш данных 1-го уровня | 32 КБ |
| Кэш данных 1-го уровня | 32 КБ | Кэш инструкций 1-го уровня | 32 КБ |
| Кэш инструкций 1-го уровня | 32 КБ | Кэш 2-го уровня | 1024 КБ |
| Кэш 2-го уровня | 256 КБ | ЦП узла NUMA 0 | 0–271 |
| Кэш 3-го уровня | 56 320 КБ | | |
| ЦП узла NUMA 0 | 0–21 | | |
| ЦП узла NUMA 1 | 22–43 | | |
Что это означает для ИИ
-----------------------
Оптимизация TensorFlow означает, что решения глубинного обучения, построенные на основе этой широко доступной и широко распространенной платформы, теперь гораздо быстрее работают на процессорах Intel; повышаются гибкость, доступность и масштаб таких решений. Производительность процессоров Intel Xeon Phi, к примеру, масштабируется почти линейно при добавлении ядер и узлов, что позволяет резко снизить время обучения для моделей машинного обучения. Наращивание производительности TensorFlow одновременно с повышением производительности процессоров Intel даст возможность обрабатывать более крупные и сложные нагрузки ИИ.
Сотрудничество между корпорациями Intel и Google для оптимизации TensorFlow организовано в ходе непрерывной деятельности, направленной на повышение доступности ИИ для разработчиков и исследователей данных, для реализации возможности запуска приложений ИИ там, где они нужны, на любых устройствах и в любой среде, от пользовательских устройств до облаков. Специалисты Intel считают, что более высокая доступность ИИ является важнейшим фактором для создания моделей и алгоритмов ИИ нового поколения, способных решить наиболее актуальные проблемы бизнеса, науки, техники, медицины и общества.
В ходе сотрудничества уже удалось резко повысить производительность на платформах с процессорами Intel Xeon и Intel Xeon Phi. Код с улучшенными алгоритмами доступен в [репозитории TensorFlow корпорации Google в GitHub](https://github.com/tensorflow/tensorflow.git). Мы просим разработчиков из сообщества ИИ попробовать эти меры оптимизации и поделиться своими отзывами. | https://habr.com/ru/post/338870/ | null | ru | null |
# Четыре паттерна вызова функций в JavaScript
Язык JavaScript был представлен как язык функционального программирования. Причина заключается в том, что функции в JS не просто разделяют логику на операционные блоки, функции являются [объектами первого класса](http://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82_%D0%BF%D0%B5%D1%80%D0%B2%D0%BE%D0%B3%D0%BE_%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B0), способными создавать другие объекты. Подобная зависимость от функций одновременно является как сильной стороной, так и настоящим проклятием этого языка. Сильная сторона заключается в том, что язык, обладая подобными особенностями, становится легковесным и быстрым (каким JavaScript изначально и видели его создатели). Однако если вы не знаете что делаете — однозначно ждите беды.
Я предлагаю посмотреть на паттерны вызова функций, а точнее на то, как значительно изменяется результат в зависимости от выбранного паттерна. Также мы рассмотрим как ведет себя `this`, в зависимости от способа вызова функции.
Итак, существует четыре пути вызова функций:
* Вызов метода — Method Invocation
* Вызов функции — Function Invocation
* Вызов конструктора — Constructor Invocation
* Вызов apply и call — Apply And Call Invocation
#### Выполнение функции
JavaScript, как и все современные языки, может модулировать логику внутри функций, и эти функции могут быть вызваны в любой момент, посреди уже запущенного процесса. Вызвав функцию, мы передаем ей необходимые параметры и управление процессами, останавливая текущую операцию. Оператор вызова — **круглые скобки ()**, которые могу заключать в себе параметры, разделенные через запятую.
К сожалению, существует несколько паттернов для вызова функций. О них не нужно быть в курсе. Их нужно зазубрить и понять, потому как, в зависимости от выбранного паттерна, вы получите разные результаты. На мой взгляд, данная особенность является ошибкой в проектировании самого языка, и если бы JavaScript создавался в меньшей спешке и с б*о*льшим вниманием, различных проблем подобного характера удалось бы избежать.
#### Четыре паттерна
Как уже говорилось, оператор для вызова функции один, а способов вызова — четыре.
##### Вызов метода — Method Invocation
Когда функция является частью объекта, она называется методом. «Вызов метода» представляет из себя вызов функции, принадлежащей объекту. Пример:
> var obj = {
>
> value: 0,
>
> increment: function() {
>
> this.value+=1;
>
> }
>
> };
>
>
>
> obj.increment();
В «вызове метода» значение `this` будет ссылаться на объект, которому принадлежит функция, в нашем случае на obj, причем данная связь будет установлена после запуска функции, что носит термин позднего привязывания (*late binding*).
##### Вызов функции — Function Invocation
Вызов функции выполняется с помощью оператора ():
> add(2,3); //5
Используя данный паттерн, `this` привязывается к global object. Это, несомненно, является ошибкой языка — постоянная привязка this к глобальному объекту может уничтожить его контекст. Это особенно заметно, если использовать функцию внутри метода. Давайте посмотрим на пример:
> var value = 500; //Global variable
>
> var obj = {
>
> value: 0,
>
> increment: function() {
>
> this.value++;
>
>
>
> var innerFunction = function() {
>
> alert(this.value);
>
> }
>
>
>
> innerFunction(); //Function invocation pattern
>
> }
>
> }
>
> obj.increment(); //Method invocation pattern
>
>
Как думаете, что будет выведено на экран? Если вы решили, что 1 — вы ошибаетесь (однако не стоит винить себя — вините кривоватый дизайн JavaScript). Правильный ответ — 500. Обратите внимание, `innerFunction` вызывается с использованием вышеупомянутого паттерна «вызова функции», соответственно `this` привязывается к global object. В результате мы и получаем 500.
Можно легко обойти эту проблему путем создания переменной `this`, но это, по моему мнению, является хаком.
> var value = 500; //Global variable
>
> var obj = {
>
> value: 0,
>
> increment: function() {
>
> var that = this;
>
> that.value++;
>
>
>
> var innerFunction = function() {
>
> alert(that.value);
>
> }
>
>
>
> innerFunction(); //Function invocation pattern
>
> }
>
> }
>
> obj.increment();
Таким образом мы привязали `this` к объекту, внутри которого вызывается функция.
##### Вызов конструктора — Constructor Invocation
Предупреждение: это еще одна особенность JavaScript, который сильно отличается от классических языков ООП! Это прототипно-ориентированный язык программирования, однако его создателям показалось, что люди «классической школы» (коих большинство) будут некомфортно себя чувствовать. В результате в прототипный JavaScript добавились принципы классического ООП и получилось что получилось — бардак.
В классическом ООП объект является реализацией класса. В С++ и Java для такой реализации используется оператор `new`. Судя по всему, создатели JS решили не ходить далеко за примером, и реализовать нечто подобное в паттерне «вызов конструктора»…
Паттерн запускается путем размещения оператора `new` прямо перед вызовом, например:
> var Cheese = function(type) {
>
> cheeseType = type;
>
> return cheeseType;
>
> }
>
>
>
> cheddar = new Cheese("cheddar"); //Возвращается объект, а не тип
Несмотря на то, что `Cheese` является функциональным объектом (а значит умеет переваривать код), мы создали новый объект путем вызова функции с `new`. `this` в данном случае будет относиться к свежесозданному объекту, и поведение `return` будет изменено. К слову о return. Его использования в «вызове конструктора» имеет две особенности:
* если функция возвращает число, цепочку, логическое выражение (true/false), null или undefined, `return` не сработает, a мы получим `this`
* если функция возвращает реализацию объекта (то есть все, кроме простых переменных), мы увидим данный объект, а не `this`
> var obj = {
>
> data : "Hello World"
>
> }
>
>
>
> var Func1 = function() {
>
> return obj;
>
> }
>
>
>
> var Func2 = function() {
>
> return "I am a simple type";
>
> }
>
>
>
> var f1 = new Func1(); //f1 назначается объекту
>
> var f2 = new Func2(); //f2 назначается новому объекту
Мы могли бы игнорировать использование `this`, и назначать объектам литералы, если бы не одно но: создатели JavaScript связали с данным паттерном одну из ключевых возможностей языка — создание объектов с произвольной ссылкой на прототип (*подробнее [здесь](http://doctrina.org/JavaScript-Objects-Prototypes.html) — англ.*). Данный паттерн неинтуитивен, более того, с ним часто возникают проблемы. Решение проблемы предлагал Douglas Crockford: можно использовать [augment object](http://www.crockford.com/javascript/inheritance.html) с методом create. Я рад сообщить, что начиная с версии 1.8.5 JavaScript, `Object.create` является вполне работающим инструментом.
##### Вызов apply и call — Apply And Call Invocation
Этот паттерн продуман гораздо лучше остальных. Он позволяет вручную запустить функцию, попутно снабдив ее параметрами и обозначив `this`. Из-за того, что функции у нас являются полноправными объектами, каждая функция в JavaScript связана с [Function.prototype](http://doctrina.org/JavaScript-Objects-Prototypes.html#cfo), а значит мы можем легко добавлять к ним методы.
Данный паттерн использует два параметра: первый — это объект, к которому привязывается `this`, второй — это массив, связанный с параметрами:
> var add = function(num1, num2) {
>
> return num1+num2;
>
> }
>
>
>
> array = [3,4];
>
> add.apply(null,array); //7
В примере выше `this` относится к `null` (функция не является объектом), а массив привязан к `num1` и `num2`. Но продолжим эксперементировать с первым параметром:
> var obj = {
>
> data:'Hello World'
>
> }
>
>
>
> var displayData = function() {
>
> alert(this.data);
>
> }
>
>
>
> displayData(); //undefined
>
> displayData.apply(obj); //Hello World
>
>
Этот пример использует `apply` для привязки `this` к `obj`. В результате мы в состоянии получить значение `this.data`. Настоящая ценность apply заключается именно в привязывании `this`.
В JavaScript также существует оператор `call`, похожий на `apply` всем, за исключением того что получает не параметры, а список аргументов.
#### Заключение
Хорошо это или не очень, JavaScript вот-вот захватит мир. А потому просто необходимо знать о его особенностях, особенно о тех, которых следует избегать. Понимание четырех паттернов вызова функций — обязаетельное условие для изучающих JavaScript. Надеюсь что этот пост вам поможет. | https://habr.com/ru/post/155815/ | null | ru | null |
# прикручиваем плагины от Idea к WebIde
Сегодня успешно закончив написание одного маленького, но очень полезного лично для меня плагина к IDEA, расстроился из-за невозможности прикрутить его к WebIDE, хотя в Idea 7/8/9 полет нормальный.
И вот, взрустнув и занявшись сравнительным анализом «старых» и «новых/кошерных» плагинов, обнаружил способ прикрутить к JetBrains WebIDE почти любой плагин от IDEA, коим и спешу поделиться :)
Я использовал "*почти*" потому что проверялось далеко не на всем, но на всем что попробовал сработало. За сим 100% работоспособности способа не обещаю, да и как вкурученный плагин будет себя вести тоже предсказать сложно, но я пока никаких проблем не обнаружил.
Прикручивать будем на примере [EmbeddedBrowser](http://plugins.intellij.net/plugin/?id=143), т.к. возникала у меня в нем несколько дней назад острая потребность, которую я успешно удовлетворил лишь сегодня.
итак:
1. Качаем
2. Распаковывем в папку с плагином в {webide\_home}/plugins/
3. ~~запускаем WebIde. не подхватился плагин? ай-яй, я так и знал :P~~
4. В {webide\_home}/plugins/EmbeddedBrowser/META-INF открываем файл plugin.xml
который выглядит примерно вот так:
> `DOCTYPE idea-plugin PUBLIC "Plugin/DTD" "http://plugins.intellij.net/plugin.dtd">
>
> <idea-plugin>
>
> <name>EmbeddedBrowsername>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
и добавляем немножко нового:
> `DOCTYPE idea-plugin PUBLIC "Plugin/DTD" "http://plugins.intellij.net/plugin.dtd">
>
> <idea-plugin **version="2">
>
> <depends>com.intellij.modules.xmldepends>**
>
> <name>EmbeddedBrowsername>
>
> ...
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
5. Сохраняем
6. Запускаем
7. Ура! Плагин успешно подхвачен, в меню Tools появился чудесный пункт Embedded Browser
8. срочно сетапаем все то, что было в IDEA и чего так не хватало в WebIDE
Если не трудно, отпишитесь у кого что «взлетело», а у кого что — нет. чтобы при необходимости доставить
что-либо каждый желающий мог поискать результат попытки к комментариях и не совершать лишних движений.
… и да простят меня разработчики WebIDE за то «спалил тему»
З.Ы.: и напоследок об упомянутом маленьком, но полезном плагине:
я существо ленивое и меня ломает каждый раз набирать однотипные куски текста вроде "**function (){}**", "**this.**/**$this->**" и т.д. Если раньше мне, в целом, хватало «макросов» в UltraEdit и IDEA, то в WebIDE макросы все еще не работают, а в IDEA 8 они никак не зависят от того, в контексте какого языка выполняются.
За сим изваял для себя плагин, который по нажатию на хоткей вставляет в редактор соответсвующие «фразы», которые могут отличаться в зависимости от языка (Java — «this.», PHP — "$this->").
в нынешней инкарнации плагин позволяет:
— указать в шаблоне где поставить курсор после вставки
— куда внутри шаблона воткнуть выделенный кусок текста (если было выделение)
— и позволяет перечитать конфигурацию без открытия/закрытия IDE.
конфиги хранятся в XML-файле внутри папки с плагином и правятся «в блокноте». сделано топорно и грубо, но вроде надежно и меня, пока, устраивает. если есть желающие попробовать — дайте знать. хотя это «фишка на любителя», не уверен что многим придется по вкусу. | https://habr.com/ru/post/76622/ | null | ru | null |
# Другие острова. Проект Ломбок для Java
Это статья является этаким вольным переводом-пересказом.
Оказывается, Ява — это не единственный остров, который как-то связан с разработками на Java. Вот вам ещё один, который называется "[Ломбок](http://ru.wikipedia.org/wiki/%D0%9B%D0%BE%D0%BC%D0%B1%D0%BE%D0%BA)". Именем этого острова назван замечательный проект, распространяемый по [лицензии MIT](http://www.opensource.org/licenses/mit-license.php).
### Что такое Project Lombok?
Project Lombok это две вещи в одном: генератор кода на этапе компиляции и генератор кода на этапе разработки. Что и делает находку бриллиантовой.
В сущности, Lombok интегрируется непосредственно в цикл компиляции Eclipse (манипулируя абстрактным деревом синтаксиса кода *в процессе его набора*) и моментально генерирует код на основе аннотаций. Сгенерированный код тут же становится доступен всем другим классам.
Какой код может генерировать Lombok из аннотаций? Самое важное, порождаются основные шаблонные вещи, которые обычно заставляют классы Java выглядеть дико многословно и монструозно, а именно:
* получатели (getters) и устанавливалки (setters) для полей
* Строковое представление класса POJO в toString()
* hashCode() и equals()
В то же время, Lombok обеспечивает автоматическое управление ресурсами. Например, ваши потоки будут всегда закрываться безопасно, без необходимости использовать блоки try/catch/finally.
### Установка Lombok и поддержка Maven
Lombok предоставляется в виде исполняемого файла JAR ([lombok.jar](http://code.google.com/p/projectlombok/downloads/list)). Правда, в настоящее время режим среды разработки работает только в Eclipse. При запуске файла JAR, появится простой мастер и попросит указать, где находятся исполняемые файлы Eclipse (см. Рисунок 1).
[](http://1.bp.blogspot.com/_mjROT5PrFas/StbrzAeYXaI/AAAAAAAAAAM/__Av56wDxF8/s1600-h/LombokFig1.gif)
**Рисунок 1.** Мастер установки Lombok.
Просто укажите на исполняемые файлы Eclipse и нажмите «Install/Update». Вы должны будете делать это каждый раз для всех новых версий Lombok.
Чтобы включить поддержку Maven, просто добавьте репозиторий Lombok и его зависимости в файл pom.xml, следуя инструкциям на [веб-сайте проекта](http://projectlombok.org/mavenrepo/index.html). После чего, Lombok будет работать с жизненным циклом компиляции Maven «прямо из коробки».
### Project Lombok в действии
Для полного понимания, каким образом Lombok истребляет массу строк кода в типичном классе POJO, рассмотрим следующую типичную сущность Person:
```
public class Person {
private Long personId;
private String salutation;
private String firstName;
private String middleName;
private String lastName;
private String phoneNumber;
private String email;
private String addressLine1;
private String addressLine2;
private String city;
private String state;
private String country;
private Calendar birthDate;
}
```
Для того чтобы этот класс стал настоящим правильным POJO, необходимо дописать для него код getters, setters, toString(), equals() и hashCode(). Если бы вы решили использовать в Eclipse функции автоматической генерации кода, то Person POJO со скоростью грибов разрастётся до более чем 240 строк кода, большинство из которых, хоть и необходимый, но фактически просто мусор, затрудняющий чтение и понимание. (см. Листинг 1).
###### Листинг 1. Сгенерированный автоматически Person POJO
```
public class Person {
private Long personId;
private String salutation;
private String firstName;
private String middleName;
private String lastName;
private String phoneNumber;
private String email;
private String addressLine1;
private String addressLine2;
private String city;
private String state;
private String country;
private Calendar birthDate;
public Long getPersonId() {
return personId;
}
public void setPersonId(Long personId) {
this.personId = personId;
}
public String getSalutation() {
return salutation;
}
public void setSalutation(String salutation) {
this.salutation = salutation;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getMiddleName() {
return middleName;
}
public void setMiddleName(String middleName) {
this.middleName = middleName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getPhoneNumber() {
return phoneNumber;
}
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getAddressLine1() {
return addressLine1;
}
public void setAddressLine1(String addressLine1) {
this.addressLine1 = addressLine1;
}
public String getAddressLine2() {
return addressLine2;
}
public void setAddressLine2(String addressLine2) {
this.addressLine2 = addressLine2;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}
public Calendar getBirthDate() {
return birthDate;
}
public void setBirthDate(Calendar birthDate) {
this.birthDate = birthDate;
}
@Override
public String toString() {
return "Person [addressLine1=" + addressLine1 + ", addressLine2="
+ addressLine2 + ", birthDate=" + birthDate + ", city=" + city
+ ", country=" + country + ", email=" + email + ", firstName="
+ firstName + ", lastName=" + lastName + ", middleName="
+ middleName + ", personId=" + personId + ", phoneNumber="
+ phoneNumber + ", salutation=" + salutation + ", state="
+ state + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((addressLine1 == null) ? 0 : addressLine1.hashCode());
result = prime * result
+ ((addressLine2 == null) ? 0 : addressLine2.hashCode());
result = prime * result
+ ((birthDate == null) ? 0 : birthDate.hashCode());
result = prime * result + ((city == null) ? 0 : city.hashCode());
result = prime * result + ((country == null) ? 0 : country.hashCode());
result = prime * result + ((email == null) ? 0 : email.hashCode());
result = prime * result
+ ((firstName == null) ? 0 : firstName.hashCode());
result = prime * result
+ ((lastName == null) ? 0 : lastName.hashCode());
result = prime * result
+ ((middleName == null) ? 0 : middleName.hashCode());
result = prime * result
+ ((personId == null) ? 0 : personId.hashCode());
result = prime * result
+ ((phoneNumber == null) ? 0 : phoneNumber.hashCode());
result = prime * result
+ ((salutation == null) ? 0 : salutation.hashCode());
result = prime * result + ((state == null) ? 0 : state.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (addressLine1 == null) {
if (other.addressLine1 != null)
return false;
} else if (!addressLine1.equals(other.addressLine1))
return false;
if (addressLine2 == null) {
if (other.addressLine2 != null)
return false;
} else if (!addressLine2.equals(other.addressLine2))
return false;
if (birthDate == null) {
if (other.birthDate != null)
return false;
} else if (!birthDate.equals(other.birthDate))
return false;
if (city == null) {
if (other.city != null)
return false;
} else if (!city.equals(other.city))
return false;
if (country == null) {
if (other.country != null)
return false;
} else if (!country.equals(other.country))
return false;
if (email == null) {
if (other.email != null)
return false;
} else if (!email.equals(other.email))
return false;
if (firstName == null) {
if (other.firstName != null)
return false;
} else if (!firstName.equals(other.firstName))
return false;
if (lastName == null) {
if (other.lastName != null)
return false;
} else if (!lastName.equals(other.lastName))
return false;
if (middleName == null) {
if (other.middleName != null)
return false;
} else if (!middleName.equals(other.middleName))
return false;
if (personId == null) {
if (other.personId != null)
return false;
} else if (!personId.equals(other.personId))
return false;
if (phoneNumber == null) {
if (other.phoneNumber != null)
return false;
} else if (!phoneNumber.equals(other.phoneNumber))
return false;
if (salutation == null) {
if (other.salutation != null)
return false;
} else if (!salutation.equals(other.salutation))
return false;
if (state == null) {
if (other.state != null)
return false;
} else if (!state.equals(other.state))
return false;
return true;
}
}
```
А теперь, как выглядит тот же POJO после «Ломбокизации»:
```
@Data
public class Person {
private Long personId;
private String salutation;
private String firstName;
private String middleName;
private String lastName;
private String phoneNumber;
private String email;
private String addressLine1;
private String addressLine2;
private String city;
private String state;
private String country;
private Calendar birthDate;
}
```
И всё! Когда Lombok установлен в вашей Eclipse Runtime, то простая аннотация [Data](https://geektimes.ru/users/data/) рисует волшебным образом весь тот код необходимого стандартного мусора. Что делает определение сущностей JPA/Hibernate невероятно легким и быстрым.
Но и это ещё не всё! Все методы getters и setters появятся в схеме, как если бы код существовал на самом деле (см. Рисунок 2).
[](http://2.bp.blogspot.com/_mjROT5PrFas/StdxifIzLXI/AAAAAAAAAAU/XM_9I8j0u5c/s1600-h/LombokFig2.gif)
**Рисунок 2. Все методы getters и setters видны в схеме**
А также их видно и при дополнении кода (см. Рисунок 3).
[](http://3.bp.blogspot.com/_mjROT5PrFas/StdxlRnIggI/AAAAAAAAAAc/G0Mlo8ezoxA/s1600-h/LombokFig3.gif)
**Рисунок 3. Все методы видны при дополнении кода**
Если необходим более филигранный контроль, то Project Lombok предлагает следующие аннотации [Getter](https://geektimes.ru/users/getter/), @Setter, @ToString и @EqualsAndHashCode. А вышесказанное означает, что аннотация [Data](https://geektimes.ru/users/data/) комбинируя, заключает их все в себе. В нашем процессе разработки, аннотация [Data](https://geektimes.ru/users/data/) используется в 99% случаях.
### Дополнительные особенности Lombok
Помимо основных характеристик, которые вы только что видели, Lombok поставляется с несколькими дополнениями:
* Аннотация @Cleanup обеспечивает автоматическое управление ресурсами. Например, в следующем сниппете, @Cleanup гарантирует, что метод Close () потока будет выполнен до выхода из метода:
```
@Cleanup InputStream in = new FileInputStream(args[0]);
@Cleanup OutputStream out = new FileOutputStream(args[1]);
```
И нет необходимости ждать Java 7, чтобы использовать автоматическое управление ресурсами уже сегодня в Java 6.
* Аннотация @Synchronized это альтернатива ключевому слову *synchronized*, но лучше реализованная:
```
@Synchronized
public static void hello() {
System.out.println("world");
}
```
* Аннотация @SneakyThrows отключает в Java проверяемые исключения:
```
@SneakyThrows
public void run() {
throw new Throwable();
}
```
Решите вы или нет использовать эту функцию (у меня смешанные чувства по поводу нее), но такую возможность иметь полезно.
### Планы на будущее: Добавление новых особенностей Java
На момент написания, актуальной версией Проекта Ломбок была 0.8.5. Краткосрочной перспективой команды Ломбок была стабилизация и безотказность работы в Eclipse. Хотя, имеются некоторые незначительные проблемы ранних версий (например, некоторые неожиданные предупреждения при компиляции), но простая перекомпиляция проекта позволяет быстро от них избавиться. В целом, выгода от использования Ломбок намного перевешивает имеющиеся небольшие сбои Eclipse (и которые довольно редки, по моему опыту). Долгосрочные же планы у Ломбок гораздо более грандиозные. Оба автора проекта Ломбок (Reinier Zwitserloot и Roel Spilker) хотят перехватить процесс компиляции в Eclipse до точки, где они действительно могут добавить новые функции в Java, в частности, реальное завершение. Узнайте больше об этой амбициозной цели в [этом обсуждаении Google Groups](http://groups.google.com/group/project-lombok/browse_thread/thread/36d096d1ccc6da7b).
### Недостатки
Основной недостаток Ломбок очевиден: работа в режиме среды разработки поддерживается только в Eclipse. Если Eclipse не является вашей IDE, то на данный момент проект Ломбок это не ваш вариант. Возможно такая поддержка в будущем может появиться в средах NetBeans и IntelliJ, но она предусматривает несколько довольно тяжелых IDE-хаков для конкретной среды. Зато, все мастерские с Eclipse должны рассмотреть добавление Ломбок в своей ежедневный инструментарий прямо сегодня.
### Прощай многословность POJO
С внедрением Проекта Ломбок, Reiner и Roel сделали многословие Java POJO достоянием истории. Когда вы добавите Ломбок к вашей ежедневной практике разработки, то просто не захотите возвращаться назад. Это очень просто и на наш взгляд, это самое революционное дополнение к экосистеме Java после рождения самого Eclipse.
### Ссылки
* Оригинал статьи находится [здесь](http://www.devx.com/Java/Article/42946/0/page/1).
* Домашняя страница проекта Ломбок: [code.google.com/p/projectlombok/](http://code.google.com/p/projectlombok/)
* Обсуждение Ломбок в [Google Groups](http://groups.google.com/group/project-lombok/browse_thread/thread/36d096d1ccc6da7b) | https://habr.com/ru/post/72555/ | null | ru | null |
# Подборка @pythonetc, январь 2020
Новая подборка советов про Python и программирование из моего авторского канала @pythonetc.
← [Предыдущие публикации](https://habr.com/ru/search/?q=pythonetc#h)
Порядок блоков `except` имеет значение: если исключение может быть поймано несколькими блоками, то его поймает верхний блок. Этот код не будет работать так, как задумано:
```
import logging
def get(storage, key, default):
try:
return storage[key]
except LookupError:
return default
except IndexError:
return get(storage, 0, default)
except TypeError:
logging.exception('unsupported key')
return default
print(get([1], 0, 42)) # 1
print(get([1], 10, 42)) # 42
print(get([1], 'x', 42)) # error msg, 42
```
`except IndexError` не будет работать, потому что `IndexError` является подклассом `LookupError`. Более конкретное исключение всегда должно находиться выше:
```
import logging
def get(storage, key, default):
try:
return storage[key]
except IndexError:
return get(storage, 0, default)
except LookupError:
return default
except TypeError:
logging.exception('unsupported key')
return default
print(get([1], 0, 42)) # 1
print(get([1], 10, 42)) # 1
print(get([1], 'x', 42)) # error msg, 42
```
Python поддерживает параллельное присваивание. Это означает, что все переменные изменяются сразу после вычисления всех выражений. Более того, вы можете использовать любое выражение, поддерживающее присваивание, а не только переменные:
```
def shift_inplace(lst, k):
size = len(lst)
lst[k:], lst[0:k] = lst[0:-k], lst[-k:]
lst = list(range(10))
shift_inplace(lst, -3)
print(lst)
# [3, 4, 5, 6, 7, 8, 9, 0, 1, 2]
shift_inplace(lst, 5)
print(lst)
# [8, 9, 0, 1, 2, 3, 4, 5, 6, 7]
```
Python не будет автоматически использовать сложение с отрицательным числом вместо вычитания. Рассмотрим пример:
```
class Velocity:
SPEED_OF_LIGHT = 299_792_458
def __init__(self, amount):
self.amount = amount
def __add__(self, other):
return type(self)(
(self.amount + other.amount) /
(
1 +
self.amount * other.amount /
self.SPEED_OF_LIGHT ** 2
)
)
def __neg__(self):
return type(self)(-self.amount)
def __str__(self):
amount = int(self.amount)
return f'{amount} m/s'
```
Этот код не работает:
```
v1 = Velocity(20_000_000)
v2 = Velocity(10_000_000)
print(v1 - v2)
# TypeError: unsupported operand type(s) for -: 'Velocity' and 'Velocity
```
Забавно, но этот код работает:
```
v1 = Velocity(20_000_000)
v2 = Velocity(10_000_000)
print(v1 +- v2)
# 10022302 m/s
```
Эта часть написана Telegram-пользователем [orsinium](https://habr.com/ru/users/orsinium/).
Функция не могут быть одновременно генератором и обычной функцией. Если в теле функции используется `yield`, то она превращается в генератор:
```
def zeros(*, count: int, lazy: bool):
if lazy:
for _ in range(count):
yield 0
else:
return [0] * count
zeros(count=10, lazy=True)
#
zeros(count=10, lazy=False)
#
list(zeros(count=10, lazy=False))
# []
```
Однако обычная функция может вернуть другой итератор:
```
def _lazy_zeros(*, count: int):
for _ in range(count):
yield 0
def zeros(*, count: int, lazy: bool):
if lazy:
return _lazy_zeros(count=count)
return [0] * count
zeros(count=10, lazy=True)
#
zeros(count=10, lazy=False)
# [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
```
А такой вариант может быть полезен в случаях с простыми выражениями-генераторами:
```
def zeros(*, count: int, lazy: bool):
if lazy:
return (0 for _ in range(count))
return [0] * count
```
При создании generator comprehension необходимо использовать скобки:
```
>>> g = x**x for x in range(10)
File "", line 1
g = x\*\*x for x in range(10)
^
SyntaxError: invalid syntax
>>> g = (x\*\*x for x in range(10))
>>> g
at 0x7f90ed650258>
```
Однако их можно опустить, если comprehension является единственный аргумент функции:
```
>>> list((x**x for x in range(4)))
[1, 1, 4, 27]
>>> list(x**x for x in range(4))
[1, 1, 4, 27]
```
Это не верно для функций, у которых несколько аргументов:
```
>>> print((x**x for x in range(4)), end='\n')
at 0x7f90ed650468>
>>>
>>>
>>> print(x\*\*x for x in range(4), end='\n')
File "", line 1
SyntaxError: Generator expression must be parenthesized if not sole argument
``` | https://habr.com/ru/post/487728/ | null | ru | null |
# Распределенное обучение нейронных сетей с MXNet. Часть 1
Сегодня мы дадим ответ на простой вопрос: "Как работает распределённое обучение (в контексте [MXNet](http://mxnet.io))?"
Все примеры кода протестированные на MXNet v0.10.0 и могут не работать (или работать по-другому) в других версиях, однако полагаю, что общие концепции будут неизменимы еще долго.
Ну и последнее перед тем, как мы перейдем к основной части, я хочу выразить благодарность за помощь в написании статьи моим коллегам, без которых эта статья не была бы возможной:
* Madan Jampani;
* Suneel Marthi;
Еще хотел бы порекомендовать поднять машинку с [DLAMI](https://habrahabr.ru/post/333380/#chto-takoe-ami) и выполнить все примеры из статьи самостоятельно, тем более, что они достаточно простые. Для выполнения кода вполне себе подойдет бесплатная машинка на AWS.
С преамбулой окончено, лезем под кат...
Распределенное обучение каким MXNet его видит
---------------------------------------------
В MXNet все участники процесса обучения поделены на 3 логические группы:
* планировщик (scheduler);
* сервер (server);
* рабочий (worker);
Это чисто логическое распределение, так что все участники могут работать на одной машине.
Для начала посмотрим на поверхностное объяснение, что каждый из участников собой представляет:
### Планировщик
Планировщик является центральным узлом кластера, отвечает за начальную настройку кластера, обеспечение нужной информацией каждого участника процесса обучения и… ничего более. Мы еще увидим, как он впадает в анабиоз сразу, как только кластер готов начать обучение. И даже когда кластер закончит свое обучение его задачей будет лишь выключить себя.
Думаю, все уже догадались, что в кластере может быть только один планировщик.
### Сервер
Сервер выступает в качестве хранилища параметров модели обучения. То есть, если обучается модель в стиле: Y = AX + B, сервер хранит вектора A и B. Еще он отвечает за их корректное обновление. Серверов может быть более чем один, а соответственно есть правило, по которому модель распределяется на несколько серверов. Но это тема отдельной статьи.
### Рабочий
Это собственно те участиники кластера, которые непосредственно выполняют обучение модели. Каждый рабочий получает свою часть данных, на которых нужно обучится, считает шаг градиента и отправляет его серверам для обновления модели.
### Пример кластера
Давайте возьмем бутафорский пример кластера с:
* планировщиком на отдельной машине;
* двумя серверами;
* тремя машинами с рабочими;
Сам кластер будет выглядеть вот так:
Эта картинка, как и описанная конфигурация, будет использована только для визуализации потока данных.
Инициализация кластера
----------------------
Мы не будем на практике создавать такой большой кластер как было описано выше, а обойдемся намного более маленьким кластером с 3-мя нодами на одной физической машине. Есть несколько тому причин:
* проще и дешевле;
* все логи будут в одном месте, что упростит объяснение;
Перед тем как продолжить, нужно уточнить одну деталь. Для MXNet, распределённое обучение по сути означает, что необходимо использовать KVStore. Имя это — акроним от "Key Value Storage". И по существу — это распределенное хранилище, которое выполняется на серверах и имеет некоторую дополнительную функциональность (например знает, как именно нужно обновлять модель, получив градиентный шаг от рабочего).
> Также, поддержка KVStore доступна только в одном из двух вариантах:
>
> * MXNet был собран вручную, с включенным флагом USE\_DIST\_KVSTORE=1 или
> * был использован [DLAMI](https://habrahabr.ru/post/333380/#chto-takoe-ami) (так как в нем фреймворк собран вручную с включенным флагом USE\_DIST\_KVSTORE=1)
>
>
>
>
>
> В данной статье я предполагаю, что будет использован MXNet из релиза Jun/Jul DLAMI ( MXNet 0.10.0).
>
> Еще есть не нулевая вероятность, что на момент прочтения, официальный pip пакет MXNet будет иметь поддержку KVStore.
Настало время начать создавать логических участников кластера. Чтобы создать участника достаточно лишь создать некоторые переменные среды и после заимпортировать модуль mxnet.
### Планировщик
Первым делом запустим планировщик:
```
ubuntu:~$ python
>>> import subprocess
>>> import os
>>> scheduler_env = os.environ.copy()
>>> scheduler_env.update({
… "DMLC_ROLE": "scheduler",
… "DMLC_PS_ROOT_PORT": "9000",
… "DMLC_PS_ROOT_URI": "127.0.0.1",
… "DMLC_NUM_SERVER": "1",
… "DMLC_NUM_WORKER": "1",
… "PS_VERBOSE": "2"
… })
>>> subprocess.Popen("python -c ‘import mxnet’", shell=True, env=scheduler_env)
```
Давайте остановимся тут на секунду, чтобы получить представление о том, что происходит. Первые 4ре линии кода не должны вызывать много вопросов у Python программистов: просто импорт зависимостей и создание окружения ОС. Что интересно здесь, так это то, какие именно обновления в переменные окружающей среды будут внесены:
Начнем с рассмотрения DMLC\_ROLE. Давайте посмотрим где именно она используется, а именно в пакете [ps-lite](https://github.com/dmlc/ps-lite). В соответствии с официальным [README](https://github.com/dmlc/ps-lite/blob/master/README.md)(в вольном переводе):
> Легкая и эффективная реализация сервера для хранения параметров.
>
> Ну а точное место, где переменная среды считывается вот [тут](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/postoffice.cc#L20) (к слову все ссылки на конкретные коммиты).
```
val = CHECK_NOTNULL(Environment::Get()->find("DMLC_ROLE")); // here
std::string role(val);
is_worker_ = role == "worker";
is_server_ = role == "server";
is_scheduler_ = role == "scheduler"; // and later here
verbose_ = GetEnv("PS_VERBOSE", 0);
```
Думаю, не стоит быть С++ гуру, чтобы понять, что тут происходит. Логичиская роль нода определяется по строке в этой самой переменной "DMLC\_ROLE". Забавно, но похоже тут нет проверки на то, что данная переменная содержит одно из разрешенных значений. Это, потенциально, может привести к интерестным проблемам.
Второе, что нас интересует, это не только где переменная читается, но и где она используется. Что бы рассказать об этом, нужно обратится к файлу van.cc, который будет встречаться нам не раз, вот конкретная линия, где переменная [используется](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L38) и создается переменная "is\_scheduler":
```
scheduler_.hostname = std::string(CHECK_NOTNULL(Environment::Get()->find("DMLC_PS_ROOT_URI")));
scheduler_.port = atoi(CHECK_NOTNULL(Environment::Get()->find("DMLC_PS_ROOT_PORT")));
scheduler_.role = Node::SCHEDULER;
scheduler_.id = kScheduler;
is_scheduler_ = Postoffice::Get()->is_scheduler(); // here
```
Если быстро пробежаться далее по коду, чтобы посмотреть, что там происходит можно увидеть следующее интересное место:
```
// get my node info
if (is_scheduler_) {
my_node_ = scheduler_;
} else {
auto role = is_scheduler_ ?
Node::SCHEDULER :
(Postoffice::Get()->is_worker() ? Node::WORKER : Node::SERVER);
```
В этом конкретном примере переменная "role" никогда не будет равна Node::SCHEDULER. Так что у вас есть шанс создать pull-request, чтобы это поправить (если еще никто этого не сделал).
Так же глядя на это место понимаешь, что для планировщика не так уж и много работы. Это потому что, в отличии от рабочего и сервера — планировщик использует IP адрес и порт, которые ему были переданы, а не ищет свободный порт в системе.
Идем далее, параметр: DMLC\_PS\_ROOT\_PORT. С этим мы быстро разберемся с учетом уже имеющихся знаний. Вот код, который уже видели:
```
scheduler_.hostname = std::string(CHECK_NOTNULL(Environment::Get()->find("DMLC_PS_ROOT_URI")));
scheduler_.port = atoi(CHECK_NOTNULL(Environment::Get()->find("DMLC_PS_ROOT_PORT"))); // here
scheduler_.role = Node::SCHEDULER;
scheduler_.id = kScheduler;
is_scheduler_ = Postoffice::Get()->is_scheduler();
```
Вновь, это из [van.cc](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L35). Как не трудно догадаться, это порт, на котором планировщик должен слушать сообщения.
Надеюсь на этом этапе понятно, что DMLC\_PS\_ROOT\_URI это просто ip адрес планировщика. Так что давайте сразу прыгнем к обсуждению DMLC\_NUM\_SERVER и DMLC\_NUM\_WORKER.
Так сложилось, что каждый логический нод MXNet в кластере должен знать о всех других нодах. Так что для каждого нода, перед тем как он запустился, в переменных среды записывается как много в кластере рабочих и серверов (число планировщиков ненужно, ибо это всегда 1). К слову эта информация хранится в классе [Postoffice](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/include/ps/internal/postoffice.h) (вместе с другой информацией о кластере).
Ну и последний параметр, но пожалуй один из архи-главнейших — PS\_VERBOSE. Это заставит наш новосозданный процесс выводить отладочную информацию, что жизненно важно для нас сейчас.
С точки зрения нашей бутафорской диаграммы наш кластер выглядит сейчас как-то так:
### Запускаем сервер
Теперь, когда у нас есть планировщик, давайте поднимем сервер. Так как мы поднимаем все логические ноды на одной машине, то нам придётся создать копию параметров окружения и вновь внести туда нужные изменения для того, что бы запустить сервер:
```
>>> server_env = os.environ.copy()
>>> server_env.update({
… "DMLC_ROLE": "server",
… "DMLC_PS_ROOT_URI": "127.0.0.1",
… "DMLC_PS_ROOT_PORT": "9000",
… "DMLC_NUM_SERVER": "1",
… "DMLC_NUM_WORKER": "1",
… "PS_VERBOSE": "2"
… })
>>> subprocess.Popen(“python -c ‘import mxnet’”, shell=True, env=server_env)
```
Надеюсь теперь происходящее в коде не вызывает вопросов, но на всякий случай:
* мы говорим, что новый процесс — сервер (DMLC\_ROLE);
* мы говорим какой IP у планировщика (DMLC\_PS\_ROOT\_URI);
* мы говорим на каком порту планировщик слушает входящее соединения (DMLC\_PS\_ROOT\_PORT);
* мы говорим серверу как много рабочих в кластере (DMLC\_NUM\_WORKER)
* мы говорим серверу как много серверов в кластере (DMLC\_NUM\_SERVER)
* ну и устанавливаем вывод в режим отладки (2)
Тут кто-то может спросить: погодите, я думал что DMLC\_PS\_ROOT\_PORT и DMLC\_PS\_ROOT\_URI для указания IP и порта логического нода, который мы запускаем? Ответом будет — нет, это адрес и порт планировщика, а вот все остальные должны сами разобраться какой у них адрес и найти себе доступный порт в системе. Информация о планировщике им нужна, чтобы постучаться к нему и попросить, чтобы он добавил их в кластер.
После запуска серверов наша диаграмма выглядит вот так:
### Запускаем рабочего
Настало время запустить, собственно, самого рабочего и создать KVStore:
```
>>> os.environ.update({
… "DMLC_ROLE": "worker",
… "DMLC_PS_ROOT_URI": "127.0.0.1",
… "DMLC_PS_ROOT_PORT": "9000",
… "DMLC_NUM_SERVER": "1",
… "DMLC_NUM_WORKER": "1",
… "PS_VERBOSE": "2"
… })
>>> worker_env = os.environ.copy()
>>> import mxnet
>>> kv_store = mxnet.kv.create(‘dist_async’)
```
К слову, KVStore может работать в двух режимах:
* dist\_sync
* dist\_async
Я оставлю за пытливым читателем вопрос о том, чем эти режимы отличаются, об этом можно почитать [вот тут](http://mxnet.io/api/python/kvstore.html).
После запуска рабочих, наша диаграмма будет выглядеть вот так:
Жизненный цикл ноды (Van)
-------------------------
Перед тем как бросится обсуждать, что происходит в момент создания KVStore, нужно рассказать о том, что у каждой ноды есть жизненный цикл, у которого есть следующие события:
* [Start](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L32) — запуск
* [Stop](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L119) — остановка
* [Receiving](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L141) — получение сообщения
Так же, тот самый класс ([Van](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc)), что отвечает за обработку этих событий, имеет несколько других, не менее важных методов. О части из них мы поговорим детально позже в других статьях, а сейчас просто перечислим:
* [Send](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L141) — отправляет сообщение
* [PackMeta](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L334) — конвертирует модель в proto сообщение
* [UnpackMeta](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L370) — распаковывает proto сообщение и создает модель
* [HeartBeat](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L408) — посылает сообщение, что он еще жив
Вот что выполняет каждая нода в момент, когда приходит сигнал Start:
* [загружает в память все данные о планировщике](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L34)
* [загружает в память информацию о том, какая роль присвоена ноде (рабочий, планировщик, сервер)](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L38)
* для не-планировщиков — [найти свободный порт и собрать все данные о себе](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L44) который нужно будет отправить планировщику (при необходимости, порт может быть установлен через переменную окружающей среды)
* [привязать себя к найденному порту](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L74)
* [запустить поток, который слушает входящие сообщения](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L86)
* [для не-планировщиков — отправить сообщение планировщику с просьбой добавить себя в кластер (обсудим немного позже)](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L96)
* [Запустить поток, который отвечает за отправку сигнала, что нода жива](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L115)
Инициализация кластера
----------------------
Как только все команды, приведенные выше, будут выполнены, на экране должно показаться много отладочной информации, которая приходит от трех ранее запущенных процессов одновременно. Пройдемся теперь по каждой линии, чтобы детально обсудить, что происходит и как будет выглядеть наша диаграмма на каждом этапе.
> [00:33:12] src/van.cc:75: Bind to role=worker, ip=1.1.1.1, port=37350, is\_recovery=0
Это запускается процесс рабочего. В данном случае это метод [Start](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L32), который сообщает нам, что его адрес 1.1.1.1, роль "worker" и порт, который он нашел 37350. Теперь он моментально попробует уведомить планировщик, что он готов быть добавлен в кластер, указав свой адрес и порт:
> [00:33:12] src/van.cc:136:? => 1. Meta: request=0, timestamp=3, control={ cmd=ADD\_NODE, node={ role=worker, ip=1.1.1.1, port=37350, is\_recovery=0 } }
Это конкретное сообщение сгенерировано в методе [Send](https://github.com/dmlc/ps-lite/blob/master/src/van.cc#L130), вот тут. В нем нужно обратить внимание на несколько вещей:
* is\_recovery=0 — сообщает, что он не в режиме восстановления, эта часть выходит за рамки данной статьи
* cmd=ADD\_NODE — команда планировщику добавить рабочего в кластер
* ? => 1 — у каждого нода есть свой ранг. Ранг назначаеться планировщиком. Сам планировщик имеет ранг 1. В нашем случае нода без ранга отправляет сообщение ноде с рангом 1(планировщик).
На нашей диаграмме этот обмен сообщениями выглядит следующим образом:
Идем далее
> [00:33:13] src/van.cc:75: Bind to role=server, ip=2.2.2.2, port=54160, is\_recovery=0
Это проснулся наш сервер. Нашел себе порт (54160) и тут же пытается уведомить об этом планировщик:
> [00:33:13] src/van.cc:136:? => 1. Meta: request=0, timestamp=0, control={ cmd=ADD\_NODE, node={ role=server, ip=2.2.2.2, port=54160, is\_recovery=0 } }
На диаграмме это выглядит вот так:
Так же, как и в случае с рабочим, наш сервер отправляет команду "ADD\_NODE", чтобы его зарегистрировали в кластере. Так, как сервер еще не зарегистрирован в кластере и не имеет ранга, то мы видим: "? => 1".
> [00:33:13] src/van.cc:75: Bind to role=scheduler, id=1, ip=127.0.0.1, port=9000, is\_recovery=0
Наконец то планировщик запущен. Он использует локальный IP и порт 9000 (все ноды в кластере должны уже знать об его адресе и порте). Так как планировщик поднят, то логично ожидать, что в этот момент он получит все входящие сообщения, что были ему отправлены и… вуаля:
> [00:33:13] src/van.cc:161:? => 1. Meta: request=0, timestamp=0, control={ cmd=ADD\_NODE, node={ role=server, ip=2.2.2.2, port=54160, is\_recovery=0 } }
Сообщение от сервера. Эта часть логов сгенерирована методом [Receive](https://github.com/dmlc/ps-lite/blob/master/src/van.cc#L141), если быть еще более точным то [вот тут](https://github.com/dmlc/ps-lite/blob/master/src/van.cc#L162). Тут же планировщик получает второе сообщение, на этот раз от рабочего:
> [00:33:13] src/van.cc:161:? => 1. Meta: request=0, timestamp=3, control={ cmd=ADD\_NODE, node={ role=worker, ip=1.1.1.1, port=37350, is\_recovery=0 } }
Первым делом планировщик берется назначать ранги, вначале рабочему (9):
> [00:33:13] src/van.cc:235: assign rank=9 to node role=worker, ip=1.1.1.1, port=37350, is\_recovery=0
Теперь серверу (8):
> [00:33:13] src/van.cc:235: assign rank=8 to node role=server, ip=2.2.2.2, port=54160, is\_recovery=0
После идет довольно важная часть:
> [00:33:13] src/van.cc:136:? => 9. Meta: request=0, timestamp=0, control={ cmd=ADD\_NODE, node={ role=worker, id=9, ip=1.1.1.1, port=37350, is\_recovery=0 role=server, id=8, ip=2.2.2.2, port=54160, is\_recovery=0 role=scheduler, id=1, ip=127.0.0.1, port=9000, is\_recovery=0 } }
Сообщения вроде этих показывают, что планировщик получил команды "ADD\_NODE" от всех, нод кластера (в нашем случае от 1го рабочего и 1го сервера) и теперь начал уведомлять все ноды обратно о их рангах и об информации о всех других нодах в кластере. То есть планировщик отправляет ВСЮ информацию о КАЖДОМ ноде кластера КАЖДОМУ ноду кластера.
В данном конкретном сообщении мы видим все данные о кластере и это сообщение отправлено ноде с рангом 9 (это работник). Информация о кластере жизненно важна, так как она нужна рабочему, например, чтобы понять, на какой сервер отправлять обновление модели.
На диаграмме этот процесс выглядит вот так:
Следующий вывод:
> [00:33:13] src/van.cc:136:? => 8. Meta: request=0, timestamp=1, control={ cmd=ADD\_NODE, node={ role=worker, id=9, ip=1.1.1.1, port=37350, is\_recovery=0 role=server, id=8, ip=2.2.2.2, port=54160, is\_recovery=0 role=scheduler, id=1, ip=127.0.0.1, port=9000, is\_recovery=0 } }
Такое же подтверждение планировщик отправляет ноде с рангом 8 (сервер). На диаграмме выглядит так:
> [00:33:13] src/van.cc:251: the scheduler is connected to 1 workers and 1 servers
Планировщик радостно сообщил, что он подключён к одному рабочему и одному серверу (ко всем нодам кластера).
Напоминание — при запуске на реальном кластере все эти логи находятся на разных машинах, посему сейчас может показаться, что тут информации больше чем нужно.
> [00:33:13] src/van.cc:161: 1 => 2147483647. Meta: request=0, timestamp=0, control={ cmd=ADD\_NODE, node={ role=worker, id=9, ip=1.1.1.1, port=37350, is\_recovery=0 role=server, id=8, ip=2.2.2.2, port=54160, is\_recovery=0 role=scheduler, id=1, ip=127.0.0.1, port=9000, is\_recovery=0 } }
>
> [00:33:13] src/van.cc:281: W[9] is connected to others
Это рабочий получил сообщения от планировщика и сообщает, что он подключен к кластеру. Можно спросить, а что такое "2147483647". Ответ — понятия не имею =) скорее всего бага, Я бы ожидал увидеть: "1 =>9". Так, как рабочий корректно видит свой ранг: "W[9]", баг скорее всего где-то в процессе логирования, так что можете его пофиксить и стать контрибьютором проекта.
> [00:33:13] src/van.cc:161: 1 => 2147483647. Meta: request=0, timestamp=1, control={ cmd=ADD\_NODE, node={ role=worker, id=9, ip=1.1.1.1, port=37350, is\_recovery=0 role=server, id=8, ip=2.2.2.2, port=54160, is\_recovery=0 role=scheduler, id=1, ip=127.0.0.1, port=9000, is\_recovery=0 } }
>
> [00:33:13] src/van.cc:281: S[8] is connected to others
Тоже самое для сервера: он получил сообщение и довольный поведал об этому миру.
> [00:33:13] src/van.cc:136:? => 1. Meta: request=1, timestamp=4, control={ cmd=BARRIER, barrier\_group=7 }
>
> [00:33:13] src/van.cc:136:? => 1. Meta: request=1, timestamp=2, control={ cmd=BARRIER, barrier\_group=7 }
>
> [00:33:13] src/van.cc:136:? => 1. Meta: request=1, timestamp=1, control={ cmd=BARRIER, barrier\_group=7 }
Еще одна важная часть. До сих пор мы видели только одну команду "ADD\_NODE". Тут мы наблюдаем новую: "BARRIER". Если кратко, то эта концепция барьеров, которая, надеюсь, знакома читателю по многопоточному программированию и означает: "остановитесь до тех пор, пока все не дойдут до этого барьера". Планировщик отвечает за то, чтобы сообщить, когда именно все достигнут барьера и могут продолжать выполнение. Первый барьер расположен сразу после того, как кластер стартовал, но перед началом обучения. Все три ноды (включая сам планировщик) отправили сообщения, которое по существу значит: "я достиг барьера, дай мне знать, когда можно двигаться далее".
Так же, как видно из сообщения тут есть понятие барьерной группы(barrier\_group). Барьерная группа эту группа нодов, которые участвуют в том или ином барьере. Эти группы:
1 — планировщик
2 — сервера
4 — рабочие
Как не трудно догадаться, это степень двойки, так что наша группа 7 это: 4 + 2 + 1. По существу данный барьер распространяется на всех.
Ну и само собой, так как в наших логах, мы увидели три отправки сообщения, логично ожидать три строки о получении планировщиком этих сообщений:
> [00:33:13] src/van.cc:161: 1 => 1. Meta: request=1, timestamp=2, control={ cmd=BARRIER, barrier\_group=7 }
>
> [00:33:13] src/van.cc:291: Barrier count for 7: 1
>
> [00:33:13] src/van.cc:161: 9 => 1. Meta: request=1, timestamp=4, control={ cmd=BARRIER, barrier\_group=7 }
>
> [00:33:13] src/van.cc:291: Barrier count for 7: 2
>
> [00:33:13] src/van.cc:161: 8 => 1. Meta: request=1, timestamp=1, control={ cmd=BARRIER, barrier\_group=7 }
>
> [00:33:13] src/van.cc:291: Barrier count for 7: 3
Происходящее на нашей диаграмме выглядит вот так:
Теперь настало время обсудить, что делает планировщик, когда получает новое сообщение о том, что нода достигла барьера в определенной группе:
* он увеличивает счетчик числа нодов, которые отправили команду BARRIER в определенной группе ([вот тут](https://github.com/dmlc/ps-lite/blob/master/src/van.cc#L292))
* когда счетчик будет равен числу нодов в группе, он отправляет всем подтверждение о том, что можно продолжить нормальную работу
В логах выше можно увидеть, как счетчик увеличивался по мере получения каждого нового сообщения. Ну а в момент, когда он достиг ожидаемого размера (3), планировщик начал отправлять подтверждения:
> [00:33:13] src/van.cc:136:? => 9. Meta: request=0, timestamp=3, control={ cmd=BARRIER, barrier\_group=0 }
>
> [00:33:13] src/van.cc:136:? => 8. Meta: request=0, timestamp=4, control={ cmd=BARRIER, barrier\_group=0 }
>
> [00:33:13] src/van.cc:136:? => 1. Meta: request=0, timestamp=5, control={ cmd=BARRIER, barrier\_group=0 }
На нашей диаграмме это выглядит вот так:
Как можно заметить, планировщик даже отправляет подтверждение самому себе. Ну и само собой, раз было отправлено сообщение от планировщика (аж 3), то мы должны увидеть [логи о том, что эти сообщения получены](https://github.com/dmlc/ps-lite/blob/5ac4af05e5048652154b80ca8f12b3d2751b50fa/src/van.cc#L141):
> [00:33:13] src/van.cc:161: 1 => 9. Meta: request=0, timestamp=3, control={ cmd=BARRIER, barrier\_group=0 }
>
> [00:33:13] src/van.cc:161: 1 => 8. Meta: request=0, timestamp=4, control={ cmd=BARRIER, barrier\_group=0 }
>
> [00:33:13] src/van.cc:161: 1 => 1. Meta: request=0, timestamp=5, control={ cmd=BARRIER, barrier\_group=0 }
Ну и последние прикосновения. В данный момент планировщик достиг второго барьера, который будет достигнут всеми нодами после окончания обучения, однако, так как планировщик не принимает участие в обучении, то он уже достиг этот самый барьер. Так что он отправляет группе barrier\_group=7 что он достиг барьер, с мгновенным подтверждением получения сообщения и установкой счетчика барьерной группы 7 в 1.
> [00:33:13] src/van.cc:136:? => 1. Meta: request=1, timestamp=6, control={ cmd=BARRIER, barrier\_group=7 }
>
> [00:33:13] src/van.cc:161: 1 => 1. Meta: request=1, timestamp=6, control={ cmd=BARRIER, barrier\_group=7 }
>
> [00:33:13] src/van.cc:291: Barrier count for 7: 1
На этом этапе инициализация кластера закончена, можно начать обучение...
Обучение
--------
Выполнив весь код, мы имеем инициализированный KVstore. Что же теперь? Давайте используем его для непосредственного обучения. Я воспользуюсь очень простым примером линейного регрессора взятого [вот от сюда](http://mxnet.io/tutorials/python/linear-regression.html). Только прошу, перед тем, как продолжить, пройдитесь по примеру, чтобы понять происходящее. Что бы сделать тренировку в описанном примере распределенной, нужно поменять всего 1 линию в коде. Вместо:
```
model.fit(train_iter, eval_iter,
optimizer_params={
'learning_rate':0.005, 'momentum': 0.9},
num_epoch=50,
eval_metric='mse',
batch_end_callback
= mx.callback.Speedometer(batch_size, 2))
```
Нужно написать:
```
model.fit(train_iter, eval_iter,
optimizer_params={
'learning_rate':0.005, 'momentum': 0.9},
num_epoch=50,
eval_metric='mse',
batch_end_callback
= mx.callback.Speedometer(batch_size, 2),
kvstore=kv_store) # updated line
```
Так просто? если коротко — да.
Небольшое заключение
--------------------
Надеюсь у читателя теперь есть более детальное понимание того, что происходит с кластером MXNet в момент его старта. Также, я надеюсь, эта статья поможет с отладкой кластера в случае каких либо проблем. Ну и плюс, имея эти знания, можно сделать некоторые выводы о характеристике сети для кластера, а именно:
* планировщику не критично меть быстрое соединение с остальными
* серверам не критично иметь быстрое соединении между собой
* каждый рабочий должен иметь быстрое соединение с каждым сервером
* рабочим не критично иметь быстрое соединение с друг другом
[Буду очень благодарен за рекомендации оригинальной статьи на Medium](https://blog.kovalevskyi.com/mxnet-distributed-training-explained-in-depth-part-1-b90c84bda725). Так же, если вдруг вы занимаетесь построением распределённых систем машинного обучения на базе AWS с использованием MXNet и у вас есть какие либо вопросы, то я с радостью готов помочь и ответить (viacheslav@kovalevskyi.com).
Ссылки:
-------
* [полная версия кода из статьи](https://github.com/blog-kovalevskyi-com/mxnet_distributed_lr_model_training)
* [Draw.IO](http://draw.io/), сервис для рисования диаграм
* [MXNet ps-lite репозиторий](https://github.com/dmlc/ps-lite) | https://habr.com/ru/post/334968/ | null | ru | null |
# Как настроить Apollo для работы с GraphQL в Android
### Зачем статья
Недавно у меня появилась необходимость реализовать работу с бэком на GraphQL. Туториалов по настройке на Android, в отличие от REST не так много и большинство из них уже не совсем актуальны.
### Что такое GraphQL
GraphQL — модная альтернатива REST API, которая позволяет запрашивать данные более оптимизированным способом, отдавая только нужные вам данные.
### Настройка окружения
Делать запросы к серверу мы будем через Apollo — самая популярная библиотека для работы с GraphQL на данный момент.
Приступим к работе. Первым делом давайте добавим в манифест нужные разрешения для работы с сетью:
```
```
Далее необходимо подключить apollo. Идём в основной build.gradle и в разделе dependencies добавляем следующую строчку:
```
classpath 'com.apollographql.apollo:apollo-gradle-plugin:2.0.0'
```
Теперь необходимо в файле build.gradle модуля app подключить дополнительные зависимости:
```
implementation("com.apollographql.apollo:apollo-runtime:2.0.0")
implementation "com.apollographql.apollo:apollo-android-support:2.0.0"
```
Кроме того, в самый верх файла добавим подключение плагина:
```
apply plugin: 'com.apollographql.apollo'
```
После того, как проект синхронизировался, нам нужно настроить кодогенерацию моделей, с помощью которых мы будем делать запросы к GraphQL.
Свернем среду разработки и откроем терминал. Переходим в папку с вашим проектом:
```
cd /Users/user/Desktop/ProjectName
```
Если у вас ещё нет npm, то сперва скачайте с [официального сайта](https://www.npmjs.com/get-npm)
Устанавливаем apollo-codegen — инструмент, который позволит скачать schema.json — файл, который послужит apollo источником для генерации моделей:
```
npm install apollo-codegen
```
Скачиваем schema.json(необходимо находиться в директории вашего проекта, где появилась папка node\_modules):
```
node_modules/.bin/apollo-codegen download-schema https://ссылка на ваше api/ --output schema.json
```
Теперь в папке проекта мы видим файл schema.json. Осталось показать apollo файлы для генерирования моделей. Для этого делаем следующие шаги.
Переходим в папку app вашего проекта, далее src -> main. Здесь нам необходимо создать папку graphQL. Сюда мы будем складывать наши .graphql файлы.
Копируем в созданную папку файл, скачанный в предыдущем шаге — schema.json
Настройка окружения закончена, переходим к коду
### Генерация кода моделей
Начнём с файлов .graphql. Тут будут храниться запросы.
В GraphQL есть два вида запросов:
query — аналог GET
mutation — аналог POST/PUT/DELETE
Предположим, что вы делаете сервис для заселения постояльцев в комнату в отеле для администраторов этого отеля. Приложение умеет делать 3 функции. Логинить пользователя(администратора), получать информацию о комнате по id и заселять постояльцев
Создадим файл loginUser.graphql в созданной в предыдущем разделе директории app/src/main/graphQL. С помощью этого файла apollo сгенерирует нам модель для логина пользователя.
Содержание файла:
```
mutation loginUser($email:String!, $password:String!) {
login(
user: {
email: $email,
password: $password
}
){
email,
token,
refreshToken
}
}
```
Кроме того, нам потребуется файл getRoom.graphql, с его помощью сгенерируется модель для получения комнаты отеля:
```
query getRoom($room_id: String) {
room(room_id: $room_id) {
title,
room_number,
cheked_in_family_name,
has_minibar
}
}
```
И финальный файл — заселение постояльцев checkUserIn.graphql. Тоже использует mutation:
```
mutation checkInFamily($room_id: String!, $family_name: String!) {
room(
room: {
title: $family_name,
room_id: $room_id
}
){
room_id,
family_name,
minibar_products{
title,
weight
}
}
}
```
Билдим проект и видим 3 сгенерированных модельки в папке app/build/generated/source/apollo/debug/service: GetRoomQuery, СheckUserInMutation, LoginUserMutation
### Выполнение запросов
Создадим singleton класс NetworkService, который будет провайдить нам ApolloClient. В нём делаем 2 метода. getApolloClient() для выполнения запросов, которые не требуют токена или каких-либо дополнительных параметров, и getApolloClientWithTokenInterceptor(), в который будем прокидывать токен, для запросов:
```
import com.apollographql.apollo.ApolloClient
import okhttp3.Interceptor
import okhttp3.OkHttpClient
import okhttp3.Request
class NetworkService {
fun getApolloClient(): ApolloClient {
val okHttp = OkHttpClient
.Builder()
.build()
return ApolloClient.builder()
.serverUrl(BASE_URL)
.okHttpClient(okHttp)
.build()
}
fun getApolloClientWithTokenInterceptor(token: String): ApolloClient {
val httpClient = OkHttpClient.Builder()
.addInterceptor(Interceptor { chain: Interceptor.Chain ->
val original: Request = chain.request()
val builder: Request.Builder = original
.newBuilder()
.method(original.method, original.body)
builder.header("Authorization", "Bearer $token")
return@Interceptor chain.proceed(builder.build())
})
.build()
return ApolloClient.builder()
.serverUrl(BASE_URL)
.okHttpClient(httpClient)
.build()
}
companion object {
private var mInstance: NetworkService? = null
fun getInstance(): NetworkService? {
if (mInstance == null) {
mInstance = NetworkService()
}
return mInstance
}
}
}
```
Теперь идём в наше activity или fragment, тут реализуем выполнение запросов. Для начала залогинемся:
```
private fun loginUser() {
val client = NetworkService.getInstance()?.getApolloClient()
val loginMutation = LoginUserMutation
.builder()
.email(emailEdit.text.toString())
.password(passwordEdit.text.toString())
.build()
client
?.mutate(loginMutation)
?.enqueue(object : ApolloCall.Callback() {
override fun onResponse(response: Response) {
if (!response.hasErrors()) {
val token = response.data?.login()?.token()
val email = response.data?.login()?.email()
//Делаем операции, не трогающие ui, например сохраняем токен в БД
runOnUiThread {
//Выводим на экран то, что хотим
}
}
}
override fun onFailure(e: ApolloException) {}
})
}
```
Это пример работы с mutation. Данный запрос мы выполняли без токена в header. Теперь давайте рассмотрим пример работы с query, попробуем получить информации о комнате. Предположим, что комната нам отдается только с токеном. Выполняем запрос следующим образом:
```
private fun getRoom() {
val token = "123456"
val client = NetworkService.getInstance()
?.getApolloClientWithTokenIntercetor(token)
val roomId = "123"
val allRoomsQuery = GetRoomQuery(Input.fromNullable(roomId))
client
?.query(allRoomsQuery)
?.enqueue(object : ApolloCall.Callback() {
override fun onResponse(response: Response) {
if (!response.hasErrors()) {
val familyName = response.data?.room()?.family\_name()
}
}
override fun onFailure(e: ApolloException) {}
})
}
```
В качестве домашнего задания попробуйте сами написать реализацию заселения постояльцев.
Полезные ссылки:
[Документация apollo-client для Android](https://www.apollographql.com/docs/android/)[Github apollo-client android](https://github.com/apollographql/apollo-android) | https://habr.com/ru/post/501184/ | null | ru | null |
# Установка Midnight Commander на Mac OS X Catalina (2020)
Государственный флаг СССРПричем здесь флаг СССР? Статья затрагивает программы из далеких 80-х годов, когда был Советский Союз, поэтому и наш красивый флаг из тех времен. Кто помнит те времена и на больших предприятиях в некоторых кабинетах были даже программисты на [перфокартах](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D1%84%D0%BE%D0%BA%D0%B0%D1%80%D1%82%D0%B0), это отдельная тема.
ПерфокартаТак вот, вернемся к установке MC на Mac OS. Уверен, те кто давно работает за компьютером, тот помнит времена [Norton Commander](https://ru.wikipedia.org/wiki/Norton_Commander) и [Volkov Commander](https://ru.wikipedia.org/wiki/Volkov_Commander) (Советская версия) и прочих файловых менеджеров, которые помогали работать на компьютере. До того как появился [Windows 3.11](https://ru.wikipedia.org/wiki/Windows_3.x) и вообще полноценный Windows, основным интерфейсом был [MS-DOS](https://ru.wikipedia.org/wiki/MS-DOS). А для [UNIX систем](https://ru.wikipedia.org/wiki/Unix) был создан [Midnight Commander](https://ru.wikipedia.org/wiki/Midnight_Commander).
Сегодня я решил установить MC на [Mac OS](https://ru.wikipedia.org/wiki/MacOS) Catalina. Зачем? Иногда нужен доступ к папкам и всем каталогам, а его нет, Apple все пытается спрятать. Через терминал - это отдельный танец с бубном, не очень удобно.
Установка не в 2 клика, все оказалось не так просто, как хотелось бы.
Решил поделиться опытом, вдруг кто-то о подобном задумался и не знает как.
Процесс установки
-----------------
> **1. Требуется установить Xcode**
>
>
Берем бесплатную версию [Xcode](https://apps.apple.com/ru/app/xcode/id497799835?mt=12) с App Store и устанавливаем.
После установки Xcode выполнить команду в строке терминала:
```
xcode-select --install
```
Если при запуске получили ответ: **xcode-select: error: command line tools are already installed, use "Software Update" to install updates**. Значит у вас уже установлен Xcode, тогда пропускайте пункт №1 установки Xcode.
После запуска установки, у вас должно появиться диалоговое окно установки, где мы выбираем инсталляцию.
Если этого не сделать то в дальнейшем Homebrew будет выдавать предупреждение.
> **2. Установка** [**Homebrew**](https://brew.sh/index_ru)
>
>
Чтобы скачать и установить Homebrew, запустим сценарий установки в командной строке который приведен ниже и ждем когда скрипт сделает свое дело:
```
ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
```
Далее идет примерно такая установка.
> **3. Установка MC**
>
>
Теперь можно установить [**Midnight Commander**](https://midnight-commander.org)**.** В командной строке набираем:
```
brew install mc
```
После установки в командной строке терминала набираем:
```
mc
```
Окно MC в Mac OS (из Терминала)**Источники, которые использовались при написании статьи:**
[Homebrew — менеджер пакетов для OS X Mavericks 10.9](https://www.vivapage.info/install-homebrew/) (04.02.2014)
[Midnight Commander на Mac OS X – установка и настройка](https://xakinfo.ru/os/midnight-commander-na-mac-os-x-ustanovka-i-nastrojka/) (09.09.2016)
[Midnight Commander на Mac OS X – установка и настройка](https://www.vivapage.info/midnight-commander-mac-os-x/) (12.02.2014) | https://habr.com/ru/post/528138/ | null | ru | null |
# Манифест об отмене 146 УК и бойкоте Сбербанка и правообладателей-паразитов. За опенсорс и Nginx
`#nginxживи`
`#ЯМыNginx`
`#ЯМыСысоевКоновалов`
| | |
| --- | --- |
| | *Астрологи объявили неделю жадных юристов в IT.
Количество правообладятлов увеличилось вдвое.* |
Когда они вводили реестр запрещенных сайтов, я молчал — что мне до педофилов и экстремистов?..
Когда они пришли за Богатовым, я молчал — я ведь не держал выходную ноду Tor.
Когда они арестовывали протестующих в Москве, я молчал — кто их знает, этих оппозиционеров, может это всё Запад стабильность нарушает.
Когда они собирали [подписи на GitHub в поддержку](https://roskomsvoboda.org/49786/) Котова, я молчал — я не разделял его взглядов или не интересовался политикой (чего мне бояться, кому я нужен?).
Когда они пришли за Сысоевым и Коноваловым, я молчал — у меня ведь нет бизнеса на пол-лярда баксов.
***… вы находитесь здесь...***
Когда они ввели выездные визы для всех с зарплатой выше среднего, я...
Стоп. `*`***звук ускоренной перемотки назад***`*`
Мы, IT-шники, люди интеллектуальные. Сначала, пусть краткий, но логический и этический анализ. Каковы более глубокие причины происходящего, и соответственно, что на самом деле следует делать?
Кроме самого громкого события недели, обысков по уголовному делу "за авторские права" в офисе Nginx 12 декабря, мало кем замеченными прошли новости о других правообладателях: АЗАПИ, опять пытающихся лишить Telegram пользователей Apple ([ссылка](http://interfax.ru/business/687766)) и заранее поданные жалобы на еще не запущенную платформу опять же Telegram ([ссылка](http://interfax.ru/business/687501)). Нет, они "впрямую" не связаны, но это не похожесть и даже не случайное совпадение по времени. Однако, к сожалению, слишком глубоко и долго расписывать времени нет. Я лениво почеркивал глобальные и фундаментальные вопросы этики в черновик 2 части статьи о Telegram, здесь же придется сжато и тезисно (disclaimer на случай, если кому-то покажется, что какие-то звенья пропущены).
Среди бурлящих в сети обсуждений и тысяч комментариев выцепилась вот такая ссылка от профессионального юриста, который давно этим занимается, [Павел Протасов «Дело о похищенном веб-сервере»](http://www.duralex.org/2019/12/14/delo-o-poxishhennom-veb-servere/), приведу выдержки:
> Вся история с наездом на nginx — это стандартный пример того, как у нас в России происходит «борьба за копирайт». Вы, наверно, думали, что там кто-то в суды ходит и что-то доказывает? Не, ни фига. Благодаря тому, что «органы» наши твердо усвоили установку на «защиту правообладателя», возбуждение и расследование (если это можно так назвать) уголовок по 146 статье УК давно уже поставлено на поток.
>
> [...]
>
> А после достижения предсказуемого результата наш «потерпевший» берет приговор суда и идет с ним судиться уже в гражданском процессе (вот типичный пример такого дела). Поскольку стандарт доказывания в нашей уголовке лежит где-то под плинтусом, в приговоре «доказанным» может быть провозглашен любой факт, лишь бы не оправдывать этого злодея, нарушителя священного копирайта. И этот факт будет считаться доказанным всеми другими судами. Удобно же! Хотя, конечно, можно и сразу в арбитраж пойти, многие так и делают.
>
> [...]
>
> Это я пишу потому что для колоссального количества людей вот такие нюансы отечественного копирайтинга стали прямо-таки откровением, судя по обсуждениям в интернетах. Нет, товарищи, в России спор о копирайте — это потенциальная уголовка. Благодарите за это несколько поколений наших «ворцов за права», прежде всего моих любимцев НП ППП, которые и начинали формировать такую практику когда-то давно. Выгодно же, когда твои права охраняет государство всей мощью своего репрессивного аппарата. А то придумали еще: в суд ходить и там судиться, фигня какая-то…
>
> Потому что, как это принято при расследовании уголовных дел, все факты будут подгоняться под ответ, тем более что «резиновая» формулировка закона «О правовой охране…» это вполне допускает. Ну и, конечно, нет оснований не доверять сотрудникам полиции, а все выступления тогдашних работников «Рамблера» в защиту Сысоева продиктованы исключительно желанием уйти от ответственности, ну и так далее. Обычно широкие слои населения видят это все при освещении каких-то «нашумевших» уголовных дел, в основном связанных со всякой «оппозицией», которая и поднимает вокруг них хайп. Но точно так же идет расследование по любому другому делу. Еще успешной подгонке под ответ могут поспособствовать некоторые интервью Сысоева [...]
>
> [...]
>
> Единственное препятствие к обвинительному приговору с последующим разводом на бабки пользователей nginx — это **нетипичность такого дела. *Именно в таких случаях получается столкнуть его с накатанных рельсов*.**
Итак, понимаете? Это не просто редкий случай "прорвался рэкет методами из 90-х из-за большой суммы денег". Это именно что ***система***, выстраивавшаяся годами. И хотя в <https://roem.ru/12-12-2019/281134/rambler-nginx/#comment-292209> уже звучат призывы к бойкоту бенефициаров:
> Просто Рамблер бойкотировать смешно. По слухам основной бизнес Рамблера — отмывание денег. Символически можно и бойкот Рамблера устроить за кампанию, просто там терять нечего в том числе и репутации уже нет. А вот у Сбера репутация есть и инфлюенсеры в соц. сетях могут её капитально поправить.
… или вот что пишет Ашманов, кстати, доверенное лицо Путина на выборах 2018: <https://roem.ru/12-12-2019/281134/rambler-nginx/#comment-292227> :
> Мамут с Грефом фактически осуществили — или одобрили, инициировали, нечаянно запустили от жадности — беспрецедентную атаку на индустрию ИТ в нашей стране.
>
> И, заметим, атаку на национальный проект «Цифровая экономика».
>
> Потому что после этой истории с кем мы будем делать эту цифровую экономику?
>
> В сети бушует истерика айтишников «надо ехать, заводи трактор».
>
> Мамут с Грефом невзначай включили турбо-режим утечки мозгов программистов и разработчиков Кремниевую Долину. До этого утечка, в общем, уменьшалась и была уже очень умеренной, по многим причинам.
>
> То есть узкий круг ограниченных лиц, из корыстных побуждений, начал поджигать один из столпов нашей экономики и суверенитета. Как гопники, кидающие камни в проезжающие электрички.
>
> Мне кажется, они даже не понимают, что они сделали. И не хотели такого. И явно удивлены реакцией. У них, я думаю, сейчас — даже на выходных — идут закулисные обсуждения в стиле «а чо такова-то», «чё эта было-то». Типа, отняли же десятки и сотни бизнесов и всё было нормально, здесь-то чо. А шум будет ещё нарастать.
… так вот, хотя это тоже дело важное и нужное, и [на хабре уже тоже высказываются о бойкоте](https://habr.com/ru/post/480162/#comment_21009810) (например [Zarathu5trA](https://habr.com/ru/users/zarathu5tra/)), давайте зрить в корень.
Источником права, то есть законов, является мораль и этика, разделяемые данным обществом.
Кто такие эти так называемые правообладатели?
Даже с точки зрения классического капитализма (не говоря уже о левых взглядах), который во многом был основан на протестантской этике (много работать — богоугодно), общественный договор основывается на том, что прибыль будет получена *в обмен на нечто полезное*. На некий продукт или услугу, т.е. действие идет и в **общественное благо**. В противном случае, получение денег "просто так", аморально, и как следствие, *должно быть* незаконно.
А теперь посмотрите с этой точки зрения на все эти АЗАПИ, НП ППП, и, кстати, любые монополии. Например, банковские. Что они дают обществу, то есть нам всем, полезного взамен? Ничего. Это чистой воды **паразитирование**. Оно аморально. Хуже того, оно ломает человеческие судьбы, иногда и жизни. Следовательно, оно может и **должно** *быть поставлено вне закона*.
Итак, вернемся к продолжению по Нимёллеру.
Если мы, то есть общество, ничего не предпримем, то за кем придут следующим? [Выводы и вынесение из комментариев](https://habr.com/ru/post/480162/):
> Полезно также будет понимать, откуда исходит угроза. И виноваты — как минимум, в случае Rambler и Nginx, не siloviki, на которых указывает Крючков. Они, в данном случае — физическое тело. Сила, которая привела это тело в движение — олигархат, вполне себе гражданские владельцы и бенефициары крупного бизнеса.
>
> И это, возможно, самый недооцениваемый — и самый важный — урок, который следует извлечь из атаки «Рамблера» на Nginx. Психологически, конечно, понятно естественное желание видеть угрозу в каких-то «чужих» — государстве, силовиках. Тогда как неприятная правда в том, что за Игорем Сысоевым пришли, буквально, «свои»
>
> [...]
>
> Если в поисках, откуда ещё можно выжать денег, олигархи дошли уже до бывших сотрудников принадлежащих им компаний, докопавшись до проекта, корни которого уходят в 2002 год — значит, куски больше уже разобраны. И, значит, следом грызня начнётся за куски ещё меньшего размера.
>
> Если сейчас олигархат готов вцепиться в Nginx стоимостью в $650 млн — значит, что светофор уже переключился на жёлтый для всех проектов over $100 млн, до которых (или бенефициаров которых) силовики их длинные руки могут дотянуться.
>
> Это — уже реальность. И, если существующие условия не изменить, следом она заглянет и в окошки поменьше.
>
> По мере уменьшения пирога, борьба тех, у кого сегодня в руках ножи и вилки, за каждый кусок будет обостряться — и, если дело дойдёт до крошек, то не побрезгуют и ими.
>
> [...]
>
> P.P.S. Из комментариев:
>
> [DarkHost](https://habr.com/ru/users/darkhost/) Думаю, если бы все айтишники одномоментно, в знак протеста, уволились из рамблера, на этом рамблер бы и закончился.
>
> [alekciy](https://habr.com/ru/users/alekciy/) Этого не будет, т. к нет профсоюзов.
>
> [vlsinitsyn](https://habr.com/ru/users/vlsinitsyn/) работникам айти нужен профсоюз. И договор коллективный, в котором бы подобные статейки в контракте не имели возможности появится.
>
> [EgorKotkin](https://habr.com/ru/users/egorkotkin/) Верно. И фрилансерам тоже. Площадки вроде fl.ru и kwork давно стали помещиками, занявшими всю землю на рынке, и пытаются превратить фрилансеров в своих крепостных.
Иными словами, послезавтра (то есть после выборов-2021 — кстати, политолог Глеб Павловский на ОГФ заявил, что эти выборы в ГосДуму будут **последними выборами в России**) — могут придти уже за вполне рядовыми компаниями и их сотрудниками.
И поскольку, таким образом, это **атака на всех нас, на всю отрасль** — нам нужно объединяться. Будь то профсоюзы или что иное в долгосрочной перспективе — вопрос еще обсуждаемый. Что мы таки можем сделать прямо сейчас — это наказать тех, кому выгодно, единственным языком, который они понимают — рублём.
* Айтишник, работаешь на копирастов? Увольняйся! Рабочие места найдутся.
* Айтишник, работаешь на любую из контор Сбербанка? Увольняйся! Ведь ЖОРИК же говорил, что программисты больше не нужны, всё искуственный интеллект сделает — вот пусть и пожинает!
ЖОРИК — прозвище Грефа среди разработчиков онлайн-процессинга Сбера, употребляемое в отсылках к идиотизмам менеджмента Сбера (а-ля "анти-Мидас")
Процессинг — сервера, в реальном времени обслуживающие банкоматы и оплату картой в магазинах (т.е. при отказе кусок экономики РФ просто встанет)
Но это действия, опять же, в перспективе. А что нужно сделать прямо сейчас, в эти дни? На Хабре объявляли 30-минутный блэкаут сайтов на nginx, в полдень воскресенья. Идея хорошая, но в таком исполнении, недостаточная. В выходной день с этого мало толку, так как мало пользователей, да было мало и участников. Необходимо делать это в *час пик* в будни, и на наиболее посещаемых сайтах; впрочем, как можно больше, чем больше, тем лучше. Цель — чтобы о nginx и его роли узнало как можно больше народу, как простых людей, так и...
… наших так называемых элит. Кто-то, наверное, эти названия сейчас впервые услышит, но в каналах из так называемой "обоймы Незыгаря" все 4 дня, до утра понедельника, по теме nginx не было НИЧЕГО (кроме одного второстепенного, да и там гламурная плесень спутала "Ой, это не наш Сысоев" с каким-то местечковым радио). Они у нас оторванные от реальной жизни, эти нами управляющие "элиты", понимаете. Они явно банально не поняли, о чем речь. Их надо учить, как маленького ребенка — в розетку пальцы не совать, воду пить только из водопровода, её там дезинфицируют. Самый, увы, "весёлый" случай несения просвещения в народные (и чиновничьи) массы — пока не продемонстрировать, *что* может сломаться, не поймут-с.
Впрочем, справедливости ради, утром от них всё же поступила такая информация:
> Достаточно много экспертов считают, что Греф не мог не знать о планах Рамблера, учитывая, что глава Сбербанка весьма трепетно относится к контролю за любимыми игрушками (одной из которых и является создание информационного холдинга). Далее мнения расходятся [...]
>
> Другие говорят, что Греф и сам заинтересован в скандале, который позволяет ему "выбросить" Мамута из проекта [...]
>
> Понятно, что Греф сейчас будет публично отыгрывать назад.
И отвечая на "возражения" к этой идее из комментариев, дескать, это наказать пользователей почем зря, и т.п.
Ну, ребята, это либо штрейкбрехерство. Либо вы до сих пор не понимаете одной из базовых вещей:
**Борьба невозможна "нахаляву", без жертв.** (или иными словами, за всё надо платить)
И небольшой перерыв в доступе к сайту (кстати, никто ж не запрещает сделать заглушку с кнопкой, позволяющей продолжить) — очень небольшая цена за предотвращение последствий, возможно, для *твоей* же шкуры в будущем.
И самый, пожалуй, инерционный момент — вида "если я так сделаю, мне ж начальство плохо сделает".
Ау, айтишник, не будь трусливым и малодушным ~~ч~~! Уж в этом-то случае — донеси до начальства, что по мере усугубления тенденций, первым придут *за ним*, а за тобой уже потом.
Айтишник, понимай! Это — не митинг! Никакой росгвардеец не закроет тебя в СИЗО по надуманному поводу, потому что никакого выхода на улицы нет! Достаточно лишь наглядно показать им, что наша работа, как работа сантехника — пока всё хорошо, никто нас не замечает, но как только что-то нами не чинится, *все по уши в дерьме*!
Главное — растущее самосознание. Даже не встав с дивана, мы можем показать многое! *(что? у вас там пол-экономики легло? не поеду, мужчина, вы что не видите, у меня ОБЕД!)*
Свобода начинается с единства.
Наконец, last but not least — судя по текущим новостям, как совет директоров Рамблера уже не сможет остановить уголовное дело (даже если захочет), так и останавливаться, судя по новости о Twitch, копирасты явно не собираются. Отсюда вытекает единственно возможное логически решение:
**Мы, IT-сообщество России, выдвигаем требование отмены статьи 146 УК РФ, закрытия всех имеющихся уголовных дел и проведения по ней амнистии.**
(в комменты призывается @roskomsvoboda для уточнения, как это воплощать)
 | https://habr.com/ru/post/480644/ | null | ru | null |
# Настройка SBCL и среды разработки SLIME под Windows. Пошаговое руководство
В данной статье я подробно опишу как установить и настроить SBCL и окружение для продуктивной разработки под Windows.
Вообще, изначально это была небольшая заметка для коллеги по планируемому мной проекту по анализу и визуализации кода и текстовых данных, но я решил её доработать и превратить в полноценную статью, так как я мало видел руководств подобного рода относительно лиспа, особенно на русском, и особенно касающихся Windows.
#### SBCL
Для начала нам нужна сама лисп-система.
SBCL для винды следует брать вот тут:
[github.com/akovalenko/sbcl-win32-threads](https://github.com/akovalenko/sbcl-win32-threads)
Этот форк SBCL, поддерживаемый и разрабатываемый Антоном Коваленко, добавляет поддержку многопоточности и исправляет огромное количество windows-специфичных багов официальной версии под винду. Кроме того, в него добавлены некоторые очень приятные фичи, которых в основной ветке нет даже в активно поддерживаемых линукс-версиях. Одна из таких фич — stdcall-коллбэки, так необходимые на винде, другая — возможность работы лисповых коллбэков в сторонних тредах(созданных не лиспом, а, например, операционной системой или сторонними сишными, и не только сишными, библиотеками).
Форк постоянно синхронизируется с основным репозиторием, и когда-нибудь в конечном итоге будет смержен с ним.
Хотя лично я регулярно собираю SBCL из исходников, прямо из HEAD ветки mswinmt, с помощью MinGW, но на страничке вики по ссылке также регулярно выкладываются msi-инсталляторы, и поэтому если вам лень ставить и настраивать MinGW, то вы можете скачать бинарники прямо там.
[github.com/akovalenko/sbcl-win32-threads/wiki](https://github.com/akovalenko/sbcl-win32-threads/wiki)
Оффверсию под Windows использовать не стоит совершенно ни по каким причинам, так она она глючная и сильно недоработанная.
После того, как у вас в руках есть инсталлятор, SBCL следует установить. Я рекомендую ставить его куда-нибудь поближе к корню файловой системы, наподобие как в «D:\SBCL\», а не как предлагается дефолтно(в \program files\), по причинам того, что, во-первых, MAX\_PATH не резиновая, а во-вторых, это поможет избежать конфликтов со сторонними библиотеками и утилитами, которым не нравятся пробелы в файловых путях.
#### ASDF
После установки рантайма лисп-системы, нам следует настроить ASDF.
ASDF это такая система сборки лисповых библиотек, и загрузки их в работающий лисповый процесс, наподобие Make, написанная полностью на CL и не использующая сторонние программы. Больше про нее почитать можно [тут](http://common-lisp.net/project/asdf/), но а я пока опишу ее настройку.
ASDF фактически является де-факто стандартной системой своего рода в среде лисп-разработчиков, и поставляется практически со всеми реализациями CL, в том числе и с SBCL, поэтому я пропущу первый этап, «где ее взять»(если у вас вдруг ее нет, то её можно скачать на ее домашней страничке по ссылке выше, это буквально один файл).
Второй этап заключается в настройке того, где ASDF ищет лисповые библиотеки.
Предположим, у нас есть директория «D:\Lisp», где у нас будут храниться всякие вещи, связанные с CL.
Предположим еще, что у нас в этой директории существует поддиректория «libraries», в которой будут находиться библиотеки, не связанные с quicklisp(про него ниже).
Тогда нам надо будет определить переменную среды `CL_SOURCE_REGISTRY`, и задать ей следующее значение:
`(:source-registry (:tree "D:/Lisp/libraries/") :inherit-configuration)`
(переменные среды, в Windows 7, например, настраиваются в `панель управления -> система -> дополнительные параметры системы -> переменные среды`)
Вторая переменная среды, которую нам надо будет определить, если мы не хотим, чтобы скомпилированные fasl-файлы засоряли директории с исходным кодом — `ASDF_OUTPUT_TRANSLATIONS`
Она определяет, куда будет складываться кеш компиляции, и откуда загружаться.
Ей нужно задать значение навроде этого:
`(:output-translations (T ("D:/Lisp/fasl-cache/" :implementation)) :inherit-configuration)`
Таким образом, fasl-файлы будут лежать по путям вроде `"D:/Lisp/fasl-cache/sbcl-1.0.52.1.mswinmt.969-6acb698-win-x86/d/Lisp/libraries/my-library/src/package.fasl"` и не будут мешаться в директориях с исходниками.
#### Quicklisp
Теперь нам нужно установить quicklisp.
[Quicklisp](http://www.quicklisp.org/) это пакетный менеджер для CL, в котором собраны наиболее свежие и наиболее популярные библиотеки. Очень удобная штука, и тоже, как и ASDF, фактически является де-факто стандартом.
Установить quicklisp очень просто — надо скачать файл [quicklisp.lisp](http://beta.quicklisp.org/quicklisp.lisp) и загрузить его в образ лисп-системы, например набрав `(load "quicklisp.lisp")` в REPL'е
После загрузки файла, в REPL появится сообщение:
`==== quicklisp quickstart loaded ====
To continue, evaluate: (quicklisp-quickstart:install)`
Нам, соответственно, надо набрать (quicklisp-quickstart:install) в REPL и нажать «Enter».
Вообще, эта функция принимает необязательный именованный параметр :path, который указывает, куда устанавливать ql, но в принципе, дефолтное ее значение(%users%/%username%/quicklisp/) подойдет многим.
После того, как установщик quicklisp'а скачает, установит и загрузит его в лисповый процесс, необходимо будет набрать в REPL'е `(ql:add-to-init-file)`, чтобы процесс загрузки ql в образ в будущем автоматизировался, и нам не приходилось каждый раз при старте лисп-системы его загружать руками.
Для установки или просто загрузки какой-либо библиотеки, quicklisp предоставляет функцию `ql:quickload`. Это реально очень удобно — он автоматически скачивает, компилирует и загружает библиотеки совершенно без каких-либо лишних усилий и телодвижений. Как говорит его автор, самое главное достоинство quicklisp в том, что он «просто работает».
В принципе, уже сейчас можно написать первую программу на лиспе под Windows.
Наберите в REPL несколько форм:
```
(ql:quickload :cffi)
(cffi:load-foreign-library "user32.dll")
(defun main ()
(cffi:foreign-funcall "MessageBoxW"
:pointer (cffi:null-pointer)
(:string :encoding :utf-16le) "SBCL на Windows это просто!"
(:string :encoding :utf-16le) "Сообщение"
:int #x40
:boolean))
(sb-ext:save-lisp-and-die "my-program.exe" :executable t :toplevel #'main)
```
Запустим my-program.exe и проверим:
#### Среда разработки
Про Emacs, наверное, слышали все.
Мнения о нем расходятся — кому-то он, возможно, представляется бесполезной игрушкой для гиков, для кого-то это заумный, но устаревший консольный редактор из 70х, а для кого-то — ежедневный инструмент.
Какое бы у вас мнение о Emacs'е не было, один факт на текущий момент остается фактом — расширение SLIME для Emacs — единственная, на текущий момент, полноценная и удобная среда разработки на Common Lisp.
Вообще, я лично имею достаточный опыт работы с продвинутыми IDE вроде Visual Studio, и могу заверить — по удобству SLIME от них ушел недалеко, а может даже, благодаря гибкости Emacs, и вырвался вперед.
Вообще, Emacs по своей сути это рантайм одного старого диалекта лиспа, Emacs Lisp, и своей расширяемости и гибкости, а может даже и выживаемости, он обязан именно этому факту.
Ну ладно, это я отвлекся.
Сначала — «где взять сам Emacs?». Вот здесь: [ftp.gnu.org/pub/gnu/emacs/windows](http://ftp.gnu.org/pub/gnu/emacs/windows/)
Качайте самый новый (на данный момент это `emacs-23.3-bin-i386.zip`) и распаковывайте контент директории `emacs-23.3` куда-нибудь навроде `"D:\Emacs\"`(кстати, ввиду изначальной юникс-ориентированности Емакса, возможны некоторые проблемы с путями с пробелами, поэтому тут совет такой же как и при установке SBCL).
Как только распаковали — запускаем программу addpm.exe, находящуюся в `%Путь_к_Emacs%/bin` — это опциональный шаг, он добавляет иконку в меню «Пуск» и тому подобное, но я все же рекомендую его пройти.
Теперь нам надо скачать SLIME.
Брать его вот тут: [common-lisp.net/project/slime](http://common-lisp.net/project/slime/)
Я лично предпочитаю обновлять через CVS, но, в принципе, там по ссылке всегда есть и простой архив с более-менее свежей версией.
Директорию SLIME нужно положить в директорию библиотек, для которой мы настроили ASDF(в случае, если вы прямо следовали написанному выше, это будет `D:\Lisp\libraries\`)
Теперь про настройку.
Для подключения SLIME и приведения Emacs'а к более-менее привычному для пользователя Windows виду, нам надо написать некоторые вещи в его файле инициализации.
Как я уже выше сказал, Emacs это по сути интерпретатор Emacs Lisp'а, а это значит, среди прочего, что его файл инициализации это просто файл с кодом на этом самом Emacs Lisp.
Находится файл, если говорить о Windows, обычно в директории `%users%\%username%\.emacs.d\`, и называется `init.el`(собственно расширение указывает, что это код на упомянутом диалекте лиспа). У меня, например, это `C:\Users\Lovesan\.emacs.d\init.el`. Если директории `.emacs.d` в директории пользователя нету — создайте её и, соответственно, файл.
Далее я приведу часть своего `init.el` с некоторыми комментариями и объяснениями.
```
;; Настройка кодировок и окружения.
;; Мы хотим чтобы наши файлы с кодом сохранялись в UTF-8,
;; пока прямо не укажем другое.
(set-language-environment 'UTF-8)
(setq default-buffer-file-coding-system 'utf-8-unix)
;; Если не отменить make-backup-files, Emacs будет засорять
;; файловую систему бэкапами.
(setq-default make-backup-files nil)
;; Это включает автосохранение - пока вы работаете с файлом,
;; Emacs время от времени автоматически создает копию, и удаляет её
;; как только вы сохрание файл с которым работаете.
(setq-default auto-save-defaults t)
;; Это отключает табы. Как бы вы не относились к табам
;; в контексте кода других языков программирования,
;; в лиспе с ними работать совершенно невозможно.
(setq-default indent-tabs-mode nil)
;; Это делает Emacs немного более дружелюбным к пользователям Windows.
;; Конкретно, первая строка включает обычный виндовый курсор для
;; текстовых редакторов, а вторая - биндит хоткеи вставки/вырезки и
;; копирования на стандартные Ctrl+V, Ctrl+X и Ctrl+C
(setq w32-use-visible-system-caret t)
(cua-mode)
;; Это настраивает подсветку парных скобок, очень полезная штука
;; чтобы в них не заблудиться, и чтобы видеть где скобки лишние.
(show-paren-mode)
;; Это настраивает дополнительный модуль highlight-parentheses
;; Полезная штука, подсвечивает вложенные скобки в несколько уровней.
;; Скачать его можно тут: http://www.emacswiki.org/emacs/HighlightParentheses
(byte-compile-file "d:/Emacs/lisp/highlight-parentheses.el")
(require 'highlight-parentheses)
(define-globalized-minor-mode global-highlight-parentheses-mode
highlight-parentheses-mode
(lambda ()
(highlight-parentheses-mode t)))
(global-highlight-parentheses-mode t)
;; Дальше собственно настройка SLIME.
;; Первое, что нужно сделать, это указать путь к рантайму реализации лиспа,
;; с которой мы будем работать.
(setq inferior-lisp-program "D:/SBCL/sbcl.exe")
;; Далее нужно указать, где у нас находится SLIME.
(add-to-list 'load-path "D:/Lisp/libraries/slime-2011-10-27/")
;; Загружаем SLIME
(require 'slime)
;; Устанавливаем, с помощью какой кодировки SLIME будет
;; общаться с лисп-системой
(setq slime-net-coding-system 'utf-8-unix)
;; Модули SLIME, которые мы подключаем
;; Тут указанные - это, по моему мнению, базовый минимум.
;; В дальнейшем можете сами подробнее почитать о них
;; в мануале SLIME.
(slime-setup '(slime-repl
slime-fuzzy
slime-fancy-inspector
slime-indentation))
;; Настроим хоткеи для автодополнения и выравнивания отступов
(define-key slime-mode-map (kbd "TAB")
'slime-indent-and-complete-symbol)
(define-key slime-mode-map (kbd "C-c TAB")
'slime-complete-symbol)
;; Это включает алгоритмы выравнивания лиспового кода из SLIME,
;; в противоположность стандартным из Emacs
(setq lisp-indent-function 'common-lisp-indent-function)
;; Немного настроим выравнивание отступов под себя
;; Более подробно о кастомизации этого дела можно почитать
;; в сорцах SLIME, а именно
;; в %путь_к_slime%/contrib/slime-cl-indent.el
(define-common-lisp-style "my-indent-style"
"My custom indent style."
(:inherit "modern")
(:variables
(lisp-loop-indent-subclauses t))
(:indentation
(if (4 2 2))
(define (λ 2))
(with-gensyms ((&whole 4 &rest 1) &body))
(once-only (as with-gensyms))))
(setq common-lisp-style-default "my-indent-style")
```
В принципе, можно начинать работать.
Запускаем Emacs (через меню пуск, или runemacs.exe в `%путь_к_emacs%/bin/`).
Набираем `Alt+X` и печатаем `slime`.
Как только SBCL откомпилирует и загрузит лисповую сторону SLIME(т.н. swank-сервер), появится REPL SLIME.
Можно, естественно, работать полностью в нем, но лучше, конечно, в основном работать с файлами.
Тут надо описать некоторые хоткеи Emacs и SLIME, чтобы хоть с чего-то начать(по себе знаю, как просто в этом редакторе потеряться, не зная биндинги основных команд).
M-x — вызов команды(то есть к-либо функции Emacs Lisp) по имени.
*(Вообще, C- означает, что во время набора должен быть нажат Ctrl, а M- соответственно Alt. Почему «M»? Потому что [«Meta key»](http://ru.wikipedia.org/wiki/Meta_(%D0%BA%D0%BB%D0%B0%D0%B2%D0%B8%D1%88%D0%B0)), но т.к. этой клавиши на стандартных клавиатурах нет, вместо нее используется Alt.)*
C-x C-c — выход из Emacs.
С-x b — смена буфера (буфер это что-то вроде файла, который открыт в Emacs, за исключением того, что некоторый буфер не обязательно с каким-то файлом в файловой системе связан).
C-x k — закрыть буфер.
C-c C-f — открывает файл, существующий или новый
C-x s — сохранить файл.
C-x C-s — сохранить файл не спрашивая о перезаписи.
C-x 0 — закрыть текущее окно.
C-x 1 — закрыть все окна кроме текущего.
C-x 2 — разделить окно на два, вертикально (в емаксе встроенный тайлинговый оконный менеджер. Пользователям современных версий винды он может показаться необычным.)
C-x 3 — разделить окно на два, горизонтально.
C-x o — перейти в другое окно
M-: — считывание и вычисление какого-либо выражения Emacs Lisp в минибуфере.
В SLIME REPL:
, — ввод специфичной для SLIME REPL команды.
В буфере файла, с которым работает SLIME(как правило, файлы с расширением .lisp и подобными):
M-. — прыгнуть к определению какого-либо символа/функции/etc.
M-, — прыгнуть назад.
C-x C-e — вычислить выражение
C-c C-k — скомпилировать и сразу загрузить файл.
TAB — автодополнение и выравнивание (мы это настроили в init.el) (кстати, также работает и в REPL)
C-c TAB — просто автодополнение
*Автодополнение и прочие подобные функции в SLIME работают основываясь на состоянии подключенной лисп системы, а не просто на основе анализа файлов с кодом. Это значит, что для того чтобы SLIME мог нам что-то конкретное о символе/функции/типе/etc. сказать, нам нужно загрузить файл или библиотеку, содержащую их, в лисп-систему, через REPL или еще как-нибудь.*
C-c C-d C-d — описать символ и все с ним связанное (работает наподобие стандартного [describe](http://l1sp.org/cl/describe))
C-c C-d h — посмотреть описание символа на [CLHS](http://l1sp.org/cl/)
C-c C-d a — найти и описать символы по их части(работает наподобие стандартного [apropos](http://l1sp.org/cl/apropos))
По лисповым выражениям удобно перемещаться стрелочками, зажав при этом Ctrl — курсор перемещается через слова и блоки текста, а не по буквам, и с помощью C-M-b и C-M-f — курсор перемещается по S-выражениям.
Вот, в принципе, и всё. Можно начинать писать код.
**Upd.** Для корректной работы SLIME очень желательно установить переменную среды HOME в значение, соответствующее пути домашней директории пользователя. У меня, на Windows 7, например, это `C:\Users\Lovesan` | https://habr.com/ru/post/131418/ | null | ru | null |
# Учебный курс по React, часть 28: современные возможности React, идеи проектов, заключение
Сегодня, в заключительной части перевода курса по React, мы поговорим о современных возможностях React и обсудим идеи React-приложений, создавая которые, вы можете повторить то, чему научились, проходя этот курс, и узнать много нового.
[](https://habr.com/ru/company/ruvds/blog/447134/)
→ [Часть 1: обзор курса, причины популярности React, ReactDOM и JSX](https://habr.com/post/432636/)
→ [Часть 2: функциональные компоненты](https://habr.com/post/433400/)
→ [Часть 3: файлы компонентов, структура проектов](https://habr.com/post/433404/)
→ [Часть 4: родительские и дочерние компоненты](https://habr.com/company/ruvds/blog/434118/)
→ [Часть 5: начало работы над TODO-приложением, основы стилизации](https://habr.com/company/ruvds/blog/434120/)
→ [Часть 6: о некоторых особенностях курса, JSX и JavaScript](https://habr.com/company/ruvds/blog/435466/)
→ [Часть 7: встроенные стили](https://habr.com/company/ruvds/blog/435468/)
→ [Часть 8: продолжение работы над TODO-приложением, знакомство со свойствами компонентов](https://habr.com/company/ruvds/blog/435470/)
→ [Часть 9: свойства компонентов](https://habr.com/company/ruvds/blog/436032/)
→ [Часть 10: практикум по работе со свойствами компонентов и стилизации](https://habr.com/company/ruvds/blog/436890/)
→ [Часть 11: динамическое формирование разметки и метод массивов map](https://habr.com/company/ruvds/blog/436892/)
→ [Часть 12: практикум, третий этап работы над TODO-приложением](https://habr.com/company/ruvds/blog/437988/)
→ [Часть 13: компоненты, основанные на классах](https://habr.com/ru/company/ruvds/blog/437990/)
→ [Часть 14: практикум по компонентам, основанным на классах, состояние компонентов](https://habr.com/ru/company/ruvds/blog/438986/)
→ [Часть 15: практикумы по работе с состоянием компонентов](https://habr.com/ru/company/ruvds/blog/438988/)
→ [Часть 16: четвёртый этап работы над TODO-приложением, обработка событий](https://habr.com/ru/company/ruvds/blog/439982/)
→ [Часть 17: пятый этап работы над TODO-приложением, модификация состояния компонентов](https://habr.com/ru/company/ruvds/blog/439984/)
→ [Часть 18: шестой этап работы над TODO-приложением](https://habr.com/ru/company/ruvds/blog/440662/)
→ [Часть 19: методы жизненного цикла компонентов](https://habr.com/ru/company/ruvds/blog/441578/)
→ [Часть 20: первое занятие по условному рендерингу](https://habr.com/ru/company/ruvds/blog/441580/)
→ [Часть 21: второе занятие и практикум по условному рендерингу](https://habr.com/ru/company/ruvds/blog/443210/)
→ [Часть 22: седьмой этап работы над TODO-приложением, загрузка данных из внешних источников](https://habr.com/ru/company/ruvds/blog/443212/)
→ [Часть 23: первое занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/443214/)
→ [Часть 24: второе занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/444356/)
→ [Часть 25: практикум по работе с формами](https://habr.com/ru/company/ruvds/blog/446208/)
→ [Часть 26: архитектура приложений, паттерн Container/Component](https://habr.com/ru/company/ruvds/blog/446206/)
→ [Часть 27: курсовой проект](https://habr.com/ru/company/ruvds/blog/447136/)
→ [Часть 28: современные возможности React, идеи проектов, заключение](https://habr.com/ru/company/ruvds/blog/447134/)
→ **The end!**
Занятие 46. Разработка современных React-приложений
---------------------------------------------------
→ [Оригинал](https://scrimba.com/p/p7P5Hd/cvDkySN)
Работой над библиотекой React занимается немало программистов в Facebook, вклад в проект делают и члены многочисленного сообщества, сложившегося вокруг React. Всё это ведёт к тому, что React очень быстро развивается. Например, если вы, изучая React в начале 2019 года, смотрели материалы по этой библиотеке, скажем, двухгодичной давности, вы не могли не заметить изменений, произошедших в React с момента выхода тех материалов. Например, в React 16.3 появились некоторые новые методы жизненного цикла компонентов, а некоторые методы были признаны устаревшими. А, скажем, в React 16.6 появилось ещё больше новых возможностей. Огромное количество новшеств ожидается в React 17.0 и в следующих версиях этой библиотеки.
Сейчас мы поговорим о некоторых современных возможностях React.
Многие из этих возможностей зависят от того, какая версия спецификации ECMAScript поддерживается инструментами, используемыми при разработке React-проекта. Скажем, если вы пользуетесь транспилятором Babel — это означает, что вам доступны самые свежие возможности JavaScript. При этом надо отметить, что при использовании в проектах неких возможностей JavaScript, ещё не включённых в стандарт, вы можете столкнуться с тем, что они, если будут включены в стандарт, могут измениться.
Одной из современных возможностей JavaScript, которой можно пользоваться при разработке React-приложений, является возможность объявления методов классов с использованием синтаксиса стрелочных функций.
Вот код компонента `App`, который выводит на экран текстовое поле:
```
import React, {Component} from "react"
class App extends Component {
// Перепишем с использованием свойств класса
constructor() {
super()
this.state = {
firstName: ""
}
this.handleChange = this.handleChange.bind(this)
}
// Перепишем в виде стрелочной функции
handleChange(event) {
const { name, value } = event.target
this.setState({
[name]: value
})
}
render() {
return (
{this.state.firstName}
======================
)
}
}
export default App
```
Вот как выглядит страница этого приложения в браузере.
*Приложение в браузере*
Перепишем метод `handleChange()` в виде стрелочной функции, приведя код компонента к следующему виду:
```
import React, {Component} from "react"
class App extends Component {
// Перепишем с использованием свойств класса
constructor() {
super()
this.state = {
firstName: ""
}
}
// Переписано в виде стрелочной функции
handleChange = (event) => {
const { name, value } = event.target
this.setState({
[name]: value
})
}
render() {
return (
{this.state.firstName}
======================
)
}
}
export default App
```
В ходе такого преобразования в код внесены небольшие изменения, но эти изменения оказывают серьёзное влияние на то, как будет работать метод. Ключевое слово `this` в стрелочных функциях указывает на лексическую область видимости, в которой они находятся. Эти функции не поддерживают привязку `this`. Эта особенность стрелочных функций ведёт к тому, что методы, объявленных с их использованием, не нужно привязывать к `this` в конструкторе класса.
Ещё одна возможность, которую мы тут рассмотрим, заключается в использовании свойств классов. Сейчас мы, при инициализации состояния в конструкторе, пользуемся инструкцией `this.state`. Так мы создаём свойство экземпляра класса. Теперь же свойства можно создавать за пределами конструктора. В результате можно преобразовать код следующим образом:
```
import React, {Component} from "react"
class App extends Component {
// Переписано с использованием свойств класса
state = { firstName: "" }
// Переписано в виде стрелочной функции
handleChange = (event) => {
const { name, value } = event.target
this.setState({
[name]: value
})
}
render() {
return (
{this.state.firstName}
======================
)
}
}
export default App
```
Обратите внимание на то, что тут мы избавились от конструктора, инициализировав состояние при объявлении соответствующего свойства. [Всё](https://github.com/tc39/proposal-class-fields) указывает на то, что эта возможность JS будет, в обозримом будущем, включена в стандарт.
Вот список материалов, посвящённых современным возможностям React.
* [API Context](https://reactjs.org/docs/context.html). Его можно использовать вместо Redux, хотя это не говорит о том, что библиотека Redux потеряла актуальность.
* [Границы ошибок](https://reactjs.org/docs/error-boundaries.html).
* [Шаблон Render props](https://reactjs.org/docs/render-props.html).
* [Компоненты высшего порядка](https://reactjs.org/docs/higher-order-components.html).
* [Маршрутизатор React](https://reacttraining.com/react-router/core/guides/philosophy).
* [Хуки React](https://reactjs.org/docs/hooks-intro.html).
* [Новые возможности React 16.6](https://reactjs.org/blog/2018/10/23/react-v-16-6.html).
В целом можно отметить, что, так как React развивается очень быстро, всем, кто занимается React-разработкой, рекомендуется постоянно наблюдать за новшествами этой [библиотеки](https://reactjs.org/).
Занятие 47. Идеи React-проектов
-------------------------------
→ [Оригинал](https://scrimba.com/p/p7P5Hd/cdL88Sz)
В ходе освоения React мы с вами создали пару проектов — Todo-приложение и генератор мемов. Вполне возможно, что вы уже знаете — что хотите создать с использованием React. Может быть, вы уже разрабатываете собственное приложение. Если же вы пока не определились с выбором, и учитывая то, что практика — это лучший способ осваивать компьютерные технологии — [вот](https://medium.freecodecamp.org/every-time-you-build-a-to-do-list-app-a-puppy-dies-505b54637a5d), [вот](https://medium.freecodecamp.org/want-to-build-something-fun-heres-a-list-of-sample-web-app-ideas-b991bce0ed9a) и [вот](https://medium.freecodecamp.org/summer-is-over-you-should-be-coding-heres-yet-another-list-of-exciting-ideas-to-build-a95d7704d36d) — материалы, в которых вы найдёте целую кучу идей веб-приложений, которые можно создать с помощью React.
Занятие 48. Заключение
----------------------
→ [Оригинал](https://scrimba.com/p/p7P5Hd/czqvNAZ)
Примите поздравления! Вы только что завершили изучение курса, посвящённого библиотеке React. Вы ознакомились с базовыми строительными блоками React-приложений, которые вы уже можете использовать для создания собственных проектов. Правда, если вы хотите создавать что-то с использованием React, будьте готовы к тому, что вам предстоит узнать ещё очень много нового.
Пройдёмся по основным концепциям, которые вы изучили в ходе освоения этого курса.
* JSX. JSX позволяет описывать пользовательские интерфейсы с применением синтаксиса, очень похожего на обычный HTML-код.
* Два подхода к разработке компонентов. Компоненты, основанные на классах и функциональные компоненты.
* Разные способы стилизации React-приложений.
* Передача свойств от родительских компонентов дочерним компонентам.
* Использование состояния компонентов для хранения данных и для работы с ними.
* Условный рендеринг.
* Работа с формами в React.
Благодарим за внимание!
**Уважаемые читатели!** Просим вас поделиться впечатлениями от этого курса и рассказать нам о том, что вы хотите разработать (или уже разрабатываете) с использованием React.
[](https://ruvds.com/turbo_vps/) | https://habr.com/ru/post/447134/ | null | ru | null |
# Дурим DPI двумя скриптами
Данная статья является лиш исследованием на тему и не должна использоваться как инструкция к действию.
В связи с разгулом банхамера по интернет просторам участились советы по использованию различных прокси, vpn, tor и анонимайзеров. Эти все способы отправляют трафик третей стороне которая его может перехватывать и модифицировать. Это не наш метод. Мы сейчас просто и легко научим браузер дурить DPI.
Я вдохновился [этой статьёй](https://habrahabr.ru/post/192046/) и сообразил относительно лёгкий способ ходить на сайты прямо не используя чужие прокси, дополнения и программы.
> я осуществил необратимые манипуляции с доменным именем таким образом, чтобы не существовало ни одного достоверного и однозначного алгоритма обращения получившейся хеш-функции.
**Исходные данные:**
Сайт(Адрес изменён): `http://rutracker.og`
Страница заглушка(Адрес изменён): `http://198.51.100.0/...`
Адрес страницы заглушки которая появляется при попытке открытия сайта. У каждого провайдера адрес страницы заглушки наверно разный.
**Итак открываем блокнот и пишем первый скрипт:**
```
function FindProxyForURL(url, host) {
if (shExpMatch(url, "http://*") && shExpMatch(host, "rutracker.og")) {
return "HTTPS rutracker.og.; PROXY rutracker.og; DIRECT";
}
return "DIRECT";
}
```
Сохраняем как «proxy.pac»
Суть этого скрипта в том чтобы использовать как прокси сам сервер к которому мы и хотим получить доступ.
**Подключаем «proxy.pac» в Chrome:**
1. Настройки -> Показать дополнительные настройки ->
Сеть -> Изменить настройки прокси-сервера ->
Вкладка «Поключения» -> Настройка сети
2. Ставим галочку «Использовать сценарий автоматической настройки»
3. В поле адрес пишем полный путь к «proxy.pac»
Например: C:\Users\name\Documents\proxy.pac
Теперь страница заглушка будет появляется через раз.
**Снова открываем блокнот и пишем:**
```
// ==UserScript==
// @name BackUserJS
// @description Window History Back Script
// @author ivan386
// @license MIT
// @version 1.0
// @include http://198.51.100.0/*
// @run-at document_start
// @grant none
// ==/UserScript==
(function (window) {
var w;
w = window;
if (w.self != w.top) {
return;
}
if (/http:\/\/198.51.100.0/.test(w.location.href)) {
w.history.back()
}
})(window);
```
Сохраняем как «back.user.js» в папку «back»
Этот скрипт возвращает нас на страницу где мы можем снова кликнуть ссылку.
**И опять открываем Блокнот и пишем:**
```
{
"manifest_version": 2,
"content_scripts" : [
{
"js":[ "back.user.js" ],
"matches":[ "http://198.51.100.0/*" ],
"run_at":"document_start"
}
],
"description" : "Window History Back Script",
"name" : "BackUserJS",
"version" : "1.0.0"
}
```
Сохраняем как «manifest.json» в папку «back»
**Теперь добавим в Chrome как Расширение:**
1. Дополнительные инструменты -> Расширения
2. Ставим галочку «Режим разработчика»
3. Нажимаем «Загрузить распакованное расширение...»
4. Находим папку «back» в которую сохраняли «back.user.js» и «manifest.json» и нажимаем ОК
**Проверяем:**
1. Перезагружаем Chrome
2. Нажимаем «Отмена» в окошке «Отключить расширения в режиме разработчика» справа.
3. Пишем в адресную строку адрес сайта и нажимаем Enter.
4. ???
5. PROFIT
**Использованные материалы:**
[Изучаем deep packet inspection у RETN](https://habrahabr.ru/post/192046/)
[Proxy Auto Configuration (PAC)](https://habrahabr.ru/sandbox/19972/)
[Учимся писать userscript'ы](https://habrahabr.ru/post/129343/)
[Userscripts. Упаковываем юзерскрипт для Chrome](https://habrahabr.ru/post/130436/)
**Продолжение:**
[Через фильтрующий прокси при помощи скрипта во имя Луны](https://habrahabr.ru/post/276623/) | https://habr.com/ru/post/276141/ | null | ru | null |
# Быстрый поиск касательных и пересечений у выпуклых многоугольников
Я недавно сделал маленькую [библиотеку](https://github.com/ilyanikolaevsky/navmesh) для решения задачи поиска кратчайшего пути на 2D карте с выпуклыми препятствиями. В процессе реализации я придумал пару алгоритмов и трюков, описания которых я нигде не встречал. Поэтому делюсь этими "изобретениями" с общественностью.
Горжусь тем, что мое решение работает очень быстро. Для внушительного количества полигонов все операции можно выполнять каждый кадр. Т.е. не надо ничего запекать и вся геометрия карты может меняться в каждом кадре.
Касательные
-----------
Некоторые читатели могут возмутиться, что к полигонам, как недифференцируемым кривым, касательных нет. Но тут я использую термин не из матанализа с таким же названием. В моем случае касательная к полигону — это прямая, пересекающая его ровно в одной точке, или проходящая через сторону.
Откуда вообще эти касательные берутся? Несложными рассуждениями можно доказать, что все кратчайшие пути на карте с выпуклыми полигонами-препятствиями состоят из отрезков прямых, которые или совпадают со стороной одного из препятствия, или обоими концами являются или концом пути или касаются какого-то полигона.
**Доказательство**
Доказательство от противного. Допустим в кратчайшем пути какая-то часть не является прямым отрезком, или является прямым отрезком, не совпадающим со стороной полигона и один из его концов не является концом пути или касательной. У кривой всегда можно чуть-чуть срезать "угол". Ведь эта кривая не может идти по границе полигона, который состоит из прямых отрезков. Противоречие с тем, что путь кратчайший. Далее будем считать, что путь состоит из прямых отрезков.
Если же отрезок просто висит концом в пространстве или лежит на границе полигона, но не является касательной к нему, то можно этот конец чуть чуть подвинуть чтобы выпрямить угол со следующим отрезком, сократив тем самым путь. Опять противоречие.
Единственные случаи, когда мы не можем сократить путь слегка подвинув границу отрезка пути — это если отрезок уже совпадает со стороной полигона или касается его.
Все случаи выше показаны на картинке. Красным показан какой-то путь, пунктиром — сокращенный путь.
Из наблюдения выше получается следующий алгоритм построения кратчайшего пути по карте: Для всех вершин полигонов и внешних точек (возможные начала и концы путей) нужно построить касательные ко всем полигонам. Оставить только те, которые касаются обоих полигонов. Добавить к этому все границы полигонов и отрезки между внешними точками. Потом выкинуть все отрезки, которые пересекаются с каким-то препятствием. Построить граф где эти отрезки — это ребра. Найти в нем кратчайший путь.
#### Наивный алгоритм
Самый простой метод построить касательные из точки — это перебрать все вершины полигона и найти те, где обе стороны лежат по одну сторону от прямой точка-вершина. Понять. что стороны лежат по одну сторону можно проверив знаки векторных произведений векторов сторон (v1, v2) и вектора из точки (v):
 
Получается что-то вроде такого:
```
// |p| хранит вершины полигона в порядке обхода против часовой стрелки.
// Класс Point используется для хранения точек или векторов.
// Оператор ^ переопределен для векторного произведения.
// Оператор - переопределен для векторной разности
std::pair Polygon::GetTangentIds(const Point &a) {
int n = p.size();
std::pair res = { -1, -1 };
for (int i = 0; i < n; ++i) {
if (p[i] == a) {
res = { i, i };
break;
}
Point v1 = p[i] - p[(i + n - 1) % n];
Point v = p[i] - a;
Point v2 = p[(i + 1) % n] - p[i];
double dir1 = v1 ^ v;
double dir2 = v ^ v2;
if (dir1 < eps && dir2 < -eps) {
res.first = i;
}
if (dir1 > eps && dir2 > -eps) {
res.second = i;
}
}
return res;
}
```
Обратите внимание на сравнения с `eps` — так правильно сравнивать вещественные числа, чтобы ошибки округления не ломали алгоритм. Плюс или минус выбираются в зависимости от строгости сравнения. `< -eps` — это значит строго меньше 0, `< eps` — значит меньше равно. Знаки расставлены в коде выше так, чтобы выбрать самую удаленную вершину, если точка `a` лежит на продолжении стороны.
Этот метод работает за `O(n)`. Можно отдельно рассмотреть случай вершины номер 0 и номер `n-1`, чтобы избавиться от модуля.
#### Быстрый логарифмический алгоритм
Раз уж точки уже упорядочены в порядке обхода, то тут явно напрашивается применение бинарного или хотя бы [троичного](https://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%BE%D0%B8%D1%87%D0%BD%D1%8B%D0%B9_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA) поиска. Искать сразу две далекие точки одним алгоритмом не получится, поэтому будем запускать наш логарифмический поиск два раза — для левой и правой касательной.
Еще одна проблема — очень сложно даже думать о каком-то упорядоченном поиске в зацикленном контейнере. Поэтому разорвем наш полигон в первой вершине. Просто проверим, вдруг она является искомым концом касательной. Если нет, то можно забыть про сторону между последней и первой вершиной и не думать о зацикленности полигона.
Если взять произвольную сторону полигона, то можно понять, лежит ли она на "лицевой" или обратной стороне полигона. Похожим методом считается освещенность граней в компьютерной графике — достаточно посмотреть на скалярное произведение нормали к стороне и вектора из вершины. Но можно не считать нормали, а брать векторное произведение с вектором-стороной:
 
Если вектор-сторона идет слева направо относительно вектора на начало стороны, то это — лицевая сторона. В противном случае — это обратная сторона. Концы касательных — это вершины между "лицевыми" и "обратными" сторонами.
Уже можно было бы запустить бинарный поиск, если бы мы точно знали, что одна граница отрезка лежит на лицевой стороне, а другая — на обратной. Но их такие еще найти надо. Тут можно воспользоваться еще одним наблюдением — вершины внутри одной стороны строго упорядочены: лицевая сторона идет слева направо, а обратная сторона — справа налево. Если у нас есть две вершины на лицевой стороне (или обе на обратной), то мы можем легко понять, лежат ли концы касательных между них: Надо только посмотреть, лежит ли последняя вершина раньше первой в порядке вершин:
Если обе вершины на обратной стороне, то переключение между обратной и лицевой стороной происходит между ними (в порядке обхода) только если вторая вершина "перескочила" лицевую сторону и оказалась раньше первой вершины отрезка. Аналогичное правило действует для двух вершин на лицевой стороне.
Давайте для конкретики введем "знаки" у вершин. Все вершины, сторона из которых идет справа налево относительно вектора из точки начала касательных, обозначим как "+" вершины — в них значение векторного произведения будет положительно. Все точки, сторона из которых лежит на лицевой стороне или идет слева направо относительно начала касательных, обозначим "-" — в них значение векторного произведения отрицательно.
Есть еще один неприятный случай: некоторые вершины могут иметь нулевое векторное произведение, если касательная совпадает со стороной (обозначим такие вершины "0"-вершинами). Еще более странные случаи, если точка-начало касательных лежит на стороне полигона, или вообще совпадает с вершиной. Ниже приведены все возможные случаи расположения начала касательных и "знаки" вершин:
1. Касательные не совпадают ни с одной стороной.
2. Левая касательная совпадает со стороной.
3. Точка лежит на пересечении двух сторон.
4. Правая касательная совпадает со стороной.
5. Точка лежит на стороне.
6. Точка совпадает с вершиной.
7. Точка внутри полигона.
Нули могут быть с обоих концов от отрезка из плюсов, минусов может и не быть. Одно точно видно — плюсы есть всегда. Поэтому давайте в качестве левой касательной брать "0/-" вершину, перед которой идет "+" вершина, а в качестве правой касательной — "+" вершину, перед которой идет "0/-" вершина. Этот подход из нескольких возможных концов (при совпадении стороны и касательной) найдет самую далекую. Если же нужен самый близкий конец, то можно после выполнения логарифмического алгоритма попытаться подвинуть левый конец вперед вдоль полигона, а правый — назад. Еще, последний случай (точка внутри полигона) немного все портит. В полигоне ничего кроме "+" нет. И мы никогда не найдем границу между двумя областями. Надо аккуратно проверить, что наш поиск не повисает в этом случае и не выдает какие-то неправильные ответы.
Итак, алгоритм для левой касательной:
```
1. Проверить, вдруг самая первая вершина удовлетворяет условию касательной. Если это не так, то мы знаем, что переключение между "+" и "0/-" происходит (если оно вообще есть) где-то между вершинами с 0 по n-1.
2. l=0, r=n-1.
4. Пока r-l > 1:
4.1. Подсчитать "знак" вершины l.
4.2. Взять m: ceil((l+r)/2). Обратите внимание, условие 4. означает, что l < m < r.
4.3. Подсчитать знак вершины m.
4.4. Присвоить r = m, если выполняется один из трех случаев:
l - "+" и m - "-/0"
l - "+" и m - "+" и l лежит левее m
l - "-/0" и m - "/0" и l лежит правее m (или на одной прямой с ней)
4.5. Иначе присвоить l = m.
```
Есть один нетривиальный момент, что делать, если l и m имеют одни и те же знаки лежат на одной прямой с точкой начала касательных? Т.е. вершина l не лежит ни строго левее ни строго правее m?
Это возможно только в случаях 2, 3, 6 — когда левая касательная совпадает со стороной. Если правая касательная совпадает со стороной, то знаки у вершин будут разные (дальняя — всегда +). При этом l и m указывают на 2 соседние вершины! Но, поскольку у нас поддерживается l < m, мы же разорвали цикл и ищем внутри не зацикленного массива, то это значит, что l — тот самый искомый конец касательной. Т.е. в случае, если обе вершины имеют знаки "-/0" и лежат на одной прямой, мы должны сдвинуть правый конец. Поэтому в пункте 4.4 сравнения надо делать именно так, если знаки совпадают во втором случае.
Для поиска правой касательной строгость сравнения должна быть в обратную сторону. Если обе вершины "-/0" и они лежат на одной прямой, то надо сдвинуть левую границу.
Итак, весь код алгоритма:
**Код**
```
std::pair Polygon::GetTangentIdsLogarithmic(const Point& a) const
{
std::pair res = { -1, -1 };
const int n = points\_.size();
Point vl = points\_[1] - points\_[0];
Point to\_l = points\_[0] - a;
Point v\_prev = points\_[0] - points\_[n - 1];
Point to\_prev = points\_[n - 1] - a;
double pointing\_l = to\_l ^ vl;
double pointing\_prev = to\_prev ^ v\_prev;
int l = 0;
int r = n - 1;
// Проверка, что вершина 0 - левая касательная.
if (pointing\_prev > eps && pointing\_l < eps) {
res.first = 0;
// Случай совпадения касательной и стороны
if (pointing\_l > -eps) {
Point v\_next = points\_[2] - points\_[1];
Point to\_next = points\_[1] - a;
double pointing\_next = to\_next ^ v\_next;
// точка начала еще может лежать на стороне
if (pointing\_next < -eps) {
res.first = 1;
}
else if (pointing\_next < eps) {
// Или совпадать с вершиной 1.
return { 1, 1 };
}
}
}
else {
// Бинарный поиск.
while (l < r - 1) {
int m = (r + l + 1) / 2;
Point vm = points\_[m + 1] - points\_[m];
Point to\_m = points\_[m] - a;
double pointing\_m = to\_m ^ vm;
double lm\_dir = to\_l ^ to\_m;
if (((pointing\_m < eps) || (lm\_dir < -eps)) &&
((pointing\_l > eps) || (lm\_dir > -eps))) {
r = m;
}
else {
l = m;
to\_l = to\_m;
pointing\_l = pointing\_m;
}
}
// На случай, если |a| лежит внутри полигона, надо проверить, что бинпоиск
// остановился на ответе, а не просто на случайной вершине.
int next = (r + 1) % n;
Point to\_r = points\_[r] - a;
Point vr = points\_[next] - points\_[r];
double pointing\_r = to\_r ^ vr;
if (pointing\_r < eps && pointing\_l > eps) {
res.first = r;
// Проверка, что |a| лежит на продолжении стороны.
Point v\_next = points\_[(next + 1) % n] - points\_[next];
Point to\_next = points\_[next] - a;
double pointing\_next = to\_next ^ v\_next;
if (pointing\_r > -eps) {
// Проверка, что |a| не лежит на стороне.
if (pointing\_next < -eps) {
res.first = next;
}
else if (pointing\_next < eps) {
// Или совпадает с вершиной.
return { next, next };
}
}
}
else return { -1, -1 };
}
// Теперь работаем с правой касательной.
vl = points\_[1] - points\_[0];
to\_l = points\_[0] - a;
v\_prev = points\_[0] - points\_[n - 1];
to\_prev = points\_[n - 1] - a;
pointing\_l = to\_l ^ vl;
pointing\_prev = to\_prev ^ v\_prev;
l = 0;
r = n - 1;
// Проверка первой вершины
if (pointing\_prev < eps && pointing\_l > eps) {
res.second = 0;
// Может ее надо подвинуть назад.
if (res.first != n - 1 && pointing\_prev > -eps) {
res.second = n - 1;
}
}
else {
while (l < r - 1) {
int m = (r + l + 1) / 2;
Point vm = points\_[m + 1] - points\_[m];
Point to\_m = points\_[m] - a;
double pointing\_m = to\_m ^ vm;
double lm\_dir = to\_l ^ to\_m;
if (((pointing\_l < eps) || (lm\_dir < eps)) &&
((pointing\_m > eps) || (lm\_dir > eps))) {
r = m;
}
else {
l = m;
to\_l = to\_m;
pointing\_l = pointing\_m;
}
}
// Проверка, что бинпоиск остановился на ответе.
Point to\_r = points\_[r] - a;
Point vr = points\_[(r + 1) % n] - points\_[r];
double pointing\_r = to\_r ^ vr;
if (pointing\_r > eps && pointing\_l < eps) {
res.second = r;
// Проверка, что ответ нужно подвинуть назад.
if ((res.first != l) && pointing\_l > -eps) {
res.second = l;
}
}
}
return res;
}
```
Несмотря на длинный и, возможно, пугающий код, этот алгоритм работает быстрее наивного уже при n=4.
#### Проверка пересечения отрезка и полигона за O(1)
\**terms and conditions apply.*
Следующий трюк, которым я хотел поделиться — это как пересекать отрезок и полигон за константу, при выполнении некоторых допущений. Во-первых, ни один конец отрезка не лежит внутри полигона, и, во-вторых, касательные уже должны быть известны. В противном случае, можно за логарифм построить касательные и проверить, что концы отрезка не лежат внутри полигона. Это дало бы логарифмический алогритм проверки на пересечение.
Оба этих допущения выполняются в моей библиотеке поиска кратчайшего пути вокруг препятствий. Возможных отрезков, которые нужно проверять на пересечение — `O(k*n^2)`, если у нас n полигонов с k вершинами. Когда как точек, из которых они торчат — всего `O(k*n)`. Поэтому гораздо быстрее сначала проверить все точки-концы отрезков по одному разу и вычеркнуть все отрезки из плохих точек. Второе допущение выполняется, потому что все касательные на все полигоны мы и так строим — это же и есть кандидаты на ребра в графе кратчайших путей. Для проверки на пересечения они достаются бесплатно.
Итак, нам даны полигон, отрезок с концами вне полигона и касательные из одного конца отрезка. Если отрезок пересекает полигон, то он точно должен пересекать и хорду между двумя концами касательных (иначе один из его концов должен был бы лежать внутри полигона). Т.е. получается, что нужно проверить пересечение лишь с одним отрезком, а это можно [сделать](https://e-maxx.ru/algo/segments_intersection_checking) за O(1). | https://habr.com/ru/post/527714/ | null | ru | null |
# Безопасность в мобильных приложениях
Информационная безопасность это всегда гонка вооружений. Из чего следует одна простая мысль, что полная безопасность невозможна, особенно в случае с клиентскими приложениями, когда у злоумышленника есть физический доступ к устройству. Но тут как при убегании от медведя: необязательно бежать быстрее медведя, достаточно бежать быстрее соседа.
Главная идея заключается в том, чтобы сломать вас было дороже получения возможной выгоды. Нужно донести до потенциального хакера одну простую мысль, «ломать нас невыгодно, иди поищи счастья в другом месте». Поэтому одной из основных критических ошибок являются крики о том что ваша защита совершенна. На подобные заявления сразу сбегается куча высоко профессиональных хакеров, которые будут ломать вашу защиту просто для доказательства своей крутизны невзирая на любую возможную выгоду.
Одним из основных столпов хорошей защиты, является журналирование действий и мониторинг всех нестандартных событий. Тяжело выстраивать защиту, если вы даже не знаете что вас ломают и каков вектор угрозы. Тут многое специфично для ваших процессов, но в качестве примеров могу привести использование большого количества разных аккаунтов с одного устройства; попытки обратиться к API к которому у аккаунта не должно быть доступа; многочасовые сессии в случаях, когда среднее время измеряется в минутах; нестандартные сбои и так далее.
### Базовые методики защиты
Они не защитят от продвинутых ребят, но прикручиваются быстро и выбрасывают всех script-kiddie которые просто скачали утилиты из интернета и не особо понимают что делают.
#### Root
В природе есть много разных методик обнаружения рута. Одним из самых простых является проверка подписи прошивки или попытка достучаться до суперпользователя:
```
private fun checkForBuildTags(): Boolean {
val tags = Build.TAGS
return tags != null && tags.contains("test-keys")
}
private fun checkForSuperUserAvailability(): Boolean {
return SUPER_USER_PATHS.any { File(it).exists() }
}
```
Также очень популярным методом получения рута является [Magisk](https://topjohnwu.github.io/Magisk/). Обнаружение само по себе является той еще игрой в кошки мышки: находят один способ, потом разработчики его патчат, находят другой, его патчат и так далее. Самой свежей методикой обнаружения является использование [изолированного процесса](https://github.com/topjohnwu/Magisk/issues/2406).
#### Emulator
Для обнаружения запуска на эмуляторе можно проверять разные поля из класса [Build](https://developer.android.com/reference/android/os/Build). Большинство возвращаемых данных постоянны и одинаковы для подавляющего большинства эмуляторов:
```
private fun checkSystemIsEmulator(): Boolean {
return (Build.BRAND.startsWith(EMULATOR_BRAND) && Build.DEVICE.startsWith(EMULATOR_DEVICE))
|| EMULATOR_FINGERPRINTS.any { Build.FINGERPRINT.contains(it) }
|| EMULATOR_HARDWARES.any { Build.HARDWARE.contains(it) }
}
```
Также практически не меняется эмулируемая среда: сеть, данные с датчиков и так далее.
#### Xposed
Один из самых популярных инструментов для изучения приложений. Принцип работы достаточно простой: хукается основной процесс Zygote, что позволяет перехватить вызов любой функции и прочитать/подменить ответ. Есть много методик обнаружения такой атаки, например проверка stackTrace:
```
private fun checkForXposedStackTrace(): Boolean {
val stackTrace = RuntimeException().stackTrace
for (trace in stackTrace) {
val className = trace.className
if (className?.contains("de.robv.android.xposed.XposedBridge") == true) {
return true
}
}
return false
}
```
#### Проверка имени установщика приложения
Имя можно получить через
```
context.packageManager.getInstallerPackageName(securityConfig.applicationId)
```
Если вернуло null, то в 99% случаев это означает что приложение установлено вручную и скорее всего взломано. Имена основных сторов:
```
private val appStoresPackages = hashMapOf(
"com.android.vending" to "Play Store",
"com.sec.android.app.samsungapps" to "Samsung Galaxy Apps",
"com.lge.lgworld" to "LG Smart World",
"com.huawei.appmarket" to "Huawei App Gallery",
"com.amazon.venezia" to "Amazon App Store",
"cm.aptoide.pt" to "Aptoide",
"net.appcake" to "AC Market",
"com.slideme.sam.manager" to "Slide Me",
"com.uptodown" to "Uptodown"
)
```
### Продвинутые методики защиты
Эти методики не спасут от профессионального специалиста по реверс-инжинирингу. От такого вообще ничего не защитит, поэтому лучше не держать на клиентских приложениях ничего сверх того что необходимо для работоспособности этого приложения. Зато они доставят достаточно много проблем, чтобы злоумышленники еще раз задумались, а надо ли это им.
#### Проверки на клонирование/пересборку приложения:
Можно проверить путь установки приложения, в большинстве случаев при клонировании приложение устанавливается по нестандартному пути:
```
context.filesDir.path
```
и/или проверить подпись
```
return context.packageManager.getPackageInfo(
context.packageName,
PackageManager.GET_SIGNATURES
).signatures.firstOrNull()
```
#### Safety net
[Проверка Android-устройства](https://developer.android.com/training/safetynet/attestation) возвращает следующий ответ:
```
{
"timestampMs": 9860437986543,
"nonce": "R2Rra24fVm5xa2Mg",
"apkPackageName": "com.package.name.of.requesting.app",
"apkCertificateDigestSha256": ["base64 encoded, SHA-256 hash of the
certificate used to sign requesting app"],
"ctsProfileMatch": true,
"basicIntegrity": true,
"evaluationType": "BASIC",
}
```
basicIntegrity - базовые проверки надежности устройства;
ctsProfileMatch - Более строгая проверка, прохождение которой означает что профиль устройства соответствует сертифицированному Google
#### SSL pinning
Эта проверка означает что мы не доверяем базовым сертификатам устройства, а доверяем только тому сертификату который нам известен. В случае okHttp3(стандарт сетевой библиотеки в большинстве приложений) проверка включается так:
```
val pinnerBuilder: CertificatePinner.Builder = Builder()
for (domain in domains) {
for (certificate in certificates) {
pinnerBuilder.add(domain, "sha256/$certificate")
}
}
builder.certificatePinner(pinnerBuilder.build())
```
#### Обфускация
Стандартным подходом в индустрии является Proguard. Для дополнительной защиты можно использовать собственный словарь с символами иностранного языка(китайский и арабский особенно хороши). Также существует проблема, при которой строковые литералы не обфусцируются. Решается платным обфускатором [DexGuard](https://www.guardsquare.com/dexguard), также на GitHub есть библиотеки не настолько качественные, зато бесплатные, например [paranoid](https://github.com/MichaelRocks/paranoid).
#### Шифрование
Шифрование всех важных данных — очень хорошее препятствие для обратного инжиниринга. Отличным вариантом алгоритма шифрации будет [AES-256](https://ru.wikipedia.org/wiki/AES_(%D1%81%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F))
```
object AES256 {
private const val ITERATION_COUNT = //степень двойки
private const val KEY_LENGTH = 256
private const val CIPHER_ALGORITHM = "AES"
private const val CIPHER_TRANSFORMATION = "AES/CBC/PKCS5Padding"
fun encrypt(key: String, salt: String, textToEncrypt: String, iv: ByteArray): String {
val ivSpec = IvParameterSpec(iv)
val secretKey = buildSecretKey(key, salt)
val cipher = Cipher.getInstance(CIPHER_TRANSFORMATION)
cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivSpec)
val encrypted = cipher.doFinal(textToEncrypt.toByteArray())
return String(Base64.encode(encrypted, Base64.DEFAULT), Charsets.UTF_8)
}
fun decrypt(key: String, salt: String, encryptedText: String, iv: ByteArray): String {
val ivSpec = IvParameterSpec(iv)
val secretKey = buildSecretKey(key, salt)
val cipher = Cipher.getInstance(CIPHER_TRANSFORMATION)
cipher.init(Cipher.DECRYPT_MODE, secretKey, ivSpec)
val encryptedArray = Base64.decode(encryptedText, Base64.DEFAULT)
val decryptedArray = cipher.doFinal(encryptedArray)
return String(decryptedArray, Charsets.UTF_8)
}
private fun buildSecretKey(key: String, salt: String): SecretKey {
val generator = PKCS5S2ParametersGenerator(SHA256Digest())
generator.init(key.toByteArray(), salt.toByteArray(), ITERATION_COUNT)
val keyArray = (generator.generateDerivedParameters(KEY_LENGTH) as KeyParameter).key
return SecretKeySpec(keyArray, CIPHER_ALGORITHM)
}
}
```
Единственное, что нужно продумать, это ротацию ключей. В идеале это будет отдельный ключ на каждую сессию, но это очень сложно и дорого поддерживать, поэтому подбирайте баланс в зависимости от доступных ресурсов и требуемого уровня безопасности.
#### JNI
Также очень интересным вариантом является перенос критической логики в нативный код. Отреверсить код на C намного тяжелее, чем это сделать с APK. Но так же как и с шифрованием это довольно дорого поддерживать, поэтому стоит продумать баланс в зависимости от доступных ресурсов и требуемого уровня безопасности.
---
Если вас заинтересовала тема безопасности в мобильных приложениях, то есть прекрасное руководство от [OWASP](https://mobile-security.gitbook.io/mobile-security-testing-guide/) с которого можно начать своё путешествие в кроличью нору. | https://habr.com/ru/post/567370/ | null | ru | null |
# Инструментарий для анализа и отладки .NET приложений
Заглянуть «под капот» кода или посмотреть на внутреннее устройство CLR можно с помощью множества инструментов. Этот пост родился из [твита](https://twitter.com/matthewwarren/status/973940550473797633), и я должен поблагодарить всех, кто помог составить список подходящих инструментов. Если я пропустил какие-то из них, напишите в комментариях.
Во-первых, я должен упомянуть, что [хороший отладчик уже присутствует в Visual Studio](https://msdn.microsoft.com/en-us/library/sc65sadd.aspx?f=255&MSPPError=-2147217396) и [VSCode](https://code.visualstudio.com/docs/editor/debugging). Также существует множество хороших (коммерческих) [профилировщиков .NET](https://stackoverflow.com/questions/3927/what-are-some-good-net-profilers) и [инструментов мониторинга приложений](https://www.quora.com/What-is-the-best-NET-Application-Server-Monitoring-Tool), на которые стоит взглянуть. Например, недавно я попробовал поработать с [Codetrack](http://www.getcodetrack.com/) и был впечатлён его возможностями.
Однако оставшийся пост посвящён **инструментам для выполнения отдельных задач**, которые позволят **лучше понять**, что происходит. Все инструменты имеют **открытый исходный код**.
### [PerfView](https://github.com/Microsoft/perfview) от [Вэнса Моррисона](https://blogs.msdn.microsoft.com/vancem/)
PerfView – великолепный инструмент, который я использую уже несколько лет. Он работает на основе [трассировки событий Windows](https://msdn.microsoft.com/en-us/library/windows/desktop/bb968803(v=vs.85).aspx?f=255&MSPPError=-2147217396) (ETW) и позволяет лучше понять, что происходит внутри CLR, а также даёт возможность получить профиль использования памяти и центрального процессора. Чтобы освоить инструмент, придётся впитать много информации, например с помощью [обучающих видео](https://channel9.msdn.com/Series/PerfView-Tutorial), но это стоит потраченного времени и усилий.
Инструмент настолько полезен, что сами инженеры Microsoft используют его, а многие из недавних [улучшений производительности в MSBuild](https://blogs.msdn.microsoft.com/dotnet/2018/02/02/net-core-2-1-roadmap/#user-content-build-time-performance) появились после [анализа узких мест](https://github.com/Microsoft/msbuild/search?q=PerfView&type=Issues) с помощью PerfView.
Инструмент создан на базе библиотеки [Microsoft.Diagnostics.Tracing.TraceEvent library](https://www.nuget.org/packages/Microsoft.Diagnostics.Tracing.TraceEvent/), которую можно использовать для создания собственных инструментов. Кроме того, поскольку исходный код библиотеки является открытым, в ней благодаря сообществу появилось множество полезных функций, например [графики flame-graphs](https://github.com/Microsoft/perfview/pull/502):
### [SharpLab](https://sharplab.io/) от [Андрея Щёкина](https://twitter.com/ashmind)
SharpLab появился как инструмент для проверки IL-кода, генерируемого компилятором Roslyn, и со временем превратился [в нечто большее](https://github.com/ashmind/SharpLab):
> SharpLab – интерактивная среда для запуска кода .NET, в которой отображаются промежуточные шаги и результаты компиляции кода. Некоторые функции языка – всего лишь обёртки для других, например using() становится try/catch. С помощью SharpLab вы увидите код, как его видит компилятор и лучше поймёте суть языков .NET.
Инструмент поддерживает C#, Visual Basic и F#, но самыми интересными функциями в нём являются Decompilation/Disassembly:
Функции декомпиляции/дизассемблирования можно использовать для:
1. C#
2. Visual Basic
3. IL
4. JIT Asm (нативный Asm Code)
Вы правильно поняли: инструмент выводит [код ассемблера](https://sharplab.io/#v2:EYLgZgpghgLgrgJwgZwLQBEJinANjASQDsYIFsBjCAgWwAdcIaITYBLAeyIBoYQpkNAD4ABAAwACEQEYA3AFgAUCIDMUgEwSAwhIDeSiYalqRAFgkBZABQBKPQaOOAblAQTSyGBIC8EgKwAdGIKio6OMgCcVh4wNiGOAL5KCUA==), который .NET JIT генерирует из вашего кода C#:
### [Object Layout Inspector](https://github.com/SergeyTeplyakov/ObjectLayoutInspector) от [Сергея Теплякова](https://twitter.com/STeplyakov)
С помощью этого инструмента вы сможете проанализировать структуру .NET объектов в памяти, т.е. как JITter расположил поля, принадлежащие вашему классу или структуре. Это полезно при написании высокопроизводительного кода. Кроме того, приятно иметь инструмент, который сделает сложную работу за нас.
Официальной документации, которая бы описывала структуру полей, не существует, поскольку авторы CLR оставили за собой право изменить её в будущем. Но знания о структуре могут быть полезны, если вы работаете над быстродействующим приложением.
Как можно изучить структуру? Можно посмотреть на необработанную память в Visual Studio или использовать команду `!dumpobj` в [SOS Debugging Extension](https://docs.microsoft.com/en-us/dotnet/framework/tools/sos-dll-sos-debugging-extension). Оба подхода требуют много усилий, поэтому мы создадим инструмент, который будет выводить структуру объекта во время выполнения.
Согласно примеру в репозитории GitHub, если вы используете `TypeLayout.Print()` с подобным кодом:
```
public struct NotAlignedStruct
{
public byte m_byte1;
public int m_int;
public byte m_byte2;
public short m_short;
}
```
появится следующий вывод, который точно покажет, как CLR расположит struct в памяти на основании правил оптимизации и заполнения байтами.
```
Size: 12. Paddings: 4 (%33 of empty space)
|================================|
| 0: Byte m_byte1 (1 byte) |
|--------------------------------|
| 1-3: padding (3 bytes) |
|--------------------------------|
| 4-7: Int32 m_int (4 bytes) |
|--------------------------------|
| 8: Byte m_byte2 (1 byte) |
|--------------------------------|
| 9: padding (1 byte) |
|--------------------------------|
| 10-11: Int16 m_short (2 bytes) |
|================================|
```
### [The Ultimate .NET Experiment (TUNE)](http://tooslowexception.com/the-ultimate-net-experiment-project/) от [Конрада Кокосы](https://twitter.com/konradkokosa)
Как сказано [на странице GitHub](https://github.com/kkokosa/Tune), TUNE – многообещающий инструмент. Он поможет изучить внутреннее устройство .NET и способы повышения производительности с помощью экспериментов с кодом C#.
Подробную информацию о нём можно узнать из [этого поста](http://tooslowexception.com/the-ultimate-net-experiment-project/), но на высоком уровне он функционирует [следующим образом](https://github.com/kkokosa/Tune):
* напишите работающий пример кода на C#, который содержит хотя бы один класс с публичным методом, принимающим один строковый параметр. Код запускается с помощью кнопки Run. Вы можете включить любое количество методов и классов. Но помните, что первый публичный метод из первого публичного класса будет выполнен с использованием первого параметра из окна ввода под кодом;
* нажмите кнопку Run, чтобы скомпилировать и выполнить код. Кроме того, он будет компилирован в IL-код и код ассемблера в соответствующих вкладках;
* пока Tune работает (в том числе во время выполнения кода), инструмент строит график, отображающий данные сборщика мусора. Он содержит информацию о размерах поколений и сеансах сбора мусора (представлены в виде вертикальных линий с числом внизу, которое указывает на то, в каком поколении выполняется сборка мусора).
Выглядит это следующим образом:
Инструменты на базе CLR Memory Diagnostics (ClrMD)
--------------------------------------------------
Наконец, давайте взглянем на определённую категорию инструментов. С момента выхода .NET разработчики всегда могли использовать [WinDBG](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/getting-started-with-windbg) и [SOS Debugging Extension](https://docs.microsoft.com/en-us/dotnet/framework/tools/sos-dll-sos-debugging-extension), чтобы посмотреть, что происходит в среде выполнения .NET. Однако, это не самые простые инструменты для первого знакомства и, как сказано в следующем твите, не всегда самые продуктивные:
> Very true. While hardcore windbg/sos skills are impressive, teaching them to novices without outlining the easier, less threatening alternatives is harmful. <https://t.co/jQanX9LVtz>
>
> — Omer Raviv (@omerraviv) [March 14, 2018](https://twitter.com/omerraviv/status/973923339906486272?ref_src=twsrc%5Etfw)
К счастью, Microsoft сделал доступной библиотеку [ClrMD](https://mattwarren.org/2016/09/06/Analysing-.NET-Memory-Dumps-with-CLR-MD/) (также известную, как [Microsoft.Diagnostics.Runtime](https://www.nuget.org/packages/Microsoft.Diagnostics.Runtime)), и теперь любой может создать инструмент для анализа дампов памяти программ .NET. Подробную информацию можно прочитать [в официальном блоге](https://blogs.msdn.microsoft.com/dotnet/2013/05/01/net-crash-dump-and-live-process-inspection/). Я также рекомендую взглянуть на [ClrMD.Extensions](https://github.com/JeffCyr/ClrMD.Extensions), которые *“… обеспечивают интеграцию с LINPad и делают использование ClrMD ещё проще”*.
Я хотел собрать список всех существующих инструментов и призвал на помощь [твиттер](https://twitter.com/matthewwarren/status/973940550473797633). Напоминалочка самому себе: осторожнее с твитами. Менеджер, ответственный за WinDBG, может прочитать их и расстроиться!
> Lazy web, I'm trying to put together a list of tools that help you debug .NET internals, specifically ones that replace the functionality you can find in WinDBG. Are there any I've missed out? <https://t.co/sg0RY0xVUH> [pic.twitter.com/XBYuSLSL2y](https://t.co/XBYuSLSL2y)
>
> — Matt Warren (@matthewwarren) [March 14, 2018](https://twitter.com/matthewwarren/status/973940550473797633?ref_src=twsrc%5Etfw)
Большинство этих инструментов работают на базе ClrMD, потому что так проще всего. Но при желании можно использовать [COM-интерфейсы напрямую](https://twitter.com/goldshtn/status/973941389791809540). Также нужно заметить, что любой инструмент на базе ClrMD **не является кроссплатформенным**, поскольку сама ClrMD предназначена только для Windows. Описание кроссплатформенных вариантов можно найти в [Analyzing a .NET Core Core Dump on Linux](http://blogs.microsoft.co.il/sasha/2017/02/26/analyzing-a-net-core-core-dump-on-linux/).
Наконец, чтобы как-то соблюсти баланс, недавно появилась [улучшенная версия WinDBG](https://blogs.msdn.microsoft.com/windbg/2017/08/28/new-windbg-available-in-preview/), которой сразу же попытались добавить функциональность:
* [Extending the new WinDbg, Part 1 – Buttons and commands](http://labs.criteo.com/2017/09/extending-new-windbg-part-1-buttons-commands/)
* [Extending the new WinDbg, Part 2 – Tool windows and command output](http://labs.criteo.com/2018/01/extending-new-windbg-part-2-tool-windows-command-output/)
* [Extending the new WinDbg, Part 3 – Embedding a C# interpreter](http://labs.criteo.com/2018/05/extending-new-windbg-part-3-embedding-c-interpreter/)
* [WinDBG extension + UI tool extensions](https://github.com/chrisnas/DebuggingExtensions) и ещё [здесь](https://github.com/kevingosse/windbg-extensions)
* [NetExt](https://github.com/rodneyviana/netext) – приложение WinDBG, которое [облегчает отладку в .NET](https://blogs.msdn.microsoft.com/rodneyviana/2015/03/10/getting-started-with-netext/) по сравнению с текущими опциями: sos или psscor. Также см. [эту статью InfoQ](https://www.infoq.com/news/2013/11/netext).
**После всех этих слов переходим к списку:**
* [SuperDump](https://www.slideshare.net/ChristophNeumller/large-scale-crash-dump-analysis-with-superdump) ([GitHub](https://github.com/Dynatrace/superdump))
+ Средство для автоматического анализа аварийного дампа ([презентация](https://www.slideshare.net/ChristophNeumller/large-scale-crash-dump-analysis-with-superdump))
* [msos](https://github.com/goldshtn/msos/wiki) ([GitHub](https://github.com/goldshtn/msos))
+ Среда с интерфейсом командной строки типа WinDbg для выполнения SOS-команд при отсутствии SOS.
* [MemoScope.Net](https://github.com/fremag/MemoScope.Net/wiki) ([GitHub](https://github.com/fremag/MemoScope.Net))
+ Инструмент для анализа памяти процесса в .NET. Можно сделать дамп памяти приложения в файл и прочитать его позже.
+ Файл содержит все данные (объекты) и информацию о тредах (состояние, стек, стек вызовов). MemoScope.Net проанализирует данные и поможет найти утечки памяти и взаимные блокировки.
* [dnSpy](https://github.com/0xd4d/dnSpy#dnspy) ([GitHub](https://github.com/0xd4d/dnSpy))
+ Отладчик и редактор сборок .NET
+ Его можно использовать для редактирования и отладки сборок, даже если у вас нет исходного кода.
* [MemAnalyzer](https://aloiskraus.wordpress.com/2017/08/17/memanalyzer-v2-5-released/) ([GitHub](https://github.com/Alois-xx/MemAnalyzer))
+ Инструмент анализа памяти для управляемого кода. Присутствует интерфейс командной строки.
+ Подобно `!DumpHeap` в Windbg может определить, какие объекты занимают больше всего места в куче без необходимости устанавливать отладчик.
* [DumpMiner](https://mycodingplace.wordpress.com/2016/11/24/dumpminer-ui-tool-for-playing-with-clrmd/) ([GitHub](https://github.com/dudikeleti/DumpMiner))
+ Инструмент с графическим интерфейсом для работы с ClrMD. Больше возможностей [появится в будущем](https://twitter.com/dudi_ke/status/973930633935409153).
* [Trace CLI](http://devops.lol/tracecli-a-production-debugging-and-tracing-tool/) ([GitHub](https://github.com/ruurdk/TraceCLI/))
+ Инструмент для отладки и отслеживания во время эксплуатации
* [Shed](https://github.com/enkomio/shed) ([GitHub](https://github.com/enkomio/shed))
+ Shed – приложение, которое анализирует выполнение программы в .NET. Его можно использовать для анализа вредоносного ПО, чтобы получить данные о том, какая информация сохраняется, при запуске такого ПО. Shed может:
+ извлекать все объекты, хранящиеся в управляемой куче;
+ выводить строки, хранящиеся в памяти;
+ создавать моментальный снимок кучи в формате JSON для последующей обработки;
+ делать дамп всех модулей, загруженных в память.
Вы можете найти множество других инструментов, [которые используют ClrMD](https://github.com/search?p=2&q=CLRMD&type=Repositories&utf8=✓). Сделать её доступной было хорошей идеей Microsoft.
Другие инструменты
------------------
Стоит упомянуть и другие инструменты:
* [DebugDiag](https://support.microsoft.com/en-gb/help/2895198/debug-diagnostics-tool-v2-0-is-now-available)
+ Инструмент DebugDiag создан для устранения таких проблем, как зависания, низкая производительность, утечки памяти или её фрагментация, а также отказы процессов, выполняющихся в пользовательском режиме (теперь с интеграцией CLRMD).
* [SOSEX](http://www.stevestechspot.com/SOSEXANewDebuggingExtensionForManagedCode.aspx) (возможно больше не разрабатывается)
+ … расширение для отладки управляемого кода, которое снижает моё недовольство SOS.
* [VMMap](https://docs.microsoft.com/en-us/sysinternals/downloads/vmmap) от Sysinternals
+ VMMap – средство для анализа виртуальной и физической памяти процессов.
+ Я применял его, чтобы проанализировать [использование памяти в CLR](https://mattwarren.org/2017/07/10/Memory-Usage-Inside-the-CLR/)
[](https://habr.com/ru/company/clrium/blog/465081/) | https://habr.com/ru/post/463305/ | null | ru | null |
# Использование нейронных сетей для поиска ответов в таблицах
Большая часть информации в мире хранится в виде таблиц, которые можно найти в Интернете или в базах данных и документах. В таблицах может находиться всё что угодно, от технических характеристик потребительских товаров до финансовой статистики и данных экономического развития страны, спортивных результатов и многого другого. Для того, чтобы найти ответ, сейчас необходимо вручную просматривать эти таблицы или полагаться на специальную службу, которая дает ответы на конкретные вопросы (например, о спортивных результатах). Однако эта информация была бы намного более доступной и полезной, если бы ее можно было запрашивать на естественном языке.
Например, на следующем рисунке показана таблица с рядом вопросов, которые люди могут задать. Ответ на эти вопросы может быть найден в одной или нескольких ячейках таблицы («*У какого рестлера было больше всего побед?*» — «*Which wrestler had the most number of reigns?*»), или может потребоваться объединение нескольких ячеек таблицы («*Сколько чемпионов мира имеют только одну победу?*» — «\*How many world champions are there with only one reign?»).
*Таблица и вопросы с ожидаемыми ответами. Ответы можно выбрать напрямую из таблицы (#1, #4) или вычислить на основе данных таблицы (#2, #3).*
[Многие](https://www.aclweb.org/anthology/P15-1142/) [недавние](https://www.aclweb.org/anthology/P18-1034/) [подходы](https://www.aclweb.org/anthology/N19-1273) для этой задачи применяют традиционный [семантический парсинг](https://en.wikipedia.org/wiki/Semantic_parsing), когда вопрос на естественном языке переводится в [SQL](https://en.wikipedia.org/wiki/SQL)-подобный запрос к базе данных, который затем исполняется для предоставления ответов. Например, вопрос: «Сколько чемпионов мира имеют только одну победу?» будет сопоставлен с таким запросом, как «`select count(*) where column("No. of reigns") == 1;`», а затем исполнен для получения ответа. Этот подход часто требует серьезной инженерии для генерации синтаксически и семантически корректных запросов, и его трудно масштабировать до произвольных вопросов, а не вопросов об очень конкретных таблицах (например, о спортивных результатах).
В статье «[TAPAS: Weakly Supervised Table Parsing via Pre-training](https://arxiv.org/abs/2004.02349)», принятой на [ACL 2020](https://acl2020.org/), авторы используют другой подход, расширяющий архитектуру [BERT](https://ai.googleblog.com/2018/11/open-sourcing-bert-state-of-art-pre.html) для кодирования вопроса вместе с табличной структурой данных, в результате чего получается модель, которая затем может указывать прямо на ответ. Вместо создания модели, работающей только с одним типом таблицы, этот подход позволяет создавать модели, применимые к таблицам из широкого диапазона доменов. Авторы показали, что после предварительного обучения на миллионах таблиц Википедии модель демонстрирует конкурентоспособную точность (accuracy) на трех наборах данных академических таблиц с [ответами на вопросы](https://en.wikipedia.org/wiki/Question_answering) (QA). Кроме того, чтобы способствовать более интересным исследованиям в этой области, авторы предоставили открытый исходный код для обучения и тестирования моделей, а также сами модели, предварительно обученные на таблицах Википедии, в своем [репозитории на GitHub](https://github.com/google-research/tapas).
Как обработать вопрос
=====================
Чтобы обработать такой вопрос, как «*Среднее время пребывания в титуле чемпиона для двух лучших рестлеров?*», модель совместно кодирует вопрос, а также содержимое таблицы строка за строкой, используя модель BERT, расширенную за счет специальных эмбеддингов для кодирования структуры таблицы.
Ключевым дополнением к модели BERT на основе архитектуры Трансформер являются дополнительные эмбеддинги, которые используются для кодирования структурированного входа. Эти эмбеддинги кодируют индекс столбца, индекс строки и специальный порядковый индекс, указывающий на порядок элементов в числовых столбцах. На следующем изображении показано, как все это объединяется на входе и подается в слои Трансформера. Также на картинке показано, как закодирован вопрос вместе с небольшой таблицей, показанной слева. Каждый токен ячейки имеет специальный эмбеддинг, который указывает его строку, столбец и порядковый индекс в столбце.
*Входной слой BERT: каждый входной токен представлен как сумма эмбеддингов его слова, абсолютной позиции, сегмента (принадлежит ли он вопросу или таблице), столбца, строки и порядкового индекса (позиция, которую будет иметь ячейка, если столбец был отсортирован по числовым значениям).*
Модель имеет два выхода: 1) для каждой ячейки таблицы оценка указывает вероятность того, что эта ячейка будет частью ответа, и 2) операция агрегирования, которая указывает, какая операция (если она есть) применяется для получения окончательного ответа. На следующем рисунке показано, как для вопроса «*Среднее время в качестве чемпиона для двух лучших борцов?*» модель должна с высокой вероятностью выбрать первые две ячейки столбца «Объединенные дни» и операцию «СРЕДНЕЕ».
*Схема модели: слой BERT кодирует как вопрос, так и таблицу. Модель выводит вероятность для каждой операции агрегирования и вероятность выбора для каждой ячейки таблицы. На вопрос «Среднее время в качестве чемпиона для двух лучших борцов?» операция СРЕДНИЙ и ячейки с числами 3,749 и 3,103 должны иметь высокую вероятность.*
Предварительное обучение
========================
Используя метод, аналогичный тому, как BERT обучается на тексте, авторы предварительно обучили модель на 6.2 миллионах пар таблица-текст, извлеченных из английской Википедии. Во время предварительного обучения модель учится восстанавливать маскированные слова как в таблице, так и в тексте. Авторы обнаружили, что модель может сделать это с относительно высокой точностью (71.4% замаскированных токенов корректно восстанавливаются для невидимых во время обучения таблиц).
Учимся только на ответах
========================
Во время тонкой настройки модель учится отвечать на вопросы из таблицы. Это достигается путем «строгого» и «мягкого» обучения с учителем (strong and weak supervision). В случае «строгого» обучения для данной таблицы и вопросов необходимо предоставить ячейки и операцию агрегирования для выбора (например, сумма или количество), что является достаточно трудоемким процессом. Чаще всего модели обучаются с помощью «мягкого» обучения, когда дается только правильный ответ (например, 3426 на вопрос в приведенном выше примере). В этом случае модель пытается найти операцию агрегирования и ячейки, которые дают ответ, близкий к правильному. Это делается путем вычисления ожидания по всем возможным решениям агрегирования и сравнения его с истинным результатом. Сценарий «мягкого» обучения выгоден, потому что он позволяет неспециалистам предоставлять данные, необходимые для обучения модели, и занимает меньше времени, чем «строгое» обучение.
Полученные результаты
=====================
Авторы применили свою модель к трем наборам данных — [SQA](https://www.microsoft.com/en-us/download/details.aspx?id=54253), WikiTableQuestions ([WTQ](https://nlp.stanford.edu/blog/wikitablequestions-a-complex-real-world-question-understanding-dataset/)) и [WikiSQL](https://github.com/salesforce/WikiSQL) — и сравнили ее результаты с тремя самыми современными моделями (state-of-the-art, SOTA) для анализа табличных данных. Модели сравнения включали [Min et al (2019)](https://www.aclweb.org/anthology/D19-1284) для WikiSQL, [Wang et al. (2019)](https://www.aclweb.org/anthology/D19-1391) для WTQ и предыдущие работы самих авторов для SQA ([Mueller et al., 2019](https://www.aclweb.org/anthology/D19-1603)). Для всех наборов данных публикуются метрики точности (accuracy) на тестовых наборах для модели «мягкого» обучения. Для SQA и WIkiSQL использовалась базовая модель, предварительно обученная на Википедии, а для WTQ было решено предварительно дообучить модель на данных SQA. Лучшие модели авторов превосходят предыдущую SOTA для SQA более чем на 12 баллов, предыдущую SOTA для WTQ более чем на 4 балла и работают аналогично лучшей опубликованной модели на WikiSQL.
*Метрика точности (accuracy) ответов для «мягкого» обучения на трех академических наборах данных TableQA.*
Авторы
======
* **Автор оригинала** – Thomas Müller
* **Перевод** – [Смирнова Екатерина](https://habr.com/ru/users/smekur/)
* **Редактирование и вёрстка** – [Шкарин Сергей](https://habr.com/ru/users/kouki_rus/) | https://habr.com/ru/post/582248/ | null | ru | null |
# Разграничение информационных систем при защите персональных данных
Предмет данной статьи — разграничение информационных систем при защите персональных данных с помощью программы Киберсейф Межсетевой экран. В статье будет показан пример развертывания программы и разграничения доступа групп ПК в реальной компании.
#### Требования к защите информационных систем персональных данных
ИСПДн (Информационная система персональных данных) – информационная система, представляющая собой совокупность персональных данных, содержащихся в базе данных, а также информационных технологий и технических средств, позволяющих осуществлять обработку таких персональных данных с использованием средств автоматизации или без использования таких средств.
Согласно приказу ФСТЭК России №21 от 18 февраля 2013 г., для обеспечения 3 уровня защищенности персональных данных применяются (пункт 12б):
*межсетевые экраны не ниже 3 класса в случае актуальности угроз 2-го типа или взаимодействия информационной системы с информационнотелекоммуникационными сетями международного информационного обмена и межсетевые экраны не ниже 4 класса в случае актуальности угроз 3-го типа и отсутствия взаимодействия информационной системы с информационно-телекоммуникационными сетями международного информационного обмена;*
В этой статье будет рассмотрено практическое использование программы [Киберсейф Межсетевой экран](http://cybersafesoft.com/rus/products/cybersafe-firewall/), которая на данный момент сертифицирована по 4-ому уровню защищенности, однако в течение месяца будет сертифицирована по 3-ему уровню (сертификат уже находится на подписи в ФСТЭК). С соответствующим сертификатом можно ознакомиться на сайте компании [КиберСофт](http://cybersafesoft.com/rus/products/cybersafe-firewall/certificate/). Ссылка на государственный реестр сертифицированного ПО будет приведена в конце статьи.
#### Постановка задачи
Структура компании, в которой мы недавно внедряли программу Киберсейф Межсетевой экран, изображена на рис. 1.
Рис. 1. Структура компании
Рассматриваемая компания содержит пять отделов (Агроотдел, IT-отдел, юридический отдел, отдел управления, ИСПДн «Атлант ПД») и три филиала. Связь с удаленными филиалами осуществляется через Интернет. На шлюзе, как и на остальных компьютерах сети, установлена программа Киберсейф Межсетевой экран.
Далее в этой статье будет показано развертывание программы Киберсейф Межсетевой экран на все компьютеры сети с помощью Active Directory, а также настройка групповых правил.
Наша задача — оградить группу ИСПДн от внешнего мира (то есть закрыть ей доступ в Интернет) и от остальной локальной сети. Таким образом, компьютеры в ИСПДн смогут «общаться» только друг с другом. **Стоит отметить, что данный продукт был специально создан для максимально быстрого решения задач по ограничению доступа к группам ПК. В других продуктах решение поставленной задачи занимает гораздо больше времени или вообще невозможно (если используется система динамического распределения сетевых адресов). Если не учитывать время, необходимое на развертывание программы с помощью Active Directory, ограничить доступ одной группы компьютеров к другой вы сможете за считанные минуты.
Данная схема не претендует на оригинальность или новизну. Задача была сделать продукт максимально удобным для разграничения нескольких ИС или ограничить одну ИС с конфиденциальной информацией от других секторов локальной сети и интернет в строгом соответсвии с законодательством РФ.**
#### Создание файла трансформации
Первым делом нужно создать файл трансформации (MST-файл), чтобы была возможность выполнить развертывание Киберсейф Межсетевой экран на все компьютеры сети с одинаковыми настройками. После этого вам не придется вручную настраивать межсетевой экран, например, создавать пользователя для входа в программу, указывать IP-адрес удаленного сервера, его порт и т.д.
Установите программу на компьютер, который будет использоваться в качестве удаленного сервера Киберсейф Межсетевой экран, и который будет использоваться вами для управления межсетевыми экранами всей сети. Можете установить программу на свой собственный компьютер, а можете установить программу сразу на шлюз, который будет предоставлять остальным компьютерам доступ к Интернету.
Для создания сценария развертывания выполните следующие действия:
* Откройте программу Киберсейф Удаленный сервер (входит в состав пакета программ Киберсейф Межсетевой экран).
* Выберите команду меню **Инструменты, Установочный скрипт файл**.
* Заполните параметры, которые будут занесены в сценарий развертывания, а именно порт, на котором будет работать файрвол (обычно 50001), порт удаленного сервера, IP-адрес удаленного сервера, ключ активации, e-mail администратора, пользователь и пароль по умолчанию (рис. 2).
* Нажмите кнопку **Сохранить скрипт**.
* В окне сохранения файла выберите формат сценария — для развертывания с помощью Active Directory нужно выбрать формат \*.mst (рис. 3)
Рис. 2. Создание сценария развертывания
Рис. 3. Сохранение сценария развертывания
Подробно программа Киберсейф Удаленный сервер рассмотрена в руководстве по программе Киберсейф Межсетевой экран (http://cybersafesoft.com/rus/products/cybersafe-firewall/).
Если в вашей организации не используется Active Directory, то с помощью программы Киберсейф Удаленный сервер вы можете создать командный файл (\*.bat). Для развертывания программы на всех компьютерах сети достаточно будет скопировать его на каждый компьютер вместе с инсталлятором программы (MSI-файл) и запустить его (командный файл). Если же для каждого компьютера нужны уникальные пользователи, тогда можно на каждом компьютере вручную запустить инсталлятор программы (MSI-файл), при этом вам не нужны ни файл трансформации, ни командный файл.
#### Развертывание Киберсейф Межсетевой экран с помощью Active Directory
Теперь рассмотрим процесс развертывания программы Киберсейф Межсетевой экран с помощью ActiveDirectory. Все иллюстрации для этого раздела были созданы в Microsoft Windows Server 2012 R2, но все приведенные инструкции будут работать и в более старых версиях (Microsoft Windows Server 2003/2008), возможно, немного будут отличаться иллюстрации.
Первым делом нужно создать папку для развертывания программного обеспечения. Она будет содержать все MSI-пакеты, развертывания которых вам нужно выполнить (не нужно создавать отдельную папку для программы Киберсейф Межсетевой экран).
Пусть это будет папка C:\Install. В этой папке создайте подпапку CSFirewall. В нее нужно поместить установочный файл csfirewall.msi и файл трансформации csfirewall.mst, который вы создали в предыдущем разделе.
К папке C:\Install нужно предоставить общий доступ. Для этого щелкните правой кнопкой по папке и выберите команду **Свойства**. На вкладке **Доступ** нажмите кнопку **Общий доступ** и предоставьте доступ на чтение и запись администратору и доступ только на чтение всем остальным пользователям сети.
Далее запустите редактор групповой политики gpmc.msc. Мы предполагаем, что программу Киберсейф Межсетевой экран нужно установить на все компьютеры сети. Поэтому щелкните правой кнопкой мыши на домене и выберите команду **Создать объект** групповой политики в этом домене и связать его (рис. 4).
Рис. 4. Редактор групповой политики
Назовите новый объект групповой политики CS\_Firewall (рис. 5). В разделе **Фильтры безопасности** удалите группу **Прошедшие проверку** и добавьте компьютеры, группы и пользователей, к которым будут применены параметры данного объекта групповой политики (рис. 6). Другими словами добавьте компьютеры, на которые должна быть установлена программа.
Рис. 5. Создание нового объекта GPO
Рис. 6. Созданный объект GPO
Щелкните правой кнопкой мыши на только что созданном GPO (CS Firewall) и выберите команду **Изменить**. Перейдите в раздел **Конфигурация пользователя, Политики, Конфигурация программ, Установка программ** (рис. 7).
Рис. 7. Раздел Конфигурация пользователя, Политики, Конфигурация программ, Установка программ
Щелкните правой кнопкой на разделе **Установка программ** и выберите команду **Создать, Пакет**. В появившемся окне нужно выбрать путь к MSI-файлу программы. Обратите внимание, что вводить нужно не локальный путь, а сетевой, поскольку пользователи будут получать доступ к пакету по сети.
Следующий шаг — выбор метода развертывания. Поскольку мы хотим предоставить файл трансформации (mst-файл, созданный программой Киберсейф Удаленный сервер), то нужно выбрать особый метод развертывания (рис. 8). Благодаря этому будет открыто окно настройки пакета развертывания (рис. 9). Затем перейдите на вкладку **Модификации**, нажмите кнопку **Добавить** и выберите файл трансформации (.mst-файл), рис. 10.
Рис. 8. Выбор метода развертывания
Рис. 9. Настройка пакета развертывания
Рис. 10. Указываем файл трансформации
Нажмите кнопку **OK**.
**Примечание**. После нажатия кнопки **OK** пакет и файл трансформации (файлы .msi и .mst соответственно) будут прокэшированы. Если вам понадобится изменить файл трансформации после создания пакета, то придется создавать пакет развертывания заново.
На этом работа с редактором групповой политики завершена. Закройте все окна, откройте командую строку (или хотя бы окно **Выполнить**, нажав комбинацию клавиш Win + R) и введите команду:
```
gpupdate /force
```
На этом все. Программа будет автоматически установлена на компьютеры после их перезагрузки и до отображения окна входа в систему. Пользователь ни на что не может повлиять и ни в чем не может ошибиться.
Иногда программа не устанавливается автоматически. Чаще всего такая проблема наблюдается на рабочих станциях под управлением Windows XP. Чтобы произвести ее установку, нужно вручную ввести на ней команду gpupdate /force.
#### Настройка правил брандмауэра
Используя панель администрирования Киберсейф межсетевой экран, вы можете задать глобальные и групповые правила для всех межсетевых экранов Киберсейф, установленных в вашей сети. Глобальные правила распространяются на все компьютеры, на которых установлена программа Киберсейф межсетевой экран, а групповые правила определяют поведение программы Киберсейф межсетевой экран, установленной на определенной группе компьютеров.
Прежде, чем приступить к настройке глобальных и групповых правил, нужно назначить пользователя администратором. Сделать это можно только с помощью программы Киберсейф Удаленный сервер.
Администратор может с помощью панели администрирования управлять удаленным брандмауэром. Итак, в программе Киберсейф Удаленный сервер разверните узел **Пользователи** и выберите пользователя, которого вы хотите сделать администратором и включите переключатель **Администратор** (рис. 11).
Рис. 11. Назначение пользователя администратором
Теперь приступим к решению нашей задачи. Напомню, нам нужно запретить доступ компьютерам ИСПДн «Атлант» доступ к Интернету и к другим компьютерам сети.
Войдите в программу Киберсейф Межсетевой экран и выберите команду меню **Файрвол, Панель администрирования**.
Создайте различные группы компьютеров, которые будут соответствовать имеющимся в сети отделам (см. рис. 1). Для создания группы щелкните правой кнопкой мыши на рабочей области и выберите команду **Добавить группу**. А чтобы добавить в группу компьютер просто перетащите его пиктограмму на пиктограмму группы. Конечный результат приведен на рис. 12. Обязательно нажмите кнопку **Применить**, чтобы программа «запомнила» созданные группы.
Нужно отметить, что при изменении IP-адресов входящих в группу компьютеров состав созданной группы не изменится. Поэтому не стоит волноваться о составе группы в случае использования в вашей организации DHCP-сервера.
Рис. 12. Созданные группы
Выделите **ИСПДн «Атлант ПД»** и нажмите кнопку **Установить правила**. Так вы сможете установить групповые правила. Для установки глобальных правил нужно выделить узел **Все** и нажать кнопку **Установить правила**.
Итак, установим правила для группы **ИСПДн «Атлант ПД»**. В появившемся окне перейдите в раздел **Правила безопасности** и нажмите кнопку **Добавить** (рис. 13).
Рис. 13. Правила безопасности: пока не заданы
На вкладке **Общие** (рис. 14) задайте описание правила — «Запрет обмена данными с группой <Название группы>».
Установите тип правила — **Запретить пакеты**, выберите направление пакетов — **Для всех пакетов** и протокол — **Любой**.
Рис. 14. Вкладка **Общие**
В качестве источника укажите **ИСПДн «Атлант ПД»**, а в качестве получателя — одну из групп вашего предприятия, например, IT-отдел. Нажмите кнопку **OK**.
Что делает это правило? Оно запрещает компьютерам **ИСПДн «Атлант ПД»** передавать любые пакеты в группу IT-отдел. Даже если какой-то компьютер из группы IT-отдел попытается установить соединение с компьютером группы **ИСПДн «Атлант ПД»**, то компьютеры группы **ИСПДн «Атлант ПД»** все равно не смогут ответить ему, поскольку им это запрещает правило.
Рис. 15. Вкладка **Источник**
Рис. 16. Вкладка **Получатель**
Повторите описанную процедуру для остальных групп в вашей сети. У вас должен получиться набор правил, показанный на рис. 17.
Рис. 17. Созданные правила для группы ИСПДн «Атлант ПД»
Осталось запретить доступ к Интернету. Для этого достаточно запретить любой обмен данными со шлюзом. Для этого создадим еще одно правило безопасности для ИСПДн «Атлант ПД». На вкладке Общие установите параметры так:
1. Описание — Запрет доступа к Интернету
2. Тип правила — Запретить пакеты
3. Направление пакетов — Для всех пакетов
4. Протокол — Любой
На вкладке **Источник** выберите в качестве источника **ИСПДн «Атлант ПД»** (рис. 15). На вкладке **Получатель** установите IP-адрес сервера (внутренний), например, 192.168.1.1 (рис. 18).
Рис. 18. Запрет доступа к Интернету
Нажмите кнопку **OK**. По умолчанию все правила являются выключенными. Для их включения щелкните на каждом правиле правой кнопкой мыши и выберите команду **Включить**. Окончательный вариант правил показан на рис. 19. Обратите внимание на статус правила — **Включено**.
Рис. 19. Окончательный вариант правил
Закройте окно редактирования правил безопасности, а в окне **Панель администрирования** нажмите кнопку **Применить**, а затем закройте само окно.
#### Вывод
Поставленная задача решена и теперь компьютеры группы **ИСПДн «Атлант ПД»** не могут взаимодействовать с остальными компьютерами локальной сети и у них нет доступа к Интернету. Средствами программ Киберсейф Межсетевой экран информационная система персональных данных была полностью изолирована от остальной сети.
#### Ссылки
[ООО «КиберСофт»](http://cybersafesoft.com/rus/about/)
[Программа «Киберсейф Межсетевой экран»](http://cybersafesoft.com/rus/products/cybersafe-firewall/)
[Приказ ФСТЭК России №21](http://fstec.ru/normotvorcheskaya/akty/53-prikazy/691-prikaz-fstek-rossii-ot-18-fevralya-2013-g-n-21)
[Государственный реестр сертифицированных средств защиты информации](http://fstec.ru/tekhnicheskaya-zashchita-informatsii/dokumenty-po-sertifikatsii/153-sistema-sertifikatsii/591-gosudarstvennyj-reestr-sertifitsirovannykh-sredstv-zashchity-informatsii-n-ross-ru-0001-01bi00) | https://habr.com/ru/post/250127/ | null | ru | null |
# Swagger в Magento 2
Тенденция перехода от сборки HTML-страниц на стороне сервера к их сборке на стороне клиента уже даже не тенденция, а тренд. Magento 2, шагая в ногу со временем в меру своих возможностей, также пытается [быть в тренде](https://www.google.lv/webhp?sourceid=chrome-instant&ion=1&espv=2&ie=UTF-8#q=headless%20magento%202), разнося обработку данных и их представление. Как простому разработчику заглянуть в "чистые" данные, если их представление вынесено достаточно далеко? Есть множество других хороших решений (начиная c [tcpdump](https://ru.wikipedia.org/wiki/Tcpdump)), и есть [swagger](http://swagger.io/).
Swagger достаточно хорошо интегрирован в Magento 2 (если только вам в голову не пришла дурацкая затея изменить код для "default" витрины). Все, что нужно для того, чтобы начать разглядывать "чистые" данные в Magento 2 с точки зрения удаленного приложения — использовать интегрированный в нее Swagger. В данном материале я не рассматриваю особенности использования самого Swagger'а, а просто привожу пример того, как использовать Swagger, интегрированный в Magneto 2, в режиме анонимного пользователя и в режиме аутентифицированного пользователя.
Доступ к сервисам
=================
Я развернул [простой Magento-модуль](https://github.com/flancer32/sample_mage2_module) по адресу <http://module.sample.flancer32.com/>. Чтобы начать использовать Swagger в режиме анонимного пользователя нужно перейти по адресу <http://module.sample.flancer32.com/swagger> Сначала загружается само Swagger-приложение (быстро), а затем идет загрузка описания web-сервисов, реализованных в Magento (медленно):
JSON-схему сервисов Magento можно вытянуть и самому по ссылке: <http://module.sample.flancer32.com/rest/default/schema?services=all>
Анонимные запросы
=================
После разбора схемы Swagger формирует список сервисов, доступных анонимному клиенту:
и позволяет не только изучать в человекочитаемом виде сами сервисы:
… но и формировать запросы:
… и анализировать ответы:
Доступ к ограниченным сервисам
==============================
Для начала нужно сделать в Magento отдельного пользователя (использовать административную учетку для доступа к сервисам — не самая хорошая идея):
и назначить ей права доступа (User Roles):
Вернее, сначала делается роль, а потом, при создании, она назначается новому пользователю. Предоставлять все права через роль — тоже не самая хорошая идея, но ведь и я не идеален. Поэтому в нашем примере пользователю "swagger" назначена роль "Swagger", которой предоставлены права на доступ к любым ресурсам.
Аутентификация через web-интерфейс не предусмотрена, может быть когда-нибудь кто-нибудь и допилит этот момент в Magento 2, но пока что аутентифицироваться приходится вручную: через свой любимый универсальный REST API клиент, через программный код или через "curl":
```
curl -X POST "http://module.sample.flancer32.com/rest/V1/integration/admin/token" \
-H "Content-Type:application/json" \
-d '{"username":"swagger", "password":"0jul4san0lRLKjYQpCqx"}'
```
Все, что нужно сделать — отправить определенный JSON-текст с параметрами аутентификации на определенный адрес (не забыв про заголовок с типом содержимого запроса). В ответ придет сессионный код для доступа к ограниченным сервисам:
```
"f6j0arlp29vx8i3av9l3eu5sag2pb5qy"
```
Код придет в кавычках, но использовать его нужно без.
Ну вот, теперь, имея код, мы вводим его в соответствующее поле:
… и получаем доступ к уже более широкому списку сервисов. Например, к такому:
Дальнейшая работа с сервисами ничем не отличается от работы в режиме анонимного пользователя. Сессионный ключ для авторизации добавляется Swagger'ом автоматически:
Заключение
==========
Swagger — замечательный инструмент, замечательно интегрированный в замечательную платформу Magento 2. Разрабатывать web-сервисы с таким инструментарием — одно удовольствие. | https://habr.com/ru/post/317770/ | null | ru | null |
# Запускаем AssemblyScript в Go
Пока одни обсуждают [что не так с WebAssembly](https://habr.com/ru/company/ruvds/blog/539100/), я думаю как его можно использовать вне браузера. Например написание [wasm фильтров](https://www.envoyproxy.io/docs/envoy/v1.17.0/configuration/http/http_filters/wasm_filter#config-http-filters-wasm) для Envoy. AssemblyScript был взят потому, что это не C++ и не Rust, т.е. ожидается более низкий порог вхождения. Под катом будет дико примитивный код и пару бенчмарков. Картинка взята из бенчмарка.
Рантаймы доступные для Go
-------------------------
Более менее живые проекты которые имеют биндинги, для Go:
* [wasmer-go](https://github.com/wasmerio/wasmer-go);
* [wasmtime-go](https://pkg.go.dev/github.com/bytecodealliance/wasmtime-go);
* [go-wasm3](https://github.com/matiasinsaurralde/go-wasm3).
Изначально пробовал запустить [life](https://github.com/perlin-network/life), но столкнувшись с двумя багами в life и последним коммит от 2019 понял, что проект мертв. Повелся из-за возможности указать лимит на количество операций([gas metering](https://godoc.org/github.com/perlin-network/life/exec#VirtualMachine.RunWithGasLimit)). В wasmer [metering](https://docs.wasmer.io/ecosystem/wasmer/wasmer-features), но в wasmer-go пока недоступно.
Hello World!
------------
Если посмотреть примеры, то типичный hello world это:
```
extern {
fn sum(x: i32, y: i32) -> i32;
}
#[no_mangle]
pub extern fn add1(x: i32, y: i32) -> i32 {
unsafe { sum(x, y) + 1 }
}
```
Что делать, строк в MVP не завезли. Нам доступны только числовые типы [i32, i64, f32, f64](https://webassembly.github.io/spec/core/text/types.html). Посмотрим во что превратится этот код:
```
import {console} from "../../assemblyscript/go";
export function hello(): void{
console.log("Hello World!")
}
// go.ts
export declare namespace console {
export function log(s: string): void
}
```
```
(module
(type $none_=>_none (func))
(type $i32_=>_none (func (param i32)))
(import "go" "console.log" (func $../../assemblyscript/go/console.log (param i32)))
(memory $0 64)
(data (i32.const 4147212) ",\00\00\00\01\00\00\00\00\00\00\00\01\00\00\00\18\00\00\00H\00e\00l\00l\00o\00 \00W\00o\00r\00l\00d\00!")
(export "memory" (memory $0))
(export "hello" (func $hello/hello))
(func $hello/hello
i32.const 4147232
call $../../assemblyscript/go/console.log
)
)
```
Тип параметра `i32` говорит нам, что это указатель в линейной памяти. Что бы правильно прочитать строку, нужно обратиться в раздел [памяти](https://www.assemblyscript.org/memory.html#internals):
```
+----------+ size
| u16 +<----------+
+----------+
| u16 |
ptr +----------+
+----->+ H |
+----------+
| e |
+----------+
| l |
+----------+
```
Указатель ссылается на первый символ строки, по смещению -4 находится длина. В Go
нам придется написать:
```
var (
LE = binary.LittleEndian
)
const (
SizeOffset = -4
)
func ToString(memory *wasmer.Memory, ptr int64) string {
data := memory.Data()
len := LE.Uint32(data[ptr+SizeOffset:]) >> 1
buf := bytes.NewReader(data[ptr:])
tmp := make([]uint16, 0, len)
for i := uint32(0); i < len; i++ {
var j uint16
_ = binary.Read(buf, LE, &j)
tmp = append(tmp, j)
}
return string(utf16.Decode(tmp))
}
```
Теперь можно написать программу:
```
package main
import (
"flag"
"fmt"
"io/ioutil"
"time"
helpers "wasmer-go-assemblyscript"
"github.com/wasmerio/wasmer-go/wasmer"
)
var callCount int
func init() {
flag.IntVar(&callCount, "call", 1, "number of calls")
flag.Parse()
}
func main() {
var globalInstane *wasmer.Instance
wasmBytes, err := ioutil.ReadFile("examples/wasm/optimized.wasm")
if err != nil {
panic(err)
}
engine := wasmer.NewEngine()
store := wasmer.NewStore(engine)
module, err := wasmer.NewModule(store, wasmBytes)
if err != nil {
panic(fmt.Sprintln("failed to compile module:", err))
}
log := wasmer.NewFunction(store,
wasmer.NewFunctionType(wasmer.NewValueTypes(wasmer.I32), wasmer.NewValueTypes()),
func(args []wasmer.Value) ([]wasmer.Value, error) {
memory, err := globalInstane.Exports.GetMemory("memory")
if err != nil {
panic(fmt.Sprintln("failed get memory:", err))
}
return helpers.Log(memory, args)
},
)
importObject := wasmer.NewImportObject()
importObject.Register("go",
map[string]wasmer.IntoExtern{
"console.log": log,
})
fmt.Println("instantiating module...")
instance, err := wasmer.NewInstance(module, importObject)
if err != nil {
panic(fmt.Sprintln("failed to instantiate the module:", err))
}
globalInstane = instance
hello, err := instance.Exports.GetRawFunction("hello")
if err != nil {
panic(fmt.Sprintln("failed to get raw function:", err))
}
fmt.Println("Calling `hello` function...")
for i := 0; i < callCount; i++ {
ts := time.Now()
_, err = hello.Call()
fmt.Println("call duration", time.Since(ts))
if err != nil {
panic(fmt.Sprintln("Failed to call the `hello` function:", err))
}
}
}
//...
func Log(memory *wasmer.Memory, args []wasmer.Value) ([]wasmer.Value, error) {
ptr := int64(args[0].I32())
print(ToString(memory, ptr))
return nil, nil
}
```
Из непонятных моментов может показаться лишь:
```
log := wasmer.NewFunction(store,
wasmer.NewFunctionType(wasmer.NewValueTypes(wasmer.I32), wasmer.NewValueTypes())
```
Мы декларируем функцию с одним аргументов, которая ничего не возвращает. Запуск:
```
$ hello -call 5
instantiating module...
Calling `hello` function...
Hello World!call duration 20.721µs
Hello World!call duration 5.51µs
Hello World!call duration 4.9µs
Hello World!call duration 4.95µs
Hello World!call duration 4.77µs
```
Первый вызов очень дорогой, все последующие немного, но дешевле. Почему так происходит, можете почитать например у разработчика [WAVM](https://github.com/WAVM/WAVM/issues/300#issue-788667045).
Передача Go строк в AS
----------------------
Одних числовых типов недостаточно. Посмотрим как можно передать строки. В зависимости от [рантайма](https://www.assemblyscript.org/runtime.html) AS.
| Variant | Description |
| --- | --- |
| full | A proper memory manager and reference-counting based garbage collector, with runtime interfaces being exported to the host for being able to create managed objects externally. |
| half | The same as *full* but without any exports, i.e. where creating objects externally is not required. This allows the optimizer to eliminate parts of the runtime that are not needed. |
| stub | A minimalist arena memory manager without any means of freeing up memory again, but the same external interface as *full*. Useful for very short-lived programs or programs with hardly any memory footprint, while keeping the option to switch to *full* without any further changes. No garbage collection. |
| none | The same as *stub* but without any exports, for the same reasons as explained in *half*. Essentially evaporates entirely after optimizations. |
Нам будут доступны *\_\_new*, *\_\_renew*, *\_\_release* и т.д. которые можно использовать так:
```
//https://github.com/AssemblyScript/assemblyscript/blob/master/lib/loader/index.js#L122
function __newString(str) {
if (str == null) return 0;
const length = str.length;
const ptr = __new(length << 1, STRING_ID);
const U16 = new Uint16Array(memory.buffer);
for (var i = 0, p = ptr >>> 1; i < length; ++i) U16[p + i] = str.charCodeAt(i);
return ptr;
}
```
Мы пойдем другим путем, будим писать прямо в память. AS на этапе компиляции
позволяет зарезервировать *N* первых байт, указав `memoryBase` при компиляции. Не стал заморачиваться и написал простой хелпер:
```
func (s *SharedMemory) WriteString(str string) (ptr int64, err error) {
size := len(str) * 2
need := int(s.offset) + size
if need > s.size {
return 0, fmt.Errorf("need %d, available %d, all %d :%w",
need,
int64(s.size)-s.offset,
s.size,
ErrNotEnoughMemory)
}
data := utf16.Encode([]rune(str))
pair := make([]byte, 2)
ptr = s.offset<<32 | int64(size)
for _, rune := range data {
LE.PutUint16(pair, rune)
copy(s.mem[s.offset:], pair)
s.offset += 2
}
return
}
```
Для наглядности:
```
+-------------+-------------+
| | |
| 32bit | 32bit |
| | |
+-------------+-------------+
offset size
```
Распаковка в AS выглядит так:
```
export namespace Go {
export function toString(ptr: i64): string {
let len = ptr & 0xFFFFFFFF
ptr = ptr >>> 32
return String.UTF16.decodeUnsafe(ptr, len)
}
}
```
Итого:
```
handler, err := instance.Exports.GetRawFunction("say")
if err != nil {
panic(fmt.Sprintln("failed to get raw function:", err))
}
say := handler.Native()
fmt.Println("Calling `say` function...")
for i := 0; i < callCount; i++ {
ts := time.Now()
shm.Reset()
ptr, _ := shm.WriteString(fmt.Sprintf("%d: Hello World!", i))
_, err = say(ptr)
fmt.Println("call duration", time.Since(ts))
if err != nil {
panic(fmt.Sprintln("Failed to call the `say` function:", err))
}
}
```
```
export function say(ptr: i64): void{
console.log(Go.toString(ptr))
}
```
```
$ string_args -call 5
Compiling module...
instantiating module...
Calling `say` function...
0: Hello World!call duration 24.94µs
1: Hello World!call duration 6.18µs
2: Hello World!call duration 5.341µs
3: Hello World!call duration 5.11µs
4: Hello World!call duration 4.86µs
```
Стоимость вызова
----------------
Попробуем оценить стоимость вызова функции. Для сравнения взял:
```
export function empty(): void {
}
let cnt = 0
export function increment(): void{
cnt++
}
```
```
//static void emptyFunction() {
//
//}
import "C"
func EmptyCFunction() {
C.emptyFunction()
}
```
Получаем 1 микросекунду, что на порядок больше чем обычный вызов CGO:
```
BenchmarkIncr-12 1000000 1150 ns/op
BenchmarkEmptyFunction-12 981108 1140 ns/op
BenchmarkEmptyCFunction-12 36840853 31.8 ns/op
```
2048 оттенков серого
--------------------
Нужна была CPU Bound задача, что бы время выполнения перекрывала стоимость вызова. Взял пример с [сайта AS](https://www.assemblyscript.org/examples/mandelbrot.html#example) и запустил генерацию изображения 1920x1080.
```
/** Number of discrete color values on the JS side. */
const NUM_COLORS = 2048;
/** Updates the rectangle `width` x `height`. */
export function update(width: u32, height: u32, limit: u32): void {
let translateX = width * (1.0 / 1.6);
let translateY = height * (1.0 / 2.0);
let scale = 10.0 / min(3 * width, 4 * height);
let realOffset = translateX * scale;
let invLimit = 1.0 / limit;
let minIterations = min(8, limit);
for (let y: u32 = 0; y < height; ++y) {
let imaginary = (y - translateY) * scale;
let yOffset = (y * width) << 1;
for (let x: u32 = 0; x < width; ++x) {
let real = x * scale - realOffset;
// Iterate until either the escape radius or iteration limit is exceeded
let ix = 0.0, iy = 0.0, ixSq: f64, iySq: f64;
let iteration: u32 = 0;
while ((ixSq = ix * ix) + (iySq = iy * iy) <= 4.0) {
iy = 2.0 * ix * iy + imaginary;
ix = ixSq - iySq + real;
if (iteration >= limit) break;
++iteration;
}
// Do a few extra iterations for quick escapes to reduce error margin
while (iteration < minIterations) {
let ixNew = ix * ix - iy * iy + real;
iy = 2.0 * ix * iy + imaginary;
ix = ixNew;
++iteration;
}
// Iteration count is a discrete value in the range [0, limit] here, but we'd like it to be
// normalized in the range [0, 2047] so it maps to the gradient computed in JS.
// see also: http://linas.org/art-gallery/escape/escape.html
let colorIndex = NUM_COLORS - 1;
let distanceSq = ix * ix + iy * iy;
if (distanceSq > 1.0) {
let fraction = Math.log2(0.5 * Math.log(distanceSq));
colorIndex = ((NUM\_COLORS - 1) \* clamp((iteration + 1 - fraction) \* invLimit, 0.0, 1.0));
}
store(yOffset + (x << 1), colorIndex);
}
}
}
/\*\* Clamps a value between the given minimum and maximum. \*/
function clamp(value: T, minValue: T, maxValue: T): T {
return min(max(value, minValue), maxValue);
}
```
```
func min(a, b uint32) uint32 {
if a < b {
return a
}
return b
}
func fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
func fclam(value, minValue, maxValue float64) float64 {
return fmin(fmax(value, minValue), maxValue)
}
//go:noinline
func Naive(width, height, limit uint32, out []byte) {
translateX := float64(width) * (1.0 / 1.6)
translateY := float64(height) * (1.0 / 2.0)
scale := 10.0 / float64(min(3*width, 4*height))
realOffset := translateX * scale
invLimit := 1.0 / float64(limit)
minIterations := min(8, limit)
for y := uint32(0); y < height; y++ {
imaginary := (float64(y) - translateY) * scale
yOffset := (y * width) << 1
for x := uint32(0); x < width; x++ {
real := float64(x)*scale - realOffset
ix := 0.0
iy := 0.0
var ixSq, iySq float64
iteration := uint32(0)
for ixSq+iySq <= 4.0 {
iy = 2.0*ix*iy + imaginary
ix = ixSq - iySq + real
if iteration >= limit {
break
}
ixSq = ix * ix
iySq = iy * iy
iteration++
}
for iteration < minIterations {
ixNew := ix*ix - iy*iy + real
iy = 2.0*ix*iy + imaginary
ix = ixNew
iteration++
}
colorIndex := uint16(NumColors - 1)
distanceSq := ix*ix + iy*iy
if distanceSq > 1.0 {
fraction := math.Log2(0.5 * math.Log(distanceSq))
colorIndex = uint16((NumColors - 1) * fclam((float64(iteration)+1-fraction)*invLimit, 0.0, 1.0))
}
offset := yOffset + (x << 1)
out[offset] = byte(colorIndex & 0xFFFF)
out[offset+1] = byte(colorIndex >> 8)
}
}
}
```
Получили интересный результат:
```
BenchmarkNaive-12 7 146213621 ns/op 0 B/op 0 allocs/op
BenchmarkAssembly-12 8 135236607 ns/op 458 B/op 16 allocs/op
```
AS на 10 миллисекунд быстрее чем наивная версия на Go. Но тут выходит "гнутый", который выдает на Ryzen 3600 115 миллисекунд, что на 20 миллисекунд превосходит версию на AS, и на 30 миллисекунд превосходит стандартный компилятор:
```
$ go test -compiler=gccgo -gccgoflags='-O3 -march=native' -bench=.
goos: linux
goarch: amd64
pkg: wasmer-go-assemblyscript/examples/mandelbrot
BenchmarkNaive-12 9 115202147 ns/op
BenchmarkAssembly-12 8 136263914 ns/op
```
Стоит отметить потенциал WebAssembly в вычислительных задачах из-за поддержки [SIMD](https://github.com/WebAssembly/simd/), которая есть в [wasmer](https://medium.com/wasmer/webassembly-and-simd-13badb9bf1a8), [v8](https://v8.dev/features/simd) и в некоторых других рантаймах. В самом AS то же можно [воспользоваться](https://www.assemblyscript.org/environment.html#low-level-webassembly-operations).
Работает, но есть баги
----------------------
Может бага, а может by design. При попытке сделать простой cancellation token, вылезла паника:
```
go func() {
time.Sleep(time.Millisecond * 100)
memory, err := globalInstane.Exports.GetMemory("memory")
if err != nil {
panic(err)
}
fmt.Println("canceling")
binary.LittleEndian.PutUint64(memory.Data(), 1)
}()
infinityLoop := handler.Native()
_, err = infinityLoop()
```
```
function isCanceled(): boolean{
let register = load(0)
return register != 0
}
export function infinityLoop(): void{
let i = 0
while (!isCanceled()) {
i++
console.log("iteration:" + i.toString()+"\n")
}
}
```
```
iteration:13639
iteration:13640
iteration:13641
iteration:13642
iteration:13643
iteration:13644
panic: Host function `1` does not exist
goroutine 1 [running]:
github.com/wasmerio/wasmer-go/wasmer.function_trampoline(0xc0000123a0, 0x7ffca8ad78c8, 0x7ffca8ad78b0, 0x0)
/home/dmitry/GolangWorkspace/pkg/mod/github.com/wasmerio/wasmer-go@v1.0.0-beta2.0.20210113150733-ddc164edfd68/wasmer/function.go:96 +0x12c
github.com/wasmerio/wasmer-go/wasmer._cgoexpwrap_55cc7d6d4e49_function_trampoline(0xc0000123a0, 0x7ffca8ad78c8, 0x7ffca8ad78b0, 0x0)
_cgo_gotypes.go:1995 +0x74
github.com/wasmerio/wasmer-go/wasmer._Cfunc_wasm_func_call(0xed1250, 0xc0000123f0, 0xc0000123e0, 0x0)
_cgo_gotypes.go:967 +0x4e
github.com/wasmerio/wasmer-go/wasmer.(*Function).Native.func1.5(0xc00007a2d0, 0xc0000123f0, 0xc0000123e0, 0x5d6308)
/home/dmitry/GolangWorkspace/pkg/mod/github.com/wasmerio/wasmer-go@v1.0.0-beta2.0.20210113150733-ddc164edfd68/wasmer/function.go:225 +0xd1
github.com/wasmerio/wasmer-go/wasmer.(*Function).Native.func1(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
/home/dmitry/GolangWorkspace/pkg/mod/github.com/wasmerio/wasmer-go@v1.0.0-beta2.0.20210113150733-ddc164edfd68/wasmer/function.go:225 +0x414
main.main()
/home/dmitry/GolangWorkspace/src/wasmer-go-assemblyscript/examples/cancellation_token/main.go:85 +0x6ff
Process finished with exit code 2
```
Вот была хост функция и вот её не стало… По поведению где-то поработал сборщик мусора. Быстрым просмотром кода был найден это момент:
Действительно отрабатывает GC и запускает финалайзер. Спишем на бету версию, чиниться добавлением KeepAlive:
```
_, err = infinityLoop()
if err != nil {
panic(err)
}
runtime.KeepAlive(log)
```
Итоги
-----
Какое применение можно найти за пределами блокчейн:
* можно посмотреть, когда нужен скриптовой движок;
* система расширений, т.е. пойти путём Envoy. Удобно никаких тебе dll/so.
Все примеры доступны на [GitHub](https://github.com/RPG-18/wasmer-go-assemblyscript).
UPD
---
[@Max Graey](https://github.com/MaxGraey) предложил установить параметр shrinkLevel в 0, это улучшило скорость
вычисления логарифма.
Стандартный компилятор:
```
go test -bench=.
BenchmarkNaive-12 7 144082544 ns/op
BenchmarkAssembly-12 10 108193154 ns/op
```
GCCGO:
```
$ go test -compiler=gccgo -gccgoflags='-O3 -march=native' -bench=.
BenchmarkNaive-12 9 114458135 ns/op
BenchmarkAssembly-12 10 107687709 ns/op
``` | https://habr.com/ru/post/540472/ | null | ru | null |
# Объяснение легковесных потоков в 200 строк на Rust
Объяснение легковесных потоков в 200 строк на Rust
==================================================
Легковесные потоки (ligthweight threads, coroutines, корутины, green threads) являются очень мощным механизмом в современных языках программирования. В этой статье Carl Fredrik Samson попытался реализовать рантайм для легковесных потоков на Раст, попутно объясняя, как они устроены "под капотом".
Так же следует учесть, что статья не суперсвежая, так что для того, чтобы примеры заработали в современной ночной версии компилятора Раст, скорее всего понадобятся изменения, найти которые можно в [репозитории кода](https://github.com/cfsamson/example-greenthreads) для этой статьи.
> Переводил для себя большей частью. Обо всех замечаниях пишите — оперативно исправлю. Старался переводить близко к тексту, но в некоторых местах переформулировал, чтобы читалось легче и было понятнее.
Green Threads
-------------
Грин треды решают общую проблему в программировании — вам не хочется, чтобы ваш код блокировал процессор, растрачивая ресурсы. Решается это использованием многозадачности, которая позволяет приостановить выполнение одного участка кода, запуская на выполнение другой, переключаясь между "контекстами".
Легко спутать с параллелизмом, но не делайте этого — это две совершенно разные вещи. Параллелизм — это как забрасывание проблемы вычислительными ресурсами. Грин треды позволяют работать умнее и эффективнее, эффективнее расходовать ресурсы.
Два способа реализовать их:
* вытесняющая многозадачность
* невытесняющая (кооперативная) многозадачность
### Вытесняющая многозадачность
Некоторый внешний планировщик останавливает задачу и запускает другую перед тем, как переключиться обратно. В этом случае задача никак не может повлиять на ситуацию — решение принимается "чем-то" ещё (часто каким-либо планировщиком). Ядра используют это в операционных системах, например, позволяя в однопоточных системах вам использовать UI (User Interface — интерфейс пользователя) в то время, когда ЦПУ выполняет вычисления. Не будем останавливаться на этом типе многозадачности, но предполагаю, что поняв одну парадигму, вы без проблеме поймёте и вторую.
### Невытесняющая многозадачность
О ней и поговорим сегодня. Задача сама решает, что процессору лучше бы заняться чем-то ещё вместо того, чтобы ждать, когда в текущей задаче что-то случится. Обычно это выполняется с помощью передачи контроля (`yielding` control) планировщику. Нормальным юз-кейсом является передача контроля, когда что-то блокирует выполнение кода. Например, это могут быть операции ввода/вывода. Когда контроль уступили центральному планировщику напрямую, процессор возобновляет выполнение другой задачи, которая готова делать что-то ещё, кроме как блокировать.
Предварительная информация
--------------------------
Это самая техническая часть статьи, но если вы на самом деле хотите понимать происходящее, то просто обязаны пробраться сквозь её дебри. Обещаю сделать это быстро и по делу, как только возможно. Достаточно быстро перейдём к коду.
Перво-наперво, мы будем взаимодействовать и управлять процессором напрямую. Это не очень переносимо, т.к. видов процессоров целая прорва. Идея всё та же самая, но мелкие детали реализации отличаются.
Сосредоточимся на одной из самых широко используемых архитектур — x86-64. В этой архитектуре процессор снабжён набором из 16 регистров:
Если интересно, остальную часть спецификации можно найти [здесь](https://github.com/hjl-tools/x86-psABI/wiki/X86-psABI)
Вне нашего интереса прямо сейчас регистры, помеченные как "callee saved". Это регистры, которые хранят контекст — следующую инструкцию для выполнения, указатель на базу, указатель на верхушку стека и т.д. Рассмотрим их чуть позже подробнее.
Если хотим управлять процессором напрямую, то нам нужно совсем немного кода на ассемблере. К счастью, для этого нужно знать совсем немного инструкций. Вот как перемещать значения из одного регистра в другой:
```
mov %rsp, %rax
```
### Супербыстрое введение в ассемблер
В первую очередь. Язык ассемблера не слишком переносимый. Каждый ЦПУ может иметь специальный набор инструкций, однако некоторые (наборы инструкций) являются общими на большинстве десктопных машин.
Есть два популярных диалекта: AT&T и Интел.
Диалект AT&T является стандартным при использовании ассемблерных вставок на Rust. Но можно использовать и диалект от Интел, указав на это компилятору. По большей части Раст перекладывает работу с ассемблерными вставками на LLVM. Для LLVM он очень похож на синтаксис ассемблерных вставок Си, но не точно такой же.
В примерах будем использовать диалект AT&T.
Ассемблер имеет строгие гарантии обратной совместимости. Вот поэтому вы видите те же самые регистры, которые адресуют данные разными способами. Взглянем на регистр `%rax`, который мы использовали в примере выше:
```
%rax # 64 битный регистр (8 байт)
%eax # младшие 32 бита регистра "rax"
%ax # младшие 16 бит регистра "rax"
%ah # старшие 8 бит части "ax" регистра "rax"
%al # младшие 8 бит регистра "rax"
```
```
+-----------------------------------------------------------------------+
|76543210 76543210 76543210 76543210 76543210 76543210 76543210 76543210|
+--------+--------+--------+--------+--------+--------+--------+--------+
| | | | | | | %ah | %al |
+--------+--------+--------+--------+--------+--------+--------+--------+
| | | | | | | %ax |
+--------+--------+--------+--------+--------+--------+-----------------+
| | | | | %eax |
+--------+--------+--------+--------+-----------------------------------+
| %rax |
+-----------------------------------------------------------------------+
```
По сути, можно разглядеть историю эволюции процессоров. Так как большинство процессоров сейчас являются 64-битными, то будем использовать 64-битные регистры.
Указание размеров в "словах" в ассемблере обусловлено историческими причинами. Оно пошло из тех времён, когда у процессоров были шины данных в 16 бит, так что размер слова равен 16 битам. Это важно знать, т.к. в диалекте AT&T будете встречать множество инструкций с суффиксом `q` (quad-word — четверное слово) или `l` (long-word — длинное слово). Так что `movq` означает перемещение 4 \* 16 бит = 64 бит.
Простая мнемоника `mov` будет использовать размер, заданный указанным регистром. Это стандартное поведение в диалекте AT&T.
Так же стоит обратить внимание на выравнивание стека по границе 16 байт в архитектуре x86-64. Просто стоит помнить об этом.
Пример, который мы будем собирать
---------------------------------
В этом примере мы создадим свой собственный стек и заставим процессор вернуться из текущего контекста и перейти к использованию стека, который мы создали.
### Подготовка проекта
Начнём новый проект в каталоге с названием "green\_threads". Запустите команду
```
cargo init
```
Из-за того, что некоторые нужные нам возможности ещё не стабилизированы, будем использовать ночную версию Раст:
```
rustup override set nightly
```
В файле `main.rs` начнём с установлки флага, который позволит использовать макрос `llvm_asm!`:
```
#![feature(llvm_asm)]
```
Установим небольшой размер стека, только 48 байт, так что можно будет лишь поглядеть на него да вывести перед переключением контекстов.
```
const SSIZE: isize = 48;
```
Затем добавляем структуру, отражающую состояние процессора. Всё, что там сейчас нужно, так это лишь указатель на стек, так что сосредоточимся на регистре, который его хранит.
```
#[derive(Debug, Default)]
#[repr(C)]
struct ThreadContext {
rsp: u64,
}
```
В дальнейших примерах мы будем использовать все регистры, помеченные как "callee saved" в документации, на которую ссылка была ранее. Эти регистры описаны в ABI x86-64. Но прямо сейчас обойдёмся лишь одним, заставив процессор перейти по нашему стеку.
Так же стоит заметить, что из-за обращения к данным из ассемблера нужно указать `#[repr(C)]`. У Раста нет стабильного ABI, так что нет уверенности в том, что значение `rsp` будет занимать первые 8 байт. У Си же есть стабильный ABI, и именно его компилятор будет использовать при указании атрибута.
```
fn hello() -> ! {
println!("I LOVE WAKING UP ON A NEW STACK!");
loop {}
}
```
Для очень простого примера определяем функцию, которая просто выводит сообщение, а потом запускает бесконечный цикл.
А следующим делом пишем ассемблерный код, который переключает нас на использование нашего собственного стека:
```
unsafe fn gt_switch(new: *const ThreadContext) {
llvm_asm!("
mov 0x00($0), %rsp
ret
"
:
: "r"(new)
:
: "alignstack" // пока работает без этого, но будет нужно позднее
);
}
```
Здесь мы используем трюк. Мы пишем адрес функции, которую хотим запустить на нашем новом стеке. Затем мы передаём адрес первого байта, где мы сохранили этот адрес на регистр `rsp` (адрес в `new.rsp` будет указывать на адрес в нашем стеке, который ведёт к функции, указанной выше). Разобрались?
Ключевое слово `ret` передаёт контроль программе по адресу возврата, находящегося на вершине стека. Загрузив в регистр `%rsp` наш адрес, мы заставляем процессор думать, что это адрес, на который нужно будет вернуться из выполняемой в данный момент функции. Так что передав инструкцию `ret`, мы заставили процессор вернуться к выполнению задач в нашем собственном стеке.
И первое, что делает процессор, читает адрес нашей функции и запускает её.
### Краткое введение в макрос для ассемблерных вставок
Если до этого вы ещё не использовали ассемблерные вставки, то он может вам показаться чужеродным. Мы будем использовать его расширенную версию чуть позже для переключения контекста. Объясню, что тут и как строка за строкой:
`unsafe` — ключевое слово, которое сообщает компилятору не использовать гарантии безопасности в функции, которую мы пишем. Так как мы управляем процессором напрямую, то это по определению небезопасно.
`gt_switch(new: *const ThreadContext)` — принимаем указатель на экземпляр структуры `ThreadContext`, из которой мы будем читать только одно поле.
`llvm_asm!("` — макрос из стандартной библиотеки Раста. Он проверяет синтаксис и предоставляет сообщения об ошибках, если встречает что-то непохожее на валидный ассемблер диалекта AT&T (по-умолчанию).
Первое, что макрос принимает в качестве входных данных — ассемблер с шаблоном — `mov 0x00($0), %rsp`. Это простая инструкция, которая копирует значение, хранящееся по смещению 0x00 (в шестнадцатеричной системе; в данном случае оно нулевое) от позиции $0 в памяти, в регистр `rsp`. Регистр `rsp` хранит указатель на следующее значение в стеке. Мы перезаписываем значение, указывающее на верхушку стеку, на предоставленный адрес.
В нормальном ассемблерном коде вы не встретите `$0`. Это часть ассемблерного шаблона и означает первый параметр. Параметры нумеруются, как 0, 1, 2 и т.д., начиная с параметров `output` и двигаясь к параметрам `input`. У нас только один входной параметр, который соответствует `$0`.
Если встретите символ `$` в ассемблере, то, скорее всего, он означает непосредственное значение (целочисленную константу), но это не всегда так (да, символ доллара может означать разные вещи в зависимости от диалекта ассемблера и в зависимости от того, ассемблер это x86 или x86-64).
`ret` — служебное слово, которое заставляет процессор вытолкнуть значение, содержащее адрес в памяти, из стека и безусловно перейти по нему. В результате, мы перехватили управление процессором и заставили его вернуться к нашему стеку.
```
output
:
```
Ассемблерные вставки немного отличаются от обычного ассемблера. В них четыре дополнительных параметра, которые мы передаём после ассемблерного шаблона. Первый из них называется `output`, и в нём передаются выходные параметры, которые используются для возвращения значений в нашей функции.
```
input
: "r"(new)
```
Второй параметр — это параметр `input`. Литерал `"r"` — это то, что при написании ассемблерных вставок называется ограничением (`constraint`). Можно использовать эти ограничения для инструктирования компилятора о решении, где размещать ваши входные параметры (например, в одном из регистров или где-то в памяти). `"r"` означает, что нужно разместить значение в регистре общего назначения по выбору компилятора. Ограничения в ассемблерных вставках — довольно обширная тема сама по себе, но, к счастью, нам слишком много и не нужно.
```
clobber list
:
```
Следующая опция — `clobber list` — список, в котором указываются регистры, которые компилятор не должен трогать, и который позволяет ему сообщить, что мы хотим управлять ими в своём ассемблерном коде. Если мы хотим вытолкнуть из стека значения, то тут нужно указать, в какие регистры, и сообщить компилятору, что он не сможет спокойно распоряжаться ими. Ну а т.к. мы просто возвращаемся к новому стеку, то тут нам ничего и не требуется указывать.
```
options
: "alignstack"
```
И последний параметр — это опции. Для Раста они уникальные и мы можем задать три: `alignstack`, `volatile` и `intel`. Я просто оставлю ссылку на документацию, где объясняется их назначение. Для работы под Windows нам требуется указать опцию `alignstack`.
### Запуск примера
```
fn main() {
let mut ctx = ThreadContext::default();
let mut stack = vec![0_u8; SSIZE as usize];
unsafe {
let stack_bottom = stack.as_mut_ptr().offset(SSIZE);
let sb_aligned = (stack_bottom as usize & !15) as *mut u8;
std::ptr::write(sb_aligned.offset(-16) as *mut u64, hello as u64);
ctx.rsp = sb_aligned.offset(-16) as u64;
gt_switch(&mut ctx);
}
}
```
Это пример создания нашего нового стека. `hello` уже является указателем (на функцию), так что мы просто кастуем значение напрямую в `u64`, потому что все указатели на 64хбитных системах имеют такую длину, а потом записываем этот указатель в наш новый стек.
> Чуть позже поговорим про стек подробнее, но сейчас уже нужно знать одну вещь — стек растёт вниз (в сторону младших адресов). Если 48байтный стек начинается с индекса *0* и заканчивается индексом *47*, индекс *32* будет находиться по смещению 16 байт от начала/базы нашего стека.
```
|0 1 2 3 4 |4 5
|0123456789 012345|6789 0123456789 01|23456789 01234567|89 0123456789
| | |XXXXXXXX |
| | | stack bottom
|0th byte |16th byte |32nd byte
```
Заметьте, что мы записали указатель по смещению в 16 байт от базы нашего стека (помните, что я писал про выравнивание по границе 16 байт?)
> Что делает строка `let sb_aligned = (stack_bottom as usize & !15) as *mut u8;`? Когда мы запрашиваем память при создании `Vec`, нет гарантии, что она будет выравнена по границе 16 байт. Эта строка просто округляет адрес до ближайшего меньшего, кратного 16 байтам. Если он уже кратен, то ничего не делает.
Мы кастуем указатель так, чтобы он указывал на тип `u64` вместо `u8`. Мы хотим записать данные наше значение `u64` на позиции 32-39, которые как раз и составляют 8 байт места под него. Без этого приведения типов мы будем пытаться записать наше `u64`-значение только в позицию 32, а это не то, что мы хотим сделать.
В регистр `rsp` (Stack Pointer — указатель на стек) мы кладём *адрес индекса 32 в нашем стеке*. Мы не передаём само `u64`-значение, которое там хранится, а только адрес на первый байт этого значения.
Когда мы выполняем команду `cargo run`, то получаем:
```
dau@dau-work-pc:~/Projects/rust-programming-book/green_threads/green_threads$ cargo run
Compiling green_threads v0.1.0 (/home/dau/Projects/rust-programming-book/green_threads/green_threads)
Finished dev [unoptimized + debuginfo] target(s) in 0.44s
Running `target/debug/green_threads`
I LOVE WAKING UP ON A NEW STACK!
```
Так что же происходит? Мы не вызываем функцию `hello` ни в каком виде, но она всё равно запускается. Происходит следующее: мы заставляем процессор перейти на работу с нашим собственным стеком и выполнить код. Мы сделали первый шаг к реализации переключения контекста.
Стек
----
Это очень важно знать. У компьютера есть только память. Нет специальной "стековой" или "памяти для кучи" — это всё части одной и той же памяти.
Разница в том, как осуществляется доступ к этой памяти и как она используется. Стек поддерживает простые операции заталкивания и выталкивания (push/pop) в непрерывном участке памяти, что и делает его быстрым. Память в куче выделяется аллокатором по запросу и может быть разбросана.
Не будем погружаться в различия между стеком и кучей — есть множество статей, где это описано, включая [главу в Rust Programming Language](https://doc.rust-lang.org/stable/book/ch04-01-what-is-ownership.html#the-stack-and-the-heap).
### Как выглядит стек
Начнём с упрощённого представления стека. 64битные процессоры читают по 8 байт за раз. В примере выше, даже представив стек в виде длинной строки из значений типа`u8`, передавая указатель, нам нужно быть уверенными, что он указывает на адрес `000`, `0008` или `0016`.
Стек растёт вниз, так что мы начинаем сверху и спускаемся ниже.
Когда мы помещаем в `stack pointer` указатель на стек, выровненный по границе 16 байт, мы нужно быть уверенными, что адрес, на который он указывает, *кратен 16* (считая от начала стека — прим). В примере выше, единственным адресом, удовлетворяющим условию, является адрес `0008` (помните, что стек начинается сверху).
Если мы добавим следующие строки в код нашего примера перед переключением (перед вызовом `gt_switch`), мы увидим содержимое нашего стека.
Прим: код изменён — добавлен вывод адреса функции `hello`, значения в ячейках выводятся в шестнадцатеричной системе, добавлен вывод пустых строк для группировки и удобочитаемости.
```
print!(
"hello func address: 0x{addr:016X} ({addr})\n\n",
addr = hello as usize
);
for i in (0..SSIZE).rev() {
print!(
"mem: {}, value: 0x{:02X}\n{}",
stack.as_ptr().offset(i as isize) as usize,
*stack.as_ptr().offset(i as isize),
if i % 8 == 0 { "\n" } else { "" }
);
}
```
Вот примерно такой вывод будет:
```
hello func address: 0x0000560CD80B50B0 (94613164216496)
mem: 94613168839439, value: 0x00
mem: 94613168839438, value: 0x00
mem: 94613168839437, value: 0x00
mem: 94613168839436, value: 0x00
mem: 94613168839435, value: 0x00
mem: 94613168839434, value: 0x00
mem: 94613168839433, value: 0x00
mem: 94613168839432, value: 0x00
mem: 94613168839431, value: 0x00
mem: 94613168839430, value: 0x00
mem: 94613168839429, value: 0x56
mem: 94613168839428, value: 0x0C
mem: 94613168839427, value: 0xD8
mem: 94613168839426, value: 0x0B
mem: 94613168839425, value: 0x50
mem: 94613168839424, value: 0xB0
mem: 94613168839423, value: 0x00
mem: 94613168839422, value: 0x00
mem: 94613168839421, value: 0x00
mem: 94613168839420, value: 0x00
mem: 94613168839419, value: 0x00
mem: 94613168839418, value: 0x00
mem: 94613168839417, value: 0x00
mem: 94613168839416, value: 0x00
mem: 94613168839415, value: 0x00
mem: 94613168839414, value: 0x00
mem: 94613168839413, value: 0x00
mem: 94613168839412, value: 0x00
mem: 94613168839411, value: 0x00
mem: 94613168839410, value: 0x00
mem: 94613168839409, value: 0x00
mem: 94613168839408, value: 0x00
mem: 94613168839407, value: 0x00
mem: 94613168839406, value: 0x00
mem: 94613168839405, value: 0x00
mem: 94613168839404, value: 0x00
mem: 94613168839403, value: 0x00
mem: 94613168839402, value: 0x00
mem: 94613168839401, value: 0x00
mem: 94613168839400, value: 0x00
mem: 94613168839399, value: 0x00
mem: 94613168839398, value: 0x00
mem: 94613168839397, value: 0x00
mem: 94613168839396, value: 0x00
mem: 94613168839395, value: 0x00
mem: 94613168839394, value: 0x00
mem: 94613168839393, value: 0x00
mem: 94613168839392, value: 0x00
I LOVE WAKING UP ON A NEW STACK!
```
Я вывел адреса в памяти в виде значений `u64`, чтобы было легче в них разобраться, если вы не очень знакомы с шестнадцатеричной системой исчисления (что вряд ли — прим.).
Первое, что заметно, так это то, что это непрерывный участок памяти, который начинается с адреса `94613168839392` и заканчивается адресом `94613168839439`.
Адреса с `94613168839424` по `94613168839431` включительно представляют для нас особый интерес. Первый адрес — это первый адрес нашего `stack pointer`, значения, которое мы записываем в регистр `%rsp%`. Диапазон представляет собой значения, которые мы пишем в стек перед переключением. (прим — коряво и сомнительно!!!)
Ну а сами значения `0xB0, 0x50, 0x0B, 0xD8, 0x0C, 0x56, 0x00, 0x00` — это указатель (адрес в памяти) на функцию `hello()`, записанный в виде значений `u8`.
По мере того, как мы будем писать более сложные функции, нашего крайне скудного 48байтного стека скоро перестанет хватать, вы увидите, как функции запускаются, а код инструктирует процессор заталкивать и выталкивать значения из нашего стека при выполнении программы.
### Размеры стека
Когда вы запускаете процесс в большинстве современных операционных системах, стандартный размер стека обычно составляет 8 Мб, но может быть сконфигурирован и другой размер. Этого хватает для большинства программ, но на плечах программиста убедиться, что не используется больше, чем есть. Это и есть причина пресловутого "переполнения стека" (stack overflow), с которым многие из нас сталкивались.
Однако, когда мы сами управляем стеками, мы можем выбирать для них размер. 8 Мб для каждого контекста определённо больше, чем нам требуется при выполнении простых функций, например, в веб-сервере. Таким образом, уменьшив размер стека мы сможем держать миллионы легковесных потоков запущенными на машине, в то время, как при использовании стеков, предоставляемых операционной системой, мы очень скоро столкнёмся с нехваткой памяти.
### Расширяемые стеки
Некоторые реализации используют расширяемые (growable — способные расти) стеки. При этом выделяется небольшой объём памяти, достаточный для большинства задач. Но при его перерасходе, вместо переполнения стека, происходит выделение памяти большего объёма под новый стек, в который переносится всё из старого, после чего выполнение программы возобновляется.
Примером такой стратегии является реализация в языке Go. Работа начинается со стека размера в 8 Кб, и когда в нём заканчивается место, выделяется стек побольше. Как и в любом аспекте программирования, в данном поведении есть компромиссы, все имеющиеся указатели должны быть правильно обновлены, а это не очень простая задача. Если вас заинтересовало то, как GO управляет стеком (что является хорошим примером использования и компромиссной реализации растущего стека), то отправляю вас к этой [статье](https://blog.cloudflare.com/how-stacks-are-handled-in-go/).
> Ещё одна вещь, что будет важна позже: мы использовали обычный вектор (`Vec`) из стандартной библиотеки. Он очень удобен, но с ним есть проблемы. Среди прочего, нет гарантии, что он останется на прежнем месте в памяти.
>
> Как вы можете понять, если стек будет перемещён в памяти, то программа аварийно завершится из-за того, что все наши указатели станут недействительными. Что-нибудь такое простое, как вызов `push()` для нашего стека (имеется в виду вектор — прим.) может вызвать его расширение. А когда вектор расширяется, то запрашивается новый кусок памяти большего размера, в который потом перемещаются значения.
Только что мы прошли основы того, как стек выглядит и работает, и готовы переходить к реализации наших грин тредов. Вы уже проделали много сложной работы, так что обещаю больше кода.
### Как настроить стек
Windows x86-64 организует стек чуть иначе, чем регламентируется соглашением вызовов [x86-64 psABI](https://gitlab.com/x86-psABIs/x86-64-ABI/-/wikis/uploads/fc4752d690a71a9a478cbcfd6b6ec0b9/x86-64-psABI-2020-10-07.pdf). Я уделю чуть больше времени стеку Windows в приложении, но важно знать, что различия не такие большие, когда вы настраиваете стек под простые функции, которые не принимают параметры, что мы и делаем.
Организация стека в psABI выглядит следующим образом:
Как вы уже знаете, `%rsp` — это наш указатель на стек. Теперь, как вы видите, нужно положить указатель на стек в позицию от base pointer, кратную 16. Адрес возврата располагается в соседних 8 байтах, и, как вы видите, выше ещё есть место для аргументов. Нужно держать всё это в уме, когда хотим сделать что-нибудь более сложное.
Вы заметите, что мы регулярно записываем адрес на нашу функцию по адресу `stack_ptr + SSIZE - 16` без объяснения, почему именно так. По-любому `SSIZE` — это размер стека в байтах.
Думайте об этом следующим образом. Мы знаем, что размер указателя (в нашем случае — указателя на функцию) равен 8 байтам. Мы знаем, что `rsp` должен быть записан на границе 16 байт, чтобы соответствовать ABI.
У нас на самом деле и выбора-то нет, кроме как писать по адресу `stack_ptr + SSIZE - 16`. Записывая байты по адресам от младшего к старшему:
* Мы не можем записать их по адреса, начиная с `stack_ptr + SSIZE` (является границей 16 байт), т.к. мы выйдем за границы выделенного участка памяти, что запрещено.
* Мы не можем записать их по адресам, начиная с `stack_ptr + SSIZE - 8`, которые находятся внутри валидного адресного пространства, но не выровнены по границе 16 байт.
Остаётся только `stack_ptr + SSIZE - 16` в качестве первой подходящей позиции. На практике мы пишем 8 байт в позиции `-16, -15, -14, ..., -9` от *старшего адреса* нашего стека (который, запутывая, часто зовётся *bottom of stack*, т.к. растёт в сторону младших адресов (прим — если адреса записать в колонку по порядку, вверху будут младшие адреса, а внизу — старшие, то дно стека как раз будет внизу)).
### Бонусный материал
Если вы достаточно любознательны, вы можете заинтересоваться тем, что происходит со стеком после того, как мы переключаемся на него.
Ответ заключается в том, как написанный нами код на Расте компилируется в инструкции для процессора, которые затем переходит к нашему стеку и используют его, как и любой другой стек.
К сожалению, чтобы показать это, пришлось увеличить размер стека до 1024 байт, чтобы в нём оказалось достаточно места для того, чтобы наш код смог распечатать его содержимое. Так что тут вывод не будет приводиться.
#### Взглянем на стек
Однако, я написал альтернативную версию нашего примера, который вы можете запустить. Он создаст два текстовых файла: `BEFORE.txt` (содержимое стека перед переключением на него) и `AFTER.txt` (содержимое стека после переключения). Вы можете своими глазами посмотреть, как живёт стек и используется нашим кодом.
> Если вы видете что-то незнакомое в этом коде, то расслабьтесь — позже мы подробно рассмотрим детали.
```
#![feature(llvm_asm)]
#![feature(naked_functions)]
use std::io::Write;
const SSIZE: isize = 1024;
static mut S_PTR: *const u8 = 0 as *const u8;
#[derive(Debug, Default)]
#[repr(C)]
struct ThreadContext {
rsp: u64,
r15: u64,
r14: u64,
r13: u64,
r12: u64,
rbx: u64,
rbp: u64,
}
fn print_stack(filename: &str) {
let mut f = std::fs::File::create(filename).unwrap();
unsafe {
for i in (0..SSIZE).rev() {
writeln!(
f,
"mem: {}, val: {}",
S_PTR.offset(i as isize) as usize,
*S_PTR.offset( i as isize)
)
.expect("Error writing to file.");
}
}
}
fn hello() {
println!("I LOVE WAKING UP ON A NEW STACK!");
print_stack("AFTER.txt");
loop {}
}
unsafe fn gt_switch(new: *const ThreadContext) {
llvm_asm!("
mov 0x00($0), %rsp
ret
"
:
: "r"(new)
:
: "alignstack"
);
}
fn main() {
let mut ctx = ThreadContext::default();
let mut stack = vec![0_u8; SSIZE as usize];
let stack_ptr = stack.as_mut_ptr();
unsafe {
S_PTR = stack_ptr;
std::ptr::write(stack_ptr.offset(SSIZE - 16) as *mut u64, hello as u64);
print_stack("BEFORE.txt");
ctx.rsp = stack_ptr.offset(SSIZE - 16) as u64;
gt_switch(&mut ctx);
}
}
```
Реализация грин тредов
----------------------
Прежде, чем начать, замечу, что код, который мы напишем, не совсем безопасный, а так же не соответствует "лучшим практикам" (best practicies) в Расте. Я хочу попытаться сделать его, как можно безопаснее без привнесения множества ненужной сложности, так что если вы видите, что что-то можно сделать ещё безопаснее без сверхусложнения кода, то призываю тебя, дорогой читатель, предложить соответствующий PR в [репозиторий](https://github.com/cfsamson/example-greenthreads).
### Приступим
Первое, что сделаем — удалим наш предыдущий пример в файле `main.rs`, начав всё с нуля, и добавим следующее:
```
#![feature(llvm_asm)]
#![feature(naked_functions)]
use std::ptr;
const DEFAULT_STACK_SIZE: usize = 1024 * 1024 * 2;
const MAX_THREADS: usize = 4;
static mut RUNTIME: usize = 0;
```
Мы задействовали две фичи: ранее рассмотренную `asm` и фичу `naked_functions`, которую требуется в разъяснении.
#### `naked_functions`
Когда Раст компилирует функцию, он добавляет к ней небольшие "пролог" и "эпилог", которые вызывают некоторые проблемы из-за того, что при переключении контекстов стек оказывается невыровненным. Хотя в нашем простом примере всё работает нормально, но когда нам нужно переключаться обратно на тот же самый стек, то возникают трудности. Атрибут `#[naked]` убирает генерацию пролога и эпилога для функции. Главным образом этот атрибут используется в связке с ассемблерными вставками.
> Если интересно, то про `naked_functions` можно почитать в [RFC #1201](https://github.com/rust-lang/rfcs/blob/master/text/1201-naked-fns.md).
>
>
>
> Naked-функции не совсем функции. Когда вызывается обычная функция, то сохраняются регистры, в стек заталкивается адрес возврата, стек выравнивается и т.п. При вызове naked-функций ничего из этого не происходит. Если слепо вызвать `ret` в naked-функции (без предварительных манипуляций как в прологе и эпилоге, описанных в ABI), то попадёте на территорию неопределённого поведения. В лучшем случае закончите в вызывающем коде с мусором в регистрах.
Размер стека `DEFAULT_STACK_SIZE` задан в 2 МБ, чего более, чем достаточно для наших нужд. Так же задаём количество тредов (`MAX_THREADS`) равным 4, т.к. для примера больше не нужно.
Последняя строка — константа `RUNTIME` — указатель на структуру, содержащую информацию о системе времени исполнения (да, я знаю, что использовать мутабельную глобальную переменную для этого не очень красиво, она нам нужна дальше, а задаём для неё значение только во время инициализации).
Для представления наших данных допишем кое-что свежее:
```
pub struct Runtime {
threads: Vec,
current: usize,
}
#[derive(Debug, Eq, PartialEq)]
enum State {
Available,
Running,
Ready,
}
struct Thread {
id: usize,
stack: Vec,
ctx: ThreadContext,
state: State,
}
#[derive(Debug, Default)]
#[repr(C)]
struct ThreadContext {
rps: u64,
r15: u64,
r14, u64,
r13: u64,
r12: u64,
rbx: u64,
rbp: u64,
}
```
Главной точкой входа будет структура `Runtime`. Мы создадим очень маленький, простой рантайм для планирования выполнения потоков и переключения между ними. Структура содержит в себе вектор структур `Thread` и поле `current`, которое указывает на поток, который выполняется в данный момент.
Структура `Thread` содержит данные для потока. Для того, чтобы отличать потоки друг от друга, они имеют уникальный `id`. Поле `stack` такое же, какое мы видели в примерах ранее. Поле `ctx` содержит данные для процессора, которые нужны для продолжения работы потока с того места, где он покинул стек. Поле `state` — это состояние потока.
`State` — это перечисление состояний потока, которое может принимать значения:
* `Available` — поток доступен и готов быть назначенным для выполнения задачи, если нужно.
* `Running` — поток выполняется
* `Ready` — поток готов продолжать и возобновить выполнение.
`ThreadContext` содержит данные регистров, которые нужны процессору для возобновления исполнения на стеке.
> Если запамятовали, то вернитесь к части "Предварительные сведения" для того, чтобы почитать о регистрах. В спецификации архитектуры x86-64 Эти регистры помечены как "callee saved".
Продолжаем:
```
impl Thread {
fn new(id: usize) -> Self {
Thread {
id,
stack: vec![0_u8; DEFAULT_STACK_SIZE],
ctx: ThreadContext::default(),
state: State::Available,
}
}
}
```
Тут всё довольно просто. Новый поток стартует в состоянии `Available`, которое означает, что он готов принять задачу для исполнения.
Нужно отметить, что здесь мы выделяем стек. Это не слишком необходимое и оптимальное решение с точки зрения использования ресурсов, т.к. память можно выделить при первом использовании структуры. Но это позволяет снизить сложность в некоторых частях кода на которых можно сфокусировать внимание, вместо того, чтобы выделять память для стека.
> Важно заметить, что после того, как стек выделен, он не должен перемещаться. Никаких вызовов метода `push()` и других, которые могут спровоцировать перевыделение памяти. Лучше было бы использовать свой собственный тип данных, который предоставляет только безопасные с этой точки зрения методы.
>
>
>
> Так же упомянем, что у `Vec` есть метод `into_boxed_slice()`, который возвращает `Box<[T]>` — срез, выделенный в куче. Срезы не могут быть расширены, так что мы можем использовать их для решения проблемы перевыделения памяти.
### Реализация рантайма
Весь код этой части находится внутри блока `impl Runtime`, реализуя методы для одноимённой структуры.
```
impl Runtime {
pub fn new() -> Self {
let base_thread = Thread {
id: 0,
stack: vec![0_u8; DEFAULT_STACK_SIZE],
ctx: ThreadContext::default(),
state: State::Running,
};
let mut threads = vec![base_thread];
let mut available_threads: Vec = (1..MAX\_THREADS).map(|i| Thread::new(i)).collect();
threads.append(&mut available\_threads);
Runtime {
threads,
current: 0,
}
}
// code of other methods is here
// ...
}
```
При инстанцировании структуры `Runtime` создаётся базовый поток в состоянии `Running`. Он держит среду исполнения запущенной пока все задачи не будут завершены. Потом создаются остальные потоки, а текущим назначается поток с номером `0`, который является базовым.
```
// Читерство, но нам нужен указатель на структуру Runtime
// сохранённый таким образом, чтобы мы могли вызывать метод yield
// без прямого обращения к этой структуре по ссылке.
// по сути мы дублируем указатель втихомолку от компилятора
pub fn init(&self) {
unsafe {
let r_ptr: *const Runtime = self;
RUNTIME = r_ptr as usize;
}
}
```
Сейчас нам это нужно. Как я упоминал, когда расписывал константы, нам нужна глобальная переменная для того, чтобы вызывать метод `yield` позже. Не очень симпатично, но мы знаем, что наш рантайм должен жить, пока есть потоки.
```
pub fn run(&mut self) -> ! {
while self.t_yield() {};
std::process::exit(0);
}
```
А это то место, где мы запускаем наш рантайм. Он беспрестанно вызывает метод `t_yield()`, пока тот не вернёт значение `false`, что означает, задач больше нет, и мы можем завершить процесс.
```
fn t_return(&mut self) {
if self.current != 0 {
std.threads[self.current].state = State::Available;
self.t_yield();
}
}
```
Когда процесс завершается, то вызываем эту функцию. Мы назвали её `t_return`, т.к. слово `return` входит в список зарезервированных. Заметьте, что *пользователь* наших потоков не вызывает эту функцию — мы организуем стек таким образом, что эта функцию вызывается, когда задача завершается.
Если вызывающий поток является базовым, то ничего не делаем. Наш рантайм вызывает метод `yield` для базового потока. Если же вызов приходит из порождённого (spawned) потока, мы узнаём, что он завершился, т.к. у всех потоков на вершине их стека находится функция `guard` (её объясню позже). Так что единственное место, откуда `t_return` может быть вызвана — это как раз функция `guard`.
Мы назначаем потоку состояние `Available`, сообщая рантайму, что готовы принять новую задачу (task), а затем немедленно вызываем `t_yield`, который дёргает планировщик для запуска нового потока.
Далее рассмотрим функцию `yield`:
```
fn t_yield(&mut self) -> bool {
let mut post = self.current;
while self.threads[pos].state != State::Ready {
pos += 1;
if pos == self.threads.len() {
pos = 0;
}
if pos == self.current {
return false;
}
}
if self.threads[self.current].state != State::Available {
self.threads[self.current].state = State::Ready;
}
self.threads[pos].state = State::Running;
let old_pos = self.current;
self.current = pos;
unsafe {
let old: *mut ThreadContext = &mut self.threads[old_pos].ctx;
let new: *const ThreadContext = &self.threads[pos].ctx;
llvm_asm!(
"
mov $0, %rdi
mov $1, %rsi
"
:
: "r"(old), "r"(new)
:
:
);
switch();
}
self.threads.len() > 0
}
```
Это сердце нашего рантайма. Пришлось выбрать имя `t_yield`, т.к. `yield` является зарезервированным словом (прим. — используется в генераторах, которые ещё не стабилизированы).
Здесь мы обходим все треды и смотрим, есть ли какой-нибудь из них в состоянии `Ready`, что означает, что у него есть задача, которую он готов выполнять. В реальном приложение это могло бы быть обращение к базе данных, которое вернуло данные.
Если же потоков в состоянии `Ready` нет, то все задачи выполнены. Это крайне простой планировщик, который использует только алгоритм циклического перебора (round-robin). Реальные планировщики могут иметь более сложный способ определения, какую задачу выполнять следующей.
> Это очень наивная реализация для нашего примера. Что случится, если тред не готов двигаться дальше (не в состоянии `Ready`) и всё ещё ожидает чего-то, например, ответа от базы данных?
>
>
>
> Не слишком сложно обработать такой случай. Вместо запуска нашего кода напрямую, когда поток готов, мы можем запросить (poll) его о статусе. Например, он может вернуть значение `IsReady`, если он дейсвительно готов заняться работой, или вернуть `Pending`, если он ожидает завершения какой-либо операции. В последнем случае мы можем просто оставить его в состоянии `Ready`, чтобы опросить позднее. Звучит знакомо? Если читали про то, как работают [Футуры](https://rust-lang-nursery.github.io/futures-api-docs/0.3.0-alpha.16/futures/task/enum.Poll.html#variant.Pending), то наверное в голове у вас складывается картина того, как это всё состыкуется вместе.
Если мы находим поток, который готов к работе, мы меняем состояние текущего потока с `Running` на `Ready`.
Затем мы вызываем функцию `switch`, которая сохраняет текущий контекст и загружает новый в процессор. Новый контекст является либо новой задачей, либо всей информацией, необходимой для процессора для возобновления работы над уже существующей задачей.
> #### Неудобная правда о naked функциях
>
>
>
>
>
> Функции naked не похожи на обычные. Например, они не принимают формальных аргументов. Обычно, когда вызывается функция с двумя аргументами, компилятор разместит каждый из них в регистрах, согласно соглашению о вызове функций для данной платформы. Когда же мы вызываем функцию, помеченную как `#[naked]`, об этом придётся заботиться самостоятельно. Таким образом мы передаём адрес наших "новой" и "старой" структур `ThreadContext`, используя ассемблер. В соглашении о вызове на платформе Linux первый аргумент помещатся в регистр `%rdi`, а второй — в регистр `%rsi`.
Часть `self.threads.len() > 0` — просто способ указать компилятору, чтобы он не применял оптимизацию. У меня такое нежелательное поведение проявлялось на Windows, но не на Linux, и является общей проблемой при запуске бенчмарков, например. Таким же образом мы можем использовать `std::hint::black_box` для того, чтобы указать компилятору, что не нужно ускорять код, пропуская шаги, которые нам необходимы. Я выбрал другой путь, а даже если его закомментировать, всё будет ок. В любом случае, код никогда не попадёт в эту точку.
Следом идёт наша функция `spawn()`:
```
pub fn spawn(&mut self, f: fn()) {
let available = self
.threads
.iter_mut()
.find(|t| t.state == State::Available)
.expect("no available thread.");
let size == available.stack.len();
unsafe {
let s_ptr = available.stack.as_mut_ptr().offset(size as isize);
let s_ptr = (s_ptr as usize & !15) as *mut u8;
std::ptr::write(s_ptr.offset(-16) as *mut u64, guard as u64);
std::ptr::write(s_ptr.offset(-24) as *mut u64, skip as u64);
std::ptr::write(s_ptr.offset(-32) as *mut u64, f as u64);
available.ctx.rsp = s_ptr.offset(-32) as u64;
}
available.state = State::Ready;
}
// не забудьте про закрывающую скобку блока `impl Runtime`
```
В то время, как `t_yield` интересна в плане логики, в техническом плане фукнция `spawn` наиболее интересна.
Это то, где мы настраиваем стек так, как обсуждали ранее, и убеждаемся, что он выглядит так, как указано в [psABI](https://cfsamson.gitbook.io/green-threads-explained-in-200-lines-of-rust/the-stack#how-to-set-up-the-stack).
Когда порождаем новый поток для выполнения задачи, сперва проверяем, что у нас есть доступный для этого поток (т.е. в состоянии `Available`). В нашем сценарии, если таких потоков нет, то паникуем, хотя есть несколько способов получше, чтобы обработать эту ситуацию. На данный момент будем придерживаться простоты.
Когда нашли доступный поток, мы получаем его стек (в виде ссылки на массив `u8`) и его длину.
В следующем сегменте приходится использовать некоторые unsafe-функции. Сперва убеждаемся, что сегмент памяти выровнен по границе 16 байт. Затем мы записываем адрес функции `guard`, которая будет вызвана, когда предоставленная нами задача завершится и функция вернёт значение. Следом мы записываем адрес функции `skip`, которая здесь нужна лишь для обработки промежуточного этапа, когда мы возвращаемся из функции `f` таким образом, чтобы функция `guard` вызывалась по границе памяти в 16 байт. И следующее значение, которое мы записываем, это адрес функции `f`.
> Вспомните объяснения того, как работает стек. Мы хотим, чтобы `f` была первой функцией, которая будет запущена. Поэтому на неё и указывает base pointer с учётом выравнивания. Затем мы заталкиваем в стек адрес на фукнции `skip` и `guard`. Таким образом мы обеспечиваем выравнивание функции `guard` по границе 16 байт, что необходимо сделать по требованиям ABI.
После того, как мы записали указатели на функции в стек, мы записываем в регистр `rsp` (который явялется указателем на стек) адрес предоставленной функции. Таким образом мы запускаем её на исполнение в первую очередь при очередном цикле планировщика.
И наконец, мы устанавливаем состояние потока в `Ready`, что означает, у нас есть работа для выполнения, и мы готовы её делать. Вспомните, что это знак для нашего "планировщика" запустить этот поток.
Вот и завершили реализацию нашей среды исполнения. Если вы добрались до этого места, вы в общих чертах понимаете, *как* легковесные потоки работают. Однако, есть есть несколько деталей, которые необходимо реализовать.
### Функции `guard`, `skip` и `switch`
```
fn guard() {
unsafe {
let rt_ptr = RUNTIME as *mut Runtime;
(*rt_ptr).t_return();
};
}
```
Когда функция, которую мы передали на исполнение, возвращает результат, что так же означает, что поток завершил выполнение своей задачи, мы разыменовываем глобальную переменную, и вызываем метод `t_return()` нашей среды исполнения. Мы могли бы написать функцию, которая проделывала некоторую дополнительную работу, когда поток завершается, но в данный момент того, что делает `t_return`, нам достаточно. Она помечает тред как `Available` (если это не базовый тред), и вызывает метод `t_yield`, что позволяет возобновить работу над другой задачей в другом потоке.
```
#[naked]
fn skip() { }
```
В функции `skip` не так много всего происходит. Мы используем атрибут `#[naked]`, так что фукнция компилируется в единственную инструкцию `ret`, которая просто выталкивает очередное значение из стека и переходит по адресу, который в этом значении содержится. В нашем случае, это значение указывает на функцию `guard`.
```
pub fn yield_thread() {
unsafe {
let rt_ptr = RUNTIME as *mut Runtime;
(*rt_ptr).t_yield();
};
}
```
А это просто вспомогательная функция, которая позволяет вызывать метод `t_yield` из любого места в коде. Она так же небезопасная, потому что наш рантайм может быть ещё неинициализирован или наоборот, уже деинициализирован (дропнут), что приведёт к неопределённому поведению. Однако же, сделать это более безопасным для нашего примера, не в приоритете.
Совсем скоро мы подойдём к последней строке, всего одна функция осталась. Если внимательно читали всё предыдущее, то можно понять её суть и без обилия комментариев.
```
#[naked]
#[inline(never)]
unsafe fn switch() {
llvm_asm!("
mov %rsp, 0x00(%rdi)
mov %r15, 0x08(%rdi)
mov %r14, 0x10(%rdi)
mov %r13, 0x18(%rdi)
mov %r12, 0x20(%rdi)
mov %rbx, 0x28(%rdi)
mov %rbp, 0x30(%rdi)
mov 0x00(%rsi), %rsp
mov 0x08(%rsi), %r15
mov 0x10(%rsi), %r14
mov 0x18(%rsi), %r13
mov 0x20(%rsi), %r12
mov 0x28(%rsi), %rbx
mov 0x30(%rsi), %rbp
"
);
}
```
Здесь ассемблерная вставка. Как помните из первого примера, это просто более расширенная версия, где мы сначала читаем значения из нужных регистров, а затем записываем в них новые значения, которые были сохранены, когда мы приостановили выполнение "нового" потока.
Это всё, что необходимо, чтобы запомнить и потом восстановить исполнение.
Так же мы снова видим использование атрибута `#[naked]`. Обычно каждая функция имеет пролог и эпилог, а здесь мы не хотим их, так как функция состоит целиком из ассемблерной вставки, и мы обо всём заботимся самостоятельно. Если же не включить этот атрибут, то будут проблемы при повторном переключении обратно к нашему стеку.
Так же есть ещё одно отличие от нашей первой функции. Это атрибут `#[inline(never)]`, который запрещяет компилятору встраивать эту функцию. Я провёл некоторое время, выясняя, почему код фейлится при сборке с флагом `--release`.
### Функция `main`
```
fn main() {
let mut runtime = Runtime::new();
runtime.init();
runtime.spawn(|| {
println!("THREAD 1 STARTING");
let id = 1;
for i in 1..=10 {
println!("thread: {} counter: {}", id, i);
yield_thread();
}
println!("THREAD 1 FINISHED");
});
runtime.spawn(|| {
println!("THREAD 2 STARTING");
let id = 2;
for i in 1..=15 {
println!("thread: {} counter: {}", id, i);
yield_thread();
}
println!("THREAD 2 FINISHED");
});
runtime.run();
}
```
Как видите, мы тут инициализируем рантайм и порождаем два потока, которые считают от 0 до 9 и до 15, а так же уступают работу между итерациями. Если запустим наш проект через `cargo run`, то должны увидеть следующий вывод:
```
THREAD 1 STARTING
thread: 1 counter: 1
THREAD 2 STARTING
thread: 2 counter: 1
thread: 1 counter: 2
thread: 2 counter: 2
thread: 1 counter: 3
thread: 2 counter: 3
thread: 1 counter: 4
thread: 2 counter: 4
thread: 1 counter: 5
thread: 2 counter: 5
thread: 1 counter: 6
thread: 2 counter: 6
thread: 1 counter: 7
thread: 2 counter: 7
thread: 1 counter: 8
thread: 2 counter: 8
thread: 1 counter: 9
thread: 2 counter: 9
thread: 1 counter: 10
thread: 2 counter: 10
THREAD 1 FINISHED
thread: 2 counter: 11
thread: 2 counter: 12
thread: 2 counter: 13
thread: 2 counter: 14
thread: 2 counter: 15
THREAD 2 FINISHED
```
Прекрасно. Наши потоки сменяют друг друга после каждого отсчёта, уступая друг другу контроль. А когда поток 1 завершается, то поток 2 продолжает свои отсчёты.
Поздравления
------------
Только что вы реализовали суперпростой, но работающий пример легковесных потоков. Пришлось довольно долго к этому идти, но если вы забрались так далеко и прочитали всё, то заслужили небольшой отдых. Спасибо за чтение! | https://habr.com/ru/post/543158/ | null | ru | null |
# Разметка медицинских данных (DICOM) в Computer Vision Annotation Tool
Второе десятилетие 21 века отлично показало, как многие трудно формализуемые в рамках классических методов задачи могут быть решены с использованием искусственных нейронных сетей. Важно и то, что для таких решений уже давно было найдено свое применение в различных прикладных областях жизни современного общества, связанных с безопасностью, автоматизацией производственных и бизнес процессов, и просто привнесением большого количества удобств. Значительная часть таких решений располагается в области Computer Vision, где в качестве основного источника данных выступают визуальные образы (изображения, видео, карты глубины). ИИ-исследователи хорошо знакомы с проблемой острой необходимости достаточного количества качественных обучающих данных (ground truth examples) для тренировки нейронных сетей, ведь фактически, чем больше таких данных использовано при обучении, тем точнее предсказания модели. Мы в компании Intel используем разные источники таких данных. Один из основных — подготовка собственных данных силами внутренней команды разметки. Для облегчения этого процесса в нашей команде был разработан инструмент **C**omputer **V**ision **A**nnotation **T**ool (CVAT), исходный код которого был опубликован на [GitHub](https://github.com/openvinotoolkit/cvat). Продукт является частью экосистемы [OpenVINO](https://github.com/openvinotoolkit) — набора инструментов для быстрой разработки эффективных приложений, использующих различные модели глубокого обучения. К настоящему времени CVAT успел набрать достаточно высокую популярность среди обычных и коммерческих пользователей по всему миру.
#### Немного истории
Однажды, после новогодних праздников один из таких пользователей обратился к нам с запросом: может ли CVAT работать с данными, представленными в формате медицинских изображений? Один из наиболее популярных форматов для хранения медицинских данных — это .dcm файлы, внутренний формат которых специфицирован стандартом **D**igital **I**maging and **CO**mmunication in **M**edicine ([DICOM](https://www.dicomstandard.org/current)). CVAT, к сожалению, никогда не разрабатывался с целью поддержки такого формата данных, хотя в прошлом и применялся для разметки разных медицинских данных, например при разработке продукта [NerveTrack](https://www.intel.com/content/www/us/en/newsroom/news/samsung-medison-improve-anesthesia-delivery.html). Были и попытки самостоятельно изменить исходный код CVAT для поддержки данных DICOM, одна из которых описана [здесь](https://hacarus.com/information/tech/20200717-cvat-dicom-ai/). В последнем источнике отмечаются преимущества использования CVAT для этих целей: открытый исходный код, с возможностью доработки под конечного пользователя, хранение конфиденциальных данных локально на внутренних серверах и развертка в локальной или корпоративной сети с возможностью работы через браузер, поскольку конечным пользователям, которые не имеют продвинутых знаний в системном администрировании, сложно осуществлять установку и настройку самостоятельно.
С тех пор мы начали задумываться о том, что стоит научить CVAT работать с этим форматом и предоставить удобный интерфейс для разметки такого рода данных. Ведь, с одной стороны, доля медицины в ИИ, достаточно высока, а значит есть и спрос на подобного рода функциональность (особенно после начавшейся пандемии COVID 19). С другой стороны, на существующем рынке нами не было найдено многофункциональных (в сравнении c CVAT) и доступных решений, в особенности с открытым исходным кодом, для разметки DICOM датасетов. Есть достаточно хорошие решения, которые в основном предоставляют функциональность для обработки, хранения, управления и просмотра DICOM данных (pydicom, cornerstonejs, orthanc-server), простые аннотационные инструменты (md.ai), и комплексные решения с хорошим функционалом для разметки данных, но они являются коммерческими, с ограниченным функционалом в бесплатных версиях (medseg.ai).
#### Почему все не так просто
Наша команда провела исследование, в ходе которого мы накидали возможные высокоуровневые дизайн-решения (т.е. того, как поддержка DICOM форматов может быть реализована в существующей экосистеме CVAT) и столкнулись с двумя трудностями, которые в совокупности являются существенным препятствием для дальнейшей работы. Первая проблема заключается в том, что DICOM стандарт подразумевает огромную вариативность .dcm файлов. Например, стандарт подразумевает существование 79 DICOM модальностей, которые определяют контент DICOM файла (CT – компьютерная томография, CR – компьютерная рентгенография, LEN – линзометрия, MR – магнитно-резонансная томография и т.д.). Кроме того, DICOM стандарт определяет огромное количество разных атрибутов или тегов, некоторые универсальные, другие зависящие от модальности. Файлы также могут включать одно изображение или несколько (слайс), или несколько слайсов. Данные в этих изображениях, часто не интерпретируются как пиксели, а могут определять, например, физические значения измерений, произведенных тем или иным оборудованием. В конце концов, DICOM это не единственный формат файлов, используемых в медицине. Поддержка всех этих сценариев была бы чрезмерно объемной задачей для нашей команды. Да и нужно ли это?
Здесь мы плавно подходим ко второй проблеме. Обычно процесс разработки новых функций в CVAT основывается на том, что необходимо нашим пользователям в первую очередь. Например, значительная часть разработанных функций была добавлена с целью удовлетворения требований внутренней команды разметки, которая занималась подготовкой данных для обучения многих моделей в [OpenVINO Model Zoo](https://github.com/openvinotoolkit/open_model_zoo) – зоопарке точных и высоко-оптимизированных моделей глубокого обучения. Такой подход подразумевает, что сперва какое-либо заинтересованное лицо обращается к нам с определенным запросом, разметить тот или иной набор данных тем или иным образом, чтобы на выходе получить разметку в определенном формате. После этого мы решаем конкретную задачу, а не пытаемся предугадать, что именно нужно пользователям. Однако, поскольку CVAT никогда и нигде не позиционировался как инструмент разметки медицинских данных, настоящее CVAT сообщество, глобально говоря, не слишком заинтересовано в реализации подобного функционала Таким образом у нас нет достаточно хорошего представления о направлении дальнейшей разработки. И одна из целей настоящего материала – собрать больше сведений о задачах, с которыми работает сообщество и востребованных функциях. Так, если вы заинтересованы в разработке, вы можете обратиться к нам через GitHub или прямым письмом (все ссылки и адреса предоставлены в конце статьи).
#### Тем не менее, это возможно
Статья не оправдала бы свое название, если бы закончилась на предыдущем абзаце. Несмотря на указанные проблемы, мы подготовили небольшое, «быстрое» решение проблемы разметки DICOM файлов в CVAT. Решение, конечно, не является самым удобным, но по крайней мере для самых простых случаев использования оно может оказаться применимым. Как было отмечено, DICOM файлы очень вариативны, но значительную долю проблем позволяют решить существующие решения, в том числе и с открытым исходным кодом. Так, мы использовали модуль языка программирования Python для работы с DICOM ([pydicom](https://github.com/pydicom/pydicom)) для подготовки скрипта, который осуществляет конвертацию DICOM файлов в обычные изображения и далее покажем подробный пример использования. Интерфейс командной строки для конвертации располагается в репозитории CVAT по [ссылке.](https://github.com/openvinotoolkit/cvat/tree/v1.4.0/utils/dicom_converter) Скрипт доступен начиная с релиза 1.4. Набор команд ниже был протестирован на ОС Ubuntu 20.04, но действия по большей части простые и легко выполнимы в ОС Windows или других с помощью графического пользовательского интерфейса.
Для корректной работы команд, описанных ниже подразумевается, что в системе установлен ряд инструментов. Чтобы установить их в Ubuntu, вы можете воспользоваться следующей командой:
```
sudo apt install curl zip unzip python3 python3-pip python3-venv git
```
Первый шаг – склонировать репозиторий, если вы этого еще не сделали:
```
git clone --branch v1.4.0 https://github.com/openvinotoolkit/cvat.git cvat && cd cvat
```
Следующим шагом необходимо перейти в папку с утилитой и рекомендуется создать виртуальное окружение Python, чтобы избежать установки лишних пакетов в систему, затем активировать его и установить необходимые зависимости:
```
cd utils/dicom_converter/
python3 -m venv .env
. .env/bin/activate
pip install -r requirements.txt
```
Теперь можно запустить скрипт для того, чтобы преобразовать набор данных. Для примера возьмем набор данных [CHAOS (Combined (CT-MR) Healthy Abdominal Organ Segmentation).](https://zenodo.org/record/3431873) Вы можете скачать его по предоставленной ссылке вручную, либо с помощью утилиты curl (Ubuntu):
```
curl -L https://zenodo.org/record/3431873/files/CHAOS_Test_Sets.zip?download=1 --output CHAOS_Test.zip
curl -L https://zenodo.org/record/3431873/files/CHAOS_Train_Sets.zip?download=1 --output CHAOS_Train.zip
```
Разархивируем полученные данные с использованием графического интерфейса или с помощью командной строки Ubuntu:
```
unzip CHAOS_Test.zip -d CHAOS_Test
unzip CHAOS_Train.zip -d CHAOS_Train
```
И сконвертируем их, запустив скрипт и передав нужные аргументы. Первый аргумент – корневой каталог с исходными файлами. Второй – корневой каталог для преобразованных файлов:
```
python3 script.py CHAOS_Train CHAOS_Train_converted
python3 script.py CHAOS_Test CHAOS_Test_converted
```
> *Примечание: Скрипт осуществляет рекурсивный поиск DICOM файлов. Структура каталогов в результате сохраняется.*
>
>
> *Примечание: Если DICOM файл содержит несколько изображений, полученные изображения будут содержать постфикс с номером изображения. Например, многофреймовый DICOM файл с именем 055829-00000000.dcm будет преобразован в набор файлов 055829-00000000\_000.png, 055829-00000000\_000.png, ...:*
>
>
В результате работы скрипта в каталогах CHAOS\_Train\_converted и CHAOS\_Test\_converted находятся обычные изображения, с которыми CVAT умеет работать. Далее в зависимости от ваших потребностей вы можете выбрать часть данных или все данные целиком и создать аннотационную CVAT задачу. Для удобства запакуем преобразованные файлы в архив с использованием графического интерфейса или с помощью командной строки в Ubuntu:
```
zip -r CHAOS_Train_converted.zip CHAOS_Train_converted/
zip -r CHAOS_Test_converted.zip CHAOS_Test_converted/
```
Кроме того, каталог можно просто переместить без дополнительной архивации в CVAT хранилище (если оно подключено) и использовать соответствующую вкладку файлов в CVAT при создании задачи, либо загрузить изображения стандартными средствами браузера из любого места на компьютере, если работаете с линейным списком изображений (загрузка каталогов пока не поддерживается).
Теперь необходимо установить CVAT, если вы этого еще не сделали. Подробный гайд по установке и настройке, в зависимости от операционной системы, может быть найден в [документации](https://openvinotoolkit.github.io/cvat/docs).
В установленном CVAT создадим проект DICOM, который включает пару абстрактных классов разметки (мы будем размечать нечто абстрактное, поскольку не являемся медицинскими экспертами и не ясно, что именно представляет область интереса в наборе данных), откроем его и затем создадим две задачи для двух архивов:
Теперь разметим абстрактные сущности на изображениях:
Изображение, размеченное вручнуюКроме ручной разметки, можно использовать полуавтоматические методы:
Полуавтоматическая сегментация с использованием OpenCV JS выглядит эффективно в данном сценарии, поскольку у размечаемых объектов высокий контраст, а значит алгоритм работает довольно точно. Еще одно размеченное изображение:
Изображение, размеченное с помощью полуавтоматических методовПосле того, как все данные размечены, можно получить результат в виде, например, PNG маски. CVAT поддерживает большое количество разных форматов, но, как показывает практика, маски довольно популярны при работе с DICOM данными.
Поддерживаемые форматыКонечный файл содержит маски и другую полезную информацию:
В этом небольшом руководстве мы рассмотрели возможный сценарий разметки DICOM данных с использованием инструмента Computer Vision Annotation Tool. Кроме того, мы постарались объяснить как именно наша команда приходит к разработке новой функциональности, какое важное влияние в этом оказывают наши пользователи, их отзывы и описания задач, которые необходимо решить с помощью инструмента. Если вы желаете оставить отзыв по инструменту или данному материалу, либо предоставить ваши идеи по охваченной теме, пожалуйста, свяжитесь с нами, используя контакты ниже.
* [Computer Vision Annotation Tool: универсальный подход к разметке данных](https://habr.com/ru/company/intel/blog/433772/)
* [Ссылка на GitHub](https://github.com/openvinotoolkit/cvat/)
* Author: Борис Секачев [boris.sekachev@intel.com](mailto:boris.sekachev@intel.com)
* Team Lead: Никита Манович [nikita.manovich@intel.com](mailto:nikita.manovich@intel.com) | https://habr.com/ru/post/562994/ | null | ru | null |
# Ищем значение числа Пи, используя генератор случайных значений
> **Представьте, что у вас есть функция random(), которая генерируют случайным образом значения в промежутке ![[0;1]](https://habrastorage.org/getpro/habr/upload_files/eff/a38/faa/effa38faa5436724d67f327abc985718.svg)**
>
> **Вычислите значение числа **
>
>
Это один из популярных вопросов на собеседовании в топовую IT компанию
В первую секунду может показаться, что ваш интервьюер слегка издевается над вам, но если вспомнить основы из теории вероятности, то все становится гораздо проще. Let's go!
База из теории вероятности
--------------------------
**Классическое определение вероятности.**
Вероятность, что событие A произойдет, равно отношению количеству благоприятных исходов к количеству всех возможных исходов 
На языке математики это выглядит так: 
Например у нас есть кубик. Какая вероятность что выпадет грань с четными значениями?
РешениеНабор всех исходов {} 
Набор благоприятных исходов  {} 
Значит 
**Геометрическое определение вероятности.**
Предыдущее определение вероятности отличное, но оно обладает несколькими существенными ограничениями. Одним из таких ограничений является тот факт, что оно неприменимо к испытаниям с бесконечным количеством исходов.
Чтобы стало понятно о чем речь - давайте решим задачку.
На отрезок ![[0;1]](https://habrastorage.org/getpro/habr/upload_files/97a/01f/abd/97a01fabd885fd29d0464e36ea49161d.svg)случайным образом брошена точка Найдите вероятность того, что она попадет в промежуток ![[0,5; 0,8]](https://habrastorage.org/getpro/habr/upload_files/96c/9a4/112/96c9a4112962713958721a0d516aed64.svg)
Понятно, что здесь не получится использовать классическое определение, поскольку на отрезке бесконечно много точек. Тогда нам идет на помощь геометрическое определение
вероятности , в нашем случае , 
Следовательно 
Решение задачи
--------------
**Концепция**
Построим геометрическую модель.
Введем систему координат с осями и 
Расположим квадрат с единичной стороной, так чтобы начало системы координат находилось в левом углу.
Нарисуем единичный круг с центром в начале координат.
геометрическая модельБудем случайным образом располагать точку в квадрате.
Наша исходная задача сводится к следующему вопросу.
**Какая вероятность, что точка попадет в верхнюю правую четверть круга (область A)**
Мы знаем, что , а 
Значит вероятность того, что точка попадет в искомую область равна 
С другой стороны, после распределения n точек по квадрату, мы можем оценить количество точек, которое попало внутрь круга. Для этого точка с координатами 
должна удовлетворять неравенству 
Тогда вероятность , где количество точек попавших внутрь круга, а n общее число точек.
Значит из верних соотношений имеем 
**Программируем**
```
import random
def estimate_pi(n):
num_point_circle = 0 #кол-во точек внутри круга
num_point_total = n
for i in range(n):
x = random.uniform(0,1)
y = random.uniform(0,1)
distance = x**2 + y**2
if distance <= 1: #определяем, что точка попала внутрь круга
num_point_circle += 1
return 4 * num_point_circle/num_point_total
n = 10000000 #общее количество точек (чем больше точек, тем лучше точность)
pi = estimate_pi(n)
print(pi)
```
На этом все!
------------
Надеюсь вам понравилась задача! Делитесь своими интересными задачками с собеседований, будем разбирать)
Связаться со мной [@polozovs](https://t.me/polozovs) | https://habr.com/ru/post/696244/ | null | ru | null |
# Панель выбора build-вариантов Build System в Sublime Text 2. (или как изобретался велосипед)
Идея и реализация: жмем в SublimeText2 сочетание клавиш, получаем панель со списком build-вариантов, автоматически сформированным по файлу выбранной Build System, выбираем нужный вариант и наблюдаем как непосредственно в интерфейсе Sublime Text 2 отображается процесс сборки проекта.
Сразу скажу, что здесь я делюсь своим бесценным опытом совместной разработки плагина [ProjectBuild](https://github.com/Snegovikufa/ProjectBuild) для Sublime Text 2, потому что в результате только опыт и был получен, поскольку, как оказалось, необходимости в реализации данного плагина не было, и весь этот процесс оказался изобретением велосипеда. Печально, но опыт все же бесценен. Повествование будет таким, что о «велосипеде» будет сказано только в конце.
#### Вступление
Итогом ранее написанной статьи [«Автоматизация сборки проекта в Sublime Text 2 c использованием Ant»](http://habrahabr.ru/post/149087/) была возможность вызова в Sublime Text 2 различных build-вариантов выбранной Build System (на примере Ant) c использованием назначенных сочетаний клавиш для них. (сейчас бы я использовал в теме того поста еще и слово «настройка»)
Что мне не нравилось в этом подходе:
1. У различных Build System могли быть совершенно разные имена их вариантов, а сочетания клавиш уже явно были привязаны к конкретным именам вариантов, которых могло и не быть в другой Build System. Моим допущением было то, что большинству разработчиков не приходится часто переключаться между несколькими Build System, и в основном разработчик работает с одной Build System. И если захочет разработчик, то изменит сочетания клавиш заново. Но согласитесь, это немного напрягает. И об этом нужно помнить. И в продолжение, также
2. Нужно помнить все назначенные вами сочетания клавиш. Понятно, что есть основные «F7», «Ctrl+B», «Ctrl+Shift+B» — но для каждого вашего варианта будет еще одно сочетание. Это значит, что нужно либо переопределить сочетание клавиш, которое уже имеется, либо отыскать незадействованное, которое было бы удобно и для пальцев и для мозга. Я пробовал найти удобные незанятые, но остановился на переопределении. И это тоже удручает, так как потенциально может лишить вас первоначальных возможностей данных сочетаний при их переопределении. А также ограничить в последующем, когда вам понадобятся новые комбинации клавиш для новых плагинов, а удобные уже задествованы для вызовов разных build-вариантов.
И тут я попробовал отписанный мне в комментариях плагин [ProjectBuild](https://github.com/Snegovikufa/ProjectBuild) для Sublime Text 2 от [snegovikufa](http://habrahabr.ru/users/snegovikufa/). Что мне очень-очень понравилось, так это выпадающая панель со списком команд. Выбрав элемент из представленного списка, можно было запустить соответствующую команду. Все настройки этого плагина хранились в отдельном файле, доступ к которому был из меню самого Sublime Text 2, там можно было перечислить список именований и соответствующих им команд. Проще говоря, этот плагин мог быть настроен для запуска «сторонней программы» непосредственно из интерфейса Sublime Text 2. И в частности его можно было использовать для запуска Ant c именами необходимых целей. Я в лоб прикрутил ProjectBuild к своему «AntProjectBuilder.sublime-build». Таким образом, это решило вторую проблему. Назначаем одно сочетание клавиш (да хоть тоже «Ctrl+Shift+B»), оно формирует панель плагина ProjectBuild в интерфейсе Sublime Text 2, где можно выбрать и запустить нужную команду в соответствии с конфигурацией ProjectBuild.
Но плагин работал так, что вызывая «стороннюю программу» хотя и не блокировал интерфейс самого Sublime Text 2, но не оставлял следов об успешности или неуспешности вызова. Например, у меня вызывалась командная строка, в ней отрабатывал Ant, и она пропадала. В консоли самого Sublime Text 2 следов не оставалось. А этого удалось добиться только с блокировкой интерфейса Sublime Text 2. То есть вызвали команду, интерфес Sublime Text 2 подвисал, а отработав этот процесс выплевывал весь свой output в консоль Sublime Text 2. Весь процесс «по ходу» наблюдать не удавалось.
И при таком использовании, когда ProjectBuild должен реализовывать функционал именно build-механизма Sublime Text 2, не решалась первая проблема — явного указания вариантов, причем так же существовало излишнее конфигурирование. Приходилось конфигурировать ProjectBuild для того, чтоб сформировать список вариантов для панели, хотя этот список вариантов уже есть непосредственно в самом "\*.sublime-build" файле выбранной Build System. Я связался с [snegovikufa](http://habrahabr.ru/users/snegovikufa/), он быстро ввел меня в курс дела, как работать с GitHub, и я приступил к изменению плагина.
#### Оффтоп о процессе переделки плагина ProjectBuild
##### GitHub
Mеня очень порадовала эта система «учета кода» (конечно же я утрирую), я никогда ранее не работал c git, но на то, чтоб разобраться с ней ушло менее получаса, тем более, что есть исчерпывающее руководство по git как для Linux, так и для Windows пользователей на самом GitHub. Я написал рабочий код, [snegovikufa](http://habrahabr.ru/users/snegovikufa/) его качественно переработал на предмет нотации Python, и так далее, поправляя друг друга и списываяь, получили результат, вылизанный рабочий итог сейчас в [dev ветке](https://github.com/Snegovikufa/ProjectBuild/tree/dev) Вещь! Мое первое впечатление, совместная разработка и git (GitHub в частности) — созданы друг для друга.
##### API Sublime Text 2 и Python
Есть [официальная](http://www.sublimetext.com/docs/2/) и [неофициальная](http://sublime-text-unofficial-documentation.readthedocs.org/en/latest/index.html) документации. Вначале казалось, что возможности API у Sublime Text 2 не так уж и велик*и*, но их вполне хватило. Чего не хватило, реализовалось на Python. Как сказал ранее, я не знаю Python, но для разработки задуманного функционала плагина больш*и*х знаний и не потребовалось. Да и [snegovikufa](http://habrahabr.ru/users/snegovikufa/) оперативно поправил потенциально непонятные для третьих лиц моменты. Единственное, что я хотел ради интереса найти, но так и не смог, так это список всех возможных ключей и значений Settings, которые существуют у Sublime Text 2 по умолчанию, хотя может плохо искал.
По формату файла "\*.sublime-workspace" в документации сказано, что это формат JSON, но было выяснено, что при json-парсинге этого файла может вылетать ошибка. Дело в том, что json-ключ в его данных может быть пустым, но это было проигнорировано плагином ProjectBuild так:
```
... json.load (f, strict = False)
```
Еще у Sublime Text 2 в "\*.sublime-build" файле может быть задействована переменная с "$project\_path", и мне совершенно не понятно, почему разработчики Sublime Text 2 не предусмотрели ее (и других) использование в путях у сочетаний клавиш, где, например, вызываются «сторонние» для Sublime программы. Может это в целях безопасности, чтоб какой-нибудь плагин по сработавшему сочетанию клавиш что-нибудь не упёр что-то «себе» из проекта, но все же.
##### Итоговый код плагина
**Спойлер**
```
import sublime
import sublime_plugin
import json
import sys
import os
class ProjectBuildCommand (sublime_plugin.TextCommand) :
def run (self, edit = None) :
# Save file if dirty
if self.view.is_dirty () :
self.view.run_command ('save')
############################################
#
# Определяем файл .sublime-workspace
# он должен быть размещен в одной из корневых директорий
# проекта и должен быть единственным
#
workspace_file = None
root_folders = self.view.window ().folders ()
for dir_ in root_folders :
for dir_item in os.listdir (dir_) :
if dir_item.endswith ('.sublime-workspace') :
if workspace_file == None :
workspace_file = os.path.join (os.path.normpath(dir_), dir_item)
else :
self.showError (
'Must be only one ".sublime-workspace" file in project root folder.\n'
'Plugin found %s and %s files.' %
(workspace_file, os.path.join (dir_, dir_item)))
return
if workspace_file == None :
self.showError (
'There are no ".sublime-workspace" file in any root folder of project.')
return
self.debug(workspace_file)
#
############################################
############################################
#
# Получаем относительный путь до файла текущей Build System
#
with open (workspace_file) as f :
try:
workspace_json_data = json.load (f, strict = False)
except Exception, e:
self.showError (
'File .sublime-workspace is empty or has incorrect json data')
return
if not 'build_system' in workspace_json_data :
self.showError (
'There are no "build_system" value in %s file.\n'
'Choose Build System and save project.' % workspace_file)
return
build_filename = workspace_json_data['build_system']
self.debug(build_filename)
#
############################################
############################################
#
# Определяем наличие файла текущей Build System
# по полному пути до него
#
build_filename_fullpath = os.path.normpath( os.path.join(os.path.dirname(sublime.packages_path()),build_filename))
if not(os.path.isfile(build_filename_fullpath)):
self.showError (
'Plugin could not find Build System file: "%s".' %
build_filename_fullpath)
return
self.debug(build_filename_fullpath)
#
############################################
############################################
#
# Загружаем JSON данные
#
with open (build_filename_fullpath) as f :
try:
json_data = json.load (f)
except Exception, e:
self.showError (
'File %s is empty or has incorrect json data' %
build_filename_fullpath)
return
#
############################################
############################################
#
# Формируем словарь build-вариантов текущей Build System
#
build_variants = []
if "cmd" in json_data:
build_variants.append (['Default', " ".join (json_data["cmd"])])
for variant in json_data.get ("variants", {}) :
build_variants.append (
[variant['name'], " ".join (variant['cmd'])])
#
############################################
############################################
#
# Демонстрируем панель вариантов.
#
def run (selected) :
if (selected >= 0) :
self.execute_variant (build_variants[selected][0])
names = [name for name, args in build_variants]
self.view.window ().show_quick_panel (names, run)
#
############################################
def execute_variant (self, variant_name) :
self.view.window ().run_command ("build", {"variant": variant_name})
def showError (self, err) :
# демонстрируем сообщение об ошибке через Sublime API
# иногда не срабатывало, хотя оно и должно было появляться
sublime.error_message ('ProjectBuild:\n\n%s' % err)
def debug (self, message) :
# change True to False or vice versa
if (False): print message
```
#### Выводы
Теперь для ProjectBuild не нужен конфиг. Вам достаточно выбрать необходимую Build System (стандартную систему или вашу собственную, как моя «AntProjectBuilder.sublime-build»). Сохранить проект в Sublime Text 2 таким образом, чтоб в одной из корневых его папок лежал файл манифеста проекта "\*.sublime-workspace". Плагином ProjectBuild отслеживается наличие этого файла и его уникальность, так как сведения о текущей Build System берутся именно из него. При изменении Build System в Sublime Text 2 не забудте сохранить проект, чтоб указанный выше файл обновился. Нажимаем назначенное для ProjectBuild сочетание клавиш и видим панель со списком build-вариантов. Список формируется автоматически по существующему в "\*.sublime-build" файле описанию вариантов выбранной в Sublime Text 2 системы Build System.
[](https://habrastorage.org/getpro/habr/post_images/d57/17b/7cd/d5717b7cd5bc02bb9b1ae0ab8d212503.png)
Указанные в самом начале статьи проблемы были успешно решены: задействовано одно сочетание клавиш и оно работает с build-механизмом непосредственно самого Sublime Text 2 и в его интерфейсе без жесткой привязки и явного именования вызываемых build-вариантов.
У плагина осталось пространство для доработки, например, сейчас игнорируется платформо-срецифичные опции, которые могут быть указаны в файле Build System, но лично мне пока и так вполне достаточно, да и необходимо мне именно то, что он сейчас и реализует.
На самом деле сложно сказать, чей вклад больше, да и важно ли это, если в итоге плагин ProjectBuild стал тем, чем, наверно, и должен был быть. И что уж греха таить, я испытываю неописуемое чувство гордости, что вот не было такого в интерфейсе и функционале Sublime Text 2, а теперь такое есть, и что это написано отчасти мной. (тут я еще не знал о «велосипеде», о, горе мне, горе)
Прежний вариант ProjectBuild будет скорее всего переделан в плагин OneHotkey по группировке команд в одно сочетание клавиш, не обязательно build команд, а просто команд запуска «сторонних» для Sublime Text 2 программ и т.п. и там уже пригодится файл настроек, который был раньше у ProjectBuild и оказался для него лишним, так как содержал для build-механизма избыточную информацию.
#### Обещанный велосипед
Все острова давным давно открыты… Как оказалось, уже изначально в Sublime Text 2 уже есть возможность вызова панели выбора вариантов текущей Build System, вам необходимо просто добавить сочетание клавиш:
```
{ "keys": ["f8"], "command": "show_overlay", "args": {"overlay": "command_palette", "text": "Build: "} }
```
И эта панель, как не печально было бы об этом говорить, удобнее, так как не привязывает вас с файлу "\*.sublime-workspace" и демонстрирует назначенные сочетания клавиш для каждого варианта, если таковые уже имеются. Однако она не поддерживает их сортировку, а плагин можно доработать на предмет упорядочивания вариантов (хотя может опять я чего не ведаю).
Наверно, все что можно выжать из этого всего, так это вернуться обратно к OneHotkey.
Спасибо за внимание. | https://habr.com/ru/post/149829/ | null | ru | null |
# Перенаправление сеанса X11 через ssh в Mac OS X
Не секрет, что работая на десктопе с линуксом, и в случае необходимости запустить на удаленном сервере какую-либо графическую программу, набор действий чрезвычайно прост:
`kostik@kostik: ~> ssh -X 192.168.1.2`
Однако, работая на Маке есть несколько дополнительных шагов, которые необходимо сделать, чтобы все было так же просто.
1) Если у вас не стоит X11 (а проверить это можно посмотрев в /Applications/Utilities/ на наличие там приложения X11.app, или через спотлайт, что значительно быстрее :) ), то поставить его можно с установочного диска Mac OS X из дополнительных пакетов.
2) Перед заходом на удаленный сервер с целью запуска графического приложения, надо чтобы X11 уже были запущены.
3) Так же необходимо, чтобы переменная окружения DISPLAY была установлена в :0.0 (в Мак ОС по умолчанию при открытии шела, DISPLAY выставляется во что-то вроде /tmp/launch-CjJQkr/:0)
Можно это все, точнее пункты 2 и 3, проделывать каждый раз заново. А можно один раз прописать алиас в свой .bash\_profile:
`alias sshx='export DISPLAY=:0.0 && open /Applications/Utilities/X11.app && ssh -X'`
после чего не задумываясь о настройке и запуске X11 коннектиться к серверу:
`kostik@kostik: ~> sshx 192.168.1.2`
На всякий случай поясню, что данный алиас устанавливает переменную окружения $DISPLAY, затем открывает приложение X11 и выпаолняет команду ssh -X с дальнейшими параметрами командной строки, в данном случае это IP сервера.
Вот собсно и все.
Надеюсь кому-то пригодится. | https://habr.com/ru/post/84061/ | null | ru | null |
# 19 принципов разработки по БЭМ, или что должен знать каждый разработчик библиотек
БЭМ набирает популярность и становится актуальнее — например, недавно Google выпустил новую библиотеку блоков под названием [Material Design Lite](http://www.getmdl.io/), реализованную по [БЭМ-методологии](https://ru.bem.info/method). Команда БЭМ тоже не сидела без дела — мы выпустили новую версию библиотеки [bem-components](https://ru.bem.info/libs/bem-components/), на базе которой построены сайты и проекты не только Яндекса, но и других разработчиков.
Эти события натолкнули нас на мысль ещё раз вспомнить и рассказать вам, как сформировались принципы разработки библиотек в БЭМ-методологии. Надеемся, что многим это будет интересно и полезно. Итак, поехали.
Долгое время мы создавали библиотеки блоков, пользуясь в основном интуицией и, как нам тогда казалось, чувством прекрасного. На этом тернистом пути было набито много шишек и усвоено много уроков. В результате у нас родился новый [документ](https://ru.bem.info/libs/principles), содержащий принципы разработки библиотек, которым мы пользуемся сейчас как чеклистом при разработке каждого нового блока. На наш взгляд, эти простые и очевидные принципы дают нам возможность получить продуманный, удобный, масштабируемый и легкий в поддержке код.
Если вы хотите узнать на примерах, как мы пришли к нашим принципам разработки, добро пожаловать под кат.
Немного истории, или о том, как мы ходили по граблям
----------------------------------------------------
Когда мы начинали работать над библиотеками, нам, как и большинству разработчиков, хотелось сделать быстро, красиво и для всех. У нас было много идей и много проектов, которые хотели использовать библиотеку.
Но на практике не всегда получается так, как хочется…
### Потерять себя, угождая всем
Кто работал в крупных и молодых компаниях, знает, как здесь любят «придумывать велосипеды»: так же было и у нас. Каждая группа разработчиков создавала блоки для себя. По сути все команды делали одно и то же, но разными способами. Первое время получалось достаточно быстро. Но количество реализаций одного и того же блока слишком быстро росло. Когда стало понятно, что всем проектам нужен общий набор блоков (например, всем были нужны одинаковые шапки и подвалы), мы решили вынести общие блоки в отдельную библиотеку. Нам казалось это грамотным и взвешенным решением, которое должно было навести порядок среди множества одинаковых блоков.
Мы начали разрабатывать универсальную библиотеку. Нам хотелось создать общие блоки для всех проектов настолько продуманными, чтобы они соответствовали требованиям каждого отдельного проекта. Мы учли все случаи использования блока (до самых редких и едва ли возможных) и попытались сделать блоки максимально удобными для пользователей. Так код каждого блока раздулся до неприличных размеров, а 90% случаев, которые мы предусмотрели, никем не использовались. Несмотря на это, нам приходилось все равно поддерживать весь этот код. Исправление любой ошибки затягивалось.
### Скорость в приоритете
Так как код наших блоков использовался внутри Яндекса, то разработчики отдельных проектов зависели от наших релизов. Поэтому нам важна была скорость, с которой мы разрабатывали блоки.
Unit-тесты мы не писали, так как нам казалось, что проектов не так много и мы успеваем отловить все ошибки. Но количество блоков росло, количество проектов — тоже. А вот количество разработчиков хоть и увеличивалось, но далеко не такими же быстрыми темпами. Нас завалили багрепорты.
### Больше прав пользователям, меньше — разработчикам
Мы хотели сделать очень удобную библиотеку. Для этого мы выделили широкий публичный API, предоставив пользователям много пространства для маневра. Однако мы не учли, что так сами свяжем себе руки. Мы не могли сделать практически никаких изменений, не затронув внешний API. Возникающие ошибки исправлялись, мы выпускали новые версии. Но разработчики всё чаще отказывались переходить со старых версий библиотеки, потому что такой переход беспощадно ломал всё в проектах и занимал большое количество времени.
### Нюансы стилевого оформления
Так все сайты, которые пользовались нашей библиотекой, имели одинаковый дизайн, мы не стали выносить стилевое оформление из ядра библиотеки. Чтобы реализовать нашу тему, мы сбрасывали общие стили и накладывали свои.
Так можно было жить ровно до того момента, пока одному из разработчиков не понадобилось изменить привычный вид контролов (например, сделать промостраницу «поярче»). Добавление новых стилей вызвало ряд проблем: стили конфликтовали друг с другом, а при их отмене контролы не хотели работать корректно. Пришлось признать, что способ реализации темы непосредственно в общем коде блока не оправдал себя. Мы пришли к выводу, что продумывая архитектуру, необходимо закладывать возможность добавления новых тем в проект.
### Злоупотребление значениями по умолчанию
Мы любили использовать значения по умолчанию для модификаторов. С одной стороны, это удобно, так как можно не указывать значение и получать рабочий контрол. С другой — значение по умолчанию всё же лишает разработчика возможности влиять на модификатор. То есть существует ограниченный ряд значений. Например, у нас есть кнопка и размеры к ней задаются через модификаторы (s, m, l, xl). Не указав модификатор, мы получали значение по умолчанию — m.
Но всегда наступает момент, когда необходимо использовать кастомное значение. Когда нам требовалось задать размер, не совпадающий ни с одним из предложенных значений модификатора, в сборку всё равно попадал лишний код про размеры. Разработчикам библиотеки приходилось много времени тратить на рефакторинг, так как они были вынуждены поддерживать все дефолтные настройки.
Мы использовали общий сброс стилей, поэтому базовая реализация блока без темы не работала. Таким образом, мы сами загоняли себя в жесткие рамки, которые было очень сложно менять.
Конечно, были и другие ошибки, про которые можно рассказывать. И мы не жалеем, что столкнулись со всеми трудностями. Это помогло нам сформировать свой подход к разработке библиотек, определить приоритеты и сформулировать простые, понятные принципы разработки БЭМ-библиотек.
Как формировались принципы
--------------------------
Мы оценили масштабы прошлых бедствий и сделали выводы, собрав весь наш опыт в одной универсальной библиотеке — [bem-components](https://ru.bem.info/libs/bem-components/), новый релиз которой состоялся совсем недавно. Сейчас мы расскажем об основных трансформациях нашего подхода и о положительном опыте создания библиотек блоков.
### Универсальный блок и блок, делающий всё и для всех — не одно и то же
В первую очередь, мы решили, что больше не будем пытаться угодить всем. Теперь мы начинаем разработку блока или дополнительной функциональности к нему только если видим в этом реальную необходимость. Необходимость определяется из количества проектов, в которых используется блок, из объема необходимых правок в коде для реализации, из необходимости изменять публичный API и времени, требуемого на переход на новую версию.
Мы стараемся создавать универсальные блоки, которые могут служить базой, основой, и использоваться в любом проекте. Все уникальные требования пользователей могут быть реализованы ими самостоятельно с помощью до- и переопределения базового блока. Благодаря этому у нас появилась возможность брать на себя ответственность за произведенный продукт. Мы стараемся сделать блок как можно проще, как результат пользователи получают понятный код, в котором легко разобраться, и который легко переопределить под нужды конкретного проекта.
Помимо сокращения функциональности блоков, мы поддерживаем единообразие на всех уровнях библиотеки. Например, если в одном блоке размеры задаются с помощью модификатора, то и размеры другого блока также должны выражаться через модификатор. Нет необходимости создавать новое событие или подписываться на него, если есть возможность работать с событием на изменение модификатора.
Мы отказались от использования значений по умолчанию в тех местах, где это было возможно. Теперь у пользователя библиотеки появилось больше возможностей влиять на код и переопределять его.
Следует также отметить, что мы значительно сузили публичный API, тем самым дали себе больше свободы на изменение блоков, а пользователям — больше уверенности в том, что заявленный API стабилен и не будет часто меняться.
### Полный и безоговорочный Open Source
Мы сделали разработку блоков открытой. Вынесли весь код на Github и стали выпускать версии библиотеки по правилам [семантического версионирования](http://semver.org/). Выпуск каждой мажорной версии теперь сопровождается подробным описанием [истории изменений](https://ru.bem.info/libs/bem-components/current/changelog/) и [руководством по миграции](https://ru.bem.info/libs/bem-components/current/migration/) на новую версию.
Мы приняли решение полностью покрывать код тестами. Это усложняет и замедляет создание блока, но заметно упрощает его поддержку. Релиз новой версии не происходит до тех пор, пока весь код не покрыт тестами.
Помимо всего перечисленного, мы считаем, что если процесс можно автоматизировать, то это нужно делать обязательно. Роботы должны выполнять все повторяющиеся действия, освобождая время разработчиков, которое, кстати, можно потратить на написание тестов.
### Больше ясности в API
Переход на новые версии стал значительно проще еще и потому, что мы внесли больше ясности в разделение приватного и публичного API. У нас появились формальные признаки, которые явно показывают, что это, к примеру, приватный API (название метода начинается с подчеркивания), а значит, никто не гарантирует его неизменность. А вот публичный API используйте на здоровье — его изменение возможно только при выпуске новой мажорной версии.
### Архитектура блока должна продумываться заранее
Мы не приступаем к разработке блока, пока окончательно не определимся с его архитектурой. Конечно, мы не можем предсказать, что во время разработки нам не понадобится реализовать дополнительную функциональность, которая не была учтена в самом начале. Но хорошо продуманная архитектура обычно делает блок легко расширяемым и позволяет без дополнительных переделок добавить что-то недостающее.
Именно так мы поступаем сейчас со стилевым оформлением блоков — тема реализована с помощью модификатора. Для добавления новой темы достаточно задать новое значение модификатора. Даже если в библиотеке предусмотрена только одна тема, мы все равно выносим ее реализацию в отдельный модификатор. При этом у нас всегда создается служебная тема Simple, которая позволяет проверить, что при добавлении новой темы, стили не конфликтуют. Также все блоки реализованы таким образом, что их базовая функциональность работает, даже если модификатор темы не указан.
Можно долго рассказывать, как мы строили-строили и наконец построили. Но, как говорится, лучше один раз увидеть — итог нашей работы библиотека bem-components. Ну и, конечно, осталось перечислить сами принципы, которые помогают нам делать наш продукт лучше, проще и понятнее.
Принципы разработки БЭМ-библиотек
---------------------------------
В результате анализа нашей многолетней работы мы сформулировали короткие принципы разработки библиотек. На первый взгляд в этом списке много очевидных правил, но очевидность не делает их менее важными.
### 1. Открытый исходный код
Разработка библиотеки ведется на GitHub, где доступны все задачи и планы. Любой разработчик может принять участие в работе над библиотекой: создать задачу с пожеланиями для команды или прислать pull request.
### 2. Простота использования
Библиотека должна быть максимально простой. Откажитесь от всего, что может расцениваться или использоваться неоднозначно.
### 3. Минимализм
Проектируя необходимую функциональность, стремитесь к пересечению, а не объединению потребностей. В ситуации выбора предпочтителен тот вариант, который решает задачу меньшим количеством кода, БЭМ-сущностей или проще в поддержке.
### 4. Покрытие тестами
Код библиотеки должен быть покрыт тестами. Это гарантирует меньшее число ошибок и экономию времени на поддержку в будущем. Код не считается законченным и стабильным, пока он не покрыт тестами. Pull request'ы с новыми фичами, но без добавления или изменения тестов не принимаются.
### 5. Единообразие
Все названия полей и методов должны быть унифицированы в рамках одной или нескольких совместимых библиотек. Если в блоке методы, модификаторы или поля называются определенным образом, то в похожей задаче нужно придерживаться той же логики именования. Последовательность и согласованность всех сущностей должны быть доведены до абсолюта. Важно, чтобы логика именования была понятна и другим разработчикам, которые будут использовать библиотеку или модифицировать ее код.
### 6. Разделение на приватный и публичный API
Приватный API блока не должен использоваться вне этого блока.
Публичный API следует делать минималистичным, не предоставляя ничего лишнего. Обязательно указывайте в документации возможные способы его использования. Стабильность публичного API гарантируется соблюдением правил [семантического версионирования](http://semver.org).
### 7. Тонкая настройка пользователем
В процессе разработки заранее продумывайте возможность гибкого до- и переопределения шаблонов, стилей и скриптов на стороне пользователя. [Например](https://github.com/bem/bem-components/blob/v2/common.blocks/button/button.bemhtml#L10), возможность указать HTML-тег во входном BEMJSON, переопределив шаблон.
### 8. Поддержка нескольких тем
Библиотека должна поддерживать несколько тем. Это позволит корректно создавать правила для каждого стиля, а также избежать конфликтов с новыми темами. Сейчас основная тема БЭМ-библиотек — islands, в ней выполнен новый дизайн Яндекса. Реализация нескольких тем внутри одной библиотеки представлена в bem-components, где вместе с islands есть дополнительная тема simple.
### 9. Явное лучше неявного (в JavaScript API)
Название метода должно максимально точно отражать суть и сразу давать понять, что он реализует. Такой подход позволяет снизить порог входа и сделать API более понятным.
### 10. Явные умолчания
Умолчания должны быть явно задекларированы — это внешний API. Любые их изменения препятствуют обратной совместимости. Неявные и нигде не описанные умолчания создают проблемы в поддержке библиотеки.
### 11. Обработка ошибок
Входные данные следует проверять перед использованием, генерируя в случае ошибки исключение, которое может быть обработано в вызывающем коде. Обработка ошибок должна происходить единообразно во всей библиотеке: не стоит добавлять в блок сложную валидацию данных, если в аналогичном случае она не происходит.
### 12. Предметная область БЭМ
Все, что может выражаться через БЭМ-сущность, должно через нее выражаться.
### 13. Модификаторы vs. специализированные поля
Модификатор — это заранее известный набор положений или состояний. Специализированное поле — заранее неизвестный набор вариативных значений.
Все, что может быть выражено в виде конечного набора значений, нужно реализовывать модификатором. Где это невозможно, используйте специализированные поля.
### 14. Иерархия блоков
Взаимодействие между блоками следует строить в иерархическом порядке. Блок не может взаимодействовать с внешними или соседними блоками.
### 15. Оптимизация на уровне блока
Решения по оптимизации должны внедряться во время разработки каждого конкретного блока. Заранее продумывайте возможные пути оптимизации, чтобы в дальнейшем их было проще реализовать в уже написанном коде.
### 16. Автоматизация рутинных процессов
Все повторяющиеся действия, такие как вставка картинок, расстановка префиксов или копирование стилей, следует автоматизировать. Разработчик не должен заниматься рутиной, для этого есть роботы.
### 17. Мобильные платформы без адаптивной верстки
Библиотека должна поддерживать мобильные платформы. Использовать адаптивную верстку не рекомендуется. Библиотека должна работать во всех браузерах, поддержка которых заявлена: допускаются деградации только стилевого оформления компонентов, но не их функциональности.
### 18. Доступность
Компоненты библиотеки должны быть доступны для чтения программами экранного доступа (accessibility), но расширять для этого публичный API не следует. Выставление всех необходимых ARIA-атрибутов реализуется на уровне шаблонов и скриптов.
### 19. Bleeding edge
Библиотека разрабатывается с ориентацией на будущее. Всегда используйте последние версии браузеров и инструментов, чтобы сохранить ее актуальность в процессе разработки как можно дольше.
Перечисленные принципы помогают нам развивать БЭМ-библиотеки: все желающие могут участвовать в разработке. Сформулировав для себя основные принципы разработки, нам также удалось разработать внутренние правила контрибъюта в наши библиотеки.
Пример следования принципам — библиотека bem-components
-------------------------------------------------------
Мы создали библиотеку, руководствуясь перечисленными принципами. bem-components — это основной opensource-продукт команды БЭМ.
Библиотека bem-components содержит 22 готовых контрола. При этом она никак не ограничивает вас от добавления недостающей функциональности.
Мы предусмотрели различные способы подключения библиотеки в проект. Обо всех [способах подключения](https://ru.bem.info/libs/bem-components/current/#usage) читайте в описании библиотеки на нашем сайте.
Начиная с версии [2.3.0](https://ru.bem.info/libs/bem-components/v2.3.0/), библиотеку bem-components можно использовать по аналогии с Bootstrap — поставка в виде [Dist](https://ru.bem.info/libs/bem-components/v2.3.0/#Подключение-предсобранных-файлов-библиотеки-dist). Теперь вы можете просто скопировать код библиотеки в проект и убедиться на конкретных примерах, как реализованы принципы в каждом блоке.
Поставка библиотеки в виде Dist предоставляет предсобранный CSS- и JavaScript-код и шаблоны. Библиотека подключается ссылками на страницу и не требует сборки.
Самый простой способ начать работать с библиотекой — подключить файлы с CDN. Для этого добавьте элементы `````
и в HTML страницы:
```
*Схема подключения файла с CDN:* //yastatic.net/название-библиотеки/версия/платформа/имя-файла.
*Пример:* <https://yastatic.net/bem-components/latest/desktop/bem-components.dev.js+bh.js>.
Другие способы подключения bem-components в виде Dist, а также подробные способы работы с библиотекой описаны в [документации](https://ru.bem.info/libs/bem-components/v2.3.0/#Работа-с-библиотекой-в-виде-dist).
Если суммировать все принципы создания библиотек, то можно сделать короткий вывод — необходимо стремиться сделать разработку простой для создателей библиотек и удобной — для пользователей.
Удачи вам в написании своих проектов и побольше счастливых пользователей!
**P.S.** Обязательно пишите нам на [форум](https://ru.bem.info/forum/?labels=bem-components) о том, что понравилось, а что вызвало вопросы.`` | https://habr.com/ru/post/267875/ | null | ru | null |
# Что происходит в Kubernetes при запуске kubectl run? Часть 1
***Прим. перев.**: Этот материал, озаглавленный в оригинале как «What happens when… Kubernetes edition!» и написанный Jamie Hannaford из компании Rackspace, является отличной иллюстрацией работы многих механизмов Kubernetes, которые зачастую скрыты от нашего глаза, но весьма полезны для лучшего понимания устройства этой Open Source-системы, алгоритма работы и взаимосвязей её компонентов. Поскольку вся статья весьма объёмна, её перевод разбит на две части. В первой речь идёт про работу kubectl, kube-apiserver, etcd и initializers.
P.S. Некоторые оригинальные ссылки на код в master-ветках были заменены на последние к моменту перевода коммиты, чтобы актуальность номеров строк, к которым отсылает автор, сохранялась долгое время.*
Представим, что я хочу задеплоить nginx в кластере Kubernetes. Я введу в терминале нечто такое:
```
kubectl run --image=nginx --replicas=3
```
… и нажму на Enter. Через несколько секунд увижу 3 пода с nginx, распределённые по всем рабочим узлам. Работает — словно по волшебству, и это здорово! Но что на самом деле происходит под капотом?
Одно из замечательных свойств Kubernetes — как эта система обслуживает развёртывание рабочих нагрузок в инфраструктуре через дружелюбные к пользователям API. Вся сложность скрыта простой абстракцией. Однако для того, чтобы полностью осознать ценность, которую приносит K8s, полезно понимать внутреннюю кухню. Эта статья проведёт вас через весь жизненный цикл запроса от клиента до kubelet, при необходимости ссылаясь на исходный код для иллюстрации происходящего.
Это живой документ. Если вы найдёте, что улучшить или переписать, изменения приветствуются! *(Речь, конечно, об оригинальной англоязычной статье в [GitHub](https://github.com/jamiehannaford/what-happens-when-k8s) — прим. перев.)*
kubectl
-------
### Валидация и генераторы
Итак, начнём. Мы только что нажали на Enter в терминале. И что теперь?
В первую очередь kubectl выполнит валидацию на стороне клиента. Он убедится, что нерабочие запросы (например, создание ресурса, который не поддерживается, или использование образа с [неправильно указанным названием](https://github.com/kubernetes/kubernetes/blob/701d6536a2584fbf4decdee38c81bc443d21df74/pkg/kubectl/cmd/run.go#L163)) быстро прервутся и не будут отправлены в kube-apiserver. Так улучшается производительность системы — благодаря снижению ненужной нагрузки.
После валидации kubectl начинает составлять HTTP-запрос, который будет отправлен kube-apiserver. Все попытки получить доступ к состоянию или изменить его в системе Kubernetes проходят через сервер API, который в свою очередь общается с etcd. И kubectl здесь не исключение. Чтобы составить HTTP-запрос, kubectl использует так называемые генераторы ([generators](https://kubernetes.io/docs/user-guide/kubectl-conventions/#generators)) — абстракцию, реализующую сериализацию.
Не совсем очевидным здесь может показаться то, что в `kubectl run` допускается указание множества типов ресурсов, не только Deployments. Чтобы это работало, kubectl [вычисляет](https://github.com/kubernetes/kubernetes/blob/701d6536a2584fbf4decdee38c81bc443d21df74/pkg/kubectl/cmd/run.go#L231-L257) тип ресурса, если имя генератора не было специально указано через флаг `--generator`.
Например, ресурсы, у которых есть `--restart-policy=Always`, рассматриваются как Deployments, а ресурсы с `--restart-policy=Never` — как поды. Также kubectl выяснит, какие другие действия необходимо предпринять — например, запись команды (для выкатов или аудита) — и является ли эта команда пробным прогоном (по наличию флага `--dry-run`).
Разобравшись, что мы хотим создать Deployment, kubectl воспользуется генератором `DeploymentV1Beta1` для создания [runtime-объекта](https://github.com/kubernetes/kubernetes/blob/7650665059e65b4b22375d1e28da5306536a12fb/pkg/kubectl/run.go#L59) из предоставленных параметров. Runtime object — это обобщающий термин для ресурса.
### Группы API и «переговоры о версиях»
Перед тем, как продолжим, важно отметить, что Kubernetes использует версионный API, который классифицируется по группам API *(API groups)*. Группа API предназначена для отнесения в одну категорию схожих ресурсов, чтобы с ними было проще взаимодействовать. Кроме того, она является хорошей альтернативой единому монолитному API. Группа API для Deployment называется `apps` и её последняя версия — `v1beta2`. Именно это вы указываете вверху определений Deployment: `apiVersion: apps/v1beta2`.
*(**Прим. перев.**: Как мы рассказывали в [анонсе Kubernetes 1.8](https://habrahabr.ru/company/flant/blog/338230/), сейчас в проекте идёт работа над созданием новой группы Workload API, в которую войдут Deployments и другие API, относящиеся к «рабочим нагрузкам».)*
В общем, после того, как kubectl сгенерировал runtime-объект, он [начинает искать](https://github.com/kubernetes/kubernetes/blob/701d6536a2584fbf4decdee38c81bc443d21df74/pkg/kubectl/cmd/run.go#L580-L597) соответствующую ему группу API и версию, после чего [собирает](https://github.com/kubernetes/kubernetes/blob/701d6536a2584fbf4decdee38c81bc443d21df74/pkg/kubectl/cmd/run.go#L598) клиента нужной версии — в нём учитывается различная REST-семантика для ресурса. Этот этап обнаружения и называется «переговором о версии» *(version negotiation)*, включает в себя сканирование содержимого `/apis` на удалённом API для получения всех возможных групп API. Поскольку kube-apiserver выдаёт структурный документ (в формате OpenAPI) по этому пути (`/apis`), клиентам легко выполнять обнаружение.
Для улучшения производительности kubectl также [кэширует](https://github.com/kubernetes/kubernetes/blob/7650665059e65b4b22375d1e28da5306536a12fb/pkg/kubectl/cmd/util/factory_client_access.go#L117) OpenAPI-схему в директории `~/.kube/schema`. Если хотите посмотреть на обнаружение API в действии, попробуйте удалить этот каталог и запустить команду с максимальным значением флага `-v`. Вы увидите все HTTP-запросы, пытающиеся найти версии API. И их много!
Финальный шаг — [отправка](https://github.com/kubernetes/kubernetes/blob/701d6536a2584fbf4decdee38c81bc443d21df74/pkg/kubectl/cmd/run.go#L628) HTTP-запроса. Когда она сделана и получен успешный ответ, kubectl выведет успешное сообщение [с учётом](https://github.com/kubernetes/kubernetes/blob/701d6536a2584fbf4decdee38c81bc443d21df74/pkg/kubectl/cmd/run.go#L403-L407) предпочтительного формата вывода.
### Аутентификация клиента
На прошлом шаге мы не упомянули аутентификацию клиента (она происходит до отправки HTTP-запроса) — рассмотрим и её.
Для успешной отправки запроса kubectl необходимо аутентифицироваться. Учётные данные пользователя почти всегда хранятся в файле `kubeconfig`, хранимом на диске, однако он может находиться в разных местах. Для его поиска kubectl делает следующее:
* если указан флаг `--kubeconfig` — использует его;
* если определена переменная окружения `$KUBECONFIG` — использует её;
* в ином случае проверяет [предполагаемый](https://github.com/kubernetes/client-go/blob/1a014f453972bd8c8183f6f105cc9a623ccc6ba3/tools/clientcmd/loader.go#L52) домашний каталог вроде `~/.kube` и использует первый найденный файл.
После парсинга файла определяются текущий контекст, текущий кластер и аутентификационные сведения для текущего пользователя. Если пользователь задал специальные значения через флаги (такие, как `--username`), приоритет отдаётся им и они переписывают значения, указанные в `kubeconfig`. Когда информация получена, kubectl устанавливает конфигурацию клиента, делая её соответствующей потребностям HTTP-запроса:
* сертификаты x509 отправляются через [`tls.TLSConfig`](https://github.com/kubernetes/client-go/blob/82aa063804cf055e16e8911250f888bc216e8b61/rest/transport.go#L80-L89) (root CA тоже входит сюда);
* токены клиента [отправляются](https://github.com/kubernetes/client-go/blob/c6f8cf2c47d21d55fa0df928291b2580544886c8/transport/round_trippers.go#L314) в HTTP-заголовке `Authorization`;
* пользователь и пароль [отправляются](https://github.com/kubernetes/client-go/blob/c6f8cf2c47d21d55fa0df928291b2580544886c8/transport/round_trippers.go#L223) через базовую аутентификацию HTTP;
* процесс аутентификации через OpenID предварительно осуществляется пользователем вручную, в результате чего появляется токен, который отправляется аналогично соответствующему пункту выше.
kube-apiserver
--------------
### Аутентификация
Итак, запрос был отправлен, ура! Что дальше? В дело вступает kube-apiserver. Как упоминалось выше, kube-apiserver — основной интерфейс, используемый клиентами и системными компонентами для сохранения и получения состояния кластера. Для выполнения этой функции необходимо верифицировать запрашивающую сторону, убедившись, что она соответствует тому, за кого себя выдаёт. Этот процесс называется аутентификацией.
Как apiserver аутентифицирует запросы? Когда сервер впервые запускается, он проверяет все предоставленные пользователем [консольные флаги](https://kubernetes.io/docs/admin/kube-apiserver/) и собирает список подходящих аутентификаторов *(authenticators)*. Рассмотрим пример: если был передан `--client-ca-file`, будет добавлен аутентификатор x509; если указан `--token-auth-file` — к списку добавится аутентификатор токенов. Каждый раз при получении запроса он прогоняется через цепочку аутентификаторов, пока один из них не сработает успешно:
1. [обработчик x509](https://github.com/kubernetes/apiserver/blob/51bebaffa01be9dc28195140da276c2f39a10cd4/pkg/authentication/request/x509/x509.go#L60) верифицирует, что HTTP-запрос зашифрован с TLS-ключом, подписанным корневым сертификатом удостоверяющего центра;
2. [обработчик токенов](https://github.com/kubernetes/apiserver/blob/51bebaffa01be9dc28195140da276c2f39a10cd4/pkg/authentication/request/bearertoken/bearertoken.go#L38) верифицирует, что предоставленный токен (определён в HTTP-заголовке `Authorization`) существует в файле на диске, указанном директивой `--token-auth-file`;
3. [обработчик basicauth](https://github.com/kubernetes/apiserver/blob/51bebaffa01be9dc28195140da276c2f39a10cd4/plugin/pkg/authenticator/request/basicauth/basicauth.go#L37) похожим образом убедится, что учётные данные для базовой аутентификации в HTTP-запросе соответствуют локальным данным.
Если ни один из аутентификаторов не завершится с успехом, запрос [не сработает](https://github.com/kubernetes/apiserver/blob/20bfbdf738a0643fe77ffd527b88034dcde1b8e3/pkg/authentication/request/union/union.go#L71) и вернёт агрегированную ошибку. Если аутентификация прошла успешно, заголовок `Authorization` убирается из запроса и сведения о пользователе [добавляются](https://github.com/kubernetes/apiserver/blob/e30df5e70ef9127ea69d607207c894251025e55b/pkg/endpoints/filters/authentication.go#L71-L75) в его контекст. Это даёт доступ к установленной ранее идентичности пользователя на последующих этапах (таких, как авторизация и admission controllers).
### Авторизация
Окей, запрос отправлен, kube-apiserver успешно верифицировал, что мы являемся теми, кем представляемся. Какое облегчение! Однако это ещё не всё. Мы можем и быть теми, кем представляемся, однако есть ли у нас права на выполнение этой операции? Идентичность и право доступа — это всё-таки не одно и то же. Чтобы продолжить, kube-apiserver должен авторизовать нас.
Способ, которым kube-apiserver выполняет авторизацию, очень схож с аутентификацией: из значений флагов он собирает цепочку авторизаторов *(authorizers)*, которые будут использоваться для каждого входящего запроса. Если **все** авторизаторы запрещают запрос, он [завершится](https://github.com/kubernetes/apiserver/blob/e30df5e70ef9127ea69d607207c894251025e55b/pkg/endpoints/filters/authorization.go#L60) с ответом `Forbidden` и остановится на этом. Если хоть один авторизатор одобрит запрос, он пройдёт дальше.
Примеры авторизаторов, входящих в состав релиза Kubernetes v1.8:
* [webhook](https://github.com/kubernetes/apiserver/blob/d299c880c4e33854f8c45bdd7ab599fb54cbe575/plugin/pkg/authorizer/webhook/webhook.go#L143), взаимодействующий с HTTP(S)-сервисом вне кластера K8s;
* [ABAC](https://github.com/kubernetes/kubernetes/blob/77b83e446b4e655a71c315ad3f3890dc2a220ccf/pkg/auth/authorizer/abac/abac.go#L223), реализующий политики из статического файла;
* [RBAC](https://github.com/kubernetes/kubernetes/blob/8db5ca1fbb280035b126faf0cd7f0420cec5b2b6/plugin/pkg/auth/authorizer/rbac/rbac.go#L43), реализующий роли RBAC *(Role-based access control — **прим. перев.**)*, добавленные администратором как ресурсы Kubernetes;
* [Node](https://github.com/kubernetes/kubernetes/blob/dd9981d038012c120525c9e6df98b3beb3ef19e1/plugin/pkg/auth/authorizer/node/node_authorizer.go#L67), проверяющий, что клиенты узлов кластера — например, kubelet — могут получать доступ только к ресурсам, находящимся на них самих.
Посмотрите на метод `Authorize` у каждого из них, чтобы увидеть, как они работают.
### Контроль допуска
Окей, мы аутентифицированы и авторизованы kube-apiserver. Что осталось? Сам kube-apiserver доверяет нам и разрешает продолжить, но у других частей системы в Kubernetes могут быть собственные глубокие убеждения по поводу того, что разрешено, а что — нет. Здесь вступают в дело [admission controllers](https://kubernetes.io/docs/admin/admission-controllers/#what-are-they).
Если авторизация отвечает на вопрос, имеет ли пользователь право, admission controllers проверяют запрос на соответствие более широкому спектру ожиданий и правил в кластере. Они являются последним оплотом контроля перед тем, как объект передаётся в etcd, и отвечают за оставшиеся в системе проверки, задающиеся целью убедиться, что действие не приведёт к неожиданным или негативным последствиям.
Принцип, по которому работают эти контроллеры, схож с аутентификаторами и авторизаторами, но имеет одно отличие: для admission controllers достаточно единственного отказа в цепочке контроллеров, чтобы прервать эту цепочку и признать запрос неудачным.
В архитектуре admission controllers прекрасна ориентация на способствование расширяемости. Каждый контроллер хранится как плагин в директории `plugin/pkg/admission` и создаётся для реализации потребностей маленького интерфейса. Каждый из них компилируется в главный бинарный файл Kubernetes.
Обычно admission controllers разбиты по категориям управления ресурсами, безопасности, установок по умолчанию и эталонной консистентности. Вот некоторые примеры контроллеров, занимающихся управлением ресурсов:
* `InitialResources` устанавливает лимиты по умолчанию для ресурсов контейнера, основываясь на предыдущем использовании;
* `LimitRanger` устанавливает значения по умолчанию для запросов и лимитов контейнера, гарантирует верхние границы для определённых ресурсов (512 Мб памяти по умолчанию, но не более 2 Гб);
* `ResourceQuota` считает количество объектов (подов, rc, балансировщиков нагрузки сервисов) и общие потребляемые ресурсы (процессор, память, диск) в пространстве имён и предотвращает их превышение.
etcd
----
К этому моменту Kubernetes полностью одобрил входящий запрос и разрешил двигаться дальше. Следующим шагом kube-apiserver десериализует HTTP-запрос, создаёт runtime-объекты из него (нечто вроде обратного процесса тому, что делают генераторы kubectl) и сохраняет их хранилище данных. Посмотрим на это в деталях.
Откуда kube-apiserver знает, что делать, принимая наш запрос? Для этого следует довольно сложная последовательность шагов, предваряющих обработку любых запросов. Посмотрим с самого начала — когда бинарный файл впервые запускается:
1. Когда бинарник kube-apiserver запущен, он [создаёт](https://github.com/kubernetes/kubernetes/blob/d12d711ba67af9c63c6497a3d73357729a76e9ab/cmd/kube-apiserver/app/server.go#L119) цепочку server chain, делающую возможной агрегацию Kubernetes apiserver. Это и есть основа для поддержки множества apiservers (о чём нам можно не беспокоиться).
2. Когда это происходит, [создаётся](https://github.com/kubernetes/kubernetes/blob/e19257f2ec87d8091defb7935bb3a161fbb229d0/cmd/kube-apiserver/app/server.go#L151) общий (generic) apiserver, выступающий в роли реализации по умолчанию.
3. Сгенерированная OpenAPI-схема [наполняет](https://github.com/kubernetes/apiserver/blob/7001bc4df8883d4a0ec84cd4b2117655a0009b6c/pkg/server/config.go#L149) конфигурацию apiserver.
4. Затем kube-apiserver последовательно проходит по всем группам API, определённым в схеме, и [настраивает](https://github.com/kubernetes/kubernetes/blob/c7a1a061c3dc5acabcc0c35b3b96a6935dccf546/pkg/master/master.go#L410) для каждого из них поставщика хранилища *(storage provider)*, выступающего в роли общей *(generic)* абстракции хранилища. С ним kube-apiserver взаимодействует, когда обращается к состоянию ресурса или изменяет его.
5. Для каждой группы API последовательно перебираются все версии группы и [устанавливаются](https://github.com/kubernetes/apiserver/blob/7001bc4df8883d4a0ec84cd4b2117655a0009b6c/pkg/endpoints/groupversion.go#L92) REST-соответствия каждому HTTP-маршруту. Это позволяет kube-apiserver находить соответствия запросам и делегировать логику найденному результату.
6. В нашем конкретном случае [регистрируется](https://github.com/kubernetes/apiserver/blob/7001bc4df8883d4a0ec84cd4b2117655a0009b6c/pkg/endpoints/installer.go#L710) POST-обработчик, который затем делегируется [обработчику создания ресурса](https://github.com/kubernetes/apiserver/blob/7001bc4df8883d4a0ec84cd4b2117655a0009b6c/pkg/endpoints/handlers/create.go#L37).
К этому моменту kube-apiserver знает, какие существуют маршруты и имеет внутренний mapping, указывающий на то, какие обработчики и поставщики хранилища должны быть вызваны при соответствии запроса. Предположим, в него попал наш HTTP-запрос:
1. Если цепочка обработчиков может найти соответствие запроса шаблону (т.е. зарегистрированным маршрутам), то [будет вызван](https://github.com/kubernetes/apiserver/blob/7001bc4df8883d4a0ec84cd4b2117655a0009b6c/pkg/server/handler.go#L153) нужный обработчик, зарегистрированный для этого маршрута. В ином случае вызывается [обработчик](https://github.com/kubernetes/apiserver/blob/7001bc4df8883d4a0ec84cd4b2117655a0009b6c/pkg/server/mux/pathrecorder.go#L248), основанный на путях (то же самое происходит при обращении к `/apis`). Если зарегистрированных обработчиков для этого пути нет, вызывается [обработчик not found](https://github.com/kubernetes/apiserver/blob/7001bc4df8883d4a0ec84cd4b2117655a0009b6c/pkg/server/mux/pathrecorder.go#L254), возвращающий 404.
2. К счастью для нас, есть зарегистрированный маршрут под названием [`createHandler`](https://github.com/kubernetes/apiserver/blob/7001bc4df8883d4a0ec84cd4b2117655a0009b6c/pkg/endpoints/handlers/create.go#L37). Что он делает? В первую очередь, он декодирует HTTP-запрос и выполняет базовую валидацию, такую как проверка соответствия предоставленных JSON-данных с ожиданиями для ресурса из API нужной версии.
3. [Происходит](https://github.com/kubernetes/apiserver/blob/7001bc4df8883d4a0ec84cd4b2117655a0009b6c/pkg/endpoints/handlers/create.go#L93-L104) аудит и финальный допуск.
4. Ресурс [сохраняется](https://github.com/kubernetes/apiserver/blob/7001bc4df8883d4a0ec84cd4b2117655a0009b6c/pkg/endpoints/handlers/create.go#L111) в etcd путём [делегирования](https://github.com/kubernetes/apiserver/blob/19667a1afc13cc13930c40a20f2c12bbdcaaa246/pkg/registry/generic/registry/store.go#L327) поставщику хранилища. Обычно ключ для etcd представляется в виде `/`, но это настраивается.
5. Любые ошибки при создании перехватываются и, наконец, поставщик хранилища выполняет вызов `get`, проверяя, что объект был действительно создан. Затем он вызывает все обработчики, назначенные на момент после создания (post-create), и декораторы, если требуется дополнительная финализация.
6. [Создаётся](https://github.com/kubernetes/apiserver/blob/7001bc4df8883d4a0ec84cd4b2117655a0009b6c/pkg/endpoints/handlers/create.go#L131-L142) HTTP-запрос и отправляется обратно.
Много шагов! Удивительно вот так следовать за apiserver, потому что понимаешь, как много работы он в действительности делает. Итак, резюмируя: ресурс Deployment теперь существует в etcd. Но мало так вот просто его туда поместить — вы всё ещё не увидите его на данном этапе…
Инициализаторы
--------------
Когда объект сохранён в хранилище данных, он не является полностью видимым apiserver и не попадает в планировщик, пока не отработает набор [инициализаторов](https://kubernetes.io/docs/admin/extensible-admission-controllers/#initializers) *(intializers)*. Инициализатор — это контроллер, ассоциированный с типом ресурса и исполняющий логику на ресурсе до того, как он становится доступным для внешнего мира. Если у типа ресурса нет зарегистрированных инициализаторов, этот шаг пропускается и ресурсы видны мгновенно.
Как [написано](https://ahmet.im/blog/initializers/) во многих блогах, это мощная возможность, позволяющая выполнять общие операции «начальной загрузки» *(bootstrap)*. Примеры могут быть такие:
* Вставка проксирующего sidecar-контейнера в под с открытым портом 80 или с конкретной аннотацией *(annotation)*.
* Вставка тома с тестовыми сертификатами во все поды определённого пространства имён.
* Предотвращение создания секрета с длиной менее 20 символов (например, для пароля).
Объекты `initializerConfiguration` позволяют определять, какие инициализаторы должны запускаться для определённых типов ресурсов. Представьте, что мы хотим запускать свой инициализатор при каждом случае создания пода. Тогда мы сделаем нечто такое:
```
apiVersion: admissionregistration.k8s.io/v1alpha1
kind: InitializerConfiguration
metadata:
name: custom-pod-initializer
initializers:
- name: podimage.example.com
rules:
- apiGroups:
- ""
apiVersions:
- v1
resources:
- pods
```
После создания этого конфига в поле ожидания (`metadata.initializers.pending`) каждого пода будет добавлен `custom-pod-initializer`. Контроллер инициализатора будет уже развёрнут и начнёт регулярно сканировать кластер на новые поды. Когда инициализатор обнаружит под со своим *(т.е. инициализатора)* названием в поле ожидания, он исполнит свои действия. После завершения работы он удалит своё название из списка ожидания. Только инициализаторы, названия которых являются первыми в списке, могут управлять ресурсами. Когда все инициализаторы отработали и список ожидания пуст, объект будет считать инициализированным.
Самые наблюдательные читатели могли заметить потенциальную проблему. Как может контроллер из пользовательского пространства обрабатывать ресурсы, если kube-apiserver ещё не сделал их видимыми? Для этого у kube-apiserver есть специальный параметр запроса `?includeUninitialized`, позволяющий возвращать все объекты, в том числе и неинициализированные.
P.S. от переводчика
-------------------
Вторую часть статьи ~~опубликуем в ближайшее время~~ **ОБНОВЛЕНО: … опубликовали по [этой ссылке](https://habrahabr.ru/company/flant/blog/342822/)**. В ней рассмотрена работа контроллеров Deployments и ReplicaSets, информаторов, планировщика, kubelet.
Читайте также в нашем блоге:
* «[**Что происходит в Kubernetes при запуске kubectl run? Часть 2**](https://habrahabr.ru/company/flant/blog/342822/)»;
* «[Наш опыт с Kubernetes в небольших проектах](https://habrahabr.ru/company/flant/blog/331188/)» *(видео доклада, включающего в себя знакомство с техническим устройством Kubernetes);*
* «[Как на самом деле работает планировщик Kubernetes?](https://habrahabr.ru/company/flant/blog/335552/)»;
* «[Инфраструктура с Kubernetes как доступная услуга](https://habrahabr.ru/company/flant/blog/341760/)»;
* «[Kubernetes 1.8: обзор основных новшеств](https://habrahabr.ru/company/flant/blog/338230/)». | https://habr.com/ru/post/342658/ | null | ru | null |
# Пишем «Hello, World» Telegram бота на Си
Привет всем, не знаю зачем это надо, но может кому пригодится…
**Дисклеймер:** Я ни в коем случае не являюсь профессиональным Си программистом.
Что нам понадобится:
**1.** Любой компьютер на Linux, Ubuntu, Centos, MacOS… с доступом к порту 443 или 8443 из интернета.
**2.** Любой Си компилятор
**3.** Бибилиотеки openssl, libssl-dev («apt-get install openssl libssl-dev» в терминале, для Ubuntu)
Итак, приступим…
**Первое** что нужно сделать — это создать бота у отца всех ботов @BotFather, опустим все подробности и предположим что с этой задачей все справились и получили токен, что-то вроде:
373288854:AAHHT77v5\_ZNEMус4bfnРЩo6dxiMeeEwgwJ
Далее создадим ssl сертификат, для установки WebHook. Команда выглядит примерно так:
```
openssl req -newkey rsa:2048 -sha256 -nodes -keyout private.key -x509 -days 365 -out public.pem
```
Упакуем ключ и публичный сертификат в один файл:
```
cat private.key public.pem > cert.pem
```
Устанавливаем WebHook:
```
curl -F"url=https://ВАШ_IP:ПОРТ(либо 443, либо 8443)/ЛЮБОЙ_URI(можно и без него, я буду использовать токен)/" -F"certificate=@public.pem" https://api.telegram.org/botТОКЕН/setWebhook/
```
Должен прийти JSON ответ что-то типа success:true..., если нет то проверьте все и попробуйте еще раз.
Приступаем к самому интересному:
Создаем файл main.c и открываем его в любом редакторе. Включаем необходимые библиотеки:
```
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
```
Функция инициализации сокета:
```
int InitializeSocket(int port) {
int sd = socket(AF_INET, SOCK_STREAM, 0);
if (sd < 0) exit(-1);
struct sockaddr_in s_addr;
s_addr.sin_family = AF_INET;
s_addr.sin_addr.s_addr = INADDR_ANY;
s_addr.sin_port = htons(port);
if (bind(sd, (struct sockaddr *)&s_addr, sizeof(s_addr)) < 0) {
printf("Binding Error!\n");
exit(-3);
}
return sd;
}
```
Включаем SSL/TLS:
```
SSL_CTX * InitializeSSL(char[] certificate) {
OpenSSL_add_all_algorithms();
SSL_load_error_strings();
SSL_library_init();
SSL_CTX * sslctx = SSL_CTX_new(TLSv1_2_server_method());
if (SSL_CTX_use_certificate_file(sslctx, certificate , SSL_FILETYPE_PEM) <= 0) {
exit(-2);
}
if (SSL_CTX_use_PrivateKey_file(sslctx, certificate, SSL_FILETYPE_PEM) <= 0) {
exit(-2);
}
if (!SSL_CTX_check_private_key(sslctx)) {
exit(-2);
}
return sslctx;
}
```
Собственно сам main():
```
int main() {
SSL_CTX * sslctx = InitializeSSL("cert.pem"); //Созданный нами файл из приватного ключа и публичного сертификата
int sd = InitializeSocket(8443); //Порт который вы указали при установке WebHook
listen(sd, 5); //Слушаем подключения на созданном сокете
while (1) { //Запускаем бесконечный цикл
int client = accept(sd, NULL, NULL) //функция accept ждет новое подключение, в качестве параметров принимает сокет, указатель на структуру sockaddr, и указатель на размер этой структуры и записывает туда данные подключения, так как нам необязательно знать подробности подключения отправим NULL, функция возвращает сетевой дескриптор.
SSL * ssl = SSL_new(sslctx); //Cоздаем ssl дескриптор
SSL_set_fd(ssl, client); //Переключаем обычный дескриптор на защищенный
if (SSL_accept(ssl) <= 0) { //Пытаемся принять подключение, если ошибка то закрываем соединение и возвращаемся к началу цикла
SSL_clear(ssl);
close(newsd);
continue;
}
//Для увеличения производительности будем использовать fork() и обрабатывать соединение в дочернем процессе, а родительский процесс вернем к ожиданию новых подключений
int pid = fork();
if (pid != 0) { //Если это родитель, то закрываем подключение и возвращаемся к началу цикла
SSL_clear(ssl);
close(newsd);
continue;
}
//Дальнейшие действия будут происходить в дочернем процессе
//Опишу их дальше после некоторых пояснений....
exit(0); //Завершаем дочерний процесс
}
}
```
Так как Telegram использует HTTP протокол поясню некоторые моменты:
Любой HTTP запрос состоит из заголовков отделенных между собой "\r\n", и тела отделенного от заголовков "\r\n\r\n", может быть пустым, но разделитель "\r\n\r\n" присутствует всегда. Запросы от Telegram будут приходить методом POST, тело будет в формате JSON.
Пример запроса похожего на Telegram:
```
POST /(URI указанный при установке WebHook) HTTP/1.1\r\n
....Неважные для нас поля заголовков
Content-Type: application/json\r\n (Тип данных в теле)
Content-Length: 256\r\n (Размер тела в байтах, целое число)
..../r/n/r/n
Json тело
```
При каждой отправке человеком боту сообщения, сервер телеграма будет посылать подобные запросы нашему серверу. В общем случае на них отвечать не обязательно, но в случае с Telegram — обязательно, иначе он будет циклично посылать один и тот же запрос.
Для этого подготовим короткий HTTP response:
```
HTTP/1.1 200 OK\r\n
Connection: close\r\n\r\n
```
Этих двух полей достаточно что бы сказать серверу Telegram что все нормально, ответ 200 и можно закрывать соединение
Продолжаем писать программу. Внутри цикла после создания дочернего процесса…
```
char[] response = "HTTP/1.1 200 OK\r\nConnection: close\r\n\r\n"; //Наш HTTP response
char header[1024];
bzero(header,1024); //Выделили массив для записи в него заголовков запроса и на всякий случай занулили там все записи.
int s = 0;
int n = 0;
while (strcmp(header + s - strlen("\r\n\r\n"), "\r\n\r\n") != 0) { //strcmp Сравнивает две строки и если они равны возвращает 0, в нашем случае сравниваем последние strlen("\r\n\r\n") байт с "\r\n\r\n", то есть ищем конец заголовка
n = SSL_read(ssl,header+s,1); //Считываем данные по одному байту в header + s, s - общее кол-во считанных байт
s += n; //n - кол-во считанных байт за раз
}
//Все, заголовки считаны, теперь нам надо проверить метод, uri, content-type и вытащить content-length запроса.
if (strstr(header,"POST /(URI указанный при установке WebHook) HTTP/1.1\r\n") == NULL) { //Ищем вхождение строки POST .... в header, если его нет то возвращается NULL, значит пришел неверный запрос, закрываем подключение и завершаем дочерний процесс
SSL_clear(ssl);
close(client);
exit(0);
}
//Также проверим тип данных, должен быть application/json;
if (strstr(header, "Content-Type: application/json") == NULL) {
SSL_clear(ssl);
close(client);
exit(0);
}
//Если все нормально, то узнаем размер тела
int len = atoi(strstr(header, "Content-Length: ") + strlen("Content-Length: ")); //strstr возвращает указатель не первое вхождение указанной строки, то есть на "Content-Length: ", а кол-во байт записано дальше после этой строки, поэтому прибавляем длину строки "Content-Length: " и приводим строку к типу int функцией atoi(char *);
char body[len+2];
bzero(body, len+2); //Создаем массив для тела, на этот раз мы точно знаем сколько байт нам понадобится, но создаем с запасом, дабы не оказалось что в памяти сразу после нашей строки что-то записано
n = 0;
s = 0;
while (len - s > 0) { //Так как мы четко знаем сколько данных нам надо считать просто считываем пока не считаем нужное кол-во
n = SSL_read(ssl, request + s, len - s); //Конечно можно было считать целиком все данные, но бывают случаи при плохом соединении, за раз все данные не считываеются, и функция SSL_read возвращает кол-во считанных байт
s += n;
}
//На этом получение данных окончено, отправим наш http response и закроем соединение SSL_write(ssl, response, (int)strlen(response));
SSL_clear(ssl);
SSL_free(ssl);
close(client);
//Так как у нас "Hello, World" бот то мы будем просто отвечать на любое сообщение "Hello, World!", но нам нужно знать кому отправлять сообщение для это из тела запросы надо вытащить параметр chat_id
int chat_id = atoi(strstr("\"chat_id\":") + strlen("\"chat_id\":")); //То же самое что и с Content-Length
//Осталось только отправить сообщение, для этого лучше создадим отдельную функцию SendMessage
char msg[] = "Hello, World!";
SendMessage(chat_id, msg); //Описание функции далее
```
Для отправки запросов нам почти так же понадобится инициализировать сокет и ssl, но в отличие от получения запросов, мы не будем ждать подключения а просто сразу будем отправлять данные:
```
void SendMessage(int chat_id, char[] msg) {
int port = 443;
char host[] = "api.telegram.org"; //Адрес и порт всегда одинаковые
//Создадим шаблон HTTP запроса для отправки сообщения, в виде форматированной строки
char header[] = "POST /bot352115436:AAEAIEPeKdR2-SS7p9jGeksQljkNa9_Smo0/sendMessage HTTP/1.1\r\nHost: files.ctrl.uz\r\nContent-Type: application/json\r\nContent-Length: %d\r\nConnection: close\r\n\r\n%s";
//Шаблон тела для отправки сообщения
char tpl[] = "{\"chat_id\":%d,\"text\":\"%s\"}";
char body[strlen(tpl)+strlen(msg)+16];
bzero(body, strlen(tpl)+strlen(msg)+16);
sprintf(body,tpl,chat_id,msg); //Как printf, только печатаем в char[]
char request[strlen(header)+strlen(body)+4];
bzero(request,strlen(header)+strlen(body)+4);
sprintf(request, header, strlen(body), body);
//Подготовили наш запрос, теперь создаем подключение
struct hostent *server;
struct sockaddr_in serv_addr;
int sd;
sd = socket(AF_INET, SOCK_STREAM, 0);
if (sd < 0) exit(-5);
server = gethostbyname(host); //Данная функция получает ip и еще некоторые данные по url
if (server == NULL) exit(-6);
bzero(&serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(portno);
memcpy(&serv_addr.sin_addr.s_addr,server->h_addr,server->h_length);
if (connect(sd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0) { exit(-6);}
SSL_CTX * sslctx = SSL_CTX_new(TLSv1_client_method());
SSL * cSSL = SSL_new(sslctx);
SSL_set_fd(cSSL, sfd);
SSL_connect(cSSL);
SSL_write(cSSL,request,(int)strlen(request)); //Отправляем наш запрос, в идеале его надо отправлять так же как мы считывали данные, то есть с проверкой на кол-во отправленных байт
char str[1024];
SSL_read(cSSL, str, 1024); //Считываем ответ и закрываем соединение
SSL_clear(cSSL);
SSL_CTX_free(sslctx);
close(sd);
}
```
На этом, в принципе все. Сохраняем файл в одной папке с сертификатом, компилируем любым компилятором и запускаем:
```
clang main.c -o bot -lcrypto -lssl
./bot
```
**Конец!**
Надеюсь статья будет кому-то полезной. | https://habr.com/ru/post/325846/ | null | ru | null |
# Лучшие практики для контейнеров Kubernetes: проверки работоспособности
**TL;DR**
* Чтобы добиться высокой наблюдаемости контейнеров и микросервисов, журналов и первичных метрик мало.
* Для более быстрого восстановления и повышения отказоустойчивости приложения должны применять Принцип высокой наблюдаемости (HOP, High Observability Principle).
* На уровне приложение для НОР требуется: должное журналирование, тщательный мониторинг, проверки работоспособности и трассировки производительности/переходов.
* В качестве элемента НОР используйте проверки *readinessProbe* и *livenessProbe* Kubernetes.
### Что такое Шаблон проверки работоспособности?
Когда проектируешь критически важное и высокодоступное приложение, очень важно подумать о таком аспекте, как отказоустойчивость. Приложение считается отказоустойчивым, если оно быстро восстанавливается после отказа. Типичное облачное приложение использует архитектуру микросервисов – когда каждый компонент помещается в отдельный контейнер. А для того, чтобы убедиться, что приложение на k8s высокодоступно, когда проектируешь кластер, надо следовать определенным шаблонам. Среди них – Шаблон проверки работоспособности. Он определяет, как приложение сообщает k8s о своей работоспособности. Это не только информация о том, работает ли pod, а еще и о том, как он принимает запросы и отвечает на них. Чем больше Kubernetes знает о работоспоспособности pod'а, тем более умные решения принимает о маршрутизации трафика и балансировке нагрузки. Таким образом, Принцип высокой наблюдаемости приложению своевременно отвечать на запросы.
### Принцип высокой наблюдаемости (НОР)
Принцип высокой наблюдаемости – это один из [принципов проектирования контейнеризированных приложений](https://www.redhat.com/cms/managed-files/cl-cloud-native-container-design-whitepaper-f8808kc-201710-v3-en.pdf). В микросеврисной архитектуре сервисам безразлично, как их запрос обрабатывается (и это правильно), но важно, как получить ответы от принимающих сервисов. К примеру, для аутентификации пользователя один контейнер посылает другому запрос HTTP, ожидая ответа в определенном формате – вот и все. Обрабатывать запрос может и PythonJS, а ответить – Python Flask. Контйнеры друг для друга – что черные ящики со скрытым содержимым. Однако принцип НОР требует, чтобы каждый сервис раскрывал несколько конечных точек API, показывающих, насколько он работоспособен, а также состояние его готовности и отказоустойчивости. Эти показатели и запрашивает Kubernetes, чтобы продумывать следующие шаги по маршрутизации и балансировке нагрузки.
Грамотно спроектированное облачное приложение журналирует свои основные события используя стандартные потоки ввода-вывода STDERR и STDOUT. Следом работает вспомогательный сервис, к примеру filebeat, logstash или fluentd, доставляющие журналы в централизованную систему мониторинга (например Prometheus) и систему сбора журналов (набор ПО ELK). На схеме ниже показано, как облачное прилоежние работает в соответствии с Шаблоном проверки работоспособности и Принципом высокой наблюдаемости.
### Как применить Шаблон проверки работоспособности в Kubernetes?
Из коробки k8s мониторит состояние pod’ов при помощи одного из контроллеров ([Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/), [ReplicaSets](https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/), [DaemonSets](https://kubernetes.io/docs/concepts/workloads/controllers/daemonset/), [StatefulSets](https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/) и проч., проч.). Обнаружив, что pod по некой причине упал, контроллер пытается отрестартить его или перешедулить на другой узел. Однако pod может сообщить, что он запущен и работает, а сам при этом не функционирует. Приведем пример: ваше приложение использует в качестве веб-сервера Apache, вы установили компонент на несколько pod’ов кластера. Поскольку библиотека была настроена некорректно – все запросы к приложению отвечают кодом 500 (внутренняя ошибка сервера). При проверке поставки проверка состояния pod`ов дает успешный результат, однако клиенты считают иначе. Эту нежелательную ситуацию мы опишем следующим образом:
В нашем примере k8s выполняет *проверку работоспособности*. В этом виде проверки kubelet постоянно проверяет состояние процесса в контейнере. Стоит ему понять, что процесс встал, и он его рестартит. Если ошибка устраняется простым перезапуском приложения, а программа спроектирована так, чтобы отключаться при любой ошибке, тогда вам для следования НОР и Шаблону проверки работоспособности достаточно проверки работоспособности процесса. Жаль только, что не все ошибки устраняются перезапуском. На этот случай k8s предлагает 2 более глубоких способа выявления неполадок в работе pod'а: [livenessProbe](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-probes/) и [readinessProbe](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-probes/).
### LivenessProbe
Во время **livenessProbe** kubelet выполняет 3 типа проверок: не только выясняет, работает ли pod, но и готов ли он получать и адекватно отвечать на запросы:
* Установить HTTP-запрос к pod'у. Ответ должен содержать HTTP-код ответа в диапазоне от 200 до 399. Таким образом, коды 5хх и 4хх сигнализируют о том, что у pod'а проблемы, пусть даже процесс работает.
* Для проверки pod'ов с не-HTTP сервисами (например, почтовый сервер Postfix), надо установить TCP-связь.
* Исполнение произвольной команды для pod'а (внутренне). Проверка считается успешной, если код завершения команды – 0.
Пример того, как это работает. Определение следующего pod'а содержит NodeJS приложение, которое на HTTP-запросы выдает ошибку 500. Чтобы убедиться, что контейнер перезапускается, получив такую ошибку, мы используем параметр livenessProbe:
```
apiVersion: v1
kind: Pod
metadata:
name: node500
spec:
containers:
- image: magalix/node500
name: node500
ports:
- containerPort: 3000
protocol: TCP
livenessProbe:
httpGet:
path: /
port: 3000
initialDelaySeconds: 5
```
Это ничем не отличается от любого другого определения pod'а, но мы добавляем объект `.spec.containers.livenessProbe`. Параметр `httpGet` принимает путь, по которому отправляет HTTP GET запрос (в нашем примере это `/`, но в боевых сценариях может быть и нечто вроде `/api/v1/status`). Еще livenessProbe принимает параметр `initialDelaySeconds`, который предписывает операции проверки ждать заданное количество секунд. Задержка нужна, потому что контейнеру надо время для запуска, а при перезапуске он некоторое время будет недоступен.
Чтобы применить эту настройку к кластеру, используйте:
```
kubectl apply -f pod.yaml
```
Спустя несколько секунд можно проверить содержимое pod'а с помощью следующей команды:
```
kubectl describe pods node500
```
В конце вывода найдите [вот что](https://xpaste.pro/p/0jD1plyr).
Как видите, livenessProbe инициировала HTTP GET запрос, контейнер выдал ошибку 500 (на что и был запрограммирован), kubelet его перезапустил.
Если вам интересно, как было запрограммировано NideJS приложение, вот файл app.js и Dockerfile, которые были использованы:
app.js
```
var http = require('http');
var server = http.createServer(function(req, res) {
res.writeHead(500, { "Content-type": "text/plain" });
res.end("We have run into an error\n");
});
server.listen(3000, function() {
console.log('Server is running at 3000')
})
```
Dockerfile
```
FROM node
COPY app.js /
EXPOSE 3000
ENTRYPOINT [ "node","/app.js" ]
```
Важно обратить внимание вот на что: livenessProbe перезапустит контейнер, только при отказе. Если перезапуск не исправит ошибку, мешающую работе контейнера, kubelet не сможет предпринять меры для устранения неисправности.
### readinessProbe
readinessProbe работает аналогично livenessProbes (GET-запросы, ТСР связи и исполнение команд), за исключением действий по устранению неисправностей. Контейнер, в котором зафиксирован сбой, не перезапускается, а изолируется от входящего трафика. Представьте, один из контейнеров выполняет много вычислений или подвергается тяжелой нагрузке, из-за чего вырастает время ответа на запросы. В случае livenessProbe срабатывает проверка доступности ответа (через параметр проверки timeoutSeconds), после чего kubelet перезапускает контейнер. При запуске контейнер начинает выполнять ресурсоемкие задачи, и его снова перезапускают. Это может быть критично для приложений, которым важна скорость ответа. Например, машина прямо в пути ожидает ответа от сервера, ответ задерживается – и машина попадает в аварию.
Давайте напишем определение readinessProbe, которое установит время ответа на GET-запрос не более двух секунд, а приложение будет отвечать на GET-запрос через 5 секунд. Файл pod.yaml должен выглядеть следующим образом:
```
apiVersion: v1
kind: Pod
metadata:
name: nodedelayed
spec:
containers:
- image: afakharany/node_delayed
name: nodedelayed
ports:
- containerPort: 3000
protocol: TCP
readinessProbe:
httpGet:
path: /
port: 3000
timeoutSeconds: 2
```
Развернем pod с kubectl:
```
kubectl apply -f pod.yaml
```
Выждем пару секунд, а потом глянем, как сработала readinessProbe:
```
kubectl describe pods nodedelayed
```
В конце вывода можно увидеть, что часть событий аналогична [вот этому](https://xpaste.pro/p/2JaA1n7J).
Как видите, kubectl не стал перезапускать pod, когда время проверки превысило 2 секунды. Вместо этого он отменил запрос. Входящие связи перенаправляются на другие, рабочие pod'ы.
Заметьте: теперь, когда с pod'а снята лишняя нагрузка, kubectl снова направляет запросы ему: ответы на GET-запрос больше не задерживаются.
Для сравнения: ниже приведен измененный файл app.js:
```
var http = require('http');
var server = http.createServer(function(req, res) {
const sleep = (milliseconds) => {
return new Promise(resolve => setTimeout(resolve, milliseconds))
}
sleep(5000).then(() => {
res.writeHead(200, { "Content-type": "text/plain" });
res.end("Hello\n");
})
});
server.listen(3000, function() {
console.log('Server is running at 3000')
})
```
**TL;DR**
До появления облачных приложений основным средством мониторинга и проверки состояния приложений были логи. Однако не было средств предпринимать какие-то меры по устранению неполадок. Логи и сегодня полезны, их надо собирать и отправлять в систему сборки логов для анализа аварийных ситуаций и принятия решений. [*это все можно было делать и без облачных приложений с помощью monit, к примеру, но с k8s это стало гораздо проще :) – прим.ред.* ]
Сегодня же исправления приходится вносить чуть ли не в режиме реального времени, поэтому приложения больше не должны быть черными ящиками. Нет, они должны показывать конечные точки, позволяющие системам мониторинга запрашивать и собирать ценные данные о состоянии процессов, чтобы в случае необходимости реагировать мгновенно. Это называется Шаблон проектирования проверки работоспособности, который следует Принципу высокой наблюдаемости (НОР).
Kubernetes по умолчанию предлагает 2 вида проверки работоспособности: readinessProbe и livenessProbe. Оба используют одинаковые типы проверок (HTTP GET запросы, ТСР-связи и исполнение команд). Отличаются они в том, какие решения принимают в ответ на неполадки в pod'ах. livenessProbe перезапускает контейнер в надежде, что ошибка больше не повторится, а readinessProbe изолирует pod от входящего трафика – до устранения причины неполадки.
Правильное проектирование приложения должно включать и тот, и другой вид проверки, и чтобы они собирали достаточно данных, особенно когда создана исключительная ситуация. Оно также должно показывать необходимые конечные точки API, передающие системе мониторинга (тому же Prometheus) важные метрики состояния работоспособности. | https://habr.com/ru/post/467155/ | null | ru | null |
# Оптимизируем затраты с помощью AWS Cost Explorer
У Amazon Web Services отличный бесплатный пакет: хороший набор сервисов и щедрая раздача кредитов для разработчиков. Я был уверен: проблем с оплатой моего окружения не будет, поэтому о расходах не беспокоился. Мое приложение на 100% serverless, и я всегда укладывался в уровень бесплатного использования, так что просто игнорировал вопрос оплаты. В какой-то момент я расслабился и потерял бдительность.
Постепенно мой продукт становился популярнее, пользователей стало больше… и я получил счет на 62$. Пережить можно, но я задумался о темпах роста: моё приложение не было оптимизировано для уменьшения затрат, так как я об этом никогда не задумывался. Что ж, пришло время заняться сокращением расходов.
AWS Cost Explorer
-----------------
Сервис [AWS Billing dashboard](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/billing-what-is.html) хорошо подходит для оплаты счетов и показывает график прогноза счетов за текущий месяц. Но этот сервис едва ли претендует на звание лучшего в AWS. Месячный прогноз часто врет, поэтому лучше игнорировать его вовсе.
Помимо Billing Dashboard, соседний Cost Explorer предоставляет очень хорошую детализацию и возможность прогнозирования. Кроме просмотра стандартной разбивки потребления в AWS, можно писать код под Cost Explorer, извлекая много ценной информации. И мне это дело зашло.
Используя Cost Explorer, я смог заранее определить уязвимые места и исправить их задолго до того, как с меня начнут списывать за них деньги. Еще раз спасибо AWS.
Пользовательский интерфейс
--------------------------
Прежде чем начать работать, надо познакомиться со стандартным видом консоли Billing Dashboard. Нужно сначала включить её, что будет стоить денег. Лучше сделать это заранее, чтобы потом не было мучительно больно. У кого много остатку, тот не боится недостатку!
Пользовательский интерфейс интуитивно понятный: здесь мы можем получать подробные отчеты по дням / услуге; или сгруппированные по времени / региону / услуге – и множеством других способов.
Это мой график потраченного за последние несколько месяцев.
### Отчеты
В разделе reports мы можем получить несколько персональных отчетов. AWS предоставляет неплохой набор готовых шаблонов для отчетов, а также возможность создавать свои с нуля.
### Бюджеты
Cost Explorer не ограничивается отчетами и графиками. Чаще начинают осваивать AWS с небольших бюджетов и настроенных под них оповещений, но есть возможность сделать гораздо больше. Можно задать независимые бюджеты (по стоимости и использованию) для отдельных сервисов, и даже для отдельных инстансов или операций внутри сервиса.
Например, бюджет, который будет контролировать объем исходящих данных для базы данных DynamoDB и предупреждать вас при достижении пороговых значений.
### Обнаружение аномалий
Это особенно актуально для систем с равномерной нагрузкой, а предупреждения помогут вам контролировать постепенный расход как запланировано. Можно задавать «мониторинги», которые следят за конкретными сценариями. Мониторинги сравнивают текущие значения потребления с историческими, чтобы предупредить об отклонении от трендов.
### Cost Explorer API
Стандартный вид консоли управления меня устраивает – но только для эпизодического ознакомления. Для того, чтобы получить нечто большее, AWS предоставляет отличный API. Репозиторий [AWS Samples Github](https://github.com/aws-samples) дает нам наглядный пример доступа к API Cost Explorer.
Мой код основан на этом примере, и позволяет разработать собственный отчет для Cost Explorer’a.
Код Lambda функции
------------------
```
import os
import sys
# Required to load modules from vendored subfolder (for clean development env)
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), "./vendored"))
import boto3
import datetime
import logging
import pandas as pd
#For date
from dateutil.relativedelta import relativedelta
#For email
from email.mime.application import MIMEApplication
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.utils import COMMASPACE, formatdate
SES_REGION="ap-south-1"
CURRENT_MONTH = True
#Default exclude support, as for Enterprise Support
#as support billing is finalised later in month so skews trends
INC_SUPPORT = os.environ.get('INC_SUPPORT')
if INC_SUPPORT == "true":
INC_SUPPORT = True
else:
INC_SUPPORT = False
TAG_VALUE_FILTER = os.environ.get('TAG_VALUE_FILTER') or '*'
TAG_KEY = os.environ.get('TAG_KEY')
class CostExplorer:
"""Retrieves BillingInfo checks from CostExplorer API
>>> costexplorer = CostExplorer()
>>> costexplorer.addReport(GroupBy=[{"Type": "DIMENSION","Key": "SERVICE"}])
>>> costexplorer.generateExcel()
"""
def __init__(self, CurrentMonth=False):
#Array of reports ready to be output to Excel.
self.reports = []
self.client = boto3.client('ce', region_name='us-east-1')
# self.end = datetime.date.today().replace(day=1)
self.riend = datetime.date.today()
self.end = self.riend
# Default is last 12 months
self.start = (datetime.date.today() - relativedelta(months=+12)).replace(day=1) #1st day of month 12 months ago
self.ristart = (datetime.date.today() - relativedelta(months=+11)).replace(day=1) #1st day of month 11 months ago
self.sixmonth = (datetime.date.today() - relativedelta(months=+6)).replace(day=1) #1st day of month 6 months ago, so RI util has savings values
self.accounts = {}
def addRiReport(self, Name='RICoverage', Savings=False, PaymentOption='PARTIAL_UPFRONT', Service='Amazon Elastic Compute Cloud - Compute'): #Call with Savings True to get Utilization report in dollar savings
type = 'chart' #other option table
if Name == "RICoverage":
results = []
response = self.client.get_reservation_coverage(
TimePeriod={
'Start': self.ristart.isoformat(),
'End': self.riend.isoformat()
},
Granularity='MONTHLY'
)
results.extend(response['CoveragesByTime'])
while 'nextToken' in response:
nextToken = response['nextToken']
response = self.client.get_reservation_coverage(
TimePeriod={
'Start': self.ristart.isoformat(),
'End': self.riend.isoformat()
},
Granularity='MONTHLY',
NextPageToken=nextToken
)
results.extend(response['CoveragesByTime'])
if 'nextToken' in response:
nextToken = response['nextToken']
else:
nextToken = False
rows = []
for v in results:
row = {'date':v['TimePeriod']['Start']}
row.update({'Coverage%':float(v['Total']['CoverageHours']['CoverageHoursPercentage'])})
rows.append(row)
df = pd.DataFrame(rows)
df.set_index("date", inplace= True)
df = df.fillna(0.0)
df = df.T
elif Name in ['RIUtilization','RIUtilizationSavings']:
#Only Six month to support savings
results = []
response = self.client.get_reservation_utilization(
TimePeriod={
'Start': self.sixmonth.isoformat(),
'End': self.riend.isoformat()
},
Granularity='MONTHLY'
)
results.extend(response['UtilizationsByTime'])
while 'nextToken' in response:
nextToken = response['nextToken']
response = self.client.get_reservation_utilization(
TimePeriod={
'Start': self.sixmonth.isoformat(),
'End': self.riend.isoformat()
},
Granularity='MONTHLY',
NextPageToken=nextToken
)
results.extend(response['UtilizationsByTime'])
if 'nextToken' in response:
nextToken = response['nextToken']
else:
nextToken = False
rows = []
if results:
for v in results:
row = {'date':v['TimePeriod']['Start']}
if Savings:
row.update({'Savings$':float(v['Total']['NetRISavings'])})
else:
row.update({'Utilization%':float(v['Total']['UtilizationPercentage'])})
rows.append(row)
df = pd.DataFrame(rows)
df.set_index("date", inplace= True)
df = df.fillna(0.0)
df = df.T
type = 'chart'
else:
df = pd.DataFrame(rows)
type = 'table' #Dont try chart empty result
elif Name == 'RIRecommendation':
results = []
response = self.client.get_reservation_purchase_recommendation(
#AccountId='string', May use for Linked view
LookbackPeriodInDays='SIXTY_DAYS',
TermInYears='ONE_YEAR',
PaymentOption=PaymentOption,
Service=Service
)
results.extend(response['Recommendations'])
while 'nextToken' in response:
nextToken = response['nextToken']
response = self.client.get_reservation_purchase_recommendation(
#AccountId='string', May use for Linked view
LookbackPeriodInDays='SIXTY_DAYS',
TermInYears='ONE_YEAR',
PaymentOption=PaymentOption,
Service=Service,
NextPageToken=nextToken
)
results.extend(response['Recommendations'])
if 'nextToken' in response:
nextToken = response['nextToken']
else:
nextToken = False
rows = []
for i in results:
for v in i['RecommendationDetails']:
row = v['InstanceDetails'][list(v['InstanceDetails'].keys())[0]]
row['Recommended']=v['RecommendedNumberOfInstancesToPurchase']
row['Minimum']=v['MinimumNumberOfInstancesUsedPerHour']
row['Maximum']=v['MaximumNumberOfInstancesUsedPerHour']
row['Savings']=v['EstimatedMonthlySavingsAmount']
row['OnDemand']=v['EstimatedMonthlyOnDemandCost']
row['BreakEvenIn']=v['EstimatedBreakEvenInMonths']
row['UpfrontCost']=v['UpfrontCost']
row['MonthlyCost']=v['RecurringStandardMonthlyCost']
rows.append(row)
df = pd.DataFrame(rows)
df = df.fillna(0.0)
type = 'table' #Dont try chart this
self.reports.append({'Name':Name,'Data':df, 'Type':type})
def addReport(self, Name="Default",GroupBy=[{"Type": "DIMENSION","Key": "SERVICE"},],
Style='Total', NoCredits=True, CreditsOnly=False, RefundOnly=False, UpfrontOnly=False, IncSupport=False):
type = 'chart' #other option table
results = []
if not NoCredits:
response = self.client.get_cost_and_usage(
TimePeriod={
'Start': self.start.isoformat(),
'End': self.end.isoformat()
},
Granularity='MONTHLY',
Metrics=[
'UnblendedCost',
],
GroupBy=GroupBy
)
else:
Filter = {"And": []}
Dimensions={"Not": {"Dimensions": {"Key": "RECORD_TYPE","Values": ["Credit", "Refund", "Upfront", "Support"]}}}
if INC_SUPPORT or IncSupport: #If global set for including support, we dont exclude it
Dimensions={"Not": {"Dimensions": {"Key": "RECORD_TYPE","Values": ["Credit", "Refund", "Upfront"]}}}
if CreditsOnly:
Dimensions={"Dimensions": {"Key": "RECORD_TYPE","Values": ["Credit",]}}
if RefundOnly:
Dimensions={"Dimensions": {"Key": "RECORD_TYPE","Values": ["Refund",]}}
if UpfrontOnly:
Dimensions={"Dimensions": {"Key": "RECORD_TYPE","Values": ["Upfront",]}}
tagValues = None
if TAG_KEY:
tagValues = self.client.get_tags(
SearchString=TAG_VALUE_FILTER,
TimePeriod = {
'Start': self.start.isoformat(),
'End': datetime.date.today().isoformat()
},
TagKey=TAG_KEY
)
if tagValues:
Filter["And"].append(Dimensions)
if len(tagValues["Tags"]) > 0:
Tags = {"Tags": {"Key": TAG_KEY, "Values": tagValues["Tags"]}}
Filter["And"].append(Tags)
else:
Filter = Dimensions.copy()
response = self.client.get_cost_and_usage(
TimePeriod={
'Start': self.start.isoformat(),
'End': self.end.isoformat()
},
Granularity='MONTHLY',
Metrics=[
'UnblendedCost',
],
GroupBy=GroupBy,
Filter=Filter
)
if response:
results.extend(response['ResultsByTime'])
while 'nextToken' in response:
nextToken = response['nextToken']
response = self.client.get_cost_and_usage(
TimePeriod={
'Start': self.start.isoformat(),
'End': self.end.isoformat()
},
Granularity='MONTHLY',
Metrics=[
'UnblendedCost',
],
GroupBy=GroupBy,
NextPageToken=nextToken
)
results.extend(response['ResultsByTime'])
if 'nextToken' in response:
nextToken = response['nextToken']
else:
nextToken = False
rows = []
sort = ''
for v in results:
row = {'date':v['TimePeriod']['Start']}
sort = v['TimePeriod']['Start']
for i in v['Groups']:
key = i['Keys'][0]
if key in self.accounts:
key = self.accounts[key][ACCOUNT_LABEL]
row.update({key:float(i['Metrics']['UnblendedCost']['Amount'])})
if not v['Groups']:
row.update({'Total':float(v['Total']['UnblendedCost']['Amount'])})
rows.append(row)
df = pd.DataFrame(rows)
df.set_index("date", inplace= True)
df = df.fillna(0.0)
if Style == 'Change':
dfc = df.copy()
lastindex = None
for index, row in df.iterrows():
if lastindex:
for i in row.index:
try:
df.at[index,i] = dfc.at[index,i] - dfc.at[lastindex,i]
except:
logging.exception("Error")
df.at[index,i] = 0
lastindex = index
df = df.T
df = df.sort_values(sort, ascending=False)
self.reports.append({'Name':Name,'Data':df, 'Type':type})
def generateExcel(self):
# Create a Pandas Excel writer using XlsxWriter as the engine.\
os.chdir('/tmp')
writer = pd.ExcelWriter('cost_explorer_report.xlsx', engine='xlsxwriter')
workbook = writer.book
for report in self.reports:
print(report['Name'],report['Type'])
report['Data'].to_excel(writer, sheet_name=report['Name'])
worksheet = writer.sheets[report['Name']]
if report['Type'] == 'chart':
# Create a chart object.
chart = workbook.add_chart({'type': 'column', 'subtype': 'stacked'})
chartend=13
for row_num in range(1, len(report['Data']) + 1):
chart.add_series({
'name': [report['Name'], row_num, 0],
'categories': [report['Name'], 0, 1, 0, chartend],
'values': [report['Name'], row_num, 1, row_num, chartend],
})
chart.set_y_axis({'label_position': 'low'})
chart.set_x_axis({'label_position': 'low'})
worksheet.insert_chart('O2', chart, {'x_scale': 2.0, 'y_scale': 2.0})
writer.save()
#Time to deliver the file to S3
if os.environ.get('S3_BUCKET'):
s3 = boto3.client('s3')
s3.upload_file("cost_explorer_report.xlsx", os.environ.get('S3_BUCKET'), "cost_explorer_report.xlsx")
if os.environ.get('SES_SEND'):
#Email logic
msg = MIMEMultipart()
msg['From'] = os.environ.get('SES_FROM')
msg['To'] = COMMASPACE.join(os.environ.get('SES_SEND').split(","))
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = "Cost Explorer Report"
text = "Find your Cost Explorer report attached\n\n"
msg.attach(MIMEText(text))
with open("cost_explorer_report.xlsx", "rb") as fil:
part = MIMEApplication(
fil.read(),
Name="cost_explorer_report.xlsx"
)
part['Content-Disposition'] = 'attachment; filename="%s"' % "cost_explorer_report.xlsx"
msg.attach(part)
#SES Sending
ses = boto3.client('ses', region_name=SES_REGION)
result = ses.send_raw_email(
Source=msg['From'],
Destinations=os.environ.get('SES_SEND').split(","),
RawMessage={'Data': msg.as_string()}
)
def lambda_handler(event, context):
costexplorer = CostExplorer(CurrentMonth=False)
#Default addReport has filter to remove Support / Credits / Refunds / UpfrontRI
#Overall Billing Reports
costexplorer.addReport(Name="Total", GroupBy=[],Style='Total',IncSupport=True)
costexplorer.addReport(Name="TotalChange", GroupBy=[],Style='Change')
costexplorer.addReport(Name="TotalInclCredits", GroupBy=[],Style='Total',NoCredits=False,IncSupport=True)
costexplorer.addReport(Name="TotalInclCreditsChange", GroupBy=[],Style='Change',NoCredits=False)
costexplorer.addReport(Name="Credits", GroupBy=[],Style='Total',CreditsOnly=True)
costexplorer.addReport(Name="Refunds", GroupBy=[],Style='Total',RefundOnly=True)
costexplorer.addReport(Name="RIUpfront", GroupBy=[],Style='Total',UpfrontOnly=True)
#GroupBy Reports
costexplorer.addReport(Name="Services", GroupBy=[{"Type": "DIMENSION","Key": "SERVICE"}],Style='Total',IncSupport=True)
costexplorer.addReport(Name="ServicesChange", GroupBy=[{"Type": "DIMENSION","Key": "SERVICE"}],Style='Change')
costexplorer.addReport(Name="Accounts", GroupBy=[{"Type": "DIMENSION","Key": "LINKED_ACCOUNT"}],Style='Total')
costexplorer.addReport(Name="AccountsChange", GroupBy=[{"Type": "DIMENSION","Key": "LINKED_ACCOUNT"}],Style='Change')
costexplorer.addReport(Name="Regions", GroupBy=[{"Type": "DIMENSION","Key": "REGION"}],Style='Total')
costexplorer.addReport(Name="RegionsChange", GroupBy=[{"Type": "DIMENSION","Key": "REGION"}],Style='Change')
if os.environ.get('COST_TAGS'): #Support for multiple/different Cost Allocation tags
for tagkey in os.environ.get('COST_TAGS').split(','):
tabname = tagkey.replace(":",".") #Remove special chars from Excel tabname
costexplorer.addReport(Name="{}".format(tabname)[:31], GroupBy=[{"Type": "TAG","Key": tagkey}],Style='Total')
costexplorer.addReport(Name="Change-{}".format(tabname)[:31], GroupBy=[{"Type": "TAG","Key": tagkey}],Style='Change')
#RI Reports
costexplorer.addRiReport(Name="RICoverage")
costexplorer.addRiReport(Name="RIUtilization")
costexplorer.addRiReport(Name="RIUtilizationSavings", Savings=True)
costexplorer.addRiReport(Name="RIRecommendation") #Service supported value(s): Amazon Elastic Compute Cloud - Compute, Amazon Relational Database Service
costexplorer.generateExcel()
return "Report Generated"
```
IAM Role
--------
Чтобы запускаться, Lambda функция должна обладать ролью с приведенными ниже правами:
### Базовая политика Lambda
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "*"
}
]
}
```
### Разрешение для записи отчетов в S3 бакет
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject"
],
"Resource": "arn:aws:s3:::account.admin/*"
}
]
}
```
### Simple Email Service
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"ses:SendEmail",
"ses:SendRawEmail"
],
"Resource": "*"
}
]
}
```
### Cost Explorer
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "ce:*",
"Resource": "*"
}
]
}
```
Запуск на Event Bridge
----------------------
Наконец, мы настраиваем регулярный запуск нашей Lambda функции на Event Bridge, например, 5 числа каждого месяца. В результате работы всех настроек я буду получать email с прикрепленным XLS-отчетом. Также можно настраивать срабатывание еженедельно и даже на определенные дни недели, при необходимости. | https://habr.com/ru/post/552462/ | null | ru | null |
# Задачи и решения для бойца PostgreSQL
[](https://habr.com/post/423097)
Приветствую всех любителей SQL!
В интернете я редко встречал статьи, которые охватывают разные рабочие моменты и тонкости, связанные с **обработкой данных в SQL**.
Мне нравится, когда из одной статьи можно почерпнуть сразу много всего, пусть даже в общих чертах.
Поэтому решил написал свою статью, содержащую различные задачи и ответы с пояснениями к ним.
Подойдет для тех, кто хорошо освоил все базовые навыки и хочет развиваться дальше.
Представленные ответы подходят для **PostgreSQL** (большинство задач подойдут и для других СУБД, но результаты и решения могут быть иными. Даже интересно, где возникнут отличия)
*Постарайтесь ответить самостоятельно, перед открытием спойлера.*
Поехали!
Буду стараться помечать звездочкой, что-либо сугубо для PostgreSQL\* (таких моментов не много)
#### 1. Немного о числовых операциях
**1.1** Выполнятся ли эти запросы? Какие результаты они вернут?
```
-- А) Начнем с простого запроса
SELECT 3/2;
-- Б)
SELECT min('Какой-то текст'::TEXT), avg('Какой-то текст'::TEXT);
-- В)* Почему данный запрос может вернуть FALSE, возможно ли такое поведение СУБД?
SELECT 7.2 = (3.8::FLOAT + 3.4)
-- Г)
SELECT (20/25)*25.0;
```
**Ответы на 1.1**А) Ответ: **1**
Будет показана только целая часть, т.к. при операции используются целые числа. Такое часто встречается и в других языках.
Б) Ответ: запрос **не выполнится**.
**avg** выдаст ошибку, т.к. принимает только числа и временные интервалы\*
Однако функция **min / max** может выполняться на текстовых данных (в соответствии с алфавитной сортировкой в БД).
Иногда это может быть полезно, когда нужно хотя бы посмотреть на столбец, который не перечислен в *GROUP BY*
Или когда к числам нужно применить алфавитную сортировку, при которой '10' < '2'
В) Ответ: **FALSE**
Может показаться странным, но такое допустимо, т.к. это особенность представления компьютером некоторых чисел с плавающей точкой, число может принять вид 7.1(9)
Вспоминается, как когда-то я долго разбирался с запросом, не зная этого
Г) Ответ: **0**. подвох в том, что выражение в скобках будет =0
SELECT (20/25.0)\*25 отработал бы более корректно
**1.2** Дана таблица "*table\_2*" (с единственным столбцом "*value*"(INTEGER)) состоящая из следующих 5 строк:
| value |
| --- |
| 5 |
| 5 |
| NULL |
| 5 |
| 5 |
Какой результат вернет запрос:
```
SELECT (avg(value)*count(*)) - sum(value) FROM table_2;
```
**Варианты ответов*** -4
* 0
* NULL
* 5
* Вызовет ошибку, т.к. не указан GROUP BY
* Ни один из перечисленных
**Ответ 1.2**ответ: **5**
Агрегатные функции, примененные к конкретному столбцу, игнорируют *NULL*, однако count**(\*)** посчитает все строки
5 \* 5 — 20
#### 2. Общие вопросы
**2.1** В каких случаях запрос может вернуть не всё содержимое таблицы? (*parent\_id* INTEGER, таблица наполнена разнообразными данными)
```
SELECT * FROM any_table WHERE parent_id = parent_id;
```
А как поведет себя запрос ниже? Какие данные он выведет? *\*PostgreSQL*
```
SELECT * FROM any_table WHERE parent_id IS NOT DISTINCT FROM parent_id;
```
**Ответы на 2.1**Первый запрос покажет все записи, кроме тех, где *parent\_id* является **NULL**
Второй запрос покажет все записи таблицы. IS DISTINCT FROM по логике похож на оператор **!=** в котором NULL идентичен NULL
IS **NOT** DISTINCT FROM логически обратит неравенство в равенство
**2.2.** Какой результат будет у запроса?
```
-- А)
SELECT * FROM (
SELECT 1
UNION ALL
SELECT 1
) x(y)
UNION
(
SELECT 2
UNION ALL
SELECT 2
);
```
**Ответ на 2.2**Результатом будет 2 строки со значениями **1** и **2**, *UNION* удалит все дубликаты в результирующей выборке, а не только между двумя объединяемыми таблицами. Замечал, что не для всех это очевидно.
**2.3** Напишите запрос, который покажет завтрашнюю дату.
**Ответ на 2.3**
```
SELECT CAST((now()+ INTERVAL '1 DAY') AS DATE)
```
Не все часто работают с датами, но какой-то минимум освоить стоит
\*Решение для Postgres, но думаю другие СУБД не сильно отличаются
Если работа с датами Вам в новинку, то советую поэкспериментировать с запросом
Например:
— заменить DAY на (week, month, year и т.д.)
— заменить +1 на -9000
— заменить DATE на TIME
— убрать CAST
— оставить только NOW()
и т.д.
И, вдохновившись какими-то результатами, отправляйтесь читать [MANUAL](https://postgrespro.ru/docs/postgresql/10/functions-datetime), все темы там подробно раскрыты
**2.4** Операторы **UPDATE**, **DELETE** , **INSERT** и **MERGE** созданы для манипулирования данными в таблицах. А является ли выполнение **SELECT ..** «безопасным»? Может ли какой-либо запрос повлиять на данные в таблице?
**Ответ на 2.4**Вопрос может показаться примитивным, однако…
В самом начале изучения SQL, у меня складывалось мнение, что этот оператор может только показывать данные, но:
Помимо того, что SELECT способен заблокировать таблицу на изменение (BEGIN; SELECT… FOR UPDATE) \*
SELECT способен вызывать функции, которые могут выполнять практически любые манипуляции.
Новичкам нужно это понимать сразу, а не после выполнения «маленького информационного» запроса на ~~Production~~ сервере
#### 3. Only PostgreSQL
**3.1** Опишите, что произойдет при выполнении данного запроса в SQL диалоге:
```
SELECT * INTO wtf FROM pg_stat_activity;
```
**Ответ на 3.1**Обычно SELECT INTO используется в функциях *plpgsql*, для записи значения в переменную.
Вне plpgsql эффект команды будет аналогичен запросу ниже:
```
CREATE TABLE wtf AS
SELECT * FROM pg_stat_activity;
```
**3.2** что покажет данный «простой» запрос
```
SELECT wtf_ FROM pg_stat_activity AS wtf_ ;
```
**Ответ на 3.2**pg\_stat\_activity системное представление (VIEW) активных процессов в базе.
Особенность запроса в том, что будет выведен один столбец со строками (ROW) имеющими TYPE pg\_stat\_activity (или другой таблицы). Знать это нужно скорее тем, кто пишет функции, подробнее можно почитать в [мануале](https://postgrespro.ru/docs/postgrespro/9.5/rowtypes)
Вопрос добавил потому, что новичок может легко по ошибке получить такой результат, и не понимать в чем дело
#### 4. Работа с текстом. Регулярные выражения
Думаю нужно уметь не только строить запросы, но и представлять результаты в нужном виде.
Регулярные выражения — это отдельная огромная тема, со множеством качественных статей. Поэтому я лишь покажу примеры, без подробных объяснений.
**4.1.** Допустим, есть таблица "*table\_5*" с текстовым столбцом "*X*" и множеством разнообразных строк. Каким запросом можно получить любые последние 10 символов каждой строки?
**Ответ на 4.1**SQL позволяет придумать массу решений одной и той же задачи, к примеру:
самое простое, что приходит на ум — это **right(X,10)**
можно использовать регулярное выражение: **substring( X, '.{0,10}$' )**
можно даже ~~накостылять~~ «извертеться»(во всех смыслах) так: **reverse(substring(reverse(X) for 10))**
**4.2** Имеется таблица «table\_6» с текстовым столбцом «X». В таблице содержится одна строка(весь текст только на английском и русском языке):
```
'Lorem 3 Ipsum 23 standard 7 dummy 17 text Ultimate Answer of Life ?? 777'
```
А) Напишите запрос, который вернет символы с 42-го по 68-ый из этой строки
Б) Как вытащить только ЗАГЛАВНЫЕ (русские или английские) буквы в строке с помощью SQL?
В) Как посчитать сумму чисел (не цифр) в строке с помощью SQL
**SQL набросок**
```
WITH table_6(X) AS(
SELECT 'Lorem 3 Ipsum 23 standard 7 dummy 17 text Ultimate Answer of Life ?? 777'::TEXT
)
SELECT X FROM table_6
```
**Ответы на 4.2**
```
-- ТУТ должен быть WITH из "SQL наброска"
-- А)
SELECT SUBSTRING(LEFT(X,68) FROM 42 ) FROM table_6 -- 1 вариант
SELECT SUBSTRING(X, 42, (68-42)+1) FROM table_6 -- 2 вариант
-- 3 вариант с Вас
-- Б) Все просто, заменяем всё кроме заглавных букв на пустоту
SELECT regexp_replace(X,'[^A-ZА-ЯЁ]', '','g') FROM table_6
-- Буква 'Ё' обычно не входит в диапазон А-Я
-- без параметра 'g' замена произойдет лишь 1 раз
-- В) Без регулярных выражений задача может показаться кошмаром
-- С помощью regexp_matches и жадного поиска** получаем массивы чисел в столбик, и суммируем вытащив из массива
SELECT sum(x[1]::INT)
FROM (
SELECT regexp_matches(X,'[0-9]+','g') FROM table_6
) AS y(x)
-- * в других СУБД функции могут иначе называться
-- ** если уберем +, то получим сумму цифр (будет браться лишь 1 символ, а не вся максимальная последовательность)
```
**4.3** Как заменить в тексте (ячейке таблицы) все двойные (тройные и более) пробелы на одинарный пробел? (по традиции: таблица "*table\_7*" со столбцом "*X*") (P.S. достаточно будет написать *SELECT* возвращающий нужный результат, а не *UPDATE table\_7 ...*)
**Ответ на 4.3**
```
WITH table_7(X) AS (SELECT 'Lorem 3 Ipsum 23 standard 7
dummy 11
text'::TEXT)
-- 1 вариант. Заменяем только пробелы (2 и более подряд)
SELECT regexp_replace(X, '( ){2,}', ' ', 'g') FROM table_7
-- 2 вариант. Заменяем все пробельные символы (табуляция, неразрывный пробел, перевод строки и т.д.) на один пробел, даже если эти символы чередуются
SELECT regexp_replace(X, '\s+', ' ', 'g') FROM table_7
-- Отчаянный вариант! Думаю те, кто когда-либо искал решение подобной задачи, натыкались на такое "изящное" решение. Без использования регулярных выражений..
-- Работает весьма хитро, на любом количестве пробелов, главное, чтобы текст не содержал используемых подстановочных символов
-- Не рекомендую такое использовать, но для разминки ума стоит понять, как оно работает
SELECT replace(replace(replace(X, ' ', '<>'), '><', ''), '<>', ' ') FROM table_7
```
**4.4** Имеется строка "*X*" в которой допущены опечатки. Вместо русских букв (е, о, с, С ) были использованы внешне похожие на них символы английского алфавита. Произведите замену данных символов с помощью SQL.
P.S. Строка должна содержать только русские символы, и переживать за возможное изменение английских слов не стоит.
(Если возникают трудности с заменой всех символов, то замените хотя бы один)
Пример строки:
`X = 'Cтрoитeльствo или рeкoнcтрукция oбъeкта'`
**Ответ на 4.4**
```
-- Несомненно, Replace(Replace(Replace(.. потрясающее решение, но
-- специальная функция гораздо изящнее для такого случая (1 символ на 1 символ)
SELECT TRANSLATE('Cтрoитeльствo или рeкoнcтрукция oбъeкта', 'Cceo', 'Ссео')
```
**4.5** Напишите запрос, который преобразует строку:
**'иВАнОв ИВан иВановиЧ'** к виду **'Иванов Иван Иванович'**
**Ответ на 4.5**
```
-- Все просто, когда имеется такая функция
SELECT initcap('иВАнОв ИВан иВановиЧ')
*Возможно в других СУБД имеются аналоги
```
**Бонусное задание для тех, кто справился**~~Здорово, если есть готовая функция~~
А сможете преобразовать наоборот? (желательно не теряя отступов).
Возможно задача не типичная, но для развития будет полезна.
**'иВАнОв ИВан иВановиЧ'** преобразовать к **'иВАНОВ иВАН иВАНОВИЧ'**
~~а инвертировать регистр?~~
**Ответ на бонусное задание**
```
SELECT string_agg(LOWER(LEFT(x,1)) || UPPER(SUBSTRING(x from 2)), '' ORDER BY rn)
FROM
(SELECT * FROM regexp_split_to_table(' иВАнОв ИВан иВановиЧ
4 TesT', '\y') WITH ORDINALITY y(x, rn) ) AS z
-- *Решение для PostgreSQL, но смысл везде такой же
-- Придумал на скорую руку, без использования процедурного языка
-- возможно неуклюжее и не производительное решение, но для данного примера подходит
-- сохраняет все пробельные символы между словами.
-- WITH ORDINALITY нужен для сохранения порядка символов (доступен с версии 9.4)
-- Разбираем строку по границам слова
-- получаем отдельно строки со словами и разделяющими их символами
-- обрабатываем..
```
#### 5. Чуть-чуть о транзакциях
Транзакции очень важная вещь в СУБД, достаточно важно понимать основные моменты.
Попробую смоделировать пример:
Допустим, есть таблица «goods» с которой собираются работать два пользователя.
В ней имеется целочисленный столбец *discount* равный 10 для всех строк.
Настройки базы данных стандартные (READ COMMITTED — чтение зафиксированных данных).
Пользователь *User\_1* открывает транзакцию, выполняет следующий запрос:
```
BEGIN;
UPDATE goods
SET discount = discount + 5;
```
Секундой позже, другой пользователь (*User\_2*)
Выполняет без открытия транзакции почти такой же запрос:
```
UPDATE goods
SET discount = discount + 10;
```
Как думаете, что произойдет при следующих раскладах:
**А)** Какой результат получит User\_2, если User\_1 оставит транзакцию открытой (т.е. не подтвердит транзакцию / не откатит изменения)?
Что увидит User\_1 при запросе:
```
SELECT discount FROM goods LIMIT 1;
```
**Б)** Что произойдет, если User\_1 сделает ROLLBACK? Какие результаты получит User\_2?
**В)** Что произойдет, если User\_1 сделает COMMIT? Какие результаты получит User\_2?
**Ответы**Насколько я знаю READ **UN**COMMITTED не поддерживается в PostgreSQL, и «грязные» (не подтвержденные) данные прочитать не получится
Ответы будут следующими:
А) Запрос User\_2 будет ожидать COMMIT или ROLLBACK от User\_1. (запрос словно подвиснет)
User\_1 в своей транзакции будет видеть свою версию снимка базы, где *discount* уже равняется **15**
Б) Если User\_1 сделает ROLLBACK, то значение *discount* останется прежним, а следом выполнится запрос User\_2, который прибавит 10 к *discount* и discount будет равен **20**
В) Если User\_1 сделает COMMIT, то значение *discount* увеличится на 5, а следом выполнится запрос User\_2, который прибавит 10 к *discount* и discount будет равен **25**
**Другая версия этой задачи**Немного другая версия задачи 13 от пользователя [kirill\_petrov](https://habr.com/users/kirill_petrov/) на особенность READ COMMITTED
```
-- Имеется таблица с двумя строками
CREATE TABLE goods (discount) AS
(SELECT 10::INT
UNION ALL
SELECT 15);
-- 1. User_1 выполняет запрос (транзакция остается открыта):
BEGIN;
UPDATE goods
SET discount = discount + 5;
--2. User_2 выполняет запрос:
UPDATE goods
SET discount = discount + 100
WHERE discount = 15
--3. User_1 выполняет
COMMIT;
```
Какие данные окажутся в таблице?
#### Заключение
Думаю, что затронул достаточно интересные моменты.
Надеюсь, задачи помогут промотивировать начинающих, ведь скучно что-либо изучать без конкретных целей/задач/направлений.
Могу порадоваться за тех, кому было легко ответить на все вопросы. А те, у кого возникали сложности, надеюсь, получили ~~пинок~~ направление развития. Те кто мало что понял, но хочет освоить SQL, приглашаю на свою прошлую статью [Курс молодого бойца PostgreSQL](https://habr.com/post/340460/).
Жду каких-либо дополнений, решений особо интересных задач(можно своих) и прочих комментариев!
Спасибо за внимание! Желаю успехов в изучении SQL! | https://habr.com/ru/post/423097/ | null | ru | null |
# Haxe и PHP: статическая типизация, стрелочные функции, метапрограммирование и многое другое
Привет, Хабр! Предлагаю вашему вниманию перевод [доклада Александра Кузьменко](https://www.youtube.com/watch?v=IeXgTkh9NAs) с прошедшей недавно (14-15 июня) конференции Hong Kong Open Source Conference 2019.
До того, как присоединиться к Haxe Foundation в качестве разработчика компилятора Haxe, Александр около 10 лет профессионально занимался программированием на PHP, так что он знает предмет доклада.
Небольшое введение о том, что такое Haxe — это кроссплатформенный набор инструментов для создания ПО, в состав которого входят:
* компилятор, который в зависимости от целевой платформы либо транслирует исходный Haxe-код в исходный код на других языках программирования (C++, PHP, Java, C#, JavaScript, Python, Lua), либо компилирует непосредственно в байт-код виртуальной машины (JVM, neko, HashLink, Flash)
* стандартная библиотека, реализованная для всех поддерживаемых платформ
* также Haxe предоставляет средства для взаимодействия с кодом, написанным на языке целевой платформы
* стандартный менеджер библиотек — haxelib
Поддержка PHP в Haxe появилась довольно давно — еще в 2008 году. В версиях Haxe до 3.4.7 включительно поддерживался PHP 5.4 и выше, а начиная с четвертой версии в Haxe поддерживается PHP версии 7.0 и выше.
Вы спросите: зачем PHP-разработчику использовать Haxe?
Основная причина для этого — возможность использовать одну и ту же логику и на сервере и на клиенте.
Рассмотрим такой пример: у вас есть сервер, написанный на PHP с использованием фреймворка Laravel, и несколько клиентов, написанных на JavaScript, Java, C#. В таком случае для обработки сетевого взаимодействия между сервером и клиентом (логика которого по идее одна и та же) от вас потребуется написать 4 реализации для каждого из используемых языков. Но с помощью Haxe вы можете написать код сетевого протокола один раз и затем скомпилировать/транслировать его под разные платформы, значительно сэкономив на этом время.
Вот еще пример — игровое приложение — клон Clash of Clans. Александр участвовал в разработке подобной игры: ее сервер был написан на PHP, мобильный клиент — на C# (Xamarin), а браузерный клиент — на JavaScript с использованием фреймворка Phaser. На клиенте и сервере обрабатывалась одна логика — так называемая "боёвка", которая просчитывала поведение юнитов игроков на локации. Изначально код боёвки был написан для каждой из платформ по-отдельности. Но со временем (а проект развивался около 5 лет) накапливались различия в ее поведении на сервере и на клиентах. Связано это было с тем, что писали ее разные люди, каждый из которых реализовывал ее по-своему. Из-за этого не было надежного способа обнаружения читеров, т.к логика на сервере вела себя совсем не так, как на клиенте, в результате страдали и честные игроки, т.к. сервер мог посчитать их читерами и не засчитать результаты честного боя.
В конце концов было принято решение перевести боёвку на Haxe, что позволило полностью решить проблему с читерами, т.к. теперь логика боёвки вела себя одинаково на всех платформах. Кроме того, данное решение позволило сократить расходы на дальнейшее развитие боевой системы, т.к. теперь было достаточно одного программиста, знакомого с Haxe, вместо трех, каждый из которых отвечал бы за свою платформу.
В чем Haxe и PHP отличаются друг от друга? В общем, синтаксис Haxe не покажется PHP-программисту чем-то чужеродным. Да, он отличается, но в большинстве случаев он будет очень похож на PHP.
На слайде показано сравнение кода для вывода строки в консоль. В Haxe код выглядит практически так же, за исключением того, что для работы с функциями PHP необходимо их импортировать (см. первую строку).
А вот так выглядит сгенерированный PHP-код в сравнении с написанным вручную.
Компилятор Haxe автоматически добавляет в код блок комментариев с описанием типов аргументов функций и возвращаемыми типами, поэтому полученный код можно подключить к PHP-проекту и для него прекрасно будет работать автодополнение.
Рассмотрим некоторые существенные отличия в синтаксисе Haxe и PHP.
Начнем с отличий в синтаксисе анонимных функций (на примере их использования для сортировки массива).
На слайде показана анонимная функция, которая захватывает и изменяет значение локальной переменной `desc`. В PHP для этого необходимо явно указать, какие переменные доступны в теле анонимной функции. Кроме того, чтобы иметь возможность изменять значение переменной, необходимо добавить `&` перед ее именем.
В Haxe такая необходимость отпадает, т.к. компилятор сам определяет, к каким переменным вы обращаетесь. Кроме того, в Haxe 4 появились стрелочные функции (краткая форма описания анонимных функций), используя которые можно сократить наш пример с сортировкой массива всего до одной строки.
Еще одно отличие в синтаксисе — это различия в описании управляющей конструкции `switch`. В PHP `switch` работает так же как и в Си. В Haxe он работает иначе:
* во-первых, в switch не используется ключевое слово `break`
* во-вторых, можно объединять несколько условий с помощью `|` (а не дублировать ключевое слово `case`)
* в-третьих, в Haxe для `switch` используется pattern matching (механизм сопоставления с образцом). Так, например, можно применить `switch` к массиву, и в условиях можно определить действия в зависимости от содержимого массива (знак `_` означает, что данное значение нас не волнует и может быть любым). Условие `[1, _, 3]` будет выполнено если массив состоит из трех элементов, при этом первый элемент равен 1, третий — 3, а значение второго — любым.
В Haxe все является выражением, и это позволяет писать более компактный код. Можно вернуть значение из `try`/`catch`, `if` или `switch`, не используя ключевое слово `return` внутри данных конструкций. В приведенном примере с `try`/`catch` компилятор "знает", что вы хотите вернуть некоторое значение, и сможет передать его из данной конструкции.
PHP постепенно движется в направлении более строгой типизации, но в Haxe уже есть строгая статическая типизация!
В приведенном примере мы присваиваем переменной `s` значение, полученное из функции `functionReturnsString()`, которая возвращает строку. Таким образом, тип переменной `s` — строка. И если попытаться передать ее в функцию `giveMeInteger()`, ожидающую в качестве аргумента целое число, то компилятор Haxe выдаст ошибку о несоответствии типов.
Этот пример также демонстрирует еще одну важную особенность Haxe — выведение типов (type inference) — способность компилятора самостоятельно определять типы переменных в зависимости от того, какое значение ей присвоить.
Для программиста это означает, что в большинстве случаев явно указывать типы переменных необязательно. Так в приведенной функции `isSmall()` компилятор определит, что тип аргумента `a` — целое число, т.к. в первой строке тела функции мы сравниваем значение `a` с целым числом. Далее компилятор на основании того, что во второй строке тела функции мы возвращаем `true`, определяет, что возвращаемый тип — булева величина. И т.к. компилятор уже определил тип возвращаемого значения, то при дальнейших попытках вернуть из функции какой-либо другой тип, он выдаст ошибку несоответствия типов.
В Haxe, в отличие от PHP, нет автоматического преобразования типов. Например, в PHP возможно вернуть строку из функции, для которой указано, что она возвращает целое число, в таком случае при выполнении скрипта строка будет преобразована в число (не всегда успешно). А в Haxe аналогичный код попросту не скомпилируется — компилятор выдаст ошибку несоответствия типов.
Еще одним отличием Haxe является его расширенная система типов, включающая в себя:
* типы функций, состоящие из типов аргументов функции и возвращаемого типа
* обобщенные (параметризированные) типы (к ним, например, относятся массивы, для которых в качестве параметра используется тип хранимых значений)
* перечисляемые типы
* [обобщенные алгебраические типы данных](https://code.haxe.org/category/functional-programming/enum-gadt.html)
* типы анонимных структур позволяют объявлять типы для объектов без объявления классов
* [абстрактные типы данных](https://haxe.org/manual/types-abstract.html) (абстракции над существующими типами, но без потери производительности в рантайме)
Все перечисленные типы при компиляции преобразуются в PHP-классы.
Одной из главных отличительных особенностей Haxe является метапрограммирование (в Haxe оно называется макросами), то есть возможность автоматической генерации исходного кода программы.
Макросы выполняются во время компиляции программы и пишутся на обычном Haxe.
Макросы имеют полный доступ к абстрактному синтаксическому дереву, то есть могут читать (искать в нем требуемые выражения) и изменять его.
Макросы могут генерировать выражения, изменять существующие типы, а также создавать новые.
В контексте PHP макросы могут например использоваться для роутинга. Скажем, у вас есть простой класс-роутер, в котором реализованы метод для отображения страницы по ее идентификатору, а также метод для выхода из системы. Используя макрос, можно сгенерировать код для метода `route()`, который на основании http-запроса будет перенаправлять его в соответствующий метод класса `Router`. Таким образом, отпадает необходимость вручную писать if’ы для вызовов каждого из методов данного класса (макрос сделает это автоматически при компиляции проекта в PHP). Заметьте, что полученный код не использует рефлексию, не требует никаких специальных конфигурационных файлов, или каких-либо еще дополнительных ухищрений, поэтому работать будет он очень быстро.
Еще один пример использования макросов — генерация кода для парсинга и валидации JSON. К примеру, у вас есть класс `Data`, объекты которого должны создаваться на основании данных, получаемых из JSON. Это можно сделать с помощью макроса, но так как у макроса есть доступ к структуре класса `Data`, то в дополнение к парсингу можно сгенерировать код для валидации JSON, добавив выброс исключений при отсутствии полей или несоответствии типа данных. Таким образом, можно быть уверенным в том, что ваше приложение не пропустит некорректные данные, получаемые от пользователей или от стороннего сервера.
Стоит также упомянуть важные особенности реализации некоторых типов данных для платформы PHP, т.к. если не учитывать их, то можно столкнуться с неприятными последствиями.
В PHP строки бинарно-безопасные ([binary safe](http://en.wikipedia.org/wiki/Binary-safe)), поэтому в PHP, если вам не требуется поддержка Юникод, методы для работы со строками работают очень быстро.
В Haxe, начиная с четвертой версии, строки поддерживают Юникод, поэтому при их компиляции в PHP будут использоваться методы из модуля для работы с многобайтовыми строками mbstring, а это означает медленный доступ к произвольным символам в строке, медленное вычисление длины строки.
Поэтому если поддержка Юникода вам не нужна, то для работы со строками можно использовать методы класса `php.NativeString`, которые будут использовать "родные" строки из PHP.
На слайде слева представлен код на PHP, который использует как методы, поддерживающие Юникод, так и нет.
Справа представлен эквивалентный код на Haxe. Как видно, если вам нужна поддержка Юникод, то необходимо использовать методы класса `String`, если нет — то методы класса `php.NativeString`.
Еще один важный момент — это работа с массивами.
В PHP массивы передаются по значению, также массивы поддерживают как числовые, так и строковые ключи.
В Haxe массивы передаются по ссылке и поддерживают только числовые ключи (если необходимы строковые ключи, то в Haxe для этого следует использовать класс `Map`). Также в Haxe-массивах не допускаются "дыры“ в индексах (индексы должны идти непрерывно).
Также стоит отметить, что запись в массив по индексу в Haxe довольно медленная.
Здесь приведен код для "маппинга" массива с использованием стрелочной функции. Как видно, компилятор Haxe довольно активно оптимизирует PHP-код, получаемый на выходе: анонимная функция в полученном коде отсутствует, вместо этого ее код применяется в цикле к каждому элементу массива. Кроме `map()` такая оптимизация применяется и к методу `filter()`.
Также при необходимости в Haxe можно использовать класс `php.NativeArray` и соответствующие методы PHP для работы с массивами.
Анонимные объекты реализованы с помощью класса `HxAnon`, который наследуется от класса `StdClass` из PHP.
В PHP `StdClass` — это класс, в экземпляры которого превращается всё, что мы пытаемся конвертировать в объект. И он бы идеально подошёл для реализации анонимных объектов, если бы не одна особенность их спецификации: в Haxe обращение к несуществующему полю анонимного объекта должно возвращать `null`, а в PHP это выкидывает warning. Из-за этого пришлось отнаследоваться от стандартного класса из PHP и добавить ему магический метод, который при обращении к несуществующим свойствам возвращает `null`.
Haxe может взаимодействовать с кодом, написанным на PHP. Для этого имеются следующие возможности (аналогичные возможностям взаимодействия с JavaScript-кодом):
* экстерны (externs)
* вставки PHP-кода напрямую в Haxe-код
* специальные классы из пакета `php.*`
+ `php.Syntax` — для специальных конструкций PHP, которых нет в Haxe
+ `php.Global` — для "нативных" глобальных функций PHP
+ `php.Const` — для "нативных" глобальных констант PHP
+ `php.SuperGlobal` — для сверхглобальных переменных PHP, доступных отовсюду (`$_POST`, `$_GET`, `$_SERVER` и т.п.)
Т.к. PHP использует классическую ООП-модель, то написание экстернов для него — довольно простой процесс. Фактически экстерны для PHP-классов — это практически дословный "перевод" в Haxe, за исключением некоторых ключевых слов.
В качестве примера так будет выглядеть код экстерна для PHP-класса со слайда выше:
Константы из PHP-класса "превращаются" в статические переменные в Haxe-коде (но с добавлением специальных мета-тэгов).
Статическая переменная `$useBuiltinEncoderDecoder` становится статической переменной `useBuiltinEncoderDecoder`.
Отсюда видно, что экстерны для PHP-классов можно создавать автоматически (Александр планирует реализовать [генератор экстернов](https://github.com/RealyUniqueName/peg) в этом году).
Для вставок PHP-кода используется специальный модуль `php.Syntax`. Код, добавляемый таким способом, не подвергается никаким преобразованиям и оптимизациям со стороны компилятора Haxe.
Кроме `php.Syntax` в Haxe осталась возможность использования [untyped-кода](https://haxe.org/manual/target-php-untyped.html).
Также стоит упомянуть такие особенности Haxe, которых нет в PHP:
* реальные свойства с методами для чтения и записи
* поля и переменные, доступные только для чтения
* статические расширения
* мета-тэги, которые можно использовать для аннотации полей и которые доступны для чтения в макросах. Таким образом, мета-тэги используются в основном для метапрограммирования
* Null-безопасность (экспериментальная функция)
* условная компиляция, которая позволяет включать/отключать части кода, которые могут быть доступными, например, в отладочной версии приложения
* компилятор Haxe генерирует высоко-оптимизированный PHP-код, который может работать в разы быстрее PHP-кода, написанного вручную.
Больше информации о Haxe и о его функциях доступно в его [официальном руководстве](https://haxe.org/manual). | https://habr.com/ru/post/458184/ | null | ru | null |
# Семантический поиск: от простого сходства Жаккара к сложному SBERT
В материале, переводом которого мы решили поделиться к старту курса о [машинном и глубоком обучении](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=060721), простым языком рассказывается о семантическом поиске, статья охватывает шесть его методов; начиная с простых сходства по Жаккару, алгоритма шинглов и расстояния Левенштейна, автор переходит к поиску с разреженными векторами — TF-IDF и BM25 и заканчивает современными представлениями плотных векторов и Sentence-BERT. Простые примеры сопровождаются кодом и иллюстрациями, а в конце вы найдёте ссылки на соответствующие блокноты Jupyter.
---
Поиск сходства — одна из самых быстрорастущих областей в ИИ и машинном обучении. По своей сути, это процесс сопоставления релевантных частей информации друг с другом. Велика вероятность, что вы нашли эту статью через поисковую систему — скорее всего, Google. Возможно, вы искали что-то вроде "what is semantic similarity search?" или "traditional vs vector similarity search". Google обработал ваш запрос и использовал многие основные принципы поиска по сходству, о которых рассказывается в этой статье.
Если поиск сходства лежит в основе успеха компании стоимостью $ 1,65 Т — пятой по стоимости в мире[1], есть *большой шанс*, что о нём стоит узнать больше. [Поиск сходства](https://www.pinecone.io/learn/what-is-similarity-search/) — сложная тема, есть бесчисленное множество методик построения эффективных поисковых систем. В этой статье мы рассмотрим несколько наиболее интересных и мощных из этих методов, уделяя особое внимание семантическому поиску. Посмотрим, как они работают, чем они хороши и как мы можем применять их самостоятельно. Можно посмотреть это видео или прочитать статью.
Два видео о двух классах подходов### Традиционный поиск
Мы начинаем с лагеря традиций и там находим нескольких ключевых игроков:
* **Сходство Жаккара.**
* **Алгоритм шинглов.**
* **Расстояние Левенштейна.**
Все это показатели отлично работают при поиске сходства, из них мы рассмотрим три самых популярных: сходство по Жаккару, алгоритм шинглов и расстояние Левенштейна.
### Сходство Жаккара
Сходство Жаккара — это простая, но иногда мощная метрика сходства. Даны две последовательности **A** и **B**: находим число общих элементов в них и делим найденное число на количество элементов обеих последовательностей.
Сходство Жаккара измеряет пересечение между двумя последовательностями по сравнению с объединением двух последовательностейПример: даны две последовательности целых чисел, запишем:
Здесь мы определили **два** общих *неодинаковых* целых числа, 3 и 4 — между двумя последовательностями с общим количеством десяти целых чисел в обеих, где **восемь** чисел являются уникальными значениями — 2/8 даёт нам оценку сходства по Жаккарду 0,25. Ту же операцию можно выполнить и для текстовых данных: всё, что мы делаем, — заменяем *целые числа* на *токены*.
Сходство по Жаккару, рассчитанное между двумя предложениями a и bМы обнаружили, что, как и ожидалось, предложения b и c набрали гораздо больше баллов. Конечно, это не лучшее решение — два предложения, в которых нет ничего общего, кроме слов *'the'*, *'a'*, *'is'* и т. д., могут получить высокие оценки Жаккара, несмотря на то, что они неодинаковы по смыслу. Эти недостатки могут быть частично устранены с помощью методов предварительной обработки, таких как удаление стоп-слов, стемминг/лемматизация и т. д. Однако, как мы скоро увидим, некоторые методы позволяют полностью избежать этих проблем.
### Алгоритм шинглов
Другая похожая техника — алгоритм использует точно такую же логику *пересечения/объединения* — но с "шинглом". 2-шингловое предложение **a** будет выглядеть так:
```
a = {'his thought', 'thought process', 'process is', ...}
```
После можно применить тот же расчёт пересечения/объединения между разбитыми на шинглы предложениями:
При помощи двух шинглов находим три совпадающих шингла между предложениями **b** и **c**, в результате сходство составляет **0,125**.
### Расстояние Левенштейна
Другая популярная метрика сравнения двух строк — расстояние Левенштейна — это количество операций, необходимых для преобразования одной строки в другую, вот его формула:
Формула расстояния ЛевенштейнаНа вид она довольно сложна; если вы её поняли, это прекрасно! Если нет, не волнуйтесь — мы разберём её. Переменные a и b представляют две наши строки, i и j — позиции символов в a и b соответственно. Итак, даны строки:
"Levenshtein" и неправильно написанное "Livinshten"Мы найдём, что:
Индексируем само слово, начиная с 1 до его длины, нулевой индекс означает "ничего" (подробнее об этом — далее).Это легко! Прекрасный способ понять логику этой формулы — визуализировать алгоритм Вагнера — Фишера, рассчитывающий расстояние Левенштейна при помощи простой матрицы. Мы берём два слова a и b и размещаем их по обеим осям нашей матрицы, включая символ *ничего* как пустое пространство:
Пустая матрица Вагнера-Фишера — мы будем работать с ней для вычисления расстояния Левенштейна между 'Levenshtein' и 'Livinshten'.*Код инициализации пустой матрицы Вагнера — Фишера:*
Переберём все позиции в матрице и применим ту сложную формулу, которую видели ранее. Первый шаг в нашей формуле if min(i, j) = 0 — здесь мы уточняем, не равны ли i и j нулю? Если да, переходим к функции max(i, j), которая присваивает текущей позиции в нашей матрице больше из двух значений — i и j:
Начнём справа, вдоль рёбер, где i и/или j равно 0, значение в матрице будет заполнено max(i, j)*Код операций min(i, j) == 0, за которой следует визуализированная выше max(i, j).*
С внешними краями нашей матрицы мы разобрались, но нам всё ещё нужно вычислить внутренние значения — именно там будет проходить оптимальный путь. Вернёмся к if min(i, j) = 0 — что, если ни одно из них не равно 0? Затем переходим к сложной части уравнения в разделе min {. Нам нужно вычислить значение для каждой строки, а после взять **минимальное** значение. Сейчас эти значения известны — они находятся в нашей матрице:
Для каждой новой позиции берём минимальное значение из трёх соседних позиций (обведено кружком вверху слева)lev(i-1, j), а все остальные операции — это операции индексации, когда мы извлекаем значение в данной позиции. Затем берём минимальное значение из трёх. Остаётся только одна операция. +1 слева должно применяться только в том случае, если a[i] != b[i] — это штраф за несовпадение символов.
![Если a[i] != b[j], прибавляем 1 к нашему минимальному значению — это штраф за несовпадение символов](https://habrastorage.org/r/w1560/getpro/habr/upload_files/12c/fbc/914/12cfbc914c84442521dd0be415c77d46.png "Если a[i] != b[j], прибавляем 1 к нашему минимальному значению — это штраф за несовпадение символов")Если a[i] != b[j], прибавляем 1 к нашему минимальному значению — это штраф за несовпадение символовЭта операция в цикле по всей матрице выглядит так:
*Полная реализация расчёта расстояния Левенштейна при помощи матрицы Вагнера — Фишера.*
Итак, мы вычислили каждое значение в матрице — эти значения представляют собой количество операций, необходимых для преобразования из строки a до позиции i в строку b до позиции j. Мы ищем количество операций для преобразования a в b, поэтому мы берём правое нижнее значение нашего массива lev[-1, -1].
![Оптимальный путь по матрице — в позиции [-1, -1] внизу — справа мы имеем расстояние Левенштейна между двумя строками](https://habrastorage.org/r/w1560/getpro/habr/upload_files/c9d/56c/572/c9d56c5721de0206c637ddecac7be442.png "Оптимальный путь по матрице — в позиции [-1, -1] внизу — справа мы имеем расстояние Левенштейна между двумя строками")Оптимальный путь по матрице — в позиции [-1, -1] внизу — справа мы имеем расстояние Левенштейна между двумя строками### Векторное сходство
Для поиска на основе вектора мы обычно используем один из нескольких методов построения векторов:
* TF-IDF.
* BM25.
* word2vec/doc2vec.
* BERT.
* USE.
В тандеме с некоторыми реализациями *приблизительных* ближайших соседей (ANN) эти векторные методы в мире поиска сходства, если говорить терминами программирования, — минимально жизнеспособные продукты. Рассмотрим подходы на основе TF-IDF, BM25 и BERT, поскольку они являются наиболее распространёнными и охватывают как разреженные, так и плотные [векторные представления](https://www.pinecone.io/learn/vector-embeddings/).
### 1. TF-IDF
Почтенный дедушка векторного поиска сходства, родившийся ещё в 1970-х годах. Он состоит из двух частей: **T**erm **F**requency (TF) и **I**nverse **D**ocument **F**requency (IDF). Компонент TF подсчитывает, сколько раз термин встречается в документе, и делит его на общее количество терминов этого же документа.
Компонент частоты термина (TF) TF-IDF подсчитывает частоту нашего запроса ("bananas") и делит её на частоту всех лексемЭто первая половина нашего расчёта, мы имеем частоту запроса в рамках текущего документа f(q, D) в числителе и частоту всех терминов в рамках текущего документа f(t, D) в знаменатели дроби. TF — хороший показатель, но не позволяет нам провести различие между распространёнными и необычными словами. Если бы мы искали слово "the", используя только TF, мы бы присвоили этому предложению ту же релевантность, что и при поиске "bananas". Это хорошо, пока мы не начнём сравнивать документы или искать что-то с помощью длинных запросов. Мы не хотим, чтобы такие слова, как *'the'*, 'is' или *'it'*, были оценены так же высоко, как *'bananas'* или *'street'*.
В идеале хочется, чтобы совпадения между более редкими словами оценивались выше. Для этого мы можем умножить TF на второй член — IDF. Обратная частота документа измеряет, насколько часто встречается слово во *всех* наших документах.
Компонент обратной частоты документов (IDF) TF-IDF подсчитывает количество документов, содержащих наш запрос.Здесь три предложения. Вычислив IDF для нашего распространённого слова *'is'*, получаем гораздо меньшее число, чем в случае более редкого слова *'forest'*. Если бы после мы искали оба слова *'is'* и *'forest'*, то объединили бы TF и IDF следующим образом:
Мы вычисляем оценки TF('is', D) и TF('forest', D) для документов a, b и c. Значение IDF относится ко всем документам, поэтому IDF('is') и IDF('forest') вычисляются только один раз. Затем мы получаем значения TF-IDF для обоих слов в каждом документе путём умножения компонентов TF и IDF. Предложение a набирает наибольшее количество баллов для 'forest', а 'is' всегда набирает 0, поскольку IDF('is') равно 0.
Это замечательно, но где здесь применяется *векторное* сходства? Итак, мы берём наш словарный запас (большой список всех слов в нашем наборе данных) и вычисляем TF-IDF для каждого слова.
Мы вычисляем значение TF-IDF каждого слова словаря, чтобы создать вектор TF-IDF. Этот процесс повторяется в каждом документеЧтобы сформировать векторы TF-IDF, мы можем собрать это воедино:
Отсюда мы получаем вектор TF-IDF. Стоит отметить, что словарь легко может иметь более 20 000 слов, поэтому созданные этим методом векторы невероятно разрежены, а это означает, что закодировать какой-либо семантический смысл мы не можем.
### 2. BM25
Преемник TF-IDF, Okapi BM25, является результатом оптимизации TF-IDF в первую очередь для нормализации результатов на основе длины документа. TF-IDF — отличный инструмент, но он может давать сомнительные результаты, когда мы начинаем сравнивать несколько упоминаний. Если мы возьмём две статьи по 500 слов и обнаружим, что "Черчилль" в статье А упоминается 6 раз, а в статье Б — 12 раз, должны ли мы считать статью А в два раза менее релевантной? Скорее всего, нет. BM25 решает эту проблему путём модификации TF-IDF:
Формула BM25Уравнение выглядит довольно неприятно, но это не что иное, как наша формула TF-IDF с несколькими новыми параметрами! Давайте сравним два компонента TF:
TF-часть BM25 (слева) по сравнению с TF-частью TF-IDF (справа)И затем часть IDF, которая даже не вводит никаких новых параметров — она просто переставляет IDF из TF-IDF.
IDF часть BM25 (слева) в сравнении с IDF TF-IDF (справа)Итак, каков результат этой модификации? Если взять последовательность из 12 лексем и постепенно подавать в неё всё больше и больше "подходящих" лексем, то получим следующие результаты:
Сравнение алгоритмов TF-IDF (вверху) и BM25 (внизу) с использованием предложения из 12 лексем и возрастающего числа релевантных лексем (ось x)Показатель TF-IDF линейно увеличивается с ростом числа релевантных лексем. Таким образом, если частота удваивается — увеличивается и показатель TF-IDF. Звучит круто! Но как реализовать это на Python? Опять же напишем простую и понятную реализацию, как с TF-IDF.
Мы использовали параметры по умолчанию для k и b, и наши результаты выглядят многообещающе. Запрос 'purple' соответствует только предложению a, а 'bananas' набирает приемлемые баллы и для b, и для c, но для c — немного выше благодаря меньшему количеству слов. Чтобы построить векторы на основе этих данных, сделаем то же самое, что и с TF-IDF.
Опять же, как и в случае с векторами TF-IDF, эти векторы разрежены. Мы не сможем кодировать семантическое [смысловое] значение, вместо этого сосредоточимся на синтаксисе.
Теперь давайте посмотрим, как можно начать рассматривать семантику.
### 3. BERT
BERT (Bidirectional Encoder Representations from Transformers) — это чрезвычайно популярная модель трансформатора, в NLP она используется *почти* для всего. Посредством 12 (или около того) уровней кодера BERT кодирует огромное количество информации в набор *плотных* векторов.
Каждый плотный вектор обычно содержит 768 значений, и мы обычно имеем 512 таких векторов для каждого закодированного BERT предложения. Эти векторы содержат то, что мы можем рассматривать как числовые представления языка. Эти векторы также возможно извлечь (если этого захочется) из разных слоёв, но обычно из последнего слоя. Теперь, имея два правильно закодированных плотных вектора, мы можем использовать метрику сходства, такую как косинусное сходство, чтобы рассчитать теперь уже семантическое сходство. Более выровненные векторы семантически схожи, и наоборот.
Меньший угол между векторами (рассчитанный с помощью косинусного сходства) означает, что они более выровнены. Для плотных векторов это коррелирует с большим семантическим сходствомНо есть одна проблема: каждая последовательность представлена 512 векторами — не одним вектором. Вот здесь-то и появляется ещё одна — блестящая — адаптация BERT. Sentence-BERT позволяет нам создать один вектор, который представляет нашу полную последовательность, иначе известную как *вектор предложений*[2]. У нас есть два способа реализации SBERT: простой способ с использованием библиотеки sentence-transformers или уже не столько простой способ с использованием transformers *и* PyTorch.
Рассмотрим оба варианта, начиная с подхода через transformers и PyTorch, чтобы получить интуитивное представление о построении векторов. Если вы уже использовали библиотеку трансформаторов HF, первые несколько шагов покажутся вам очень знакомыми: инициализируем SBERT и токенизатор, токенизируем наш текст и обработаем токены моделью.
Мы добавили сюда новое предложение, предложение **g** несёт тот же *семантический* смысл, что и **b**, — без тех же ключевых слов. Из-за отсутствия общих слов все наши предыдущие методы не смогли бы найти сходство между этими двумя последовательностями — запомните это на будущее.
У нас есть векторы длины 768, но это **не** *векторы предложений*, так как мы имеем векторное представление каждой лексемы в последовательности (поскольку мы работаем SBERT, их здесь 128, а в случае BERT их 512). Для создания вектора предложений нам необходимо выполнить вычислить среднее значение.
Первое, что мы делаем, — умножаем каждое значение в тензоре embeddings на соответствующее значение attention\_mask. Маска attention\_mask содержит **единицы** там, где у нас есть "настоящие токены" (например, не токен заполнения), и **нули** в других местах — эта операция позволяет нам игнорировать ненастоящие токены.
И вот наши векторы предложений, при помощи которых мы можем измерить сходство, вычислив косинусное сходство между всеми векторами.
Визуализировав массив, можно легко определить предложения с более высоким уровнем сходства:
Тепловая карта, показывающая косинусное сходство между нашими векторами предложений SBERT: обведена оценка между предложениями b и gТеперь вспомните замечание о том, что предложения b и g имеют по сути одинаковый смысл, но не имеют *ни одного* одинакового ключевого слова. Мы надеемся, что SBERT с его превосходными семантическими представлениями языка определит эти два предложения как похожие — и вот, пожалуйста, сходство между ними составляет 0,66 балла (обведено выше). Итак, **альтернативный (простой) подход заключается в применении SBERT**. Чтобы получить точно такой же результат, как выше, напишем:
Что, конечно, гораздо проще. На этом завершаем прогулку по истории с Жаккаром, Левенштейном и Bert!
Ссылки* [[1]](https://companiesmarketcap.com/alphabet-google/marketcap/) Market Capitalization of Alphabet (GOOG), Companies Market Cap.
* [[2]](https://arxiv.org/abs/1908.10084) N. Reimers, I. Gurevych, Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks (2019), Proceedings of the 2019 Conference on Empirical Methods in 2019.
* [Репозиторий блокнотов](https://github.com/pinecone-io/examples/tree/master/semantic_search_intro)
Блокноты Colab* [Jaccard](https://colab.research.google.com/github/pinecone-io/examples/blob/master/semantic_search_intro/jaccard.ipynb),
* [Levenshtein](https://colab.research.google.com/github/pinecone-io/examples/blob/master/semantic_search_intro/levenshtein.ipynb),
* [TF-IDF](https://colab.research.google.com/github/pinecone-io/examples/blob/master/semantic_search_intro/tfidf.ipynb),
* [BM25](https://colab.research.google.com/github/pinecone-io/examples/blob/master/semantic_search_intro/bm25.ipynb),
* [SBERT](https://colab.research.google.com/github/pinecone-io/examples/blob/master/semantic_search_intro/sbert.ipynb).
Эта статья — живая иллюстрация развития технологий анализа текста и искусственного интеллекта. Если вы не хотите оставаться в стороне от области ИИ, то вы можете обратить внимание на наш курс [«Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=060721). Или же прокатайтесь в работе с данными на нашем [курсе о Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=060721).
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=060721), как прокачаться и в других специальностях или освоить их с нуля:
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=060721)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=060721)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=060721)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=060721)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=060721)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=060721)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=060721)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=060721)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=060721)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=060721)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=060721)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=060721)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=060721)
**КУРСЫ**
* [Курс по 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=060721)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=060721)
* [Курс «Математика для Data Science»](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=060721)
* [Курс «Математика и 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=060721)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=060721)
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=060721)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=060721)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=060721) | https://habr.com/ru/post/566414/ | null | ru | null |
# Человеческим языком про метрики 3: перцентили для чайников
Это третья статья из цикла. В [прошлой части](https://habr.com/ru/company/tochka/blog/685636/) мы разбирали типы метрик, и уже там начали встречаться перцентили. Это полезная штука, но для неподготовленного читателя она выглядит просто как математическая дичь. Эта статья поможет разобраться в перцентилях по-инженерному, не заканчивая профильный факультет. Кстати, в следующей части будет подобное объяснение производных.
Лучше, конечно, объяснять эту тему вживую и с доской, но у нас будет простой `python` – потому что это то же самое, что писать математику вручную, только короче.
Оглавление цикла:
1. [Потерянное введение](https://habr.com/ru/company/tochka/blog/683608/)
2. [Prometheus](https://habr.com/ru/company/tochka/blog/685636/)
3. Перцентили для чайников
4. [PromQL](https://habr.com/ru/company/tochka/blog/693834/)
### Зачем?
Какую задачу решают перцентили, и зачем эти сложности? На самом деле, они нужны для того, чтобы посмотреть на массив данных и описать их одним числом. Например «большинство HTTP запросов обработались в пределах 5 секунд». Это нужно, чтобы было удобно смотреть на графике, как ведет себя приложение «в целом». Иногда запросы залипают или завершаются раньше времени, но нам это не важно, если большинство запросов ведут себя предсказуемо. В общем, это способ **сжать** историю наблюдений до одного числа, при этом по пути **потерять неудобные** для нас данные, чтобы не мешали смотреть на общую картину.
### Данные
Мы рассматриваем перцентили в контексте метрик. Напомню, метрика — это временной ряд, то есть набор значений во времени. Пока забудем про timestamp-ы. Тогда останутся данные вида `[1,2,0,10,50,42,38]`. Вот с такими данными мы и будем работать в этой статье: просто каким-то **массивом чисел**.
### Подготовка
Для начала разберемся с тем, что часто встречается и проще всего для понимания: что такое «среднее арифметическое» и «медиана». Работать будем вот с этими массивами:
```
a = [1, 2, 0, 10, 50, 42, 38]
b = [1, 2, 0, 10, 50, 42, 38, 5]
```
Среднее арифметическое
----------------------
Это сумма всех элементов, деленная на их количество:
```
sum(a)/len(a)
# 20.428571428571427 - среднее арифметическое массива a
sum(b)/len(b)
# 18.5 - среднее арифметическое массива b
```
Медиана
-------
Чтобы не разглядывать весь массив, можно выбрать какой-то один хороший элементМедиана – это «средний элемент», то есть буквально в середине массива (если его упорядочить). Чтобы ее найти:
1. Упорядочим массив
2. Если длина массива нечетная, берем элемент посередине
3. Если длина массива четная, берем два элемента посередине и считаем их среднее арифметическое
Случай с четной длиной — это просто такой математический костыль.
```
sort_a = sorted(a)
# [0, 1, 2, 10, 38, 42, 50]
len(sort_a)
# 7 - длина массива нечетная, элемент посередине - с индексом 3
sort_a[3]
# 10 - медиана массива a
```
Случай с массивом четной длины:
```
sort_b = sorted(b)
# [0, 1, 2, 5, 10, 38, 42, 50]
len(sort_b)
# 8 - длина массива четная, элементы посередине - с индексом 3 и 4
sort_b[3]
# 5
sort_b[4]
# 10
(sort_b[3] + sort_b[4])/2
# 7.5 - медиана массива b
```
Можно сказать, что это **свойства нашего массива**. Если мы поменяем в нем значения, то его свойства изменятся: будет другое среднее арифметическое и другая медиана. А какие еще есть полезные свойства?
```
max(a)
# 50
max(b)
# 50
min(a)
# 0
min(b)
# 0
```
Это нам пригодится чуть ниже.
Перцентили
----------
> Вообще, есть разные слова, которые обозначают похожие вещи: квантиль (quantile), перцентиль или процентиль (percentile), квартиль (quartile). Пока давайте забьем на все кроме **перцентиля**, остальное разберем в конце
>
>
Можно прочитать [определение в википедии](https://ru.wikipedia.org/wiki/%D0%9A%D0%B2%D0%B0%D0%BD%D1%82%D0%B8%D0%BB%D1%8C), но оно очень математически точное и из-за этого абстрактное, поэтому непонятно, зачем оно вообще надо. Давайте дойдем до этой штуки постепенно, от понятных вещей.
### Опять медиана
У медианы есть такая особенность: половина элементов массива **больше** либо равна ей, а другая половина элементов — **меньше** либо равна. Мы же достали ее из **середины сортированного массива**, логично? Остановитесь и подумайте над этим:
```
# a
[0, 1, 2, 10, 38, 42, 50]
'''
^^
10
[ <= ]
[ >= ]
'''
# b
[0, 1, 2, 5, 10, 38, 42, 50]
'''
^
7.5
[ <= ]
[ >= ]
'''
```
Вот возьмем ту часть, которая меньше либо равна. Можно поиграться терминами и перефразировать так:
> 50% элементов массива <= какого-то числа
>
>
Так исторически сложилось, что это «какое-то число» часто используется и имеет свое название, **медиана**. Еще часто используется вот такое значение:
> Все элементы массива <= какого-то числа
> *или другими словами*
> 100% элементов массива <= какого-то числа
>
>
Это, внезапно, **максимальный элемент**, то есть `max()`: все элементы массива меньше либо равны ему. Ну и наконец, часто встречается вот это:
> Ни один элемент массива не < какого-то числа
> *или другими словами*
> 0% элементов массива < какого-то числа
>
>
Тут опять втыкается математический костыль, потому что в данном случае оказалось удобно заменить `<=` на `<`, чтобы в качестве «какого-то числа» взять **минимальный элемент**, то есть `min()`. Не заморачивайтесь, почему и зачем, мы тут не за этим...
**Поздравляю, теперь вы знаете три перцентиля: 0-й, 50-й и 100-й.**
### Обобщаем
Заметное свойство массива можно выбирать под свою задачуА что если пошатать определение медианы и взять какой-то произвольный процент? Ну или как-то обобщить min, max и медиану?
> N-й перцентиль - это такое число, что N% элементов массива меньше или равны этому числу
> *или чуть короче*
> X - это N-й перцентиль, если N% элементов массива <= X
>
>
Под это определение попадают медиана (N=50), max (N=100) и min (N=0), с небольшой поправкой на равенство в случае с min. Они описывают понятные вещи: средний элемент, максимальный, минимальный. А что описывает, например, **95-й перцентиль**? Подставим его в определение:
> 95-й прецентиль — это такое число, что 95% элементов массива меньше или равны этому числу.
>
>
И что с этим делать? Оказывается, очень удобно использовать эту штуку, чтобы описать **большинство** элементов массива, при чем степень точности регулируется: 80%, 95%, 99%, 99.9%, ... Для чего бывает полезно описывать «большинство из массива»? Чтобы выбросить пики! Например, у вас есть HTTP-сервер, и вы считаете время обработки запросов. Иногда запросы зависают надолго, потому что сеть моргнула, нода перезапускалась, БД приуныла, пришел GC, клиент сам отвалился, ... В принципе это нормально, мы же не регистрируем сбой из-за каждого подвисшего запроса. Вы хотите знать, что **в целом** у вас запросы отрабатывают за какое-то разумное время. Вот в этой фразе **«в целом»** на математическом языке заменяется на **«какой-то перцентиль»**, а **«разумное время»** — это его **значение**. Например:
> 95 перцентиль от времени обработки запросов = 5 секунд
>
>
То есть, **большинство** (95%) запросов мы обработали за 5 секунд или меньше. А остальные 5% обрабатывались дольше. Можно еще посчитать 99-й перцентиль и сравнить с 95-м, тогда станет понятно, что **большинство** запросов укладываются в 5 секунд, а **подавляющее большинство**, скажем, в 6 секунд, что вообще-то тоже неплохо. При этом **максимум** может оказаться каким-нибудь гигантским, скажем, 60 секунд и встречаться крайне редко (оставшийся 1%), поэтому нам он не интересен. А еще до кучи посчитаем медиану (50-й перцентиль), она может оказаться сильно меньше 95-го перцентиля (например 1 секунда). Это поможет понять, что **в среднем** запросы отрабатывают быстро и есть запас по производительности.
> Перцентили позволяют нарезать слоями ваш массив и понять, на какие группы делятся элементы: в среднем они такие-то, в основном такие-то, в подавляющем большинстве такие-то и т.д
>
>
Мы не будем здесь разбирать, как именно считать произвольный перцентиль на произвольном массиве. Важно только заметить одну деталь: медиану мы иногда считаем как среднее арифметическое двух элементов, то есть мы не берем ее как элемент из массива, а высчитываем где-то посередине между элементами. По аналогии, перцентили тоже не обязательно берутся из элементов массива, а могут высчитываться **где-то между ними**, поэтому значение перцентиля может оказаться дробным даже для набора из целых чисел.
Для интересующихся, функция на чистом питоне, которая считает перцентиль из сортированного массива
```
# взято отсюда: https://stackoverflow.com/a/2753343
import math
def percentile(arr, n):
k = (len(arr)-1) * n
f = math.floor(k)
c = math.ceil(k)
if f==c:
return arr[int(k)]
d0 = arr[int(f)] * (c-k)
d1 = arr[int(c)] * (k-f)
return d0+d1
# пример:
# percentile(sort_a, 0.95)
# percentile(sort_b, 0.5)
```
Если все понятно с определением — **отправляемся назад, в будущее!**
### Добавляем время
Историю изменений в массиве тоже можно наблюдать издалекаВспомним, что перцентили, как и медиана — это свойства конкретного массива. Если в массив добавить элемент, свойства массива изменятся, и надо будет все пересчитывать. Если массив меняется со временем, то со временем меняются и его свойства. Поэтому можно их выводить на график и косвенно наблюдать, что происходит с данными.
> Большие массивы чисел сами по себе «в лоб» не понятно как вообще можно визуализировать, поэтому в метриках и используются перцентили
>
>
В самом начале мы считали медиану, min и max на небольших массивах. Если мы начнем записывать время обработки HTTP запросов, и не будем перезапускать приложение месяцами, у нас могут накопиться миллионы значений, которые еще нужно сортировать и обсчитывать, когда мы захотим узнать перцентили. Ну или как-то хитро хранить в сортированном виде и находить место для очередного значения... Короче, это все потенциально разрастается в бесконечность, поэтому так никто не делает.
### Семплирование
Обычно для метрик мы семплируем данные, то есть из всего множества **выбираем** только некоторые элементы, чтобы из них уже считать перцентили и другие свойства. Как из бесконечного ряда даных выбрать конечное количество элементов? Придется чем-то пожертвовать, для этого есть разные алгоритмы. Мы храним, например, до 100 элементов, а когда надо записать новый, мы решаем, какой элемент нужно выкинуть:
* Sliding Window: просто выбрасываем **самый старый** элемент. Очень просто в реализации и понимании
* [Forward Decay](http://dimacs.rutgers.edu/~graham/pubs/papers/fwddecay.pdf): выбрасываем **случайный** элемент, но чем он старее, тем больше **вероятность**, что он будет выброшен. Вероятность может расти как угодно, например, экспоненциально. Идея в том, что старые значения все еще чуть-чуть влияют на свойства массива, поэтому такая выборка немного точнее описывает наш бесконечный ряд данных
### Сжатие
Можно считерить и вообще хранить не сами элементы, а «корзины» или «бакеты». Это просто счетчики того, сколько раз элемент **попал в такой-то диапазон**. На примере будет понятнее: берем время обработки HTTP запросов. Определимся, какое время считать хорошим, какое плохим (пример из прошлой части):
* `<= 0.1` сек - хороший запрос
* `<= 1` - сойдет
* `<= 5` - подозрительно
* `больше 5` - вообще плохо. Для однообразия можно сказать, что это `<= infinity`
Пришел запрос, померяли время X, и добавили `+1` к тем бакетам, у которых подходят условия: `X <= 0.1`, `X <= 1` и т.д.
А дальше в дело вступает магия, которую не обязательно знать, и поэтому мы ее разбирать не будем, но **из бакетов тоже можно посчитать перцентили**. Конечно, если бакетов мало, мы теряем точность, зато экономим ресурсы! Алгоритм можно посмотреть [в этой статье](https://medium.com/@mnylen/bucketing-technique-for-calculating-median-and-k-th-percentile-of-a-large-dataset-33199af2538c) — там нет ничего сложного, тоже инженерно-алгоритмические фокусы, только более громоздкие.
Prometheus
----------
С перцентилями можно столкнуться при использовании `Histogram` и `Summary`. Подробнее о том, как они выглядят, было [в прошлой части](https://habr.com/ru/company/tochka/blog/685636/). Гистограмма — это бакеты, которые вы считаете в своем приложении, а prometheus можно потом попросить посчитать из них перцентили. Причем если **бакеты одинаковые**, а **теги разные** (например, гистограмма с разных реплик или слоев), то можно без проблем их **посчитать вместе**. Summary — это перцентили, которые вы уже посчитали в приложении, а prometheus просто сохраняет их как числа. Обычно считается с помощью семплирования, поэтому точнее, чем бакеты. Ее можно просто в лоб вывести на график, но **нельзя агрегировать**! Причина, упрощенно, в том, что у вас разные выборки, поэтому результат агрегации будет отражать непонятно что. Вот показательный пример:
### Не агрегируйте Summary
Пример, который демонстрирует, что с виду одинаковые Summary с двух реплик нельзя как-то сложить вместе: предположим у вас две реплики `app1` и `app2`, они получают HTTP-запросы и записывают время обработки.
```
app1 = [9]*5 # пять запросов по 9 секунд
app2 = [1]*100 # сто запросов по секунде
percentile(app1, 0.95)
# 9 - 95й перцентиль app1
percentile(app2, 0.95)
# 1 - 95й перцентиль app2
```
Каждая пишет в prometheus метрику типа Summary с 95-м перцентилем и с тегом, чтобы различать с какой реплики сняты данные.
```
http_time{quantile="0.95", instance="app1"} 9
http_time{quantile="0.95", instance="app2"} 1
```
Вы думаете, что неплохо бы нарисовать один **общий** график «95й перцентиль от времени обработки HTTP» и делаете такой запрос к prometheus:
```
avg(http_time{quantile="0.95"}) without (instance)
```
`avg` — потому что нужна же какая-то функция, чтобы сложить вместе два значения, почему бы не взять среднее арфиметическое между ними? Не сумму же. В результате получается `(9+1)/2 = 5`, вроде бы все нормально, да? А теперь давайте по-честному посчитаем 95 перцентиль на **общих** данных от `app1` и `app2`:
```
all = sorted(app1+app2)
percentile(all, 0.95)
# 1
```
Честный 95-й перцентиль равен `1`, а `avg` от двух метрик получился `5`, то есть вы видите что-то на графике, но это совершенно бессмысленное значение. Если вам нужно агрегировать summary, подумайте, для чего вы на них смотрите. Например, в случае со временем обработки HTTP, скорее всего вас интересует, **не превышает ли** 95-й перцентиль какой-то порог. Поэтому можно взять **максимум** из метрик вместо `avg`:
```
max(http_time{quantile="0.95"}) without (instance)
```
Вы будете видеть один график, и если какая-то из реплик работает **в основном** медленно, то это будет видно. Конечно, решение не идеальное. Например, может привести к false-positive алертам: тормозит только одна реплика, а не все приложение, но вам уже звонят посреди ночи.
> Нужно понимать, какие данные вы хотите видеть и для каких целей, и выбирать Histogram, Summary, бакеты, перцентили, способы семплирования и агрегации аккуратно, понимая их ограничения.
>
>
### Рецепты
Можно запомнить несколько простых рецептов, чтобы сделать метрику, отражающую **большинство данных**, и не думать (*ведь так хочется не думать, а просто сделать уже, чтобы работало!*):
* Для начала попробуйте сделать гистограмму.
* Сделайте бакетов пять, вроде «отлично/хорошо/сойдет/плохо/недопустимо».
* Если вообще не представляете, какие нужны бакеты, придется взять Summary.
* Вам скорее всего нужен **95-й перцентиль** (вне зависимости от типа метрики).
* Сравните визуально 95-й перцентиль и медиану. Медиана покажет что-то максимально усредненное, 95-й перцентиль покажет изменения с большей точностью, но спрячет выбросы.
* Если у вас Summary, не агрегируйте ее или делайте очень осторожно, никакого `avg()`!
* У Summary неплохо бы понимать параметры семплирования, читайте доку к вашей библиотеке для метрик.
Вариации на тему
----------------
Короткий словарик похожих терминов, как и обещано:
* **Пер**центиль мы уже знаем. Это число N от 0 до 100, такое, что N% элементов массива меньше него.
* **Про**центиль это другой способ перевести **percentile** на русский язык. То есть синоним слова **пер**центиль.
* Ква**р**тиль это четверти: 25%, 50%, 75%, 100%. То есть бывает первый, второй третий и четвертый квартиль. И еще иногда используют нулевой.
* Ква**н**тиль - это, условно, перцентиль без процентов. Используется в статистике, где бывает удобно указывать абсолютную вероятность, а не в процентах
* Еще можно встретить дециль — это 10%, 20% и т.д.
Есть еще разночтения самого определения, которое, по сути, гнется и шатается под вашу задачу, например:
* Можно определить перцентили через вероятности, как это сделано в матстатистике. Этот способ точнее описывает суть, но гораздо сложнее для понимания, поэтому сойдет и так.
* Можно в определении использовать `< > >=` вместо `<=` и это все можно тоже называть перцентилями, например «95% элементов больше X».
* Можно считать перцентиль так, чтобы он всегда был элементом массива, это нужно в некоторых задачах (как и медиану не считать средним арифметическим, а брать ближайший больший/меньший элемент).
В целом все это создает путаницу, особенно для тех, кто еще не знаком с самим понятием и не переваривает сложные математические определения. Поэтому здесь разобран один вариант, наиболее близкий к тому, как работает `prometheus`, чтобы можно было как-то пользоваться `Histogram`, `Summary` и понимать, что вообще происходит.
Бонус
-----
Для тех, кто осилил, несколько очень приятных картинок, которые помогут запомнить простые выводы. Случайно [найдены в твиттере](https://twitter.com/nalgeon/status/1358783814022156291):
---
В следующий (последней) части, вооружившись всеми знаниями и научившись писать метрики, будем разбираться, как писать запросы к Prometheus, чтобы уже увидеть хоть что-то на графиках. | https://habr.com/ru/post/690814/ | null | ru | null |
# Разработка простой игры в Code::blocks с использованием Direct3D 9
Хочу рассказать о своем первом опыте в геймдеве. Сразу стоит оговориться, что статья будет чисто технической, поскольку моей целью было всего лишь получение навыков разработки графических приложений, использующих Direct3D, без привлечения высокоуровневых средств разработки игр типа Unity. Соответственно, никаких разговоров о внедрении, монетизации и раскрутке игры также не будет. Статья ориентирована на новичков в программировании приложений Direct3D, а также просто на людей, интересующихся ключевыми механизмами работы подобных приложений. Также в конце привожу список литературы по геймдеву, тщательно отобранный мной из более чем ста книг по программированию игр и компьютерной графики.
#### Введение
Итак, в свободное от работы время решил я изучить популярный графический API. Прочитав несколько книг и разобрав кучу примеров и туториалов (в том числе из DirectX SDK), я осознал, что настал тот самый момент, когда стоит попробовать свои силы самостоятельно. Основная проблема была в том, что большинство существующих примеров просто демонстрируют ту или иную возможность API и реализованы процедурно чуть ли не в одном cpp-файле, да еще и с использованием обертки DXUT, и не дают представления о том, какую структуру должно иметь конечное приложение, какие классы нужно спроектировать и как это все должно друг с другом взаимодействовать, чтобы все было красиво, читабельно и эффективно работало. Данный недостаток касается и книг по Direct3D: например, для многих новичков не является очевидным тот факт, что состояния рендера (render states) не всегда нужно обновлять при отрисовке каждого кадра, а также, что большинство тяжеловесных операций (типа заполнения вершинного буфера) следует выполнить всего один раз при инициализации приложения (либо при загрузке игрового уровня).
#### Идея
Первым делом мне необходимо было определиться с самой идеей игры. На ум сразу пришла старая игра из 1992 года под MS-DOS, которая, я думаю, многим знакома. Это логическая игра [Lines](https://ru.wikipedia.org/wiki/Lines) компании Gamos.
Что ж, вызов принят. Вот что мы имеем:
* есть квадратное поле из ячеек;
* в ячейках на поле есть разноцветные шары;
* после перемещения шара появляются новые шары;
* цель игрока в том, чтобы выстраивать одноцветные шары в линии: накопление в одной линии определенного числа одноцветных шаров приводит к их детонации и начислению очков;
* главная задача — продержаться как можно дольше, пока на поле не закончатся свободные ячейки.
Теперь посмотрим с точки зрения приложения Direct3D:
* поле из ячеек сделаем в виде трехмерной платформы с выступами, каждая ячейка будет представлять из себя что-то типа подиума;
* должно быть реализовано три вида анимации шаров:
1. появление шара: сначала появляется маленький шар, который за короткое время вырастает до взрослого размера;
2. перемещение шара: просто происходит последовательное передвижение по ячейкам;
3. прыгающий шар: при выборе шара мышью он должен активизироваться и начать прыгать на месте;
* должна быть реализована система частиц, которая будет использоваться при анимации взрыва;
* должен быть реализован вывод текста: для отображения на экране заработанных очков;
* должно быть реализовано управление виртуальной камерой: вращение и зум.
По сути дела пункты, перечисленные выше, являются жалким подобием документа под названием дизайн-проект. Настоятельно рекомендую перед началом разработки расписать в нем все до мелких подробностей, распечатать и держать перед глазами! Забегая вперед сразу показываю демо-ролик для наглядности реализации пунктов (кстати, видео записано с помощью программы [ezvid](http://www.ezvid.com/), так что не пугайтесь их сплэш-скрина в начале):
#### Начало разработки
До сих пор я не упоминал, какие инструменты использовались. Во-первых, необходим DirectX software development kit (SDK), всегда доступный для свободного скачивания на сайте Microsoft: [DirectX SDK](http://www.microsoft.com/en-us/download/details.aspx?id=6812). Если вы собираетесь использовать версию Direct3D 9, как я, то после установки необходимо через главное меню открыть DirectX Control Panel и на вкладке Direct3D 9 выбрать, какая версия библиотек будет использоваться при сборке — retail либо debug (это влияет на то, будет ли Direct3D сообщать отладчику о результатах своей деятельности):
**Debug или retail**
Почему Direct3D 9-й версии? Потому что это последняя версия, где все еще есть fixed function pipeline, то есть фиксированный графический конвейер, включающий в себя, например, функции расчета освещения, обработки вершин, смешивания и так далее. Начиная с 10-й версии, разработчикам предлагается самостоятельно реализовывать эти функции в шейдерах, что является неоспоримым преимуществом, но, на мой взгляд, сложновато для восприятия при первых опытах с Direct3D.
Почему Code::blocks? Наверное, глупо было использовать кросс-платформенную IDE для разработки приложения, использующего некросс-платформенный API. Просто Code::blocks занимает в несколько раз меньше места, чем Visual Studio, что оказалось очень актуальным для моего дачного ПК.
Старт разработки с Direct3D оказался очень прост. В Code::blocks я создал пустой проект (empty project), затем в build options нужно было сделать две вещи:
1) На вкладке search directories и подвкладке compiler добавить путь к директории include DirectX SDK — например, так:
**Search directories**
2) На вкладке linker добавить две библиотеки — d3d9.lib и d3dx9.lib:
**Linker**
После этого в исходном коде приложения нужно будет включить заголовочные файлы Direct3D:
```
#include "d3d9.h"
#include "d3dx9.h"
```
#### Структура приложения
Здесь я допустил первую ошибку: начал размышлять над тем, какой шаблон проектирования выбрать. Пришел к выводу, что лучше всего подходит MVC (model-view-controller): моделью будет класс игры (game), включающий всю логику — вычисление путей перемещения, появление шаров, разбор взрывных комбинаций; представлением будет класс движка (engine), отвечающий за отрисовку и взаимодействие с Direct3D; контроллером будет собственно обертка (app) — сюда входит цикл обработки сообщений, обработка пользовательского ввода, а также, что самое главное, менеджер состояний и обеспечение взаимодействия объектов game и engine. Вроде бы все просто, и можно начинать писать заголовочные файлы, но не тут-то было! На этом этапе оказалось очень сложно сориентироваться и понять, какие методы должны быть у этих классов. Понятно, что сказалось полное отсутствие опыта, и я решил прибегнуть к совету одной из книг: **«Не пытайтесь с самого начала написать идеальный код, пусть он будет неоптимальным и сумбурным. Понимание приходит со временем, и рефакторингом можно заняться потом.»** В итоге после нескольких итераций рефакторинга **уже работающего макета** определение трех основных классов приняло вид:
**Класс TGame**
```
class TGame {
private:
BOOL gameOver;
TCell *cells;
WORD *path;
WORD pathLen;
LONG score;
void ClearField();
WORD GetSelected();
WORD GetNeighbours(WORD cellId, WORD *pNeighbours);
BOOL CheckPipeDetonate(WORD *pPipeCells);
public:
TGame();
~TGame();
void New();
BOOL CreateBalls(WORD count);
void Select(WORD cellId);
BOOL TryMove(WORD targetCellId);
BOOL DetonateTest();
WORD GetNewBallList(TBallInfo **ppNewList);
WORD GetLastMovePath(WORD **ppMovePath);
WORD GetDetonateList(WORD **ppDetonateList);
LONG GetScore();
BOOL IsGameOver();
};
```
**Класс TEngine**
```
class TEngine {
private:
HWND hWindow;
RECT WinRect;
D3DXVECTOR3 CameraPos;
LPDIRECT3D9 pD3d;
LPDIRECT3DDEVICE9 pDevice;
LPDIRECT3DTEXTURE9 pTex;
LPD3DXFONT pFont;
D3DPRESENT_PARAMETERS settings;
clock_t currentTime;
TGeometry *cellGeometry;
TGeometry *ballGeometry;
TParticleSystem *psystem;
TBall *balls;
TAnimate *jumpAnimation;
TAnimate *moveAnimation;
TAnimate *appearAnimation;
LONG score;
void InitD3d();
void InitGeometry();
void InitAnimation();
void DrawPlatform();
void DrawBalls();
void UpdateView();
public:
TEngine(HWND hWindow);
~TEngine();
void AppearBalls(TBallInfo *ballInfo, WORD count);
void MoveBall(WORD *path, WORD pathLen);
void DetonateBalls(WORD *detonateList, WORD count);
BOOL IsSelected();
BOOL IsMoving();
BOOL IsAppearing();
BOOL IsDetonating();
void OnResetGame();
WORD OnClick(WORD x, WORD y, BOOL *IsCell);
void OnRotateY(INT offset);
void OnRotateX(INT offset);
void OnZoom(INT zoom);
void OnResize();
void OnUpdateScore(LONG score);
void Render();
};
```
**Класс TApplication**
```
class TApplication {
private:
HINSTANCE hInstance;
HWND hWindow;
POINT mouseCoords;
TEngine* engine;
TGame* game;
BOOL moveStarted;
BOOL detonateStarted;
BOOL appearStarted;
void RegWindow();
static LRESULT CALLBACK MsgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
void ProcessGame();
public:
TApplication(HINSTANCE hInstance, INT cmdShow);
~TApplication();
TEngine* GetEngine();
TGame* GetGame();
INT MainLoop();
};
```
Класс TGame имеет всего 3 метода, которые может инициировать сам пользователь — New (новая игра), Select (выбор шара) и TryMove (попытка переместить шар). Остальные вспомогательные и вызываются контроллером в особых случаях. Например, DetonateTest (тест на взрывные комбинации) вызывается после появления новых шаров или после попытки перемещения. GetNewBallList, GetLastMovePath, GetDetonateList вызываются, соответственно, после появления шаров, после перемещения и после взрыва, с одной целью: получить список конкретных шаров и передать его на обработку объекту engine, чтобы он что-то нарисовал. На логике работы TGame не хочется подробно останавливаться, поскольку есть [исходники с комментариями](https://github.com/psylancer/balls). Скажу только, что определение пути перемещения шара реализовано с помощью [алгоритма Дейкстры](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%94%D0%B5%D0%B9%D0%BA%D1%81%D1%82%D1%80%D1%8B) по неориентированному графу с равными весами всех ребер.
Рассмотрим подробнее классы движка и контроллера.
#### TEngine
* В классе определены поля для хранения handle окна и его прямоугольника. Они используются в методе OnResize, который контроллер вызывает при изменении размеров окна, для расчета новой матрицы проекции.
* В поле CameraPos хранятся координаты наблюдателя в мировом пространстве. Вектор направления взгляда хранить не нужно, поскольку по моей задумке камера всегда направлена в начало координат, которое, кстати, совпадает с центром платформы.
* Также имеются указатели на интерфейсы Direct3D: LPDIRECT3D9, который нужен только для создания устройства; LPDIRECT3DDEVICE9 — собственно, само устройство Direct3D, основной интерфейс, с которым приходится работать; LPD3DXFONT и LPDIRECT3DTEXTURE9 для работы с текстом и текстурой.
* Поле currentTime используется для хранения текущего времени в миллисекундах и необходимо для отрисовки плавной анимации. Дело в том, что отрисовка каждого кадра занимает разное количество миллисекунд, поэтому приходится каждый раз замерять эти миллисекунды и использовать в качестве параметра при интерполировании анимации. Такой способ известен под названием **синхронизация временем** и используется повсеместно в современных графических приложениях.
* Указатели на объекты класса TGeometry (cellGeometry и ballGeometry) хранят геометрию одной ячейки и одного шара. Сам по себе объект TGeometry, как понятно из названия, предназначен для работы с геометрией и содержит вершинные и индексные буферы, а также описание материала (D3DMATERIAL9). При отрисовке мы можем изменять мировую матрицу и вызывать метод Render объекта TGeometry, что приведет к отрисовке нескольких ячеек или шаров.
* TParticleSystem — это класс системы частиц, имеющий методы для инициализации множества частиц, обновления их позиций в пространстве и, конечно же, рендеринга.
* TBall \*balls — массив шаров с информацией о цвете и статусе [прыгающий, перемещающийся, появляющийся].
* Три объекта типа TAnimate — для обеспечения анимации. Класс имеет метод для инициализации ключевых кадров, которые представляют собой матрицы мирового преобразования, и методы для вычисления текущей позиции анимации и применения преобразования. В процедуре рендеринга объект engine последовательно отрисовывает шары и при необходимости вызывает метод ApplyTransform нужной анимации, чтобы сдеформировать либо переместить шар.
* InitD3d, InitGeometry, InitAnimation вызываются только из конструктора TEngine и выделены в отдельные методы для наглядности. В InitD3d создается устройство Direct3D и устанавливаются все необходимые render state'ы, включая установку точечного источника освещения со specular-составляющей прямо над центром платформы.
* Три метода AppearBalls, MoveBall и DetonateBalls запускают анимации появления, перемещения и взрыва, соответственно.
* Методы IsSelected, IsMoving, IsAppearing, IsDetonating используются в функции менеджера состояний для отслеживания момента окончания анимации.
* Методы с префиксом On вызываются контроллером при возникновении соответствующих событий: клика мышью, вращении камеры и т.д.
Рассмотрим основной метод Render:
**TEngine::Render()**
```
void TEngine::Render()
{
//вычисляем, сколько миллисекунд прошло с момента отрисовки предыдущего кадра
clock_t elapsed=clock(), deltaTime=elapsed-currentTime;
currentTime=elapsed;
//обновляем позиции анимаций, если они активны
if(jumpAnimation->IsActive())
{
jumpAnimation->UpdatePosition(deltaTime);
}
if(appearAnimation->IsActive())
{
appearAnimation->UpdatePosition(deltaTime);
}
if(moveAnimation->IsActive())
{
moveAnimation->UpdatePosition(deltaTime);
}
pDevice->Clear(0,NULL,D3DCLEAR_STENCIL|D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,D3DCOLOR_XRGB(0,0,0),1.0f,0);
pDevice->BeginScene();
//рисуем платформу
DrawPlatform();
//рисуем шары
DrawBalls();
//если активна система частиц, то обновляем положения частиц и рендерим их с текстурой
if(psystem->IsActive())
{
pDevice->SetTexture(0,pTex);
psystem->Update(deltaTime);
psystem->Render();
pDevice->SetTexture(0,0);
}
//вывод заработанных очков
char buf[255]="Score: ",tmp[255];
itoa(score,tmp,10);
strcat(buf,tmp);
RECT fontRect;
fontRect.left=0;
fontRect.right=GetSystemMetrics(SM_CXSCREEN);
fontRect.top=0;
fontRect.bottom=40;
pFont->DrawText(NULL,_T(buf),-1,&fontRect,DT_CENTER,D3DCOLOR_XRGB(0,255,255));
pDevice->EndScene();
pDevice->Present(NULL,NULL,NULL,NULL);
}
```
В самом начале вычисляется, сколько миллисекунд прошло с предыдущего вызова Render(), затем обновляются прогрессы анимаций, если они активны. Очищаются буферы методом Clear и последовательно рисуются платформа, шары и система частиц, если она активна. Напоследок выводится строка с текущим значением заработанных очков.
#### TApplication
* Класс имеет поле для хранения координат мыши, поскольку нам необходимо будет вычислять значения относительных смещений курсора, чтобы вращать камеру.
* Булевы флаги appearStarted, moveStarted и detonateStarted необходимы для отслеживания статуса соответствующих анимаций.
* В метод RegWindow вынесен код для регистрации класса окна.
* Static-метод MsgProc — так называемая оконная процедура.
* ProcessGame — упрощенная версия менеджера состояний, в котором оценивается текущее состояние игры и в зависимости от него предпринимаются какие-то действия.
* MainLoop — цикл обработки сообщений.
Вот такой легковесный контроллер. Подобный цикл обработки сообщений можно встретить в любой книге по Direct3D:
**TApplication::MainLoop()**
```
INT TApplication::MainLoop()
{
MSG msg;
ZeroMemory(&msg,sizeof(MSG));
while(msg.message!=WM_QUIT)
{
if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
//если нет сообщений, то обрабатываем состояние игры и занимаемся рендерингом
ProcessGame();
engine->Render();
}
}
return (INT)msg.wParam;
}
```
Внимания заслуживает только то, что находится внутри блока else — это так называемая IdleFunction, которая выполняется при отсутствии сообщений.
А вот и функция менеджера состояний:
**TApplication::ProcessGame()**
```
void TApplication::ProcessGame()
{
if(moveStarted)
{
//ждем до окончания анимации перемещения
if(!engine->IsMoving())
{
//перемещение окончено - тестируем на взрыв
moveStarted=FALSE;
if(game->DetonateTest())
{
//инициируем взрыв и увеличиваем очки
WORD *detonateList,
count=game->GetDetonateList(&detonateList);
detonateStarted=TRUE;
engine->DetonateBalls(detonateList,count);
engine->OnUpdateScore(game->GetScore());
}
else
{
//иначе пытаемся добавить шары
if(game->CreateBalls(APPEAR_COUNT))
{
TBallInfo *appearList;
WORD count=game->GetNewBallList(&appearList);
appearStarted=TRUE;
engine->AppearBalls(appearList,count);
}
else
{
//game over!
}
}
}
}
if(appearStarted)
{
//ждем до окончания анимации появления
if(!engine->IsAppearing())
{
appearStarted=FALSE;
//появление окончено - тестируем на взрыв на всякий случай
if(game->DetonateTest())
{
//инициируем взрыв и увеличиваем очки
WORD *detonateList,
count=game->GetDetonateList(&detonateList);
detonateStarted=TRUE;
engine->DetonateBalls(detonateList,count);
engine->OnUpdateScore(game->GetScore());
}
}
}
if(detonateStarted)
{
//ждем до окончания анимации взрыва
if(!engine->IsDetonating())
{
//просто сбрасываем флаг
detonateStarted=FALSE;
}
}
}
```
Что ж, пожалуй, на этом все!
#### Заключение
Здесь самое место, чтобы перечислить недостатки. Разумеется, в коде куча мест для оптимизаций. Кроме того, я не упомянул о таких вещах, как смена параметров видеорежима (разрешение экрана, multisampling) и обработка потери устройства (LostDevice). На счет последнего имеется подробное обсуждение [на сайте gamedev.ru](http://www.gamedev.ru/code/forum/?id=81910).
Надеюсь, мои изыскания принесут кому-то пользу. Кстати, [исходники на github](https://github.com/psylancer/balls).
**Спасибо за внимание!**
#### Обещанная литература
1. Frank D. Luna Введение в программирование трехмерных игр с DirectX 9.0 — для понимания основ;
2. Горнаков С. DirectX9 уроки программирования на С++ — тоже основы, но есть главы по DirectInput, DirectSound и DirectMusic. В примерах программ иногда встречаются ошибки;
3. Фленов М. Е. DirectX и C++ искусство программирования — забавный стиль изложения. В основном, целью книги является создание анимационных роликов с использованием интересных эффектов, в том числе с шейдерами. Судите сами по названию разделов: сердечный приступ, огненный дракон;
4. Баррон Тодд Программирование стратегических игр с DirectX 9 — полностью посвящена темам, связанным со стратегическими играми: блочная графика, ИИ, создание карт и ландшафтов, спрайты, спецэффекты с системами частиц, а также разработка экранных интерфейсов и работа с DirectSound/Music;
5. Bill Fleming 3D Creature WorkShop — книга не по программированию, а по разработке трехмерных моделей персонажей в средах LightWave, 3D Studio Max, Animation Master;
6. Thorn Alan DirectX 9 User interfaces Design and implementation — подробная книга о разработке графических интерфейсов с DirectX. Рассматривается иерархическая модель компонентов экранных форм, подобная реализованной в Delphi;
7. Adams Jim Advanced Animation with DirectX — рассматриваются типы анимации (скелетная, морфинг и разновидности) и их реализация, а также работа с геометрией и анимацией из X-файлов;
8. Ламот Андре Программирование игр для Windows. Советы профессионала — эта книга уже посерьезнее: рассматриваются вопросы оптимизации, выбора структур данных под различные задачи, многопоточность, физическое моделирование, ИИ. В последней главе описывается создание игры про космический корабль и пришельцев;
9. David H. Eberly 3D Game engine design — хорошая книга для понимания всей теории игростроения: сначала описываются технологии графических API (трансформации, растеризация, затенение, смешивание, мультитекстурирование, туман и т.д.), затем такие темы, как граф сцены, выбор объектов, определение столкновений, анимация персонажей, level of detail, ландшафты;
10. Daniel Sánchez-Crespo Dalmau Core techniques and algorithmes in game programming — подробно рассматриваются алгоритмы и структуры данных, используемые в задачах игростроения, такие как ИИ, скриптинг, рендеринг в закрытых и в открытых пространствах, алгоритмы отсечения, процедурные техники, способы реализации теней, реализация камеры и т.д.;
11. Ламот Андре Programming Role Playing Games with directX 9 — тысячестраничное подробное руководство по разработке RPG. Включает как теоретические главы по программированию с Direct3D, DirectInput, DirectSound, DirectPlay, так и прикладные главы, имеющие непосредственное отношение к игровому движку. | https://habr.com/ru/post/251081/ | null | ru | null |
# Как заставить Vue.js и Electron работать вместе
Введение
--------
На волне популярности (надеюсь, что они популярны) [Vue.js](https://vuejs.org) и [Electron](https://electronjs.org), возникает резонный вопрос, а как заставить их работать вместе. В этом небольшом руководстве я расскажу, как быстро установить и настроить шаблон для разработки приложений на Electron и Vue.js. И так приступим.
Что нам понадобится
-------------------
* [*yarn*](https://yarnpkg.com/en/) — пакетный менеджер, аналог [npm](https://www.npmjs.com). Я выбрал yarn, потому что мне просто нравится этот инструмент, однако вы можете использовать и npm. Как установить yarn [здеся](https://yarnpkg.com/en/docs/install#windows-stable), а npm [тута](https://www.npmjs.com/get-npm);
* [*vue-cli*](https://github.com/vuejs/vue-cli) — консольная утилита, которая позволяет быстро инициализировать проекты на Vue.js, добавив поддержку [webpack](https://webpack.js.org);
* [*electron-vue*](https://github.com/SimulatedGREG/electron-vue) — шаблон, который мы и будем использовать.
Установка
---------
Запустим наш терминал и введём команду, чтобы установить vue-cli:
```
yarn global add vue-cli
```
Аналогично для npm:
```
npm install vue-cli -g
```
Затем создадим проект:
```
vue init simulatedgreg/electron-vue <имя_папки>
```
Вместо `<имя_папки>` пшием название папки, в которую хотим поместить все файлы для работы.
Во время установки нам будут заданы следующие вопросы:
* **? Application name**: имя проекта.
* **? Project description**: описание проекта.
* **? Select which Vue plugins to install**: выбираем плагин, который хотим установить;
* **? Use linting with ESLint**: будете ли вы использовать [ESLint](https://eslint.org) (линтер или дичь, которая будет проверять ваш JS код на соответсвие стайл-гайду).
* **? Setup up unit testing with Karma + Mocha**: установить тесты [Karma](https://karma-runner.github.io/2.0/index.html) и [Mocha](https://mochajs.org).
* **? Setup up end-to-end testing with Spectron + Mocha**: установить [Spectron](https://electronjs.org/spectron) и Mocha для end-to-end тестирования.
* **? What build tool would you like to use**: какой сборщик изволите [electron-builder](https://github.com/electron-userland/electron-builder) или [electron-packager](https://github.com/electron-userland/electron-packager); я советую electron-builder, так как с ним проблем меньше.
* **? author**: ваше имя.
После того, как ответили на вопросы, переходим в нашу директорию и устанавливаем необходимые пакеты:
```
cd <имя_папки>
yarn
```
Для npm:
```
cd <имя_папки>
npm install
```
И, чтобы проверить работоспособность всего установленного, запустим приложение:
```
yarn dev
```
Или:
```
npm run dev
```
И мы должны увидеть следующее:
А что дальше то?
----------------
Дальше разберём основные папки, которые есть в нашей рабочей директории:
* **.electron-vue**: все конфиги для работы webpack;
* **build**: когда вы собирёте ваш проект, то здесь вы найдёте все файлы, которые получились после сборки (установщик, распакованная версия); также здесь есть папка icons, в которой необходимо поместить иконки приложения для разных ОС;
* **dist**: в режиме разработки из этой папки запускается приложение, поэтому её трогать не имеет смысла;
* **src**: весь исходный код вашего приложения:
+ **main**: файлы для работы с [Main process](https://electronjs.org/docs/tutorial/application-architecture) в Electron;
+ **assets**: картинки и пр. медиа;
+ **components**: место хранения всех Vue-компонентов;
+ **router**: файлы для [vue-router](https://router.vuejs.org/en/);
+ **store**: файлы для [vuex](https://vuex.vuejs.org/en/intro.html);
Сборка
------
Чтобы собрать ваше приложение, введите:
```
yarn build
```
Или:
```
npm run build
```
Результат появится в папке build. Настройки для electron-builder находятся в **package.json** в разделе build.
Заключение
----------
Теперь у вас есть отличное рабочее окружение, и если вы хотите узнать больше, то вот официальная документация: [тут](https://simulatedgreg.gitbooks.io/electron-vue/content/en/). | https://habr.com/ru/post/358432/ | null | ru | null |
# Всё вы врёте! О рекламе CRM
«На заборе тоже написано, а за ним дрова лежат», — пожалуй, лучшая поговорка, которой можно описать рекламу в Интернете. Читаешь одно, а потом узнаёшь, что неправильно прочитал, не так понял и в правом верхнем углу были две звёздочки. Это и есть та самая «голимая» реклама, из-за которой процветает адблок. И даже рекламодатели устают от потока рекламы с недомолвками и уловками. «С меня хватит!», — решила наш маркетолог, которая за 11 лет вникла в пиар и маркетинг в ИТ с самого низа процесса. Она собрала всю рекламу CRM на свои куки и сегодня открытый микрофон достаётся ей — вместе с правом рассказать, что есть что в рекламе CRM-систем, как читать все эти объявления и не попасться в расставленные маркетинговые сети. А может, и себе идеи подсмотрите.
[](https://habr.com/ru/company/regionsoft/blog/473394/)
***Disclaimer:** мнение сотрудника может совпадать, а может не совпадать с мнением компании [RegionSoft Developer Studio](https://www.regionsoft.ru/). Названия компаний заблюрены, все объявления реальны.*
Привет, Хабр!
Если бы эти сети были маркетинговые! Они порой просто рассчитаны на то, чтобы заполучить информацию о клиенте (лид), загнав его на лендинг. А дальше можно окучивать, ловить в социальных сетях или просто не перезвонить (как и поступили некоторые герои нашего обзора). Перед тем, как погрузиться в бездну рекламы CRM-систем, давайте определимся, кто эту рекламу даёт и на кого она рассчитана.
Почему вы видите рекламу?
-------------------------
Вы ищете в Google или Яндексе «crm», «купить crm», «что такое crm» и т.д. Поисковик предлагает всем компаниям, у которых есть реклама в Яндекс.Директ или Google Ads (ex-AdWords) поучаствовать в аукционе за право быть вам показанным. В зависимости от размера ставки и CTR объявления вверху и внизу страницы вам выпадает реклама различных CRM (или редко тех, кто умудрился дать другую рекламу по этому слову — безумно дорогая затея) и вы можете по ней кликнуть. Если вы это делаете, вы попадаете в списки ремаркетинга (ретаргетинга) компании-рекламодателя и теперь они будут показывать вам и всем остальным из списка типа ультра персонализированную рекламу на площадках (в контекстно-медийной сети). Если вы не кликаете (и если кликаете тоже), рано радоваться — поисковик вас запомнил и теперь на всех площадках за вами будут бегать разнообразные объявления. Ну то есть ни для кого не секрет, что вы поинтересовались CRM, а значит — игра началась :-)
```
https://*****.com/ru/?utm_source=yandex&utm_medium=cpc&utm_campaign=type1_search%7Ccid_40424975%7CEkshtein&utm_content=gid_3664236016%7Caid_6926784727%7C15614453365%7C&utm_term=crm%20внедрить&source=zen.yadnex.ru®ion=Нижний%20Новгород_47&device=mobile
```
```
https://cloud*****.ru/?utm_source=yandex&utm_medium=cpc&utm_campaign=rsy&utm_content=8072165963&utm_term=битрикс%2024%20купить%20лицензию®ion=47®ion_name=Нижний%20Новгород.mobile.Нижний%20Новгород..none█=none.0&yclid=5954618054675816680
```
Вот эти UTM-метки знают о вас всё и передают ваш идентификатор в рекламную сеть. Кстати, есть пользователи, которые не кликают по баннеру и не режут его адблоком, они смотрят название компании в рекламе или на баннере и вручную переходят на сайт. Такая паранойя напрасна: сайт всё равно вас запомнит, если вы ходите не через анонимный браузер или VPN.
Но и это не всё. Если вы искали CRM и были залогинены с этого же устройства в Facebook или других соц.сетях, ждите рекламу и там. Ну а если поискали «crm» в соц.сетях, чтобы, например, посмотреть, что люди пишут, всё — вы в фокусе.
Кто может размещать рекламу?
----------------------------
Все, у кого есть минимальный сайт или лендинг заявленной тематики (бывают и исключения, когда сайт не нужен вовсе, но это частный случай).
* Компания-вендор — сам разработчик CRM-систем, который проводит внедрения напрямую (например, мы даём рекламу [RegionSoft CRM](https://www.regionsoft.ru/) именно так). Такие объявления при намётанном глазе можно выделить из общей массы — они имеют сдержанный текст и продуманные картинки в КМС, потому что вендор дорожит репутацией и не рискует размещать что-то, что может нарушить правила Яндекса или ФЗ «О рекламе». Хотя есть «креативные» исключения среди молодых вендоров. Реклама ведёт на официальный сайт или лендинг в том же домене.
* Партнёры, дилеры, дистрибьюторы — компании, аффилированные вендорам, которые стараются транслировать их политику (что не всегда получается). Их реклама более «наглая», сайты нередко — просто визитки или одностраничные лендинги.
* Рефералы — компании, для которых CRM не основная деятельность, но если выгорит, почему бы и не получить процент и деньги за обучение и «внедрение» (читай — простейшую настройку). Чаще всего встречаются в социальных сетях, реклама может вести на лендинг, чат, страницу в соц.сети или просто форму отправки данных. Среди рефералов попадаются инфобизнесмены (ладно, мы на Хабре, можно откровенно — инфоцыгане), к ним мы ещё вернёмся.
На кого реклама рассчитана?
---------------------------
Если бы рекламодатели это знали… :-) На самом деле, конечно, все мы мечтаем, чтобы рекламу смотрели непременно лица принимающие решения (ЛПР), которые увидят рекламное объявление, впечатлятся и свяжутся, оставив точное имя (а не Мой Господин), точную почту (а не hrenvam@iditenah.ru) и точный телефон. Рассчитываем мы, конечно, на них, но понимаем, что попадаем и в студентов с курсовиками (нам однажды написал студент, который хотел взять наши тексты с Хабра в диплом, но при этом заменить название на другую популярную CRM), в сотрудников, которым нужно узнать, что такое CRM и что им предстоит (хотя отчасти именно для них мы ведём блог на Хабре) и просто тех, кто хочет уточнить, что такое CRM.
Исходя из такого расчёта реклама должна быть точной, честной, релевантной запросу и вести на сайт, который может продавать. Вот мы и разберём, какая она и что за ней стоит.
Где можно столкнуться с рекламой CRM-систем?
--------------------------------------------
* На поиске — в выдаче поисковых систем.
* На сайтах и сервисах — в поисковых партнёрах поисковых сетей (например, Яндекс.Дзен, Погода, Карты или любой другой сайт, подключённый к поисковикам).
* В мобильных приложениях.
* В социальных сетях (реклама размещается в том числе через собственные рекламные кабинеты площадок).
* Ну и хоть речь идёт не о контенте, будучи на Хабре, не могу не упомянуть ещё два вида рекламы, которая отлично работает — это собственно качественный контент (формула простая: от 80% пользы, не более 20% пиара) и баннеры, которые закупаются непосредственно у площадки и размещаются с жёстким таргетом.
Это общая, краткая информация о рекламе, которая бегает за вами в интернете. А теперь самое время перейти к конкретным примерам и разобрать их, чтобы понять, а не лишнего ли нам обещают? А то раскатаешь губу на бесплатную CRM с обучением и учебником в подарок, а потом — плати давай.
#### А блоги компаний на Хабре — реклама?
Однозначно да, это реклама и PR. Но этот вид продвижения несколько отличается от классических рекламных активностей, это так называемая ситуация win-win. Вы читаете интересные и полезные (не всегда, увы) статьи компании и платите за это просмотром рекламы, а кому нужно — получает важную информацию о продукте. Например, наш блог. Вы гарантированно нигде в русскоязычном сегменте Интернета не найдёте такого количества подробных материалов о CRM — мы фактически выкладываем всё, что знаем сами (исключая кейсы компаний, т.к. там NDA, согласования и нервы). Мы написали 100 статей на Хабре и они все честны, отражают наш опыт, помогают сотням читателей ориентироваться в мире CRM. И нам кажется оправданной реклама внутри таких статей. То же самое можно сказать про примерно 70% блогов компаний на Хабре.
Мы посмотрели рекламу за вас — там чудеса!
------------------------------------------
Рост продаж и прибыли
---------------------
Самая большая ложь в рекламе CRM-систем — это разнообразные заявления о том, что CRM-система что-то сделает за вас, что-то у вас увеличит или что вы сможете что-то увеличить благодаря CRM.
Ни один вендор не может гарантировать вам, что после внедрения их CRM-системы ваши продажи вырастут на 10%, в 2 раза, на порядок и т.д. Конечно, автоматизация продаж чаще всего приводит к оптимизации процессов и, как следствие, к росту продаж, но для каждой компании эти показатели строго индивидуальны и зависят от множества факторов. Поэтому, встретив такую рекламу, можете смело спрашивать гарантии и сроки такого роста. А вот про увеличение прибыли написано хитро — до 30% (ну то есть от 0 до 30%), но что делать, если прибыль во время или сразу после внедрения сократится?
*Увеличим продажи в 2 раза, увеличим прибыль до 30%. Непропорционально, не находите? Маржинальность продаж упадёт что ли?*
*Это объявление стало «нулевым пациентом». Именно после него возник замысел этой статьи. Увеличить продажи в несколько раз с качественным ПО — это же беспредельно ложное обещание. Кстати, я оставила заявку, но мне так никто и не перезвонил.*
*Скромнее, но тоже немало*
*Вот тут прямо: рост на 40% благодаря внедрению. Откуда они эти цифры берут, интересно?*
*Нет, не верю. И убеждаться не собираюсь, потому что рост продаж, изменение их качества, среднего чека и цикла продаж очень индивидуально. Ни в коем случае нельзя брать на себя такие обязательства.*
*Ставки растут, гарантии увеличиваются. Рост прибыли в первый месяц? А если падение за счёт того, что менеджеры будут обучаться и осваиваться в CRM-системе?*
### Итого
Ни один вендор CRM не может гарантировать рост продаж, тем более в точные сроки и на точный процент. Эффективность внедрения CRM и влияние внедрения на бизнес-показатели определяется огромным количеством факторов, индивидуальных для каждой компании. К тому же, увеличение прибыли может произойти вовсе не за счёт роста продаж, а за счёт оптимизации процессов и снижения операционных издержек.
Внедрение за 15 минут, час, день и т.д.
---------------------------------------
У нас есть новый замечательный проект — [облачный хелпдеск ZEDLine Support](https://www.zedline.ru/). Когда мы внедряем его клиентам или пишем статью на Хабре, мы говорим — старт за 5 минут. И мы отвечаем за то, что старт работы этого сервиса займёт ровно 5 минут с поправкой на скорость соединения. Потому что это простое веб-приложение, в котором вы создаёте анкету для заявок и начинаете работу поддержки ваших клиентов в новом удобном интерфейсе. Вот как он выглядит:
*Интерфейс [облачного хелпдеска ZEDLine Support](https://www.zedline.ru/). Кстати, можете зарегистрироваться и посмотреть, как настраивается анкета и легко заводятся тикеты — нам самим очень нравится :-)*
А вот как выглядит интерфейс CRM-системы и карточка клиента в ней. Как вы считаете, возможно ли её внедрение за 15 минут, час или день? Её первый раз просмотреть и протестировать чисто по функциональности — уже часа 3, и то, если вы знаете, что такое CRM и понимаете, как воспринимать её интерфейс. Но это так, немного иронии. На самом деле, проблема в том, что в рекламе под словом «внедрение» подразумевается всё что угодно: регистрация в системе, первичная настройка, «прогон» с хинтами (подсказками) по интерфейсу и т.д.
*Главное окно (рабочий стол) RegionSoft CRM*
*Карточка клиента RegionSoft CRM*
Для обычного человека, который ведёт бизнес и впервые сталкивается с CRM-системой, внедрение — история абстрактная и, скорее всего, выглядит именно как установка системы на ПК или настройка в окне браузера. На самом деле внедрение — сложный, долгосрочный, поэтапный процесс ввода CRM-системы в эксплуатацию. Он включает подготовительный этап (анализ бизнес-процессов, консультации, оптимизацию процессов, формирование и сбор требований), этап собственно установки и обучения, постепенный ввод в эксплуатацию. Чтобы оценить глубину этого процесса, посмотрите на схему, которую мы разработали:
[*Качайте и распечатывайте схему* — в ней подробный план, а точнее полный алгоритм внедрения CRM-системы (загрузка начнётся сразу, без вирусов). Если останутся вопросы, читайте подробности о схеме](http://bit.ly/2CcZDMA).
Освоение CRM — отдельная тема, и оно тоже не может занимать 15 минут. Сперва сотрудник погружается в интерфейс, изучает основные функции, затем вносит данные и учится использовать модули, затем осваивается с настройками и мастерами настроек (например, калькуляторов и бизнес-процессов), строит отчёты, учится пользоваться почтой и телефонией в CRM, взаимодействует с коллегами. В ходе освоения CRM-системы пользователи знакомятся с документацией к ПО, которая у настоящего, опытного вендора занимает не пару хинтов и не три листа. Она представляет собой большой проработанный мануал на несколько сотен страниц — за 15 минут прочитать точно не получится, не то что освоить. Например, мануал по нашей RegionSoft CRM 7.0 занимает 300 листов — [можете скачать и посмотреть](http://bit.ly/2ONW3Nv), он знакомит с CRM максимально подробно.
*Если освоение CRM занимает 15 минут, это не CRM-система, а контакт-менеджер*
Эти ребята едва ли не рекордсмены по обещаниям. «CRM нового поколения» (от нового поколения там только то, что она, видимо, разработана представителями нового поколения) понятна с первого взгляда и не требует обучения — так утверждает лендинг. С одной стороны, эта система не так уж и проста, с другой — какая же это автоматизация хотя бы продаж (не говоря уж об оперативной работе!), если она не требует обучения.
*Собственно, вот она и истина — «базовое внедрение». По сути настройка web-приложения и допуск сотрудников в него. После этого начинается «небазовое», как правило, у большинства вендоров платное. Тоже лукавство, но выглядит честнее перечисленных выше примеров.*
*Точно. Но это не точно :-)*
CRM напишут прямо для вас, под заказ
------------------------------------
На этом месте у меня начал дёргаться правый глаз и одолели воспоминания о том, как один из моих первых руководителей компании среднего бизнеса предлагал не заморачиваться покупкой CRM, а написать свою CRM на коленке. Писать начали — уже нет компании, а система так и не была написана. Потому что это нереально. Реально написать простое решение, которое будет хранить информацию о клиентах и сделках, выводить отчёты и слать напоминания из базового календаря. Это не CRM-система, хотя так и называется. Разработка нормальной, приемлемой для работы и автоматизации CRM занимает несколько лет и стоит несколько миллионов рублей. Зачем вам это, когда есть десятки готовых решений на любой вкус и даже на любой бюджет?
Если вы посмотрите сайты компаний, предлагающих разработку CRM-систем, то увидите, что интерфейсы похожи, схожа и архитектура. Дело в том, что сейчас есть фреймворк Symfony (PHP), на котором эти CRM и пишутся — это самый популярный вариант. Хотя есть решения и на Laravel и даже на Yii. Ну и к тому же есть опенсорсные проекты, которые легко превращают в коммерческие, не форкая, а просто повторяя часть кода.
Проблема в том, что вы получите CRM с приемлемым интерфейсом, вас всё устроит, но по ходу использования вылезет такое количество ошибок, багов, проблем, дыр в безопасности и т.д., что единственное, что вам захочется — бросить CRM и купить готовое решение (протестированное, с поддержкой, отточенными функциями и лучшими практиками на борту).
*Процесс **изготовления** CRM страшно представить. Волнуют вопросы, есть ли обжиг или, к примеру, хонингование? А вдруг там крекинг?*
Иногда под «напишем» имеется ввиду стандартная вендорская CRM, которую партнёр дорабатывает или конфигурирует под ваши требования — но это не значит, что CRM «написана» под вас, она доработана и переделана под вас.
*Это уже совсем фантастика. Если с web-CRM ещё что-то можно сотворить, то разработка под Windows — это сложно, долго, дорого. И бестолково, когда есть хорошие решения с подтверждённым опытом внедрений, историей провалов и успехов и со стабильными версиями.*
*Я два раза не повторяю, не повторяю. Интересно попросить соблюсти сроки хотя бы в полгода.*
Не платят все!
--------------
Сразу оговорюсь, речь идёт о бесплатном тарифе, когда все остальные платны, open source мы сейчас не рассматриваем. Бесплатность — едва ли не самый распространённый маркетинговый инструмент. Расчёт простой: познакомить пользователя с CRM-системой ближе, привязать его и затем уже вывести на платную подписку. Выделю несколько типов бесплатности.
* Бесплатная CRM — по сути демо-версия с ограниченным сроком действия (чаще 14 дней, реже — 30). Вы её изучаете, вносите первые сделки, тестируете, оставляете свои данные. После этого происходит честное общение на предмет покупки.
* Бесплатная CRM старого релиза — пользователю доступна CRM с ограничениями или без, но старого релиза (смотрите номер текущей версии и бесплатной версии). Как правило, поставляется как есть (as is), не поддерживается и годится для предпринимателей-одиночек для базового учёта клиентов и сделок. Легаси есть легаси, ничего хорошего.
* Бесплатная CRM с ограничениями сроков, пользователей, функциональности, дискового пространства и т.д. — вроде как «полноценная» CRM навсегда. Самая заманчивая ловушка: вы начинаете ею активно пользоваться, вносите данные, и через 3-5 месяцев вам начинает чего-то не хватать, и это что-то обнаруживается в платной версии. Данные бросать жалко, менять CRM и выбирать снова уже лень, вы просто переходите на платную подписку.
В принципе, в этом нет ничего плохого — обязательно узнавайте полные ограничения, уточняйте сроки действия бесплатного тарифа. Пользуясь случаем, напомню: бесплатный сыр только в мышеловке.
*Здесь и бесплатная, и взлёт продаж за 15 дней. Стоит ли искать дальше?*
*CRM простая, бесплатная продажи повышающая*
Это вот особый случай. Попробуйте понять, что здесь не так, не заглядывая в подпись под картинкой.
*В итоге не бесплатная. Знаете, почему? Потому что «внедрение за 0», т.е. настройка будет бесплатной и час обучения, про лицензии/подключения никто не говорил. Зато ещё один не очень честный приёмчик «Только 1 день!» Конечно, не один, я неделю эту рекламу ловила (подозреваю, это ретаргетинг.*
*Та же история: 7500 вместо 20 000, а то и за ноль — за **внедрение**. Что в него входит — хз.*
Сто мильонов клиентов
---------------------
Как происходит покупка программного обеспечения? Сперва потенциальный пользователь регистрируется на сайте и получает доступ к бесплатной или демо-версии, тестирует и уже потом принимает решение о покупке. В клиенты конвертируются далеко не все лиды. Но, в принципе, никто не мешает компании называть клиентом каждого, кто оставил данные на сайте. Собственно, поэтому клиентов можно считать по зарегистрированным лидам, можно по первой оплате (при хорошем раскладе примерно в 8-10 раз меньше), можно по постоянным клиентам (как правило, ниже 10%). Но для маркетинга все средства хороши, поэтому на рынке есть компании с миллионами клиентов. В принципе, это показатель уровня компании, но слепо верить цифрам не стоит.
*Здесь всё прекрасно — и идеальный порядок в продажах, и 15 000 клиентов. Диву даёшься: откуда при таких упорядоченных продажах те жуткие отделы продаж компаний, в которые обращаешься...*
*К слову, в одном из рекламных материалов партнёров этой же компании значится цифра не 5 млн., а 2 млн., 2017 год. Неплохо бы синхронизировать рекламные шаблоны.*
Ещё есть версия «за 0 рублей покажем CRM» — чистой воды уловка. Все приличные вендоры проводят онлайн демонстрацию CRM-системы абсолютно бесплатно, в этом нет никакого преимущества.
Прочая магия
------------
Когда создаёшь рекламные объявления для Директа, рано или поздно креатив цинично начинает рваться наружу и хочется писать что-то вроде «RegionSoft CRM — держим рынок 15 лет» или «Гипер CRM для вашего очешуительного бизнеса». Эти объявления плохие: они не несут никакой информационной нагрузки. Однако выделяться как-то нужно — что некоторые компании, работающие с CRM-системами, и делают.
Например, выдают обычные вещи за свои конкурентные преимущества или обыгрывают факты, которых по сути у конкретной CRM и нет.
*Уже почти все и давно говорят, все прайсы открыты без регистрации. Ну а тут всё просто: хочешь за CRM х рублей, назначаешь цену х + 3000, даёшь объявление. Маркетинг организации, 1 курс. А на самом деле, эти ребята как раз те, кто предлагает вам получить прайс за ответ на 3 вопроса, а не перейти по прямой ссылке на сайт — тем самым они получат о вас больше информации. Хитро, и в принципе не особо очевидно для неискушённого пользователя.*
Ну это классика жанра: «не покупайте CRM, пока не посмотрите нашу». Кликбейт чистой воды.
*За этой рекламой нет ERP-системы, мы проверяли, но опять же — никто не мешает таковыми называться. А выглядит и звучит солидно, как два в одном.*
Кстати, о ERP, точнее, о не совсем честном содержимом того, что находится за кликом по объявлению. Бывает, что предлагают отраслевые CRM — а на самом деле, вы получаете демо-доступ к одной и той же CRM-системе, а ваше указание отраслевой принадлежности помогает менеджеру по продажам выбрать наиболее подходящий скрипт для общения с вами. За время тестов попалась одна компания прямо с каноническим подходом: объявление даётся по «CRM для…», на сайте список отраслей, а по сути ты регистрируешься в одном и том же интерфейсе — даже сущности и справочники ради приличия не именованы под отрасль.
*Кстати, конкретно юристы к CRM относятся с прохладцей по ряду причин, включая безопасность. Не говоря уже о том, что у них нет десятков бизнес-задач, там весьма специфические процессы, и они предпочитают сочетать Excel и стеллажи с бумажными архивами.*
*ТОП-3 компаний РФ — тоже большой вопрос (ТОП-3 среди всех — вряд ли, ТОП-3 CRM — нет же, ТОП-3 какого-то класса партнёров вендора — всего скорей).*
Ну и конечно, куда без роботов, нейросетей и искусственного интеллекта! Опять же, дело в определениях этих понятий. Сперва давайте определимся с роботами. Роботы есть в большинстве серьёзных CRM-систем, но не все догадались так их назвать. В большинстве случаев роботы в CRM — это программные триггеры, которые вызывают событие. Например, вы создали сделку, поставили себе задачу на звонок через три дня — за день, за час и за 15 минут до звонка вам поступит напоминание. Это по сути и есть робот, не человек же. Есть более сложные роботы: которые запускают и переводят с этапа на этап бизнес-процессы, звонят, делают бэкапы и синхронизации ночью по расписанию и проч. Никакой научной фантастики — обычный программный код (ну ладно, не обычный — хороший, продуманный программный код).
*Справедливое объявление, роботы на месте, рутиной занимаются. Но всё же робот — это скорее маркетинговое название, пусть оно не производит на вас WOW-эффект и не берёт ~~за душу~~ за кошелёк.*
С нейросетями и искусственным интеллектом дела обстоят сложнее. Действительно, в мире и в России есть несколько CRM-систем, в которых используются эти технологии, и это замечательно с точки зрения разработки и инженерного интереса. И вполне замечательно с точки зрения очень большой компании: на основе анализа закрытых сделок и/или поведенческих паттернов клиентов предсказывается результат отношений с новым клиентом (*Например, вы продаёте канцелярку и расходники для офиса по всей России и давно заметили, что юристы покупают много офисной бумаги — вам для этого не нужен ИИ. Но после 3-4 тыс. закрытых сделок вы замечаете, что юристы (с бумагой), покупающие больше мыла и полотенец на сотрудника, покупают ещё больше конфет и чая. Вы это не увидите, а ИИ просчитает. Это те компании, которые принимают клиентов у себя в офисе, и им можно предложить что-то специфическое — но до этого вы уже дойдёте своим умом, ИИ всего лишь порекомендует новым клиентам с большим объёмом бумаги и моющих средств предложить ещё и конфетки*). Так вот, если у вас небольшой объём закрытых сделок (менее 3-4 тыс. сделок минимум), то вам такая CRM как программный комплекс с искусственным интеллектом бесполезна: ему будет не на чем обучаться, не хватит данных (ну то есть не из чего делать вывод о вероятности наступления события). Не ведитесь на красивые термины!
Нарушение ФЗ «О рекламе»
------------------------
Для начала цитата из ФЗ «О рекламе» (ст. 5):
*3. Недостоверной признается реклама, которая содержит не соответствующие действительности сведения:
1) о преимуществах рекламируемого товара перед находящимися в обороте товарами, которые произведены другими изготовителями или реализуются другими продавцами;*
Сюда относится превосходная степень (лучшая, сильнейшая, самая быстрая и т.д.), применяемая к товару, если нет доказательств приведённого утверждения (Forrester признал Ромашка CRM лучшей по быстродействию); здесь же — всё, что связано с «номер 1». Такие объявления — неуважение к конкурентам и пользователям. На них можно смело жаловаться Яндексу/Google и в ФАС. Впрочем, мы этого делать не будем — разве так поступают с исследовательскими образцами :-)
*Кто сказал, что лучшая? По мнению кого она такая?*
*Номер 1 и это совсем не номер 1, даже из тех, кого мы с вами слышим чаще всего. Кстати, 100% надёжность тоже так себе заявление — даже у супер отказоустойчивых серверов 99.6-99.9%. А здесь внешнее облако с данными, бэкапы, само приложение, пинг…*
Однако некоторые вендоры имеют право заявлять, что они номер один. Например, можно заказать платное исследование (примерно от 1-1,5 млн. руб.) в разрезе узкой отраслевой сферы и там получить №1 по какому-то критерию (указывать детали под звёздочкой на сайте). Вам как пользователю от этого вроде не жарко и не холодно, но, во-первых, вы можете легко доверить №1, во-вторых, стоимость таких исследований ляжет на ваши плечи посредством роста стоимости программного обеспечения.
Мистические совпадения
----------------------
В этом объявлении нет ничего особенного, перечисление функциональности CRM. Всё бы ничего, если бы это не было рекламное объявление… как у RegionSoft CRM, буковка в буковку, но при этом совершенно другой системы. При этом это наше довольно старое объявление, которым я горжусь — очень ёмко удалось высказать мысль о функциональных возможностях.
Вот реклама некой партнёрской компании одной из известных CRM:
А вот скриншот из интерфейса нашего Яндекс.Директа с этим самым текстом:
Сложно предположить, что это совпадение, тем более, что в продвигаемой компанией-партнёром CRM-системе нет ни бизнес-процессов, ни KPI (и это не хорошо и не плохо — просто у них своя философия CRM, у нас — своя философия, в которой есть место сложной системе KPI, бизнес-процессам и другим бизнес-наворотам).
Инфобизнес
----------
Крупные CRM-системы стремятся выстроить свою партнёрскую сеть и поэтому делают вхождение в ряды дистрибьюторов максимально простым, а иногда даже предлагают эксклюзивные условия для коучей, бизнес-тренеров, которые нередко являются инфобизнесменами. Поэтому будьте готовы заплатить деньги тренеру по продажам или тимбилдингу, и за эти же деньги получить рекламу CRM-системы и дальнейшее её навязывание в агрессивной форме.
Есть и другие способы: инфобизнесмены продают книги и методички о CRM, предлагают вам чек-листы в обмен на данные, по которым вам потом будут что делать? Правильно — продавать CRM-систему. Впрочем, часто регламенты, чек-листы и проч. супер важные файлы вам вышлют бесплатно, но опять же — в обмен на ваши телефон и e-mail.
Из того, что я отловила за время исследования, мне прислали: 2 чек-листа, методичку за авторством Капитана Очевидности, требовали по телефону подробности о моей компании в обмен на чеклист и — вишенка на торте — прислали полный мануал к известной российской CRM за 2017 год.
*Нет, друзья, выслать что-то в 2019 году в обмен на данные пользователя — это не дарим, это по сути продаём. И к этому нужно относиться ответственно.*
*Один из шедевров инфобиза, который пришёл ко мне по CRM-запросам, но так и не пролил свет на автоматизацию. С окончанием минут и вечным счётчиком — уже давно неактуальный инструмент, ну а PDF, которых осталось всего 3… На складе закончились что ли? Почему никто из CRM-щиков не догадался использовать формулу «Осталось всего ~~1043~~ 74 лицензии»?! :-)*
И даже не CRM
-------------
Бывает, что вместо CRM попадается что-то другое по своей логике и назначению: мне так попались два хелпдеска, один тренер по продажам, две маркетинговых системы и кучка IP-телефонии всех мастей и видов. Ниже — самый неузнаваемый и безобидный из примеров:
Эту статью я готовила достаточно долго (чтобы собрать рекламу и попасть в списки ремаркетинга, ретаргетинга и т.д.). За это время я узнала причину такого позиционирования — один из хелпдесков решил по некоторым причинам примкнуть к стану простых CRM-систем, о чём и было сообщено в Facebook. Тем не менее, это больше мини-хелпдеск, чем CRM, но поскольку отраслевого стандарта как такового нет, каждый волен называться, как он считает нужным.
*Это вот тоже совсем не CRM, а коннектор для соединения (интеграцией это назвать можно с натяжкой) кучи разных сервисов. В общем, грубо говоря, костыль-коннектор для зоопарка корпоративного ПО.*
К слову, за время теста (около полутора месяцев) за мной носились объявления лидогенераторов, различного ПО а-ля контакт-менеджер, бизнес-тренеров и коучей, курсов продажников и проч. Так что на каждого бедолагу, ищущего CRM, открыт сезон охоты. В каких-то других сферах так же (попробуйте начать выбирать автомобиль или автошколу), в каких-то получше (как правило для специализированных товаров и услуг).
А теперь вот в Инстаграме приходят такие подписчики, как на оповещении ниже.
*Babki идут. Где CRM — там и babki.*
А как у них?
------------
Пять лет назад я продвигала софт, который прикидывался CRM, на международном рынке (это была другая компания, не РегионСофт). И я заметила, что отношение к CRM-системам за рубежом (Западная Европа и США) совершенно другое: это нужный рабочий софт, к которому есть требования и который обязательно должен быть. Никто не обвиняет компании в навязывании, все интересуются возможностями новинок, малый бизнес активен и открыт к общению.
Поэтому объявления скучные, без огонька. То ли дело у нас!
Да и вообще объявления российских компаний в Google оказались гораздо скучнее, чем в Яндексе. У меня есть несколько версий, откуда такая разница у одних и тех же компаний, но я почти уверена, что это составляющие одной большой причины — неохота связываться с Google Ads:
* аудитория Google в России менее интересна
* настройки кампаний гораздо сложнее и дольше
* требования Google к рекламе жестче.
Кстати, если вы ни разу не попадали под отключение рекламы в Google Ads/AdWords, могу поделиться впечатлениями. Вы встаёте утром, входите в аккаунт, там много красного и понятно, что реклама не работает. Вы звоните в поддержку, вас гоняют по специалистам, потом вы пишете письма и получаете довольно прохладные ответы. Если нет персонального менеджера, блокировка может продлиться долго, поэтому секрет прост: доставайте поддержку, снитесь им — и всё будет хорошо. Ребята страшно бюрокартизированные, но адекватные.
Это музыка может играть вечно — пока я писала этот пост, блюрила, группировала и делала выводы, на меня продолжала валиться причудливая и не очень реклама CRM-систем и бизнес-услуг всех мастей и видов. Каждый рекламодатель стремится выделиться, тем самым нередко переступая грани законного, честного и разумного. Каждый покупатель вправе выбирать. Учитесь читать рекламу компаний и вы сможете выбрать достойного партнёра по автоматизации, деловой подход которого читается ещё в объявлении.
---
> ### Наш арсенал для комплексной автоматизации бизнеса:
>
>
>
> [**RegionSoft CRM**](http://regionsoft.ru/) — мощная десктопная CRM-система для малого и среднего бизнеса.
>
>
>
> **NEW!** [**ZEDLine Support**](https://www.zedline.ru/) — облачный хелпдеск с удобным интерфейсом и высокой скоростью работы.
>
>
>
> Пишите, звоните, обращайтесь — автоматизируем до зубов! :-) | https://habr.com/ru/post/473394/ | null | ru | null |
# PrestaShop. О глюке в многоуровневой навигации
Привет Хабр! Я понимаю, что история, о которой я хочу рассказать совсем обычная. У каждого программиста, работающего с Open Source, таких случаев до десяти на дню. Но я все равно решил о ней написать. Кому-то она реально поможет, а кому-то может просто улучшит настроение, что тоже неплохо.
Будет немного реверс-инжиниринга, немного философских размышлений, и конечно счастливый конец. Кому важно только исправление глюка – можете не читать весь этот бред и сразу скопировать хак из конца статьи. В любом случае, добро пожаловать под кат.
Немного про PrestaShop
----------------------
Началось все с того, что начальство поставило задачу сделать Интернет-магазин. Выбор был сделан в пользу PrestaShop 1.6 по следующим причинам:
* Написано на PHP
* Адаптивный дизайн прямо из коробки
* Неплохо выглядит со стандартной темой (в том числе и на мобильных устройствах).
* Хорошо справилась с более 50 000 загруженных товаров
* Из коробки присутствует удобный и хорошо выглядящий блок фильтров (на языке PrestaShop он называется блок многоуровневой навигации)
С последним пунктом через некоторое время и возник вопрос, ставший предметом этой статьи.
В чем проявляется глюк
----------------------
Когда товары были уже загружены и я начал настраивать фильтры выяснилось, что в определенных случаях модуль ведет себя некорректно.
Напротив каждого значения в блоке фильтров показывается число товаров (см. рисунок), которое будет отфильтровано, если Вы отметите эту позицию. Смысл в том, что при выборе разных значений в разных фильтрах все количества хитрым образом пересчитываются, обеспечивая удобную обратную связь и помогая принять решение о дальнейшем отборе товаров.
Здесь и закралось неадекватное поведение. Если Вы отметили одно свойство, то все работает и новые количества появляются. Если вы отметили два и более свойств, то количество напротив позиций остальных фильтров сбрасывается до начальных (как будто ни одна позиция не выбрана).
Здесь нужно отметить, что в PrestaShop есть понятия атрибутов и понятия свойств товара. Атрибуты (attributes) – это характеристики товара, которые участвуют в формировании разных версий одного и того же товара (например размер обуви для одной конкретной модели обуви). Свойства (features) — это характеристики, общие для всех вариантов товара. В формировании вариантов товара они не участвуют, а просто информируют пользователя о потребительских свойствах.
Ошибка проявляется, если вы отмечаете позиции в блоке фильтра по свойствам (features). В других фильтрах (например, по производителю) этот эффект не проявляется.
Первичные предположения
-----------------------
Стало ясно, что:
* Это глюк (так как с одной позицией все работает, то есть логика пересчета в код заложена)
* Этот глюк расположен в модуле многоуровневой навигации (blocklayered)
* Этот глюк скорее всего связан с неправильным построением условия SQL- запроса (объяснить я не могу, это больше на интуитивном уровне).
Поиски в Интернете ничего не дали, поэтому стоял выбор:
* Оставить все как есть, согласившись, что это особенность функционирования магазина.
* Залезть с головой в код и, проявив энтузиазм, найти причину глюка (и исправить).
Я принял второе решение. Энтузиазм убавился, когда я открыл файл blocklayered.php. Он содержал более 3,5 тысяч строк кода из которого 70% — многоэтажные SQL-запросы. Задача стала походить на поиски иголки в стоге сена. Поначалу я испугался, и даже нехорошо подумал о создателях PrestaShop. Но потом прикинул, как бы я стал программировать непростую логику работы подобного модуля и немного поуспокоился. Задача действительно сложная и, скорее всего, сложность кода вызвана объективными причинами. Но все равно, при работе с модулем не оставляла мысль, что можно сделать все это как-то покрасивее.
Инструменты и приемы
--------------------
При решении проблемы будем использовать следующие инструменты:
**WinSCP** — надежный FTP-клиент с множеством функций. Ни разу не подводил даже на больших количествах файлов и объемах. Все функции доступны в том числе и из командной строки, что делает его полезным при написании скриптов.
**UwAmp** — простая в установке и настройке WAMP-сборка. Будем ее использовать для локального запуска исследуемого кода.
**Notepad++** — отличный редактор для реверс-инжиниринга. Работа в разных кодировках и с разными концами строк. Хорошая подсветка синтаксиса. Открытие больших файлов. Поиск строк в том числе и по файлам в каталогах. Работает очень надежно.
**HeidiSQL** — GUI для MySQL. Бесплатный графический инструмент для баз данных. Иногда глючит, но в целом работать очень удобно. Используем его для изучения содержимого базы данных при анализе кода.
Основными приемами будет дамп переменных и поиск по исходному коду имен функций и кусков кода. Так как интересующие нас события происходят в том числе и в ajax-запросах дамп переменных делаем в файл. Для этого там где нужно вставляем следующий код:
```
$f=fopen('headfire.txt','a+');
fwrite($f,$very_important_variable);
fwrite($f, PHP_EOL);
fclose($f);
```
**headfire** в названии файла – мой псевдоним, я его использую, там где надо пометить именно мой код или файл. Вы должны использовать свою кодовую строку. Важно, чтобы ее легко было найти и трудно спутать с другими файлами или строками кода.
Начало анализа
--------------
Примерно половина кода отвечает за BackOffice. Этот код отсеиваем сразу и стараемся туда не заглядывать.
Раскрутку проблемы начинаем с поиска tpl-файла, ответственного за вывод наших фильтров на страницу. Искать долго не пришлось. Tpl-файл лежит в корне модуля и называется **blocklayered.tpl**. Заглянув в него убеждаемся, что в нем есть строчка вывода количества, которое у нас глючит.
```
[{$value.name|escape:html:'UTF-8'}{if $layered\_show\_qties} ({$value.nbr}){/if}]({$value.link})
```
Краем глаза замечаем, что количество выводится по условию $layered\_show\_qties, а само количество имеет аббревиатуру nbr. Может это пригодится, а может нет.
Следующим шагом находим место, где вызывается шаблон **blocklayered.tpl**. Это оказывается функция
```
public function generateFiltersBlock($selected_filters);
```
Для проверки выясняем, что она вызывается два раза – один из хука левой колонки, другой из ajax-запроса. Вроде, похоже на правду. Сама функция небольшая, но в ней есть вызов функции, которая подготавливает данные для шаблона
```
public function getFilterBlock($selected_filters = array())
```
Эта функция занимает более 800 строк. В ней куча SQL-запросов. Скорее всего, здесь сосредоточена вся логика формирования фильтров. Что примечательно, что в модуле она вызывается 5 раз. Кажется, что слишком накладно вычислять столько запросов 5 раз подряд. Но потом замечаешь переменную
```
static $cache = null;
```
и понимаешь, что это старый добрый трюк с кэшированием в статической переменной. И еще понимаешь, что писали код отъявленные PHP-шники, которые не остановятся ни перед чем.
AND, OR и святая вода
---------------------
Нужно как-то изучить работу функции. Глюк происходит в момент, когда в фильтре зажигается вторая галочка. А это сопровождается Ajax-запросом. Поэтому используем дамп переменной в файл.
С помощью крепкого кофе и танцев с бубнами вокруг газовой плиты находим место, где посылается основной запрос для каждого блока фильтра и вставляем туда отладочный код, выводящий этот запрос в файл (переменная **$sql\_query**):
```
// headfire debug begin
$f=fopen('headfire.txt','a+');
fwrite($f,print_r($sql_query,true));
fwrite($f, PHP_EOL);
fclose($f);
// headfire debug end
$products = false;
if (!empty($sql_query['from']))
{
$products = Db::getInstance()->executeS($sql_query['select']."\n".$sql_query['from']."\n".$sql_query['join']."\n".$sql_query['where']."\n".$sql_query['group']);
}
```
Обратите внимание -**$sql\_query** – массив. Это видно из кода, поэтому выводим в дамп с помощью **print\_r** с флагом **true**.
Сразу первый же вывод в файл кричит нам о проблеме:
```
Array
(
[select] => SELECT p.`id_product`, sa.`quantity`, sa.`out_of_stock`
[from] =>
FROM ps_cat_restriction p
[join] => LEFT JOIN `ps_stock_available` sa
ON (sa.id_product = p.id_product AND sa.id_product_attribute=0 AND sa.id_shop = 1 AND sa.id_shop_group = 0 ) LEFT JOIN `ps_manufacturer` m ON (m.id_manufacturer = p.id_manufacturer)
INNER JOIN `ps_layered_price_index` psi ON (psi.id_product = p.id_product AND psi.id_currency = 1
AND psi.price_min <= 3631136 AND psi.price_max >= 4618 AND psi.id_shop=1)
[where] => WHERE 1 AND EXISTS (SELECT * FROM ps_feature_product fp WHERE fp.id_product = p.id_product AND fp.`id_feature_value` = 26634 OR fp.`id_feature_value` = 22096)
[group] =>
[second_query] =>
)
```
Обратите внимание на условие **[where]**: там написано в одну строчку AND и OR, причем OR находится между однородных условий и не выделено скобками.
```
fp.id_product = p.id_product AND fp.`id_feature_value` = 26634 OR fp.`id_feature_value` = 22096
```
Я убежден, что всякий здравомыслящий программист, заметив, что в каком-то условии комбинируются AND и OR и при этом не расставлены скобки, сразу должен бежать за святой водой и окраплять ей монитор, винчестер, и клавиатуру, чтобы эта зараза не распространилась вокруг.
Если серьезно, то даже при беглом взгляде на условие и исходя из характера проблемы становится ясно, что ошибка именно здесь – OR забыли заключить в скобки. Осталось только найти это место и исправить. Но здесь нас тоже подстерегает маленький сюрприз.
Сюрприз на последок: динамическая диспетчеризация
-------------------------------------------------
Пытаемся найти место, где формируется ошибочное условие. Используем для этого отрывки из трассировочного вывода. Поиск по **'fp.`id\_feature\_value`** наводит нас на функцию:
```
private static function getId_featureFilterSubQuery($filter_value, $ignore_join = false)
```
Это то, что нужно. Видим код, который формирует условие без скобок и заменяем его на правильный. Попутно хочу заметить на то, как вставляются OR – они вставляются всегда, а последний OR откусывается (причем варварским методом).
```
foreach ($filter_value as $filter_val)
$query_filters .= 'fp.`id_feature_value` = '.(int)$filter_val.' OR ';
$query_filters = rtrim($query_filters, 'OR ').') ';
```
Считаю это некрасивым. Поэтому переписываю этот кусок кода в своем стиле. Внизу приводится исходный и исправленный код функции.
```
//modules/blocklayered/block blocklayered.php
private static function getId_featureFilterSubQuery($filter_value, $ignore_join = false)
{
if (empty($filter_value))
return array();
$query_filters = ' AND EXISTS (SELECT * FROM '._DB_PREFIX_.'feature_product fp WHERE fp.id_product = p.id_product AND ';
foreach ($filter_value as $filter_val)
$query_filters .= 'fp.`id_feature_value` = '.(int)$filter_val.' OR ';
$query_filters = rtrim($query_filters, 'OR ').') ';
return array('where' => $query_filters);
}
```
```
//modules/blocklayered/block blocklayered.php
private static function getId_featureFilterSubQuery($filter_value, $ignore_join = false)
{
if (empty($filter_value))
return array();
//headfire hack begin
$query_filters = ' AND EXISTS (SELECT * FROM '._DB_PREFIX_.'feature_product fp WHERE fp.id_product = p.id_product AND ';
$query_filters1 = '';
foreach ($filter_value as $filter_val) {
if ($query_filters1) $query_filters1 .= ' OR ';
$query_filters1 .= 'fp.`id_feature_value` = '.(int)$filter_val;
}
$query_filters .= '( '.$query_filters1.' )'.')';
// headfire hack end
return array('where' => $query_filters);
}
```
А сюрприз заключается в том, что в модуле эта функция напрямую нигде не вызывается. Корявое имя наводит на грустные мысли о том, что оно где-то формируется программно и вызывается динамически. Так оно и есть, причем в остальных подобных местах сделаны честные **case**. А здесь решили поиграть с динамической диспетчеризацией.
Конец истории
-------------
Глюк исправлен. Фильтры стали работать красиво. Возможно эта ошибка уже решена в новых релизах PrestaShop. Ну а если нет и у Вас вскрылась похожая проблема – я рад если смог Вам помочь. И еще – не скупитесь на скобки, даже если порядок действий очевиден. | https://habr.com/ru/post/321398/ | null | ru | null |
# Сохраните в закладках эту статью, если вы новичок в Python (особенно если изучаете Python сами)
Привет, Хабр! Представляю вашему вниманию перевод статьи "Bookmark this if you are new to Python (especially if you self-learn Python)" в двух частях ([1](https://towardsdatascience.com/bookmark-this-if-you-are-new-to-python-especially-if-you-self-learn-python-54c6e7b5dad8), [2](https://towardsdatascience.com/bookmark-this-if-you-are-new-to-python-especially-if-you-self-learn-python-part-2-ab3ba54e2f45)) c простыми, но полезными советами и трюками в Python.
Если из-за скучной карантинной жизни вы решили погрузиться в Python, поздравляю. Вы столкнулись с самым [быстрорастущим](https://insights.stackoverflow.com/survey/2019) языком программирования. Я уверен, что вы уже знаете некоторые преимущества Python, такие как его простота, легкость в освоении и т.д. Это также основные причины, по которым я изучил Python пять лет назад. Я надеюсь, что вы сможете изучать Python более эффективно и наслаждаться этим процессом, и для этого я подготовил список простых, но полезных трюков и советов.
*Уточнение: в настоящее время я использую **Python 3.8**. Если вы столкнулись с какими-либо проблемами во время запуска моих примеров, пожалуйста, проверьте, не связано ли это с вашей версией Python.*
Содержание
==========
* [Сравнение значений](#sravnenie-znacheniy)
* [Условный оператор возврата](#uslovnyy-operator-vozvrata)
* [Назначение нескольких переменных из списка/кортежа в одну строку](#naznachenie-neskolkih-peremennyh-iz-spiskakortezha-v-odnu-stroku)
* [Генерация списков](#generaciya-spiskov)
* [Используйте zip для сравнения элементов в двух списках](#ispolzuyte-zip-dlya-sravneniya-elementov-v-dvuh-spiskah)
* [Используйте lambda для сортировки вложенного массива по второму элементу](#ispolzuyte-lambda-dlya-sortirovki-vlozhennogo-massiva-po-vtoromu-elementu)
* [filter, map](#filter-map)
* [Проверка, все ли элементы в списке уникальные](#proverka-vse-li-elementy-v-spiske-unikalnye)
* [Форматирование строк](#formatirovanie-strok)
* [enumerate](#enumerate)
* [Получение определенной части массива](#poluchenie-opredelennoy-chasti-massiva)
* [Комбинации и перестановки](#kombinacii-i-perestanovki)
* [Одновременное обновление нескольких переменных](#odnovremennoe-obnovlenie-neskolkih-peremennyh)
* [Получение строки из списка](#poluchenie-stroki-iz-spiska)
* [Underscore (подчеркивание)](#underscore-podcherkivanie)
* [Dict.keys, Dict.values, Dict.items](#dictkeys-dictvalues-dictitems)
* [Сравнение двух множеств](#sravnenie-dvuh-mnozhestv)
* [collections.Counter](#collectionscounter)
* [Заключение](#zaklyuchenie)
Сравнение значений
------------------
```
>>> a = 1
>>> b = 3
>>> a == 1
True
>>> a == 2
False
>>> a == b
False
>>> a > b
False
>>> a <= b
True
>>> if a <= b :
... print('a is less than or equal to b')
...
a is less than or equal to b
```
Вы можете сравнить значения двух объектов. Результатом будет `True` или `False`. Вы можете использовать сравнение непосредственно в качестве условия в операторе `if-else`.
Условный оператор возврата
--------------------------
Вместо
```
>>> def compare(a,b):
... if a> b:
... return a
... else:
... return b
...
```
вы можете поместить условие непосредственно после оператора `return`.
```
>>> def compare(a, b):
... return a if a > b else b
...
```
Назначение нескольких переменных из списка/кортежа в одну строку
----------------------------------------------------------------
Вместо
```
>>> arr_list = [1,4,7]
>>> a = arr_list[0]
>>> b = arr_list[1]
>>> c = arr_list[2]
```
вы можете сделать то же самое, но в одну строку:
```
>>> a, b, c = arr_list
>>> a
1
>>> b
4
>>> c
7
```
Генерация списков
-----------------
Вместо
```
>>> arr_list = [1,4,7]
>>> result = []
>>> for i in arr_list:
... result.append(i*2)
...
>>> result
[2, 8, 14]
```
вы можете сделать так:
```
>>> result = [x*2 for x in arr_list]
>>> result
[2, 8, 14]
```
Используйте zip для сравнения элементов в двух списках
------------------------------------------------------
Вместо
```
>>> a = [1,5,8]
>>> b = [3,4,7]
>>> result = []
>>> for i in range(len(a)):
... result.append(a[i] if a[i] < b[i] else b[i])
...
>>> result
[1, 4, 7]
```
можно так:
```
>>> result = [min(i) for i in zip(a,b)]
>>> result
[1, 4, 7]
```
Используйте lambda для сортировки вложенного массива по второму элементу
------------------------------------------------------------------------
```
>>> arr_list= [[1,4], [3,3], [5,7]]
>>> arr_list.sort(key=lambda x: x[1])
>>> arr_list
[[3, 3], [1, 4], [5, 7]]
```
filter, map
-----------
Вместо
```
>>> arr_list = [-1, 1, 3, 5]
>>> result = []
>>> for i in arr_list:
... if i > 0:
... result.append(i**2)
...
>>> result
[1, 9, 25]
```
делайте так
```
>>> result = list(map(lambda x: x**2, filter(lambda x: x > 0, arr_list)))
>>> result
[1, 9, 25]
```
*Поправка: виноват-виноват, можно еще лучше с помощью генерации списков :)*
Спасибо `Oleg Kapustin` и `Kuldeep Pal`.
```
>>> result = [i**2 for i in arr_list if i > 0]
>>> result
[1, 9, 25]
```
Проверка, все ли элементы в списке уникальные
---------------------------------------------
Используйте функцию `set` для удаления повторяющихся элементов из списка, а затем проверьте, равны ли длина списка и получившегося множества.
```
>>> arr_list = [1,4,4,6,9]
>>> len(arr_list) == len(set(arr_list))
False
```
Форматирование строк
--------------------
```
>>> pi = 3.14159
# До Python3.6
>>> print('The value of pi is {:.2f}'.format(pi))
The value of pi is 3.14
>>> a, b, c = 1,5,9
>>> print('a is {}; b is {}; c is {}'.format(a,b,c))
a is 1; b is 5; c is 9
# С Python3.6+
>>> print(f'The value of pi is {pi:.2f}')
The value of pi is 3.14
>>> pi
3.14159
>>> print(f'a is {a}; b is {b}; c is {c}')
a is 1; b is 5; c is 9
```
Одним из преимуществ форматирования строк является возможность вывода числового значения с округлением без влияния на точность исходного значения.
Дополнительная информация: [PyFormat](https://pyformat.info)
enumerate
---------
Вместо
```
>>> arr_list = [1, 5, 9]
>>> for i in range(len(arr_list)):
... print(f'Index: {i}; Value: {arr_list[i]}')
...
Index: 0; Value: 1
Index: 1; Value: 5
Index: 2; Value: 9
```
можно так:
```
>>> for i, j in enumerate(arr_list):
... print(f'Index: {i}; Value: {j}')
...
Index: 0; Value: 1
Index: 1; Value: 5
Index: 2; Value: 9
```
Получение определенной части массива
------------------------------------
```
>>> arr_list = [1,4,6,8,10,11]
>>> a, *b, c = arr_list
>>> a
1
>>> b
[4, 6, 8, 10]
>>> c
11
```
Комбинации и перестановки
-------------------------
Используйте возможности [itertools](https://docs.python.org/2/library/itertools.html)
```
>>> str_list = ['A', 'C', 'F']
>>> list(itertools.combinations(str_list,2))
[('A', 'C'), ('A', 'F'), ('C', 'F')]
>>> list(itertools.permutations(str_list,2))
[('A', 'C'), ('A', 'F'), ('C', 'A'), ('C', 'F'), ('F', 'A'), ('F', 'C')]
```
Одновременное обновление нескольких переменных
----------------------------------------------
Вместо
```
>>> a = 5
>>> b = 8
>>> temp = a
>>> a = b
>>> b = temp + a
>>> a
8
>>> b
13
```
Вы можете делать вычисление обеих переменных в одной строке. В этом случае не нужно создавать временную переменную.
```
>>> a = 5
>>> b = 8
>>> a,b = b, a+b
>>> a
8
>>> b
13
```
(PS: Что же это? Последовательность Фибоначчи!)
Дополнительная информация: [Evaluation order](https://docs.python.org/3/reference/expressions.html#evaluation-order)
Получение строки из списка
--------------------------
```
>>> str_list = ['This', 'is', 'WYFok']
>>> ' '.join(str_list)
'This is WYFok'
```
Можно объединить все элементы, которые должны быть в строковых форматах, в строку с помощью функции `join`. Только необходимо добавить разделитель между элементами.
```
>>> ans_list = [3,6,9]
>>> 'The answer is '+','.join(map(str,ans_list))
'The answer is 3,6,9'
```
С помощью функции `map` можно преобразовать целочисленные элементы в строки, и в сочетании с функцией `join` вы получите новую строковую переменную.
Дополнительная информация: [str.join](https://docs.python.org/3/library/stdtypes.html#str.join), [map](https://docs.python.org/3/library/functions.html#map)
Underscore (подчеркивание)
--------------------------
Обычно, если требуется повторить шаг, используется цикл `for`, как показано ниже:
```
>>> for i in range(3):
... print('Hello')
...
Hello
Hello
Hello
```
Можно увидеть, что переменная `i` не используется в этом цикле `for`. В этой ситуации вместо `i` можно использовать `_` (подчеркивание). ( `_` – просто имя переменной, и в Python его принято использовать для игнорируемых переменных. Это означает, что переменная цикла фактически не используется.)
```
>>> for _ in range(3):
... print('Hello')
...
Hello
Hello
Hello
```
Dict.keys, Dict.values, Dict.items
----------------------------------
```
>>> teacher_subject = {'Ben':'English','Maria':'Math','Steve':'Science'}
>>> teacher_subject.keys()
dict_keys(['Ben', 'Maria', 'Steve'])
>>> teacher_subject.values()
dict_values(['English', 'Math', 'Science'])
>>> teacher_subject.items()
dict_items([('Ben', 'English'), ('Maria', 'Math'), ('Steve', 'Science')])
```
Для словаря можно использовать функции `keys` и `values` для извлечения ключей и значений соответственно. С помощью функции `items` можно извлекать сразу и ключи, и значения вместе. Это полезно, если вам нужно переключаться между ключами и значениями.
```
>>> subject_teacher = {y:x for x,y in teacher_subject.items()}
>>> subject_teacher
{'English': 'Ben', 'Math': 'Maria', 'Science': 'Steve'}
```
Важно: остерегайтесь дублирующихся значений при переключении, иначе вы получите отсутствующие элементы после.
(Дополнительно: С `zip` вы можете сформировать словарь из двух списков)
```
>>> subject = ['English','Math','Scienc']
>>> teacher = ['Ben','Maria','Steve']
>>> subject_teacher = {f:v for f,v in zip(subject,teacher)}
>>> subject_teacher
{'English': 'Ben', 'Math': 'Maria', 'Scienc': 'Steve'}
```
Дополнительная информация: [Mapping Types — dict](https://docs.python.org/3/library/stdtypes.html?#mapping-types-dict)
Сравнение двух множеств
-----------------------
```
>>> a = {1,2,3}
>>> b = {1,2,3,4,5}
# a подмножество b?
>>> a<=b
True
# b подмножество a?
>>> a>=b
False
# Объединение a и b
>>> a.union(b)
{1, 2, 3, 4, 5}
# Пересечение a и b
>>> a.intersection(b)
{1, 2, 3}
# Разница
# Вернет элементы из a, но не из b
>>> a.difference(b)
set()
# Вернет элементы из b, но не из a
>>> b.difference(a)
{4, 5}
```
Дополнительная информация: [Set](https://docs.python.org/3/library/stdtypes.html#set)
collections.Counter
-------------------
Это удобно, если требуется подсчитать количество всех элементов в списке. Появится объект класса `Counter`, отображающий все уникальные элементы списка с соответствующим количеством этих элементов в списке.
```
>>> import collections
>>> arr_list = [1,1,1,1,2,2,2,3,3,5,5,5,7]
>>> c = collections.Counter(arr_list)
>>> c
Counter({1: 4, 2: 3, 5: 3, 3: 2, 7: 1})
>>> type(c)
>>> c[1]
4
>>> c[6]
0
# Приводим обратно к словарю
>>> dict(c)
{1: 4, 2: 3, 3: 2, 5: 3, 7: 1}
```
Дополнительная информация: [collections.Counter](https://docs.python.org/3/library/collections.html#collections.Counter)
Заключение
==========
Хотя эти приемы довольно просты, они могут помочь сэкономить время и упростить ваш код. Надеюсь, статья помогла вам разобраться, как использовать простые возможности Python. Хорошего обучения и кода. Увидимся в следующий раз. | https://habr.com/ru/post/498074/ | null | ru | null |
# Упаковка в контейнеры (bin packing) при помощи генетического алгоритма
Доброго времени суток, коллеги.
Этой статьей я продолжаю цикл посвященный [EvoJ](http://evoj-frmw.appspot.com/) — Java фреймворку для решения задач генетическим алгоритмом.
В своей [предыдущей заметке](http://habrahabr.ru/blogs/algorithm/138276/) я познакомил читателей Хабра с основными принципами работы с EvoJ.
Сегодня мы рассмотрим, как при помощи EvoJ можно решить задачу упаковки в контейнеры.
#### Постановка задачи
Если в двух словах, то задача упаковки в контейнеры ставится следущим образом: имеется набор контейнеров определенного объема, и набор предметов, которые в эти контейнеры требуется уложить (в простейшем случае пространственной ориентацией пренебрегают). Цель — уложить все предметы, использовав при этом как можно меньше контейнеров.
#### Выбор способа описания решения
Чтобы воспользоваться EvoJ мы должны неким образом описать переменные составляющие решение задачи в виде Java-интерфейса.
Первый вариант, это описать каждый контейнер, как список предметов в него попавших:
```
public interface Solution {
List> getContainers();
}
```
По сути это список контейнеров, каждый из которых описан списком деталей, которые в него попали.
Не смотря на то, что EvoJ позволяет описать решение таким образом, такой подход заставит принимать дополнительные усилия по отсеву противоречивых решений, когда один и тот же предмет попадает в несколько контейнеров.
Более простым подходом будем описать в какой контейнер попал каждый конкретный предмет:
```
public interface Solution {
@ListParams(length = "itemsCount",
elementRange = @Range(strict = "true", min = "0", max = "lastBinIndex"),
elementMutationRange = @MutationRange(value = "100%"))
List getBinIndices();
}
```
Здесь решение представлено, как список, каждый элемент которого указывает в какой контейнер попал соответствующий предмет.
Этот интерфейс так же демонстрирует некоторые приемы EvoJ. Во-первых, длина списка, и максимальное значение его элементов задано не конкретными числами, а именами переменных. Это позволяет не завязываться на конкретные значения в compile-time.
Во-вторых, в данной задаче важным элементом является указание `MutationRange=100%`. Вспомним, что в списке лежат номера контейнеров, и если оставить радиус мутации по умолчанию, то в ходе мутации предмет сможет перемещаться только между близко расположенными контейнерами, что резко снизит эффективность эволюции.
#### Выбор фитнесс-функции
Натуральной фитнесс-функцией будет количество занятых контейнеров, однако такой подход не очень эффективен. Проиллюстрируем почему.
**Решение 1**
**Решение 2**
В обоих решениях занято три контейнера. Но, очевидно, что второе решение предпочтительнее, так как ему остается всего одна мутация до того, чтобы стало занято два контейнера. Конечно, и из первого решения в результате мутации может получиться решение, где заняты всего два контейнера, однако вероятность этого гораздо ниже.
Таким образом, количества занятых контейнеров недостаточно для полноценной оценки «приспособленности» решения. Чтобы исправить ситуацию введем дополнительный показатель — сумму квадратов свободного места в контейнерах (простая сумма свободного места в обоих случаях окажется одинаковой).
Может случиться так, что какие-нибудь из контейнеров окажутся перегруженными. С нашей точки зрения такое решение не валидно и можно было бы избавляться от подобных членов генофонда выставляя им рейтинг `null`. С другой стороны перегруженность может быть небольшой, в то время как решение занимает не так много контейнеров и есть шанс, что в результате мутации или удачного скрещивания перегузка исчезнет.
Введем третий показатель для оценки решения — сумму квадратов перегрузок.
Таким образом, чтобы адекватно оценить решение, требуется три числа. Можно было бы свести их в некий интегральный показатель, однако EvoJ позволяет возвращать из fitness-функции любое `Comparable` значение. Заведем свой класс для этого.
```
public class PackRating implements Comparable {
private int binsUsed;
private int score;
private int overflow;
public PackRating(int binsUsed, int score, int overflow) {
this.binsUsed = binsUsed;
this.score = score;
this.overflow = overflow;
}
public int compareTo(Object o) {
PackRating other = (PackRating) o;
if (this.overflow != other.overflow) {
return other.overflow - this.overflow;
}
if (this.binsUsed != other.binsUsed) {
return other.binsUsed - this.binsUsed;
}
return this.score - other.score;
}
public int getBinsUsed() {
return binsUsed;
}
public int getOverflow() {
return overflow;
}
public int getScore() {
return score;
}
}
```
Здесь поле `binsUsed` — количество занятых контейнеров. Поле `score` — сумма квадратов свободного места в контейнерах. И, наконец, поле overflow — сумма квадратов перегрузок контейнеров.
Процедура сравнения, считает любое решение без перегрузки лучше любого решения с перегрузкой, при равенстве перегрузок начинают приниматься во внимание занятые контейнеры (меньше — лучше), и, наконец, если занято одинаковое число контейнеров, начинает приниматься во внимание поле `score` (больше — лучше).
Осталось имплементировать fitness-функцию. Сделам это, как и в примерах из [предыдущей статьи](http://habrahabr.ru/blogs/algorithm/138276/), расширив класс AbstractSimpleRating.
```
public class BinPackRatingCalculator extends AbstractSimpleRating {
private int[] items;
private int[] bins;
public BinPackRatingCalculator(int[] items, int[] bins) {
this.items = items;
this.bins = bins;
}
@Override
protected Comparable doCalcRating(Solution solution) {
int[] tmpBins = new int[bins.length];
int score = 0;
int overflow = 0;
int binsUsed = 0;
final List indicex = solution.getBinIndices();
for (int item = 0; item < indicex.size(); item++) {
Integer binIndex = indicex.get(item);
tmpBins[binIndex] += items[item];
}
for (int bin = 0; bin < tmpBins.length; bin++) {
int dl = bins[bin] - tmpBins[bin];
final int dl2 = dl \* dl;
if (dl < 0) {
overflow += dl2;
} else {
score += dl2;
}
if (tmpBins[bin] > 0) {
binsUsed++;
}
}
return new PackRating(binsUsed, score, overflow);
}
}
```
Не будем подробно разбирать этот код, он просто вычисляет наши fitness-показатели и возвращает их в виде экземпляра класса `PackRating`.
#### Заставляем все работать
Создадим новый класс с `main`-методом:
```
public static void main(String[] args) {
int[] items = {3, 2, 4, 4, 5, 3, 4, 5, 6};
int[] bins = {8, 8, 8, 8, 8, 4, 12, 12, 8, 6};
Map context = new HashMap();
context.put("itemsCount", Integer.toString(items.length));
context.put("lastBinIndex", Integer.toString(bins.length - 1));
DefaultPoolFactory factory = new DefaultPoolFactory();
GenePool pool = factory.createPool(200, Solution.class, context);
DefaultHandler handler = new DefaultHandler(new BinPackRatingCalculator(items, bins), null, null, null);
handler.iterate(pool, 40);
Solution bestSolution = pool.getBestSolution();
showSolution(bestSolution, bins, items);
}
```
Здесь массив `items` содержит условные размеры предметов. Массив `bins` — условную вместимость имеющихся контейнеров. Особенностью приведенного кода является использование контекста с переменными для указания длины списка из интерфейса `Solution` и ограничения возможных значений. В остальном, код повторяет то, что было показано в [предыдущей статье](http://habrahabr.ru/blogs/algorithm/138276/): создание фабрики популяций, создание популяции из 200 особей, создание хэндлера и осуществление 40 итерации.
Размер популяции и количество итерации подобраны экспериментальным путем.
Приведенный код выполняется довольно быстро, и даже 1000 итераций над популяцией в 200 решений на моем четырехлетнем ноутбуке выполняется около двух секунд.
#### Послесловие
Мы рассмотрели, как можно применить генетический алгоритм к решнию одной из классических NP-сложных задач. Следует сделать замечание, что генетический алгоритм не гарантирует нахождения **самого** лучшего решения, но позволяет очень неплохо к нему приблизиться, что в большинстве случаев является достаточным.
Для заинтересовавшихся [здесь](http://evoj.sourceforge.net/static/demos/binpackingdemo.zip) выложены исходники рассмотренного примера в виде Maven-проекта.
Спасибо за внимание. | https://habr.com/ru/post/139646/ | null | ru | null |
# Разбираемся с Custom Tooling в Argo CD
Спустя некоторое время после написания [первой статьи](https://habr.com/post/481662/), где я ловко управлялся с jsonnet и гитлабом, я понял что пайплайны это конечно хорошо, но излишне сложно и неудобно.
В большинстве случаев требуется типовая задача: "сгенерировать YAML и положить его в Kubernetes". Собственно, с чем Argo CD замечательно и справляется.
Argo CD позволяет подключить Git-репозиторий и синкать его состояние в Kubernetes. По умолчанию есть поддержка нескольких видов приложений: Kustomize, Helm чарты, Ksonnet, голый Jsonnet или просто директории с YAML/JSON манифестами.
Большинству пользователей этого набора будет достаточно, но не всем. Для того чтобы удовлетворить потребности всех и каждого в Argo CD имеется возможность использовать custom tooling.
В первую очередь интересует возможность добавления поддержки [qbec](https://habr.com/ru/post/481662/) и [git-crypt](https://habr.com/ru/post/481662/#git-crypt), которые с полна были рассмотренны в предыдущей статье.
---
Прежде чем приступить к конфигурации, нужно сначала разобраться с тем как именно Argo CD работает.
Для каждого добавленного приложения он имеет две фазы:
* **init** — начальная подготовка перед деплоем, здесь может быть всё что угодно: скачивание зависимостей, распаковка секретов и другое.
* **generate** — выполнение непосредственно команды генерации манифестов, вывод должен быть валидным YAML stream, это именно то, что будет применено в кластер.
Примечательно то, что Argo применяет этот подход для любого типа приложений, в том числе и для Helm. То есть в Argo CD Helm не занимается деплоем релизов в кластер, а используется только для генерации манифестов.
Со своей стороны Argo умеет нативно обрабатывать Helm-хуки, что позволяет не нарушать логики применения релизов.
---
QBEC
====
Qbec позволяет удобно описывать приложения с помощью jsonnet, а кроме того имеет возможность рендерить Helm-чарты, а так как Argo CD умеет нормально обрабатывать Helm-хуки, то использование этой возможности с Argo CD позволяет добиться ещё более корректных результатов.
Для того чтобы добавить поддержку qbec в argocd нужно две вещи:
* в конфиге Argo CD дожен быть определен ваш custom plugin и команды для генерации манифестов.
* нужные бинарники должны быть доступны в образе **argocd-repo-server**.
Первая задача [решается](https://argoproj.github.io/argo-cd/user-guide/config-management-plugins/) довольно просто:
```
# cm.yaml
data:
configManagementPlugins: |
- name: qbec
generate:
command: [sh, -xc]
args: ['qbec show "$ENVIRONMENT" -S --force:k8s-namespace "$ARGOCD_APP_NAMESPACE"']
```
*(команда **init** не используется)*
```
$ kubectl -n argocd patch cm/argocd-cm -p "$(cat cm.yaml)"
```
Для добавления бинарников предлагается [собрать новый образ](https://argoproj.github.io/argo-cd/operator-manual/custom_tools/#byoi-build-your-own-image), или использовать [трюк с init-контейнером](https://argoproj.github.io/argo-cd/operator-manual/custom_tools/#adding-tools-via-volume-mounts):
```
# deploy.yaml
spec:
template:
spec:
# 1. Define an emptyDir volume which will hold the custom binaries
volumes:
- name: custom-tools
emptyDir: {}
# 2. Use an init container to download/copy custom binaries into the emptyDir
initContainers:
- name: download-tools
image: alpine:3.12
command: [sh, -c]
args:
- wget -qO- https://github.com/splunk/qbec/releases/download/v0.12.2/qbec-linux-amd64.tar.gz | tar -xvzf - -C /custom-tools/
volumeMounts:
- mountPath: /custom-tools
name: custom-tools
# 3. Volume mount the custom binary to the bin directory (overriding the existing version)
containers:
- name: argocd-repo-server
volumeMounts:
- mountPath: /usr/local/bin/qbec
name: custom-tools
subPath: qbec
- mountPath: /usr/local/bin/jsonnet-qbec
name: custom-tools
subPath: jsonnet-qbec
```
```
$ kubectl -n argocd patch deploy/argocd-repo-server -p "$(cat deploy.yaml)"
```
Теперь посмотрим как будет выглядеть манифест нашего приложения:
```
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
name: qbec-app
namespace: argocd
spec:
destination:
namespace: default
server: https://kubernetes.default.svc
project: default
source:
path: examples/test-app
targetRevision: fix-example
plugin:
env:
- name: ENVIRONMENT
value: dev
name: qbec
repoURL: https://github.com/kvaps/qbec
syncPolicy:
automated:
prune: true
```
В переменной **ENVIRONMENT** мы передаём имя окружения для которого нужно выполнять генерацию манифестов.
применим и посмотрим что у нас получилось:
приложение задеплоилось, отлично!
---
git-crypt
=========
Git-crypt позволяет настроить прозрачное шифрование репозитория. Это простой и безопасный способ хранить конфиденциальные данные прямо в git.
С имплементацией git-crypt оказалось сложнее.
Теоретически мы могли бы выполнять **`git-crypt unlock`** на init-стадии нашего custom-плагина, но это не очень удобно, так как не позволило бы использовать нативные методы деплоя. Например в случае Helm и Jsonnet, мы теряем гибкий GUI-интерфейс который позволяет упростить настройку приложения (values-файлы и прочее).
Именно по этому хотелось выполнять распечатывание репозитория еще на более ранней стадии, при клонировании.
Так как на данный момент Argo CD не предоставляет возможности для описания каких-либо хуков для синхронизации репозитория, пришлось обойти это ограничение хитрым шелл скриптом-обёрткой, который заменяет собой команду git:
```
#!/bin/sh
$(dirname $0)/git.bin "$@"
ec=$?
[ "$1" = fetch ] && [ -d .git-crypt ] || exit $ec
GNUPGHOME=/app/config/gpg/keys git-crypt unlock 2>/dev/null
exit $ec
```
Argo CD выполняет **`git fetch`** каждый раз перед операцией деплоя. Именно на эту команду мы и повесим выполнение **`git-crypt unlock`** для разблокировки репозитория.
для тестов можете использовать [мой docker-образ](https://github.com/kvaps/argocd-git-crypt) в котором уже есть всё необходимое:
```
$ kubectl -n argocd set image deploy/argocd-repo-server argocd-repo-server=docker.io/kvaps/argocd-git-crypt:v1.7.3
```
Теперь нам нужно подумать о том, как Argo будет расшифровывать наши репозитории. А именно сгенерировать gpg-ключ для него:
```
$ kubectl exec -ti deploy/argocd-repo-server -- bash
$ printf "%s\n" \
"%no-protection" \
"Key-Type: default" \
"Subkey-Type: default" \
"Name-Real: YOUR NAME" \
"Name-Email: YOUR EMAIL@example.com" \
"Expire-Date: 0" \
> genkey-batch
$ gpg --batch --gen-key genkey-batch
gpg: WARNING: unsafe ownership on homedir '/home/argocd/.gnupg'
gpg: keybox '/home/argocd/.gnupg/pubring.kbx' created
gpg: /home/argocd/.gnupg/trustdb.gpg: trustdb created
gpg: key 8CB8B24F50B4797D marked as ultimately trusted
gpg: directory '/home/argocd/.gnupg/openpgp-revocs.d' created
gpg: revocation certificate stored as '/home/argocd/.gnupg/openpgp-revocs.d/9A1FF8CAA917CE876E2562FC8CB8B24F50B4797D.rev'
```
Сохраним имя ключа **`8CB8B24F50B4797D`** для дальнейших шагов. Экспортируем сам ключ:
```
$ gpg --list-keys
gpg: WARNING: unsafe ownership on homedir '/home/argocd/.gnupg'
/home/argocd/.gnupg/pubring.kbx
-------------------------------
pub rsa3072 2020-09-04 [SC]
9A1FF8CAA917CE876E2562FC8CB8B24F50B4797D
uid [ultimate] YOUR NAME
sub rsa3072 2020-09-04 [E]
$ gpg --armor --export-secret-keys 8CB8B24F50B4797D
```
И добавим его в виде отдельного секрета:
```
# argocd-gpg-keys-secret.yaml
apiVersion: v1
kind: Secret
metadata:
name: argocd-gpg-keys-secret
namespace: argocd
stringData:
8CB8B24F50B4797D: |-
-----BEGIN PGP PRIVATE KEY BLOCK-----
lQVYBF9Q8KUBDACuS4p0ctXoakPLqE99YLmdixfF/QIvXVIG5uBXClWhWMuo+D0c
ZfeyC5GvH7XPUKz1cLMqL6o/u9oHJVUmrvN/g2Mnm365nTGw1M56AfATS9IBp0HH
O/fbfiH6aMWmPrW8XIA0icoOAdP+bPcBqM4HRo4ssbRS9y/i
=yj11
-----END PGP PRIVATE KEY BLOCK-----
```
```
$ kubectl apply -f argocd-gpg-keys-secret.yaml
```
Единственное что нам осталось, это пробросить его в контейнер **argocd-repo-server**, для этого отредактируем deployment:
```
$ kubectl -n argocd edit deploy/argocd-repo-server
```
И заменим существующий **gpg-keys** volume на **`projected`**, где и укажем наш секрет:
```
spec:
template:
spec:
volumes:
- name: gpg-keys
projected:
sources:
- secret:
name: argocd-gpg-keys-secret
- configMap:
name: argocd-gpg-keys-cm
```
Argo CD автоматически подгружает gpg-ключи из этой директории при старте контейнера, таким образом он загрузит и наш приватный ключ.
проверим:
```
$ kubectl -n argocd exec -ti deploy/argocd-repo-server -- bash
$ GNUPGHOME=/app/config/gpg/keys gpg --list-secret-keys
gpg: WARNING: unsafe ownership on homedir '/app/config/gpg/keys'
/app/config/gpg/keys/pubring.kbx
--------------------------------
sec rsa2048 2020-09-05 [SC] [expires: 2021-03-04]
ED6285A3B1A50B6F1D9C955E5E8B1B16D47FFC28
uid [ultimate] Anon Ymous (ArgoCD key signing key)
sec rsa3072 2020-09-03 [SC]
9A1FF8CAA917CE876E2562FC8CB8B24F50B4797D
uid [ultimate] YOUR NAME
ssb rsa3072 2020-09-03 [E]
```
Отлично, ключ загружен! Теперь нам достаточно добавить Argo CD в наш репозиторий в качестве коллаборатора и он сможет автоматически расшифровывать его на лету.
Импортируем ключ на локальный компьютер:
```
$ GNUPGHOME=/app/config/gpg/keys gpg --armor --export 8CB8B24F50B4797D > 8CB8B24F50B4797D.pem
$ gpg --import 8CB8B24F50B4797D.pem
```
Настроим уровень доверия:
```
$ gpg --edit-key 8CB8B24F50B4797D
trust
5
```
Добавим argo в качестве коллаборатора в наш проект:
```
$ git-crypt add-gpg-user 8CB8B24F50B4797D
```
---
**Ссылки по теме**:
* [GitHub: репозиторий с модифицированным образом](https://github.com/kvaps/argocd-git-crypt)
* [Argo CD: Custom Tooling](https://argoproj.github.io/argo-cd/operator-manual/custom_tools/)
* [Argo CD: Config Management Plugins](https://argoproj.github.io/argo-cd/user-guide/config-management-plugins/)
* [GitHub Gist: генерация gpg ключей без пароля в неинтерактивном режиме](https://gist.github.com/vrillusions/5484422) | https://habr.com/ru/post/517966/ | null | ru | null |
# О параметре компилятора /SAFESEH
Введение
--------
В этой истории я расскажу вам об увлекательном приключении, которое привело меня к решению одной загадки, которую я сам себе загадал. Разгадка являет собой небольшую подробность в механизме загрузчика 32-х разрядных приложений в системе Windows 7 и выше, а процесс разгадки - длинное путешествие воина, который следует по пути сердца.
Если вы попали на эту страницу в поисках ответа на вопрос, то смотрите спойлер ниже, потому что основное содержание может быть интересно тем, кто только пытается разобраться в механизме SEH.
Вся проблема заключалась в том, что я воспользовался неверным описанием структуры dataDirectories, взятым из Википедии. На месте поля boundImport, на самом деле находится поле [loadConfigTable](https://docs.microsoft.com/en-us/windows/win32/debug/pe-format), которое указывает на структуру IMAGE\_LOAD\_CONFIG\_DIRECTORY32. Эта структура содержит поле SEHandlerTable. Если оно равно нулю, то параметр /SAFESEH выключен. Если оно является виртуальным указателем на таблицу безопасных обработчиков, то будут работать только те обработчики, которые указаны в таблице. Таблица представляет из себя список смещений, относительно виртуального адреса секции .text . Количество обработчиков задаётся в поле SEHandlerCount.
С чего всё началось
-------------------
Задумавшись о способе защиты своей программы от копирования, я вспомнил о [статье](http://samag.ru/archive/article/568) Криса Касперского, в которой я узнал о существовании антиотладочных приёмов. Тщетно пытаясь реализовать разобранный Крисом пример в своей программе, я натыкался на стену непонимания со стороны Windows. Проблема заключалась в том, что Windows отказывалась пользоваться моим обработчиком исключений, посчитав его «небезопасным».
Более менее подробно о SEH мне удалось почерпнуть из этой [статьи](//qxov.narod.ru/articles/seh/seh.html). Но, тем не менее, пока я сам не рассмотрел этот механизм c лупой и инструментами, у меня оставались очень смутные представления о его устройстве. Я разматывал цепочки обработчиков, ставил на них точки останова, наблюдал порядок их выполнения, рассматривал возвращаемые значения и т.д.
Ближе к делу
------------
Рассмотрим маленький пример (я пользуюсь компилятором Microsoft Visual C++ )
```
int main()
{
__asm
{
mov eax, DWORD PTR SS : [0]
}
}
```
Ничего особенного, пытаемся положить в регистр eax содержимое по адресу 0.
Компилируем, запускаем под отладчиком OllyDbg.
Получаем грустное сообщение «access violation when reading 0x00000000».
Берем на заметку, что размер инструкции, которая пытается прочитать по адресу 0 - равен 6 байтам. Обратим также внимание на регистр Eip, который указывает на проблемную инструкцию (совпадает с её адресом слева). Сама же инструкция выглядит как последовательность из 6 байт: 36 A1 00 00 00 00.
Теперь я хочу обработать это исключение, не используя ключевых слов \_\_try, \_\_except т.к. мне показалось это интересной и заманчивой идеей.
Напишем же свой собственный обработчик для обработки этого исключения!
Есть информация, что при возникновении исключения в функцию-обработчик система отправляет следующие аргументы:
```
struct _EXCEPTION_RECORD* exceptionRecord,
void* establisherFrame,
struct _CONTEXT* contextRecord,
void* dispatcherContext
```
где exceptionRecord – структура, содержащая код ошибки, адрес исключения, а contextRecord – структура содержащая контекст регистров (включая регистр Eip). Соглашение о вызове функции-обработчика должно быть \_\_cdecl, а возвратить она должна одно из следующих значений:
```
typedef enum _EXCEPTION_DISPOSITION
{
ExceptionContinueExecution,
ExceptionContinueSearch,
ExceptionNestedException,
ExceptionCollidedUnwind
} EXCEPTION_DISPOSITION;
```
Я решил обработать это исключение таким нехитрым образом:
```
EXCEPTION_DISPOSITION __cdecl ExceptionHanler(
struct _EXCEPTION_RECORD* exceptionRecord,
void* establisherFrame,
struct _CONTEXT* contextRecord,
void* dispatcherContext
)
{
contextRecord->Eip += 6;
MessageBoxA(0, "Exteption was handled", "Success!", 0);
return ExceptionContinueExecution;
}
```
Сместив регистр Eip на 6 байт, мы обойдём проблемную инструкцию! И говорим: ExceptionContinueExecution – продолжить выполнение. Соответственно, выполнение продолжится с инструкции по адресу Eip + 6 и исключений больше возникнуть не должно.
Просто поместить код обработчика в программе - этого мало. Необходимо дать понять системе, что нужно вызывать именно его. И ещё я хочу, чтобы он вызвался самым первым, среди прочих. Для этого нам необходимо где-то создать структуру, состоящую из двух полей: Next и Handler. Поле Next будет содержать указатель на такую же структуру, но с предыдущим обработчиком (с тем, который мы потесним). Поле Handler будет содержать указатель на нашу функцию-обработчик. Указатель на текущую такую структуру находится в TIB (thread information block), иначе говоря, по адресу fs:[0]. Создадим её в стеке.
Преобразуем нашу функцию main:
```
int main()
{
__asm
{
push ExceptionHanler //положим в стек адрес функции-обработчика
push fs:[0] //положим в стек указатель на структуру текущего обработчика
//теперь в стеке лежит структура, содержащая 2 поля: указатель на
//следующий обработчик и адрес нашего обработчика
mov fs:[0] , esp //положим указатель на свою структуру, вместо текущего
//обработчика по адресу fs:[0]
mov eax, DWORD PTR SS:[0] //пытаемся прочитать по адресу 0
add esp, 8 //чистим стек, удалив 8 байт (размер структуры)
}
}
```
По незнанию, я компилирую это с настройками по умолчанию - с флагом /SAFESEH и игнорирую непонятные рекомендации компилятора о том, что мне неплохо было бы отключить этот флаг, раз я записываю что-то по адресу fs:[0]. Да что там говорить, я далеко не сразу обратил на это внимание.
Результат – все та же ошибка чтения по адресу 0 и приложение «падает» как ни в чем не бывало!
Хорошо, что все позади. Теперь я знаю об этом флаге. Пробую компилировать с настройкой /SAFESEH:NO.
Компилируем, выполняем наш код, видим наше развесёлое сообщение:
Жмем «ок» программа успешно завершается. Фух.
Переломный момент
-----------------
Но нет, подождите-ка, но что ИМЕННО сделал в тот раз компилятор, чтобы проигнорировать мой обработчик исключения? Что это за фокусы? И как мне быть, если вдруг… ну чисто теоретически, мне вдруг однажды захочется сделать так, чтобы моё приложение имело флаг /SAFESEH, но при этом, чтобы оно заработало, я должен буду встроить в него код mov fs:[0], esp, с указателем на свою функцию-обработчик, вызвать в произвольном месте исключение и обработать его так, как моей душе угодно? Не считаю, что флаг /SAFESEH должен быть помехой для моих фантазий.
Пытаясь получить информацию о работе этого флага, я увидел что-то размытое про «таблицы безопасных обработчиков». Если они есть, то как мне на них посмотреть? Как добавить в них свой обработчик? Каким образом нужно изменить исполняемый файл, чтобы заставить систему при его исполнении выбирать обработчик именно из этой таблицы или наоборот, отключить выбор обработчика? Столько вопросов и так мало ответов…
Не падая духом, в надежде разгадать загадку…
Полистав срабатывающие обработчики, я увидел те, которые пушит компилятор на стадии выполнения crt0 (код до функции main), а также обработчик из библиотеки ntdll.dll. Все эти обработчики исправно срабатывают в порядке своей очереди, если я не помещаю свой обработчик по адресу fs:[0]! Но как система узнает, какая функция безопасный обработчик, а какая нет?
В своем путешествии я провёл серию экспериментов. Например, компилируя с флагом /SAFESEH, ставил точку останова перед проблемной инструкцией, брал первый обработчик, на который указывала первая структура по адресу fs:[0] и менял начало функции прямо в отладчике на JMP ExceptionHandler (мой самописный обработчик). Срабатывает! Срабатывает именно мой обработчик! И к чему тогда эта неведомая таблица безопасных, когда я могу легко подставить вместо любого безопасного прыжок на свой «опасный»? Впрочем, не важно. Это не даёт ответа на мои изначальные вопросы.
Теперь я пробую записать лог от entry point до функции main двух EXE файлов, скомпилированных с флагом /SAFESEH и /SAFESEH:NO, наивно предполагая, что компилятор на этой стадии вызывает некие WinApi функции, с помощью которых можно добавить в систему адреса безопасных обработчиков. Все тщетно. Два лога практически не отличаются, разве что серией дополнительных невнятных инструкций, не имеющих ничего общего с адресами безопасных обработчиков. Но подозрения все равно остались.
Чтобы окончательно исключить crt0 из списка подозреваемых мне необходимо выяснить еще кое-что. Я придумал следующий эксперимент, результат которого даст мне точный ответ на вопрос! Меняю инструкцию точки входа в программу на следующие команды push main, ret. Таким образом, первой командой в стек попадает адрес функции main, а вторая команда ret «возвращает» регистр указатель на выполнение функции main и функция main выполняется сразу, без crt0! (можно было обойтись и простым JMP, но его немного сложнее реализовать на лету в отладчике)
Я снова был удивлён, ведь мой обработчик вновь не вызвался! Несмотря на неудачу, это дало очень важный ответ: тайна кроется внутри EXE, скомпилированного хитрым образом, а не в коде, который выполняет компилятор.
Может быть, они спрятали этот флаг в PE хедере? В каком-нибудь поле LoaderFlags? И тут неудача… У обоих файлов абсолютно идентичные структуры, за исключением разницы в размере секции rdata. Но даже если в секции rdata и лежит несколько дополнительных байт, разве это может быть способом взаимодействия с загрузчиком, кардинально изменяющим работу программы? Я был уверен, что нет…
Ведь в секциях можно размещать что угодно, главное - соблюсти ключевые правила, думаю я. Там ведь полно мусора! Всякие строки, цифры, дни недели, это ведь не монолитная структура какая-то, а блоки данных, на которые указывают указатели. Эти блоки располагаются в произвольном месте, но в диапазоне секции. При сравнении двух файлов, никаких указателей на область rdata я не увидел, кроме известной importTable, debug и неизвестного указателя на boundImport. Кроме того, такой же указатель был и в файле без флага /SAFESEH! Его размер в таблице dataDirectories был очень маленьким и он был заполнен нулями. Это не вызывало моих подозрений, потому что я был уверен, что если бы это каким-то образом включало в себя таблицу обработчиков, то в файле без флага /SAFESEH это поле просто напросто отсутствовало бы, что было бы знаком для загрузчика «у этого EXE таблицы нет».
Победа близка
-------------
Отчаявшись, я беру адрес первого «безопасного» обработчика, который подсовывает в мой EXE компилятор. А точнее - первые два младших байта его адреса и прошелся поиском по всему файлу. То, что я решил взять именно 2 байта, включая те значения, которые не являются виртуальными адресами, является везением. И вот, я выписал все сырые адреса, по которым располагаются эти значения, преобразовал адреса в виртуальные (их было около 3-х) и приступил к задуманному.
Имея несколько адресов в памяти, предположительно намекающих на «законный» обработчик от компилятора, я ставлю точку останова перед командой mov eax, DWORD PTR SS : [0] и жму play. Срабатывает. Я расставляю точки останова на чтение памяти по записанным адресам и снова жму play.
Удивительно! О брекпоинт споткнулась некая безымянная функция в библиотеке ntdll.dll.
Смотрим. Функция пытается считать по адресу 0x1341d20 из диапазона rdata число 0x1be0, а затем сравнить его с числом, находящимся в EBX – 0x1000. Так, а ведь по адресу imageBase + 0x1000 расположился мой подставной обработчик! Он - то сейчас и находится в числе первых обработчиков. А по адресам 0x1be0, 0x2080 и 0x2351 располагаются безопасные обработчики от компилятора. Вот она эта таблица! Она всё это время была в моём файле!
В отладчике я меняю содержимое адреса 0x1341d20 с 0x1be0 на 0x1000 и… мой обработчик стал вдруг безопасным и послушно обработал исключение!
Реализация проверки безопасных обработчиков в открытом виде! Она не находится внутри ядра Windows, как я ожидал. Так что можно даже подкорректировать код в ntdll.dll, чтобы в нужное время он разрешал или запрещал выбранные нами обработчики!
Вернёмся к нашему файлу еще раз внимательно посмотрим, что находится в окрестностях.
Ага, таблица на месте. Кроме того, случайно мне бросился в глаза адрес-указатель на начало таблицы, а также странное совпадение – число 3, равное количеству обработчиков.
Попробую-ка я заполнить нулями этот адрес-указатель.
Успех! Программа, которую я скомпилировал с флагом /SAFESEH теперь выполняется так, как будто бы был установлен флаг флага /SAFESEH:NO!
А сравним с файлом, который был скомпилирован без этого флага?
Чёрт… ни адреса-указателя на таблицу в этом месте, ни таблицы обработчиков… И как я сразу не додумался сравнить два файла скомпилированных с разными флагами в Total Commander?!
Тем не менее, что указывает на это место в PE хедере? Самым близким является boundImport. И вот только теперь я открываю сайт Microsoft с описанием PE формата.
В общем… я предлагаю вам самим ознакомиться с тем, что парни из Microsoft пишут там про boundImport. Что-то о таблице каталога отложенной загрузки на этапе связывания пост-обработки? Что?
В этом большом и непонятном документе, в котором описаны разные различия этого формата для разных платформ и т.д. Но меня уже не остановить, я начинаю упорно вводить в поиске слово except… прыгаю по результатам поиска.. Вот, .sxdata - содержит индекс символа каждого из обработчиков. Какая . sxdata? У меня такого нет. Есть только виртуальный указатель в поле boundImport, относительно которого неподалёку размещается адрес-указатель и таблица с адресами функций-обработчиков.
Ищу дальше... Вот, ещё говорят, что в разделе pdata содержится массив обработчиков и что таблица может быть в нескольких форматах. Даже если и так, как загрузчик попадает на начало этой таблицы? В том месте, куда указывает boundImport, нет ничего похожего на тот формат, который представлен.
Смотрю дальше... The Load Configuration Structure. Судя по описанию очень похоже! Они говорят, что структура IMAGE\_LOAD\_CONFIG\_DIRECTORY где-то присутствует и описывают ее предназначение, связанное с SEH.
Думаю, а попробую-ка. Взял, да и написал, что по адресу boundImport находится структура IMAGE\_LOAD\_CONFIG\_DIRECTORY32 и рассмотрел её поля. Все сошлось как пазл! Это опять же было большим везением, что я решился на это.
Вот и всё, весь секрет заключался в том, что boundImport в PE хедере (разложенном по таблице из Википедии) указывает на структуру IMAGE\_LOAD\_CONFIG\_DIRECTORY32. Эта структура содержит поля, которые кардинальным образом меняют работу программы! Теперь мы с уверенностью можем сами создать свою таблицу обработчиков и добавить в неё только то, что посчитаем нужным!
Может быть, где-то в недрах документации есть информация о том, что boundImport уже называется не так на моей платформе? Или информация о том, что его назначение изменилось? Может быть, boundImport оказался исключен или сдвинут? | https://habr.com/ru/post/563106/ | null | ru | null |
# Помочь компилятору в векторизации? — Лучше просто не мешать
Это — вольный перевод моего недавнего [поста](http://software.intel.com/en-us/blogs/2011/10/12/mr-compiler-may-i-help-you-with-the-loop-vectorization-not-a-disservice-please/) на английской версии Intel Software Network. Так что те, ~~кому Victoria Zhislina нравится больше vikky13~~, кто уже видел этот пост, могут сразу прочесть первый и последний абзацы, отсутствующие в оригинале.
*— Всем здрасьте, мне нужен транслятор с русского языка в код программы на C++. Ну то есть, я пишу задачу, а транслятор реализует ее решение на языке С++. Где можно такой найти? Если для Cи нету, может быть, есть для других языков?
— Есть, называется начальник отдела разработки. Пишешь задачу на русском — отдаешь подчиненным и все, код готов! Хоть на Си, хоть на Дельфи, хоть на Яве. Я проверял, работает!*
Говорят, что это не анекдот, а реальный вопрос на программистском форуме. Также говорят, что человек гораздо умнее машины, а значит, может ей помочь — поделиться умом. Но есть немало случаев, когда делать этого точно не стоит. Результат будет обратный ожидаемому.
Вот наглядный пример из известной open source библиотеки [OpenCV](http://opencv.willowgarage.com/wiki/):
```
cvtScale_( const Mat& srcmat, Mat& dstmat, double _scale, double _shift )
{
Op op;
typedef typename Op::type1 WT;
typedef typename Op::rtype DT;
Size size = getContinuousSize( srcmat, dstmat, srcmat.channels() );
WT scale = saturate_cast<WT>(_scale), shift = saturate_cast<WT>(_shift);
for( int y = 0; y < size.height; y++ )
{
const T* src = (const T*)(srcmat.data + srcmat.step*y);
DT* dst = (DT*)(dstmat.data + dstmat.step*y);
int x = 0;
for(; x <= size.width - 4; x += 4 )
{
DT t0, t1;
t0 = op(src[x]*scale + shift);
t1 = op(src[x+1]*scale + shift);
dst[x] = t0; dst[x+1] = t1;
t0 = op(src[x+2]*scale + shift);
t1 = op(src[x+3]*scale + shift);
dst[x+2] = t0; dst[x+3] = t1;
}
for( ; x < size.width; x++ )
dst[x] = op(src[x]*scale + shift);
}
}
```
Это — простая функция-шаблон, работающая с char, short, float и double.
Ее авторы решили помочь компилятору с SSE-векторизацией, развернув внутренний цикл по 4 и обрабатывая оставшийся хвост данных отдельно.
Думаете, современные компиляторы (под Windows) сгенеруют оптимизированный код в соответствии с замыслом авторов?
Давайте проверим, скомпилировав этот код с помощью Intel Compiler 12.0, с ключом /QxSSE2 (проверено, что использование других SSEx и AVX опций даст такой же результат)
А результат будет довольно неожиданный. Ассемблерный листинг на выходе компилятора неопровержимо показывает, что развернутый цикл НЕ векторизуется. Компилятор генерирует SSE инструкции, но только скалярные, а не векторные. Зато остаток данных — «хвост», содержащий всего 1-3 элемента данных в неразвернутом цикле, векторизуется по полной программе!
Если мы уберем разворачивание цикла:
```
for( int y = 0; y < size.height; y++ )
{
const T* src = (const T*)(srcmat.data + srcmat.step*y);
DT* dst = (DT*)(dstmat.data + dstmat.step*y);
int x = 0;
for( ; x < size.width; x++ )
dst[x] = op(src[x]*scale + shift);
}
```
… и снова посмотрим на ассемблер (вас я пугать им не буду), то обнаружим, что теперь цикл полностью векторизован для всех типов данных, что несомненно увеличивает производительность.
**Вывод**: **Больше работы — меньше производительность. Меньше работы — больше. Вот бы всегда так.**
Заметим, что Microsoft Compiler, Visual Studio 2010 и 2008 с ключом /arch:SSE2 НЕ векторизует вышеприведенный код ни в развернутом ни в свернутом виде. Код, им произведенный, очень похож и по виду и по производительности в обоих случаях. То есть, если для компилятора Intel развертывание цикла — вредно, то для Microsoft — просто бесполезно :).
А что если вы все же хотите сохранить развертывание цикла — ~~оно дорого вам как память~~, но и векторизацию тоже хотите?
Тогда используйте прагмы компилятора Intel как показано ниже:
**#pragma simd**
```
for(x=0; x <= size.width - 4; x += 4 )
{
DT t0, t1;
t0 = op(src[x]*scale + shift);
t1 = op(src[x+1]*scale + shift);
dst[x] = t0; dst[x+1] = t1;
t0 = op(src[x+2]*scale + shift);
t1 = op(src[x+3]*scale + shift);
dst[x+2] = t0; dst[x+3] = t1;
}
```
**#pragma novector**
```
for( ; x
```
И последнее. Само по себе разворачивание циклов может положительно повлиять на производительность. Но, во-первых, возможный выигрыш от векторизации все равно превысит это положительное влияние, а, во-вторых, разворачивание можно поручить компилятору, тогда и векторизация от этого не пострадает. В числе прочего планирую затронуть эту тему на [вебинаре](http://software.intel.com/ru-ru/articles/trainings-webinars/) 27 октября. | https://habr.com/ru/post/131159/ | null | ru | null |
# Создание расширений для Speed Dial
Вступление
----------
В 2007 году мы [представили](http://www.opera.com/docs/changelogs/windows/920/) миру Speed Dial. Сегодня вы можете найти реализации этого популярного концепта почти во всех ведущих браузерах. Но как бы мы этим не гордились, какими бы родителями мы были, если бы не помогали нашему детищу расти и изучать новые способности? В релизе Opera 11.10 мы улучшили внешний вид и UX нашего Speed Dial и добавили [возможность разработчикам контролировать то, как будет выглядеть их сайт](http://dev.opera.com/articles/view/opera-speed-dial-enhancements/) в ячейках Speed Dial. В Opera 11.50 мы делаем ещё один шаг вперёд вместе с **расширениями для Speed Dial**.
Точно так же как вы можете расширить возможности своего браузера с помощью [расширений для Opera](https://addons.opera.com/addons/extensions/), вы можете настраивать и расширять возможности Speed Dial, чтобы сделать его ещё более удобным. Вместо того, чтобы быть ограниченным отображением иконок или скриншотов страниц, Speed Dial теперь может отображать «живой» контент, и эта статья покажет вам, как это сделать.
Замечание: Чтобы опробовать этот пример, вам необходима [Opera 11.50](http://www.opera.com/browser/next/) и пример расширения для Speed Dial: [скачать наши часы для Speed Dial](http://dev.opera.com/articles/view/creating-opera-speed-dial-extensions/clock_SD_extension.oex).
Основы
------
Для сохранения совместимости с обычными расширениями для Opera расширения для Speed Dial используют тот же формат и структуру, но с некоторыми дополнениями. Другими словами, следующие мелкие добавления в код файла *config.xml* могут превратить существующее расширение для Opera в расширение для Speed Dial:
* Элемент с атрибутом *name* и значением *opera:speeddial*, который превращает расширение в расширение для Speed Dial.
* Атрибут *viewmodes* тэга со значением *minimized*: показывает фоновую страницу в ячейке Speed Dial.
Обратите внимание, на данный момент расширение не может одновременно использовать Speed Dial и панель инструментов браузера. Другими словами, расширение с кнопкой на панели браузера не может одновременно быть расширением для Speed Dial в текущей реализации.
Описываем расширение для Speed Dial в файле *config.xml*
--------------------------------------------------------
Давайте применим теорию на практике и пошагово создадим тестовое расширение. Чтобы просмотреть следующие фрагменты кода вы можете скачать [наше расширение для Speed Dial — часы](http://dev.opera.com/articles/view/creating-opera-speed-dial-extensions/clock_SD_extension.oex) и взглянуть на исходный код внутри пакета. Рисунок 1 показывает, как будет выглядеть расширение в итоге.
**Рисунок 1**: Расширение «часы» установленное в Speed Dial браузера Opera.
В то время как обычные ячейки Speed Dial отображают скриншот веб-страницы, расширение для Speed Dial отображает стартовую (или фоновую) страницу расширения — это файл *index.html* по умолчанию. Чтобы задействовать это, мы, в первую очередь, должны добавить в тэг файла config.xml атрибут *viewmodes* со значением *minimized*:
Этот атрибут скажет браузеру отображать фоновую страницу расширения в минимизированном виде. Размер ячейки Speed Dial при 100% зуме — 256х160 пикселей. В дополнение, мы должны добавить элемент *feature* с атрибутом *required* и элементом *param*:
```
```
Атрибут *required* элемента *feature* указывает на необходимость Speed Dial для запуска расширения. Для примера, могут быть другие браузеры, которые совместимы с расширениями для Opera, но не поддерживают Speed Dial. Если ваше расширение должно работать в таких условиях, используйте значение *false*. Если же ваше расширение не работает без Speed Dial — выбирайте значение *true*.
Элемент *param* обязателен и указывает на страницу, которая должна открыться при клике на иконку в Speed Dial.
Вот полный код файла config.xml для расширения:
```
xml version="1.0" encoding="utf-8"?
Clock Speed Dial Extension
This is an example Speed Dial extension showing a simple clock.
Daniel Davis
```
Добавляем контент в расширение
------------------------------
Следующим шагом для нас будет создание чего-нибудь интересного для показа в окне Speed Dial. Это фоновая страница расширения, поэтому мы должны создать файл *index.html* в той же директории, что и файл *config.xml*. Для примера, мы сделаем простые цифровые часы на JavaScript, которые отображают время с точностью до секунды. Для начала создадим базовый файл *index.html* с пустым элементом *output*:
```
Clock Speed Dial Extension
```
Затем создадим директорию scripts с файлом *background.js*, на который мы ссылаемся в *index.html*. JS-файл выглядит так:
```
window.addEventListener('load', function() {
// Simple function to prefix a zero if the value passed is less than 10
function formatTime(time) {
return (time < 10) ? '0' + time : time;
}
var output = document.querySelector('output');
var date, hours, mins, secs;
// Get and display the current time every 500 milliseconds
var timer = window.setInterval(function() {
date = new Date();
hours = date.getHours();
mins = date.getMinutes();
secs = date.getSeconds();
output.innerHTML = formatTime(hours) + ':' + formatTime(mins) + ':' + formatTime(secs);
}, 500); // Twice a second to allow for slight delays in JavaScript execution
}, false);
```
Подключаемая css (*style.css*) также проста, но содержит хитрый трюк:
```
* {
margin: 0;
padding: 0;
}
html {
height: 100%;
}
/* Use display:table and display:table-cell
so that we can use vertical-align:middle */
body {
background: #444;
color: #fff;
display: table;
height: 100%;
width: 100%;
}
output {
display: table-cell;
font-family: monospace;
font-size: 10em;
text-align: center;
text-shadow: 0 0.1em 0.1em #000;
vertical-align: middle;
}
/* Styles here are only applied in a "minimized" state */
@media screen and (view-mode: minimized) {
output {
font-size: 1.8em;
}
}
```
Как вы можете видеть, используется CSS3-запрос в конце файла, который проверяет условие *view-mode: minimized* на соответствие спецификации [view-mode Media Feature](http://dev.w3.org/2006/waf/widgets-vmmf/). Другими словами, стили в этой секции будут применены только если страница отображается в минимизированном состоянии, как в ячейке Speed Dial. Это удобный способ переопределения стилей в некоторых ситуациях без необходимости использовать несколько дизайнов.
Завершаем расширение
--------------------
Как обычно, чтобы упаковать наши труды как расширение, нужно зазиповать все файлы в корневой директории (но не саму директорию) и сменить архиву расширение с *zip* на *oex*. Если вы ещё не сделали этого, то скачайте [расширение clock\_SD\_extension.oex](http://dev.opera.com/articles/view/creating-opera-speed-dial-extensions/clock_SD_extension.oex) и попробуйте.
SpeedDialContext API
--------------------
После установки расширение может динамически контролировать свою ячейку Speed Dial через SpeedDialContext API. Это очень простое API с двумя записываемыми свойствами: *title* и *url*. Они доступны в фоновом скрипте через объект *opera.contexts.speeddial*, например так:
```
if (opera.contexts.speeddial) {
var sd = opera.contexts.speeddial;
sd.title = "My title";
sd.url = "mypage.html";
}
```
Мы можем использовать эту возможность для улучшения нашего расширения, например для отображения дружеского сообщения в зависимости от времени суток. Единственный файл, который необходимо отредактировать, это *background.js*:
```
window.addEventListener('load', function() {
// Simple function to prefix a zero if the value passed is less than 10
function formatTime(time) {
return (time < 10) ? '0' + time : time;
}
var output = document.querySelector('output');
var date, hours, mins, secs, tmp_hours, timeofday;
var messages = {
"morning": "Good morning!",
"afternoon": "Good afternoon!",
"evening": "Good evening!",
"night": "Shouldn't you be in bed?"
};
// Get and display the current time every 500 milliseconds
var timer = window.setInterval(function() {
date = new Date();
hours = date.getHours();
mins = date.getMinutes();
secs = date.getSeconds();
output.innerHTML = formatTime(hours) + ':' + formatTime(mins) + ':' + formatTime(secs);
// Make the Speed Dial title display time-related message
if (hours !== tmp_hours) {
if (hours > 15) {
timeofday = 'evening';
} else if (hours > 11) {
timeofday = 'afternoon';
} else if (hours > 3) {
timeofday = 'morning';
} else {
timeofday = 'night';
}
if (opera.contexts.speeddial) {
opera.contexts.speeddial.title = messages[timeofday];
}
tmp_hours = hours;
}
}, 500); // Twice a second to allow for slight delays in JavaScript execution
}, false);
```
Это тот же самый файл из первого примера, но с несколькими дополнениями. А именно:
* объект *messages* содержит сообщения для различного времени суток;
* повторяющаяся проверка, выполняющая код когда время меняется;
* строка, которая отображает соответствующее сообщение из объекта messages в заголовке Speed Dial.
Расширение может быть скачано здесь: [friendly\_clock\_SD\_extension.oex](http://dev.opera.com/articles/view/creating-opera-speed-dial-extensions/friendly_clock_SD_extension.oex). После установки оно будет выглядеть так:
**Рисунок 2**: Дружеское расширение «часы», установленное в Speed Dial браузера Opera.
Заключение
----------
Как вы видите, разработчики получили дополнительный способ улучшить свои расширения. Приведённые примеры просты, но показывают потенциал расширений для Speed Dial, если объединить их с умными идеями и навыками веб-разработки. Мы надеемся увидеть более интересные расширения, чем просто красивые ссылки на сайты, так что мы ждём ваших креативных использований этого API в [репозитории расширений для Opera](https://addons.opera.com/addons/extensions/)!
Ссылки
------
[API расширений для Opera: Руководство по Speed Dial](http://www.opera.com/docs/apis/extensions/speeddialguide/) | https://habr.com/ru/post/118594/ | null | ru | null |
# How to Set Up Your Own VPN Server in 15 Minutes
If you use Habr, chances are, you’re conscious about privacy on the web. As governments and corporations tighten their grip on people’s online activities, the issue of keeping your browsing data to yourself becomes more and more relevant.
Numerous tech websites say VPN is no longer a geek-only thing, and regular people should use it, too ([Fast Company](https://www.fastcompany.com/90282668/the-one-thing-you-should-do-to-protect-your-privacy-in-2019), [Mashable](https://mashable.com/article/why-you-need-vpn/), [PCMag](https://www.pcmag.com/article/364072/do-i-need-a-vpn-at-home)). But as a tech-savvy person, you know there isn’t a service you can trust as much as the one you host and manage yourself.
With this post, you’ll deploy your own instance of Outline VPN on AWS.
What is Outline?
----------------
[Outline](https://getoutline.org/) is an open-source project backed by [Jigsaw](https://jigsaw.google.com/), a Google subsidiary focused on information security and privacy. Outline consists of three parts: a Docker-based server software, Outline Manager for creating and deleting users, and the client app for several platforms. Sources for all those components are [available on GitHub](https://github.com/Jigsaw-Code).
**More Details**Strictly speaking, Outline is not a traditional VPN, but a ShadowSocks-based proxy. However, since it forwards traffic to the remote server and encrypts data en route, i.e. does two things usually expected from a VPN service, I’ll refer to Outline as a VPN (it seems like everyone does so).
Hosting
-------
For the sake of simplicity, we’ll host Outline with [Lightsail](https://lightsail.aws.amazon.com/), an amateur-friendly part of AWS. [The lowest-tier plan](https://aws.amazon.com/lightsail/pricing/) costs $3.50 (less than ₽250) a month and gives you 512 MB of RAM, a 20-gigabyte SSD, and 1 TB of data transfer—enough resources to run a VPN service.
**Why Lightsail and not EC2**EC2 is good for when your project needs scalability and you’re prepared to configure (and pay for) every service, including computing, data transfer, etc., individually. For small projects, like a personal VPN server, EC2 is confusing and, most importantly, too expensive: the cheapest EC2 instance will cost you $3.87 a month, data transfer not included.
The only good reason to use EC2 instead of Lightsail is if you haven’t used the AWS free tier (Lightsail is not eligible for it).
Getting Started with Lightsail
------------------------------
Create a new Lightsail instance. You’ll be presented with a list of locations. Select whichever one that suits you most. Changing availability zone is only relevant if you launch several instances in one region and are worried about fault tolerance; otherwise, leave the default value.
Select Ubuntu 18.04 LTS as the operating system.
Create the instance, wait for it to launch, and then open its settings. On the Networking tab, create a static IP address (it’s included in the price of the instance).
Connect to the server using SSH. You can use the browser-based client on the Connect tab in settings.
Once connected, install software updates.
```
sudo apt-get update
sudo apt-get upgrade
```
️ It’s highly recommended to configure swap. See [this guide](https://www.digitalocean.com/community/tutorials/how-to-add-swap-space-on-ubuntu-18-04).
Install Docker
--------------
Outline server software relies on Docker, but Ubuntu ships without it installed. Fortunately, it can be installed in a matter of seconds.
```
sudo curl -sS https://get.docker.com/ | sh
sudo usermod -aG docker ubuntu
```
️ Don’t forget to log out and reconnect to the server for settings to apply!
Install and Configure Outline
-----------------------------
Run the following command to install server software:
```
sudo bash -c "$(wget -qO- https://raw.githubusercontent.com/Jigsaw-Code/outline-server/master/src/server_manager/install_scripts/install_server.sh)"
```
Once installation is complete, you’ll see two important things: server management key and a set of ports you need to open. Go back to server settings and configure firewall on the Networking tab.
Download and install Outline Manager from [the website](https://getoutline.org/). The app is available for macOS, Windows, and Linux. On the setup page, select “Set up Outline anywhere” and paste the server management key.
Once you’ve done that, you’ll see the server management screen where you can add and remove user keys, and view data transfer stats. Create a key, rename it if you want, click the share button on the right, scroll down in the popup window, and copy the access key.
Connect to Your Server
----------------------
Download the Outline Client app. As of today, it supports [macOS](https://itunes.apple.com/us/app/outline-app/id1356178125), Windows, Linux, [ChromeOS](https://play.google.com/store/apps/details?id=org.outline.android.client), [iOS](https://itunes.apple.com/us/app/outline-app/id1356177741), and [Android](https://play.google.com/store/apps/details?id=org.outline.android.client). In the app, click or tap the plus button, paste the key, and connect to the server.
**Your traffic is now secure.**
 | https://habr.com/ru/post/448108/ | null | en | null |
# Сбор контекстной информации для логирования
Зачастую требуется записывать в логи дополнительную информацию, которая может прояснить ситуацию и в дальнейшем упростить отладку приложения. Например, если логируется информация об ошибке, неплохо было бы также сохранить в некоторой форме и входные данные, чтобы было проще воспроизвести проблему. Здесь я хочу описать подход, позволяющий собрать эту дополнительную информацию.
Постановка задачи
-----------------
Пусть у нас есть ASP.NET MVC We-сервис. Он принимает POST-запросы, содержащие описание того, что нужно сделать, в JSON-формате. После анализа такого описания, сервис создает и выполняет несколько SQL-запросов к базе данных. Затем он объединяет результаты и отсылает их клиенту.
Необходимо сказать, что этот сервис широко использует асинхронность и многопоточность через *async/await* и `Task`.
Теперь, когда мы понимаем, с чем имеем дело, перейдем к проблемам.
Сбор контекстной информации об ошибках
--------------------------------------
Иногда наш сервис выдает ошибки. Причины могут быть разными: неправильный JSON на входе, баги в коде, проблемы с базой данных,… В этом случае мы должны записать в лог информацию об ошибке.
Нет никаких проблем с логированием самого исключения. Мы можем отловить его в action-методе нашего контроллера:
```
public class ServiceController : ApiController
{
[Route("api/service")]
[HttpPost]
public async Task ServiceAction(
[FromBody] RequestModel requestModel
)
{
try
{
...
}
catch (Exception ex)
{
Logger.LogError(ex);
throw;
}
}
}
```
Или же мы можем создать для этого специализированный атрибут:
```
public class LogErrorAttribute : ActionFilterAttribute
{
public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
{
base.OnActionExecuted(actionExecutedContext);
if (actionExecutedContext.Exception != null)
{
Logger.LogError(actionExecutedContext.Exception);
}
}
}
```
и использовать его на action-методе:
```
[Route("api/service")]
[HttpPost]
[LogError]
public async Task ServiceAction(
[FromBody] RequestModel requestModel
)
{
...
}
```
Но нам требуется большее. Для каждой ошибки мы хотим сохранять дополнительную информацию:
* Текст JSON-тела запроса.
* Текст всех сгенерированных SQL-запросов.
Есть и еще одно требование. Эта дополнительная информация должна записываться в лог только с случае возникновения ошибки. В противном случае в логах она нам не нужна.
Выполнить это для тела запроса не сложно:
```
public class ServiceController : ApiController
{
[Route("api/service")]
[HttpPost]
public async Task ServiceAction(
[FromBody] RequestModel requestModel
)
{
var requestText = await Request.Content.ReadAsStringAsync();
try
{
...
}
catch (Exception ex)
{
Logger.LogError(ex);
Logger.LogError($"Request test is {requestText}");
throw;
}
}
}
```
Но для SQL-запросов все не так просто. Дело в том, что эти запросы генерируются не action-методом. Они даже генерируются не в контроллере. Между action-методом и методом, генерирующим SQL, множество вызовов других методов других классов. Как же нам извлечь тексты этих запросов, когда они будут нам нужны?
Одним из вариантов является использование списка сообщений (например, `List`). Мы создаем его в нашем action-методе (`ServiceAction`) и передаем его в метод, занимающийся генерацией SQL. Там мы добавим тексты SQL-запросов в этот список. В случае, если произошла ошибка, action-метод будет иметь у себя список сообщений, которые нужно поместить в лог.
У этого метода есть очень существенный, на мой взгляд, недостаток. Нам придется передавать наш список сообщений по всей цепочке вызовов методов до тех пор, пока мы не достигнем метода, генерирующего SQL. Это означает, что во многих местах этот список сообщений будет нужен только для того, чтобы передать его дальше. Это усложняет код, и я постарался бы избежать этого.
Если вы используете DI контейнер и можете создавать ваши классы из него, то можно попробовать поместить список сообщений в контейнер с временем жизни “per request”. Класс, занимающийся генерацией SQL, будет принимать этот список сообщений в качестве параметра конструктора. Тогда и экземпляр данного класса и экземпляр контроллера смогут получить доступ к одному и тому же экземпляру списка сообщений.
Но существует более удобный способ сбора контекстной информации даже в том случае, если вы не используете DI контейнер. Было бы хорошо, если бы мы могли получать доступ к списку сообщений через статическое свойство:
```
public static async Task RunReaderAsync(this SqlCommand cmd)
{
var message = $"SQL Server query is: {cmd.CommandText}";
ErrorContext.Current.AttachMessage(message);
...
}
```
Здесь есть серьезная проблема. Наш сервис может одновременно обслуживать несколько запросов. И каждый такой запрос должен иметь свой собственный список сообщений. Более того, при обработке одного запроса наш код может порождать несколько потоков (например, с помощью *async/await*). И все эти потоки должны иметь доступ к одному и тому же списку сообщений. Как это можно реализовать?
Нам на помощь приходит класс `AsyncLocal`. Он гарантирует, что если вы положите некоторое значение в экземпляр этого класса в одном потоке, то вы сможете получить это значение в данном потоке, а также во всех потоках, запущенных из данного начиная с этого момента. В то же время все другие потоки не будут иметь доступа к этому значению.
Давайте посмотрим на реализацию класса `ErrorContext`:
```
public class ErrorContext
{
private static readonly object Lock = new object();
private static readonly AsyncLocal CurrentErrorContext = new AsyncLocal();
private readonly Lazy> \_attachedMessages = new Lazy>(() => new ConcurrentBag());
private ErrorContext()
{}
public static ErrorContext Current
{
get
{
lock (Lock)
{
var errorContext = CurrentErrorContext.Value;
if (errorContext == null)
{
CurrentErrorContext.Value = errorContext = new ErrorContext();
}
return errorContext;
}
}
}
public static ErrorContext CreateNewErrorContext()
{
lock (Lock)
{
var errorContext = new ErrorContext();
CurrentErrorContext.Value = errorContext;
return errorContext;
}
}
public void AttachMessage(string message)
{
if (!string.IsNullOrWhiteSpace(message))
{
\_attachedMessages.Value.Add(message);
}
}
public IReadOnlyList GetMessages()
{
return \_attachedMessages.Value.ToArray();
}
}
```
Метод `CreateNewErrorContext` немедленно создает новый список сообщений и сохраняет его в поле `CurrentErrorContext`, имеющем тип `AsyncLocal`. Вы можете получить доступ к текущему списку в любом месте кода с помощью статического свойства `Current`. Метод `AttachMessage` добавляет новое сообщение в список. Он сохраняет сообщения в экземпляре `ConcurrentBag`, поскольку этот метод может одновременно вызываться из нескольких потоков. Метод `GetMessages` возвращает все сохраненные сообщений, так что их можно записать в лог.
Теперь можно легко инициализировать и использовать `ErrorContext` внутри `LogErrorAttribute`:
```
public class LogErrorAttribute : ActionFilterAttribute
{
public override void OnActionExecuting(HttpActionContext actionContext)
{
ErrorContext.CreateNewErrorContext();
base.OnActionExecuting(actionContext);
}
public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
{
base.OnActionExecuted(actionExecutedContext);
if (actionExecutedContext.Exception != null)
{
foreach(var message in ErrorContext.Current.GetMessages())
{
Logger.LogError(message);
}
Logger.LogError(actionExecutedContext.Exception);
}
}
}
```
В любом месте вашего кода можно добавить свое сообщение в текущие контекст ошибки следующим образом:
```
ErrorContext.Current.AttachMessage(message);
```
Логирование проблем с производительностью
-----------------------------------------
Иногда мой сервис работает медленно. Не для всех запросов, но для некоторых выполнение занимает слишком много времени. Мне бы хотелось сохранить информацию о таких запросах, чтобы позже проанализировать ее. Как это можно реализовать, и какая информация нам нужна?
Прежде всего, мне нужен некоторый порог времени выполнения. Если обработка запроса занимает меньше времени, то все в порядке. Я ничего не буду писать в лог в этом случае. Но если времени уходит больше, я должен добавить в лог некоторую информацию.
Какая информация мне нужна? Определенно нужно знать, сколько времени заняла обработка запроса. Но этого не достаточно. Мой сервис делает множество вещей: проверку параметров запроса, получение данных из других сервисов, построение SQL-запросов и их выполнение, … Мне нужно знать, сколько времени заняла каждая такая часть, чтобы понять, где скрыта проблема.
Кроме того, мне нужна та же информация, что и для ошибок. Мне нужно тело запроса, чтобы иметь возможность воспроизвести проблему. Мне нужны тексты SQL-запросов на случай, если именно они отнимают наибольшее время.
Как этого можно добиться? Опять же, с помощью класса `AsyncLocal`:
```
public class Timer : IDisposable
{
private static readonly object Lock = new object();
private static readonly AsyncLocal CurrentTimer = new AsyncLocal();
private readonly Stopwatch \_stopwatch = new Stopwatch();
private readonly Lazy> \_attachedTimers = new Lazy>(() => new ConcurrentQueue());
private readonly Lazy> \_attachedMessages = new Lazy>(() => new ConcurrentQueue());
private readonly string \_description;
private readonly TimeSpan? \_threshold;
private readonly Timer \_previousCurrent;
private bool \_isDisposed;
private bool \_suspendLogging;
private Timer(Timer previousCurrent, string description = null, TimeSpan? threshold = null)
{
\_previousCurrent = previousCurrent;
\_description = description;
\_threshold = threshold;
\_stopwatch.Start();
}
public static Timer Current
{
get
{
lock (Lock)
{
var timer = CurrentTimer.Value;
if (timer == null)
{
CurrentTimer.Value = timer = new Timer(null);
}
return timer;
}
}
}
public static Timer SetCurrentTimer(string description, TimeSpan? threshold = null)
{
lock (Lock)
{
var currentTimer = CurrentTimer.Value;
var timer = new Timer(currentTimer, description, threshold);
CurrentTimer.Value = timer;
currentTimer?.\_attachedTimers.Value.Enqueue(timer);
return timer;
}
}
public void AttachMessage(string message)
{
if (!string.IsNullOrWhiteSpace(message))
{
\_attachedMessages.Value.Enqueue(message);
}
}
public void Dispose()
{
if (!\_isDisposed)
{
\_isDisposed = true;
\_stopwatch.Stop();
if (\_attachedTimers.IsValueCreated)
{
foreach (var attachedTimer in \_attachedTimers.Value)
{
attachedTimer.Dispose();
}
}
if (!\_suspendLogging && \_threshold.HasValue && \_stopwatch.Elapsed > \_threshold.Value)
{
Log();
}
if (\_previousCurrent != null)
{
CurrentTimer.Value = \_previousCurrent;
}
}
}
private JObject Message
{
get
{
Dispose();
var message = new StringBuilder($"It took {\_stopwatch.ElapsedMilliseconds} ms to execute {\_description}.");
if (\_threshold.HasValue)
{
message.Append($" Duration threshold is {\_threshold.Value.TotalMilliseconds} ms.");
}
var messageObj = new JObject
{
["message"] = message.ToString(),
};
if (\_attachedTimers.IsValueCreated && \_attachedTimers.Value.Any())
{
messageObj["attachedTimers"] = new JArray(\_attachedTimers.Value.Select(t => t.Message));
}
if (\_attachedMessages.IsValueCreated && \_attachedMessages.Value.Any())
{
messageObj["attachedMessages"] = new JArray(\_attachedMessages.Value);
}
return messageObj;
}
}
public void Log()
{
try
{
\_suspendLogging = true;
Dispose();
if (\_stopwatch.Elapsed < \_threshold)
{
Logger.LogDebug(Message.ToString());
}
else
{
Logger.LogWarning(Message.ToString());
}
}
finally
{
\_suspendLogging = false;
}
}
}
```
Давайте посмотрим, как это работает. Метод `SetCurrentTimer` создает новый таймер. Здесь можно задать его описание и необязательный порог времени выполнения.
Почему этот порог не обязателен? Иногда мне требуется, чтобы часть моего кода выполнялась не дольше определенного времени. Так я могу желать, чтобы весь запрос к сервису обрабатывался за 3 секунды. В других случаях я не хочу накладывать ограничения на время выполнения. Например, мне не важно сколько занимает выполнение моих SQL-запросов до тех пор, пока весь запрос к сервису обрабатывается менее чем за 3 секунды. По этой причине для некоторых таймеров нужно устанавливать порог времени выполнения, тогда как для других — нет.
Внутри метода `SetCurrentTimer` создается новый таймер и кладется в переменную `CurrentTimer` типа `AsyncLocal`. Но это еще не все. В этот момент может уже существовать другой активный таймер. В этом случае новый только что созданный таймер присоединяется к уже существующему. Это позволяет создавать вложенные таймеры, чтобы измерять время выполнения как всего блока кода, так и его частей:
```
using (Timer.SetCurrentTimer("The whole block"))
{
...
using (Timer.SetCurrentTimer("Part 1"))
{
...
}
...
using (Timer.SetCurrentTimer("Part 2"))
{
...
}
...
}
```
Свойство `Current` дает доступ к текущему таймеру. Это полезно, если вы хотите добавить к нему некоторые сообщения:
```
var message = $"SQL Server query is: {cmd.CommandText}";
Timer.Current.AttachMessage(message);
```
Здесь присоединенные сообщения и вложенные таймеры хранятся в экземплярах `ConcurrentQueue`, поскольку порядок их следования может быть важен.
Свойство `Message` возвращает собранные в единое целое сообщения от текущего и всех сложенных в него таймеров. Здесь я использую JSON-классы из библиотеки [JSON.NET](https://www.newtonsoft.com/json) для структурирования всех сообщений. Но на самом деле это не так важно. Можно использовать любой формат.
Метод `Log` записывает сохраненную в таймере информацию в лог, не зависимо от того, был ли установлен порог времени выполнения или нет. В то же время, метод `Dispose` записывает информацию в лог только в том случае, если был превышен установленный порог времени выполнения.
Теперь можно создать еще один атрибут для методов наших контроллеров:
```
public class TimerContextAttribute : ActionFilterAttribute
{
private readonly string _timerDescription;
private readonly int _durationThresholdMs;
private readonly AsyncLocal \_timer = new AsyncLocal();
public TimerContextAttribute(string timerDescription, int durationThresholdMs)
{
if (string.IsNullOrWhiteSpace(timerDescription)) throw new ArgumentNullException(nameof(timerDescription));
\_timerDescription = timerDescription;
\_durationThresholdMs = durationThresholdMs;
}
public override void OnActionExecuting(HttpActionContext actionContext)
{
\_timer.Value = Timer.SetCurrentTimer(\_timerDescription,
TimeSpan.FromMilliseconds(\_durationThresholdMs));
base.OnActionExecuting(actionContext);
}
public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
{
base.OnActionExecuted(actionExecutedContext);
\_timer.Value?.Dispose();
}
}
```
и использовать его на action-методах так:
```
[Route("api/service")]
[HttpPost]
[TimerContext("For ServiceAction method", 3000)]
public async Task ServiceAction(
[FromBody] RequestModel requestModel
)
{
...
}
```
Заключение
----------
В этой статье я описал, как достаточно просто собирать информацию из многих мест в коде и получить к ней доступ позже. Такая функциональность может быть реализована с помощью статических свойств и методов, которые манипулируют экземплярами класса `AsyncLocal`.
Надеюсь, материал статьи будет полезен для улучшения системы логирования в ваших приложениях. | https://habr.com/ru/post/416751/ | null | ru | null |
# mysqlcheck и optimize таблиц InnoDB
Только что заметил, что если делать
`mysqlcheck -o --repair db_name`
и ваши таблицы в InnoDB, то не только **не** происходит repair (что и не должно, так как движок не поддерживает эту функцию), но и optimize не срабатывает.
То есть, база остается без optimize и вы этого не замечаете!
Если делать так:
`mysqlcheck -o db_name`
, то происходит пересоздание (recreate) каждой таблицы.
Из-за этого у меня optimize не выполнялся скриптом по крону уже полгода, с момента перехода с MyISAM на InnoDB.
PS: В моем случае используется innodb\_file\_per\_table. | https://habr.com/ru/post/138324/ | null | ru | null |
# Разработка чат-бота (laravel+botman)
Welcome! Я, как junior full stack разработчик, при попытке написать бота с использованием laravel и botman’а столкнулся с многими проблемами. Во-первых, я плохо знаю английский, а на русском статей очень мало на эту тему, а те, что есть не помогли мне решить мои проблемы. В статье будет рассказано и показано, как разработать чат-бота на laravel+botman для telegram. Сам я разрабатывал ботов(коммерческих) под viber и telegram. Как разработчику telegram мне нравится больше всего.
Я не буду показывать как установить laravel и настроить сервер для его работы. Если вы никогда этого не делали, то проще будет установить openserver, в него встроен composer(пакетный менеджер для php) и уже настроен локальный сервер для laravel’a. Вам останется лишь прописать немного кода в .htaccess. Дома я именно так и работаю. В статье покажу один из способов разработки чат-бота, настроим бота для работы в телеграм, а так же, в конце, оставлю ссылки на полезные статьи о laravel’e и botman’e.
Проектирование/подготовка
-------------------------
Разработку бота предлагаю, как и все нормальные разработчики, начать с проектирования, постановки задачи и объяснения как работает laravel. Перед этим скажу, что я пишу код в phpStrom. Можно писать в любом другом IDE, но я пользуюсь именно им.
В laravel реализован паттерн MVC(Model View Controller). Это не значит, что нужно писать только под mvc, можно и говнокодить, но лучше пользоваться теми преимуществами, которые предоставляет фреймворк. Если вы знакомы с mvc, но не применяли его, как я, то разработка с помощью laravel’a это лучший способ закрепить знания.
### Что должен делать наш бот:
* Спрашивать у пользователя его имя
* Поинтересоваться, нравится пользователю погода или нет
* Также записать ответ в БД
* Попрощаться и отправить картинку
Немного о MVC. При обращение к нашему ПО, посредством команд(url адреса), мы должны принять эти команды и обработать, понять, что требуется пользователю. Для этого есть пути, так называемые routes. Routes определяет какой Controller нужно использовать, в свою очередь controller, если это требуется, обращается к БД через model. Model связывается с базой данных и возвращает нужный нам результат. В боте view не нужен, т.к. вся работа идет через интерфейс мессенджера. Тем самым, после получения данных от model’и, controller отдает эти данные view, в нашем случае это blade шаблон (именно его использует laravel). Данные можно отдать и обычной php странице, но лучше это делать через blade шаблоны. Мы используем интерфейс мессенджера, то отправлять данные будем сразу в него.
Разработка
----------
Чтобы создать проект, достаточно ввести в консоль следующую команду
`composer create-project --prefer-dist botman/studio botelegram`
Входной точкой будет rout "/start". В botman’e есть несколько реализаций routes. Т.к. мы будем обращаться к routes через бота в телеграме, то нам нужен "botman.php".
В нем нам нужно записать следующую строчку
```
$botman->hears('/start', function ( $bot ) { $bot->startConversation ( new mainConversation ); } );
```
telegram сам предлагает начинать работу с ботом через команду "start", а раз так, то мы можем облегчить взаимодействие с ботом, задав начальную точку входа как "/start" и сразу перейти к работе с ним.
С помощью $bot->startConversation ( new mainConversation ); мы указываем какой контроллер будет отвечать за работу. Так же, пропишем использование нашего контроллера, для этого нам нужно в файле с путями добавить этот код:
```
use App\Conversations\mainConversation;
```
Продолжим. Нам нужно создать базу данных и сам контроллер. Я подразумеваю, что вы используете openserver. БД можно создать через консоль или с помощью phpMyAdmin, который встроен в openserver.
Теперь немного конфигураций. Нам нужно внести данные БД в конфигурационный файл laravel. Он лежит в корневом каталоге проекта и называется .env
Найдите строчки связанные с БД
```
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=botelegram
DB_USERNAME=root
DB_PASSWORD=
```
Здесь нас интересует лишь название базы, имя юзера и пароль. Если вы используете openserver, то можно написать в имя-root, а пароль оставить пустым, название БД зависит уже от вас.
Теперь наше приложение имеет доступ к БД. Следующее, что нам потребуется, это создать model и migration. Прописываем в консоле:
`php artisan make:model messengerUser -m`
Флаг -m создаст миграцию для БД и свяжет ее с нашей моделью. Давайте сразу и настроим нашу миграцию, чтобы больше к ней не возвращаться.
Лучше так не делать, но чтобы не создавать кучу файлов, запишем все данные в одну таблицу.
Нам нужно:
* id чата
* Имя пользователя
* Хорошая погода или нет
Этого достаточно, чтобы продемонстрировать основные возможности botman’a. Откройте только что созданную миграцию, которая находится в database/migrations/дата\_создания\_create\_messanger\_users\_table.php
Дополните метод up в данной миграции, она должна иметь следующий вид:
```
public function up() {
Schema::create('messenger_users', function (Blueprint $table) {
$table->increments('id');
$table->string("id_chat");
$table->string("name");
$table->string('response');
$table->timestamps();
});
}
```
Теперь нам нужно запустить миграцию, чтобы наша таблица существовала в БД. В консоли нужно прописать:
`php artisan migrate`
Подсказка: если в процессе разработки вам потребуется изменить поля в таблице, а в таблице есть данные, и если вам они не нужны, то с помощью команды `php artisan migrate:refresh` можно обновить таблицы.
Результат:
laravel провел 3 миграции, но нас интересует лишь 3-я миграция т.к. именно туда мы будем записывать наши данные.
Настало время создать controller, подключить к нему нашу model и написать логику.
Вообще, лучше все файлы создавать через консоль, но так как мы пользуемся botman’ом, да и я уже так привык, создадим controller вручную. В botman контроллер носит название conversation, возможно, между ними есть существенные отличия, но в этом я не разбирался — не было нужды. В папке app/Conversations создаем файл с именем mainConversation.php .
На экране вы видите минимальную комплектацию conversation’а
```
namespace App\Conversations;
use BotMan\BotMan\Messages\Conversations\Conversation;
class mainConversation extends conversation
{
public function run () {
}
}
```
В вашем классе обязательно должен быть публичный метод run, он является входной точкой для controller’а.
Подключим нашу модель к котроллеру:
`use app\messengerUser;`
Пропишем начальную логику. Метод run будет запускать приватный метод, который спросит, как зовут пользователя, запишет его id и имя в id\_chat и name нашей таблицы.
Для начала пропишем:
```
use App\messengerUser as database;
use BotMan\BotMan\Messages\Attachments\Image;
use BotMan\BotMan\Messages\Conversations\Conversation;
use BotMan\BotMan\Messages\Incoming\Answer as BotManAnswer;
use BotMan\BotMan\Messages\Outgoing\Actions\Button;
use BotMan\BotMan\Messages\Outgoing\OutgoingMessage;
use BotMan\BotMan\Messages\Outgoing\Question as BotManQuestion;
```
что позволит нам использовать методы botman’a
А теперь внесем изменения в наш контроллер:
```
class mainConversation extends conversation
{
public $response = [];
public function run () {
$this->setName();
}
private function setName() {
$question = BotManQuestion::create("Привет! Как тебя зовут?");
$this->ask( $question, function ( BotManAnswer $answer ) {
if( $answer->getText () != '' ){
array_push ($this->response, $answer->getText());
$this->askWeather ();
}
});
}
}
```
run() запускает нужный нам метод, это setName(). Уже в setName() мы спрашивает имя пользователя, записываем имя в массив, после запускаем следующий метод, который спросит пользователя о погоде.
```
private function askWeather () {
$question = BotManQuestion::create("Тебе нравится погода на улице?");
$question->addButtons( [
Button::create('Да')->value(1),
Button::create('Нет')->value(2)
]);
$this->ask($question, function (BotManAnswer $answer) {
// здесь можно указать какие либо условия, но нам это не нужно сейчас
array_push ($this->response, $answer);
$this->exit();
});
}
```
askWeather() имеет схожую структуру, но здесь мы используем кнопки чтобы ограничить выбор пользователя и облегчить себе жизнь т.к. кнопки убирают очень много ошибок, которые может создать пользователь. Здесь мы также создаем вопрос, с помощью addButtons() привязываем к вопросу кнопки, а позже вызываем данный вопрос и обрабатываем ответ, а также переходим к последнему методу.
Метод exit() будет записывать все данные в БД(можно вынести в отдельный метод), прощаться с пользователем, а также отправит ему картинку.
```
private function exit() {
$db = new database();
$db->id_chat = $this->bot->getUser()->getId();
$db->name = $this->response[0];
$db->response = $this->response[1];
$db->save();
$attachment = new Image('https://gykov.ru/projects/botelegram.png');
$message = OutgoingMessage::create('До новых встреч!')
->withAttachment($attachment);
$this->bot->reply($message);
return true;
}
```
С помощью OutgoingMessage::create('До новых встреч!')->withAttachment($attachment) мы создаем новое сообщение и привязываем к нему картинку. Вообще, все публичные файлы, которые должен видеть пользователь, размещаются в папке public, но в последнем моем боте с этим случилась проблема и мне пришлось разместить их в отдельной папке на сервере(не связанной с проектом). Здесь я сделал тоже самое.
Логика нашего бота готова. Чтобы протестировать его достаточно открыть сайт через openserver, но перед этим, нужно создать файл .htiaccess со следующим содержимым
```
RewriteEngine On
RewriteRule ^(.\*)$ public/$1 [L]
```
Файл должен находиться в корне сайта. Теперь все запросы будут передаваться в папку public. Так работает laravel. Открываем сайт и тестируем бота, не забываем, что для начала нужно ввести "/start".
Убедившись, что все работает можно и присоединить его к телеграмм. Для этого необходимо создать нового бота у @botfather, скопировать key бота в конец .env файла. Выглядит это вот так:
`TELEGRAM_KEY=key_bot`
Теперь нужно поставить в наш проект драйвер для совместной работы нашей логики и телеграм бота. Делается это всего лишь одной командой в консоли:
`composer require botman/driver-telegram`
Также потребуется зарегистрировать бота в laravel.
`php artisan botman:telegram:register`
Нам будет предложено ввести адрес по которому будет доступен наш бот.
Если вы разрабатываете бота на сервере, то достаточно добавить <https://url_site/botman> после этого бота можно протестировать и в самом мессенджере. Но знайте, для laravel’а нужны особые настройки сервера и вам, скорей всего, придется самим его настраивать. Ссылку о том, как настроить сервер я оставлю в конце статьи.
Пожалуй, на этом все. Если вы дочитали до конца, то поздравляю, теперь вы можете разрабатывать чат-ботов под laravel с использованием botman. Если есть вопросы, то с радостью отвечу в комментариях, а также обещанные ссылки:
[Исходники на github](https://github.com/EpicLegend/botelegram)
[Документация botman](https://botman.io/)
[Настройка сервера](https://www.digitalocean.com/community/tutorials/how-to-deploy-a-laravel-application-with-nginx-on-ubuntu-16-04)
[Статья по которой я создавал своего первого бота](https://christoph-rumpel.com/2018/05/how-i-built-the-laravelquiz-chatbot-with-botman-and-laravel)
[Ру статья по botman](https://phpnick.ru/posts/category/php/52) | https://habr.com/ru/post/456240/ | null | ru | null |
# Спойлер: Вставка SVG иконок одним единственным способом
В статье будет обсуждаться проблема вставки SVG иконок в веб — страницу.
Что мы имеем, и как мы используем это. Глобально есть три способа:
* Вставка исходного кода SVG иконки прямо в DOM страницы.
* С помощью HTML тега IMG
* С помощью CSS background-image
Мы не будем говорить о варианте вставки иконок в виде шрифтов, ибо у этого подхода есть масса недостатков (некоторые из них чисто субъективны), о которых можно узнать с помощью поиска в Гугл, и вариант с IFRAME и OBJECT тегами тоже опустим по той же причине.
У всех этих способов есть свои достоинства и недостатки. С появлением SVG у нас появились новые требования к иконкам. Например, во времена PNG нам и в голову бы не пришло использовать одну и ту же иконку в разных размерах в разных частях сайта и с разными цветными заливками. Для этого нам пришлось бы попросить у дизайнера несколько иконок с разными цветами и размерами. Но с появлением SVG мы озверели и начали одну и ту же иконку вставлять повсюду, так как появилась возможность в соответствии с желаниями изменять вид иконки с помощью CSS.
Приведу пример:
Есть у нас иконка — звездочка для рейтингов. Где-то она белая, где-то желтая, большая и маленькая. Плюс может быть обрезанная половинка звездочки, скажем, для обозначения рейтинга 2.5 или 4+.
Для реализации данного примера нам нужно как минимум четыре PNG иконок для каждого цвета и формы, но если у нас SVG, то вместо четырех мы спокойно можем обойтись и одной единственной, специально оформленной для данной задачи и не только.
Нашу звездочку можно прямо вставить в DOM и с помощью стилей оформить ее так, как нам нужно. Это первый вариант, знакомая нам практика.
В первом варианте из достоинств можно перечислить удобное управление элементами графики, анимацию отдельных частей иконки и т.п., полное управление SVG тегами. Из недостатков первое, что в этом случае мы получаем большой размер DOM, что по некоторым причинам является не совсем хорошим феноменом. Вторым недостатком, по сравнению с третьим вариантом, является то, что размер, позиционирования (центровка по вертикали и горизонтали) является в некоторых случаях не тривиальной задачей.
А что насчет второго варианта, то он самый избыточный, так как не имеет ни одного из достоинств двух других вариантов.
Что у нас получается? Мы имеем два варианта вставки иконок, у которых есть свои достоинства и между которыми иногда бывает сложно сделать выбор.
А теперь представьте, что вы можете использовать почти все достоинства (кроме анимации отдельных частей иконки) первого варианта наряду с третьим вариантом.
То есть вставлять иконки с помощью CSS background-image, или HTML тега IMG, и по вашему усмотрению изменить цвет каждого тега в SVG, будь то path, polygon или circle, не имеет значения.
Вот как это будет выглядеть:
```
background-image: url(star.svg?p=red,$00ff00,,green);
```
или
```
```
Думаю, что идея ясна, синтаксис уже зависит от настроек сервера, а над реализацией еще надо поразмышлять.
Тут [ссылка](https://github.com/psrafo/icon) того, как я решил для себя эту проблему. Приветствуются любые решения, если они крутые.
Как это работает
----------------
**Структура директорий*** **caches** — папка для кэша
* **colors** — папка для хранения оригинальных цветов иконок
* **icons** — папка для отформатированных иконок
* **originals** — папка, куда скачиваются все иконки (ее можно задать и вручную)
**Цикл работы**Берутся все иконки из папки **originals**, с помощью DOMDocument находятся все теги иконок, у которых есть цвет(fill), после цвет в иконке заменяется указателем на него в виде этого — "%1", а оригинальный цвет мы сохраняем в папке **colors** для случая, если мы захотим, чтобы она осталась неизменной.
Пример использования данной реализации.
```
icon/?p=parse /* запускает цикл работы */
```
```
icon/?p=empty /* удаляет все файлы, созданные вследствии работы команды parse */
```
```
background-image: url("icon/?p=leaderboard,red,blue,$000,green,orange,yellow,$0f0");
```
 | https://habr.com/ru/post/278825/ | null | ru | null |
# Пришло время переосмыслить безопасность OpenBSD
OpenBSD позиционируетcя как защищённая ОС. Однако за последние несколько месяцев в системе найден ряд уязвимостей. Конечно, в этом нет ничего экстраординарного. Хотя некоторые уязвимости довольно необычные. Можно даже сказать, критические. У разработчиков OpenBSD несколько принципов, как обеспечить безопасность. Вот два из них:
* избегать ошибок;
* минимизировать риск ошибок.
Не все согласны, что этих принципов достаточно, чтобы строить защищённые системы. Мне кажется, есть смысл изучить, работает ли подход OpenBSD, или он изначально обречён.
Для иллюстрации я выбрал не все, а только несколько интересных багов, которые случайно совпадают с темой нашего разговора.
libc auth
=========
Функции **auth** запускают хелперы без проверки argv. [Отчёт](https://marc.info/?l=bugtraq&m=157554141629037&w=2). [Патч](https://ftp.openbsd.org/pub/OpenBSD/patches/6.6/common/010_libcauth.patch.sig).
Это поразительно простая ошибка, но, вероятно, она не показалась слишком очевидной во время код-ревью. Мне кажется, отчасти причина в некоторой путанице в том, кто отвечает за проверку входных данных. Вы можете вызвать каждый из трёх задействованных компонентов: программу, библиотеку или login\_passwd — и разумно предположить, что проверку выполняет кто-то другой. В конце концов, я думаю, виновной признали библиотеку, потому что именно для неё появился патч, но лично мне её код на первый взгляд не кажется однозначно неправильным.
Более интересная часть истории заключается в том, что даже с упомянутой ошибкой libc функция **login\_passwd** не была бы уязвима таким образом, если бы не другой баг. В 2001 году login\_passwd переписали для поддержки kerberos, и, возможно, именно тогда ввели то, что является настоящей причиной ошибки. Предложение аутентификации запросно-ответного типа (как в системе s/key) возвращает аутентифицированное состояние, а не молчание. Много лет спустя код kerberos удалили, но часть кода для его поддержки осталась, как и введённая ошибка.
Если бы код kerberos тщательно почистили, то баг с аутентификацией всё равно остался бы (там были и некоторые другие связанные проблемы с парсингом argv), но его влияние, безусловно, сильно бы уменьшилось.
Не так легко провести корректный парсинг argv в контексте безопасности. Многие логичные советы и подходы тут не работают. Я только отмечу, что эта уязвимость выскочила после [очередного обсуждения проблемы с именами файлов в Unix/Linux/POSIX](https://dwheeler.com/essays/fixing-unix-linux-filenames.html), хотя ведущий минус (дефис) на самом деле не относится к названию файла.
ld.so
=====
Из кода **ld.so** не удалены плохие переменные окружения. [Отчёт](https://marc.info/?l=bugtraq&m=157614618304275&w=2). [Патч](https://ftp.openbsd.org/pub/OpenBSD/patches/6.6/common/013_ldso.patch.sig).
Что-то похожее на ошибку памяти. Но нет. Баг здесь заключается в привязке успеха одной операции — разбиения переменной окружения — к удалению этой переменной. Весьма самоуверенно.
Конечно, сторонники различных систем типизации будут уверять, что обработают эти операции в правильном порядке, но не факт, что это поможет. Код C не вылетал с ошибкой из-за отсутствия обработки ошибок или потому что ошибка распределения памяти осталась незаметной.
ftp
===
**ftp** следует редиректам на локальные файлы. [Отчёт](https://marc.info/?l=openbsd-tech&m=157669682232327&w=2). [Патч](https://ftp.openbsd.org/pub/OpenBSD/patches/6.6/common/015_ftp.patch.sig).
Баг NetBSD ftp с редиректами — это же давно типичный пример [бесконтрольных функций](https://flak.tedunangst.com/post/features-are-faults-redux). И вот опять та же ошибка (к счастью, с незначительными последствиями)! Ребята, ну сидите дома. Не добавляйте в свои программы дополнительные функции.
smtpd from
==========
**smtpd** не может проверить некоторые адреса отправителей. [Отчёт](https://marc.info/?l=oss-security&m=158028971107787&w=2). [Патч](https://ftp.openbsd.org/pub/OpenBSD/patches/6.6/common/019_smtpd_exec.patch.sig). [Комментарий](https://poolp.org/posts/2020-01-30/opensmtpd-advisory-dissected/).
Думаю, что в комментарии Жиля всё сказано, но напомню предысторию. Давным-давно вся почта хранилась локально у каждого пользователя в */var/mail* в файлах mbox. Это не очень здорово, потому что существует вероятность повреждения, если mua удалит электронное письмо, пока mda доставляет новое (не говоря уже о других проблемах типа искажения поля From). Поэтому файл mbox нужно заблокировать. Но блокировка в сетевой файловой системе работает ненадёжно. Так что вместо блокировки мы задействуем lock-файлы. Однако нужно прийти к согласию по определённому протоколу блокировки, ведь файлами mbox владеет пользователь, а самим каталогом — рут. Таким образом, чтобы фактически изменить файл mbox, нужно каждый раз запускать вспомогательную функцию setuid. Ну, вот уже первая проблема. Ещё один пережиток старых времён заключается в настройках mda, которую можно использовать не просто как программу, а как конвейер оболочки. Народ прописывает что-то вроде `spam-assassin | mail.mda`, а это вы уже не сможете просто передать `execve()`.
Здесь очень много сложностей, которые корнями уходят в прошлое. И, к сожалению, этот проблемный код нельзя просто заменить. Электронная почта используется давным-давно, и на её основе построены очень сложные системы и рабочие процессы, поэтому очень трудно просто вырезать один кусок кода — и вставить новый. Несмотря на различные уровни разделения привилегий, родительский процесс с правами рута по-прежнему во многом доверяет своим менее привилегированным дочерним процессам. Он выполнит команды и аргументы, которые получит.
Избежать этого кажется так же просто, как переключиться на формат хранения maildir, но это требует различных изменений во многих местах. Стандартный mua **mail** не понимает этот формат. Как по мне, так mbox давно отжил своё, но многих он по-прежнему устраивает, а процедура обновления, возможно, не полностью прозрачна и не пройдёт автоматически.
smtpd read
==========
Чтение за пределами области в **smtpd** можно использовать для выполнения команд. [Отчёт](https://marc.info/?l=oss-security&m=158274593103259&w=2). [Патч](https://ftp.openbsd.org/pub/OpenBSD/patches/6.6/common/010_libcauth.patch.sig).
Здесь реально проблема безопасности памяти. Отправив несколько забавных строк состояния, удалённый smtp-сервер может внедрить в очередь smtpd команды для выполнения. Когда электронное письмо помещается в очередь для повторной доставки, smtpd добавляет в заголовок некоторую информацию о месте назначения, чтобы знать, какую команду следует выполнить (см. выше). Эта атака похожа на [«контрабанду» http-запросов](https://habr.com/ru/company/itsumma/news/t/493022/). Если вы можете сгенерировать «отлуп» с неожиданными командами в заголовке, то smtpd выполнит их при попытке повторной доставки.
Как и выше, одна из проблем заключается в том, что наиболее чувствительные части smtpd находятся слишком близко к поверхности атаки. Мне кажется, истинная проблема в том, что smtpd хранит собственные метаданные внутри данных электронной почты. Из-за этого становится возможной атака с рассинхронизацией парсинга. Если бы процитированный ответ с сервера хранился совершенно отдельно от файла с инструкциями по доставке, то чтение за пределами границ не нанесло бы особого вреда.
Эта уязвимость мне кажется показательной, потому что мы здесь видим опасность смешивания данных с разными уровнями доверия. Эту опасность никогда не обсуждали. А она точно есть.
Выводы
======
Конечно, вывод был понятен с самого начала, но мы всё равно об этом скажем.
Думаю, некоторые из этих ошибок помогают продемонстрировать, насколько жизненно важны для безопасности такие принципы, как **удаление устаревших интерфейсов** и **снижение сложности кода**. По большей части, провал произошёл из-за того, что этим принципам не следовали до конца, а не потому, что сами принципы испорчены или несостоятельны. Некоторые вещи ускользают из виду, но я не согласен, что разработчикам необходима какая-то сверхчеловеческая бдительность. Тут легко давать бесполезные советы, типа будь внимательнее, не делай ошибок и git gud [слэнговое геймерское выражение означает 'get good', то есть «поправляйся, выздоравливай» — прим. пер.]. Но я думаю, что у OpenBSD более серьёзные проблемы.
Даже OpenBSD может рискнуть безопасностью ради утилитарной практичности. Вот почему долгое время не вносятся изменения в некоторые устаревшие проекты. Так что, возможно, урок состоит в том, что эффективных принципов нужно придерживаться всегда, а не только тогда, когда это удобно. Хотя зачастую трудно сделать правильный выбор.
Три самые серьёзные уязвимости, auth и две smtpd, более или менее пригодны для эксплуатации только из-за архитектурных проблем, которые выходят за рамки оригинального бага. Они должны были остаться просто мелкими недочётами, которые демонстрируют, что в хорошо защищённой системе не обязательно нужно стремиться к идеальному коду, то есть мелкие ошибки допустимы — и они не повляют на безопасность. Увы, бывает трудно выявить недостатки дизайна в абстрактном виде. И все части системы по отдельности выглядят защищёнными, но если их соединить, то могут появиться слабые места.
Разделение привилегий — ключевой компонент безопасности OpenBSD, а в его основе лежит межпроцессная коммуникация. Есть смысл более пристально присмотреться к тому, какие проблемы могут возникнуть с повреждёнными процессами. Защищённые браузеры всё больше усиляют защиту и затрудняют атаки. В частности, smtpd должен быть защищён от повреждения памяти в сетевых задачах. Но вызывает тревогу та лёгкость, с которой он способен управлять родительским процессом.
Только одну ошибку можно было предотвратить, используя более безопасный язык. Да, наверное, существует какая-то программная идиома, которая в некоторых случаях способна помочь, если следовать ей с религиозным упорством. Но я пока не уверен, что каждый программист по умолчанию корректно закодирует все соответствующие инварианты.
Написание почтового сервера — сложное дело. Особенно если вас поджимают рамки легаси.
---
[](http://miran.ru/) | https://habr.com/ru/post/495120/ | null | ru | null |
# Cocos2d-x — Основные понятия
Предисловие
-----------
Начну с небольшой предыстории. Не так давно, мы с другом решили разработать свою двумерную игру, для дипломного проекта. После того как мы определились с ее жанром и получили примерное представление об игровом процессе, перед нами встал вопрос о выборе движка. Unreal или Unity мы отбросили сразу, так как они показались нам слишком «тяжелыми» инструментами для 2d игры. Cocos2d-x был бы идеальным вариантом, если бы не одна деталь — практически полное отсутствие вводных уроков. Те статьи, что нам удалось найти были, либо не закончены, либо недостаточно подробны. И тогда, я решил перевести официальную документацию, практически без знаний английского и заодно поделится своим переводом с остальными (кто же если не я).
Эта статья представляет собой почти дословный перевод официальной документации к Cocos2d-x. Если вы не хотите разбираться во всяких тонкостях устройства движка, а хотите сразу начать писать свою игру, могу посоветовать вам эту статью: [Cocos2d-x — разработка простой игры](https://habrahabr.ru/post/270133/) .
Если вы еще не установили Cocos2d-x или не можете создать проект, то тут вы найдете подробную инструкцию: [Создание многоплатформенных игр с использованием Cocos2d-x версии 3.0 и выше](https://m.habrahabr.ru/company/intel/blog/260267/).
Оригинальная статья: [Cocos2d-x programmers guide](http://www.cocos2d-x.org/docs/programmers-guide/basic_concepts/index.html).
P.S.: Не советую клонировать cocos2d-x с gitHub. У меня после клонирования не доставало нескольких важных файлов. Но может быть мне просто не повезло.
Приступим!
Основные понятия Cocos2d-x
--------------------------
Эта глава предполагает, что вы только начали ознакомление с Cocos2d-x и уже готовы начать работу над игрой вашей мечты. Не волнуйтесь, будет весело!
Cocos2d-x кросс-платформенный игровой движок. Игровой движок — это программное обеспечение, которое обеспечивает базовый функционал, необходимый всем играм. Вы могли слышать, что это называется API или фреймворк, но в этом руководстве мы будем называть его 'игровым движком'.
Игровые движки включают множество компонентов, которые при совместном использовании повышают скорость разработки и часто работают лучше самодельных библиотек. Игровой движок обычно содержит некоторые или все следующие компоненты: визуализатор, 2d/3d графику, обработчик столкновений, физический движок, звук, анимацию и многое другое. Игровые движки обычно поддерживают несколько платформ, таким образом они упрощают портирование вашей игры на различные устройства.
Поскольку Cocos2d-x является игровым движком, он предоствляет API для разработки кросс-платформенных игр. Благодаря инкапсуляции мощности внутри простого для использования API, вы можете сосредоточится на разработке вашей игры и меньше беспокоиться о технической основе. Cocos2d-x возьмет на себя тяжелую работу.
Cocos2d-x предоставляет следующие объекты: *Scene*, *Transition*, *Sprite*, *Menu*, *Sprite3D*, *Audio* и многие другие. Всё необходимое для создания игры включено.
Main Components
---------------
Это может показаться очень сложным, но начать использовать Cocos2d-x просто. Перед погружением, мы должны понять некоторые концепции используемые в Cocos2d-x. В сердце Cocos2d-x лежат объекты: *Scene*, *Node*, *Sprite*, *Menu* и *Action*. Посмотрите на любую игру и вы увидите все эти компоненты в той или иной форме!
Взгляните сюда. Возможно вы обнаружите схожесть с одной очень популярной игрой:
Давайте посмотрим еще раз, но разделим скриншот на компоненты, используемые для его создания:
Вы можете видеть меню, некоторые спрайты и надписи, все они имеют аналоги в Cocos2d-x. Взгляните на свой собственный концепт игры и посмотрите какие у вас есть компоненты, скорее всего вы обнаружите совпадения.
Director
--------
Cocos2d-x использует концепцию режиссера (*Director*), как в кино! Объект *Director* контролирует поток операций и сообщает всем что делать. Основной задачей режиссера является контроль переходов и замен сцен. *Director* — это базовый singleton (фактически, может существовать только один экземпляр этого класса за раз), который может быть вызван в любом месте вашего кода.
Вот пример типичного игрового потока. *Director* позаботится о его исполнении, в соответствии критериям вашей игры:
Вы являетесь режиссером вашей игры. Вы решаете что, когда и каким образом происходит.
Scene
-----
В своей игре вы, вероятно, хотите видеть главное меню, несколько уровней и завершающую сцену. Как вы всё это и организуете? Как вы догадались, при помощи сцен (*Scene*). Вспомните какой-нибудь понравившийся вам фильм. Вы можете заметить, что он четко разбит на сцены или отдельные части истории. Если мы применим тот же самый подход к играм, мы должны придумать как минимум несколько сцен, независимо от того, насколько простая игра.
Снова взглянем на уже знакомое нам изображение:
Это главное меню и оно является отдельной сценой. Эта сцена состоит из нескольких частей, которые в совокупности дают нам финальный результат. Сцены рисуются при **рендере**. **Рендер** отвечает за отображение спрайтов и других объектов на сцене. Чтобы лучше это понять нам нужно немного поговорить о графе сцены (**scene graph**).
Scene Graph
-----------
Scene graph это структура данных организующая графическую сцену. **Scene graph** содержит *Node* объекты в древовидной (да, это называется графом, но, фактически, представляет собой дерево) структуре.
Я уверен, что вы задаётесь вопросом, почему вы должны думать об этих технических деталях, если Cocos2d-x делает тяжёлую работу за вас? Это действительно важно для понимания того, как сцены отрисовываются в ходе рендера.
Как только вы начинаете добавлять узлы, спрайты и анимации в свою игру, вы хотите быть уверены в том, что на экране отобразится именно то, чего вы ожидали. Но что если этого не произошло? Что если ваши спрайты оказались скрыты за фоном, а вы хотите, чтобы они были спереди? Ничего страшного, просто сделайте шаг назад и пробегитесь по графу сцены на листе бумаги, и я уверен, вы легко найдете свою ошибку.
Поскольку **Scene Graph** является деревом; вы можете его обойти. Cocos2d-x использует **in-order** алгоритм обхода. Вышеупомянутый алгоритм **in-order** начинает обход с левой стороны дерева, затем проходит через корень и завершается в правой части дерева. Поскольку правая сторона дерева рендерится последней, на экране она отображается первой.
Граф сцены легко продемонстрировать, давайте взглянем на нашу игровую сцену:
Она будет отображаться на экране согласно дереву, приведенному ниже:
Еще один момент о котором нужно рассказать — элементы с отрицательным порядком Z (**z-order**) находятся с левой стороны дерева, в то время как элементы с положительным порядком Z находятся с правой стороны. Держите это во внимании при упорядочивании ваших элементов! Конечно, вы можете добавлять элементы в любом порядке, и они автоматически отсортируются исходя из настраиваемого параметра **z-order**.
Основываясь на этой концепции, мы можем подумать о сцене как о коллекции узлов (*Node*). Давайте разобьем сцену на части сверху вниз, чтобы увидеть как **scene graph** использует **z-order** для компоновки сцены:
Фактически, сцена собрана из множества узлов, с различными параметрами **z-order**, сложенных в «стек» друг над другом.
В Cocos2d-x вы строите **scene graph** используя вызов *addChild()*:
```
// Добавление дочернего элемента с z-order равным -2, таким образом
// он идет в левую сторону дерева (потому что z-order отрицательный)
scene->addChild(title_node, -2);
// Если вы не указали z-order, будет использован 0
scene->addChild(label_node);
// Добавление дочернего элемента с z-order равным -2, таким образом
// он пойдет в правую часть дерева (потому что z-order положительный)
scene->addChild(sprite_node, 1);
```
Sprites
-------
Все игры содержат спрайты, и вы, наверняка, уже имеете представление о них. Спрайты представляют собой графические объекты, которые вы перемещаете по экрану. Главный персонаж вашей игры, вероятнее всего, тоже спрайт. Я знаю, вы можете спросить — не каждый графический объект является спрайтом? Нет! Почему? Спрайт является спрайтом, только если вы его перемещаете. Если вы не перемещаете его, то это обычный узел (Node).
Ещё раз взглянем на знакомое изображение, отметим где спрайты а где узлы:
Спрайты важны в каждой игре. При написании платформера, у вас, вероятно, есть главный персонаж, который был создан с использованием какого-либо изображения. Это и есть спрайт.
Спрайты просто создать и они имеют следующие настраиваемые параметры: **position**, **rotation**, **scale**, **opacity**, **color** и другие.
```
// Вот так создается спрайт
auto mySprite = Sprite::create("mysprite.png");
// А так изменяются свойства спрайта
mySprite->setPosition(Vec2(500, 0));
mySprite->setRotation(40);
mySprite->setScale(2.0); // равномерно задает масштаб обеим осям X и Y
mySprite->setAnchorPoint(Vec2(0, 0));
```
Давайте продемонстрируем каждое свойство из данного кода, рассмотрим следующий скриншот:
Если мы зададим позицию используя *mySprite->setPositon(Vec2(500, 0));*:
Узел-спрайт изменил свою позицию с оригинальной на заданную нами.
Если мы сейчас зададим вращение, используя *mySprite->setRotation(40);*:
… вы можете видеть, что спрайт был повернут на величину, которая была указана.
Если мы сейчас зададим новый масштаб используя mySprite->setScale(2. 0);:
Снова, мы можем видеть, что спрайт изменился в соответствии с кодом.
Наконец, все узлы (поскольку Sprite является подклассом Node) имеют опорную точку (**anchor point**). Мы еще не говорили об этом, так что сейчас самое время. Вы можете думать о опорной точке как о способе определения, какая часть спрайта будет использоваться как базовая координата, при задании позиции.
Зададим опорную точку для персонажа нашей игры, используя следующий вызов:
```
mySprite->setAnchorPoint(Vec2(0, 0));
```
Это приведет к тому, что нижний левый угол нашего спрайта станет использоваться как базис для каждого вызова **setPosition()**. Давайте взглянем на несколько таких примеров в действии:
  
Обратите внимание на красную точку в каждом изображении. Эта красная метка иллюстрирует, где находится опорная точка!
Как вы могли заметить, опорная точка очень полезна при позиционировании узлов. Вы даже можете регулировать опорную точку динамически, для симуляции эффектов в вашей игре.
Actions
-------
Создание сцены и добавление спрайтов на экран — это только часть того, что нам необходимо сделать. Чтобы сделать игру, нам необходимо заставить вещи двигаться! **Action** объекты являются основной частью каждой игры. Действия (**Action**) позволяют трансформировать Node объекты во времени. Хотите двигать спрайт из одной точки в другую? Нет проблем! Вы даже можете создать последовательность (**Sequence**) действий, которые будут выполнены на узле. Вы можете менять параметры узла такие как **position**, **rotation** и **scale**. Примеры действий: **MoveBy**, **Rotate**, **Scale**.
Сейчас мы продемонстрируем работу действий:
… и через 5 секунд спрайт переместится в новое положение:
**Action** объекты создавать легко:
```
auto mySprite = Sprite::create("Blue_Front1.png");
// Двигаем спрайт на 50 пикселей вправо и 10 пикселей вверх за 2 секунды
auto moveBy = MoveBy::create(2, Vec2(50,10));
mySprite->runAction(moveBy);
// Двигаем спрайт в заданную локацию в течении двух секунд.
auto moveTo = MoveTo::create(2, Vec2(50,10));
mySprite->runAction(moveTo);
```
Sequence и Spawn
----------------
С движущимися по экрану спрайтами мы имеем все необходимое, для создания нашей игры, верно? Не вполне. Как же запустить несколько действий? Cocos2d-x реализует это, несколькими путями.
**Sequence** — это множество действий, запускаемых в определенном порядке. Нужно запустить последовательность в обратном порядке? Нет проблем, Cocos2d-x реализует это без дополнительной работы.
Взглянем на следующий пример последовательности для постепенного движения спрайта:
Эту последовательность легко создать:
```
auto mySprite = Node::create();
// двигается в точку 50, 10 за 2 секунды
auto moveTo1 = MoveTo::create(2, Vec2(50,10));
// сдвигается относительно текущей позиции на 100, 10 за 2 секунды
auto moveBy1 = MoveBy::create(2, Vec2(100,10));
// двигается в точку 150, 10 за 2 секунды
auto moveTo2 = MoveTo::create(2, Vec2(150,10));
// создаем задержку
auto delay = DelayTime::create(1);
mySprite->runAction(Sequence::create(moveTo1, delay, moveBy1, delay.clone(),
moveTo2, nullptr));
```
Этот пример запускает последовательность, по порядку, но как запустить все указанные действия одновременно? Такая возможность тоже есть в Cocos2d-x, это называется Spawn. Spawn будет принимать все указанные действия и запускать их одновременно. Некоторые могут быть длиннее других, в таком случае все они не будут закончены в одно время.
```
auto myNode = Node::create();
auto moveTo1 = MoveTo::create(2, Vec2(50,10));
auto moveBy1 = MoveBy::create(2, Vec2(100,10));
auto moveTo2 = MoveTo::create(2, Vec2(150,10));
myNode->runAction(Spawn::create(moveTo1, moveBy1, moveTo2, nullptr));
```
Родители, дети и их связь
-------------------------
Cocos2d-x использует принцип наследования свойств родителей и детей. Это означает, что изменения родительского узла применяются и к дочерним элементам. Рассмотрим один спрайт, который имеет наследников:
Изменение вращения родителя так же изменяет вращение всех детей:
```
auto myNode = Node::create();
// задаем вращение
myNode->setRotation(50);
```
По аналогии с вращением, если вы измените масштаб родителя, наследникам так же будет задан новый масштаб:
```
auto myNode = Node::create();
// масштабирование
myNode->setScale(2.0); // увеличиваем в 2 раза
```
Не все изменения родителя отражаются на детях. Изменения родительской опорной точки влияет только на операции трансформации (scale, position, rotate, skew и так далее ...) и не влияет на позиционирование наследников. Фактически, дети всегда будут добавляться в нижний-левый (0,0) угол родителя.
Logining как способ вывода сообщений
------------------------------------
Иногда, когда ваше приложение запущено, вы можете захотеть увидеть сообщение, выведенное в консоль, для информации или отладочных целей. Реализуется движком, с помощью использования log().
```
// простая строка
log("This would be outputted to the console");
// переменная string
string s = "My variable";
log("string is %s", s);
// double
double dd = 42;
log("double is %f", dd);
// integer
int i = 6;
log("integer is %d", i);
// float
float f = 2.0f;
log("float is %f", f);
// bool
bool b = true;
if (b == true)
log("bool is true");
else
log("bool is false");
```
Если вы предпочитаете **std::cout**, то можете использовать его вместо **log()**, однако **log()** мог бы предоставить упрощенное форматирование сложного вывода.
Вывод
-----
Мы разобрали множество понятий Cocos2d-x. Можете глубоко вздохнуть. Не волнуйтесь. Просто погрузитесь в свои идеи и реализуйте их, шаг за шагом. Cocos2d-x и программирование не являются навыками, которые изучаются за одну ночь. Они требуют практики и понимания. Помните, что форумы так же помогут ответить на ваши вопросы.
От переводчика
--------------
Возможно, многое из этой статьи вам уже было известно. Но это была лишь вводная часть из серии уроков по cocos2d-x. В дальнейшем, я буду продолжать переводить новые статьи и выкладывать их сюда, если это будет кому-то интересно.
Продолжение: [Cocos2d-x — Работа со спрайтами](https://habrahabr.ru/post/339690/) | https://habr.com/ru/post/339564/ | null | ru | null |
# Custom view на Compose
Всем привет, меня зовут Николай Широбоков, я — Android-разработчик в e-legion.
В июле Google выпустил стабильную версию Compose. Это вызвало большой интерес в сообществе. Все вокруг стали поговаривать, что эта технология захватит Android-разработку, и скоро все будут писать на Compose.
Я принялся за изучение, заглянул на developer.android.com и нашел различные туториалы по использованию этой библиотекой, но не увидел примеров, как можно создавать кастомные view. Поэтому решил попробовать сделать это и поделиться с вами результатом.
В этой статье покажу, как можно реализовать рыночный график со скроллом и зумом на Compose.
Рисуем свечи
------------
Перед тем, как что-то нарисовать, нужно создать модель.
```
class Candle(
val time: LocalDateTime,
val open: Float,
val close: Float,
val high: Float,
val low: Float
)
```
Список со свечками я создал, скачав и распарсив файл с Финама. Это не самое интересное, поэтому останавливаться на этом не буду. Если интересно, смотрите код [тут](https://github.com/ShirobokovNE/MarketChart).
Для того, чтобы код был чище и лучше читался, сделал класс MarketChartState. В нем буду хранить состояние графика.
```
class MarketChartState {
// общий список свечей
private var candles = listOf()
// видимое количество свечей
private var visibleCandleCount by mutableStateOf(60)
// размеры области для рисования
private var viewWidth = 0f
private var viewHeight = 0f
// минимальная и максимальная цены видимых свечей
private val maxPrice by derivedStateOf { visibleCandles.maxOfOrNull { it.high } ?: 0f }
private val minPrice by derivedStateOf { visibleCandles.minOfOrNull { it.low } ?: 0f }
// видимые на экране свечи
val visibleCandles by derivedStateOf {
if (candles.isNotEmpty()) {
candles.subList(
0,
visibleCandleCount
)
} else {
emptyList()
}
}
fun setViewSize(width: Float, height: Float) {
viewWidth = width
viewHeight = height
}
// отступ от левого края экрана
fun xOffset(candle: Candle) =
viewWidth \* visibleCandles.indexOf(candle).toFloat() / visibleCandleCount.toFloat()
// отступ от верхнего края экрана
fun yOffset(value: Float) = viewHeight \* (maxPrice - value) / (maxPrice - minPrice)
}
```
derivedStateOf() создает State, значение для которого вычисляется лямбде. Это значение кешируется, и каждый новый подписчик получает уже закешированное значение. Если в лямбде используется другой State, то при его изменении значение будет пересчитано.
**Пример.** В лямбде visibleCandles используется visibleCandleCount. При изменении visibleCandleCount значение visibleCandles пересчитается.
Для рисования графика обратился к Composable функции Canvas. В ней есть доступ к DrawScope, в котором можно рисовать линии, прямоугольники, овалы и другие различные элементы.
```
Canvas(
modifier = Modifier
.fillMaxSize()
.background(Color(0xFF182028))
) {
// из общей ширины и высоты вычел захардкоженные значения,
// чтобы в освободившейся области рисовать дату и цену.
val chartWidth = size.width - 128.dp.value
val chartHeight = size.height - 64.dp.value
state.setViewSize(chartWidth, chartHeight)
// горизонтальная линия
drawLine(
color = Color.White,
strokeWidth = 2.dp.value,
start = Offset(0f, chartHeight),
end = Offset(chartWidth, chartHeight)
)
// вертикальная линия
drawLine(
color = Color.White,
strokeWidth = 2.dp.value,
start = Offset(chartWidth, 0f),
end = Offset(chartWidth, chartHeight)
)
// отрисовка свечей
state.visibleCandles.forEach { candle ->
val xOffset = state.xOffset(candle)
drawLine(
color = Color.White,
strokeWidth = 2.dp.value,
start = Offset(xOffset, state.yOffset(candle.low)),
end = Offset(xOffset, state.yOffset(candle.high))
)
if (candle.open > candle.close) {
drawRect(
color = Color.Red,
topLeft = Offset(xOffset - 6.dp.value, state.yOffset(candle.open)),
size = Size(12.dp.value, state.yOffset(candle.close) - state.yOffset(candle.open))
)
} else {
drawRect(
color = Color.Green,
topLeft = Offset(xOffset - 6.dp.value, state.yOffset(candle.close)),
size = Size(12.dp.value, state.yOffset(candle.open) - state.yOffset(candle.close))
)
}
}
}
```
График, после запуска приложения:
Линии цен
---------
Добавлю 9 ценовых линий. Линии будут располагаться на равном удалении друг от друга по всему экрану.
Изменения в стейте.
```
val priceLines by derivedStateOf {
val priceItem = (maxPrice - minPrice) / 10
mutableListOf().apply {
repeat(10) { if (it > 0) add(maxPrice - priceItem \* it) }
}
}
```
В функции Canvas нарисую линии и текст. В DrawScope нет возможности рисовать текст, поэтому воспользуюсь расширением drawIntoCanvas, в котором можно получить доступ к Canvas к тому самому, который используется для рисования во View, и уже на нем нарисую текст.
```
state.priceLines.forEach { value: Float ->
val yOffset = state.yOffset(value)
val text = decimalFormat.format(value)
drawLine(
color = Color.White,
strokeWidth = 1.dp.value,
start = Offset(0f, yOffset),
end = Offset(chartWidth, yOffset),
pathEffect = PathEffect.dashPathEffect(intervals = floatArrayOf(10f, 20f), phase = 5f)
)
drawIntoCanvas {
textPaint.getTextBounds(text, 0, text.length, bounds)
val textHeight = bounds.height()
it.nativeCanvas.drawText(
text,
chartWidth + 8.dp.value,
yOffset + textHeight / 2,
textPaint
)
}
}
```
Масштабирование
---------------
Для этого воспользуюсь готовым решением из библиотеки и добавлю функцию расширение Modifier.transformable к Modifier в Canvas.
```
Canvas(
modifier = Modifier
.fillMaxSize()
.background(Color(0xFF182028))
.transformable(state.transformableState)
)
```
В стейте вызову функцию TransformableState и передам туда лямбду, в которой буду пользоваться только переменной для зума.
```
val transformableState = TransformableState { zoomChange, _, _ ->
visibleCandleCount = (visibleCandleCount / zoomChange).roundToInt()
}
```
Так как в стейте переменные maxPrice и minPrice зависят от видимых свечек, они сразу пересчитываются и также пересчитываются значения в priceLines.
Временные линии
---------------
Теперь буду добавлять на график временные линии и их расположение в зависимости от зума.
Изменения в стейте.
```
// количество свечек между временными линиями
private var candleInGrid = Float.MAX_VALUE
// временные линии
var timeLines by mutableStateOf(listOf())
// вычисления линий
fun calculateGridWidth() {
val candleWidth = viewWidth / visibleCandleCount
val currentGridWidth = candleInGrid \* candleWidth
when {
currentGridWidth < MIN\_GRID\_WIDTH -> {
candleInGrid = MAX\_GRID\_WIDTH / candleWidth
timeLines.value = candles.filterIndexed { index, \_ -> index % candleInGrid.roundToInt() == 0 }
}
currentGridWidth > MAX\_GRID\_WIDTH -> {
candleInGrid = MIN\_GRID\_WIDTH / candleWidth
timeLines.value = candles.filterIndexed { index, \_ -> index % candleInGrid.roundToInt() == 0 }
}
}
}
```
Изменения в функции Canvas.
```
state.timeLines.forEach { candle ->
val offset = state.xOffset(candle)
if (offset !in 0f..chartWidth) return@forEach
drawLine(
color = Color.White,
strokeWidth = 1.dp.value,
start = Offset(offset, 0f),
end = Offset(offset, chartHeight),
pathEffect = PathEffect.dashPathEffect(intervals = floatArrayOf(10f, 20f), phase = 5f)
)
drawIntoCanvas {
val text = candle.time.format(timeFormatter)
textPaint.getTextBounds(text, 0, text.length, bounds)
val textHeight = bounds.height()
val textWidth = bounds.width()
it.nativeCanvas.drawText(
text,
offset - textWidth / 2,
chartHeight + 8.dp.value + textHeight,
textPaint
)
}
}
```
Скролл
------
График почти готов, осталось добавить скролл. Снова воспользуюсь готовым решением и добавлю функцию расширение Modifier.scrollable к Modifier в Canvas.
```
Canvas(
modifier = Modifier
.fillMaxSize()
.background(Color(0xFF182028))
.scrollable(state.scrollableState, Orientation.Horizontal)
.transformable(state.transformableState)
)
```
Изменения в стейте.
```
private val scrollOffset by mutableStateOf(0f)
val scrollableState = ScrollableState {
scrollOffset = if (it > 0) {
(scrollOffset - it.scrolledCandles).coerceAtLeast(0f)
} else {
(scrollOffset - it.scrolledCandles).coerceAtMost(candles.lastIndex.toFloat())
}
it
}
// преобразование проскроленного расстояния в проскроленные свечки
private val Float.scrolledCandles: Float
get() = this * visibleCandleCount.toFloat() / viewWidth
// видимые свечи
val visibleCandles by derivedStateOf {
if (candles.isNotEmpty()) {
candles.subList(
scrollOffset.roundToInt().coerceAtLeast(0),
(scrollOffset.roundToInt() + visibleCandleCount).coerceAtMost(candles.size)
)
} else {
emptyList()
}
}
```
Сохраняем состояние
-------------------
График готов, но при повороте экрана стейт пересоздается. Для сохранения состояния обернул стейт в rememberSaveable и написал Saver.
```
rememberSaveable(saver = MarketChartState.Saver) { MarketChartState.getState(candles) }
val Saver: Saver = listSaver(
save = { listOf(it.candles, it.scrollOffset, it.visibleCandleCount) },
restore = {
getState(
candles = it[0] as List,
visibleCandleCount = it[2] as Int,
scrollOffset = it[1] as Float
)
}
)
```
Код этого примера можно найти по этой [ссылке](https://github.com/ShirobokovNE/MarketChart).
Compose оставил у меня только положительные впечатления, и я уверен, что этот подход захватит Android-разработку.
Всем добра и крутых экранов с Compose. | https://habr.com/ru/post/588657/ | null | ru | null |
# Разработка мобильной 2D-игры «Составь слова из слова»
Как-то обычным летним вечером ехал домой с работы в метро и увидел у одного парня игру на планшете, где нужно составлять слова из букв. Скачал ее на свой планшет и начал играть. Поиграв какое-то время, понял, что некоторые особенности можно было бы реализовать поудобнее, и решив, что я могу сделать игрушку минимум не хуже, принялся за реализацию.
### Работа со словарями
Имея некоторый опыт работы с БД Oracle, решил что обработку словарей буду вести в ней (Oracle 11.2 XE). Накачал в интернете несколько словарей в виде текстовых файлов с разделителями и с помощью механизма External Table загрузил в БД. Из загруженных слов отобрал 700 существительных длиной 8-10 букв. Это как раз и будут те слова, из букв которых игроки будут вести составление. Далее необходимо для каждого из этих 700 слов подобрать набор слов, которые можно из него составить. Для этого нужно проиндексировать все слова, чтобы можно было делать поиск по вхождению букв.
Создаем вью поверх таблицы со словами:
```
create or replace view words_parsed_v as
select word,
regexp_count(word, 'а') as а,
regexp_count(word, 'б') as б,
regexp_count(word, 'в') as в,
regexp_count(word, 'г') as г,
regexp_count(word, 'д') as д,
regexp_count(word, 'е') as е,
regexp_count(word, 'ж') as ж,
regexp_count(word, 'з') as з,
regexp_count(word, 'и') as и,
regexp_count(word, 'й') as й,
regexp_count(word, 'к') as к,
regexp_count(word, 'л') as л,
regexp_count(word, 'м') as м,
regexp_count(word, 'н') as н,
regexp_count(word, 'о') as о,
regexp_count(word, 'п') as п,
regexp_count(word, 'р') as р,
regexp_count(word, 'с') as с,
regexp_count(word, 'т') as т,
regexp_count(word, 'у') as у,
regexp_count(word, 'ф') as ф,
regexp_count(word, 'х') as х,
regexp_count(word, 'ц') as ц,
regexp_count(word, 'ч') as ч,
regexp_count(word, 'ш') as ш,
regexp_count(word, 'щ') as щ,
regexp_count(word, 'ъ') as ъ,
regexp_count(word, 'ы') as ы,
regexp_count(word, 'ь') as ь,
regexp_count(word, 'э') as э,
regexp_count(word, 'ю') as ю,
regexp_count(word, 'я') as я
from words;
-- вытащим 5 строк для примера
select * from words_parsed_v where rownum <= 5;
```
| word | а | б | в | г | д | е | ж | з | и | й | к | л | м | н | о | п | р | с | т | у | ф | х | ц | ч | ш | щ | ъ | ы | ь | э | ю | я |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| аквариум | 2 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| акварель | 2 | 0 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 |
| траншея | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| генерал | 1 | 0 | 0 | 1 | 0 | 2 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| диплом | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
Далее с использованием этой вью делается нехитрый алгоритм поиска "вложенных" слов для каджого "главного" слова.
Стоит отметить, что кроме автоматической обработки так же не обошлось и без ручного труда по фильтрации всех частей речи, кроме существительных, правка орфографических ошибок и т.д.
### Взаимодействие с online-словарями
Так как не для всех слов в словарях было толкование, то и тут пришлось извращаться. Написал процедуру, которая с неким интервалом обращается к онлайн словарям и вытягивает описание. Понять логику работы процедуры поможет простейший пример:
```
create or replace function get_url_dic_academic(p_word varchar2) return varchar2 as
begin
return 'http://dic.academic.ru/searchall.php?SWord=' || p_word || '&from=xx&to=ru&did=&stype=';
end;
/
select httpuritype(get_url_dic_academic('биология')).GetClob() as rst
from dual;
```
Результат последнего запрос спрятан под спойлер. Его обработкой занимается написанный мною парсер с использованием регулярных выражений, код которого приводить здесь я не вижу смысла.
**Результат запроса rst**
```
Словари и энциклопедии на Академике
var googletag = googletag || {};
googletag.cmd = googletag.cmd || [];
(function() {
var gads = document.createElement('script');
gads.async = true;
gads.type = 'text/javascript';
var useSSL = 'https:' == document.location.protocol;
gads.src = (useSSL ? 'https:' : 'http:') +
'//www.googletagservices.com/tag/js/gpt.js';
var node = document.getElementsByTagName('script')[0];
node.parentNode.insertBefore(gads, node);
})();
// --== Google DFP ==--
googletag.cmd.push(function() {
googletag.defineSlot('/59581491/top\_bnr', [[728, 90], [970, 90]], 'div-gpt-ad-topline').addService(googletag.pubads());
googletag.defineSlot('/59581491/right-top', [240, 400], 'div-gpt-ad-right-top').addService(googletag.pubads());
//googletag.defineSlot('/59581491/right\_bnr', [240, 400], 'div-gpt-ad-right-1').addService(googletag.pubads());
//googletag.defineSlot('/59581491/right\_bnr', [240, 400], 'div-gpt-ad-right-2').addService(googletag.pubads());
// Установим переменные таргетинга для всей страницы
googletag.pubads().setTargeting("lang", "ru"); // ru, en, de, es, fr
googletag.pubads().setTargeting("pageType", "search"); // main, article, search, book, contents
googletag.pubads().setTargeting("segment", ""); // Рекламный сегмент
googletag.pubads().collapseEmptyDivs();
googletag.pubads().enableSingleRequest();
googletag.enableServices();
});
div.hidden,#TerminsNavigationBar,#ad\_bottom,#ad\_right,#ad\_top,#ad\_top2,#contextmenu,#dic-query,#footer ul+div,#lang,#langbar,#logo img.h,#restrictions,#search-box .translate-lang,#search-tabs,#sharemenu,#t-direction-head,#top-menu,#translate-arrow,.smm,div.autosuggest{display:none}p,ul{list-style-type:none;margin:0 0 15px}ul li{margin-bottom:6px}.content ul{list-style-type:disc}\*{padding:0;margin:0}body,html{height:100%}body{padding:0;margin:0;color:#000;font:14px Helvetica,Arial,Tahoma,sans-serif;background:#fff;line-height:1.5em}a{color:#0d44a0;text-decoration:none}h1{font-size:24px;margin:0 0 18px}h2{font-size:20px;margin:0 0 14px}h3{font-size:16px;margin:0 0 10px}h1 a,h2 a{color:#454545!important}#page{margin:0 auto;min-height:100%;position:relative;padding-top:105px;width:745px;padding-right:255px}\* html #page{height:100%}#header{position:relative;height:122px}#logo{float:left;margin-top:21px;width:125px}#logo a.img{width:90px;margin:0 0 0 16px}#logo a.img.logo-en{margin-left:13px}#logo a{display:block;font-size:12px;text-align:center;word-break:break-all}#site-title{padding-top:35px;margin:0 0 5px 135px}#site-title a{color:#000;font-size:18px;font-style:italic;display:block;font-weight:400}#search-box{margin-left:135px;border-top-right-radius:3px;border-bottom-right-radius:3px;padding:4px;position:relative;background:#abcf7e;min-height:33px}#search-box.dic{background:#896744}#search-box table{border-spacing:0;border-collapse:collapse;width:100%}#search-box table td{padding:0;vertical-align:middle}#search-box table td:first-child{padding-right:3px}#search-box table td:last-child{width:1px}#dic-query,#search-query,.translate-lang{padding:6px;font-size:16px;border:1px solid #949494;width:100%;box-sizing:border-box;height:32px;margin:0;background:#fff;float:left;border-radius:0!important}#search-button{width:70px;height:32px;text-align:center;border:1px solid #7a8e69;border-radius:3px;background:#e0e0e0}#search-tabs{display:block;margin:0 15px 0 135px;padding:0;list-style-type:none}#search-tabs li{float:left;min-width:70px;max-width:140px;padding:0 15px;height:23px;line-height:23px;background:#bde693;text-align:center;margin-right:1px}#search-box.dic+#search-tabs li{background:#C9A784}#search-tabs li:last-child{border-bottom-right-radius:3px}#search-tabs li a{color:#353535;font-style:italic;font-size:12px;display:block;white-space:nowrap;text-overflow:ellipsis;overflow:hidden}#search-tabs li.active{height:22px;line-height:23px;position:relative;background:#abcf7e;border-bottom-left-radius:3px;border-bottom-right-radius:3px}#search-box.dic+#search-tabs li.active{background:#896744}#search-tabs li.active a{color:#fff}#content{clear:both;margin:30px 0;padding-left:15px}#content a{text-decoration:underline}#content .breadcrumb{margin-bottom:20px}#search\_links,#search\_sublinks{margin-bottom:8px;margin-left:-8px}#search\_links a,#search\_sublinks a{padding:3px 8px 1px;border-radius:2px}#search\_links a.active,#search\_sublinks a.active{color:#000!important;background:#bde693;text-decoration:none!important}.term{color:#8b4513}@media (max-width:767px){.hideForMobile{display:none}#header{height:auto}#page{padding:5px;width:auto}#logo{float:none;width:144px;text-align:left;margin:0;padding-top:5px}#logo a{height:44px;overflow:hidden;text-align:left}#logo img.h{display:initial;width:144px;height:44px}#logo img.v{display:none}#site-title{padding:0;margin:10px 0 5px}#search-box,#search-tabs{clear:both;margin:0;width:auto;padding:4px}#search-box.translate #search-query{width:100%;margin-bottom:4px}#search-box.translate #td-search{overflow:visible;display:table-cell}ul#search-tabs{white-space:nowrap;margin-top:5px;overflow-x:auto;overflow-y:hidden}ul#search-tabs li,ul#search-tabs li.active{background:0 0!important;box-shadow:none;min-width:0;padding:0 5px;float:none;display:inline-block}ul#search-tabs li a{border-bottom:1px dashed green;font-style:normal;color:green;font-size:16px}ul#search-tabs li.active a{color:#000;border-bottom-color:#fff;font-weight:700}ul#search-tabs li a:hover,ul#search-tabs li.active a:hover{color:#000}#content{margin:15px 0}}#search\_results{margin-left:23px}.terms-list .item{float:left;margin:2px 0 0 -108px;position:relative;width:100px;color:#898989;font-size:11px;text-align:right}
<!--
yandex\_site\_charset = 'UTF-8';
// Размер шрифтов
var yandex\_ad\_fontSize = 1;
// Настройки объявлений Директа
var yandex\_direct\_fontColor = '000000';
var yandex\_direct\_titleColor = '0000CC';
var yandex\_direct\_siteurlColor = '006600';
var yandex\_direct\_linkColor = '0000CC';
function yandex\_direct\_print(){ }
// Настройки объявлений Маркета
var yandex\_market\_fontColor = '000000';
// var yandex\_market\_BorderColor = 'E3D8F4';
var yandex\_market\_BorderColor = 'FFFFFF'; // 'E3D8F4';
var yandex\_market\_BgColor = 'FFFFFF'; // 'F5F1FB';
var yandex\_market\_headerBgColor = 'FFFFFF';
var yandex\_market\_catColor = '777278';
var yandex\_market\_offerlinkColor = '0B57AC';
var yandex\_market\_linkColor = '0B57AC';
function yandex\_market\_print(){ }
// Настройки Спец. размещения
var yandex\_premium\_fontColor = '000000';
var yandex\_premium\_titleColor = '0000CC';
var yandex\_premium\_siteurlColor = '006600';
function yandex\_premium\_print(){ }
var yandex\_r = Math.round(Math.random() \* 100000);
//-->
(adsbygoogle = window.adsbygoogle || []).push({
google\_ad\_client: "ca-pub-8594606551930257",
enable\_page\_level\_ads: true
});
(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','ga');
ga('create', 'UA-2754246-1', 'auto');
ga('require', 'displayfeatures');
// ga('set', 'dimension1', '');
ga('set', 'dimension2', 'search');
// ga('set', 'campaignKeyword', dimensionValue1);
ga('send', 'pageview', {'dimension1':''});
if(typeof(console) == 'undefined' ) console = {};
if(typeof(console.log) == 'undefined' ) console.log = function(){};
if(typeof(console.warn) == 'undefined' ) console.warn = function(){};
if(typeof(console.error) == 'undefined' ) console.error = function(){};
if(typeof(console.time) == 'undefined' ) console.time = function(){};
if(typeof(console.timeEnd) == 'undefined' ) console.timeEnd = function(){};
Academic = {};
Academic.sUserLanguage = 'ru';
Academic.sDomainURL = '';
Academic.sMainDomainURL = 'http://dic.academic.ru/';
Academic.sTranslateDomainURL = 'http://translate.academic.ru/';
Academic.Lang = {};
Academic.Lang.sTermNotFound = 'Термин, отвечающий запросу, не найден';
[
dic.academic.ru](http://dic.academic.ru)
* [RU](#)
+ [EN](http://www.enacademic.com)
+ [DE](http://www.deacademic.com)
+ [FR](http://www.fracademic.com)
+ [ES](http://www.esacademic.com)
* [Запомнить сайт](#)
* [Словарь на свой сайт](http://partners.academic.ru/partner_proposal.php)
[Словари и энциклопедии на Академике](http://dic.academic.ru)
---------------------------------------------------------------
| | |
| --- | --- |
|
Все языкиАбхазскийАдыгейскийАзербайджанскийАймараАйнский языкАканАлбанскийАлтайскийАнглийскийАрабскийАрагонскийАрмянскийАрумынскийАстурийскийАфрикаансБагобоБаскскийБашкирскийБелорусскийБолгарскийБурятскийВаллийскийВарайскийВенгерскийВепсскийВерхнелужицкийВьетнамскийГаитянскийГреческийГрузинскийГуараниГэльскийДатскийДолганскийДревнерусский языкИвритИдишИнгушскийИндонезийскийИнупиакИрландскийИсландскийИспанскийИтальянскийЙорубаКазахскийКарачаевскийКаталанскийКвеньяКечуаКиргизскийКитайскийКлингонскийКомиКорейскийКриКрымскотатарскийКумыкскийКурдскийКхмерскийЛатинскийЛатышскийЛингалаЛитовскийЛюксембургскийМайяМакедонскийМалайскийМаньчжурскийМаориМарийскийМикенскийМокшанскийМонгольскийНауатльНемецкийНидерландскийНогайскийНорвежскийОрокскийОсетинскийОсманскийПалиПапьяментоПенджабскийПерсидскийПольскийПортугальскийРумынский, МолдавскийРусскийСанскритСеверносаамскийСербскийСефардскийСилезскийСловацкийСловенскийСуахилиТагальскийТаджикскийТайскийТатарскийТвиТибетскийТофаларскийТувинскийТурецкийТуркменскийУдмурдскийУзбекскийУйгурскийУкраинскийУрдуУрумскийФарерскийФинскийФранцузскийХиндиХорватскийЦерковнославянский (Старославянский)ЧаморроЧеркесскийЧерокиЧеченскийЧешскийЧувашскийШайенскогоШведскийШорскийШумерскийЭвенкийскийЭльзасскийЭрзянскийЭсперантоЭстонскийЮпийскийЯкутскийЯпонский
Все языкиАбхазскийАварскийАдыгейскийАзербайджанскийАймараАйнский языкАлбанскийАлтайскийАнглийскийАрабскийАрмянскийАфрикаансБаскскийБашкирскийБелорусскийБолгарскийВенгерскийВепсскийВодскийВьетнамскийГаитянскийГалисийскийГреческийГрузинскийДатскийДревнерусский языкИвритИдишИжорскийИнгушскийИндонезийскийИрландскийИсландскийИспанскийИтальянскийЙорубаКазахскийКарачаевскийКаталанскийКвеньяКечуаКитайскийКлингонскийКорейскийКрымскотатарскийКумыкскийКурдскийКхмерскийЛатинскийЛатышскийЛингалаЛитовскийЛожбанМайяМакедонскийМалайскийМальтийскийМаориМарийскийМокшанскийМонгольскийНемецкийНидерландскийНорвежскийОсетинскийПалиПапьяментоПенджабскийПерсидскийПольскийПортугальскийПуштуРумынский, МолдавскийРусскийСербскийСловацкийСловенскийСуахилиТагальскийТаджикскийТайскийТамильскийТатарскийТурецкийТуркменскийУдмурдскийУзбекскийУйгурскийУкраинскийУрдуУрумскийФарерскийФинскийФранцузскийХиндиХорватскийЦерковнославянский (Старославянский)ЧаморроЧерокиЧеченскийЧешскийЧувашскийШведскийШорскийЭвенкийскийЭльзасскийЭрзянскийЭсперантоЭстонскийЯкутскийЯпонский
| Найти! |
* [Толкования](#)
* [Переводы](#)
* [Книги](#)
var between\_type="adj";document.write('<script type = "text/javascript" src = "http://cache.betweendigital.com/sections/149534.js"></scr'+'ipt>')
биология
========
Толкование
[Перевод](http://translate.academic.ru/биология/ru/)
[Книги](/searchall.php?SWord=%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F&stype=10)
[Фильмы](/searchall.php?SWord=%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F&stype=11)
* 1 **[БИОЛОГИЯ](http://big_medicine.academic.ru/2478/%D0%91%D0%98%D0%9E%D0%9B%D0%9E%D0%93%D0%98%D0%AF)** — БИОЛОГИЯ. Содержание: I. История биологии.............. 424 Витализм и машинизм. Возникновение эмпирических наук в XVI XVIII вв. Возникновение и развитие эволюционной теории. Развитие физиологии в XIX в. Развитие клеточного учения. Итоги XIX века …
[Большая медицинская энциклопедия](http://big_medicine.academic.ru/)
* 2 **[БИОЛОГИЯ](http://dic.academic.ru/dic.nsf/dic_fwords/7704/%D0%91%D0%98%D0%9E%D0%9B%D0%9E%D0%93%D0%98%D0%AF)** — (греч., от bios жизнь, и logos слово). Наука о жизни и ее проявлениях у животных и растений. Словарь иностранных слов, вошедших в состав русского языка. Чудинов А.Н., 1910. БИОЛОГИЯ греч., от bios, жизнь, и logos, слово. Учение о жизненной силе.… …
[Словарь иностранных слов русского языка](http://dic.academic.ru/contents.nsf/dic_fwords/)
* 3 **[БИОЛОГИЯ](http://dic.academic.ru/dic.nsf/dic_biology/627/%D0%91%D0%98%D0%9E%D0%9B%D0%9E%D0%93%D0%98%D0%AF)** — (от био... и ...логия), совокупность наук о живой природе. Предмет Б. все проявления жизни: строение и функции живых существ и их природных сообществ, распространение, происхождение и развитие, связи друг с другом и с неживой природой. Задачи Б.… …
[Биологический энциклопедический словарь](http://dic.academic.ru/contents.nsf/dic_biology/)
* 4 **[БИОЛОГИЯ](http://dic.academic.ru/dic.nsf/enc3p/72882)** — (от био... и ...логия) совокупность наук о живой природе об огромном многообразии вымерших и ныне населяющих Землю живых существ, их строении и функциях, происхождении, распространении и развитии, связях друг с другом и с неживой природой.… …
[Большой Энциклопедический словарь](http://dic.academic.ru/contents.nsf/enc3p/)
* 5 **[Биология](http://illustrated_dictionary.academic.ru/1345/%D0%91%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F)** — (от био... и ...логия), совокупность наук о живой природе. Биология изучает строение и функции организмов и их сообществ, происхождение, распространение, развитие, связи организмов друг с другом и с неживой природой. Биология устанавливает… …
[Иллюстрированный энциклопедический словарь](http://illustrated_dictionary.academic.ru/)
* 6 **[биология](http://epistemology_of_science.academic.ru/79/%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F)** — БИОЛОГИЯ (от греч. bio жизнь и logos слово, учение) совокупность наук о жизни во всем разнообразии проявления ее форм, свойств, связей и отношений на Земле. Впервые термин был предложен одновременно и независимо друг от друга в 1802… …
[Энциклопедия эпистемологии и философии науки](http://epistemology_of_science.academic.ru/)
* 7 **[БИОЛОГИЯ](http://dic.academic.ru/dic.nsf/ecolog/2771/%D0%91%D0%98%D0%9E%D0%9B%D0%9E%D0%93%D0%98%D0%AF)** — (от био... и ..логия), совокупность наук о живой природе. Предметом изучения биологии является жизнь во всех ее проявлениях. Термин “биология” предложили Ж. Б. Ламарк и Г. Р. Тревиранус независимо друг от друга (1802). Экологический… …
[Экологический словарь](http://dic.academic.ru/contents.nsf/ecolog/)
* 8 **[биология](http://gallicismes.academic.ru/6493/%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F)** — и, ж. biologie f. 1. Комплекс научных дисциплин о живой природе, о закономерностях органической жизни. БАС 2. Ему < Антуану Батисту Пьеру Антуану де Моне шевалье де Ламарк>.. принадлежала заслуга введения в научный обиход самого термина… …
[Исторический словарь галлицизмов русского языка](http://gallicismes.academic.ru/)
* 9 **[БИОЛОГИЯ](http://dic.academic.ru/dic.nsf/ntes/492/%D0%91%D0%98%D0%9E%D0%9B%D0%9E%D0%93%D0%98%D0%AF)** — БИОЛОГИЯ, наука о жизни и живых организмах. К ней относятся ботаника, зоология, экология, физиология, цитология, генетика, таксономия, эмбриология и микробиология. Все эти отрасли науки посвящены изучению происхождения, истории, строения,… …
[Научно-технический энциклопедический словарь](http://dic.academic.ru/contents.nsf/ntes/)
* 10 **[БИОЛОГИЯ](http://dic.academic.ru/dic.nsf/ushakov/747586)** — БИОЛОГИЯ, биологии, мн. нет, жен. (от греч. bios жизнь и logos учение). Общее учение о жизни органического мира. Толковый словарь Ушакова. Д.Н. Ушаков. 1935 1940 …
[Толковый словарь Ушакова](http://dic.academic.ru/contents.nsf/ushakov/)
* 11 **[БИОЛОГИЯ](http://dic.academic.ru/dic.nsf/ogegova/12178)** — БИОЛОГИЯ, и, жен. Совокупность наук о живой природе, о закономерностях органической жизни. Космическая б. (изучающая жизнедеятельность организмов в условиях космоса). | прил. биологический, ая, ое. Толковый словарь Ожегова. С.И. Ожегов, Н.Ю.… …
[Толковый словарь Ожегова](http://dic.academic.ru/contents.nsf/ogegova/)
* 12 **[БИОЛОГИЯ](http://dic.academic.ru/dic.nsf/enc_philosophy/1852/%D0%91%D0%98%D0%9E%D0%9B%D0%9E%D0%93%D0%98%D0%AF)** — (от греч. bios – жизнь и logos – учение) наука о жизни, основанная на данных психологии, ботаники, зоологии, антропологии. Формы жизни и их структура изучаются морфологией, которая как органология, анатомия и гистология ставит себе целью… …
[Философская энциклопедия](http://dic.academic.ru/contents.nsf/enc_philosophy/)
* 13 **[биология](http://dic.academic.ru/dic.nsf/dic_synonims/9343/%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F)** — сущ., кол во синонимов: 73 • агробиология (1) • актинобиология (1) • альгология (3) …
[Словарь синонимов](http://dic.academic.ru/contents.nsf/dic_synonims/)
* 14 **[биология](http://technical_translator_dictionary.academic.ru/14640/%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F)** — — [http://www.dunwoodypress.com/148/PDF/Biotech Eng Rus.pdf] Тематики биотехнологии EN biology …
[Справочник технического переводчика](http://technical_translator_dictionary.academic.ru/)
* 15 **[Биология](http://philosophy_sponville.academic.ru/220/%D0%91%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F)** — Биология ¦ Biologie Наука о живых организмах и о жизни вообще. Нетрудно заметить, что существование биологии как науки отнюдь не может служить резоном к тому, чтобы жить, и даже к тому, чтобы заниматься биологией. Тем не менее все наши… …
[Философский словарь Спонвиля](http://philosophy_sponville.academic.ru/)
* 16 **[Биология](http://genetics_dictionary.academic.ru/913/%D0%91%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F_)** — \* біялогія \* biology учение о жизни, включающее в себя систему наук: зоологию, ботанику, генетику, физиологию, экологию и др. Изучает общие и частные закономерности проявления жизни. Основная цель исследования выявление основных свойств,… …
[Генетика. Энциклопедический словарь](http://genetics_dictionary.academic.ru/)
* 17 **[Биология](http://dic.academic.ru/dic.nsf/ruwiki/55)** — У этого термина существуют и другие значения, см. Биология (значения). Биология (греч. ???????? ???, био, жизнь; др. греч. ????? учение, наука) система наук, объектами изучения которой являются живые существа и их взаимодействие с… …
[Википедия](http://dic.academic.ru/contents.nsf/ruwiki/)
* 18 **[Биология](http://dic.academic.ru/dic.nsf/bse/69404/%D0%91%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F)** — (от Био... и ...Логия совокупность наук о живой природе. Предмет изучения Б. все проявления жизни: строение и функции живых существ и их природных сообществ, их распространение, происхождение и развитие, связи друг с другом и с неживой… …
[Большая советская энциклопедия](http://dic.academic.ru/contents.nsf/bse/)
* 19 **[биология](http://dic.academic.ru/dic.nsf/es/8884/%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F)** — и; ж. [от греч. bios жизнь и logos учение] 1. Комплексная наука о живой природе и закономерностях органической жизни. / Об отдельных направлениях или разделах этой науки. Молекулярная, космическая б. // Учебный предмет, излагающий эту науку.… …
[Энциклопедический словарь](http://dic.academic.ru/contents.nsf/es/)
* 20 **[Биология](http://dic.academic.ru/dic.nsf/enc_medicine/4642/%D0%91%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F)** — I Биология (греч. bios жизнь + logos учение) совокупность естественных наук о жизни как особом явлении природы. Предметом изучения служат строение, функционирование, индивидуальное и историческое (эволюция) развитие организмов, взаимоотношения их …
[Медицинская энциклопедия](http://dic.academic.ru/contents.nsf/enc_medicine/)
**Страницы**
* [Следующая →](/searchall.php?SWord=%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F&stype=0&btype=1&p=1)
* 1
* [2](/searchall.php?SWord=%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F&stype=0&btype=1&p=1)
* [3](/searchall.php?SWord=%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F&stype=0&btype=1&p=2)
* [4](/searchall.php?SWord=%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F&stype=0&btype=1&p=3)
* [5](/searchall.php?SWord=%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F&stype=0&btype=1&p=4)
* [6](/searchall.php?SWord=%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F&stype=0&btype=1&p=5)
* [7](/searchall.php?SWord=%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F&stype=0&btype=1&p=6)
* [8](/searchall.php?SWord=%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F&stype=0&btype=1&p=7)
* [9](/searchall.php?SWord=%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F&stype=0&btype=1&p=8)
* [10](/searchall.php?SWord=%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F&stype=0&btype=1&p=9)
(adsbygoogle = window.adsbygoogle || []).push({});
(function(w, d, n, s, t) {
w[n] = w[n] || [];
w[n].push(function() {
Ya.Direct.insertInto(48186, "yandex\_ad", {
ad\_format: "direct",
font\_size: 1,
type: "grid",
limit: 4,
title\_font\_size: 3,
links\_underline: true,
site\_bg\_color: "FFFFFF",
header\_bg\_color: "FEEAC7",
title\_color: "0000CC",
url\_color: "006600",
text\_color: "000000",
hover\_color: "0066FF",
sitelinks\_color: "0000CC",
favicon: true,
no\_sitelinks: false
});
});
t = d.getElementsByTagName("script")[0];
s = d.createElement("script");
s.src = "//an.yandex.ru/system/context.js";
s.type = "text/javascript";
s.async = true;
t.parentNode.insertBefore(s, t);
})(window, document, "yandex\_context\_callbacks");
<!--
document.write("<a href='http://www.liveinternet.ru/click' "+
"target=\_blank style='border-bottom: none;'><img src='http://counter.yadro.ru/hit?t44.6;r"+
escape(document.referrer)+((typeof(screen)=="undefined")?"":
";s"+screen.width+"\*"+screen.height+"\*"+(screen.colorDepth?
screen.colorDepth:screen.pixelDepth))+";u"+escape(document.URL)+
";h"+escape(document.title.substring(0,80))+";"+Math.random()+
"' alt='' title='LiveInternet' "+
"border='0' width='31' height='31'><\/a>")
//-->
16+
© Академик, 2000-2014
* Обратная связь:
[Техподдержка](#),
[Реклама на сайте](#)
[Экспорт словарей на сайты](http://partners.academic.ru/partner_proposal.php), сделанные на PHP, Joomla, Drupal, WordPress, MODx.
googletag.cmd.push(function() { googletag.display('div-gpt-ad-right-top'); });
<!--
(function(w, d, n, s, t) {
function renderDirect () {
Ya.Direct.insertInto("21881", "yandex\_premium\_21881", {
ad\_format: "premium",
type: "vertical",
limit: 3,
favicon: true,
no\_sitelinks: false,
sitelinks\_color: "0000CC",
title\_font\_size: 3,
font\_size: 1,
site\_bg\_color: "FFFFFF",
title\_color: "0000CC",
text\_color: "000000",
url\_color: "006600",
hover\_color: "0000CC",
links\_underline: true,
search\_text: "биология",
search\_page\_number: 1
});
}
w[n] = w[n] || []; w[n].push(renderDirect);
t = d.getElementsByTagName("script")[0];
s = d.createElement("script");
s.type = "text/javascript";
s.src = "//an.yandex.ru/system/context.js";
s.async = true;
t.parentNode.insertBefore(s, t);
})(window, document, "yandex\_context\_callbacks"); //-->
<!--
if (typeof(pr) == 'undefined') { var pr = Math.floor(Math.random() \* 4294967295) + 1; }
if (typeof(document.referrer) != 'undefined') {
if (typeof(afReferrer) == 'undefined') {
afReferrer = encodeURIComponent(document.referrer);
}
} else {
afReferrer = '';
}
var addate = new Date();
var dl = encodeURIComponent(document.location);
var pr1 = Math.floor(Math.random() \* 4294967295) + 1;
document.write('<div id="AdFox\_banner\_'+pr1+'"><\/div>');
document.write('<div style="visibility:hidden; position:absolute;"><iframe id="AdFox\_iframe\_'+pr1+'" width=1 height=1 marginwidth=0 marginheight=0 scrolling=no frameborder=0><\/iframe><\/div>');
AdFox\_getCodeScript(1,pr1,'//ads.adfox.ru/247068/prepareCode?pp=g&ps=cfov&p2=fifz&pct=a&plp=a&pli=a&pop=a&pr=' + pr +'&pt=b&pd=' + addate.getDate() + '&pw=' + addate.getDay() + '&pv=' + addate.getHours() + '&prr=' + afReferrer + '&dl='+dl+'&pr1='+pr1);
// -->
var between\_type="adj";document.write('<script type = "text/javascript" src = "http://cache.betweendigital.com/sections/153110.js"></scr'+'ipt>')
(adsbygoogle = window.adsbygoogle || []).push({});
googletag.cmd.push(function() { googletag.display('div-gpt-ad-topline'); });
(function(w, d, n, s, t) {
w[n] = w[n] || [];
w[n].push(function() {
Ya.Context.AdvManager.render({
blockId: "R-48186-8",
renderTo: "yandex\_ad\_R-48186-8",
async: true
});
});
t = d.getElementsByTagName("script")[0];
s = d.createElement("script");
s.type = "text/javascript";
s.src = "//an.yandex.ru/system/context.js";
s.async = true;
t.parentNode.insertBefore(s, t);
})(this, this.document, "yandexContextAsyncCallbacks");
(function(L){if(typeof(ar\_cn)=="undefined")ar\_cn=1;
var S='setTimeout(function(e){if(!self.CgiHref){document.close();e=parent.document.getElementById("ar\_container\_"+ar\_bnum);e.parentNode.removeChild(e);}},3000);',
j=' type="text/javascript"',t=0,D=document,n=ar\_cn;L='' + ('https:' == document.location.protocol ? 'https:' : 'http:') + ''+L+escape(D.referrer||'unknown')+'&rnd='+Math.round(Math.random()\*999999999);
function \_(){if(t++<100){var F=D.getElementById('ar\_container\_'+n);
if(F){try{var d=F.contentDocument||(window.ActiveXObject&&window.frames['ar\_container\_'+n].document);
if(d){d.write('<sc'+'ript'+j+'>var ar\_bnum='+n+';'+S+'<\/sc'+'ript><sc'+'ript'+j+' src="'+L+'"><\/sc'+'ript>');t=0}
else setTimeout(\_,100);}catch(e){try{F.src="javascript:{document.write('<sc'+'ript"+j+">var ar\_bnum="+n+"; document.domain=\""
+D.domain+"\";"+S+"<\/sc'+'ript>');document.write('<sc'+'ript"+j+" src=\""+L+"\"><\/sc'+'ript>');}";return}catch(E){}}}else setTimeout(\_,100);}}
D.write('<div style="visibility:hidden;height:0px;left:-1000px;position:absolute;"><iframe id="ar\_container\_'+ar\_cn
+'" width=1 height=1 marginwidth=0 marginheight=0 scrolling=no frameborder=0><\/iframe><\/div><div id="ad\_ph\_'+ar\_cn
+'" style="display:none;"><\/div>');\_();ar\_cn++;
})('//ad.adriver.ru/cgi-bin/erle.cgi?sid=189955&target=top&bt=43&pz=0&tail256=');
```
Само собой, результат такой обработки также требует ручной правки.
### Разработка приложения
Приложение собиралось в среде разработки кроссплатформенных приложений Marmalade SDK на языке программирования C++. Попытаюсь привести UML-диаграмму, отображающая классы приложения, их основные свойства и методы.
Главный класс приложения, с которым оперирует цикл обработки событий — класс **Application**.
Класс **MainScreen** — класс, отвечающий за отрисовку стартового экрана приложения. Выглядит он так:
**LevelGroupScreen** отвечает за отрисовку таблицы уровней группы:
**LevelScreen** — отрисовка основного экрана, отвечающего за игровой процесс:
**ImageResource** — класс, отвечающий за манипуляцию с изображениями-иконками.
Класс **Application** содержит указатели на все эти классы скринов, а так же на класс ImageResource.
При вызове Application.Init() последовательно создает экземпляры этих классов и инициализирует их.
Атрибут **ActiveScreen** хранит информацию о том, какой из экранов сейчас активен, чтобы при необходимости вызывать на активном экране методы обработки ввода (**OnClick**, **OnMove**) и перерисовки (**Draw**).
Метод **UpdateInput** занимается обработкой событий ввода, инициируемых пользователем и передаваемых приложению от операционной системы.
Каждый из экранов при необходимости может обратиться к **ImageResource** для получения из памяти того или иного изображения.
Соответственно, при закрытии приложения последовательно вызываются деструкторы всех объектов.
### Подводя итоги
Те проблемы, которые я увидел в исходном приложении, я решил в своем:
* поддержка книжной и альбомной ориентации экрана;
* возможность масштабировать шрифт;
* выделение слова при повторном вводе;
* сортировка слов по длине (по убыванию) и алфавиту;
* поддержка жестов, в том числе и zoom-жестов;
* огромное количество уровней.
Для тех, кому интересна реализация: [Android](https://play.google.com/store/apps/details?id=org.popapp.sostav_slova_iz_bukv), [iOS](https://itunes.apple.com/ru/app/id1112942939). | https://habr.com/ru/post/309800/ | null | ru | null |
# PHP-Дайджест № 169 (26 ноября – 9 декабря 2019)
[](https://habr.com/ru/post/479306/)
Свежая подборка со ссылками на новости и материалы. В выпуске: PHP 7.4, PhpStorm 2019.3, InfectionPHP и другие релизы, статистика версий PHP, об использовании FFI, видео с прошедших конференций и митапов, порция полезных инструментов, и многое другое.
Приятного чтения!
### Новости и релизы
* [PHP 7.4.0](https://www.php.net/releases/7_4_0.php) — Долгожданный релиз интерпретатора доставлен строго по расписанию. Спасибо всем контрибьюторам и релиз-менеджерам [Derick Rethans](https://twitter.com/derickr) и [Peter Kokot](https://twitter.com/peter_kokot) за проделанную работу! Из нового:
• [Типизированные свойства](https://php.watch/versions/7.4/typed-properties)
• [Стрелочные функции](https://www.php.net/manual/ru/migration74.new-features.php#migration74.new-features.core.arrow-functions)
• [Ограниченная ковариация возвращаемого типа и контравариантность типа аргумента](https://www.php.net/manual/ru/migration74.new-features.php#migration74.new-features.core.type-variance)
• [Присваивающий оператор объединения с null (??)](https://www.php.net/manual/ru/migration74.new-features.php#migration74.new-features.core.null-coalescing-assignment-operator)
• [Распаковка внутри массивов](https://www.php.net/manual/ru/migration74.new-features.php#migration74.new-features.core.unpack-inside-array)
• [Разделитель в числовых литералах](https://www.php.net/manual/ru/migration74.new-features.php#migration74.new-features.core.numeric-literal-separator)
• [Обработка исключений из метода \_\_toString()](https://www.php.net/manual/ru/migration74.new-features.php#migration74.new-features.core.tostring-exceptions)
• [Предзагрузка OPcache](https://stitcher.io/blog/preloading-in-php-74)
• [FFI](https://www.php.net/manual/ru/book.ffi.php) — [Все что вы хотели знать про PHP 7.4 FFI](https://jolicode.com/blog/php-7-4-ffi-what-you-need-to-know)
• Пачка возможностей [переведены в разряд устаревших](https://www.php.net/manual/ru/migration74.deprecated.php), а также есть [изменения, ломающие обратную совместимость](https://www.php.net/manual/ru/migration74.incompatible.php).
• Полный список изменений в документе [php-src/UPGRADING](https://github.com/php/php-src/blob/PHP-7.4/UPGRADING)
 [Как Badoo переходит на PHP 7.4](https://habr.com/ru/company/badoo/blog/477822/).
Судя по [бенчмаркам](https://community.centminmod.com/threads/php-benchmarks-7-4-vs-7-3-vs-7-2-vs-7-1-vs-7-0-php-fpm.18741/), производительность без учёта предзагрузки увеличилась в среднем на ~11%.
> С выходом 7.4 [закончился](https://www.php.net/supported-versions.php) период поддержки PHP 7.1, а PHP 7.2 перешёл в режим только секьюрити фиксов. Самое время обновиться: [Как установить PHP 7.4](https://www.colinodell.com/blog/201911/how-to-install-php-74) на различных ОС.
*  [PHP Internals News #37 – PHP 7.4 Celebrations!](https://phpinternals.news/37) — Разработчики рассказывают о своих любимых фичах из PHP 7.4.
*  [PhpStorm 2019.3](https://habr.com/ru/company/JetBrains/blog/478030/) — Поддержка PHP 7.4, PSR-12, WSL, MongoDB и многое другое. [Видеообзор основных изменений](https://www.youtube.com/watch?v=h9KGsD87t_M).
* [Drupal 8.8.0](https://www.drupal.org/blog/drupal-8-8-0) — Кроме прочего, в релизе добавлена нативная поддержка Composer.
* [Статистика версий PHP – 2019.2](https://blog.packagist.com/php-versions-stats-2019-2-edition/) — Традиционная подборка статистики использования версий PHP на основе данных, которые отправляет Composer при подключении к packagist.org. Новые версии принимаются сообществом быстро, у PHP 7.3 доля 35.24%, а PHP 5 медленно отмирает и занимает 9%.
* [skyeng/php-communities](https://github.com/skyeng/php-communities) — Открытый список PHP-событий, спикеров и организаторов. Ближайшие мероприятия:
• 10 декабря, Одесса: [PHP OpenSource world. Stable multi-threaded application.](https://www.facebook.com/events/415274049185554)
• 12 декабря, Москва: [Открытый микрофон: backend. Badoo приглашает спикеров](https://habr.com/ru/company/badoo/blog/477392/)
• 14 декабря, Казань: [Большая встреча PHP-разработчиков](https://leader-id.ru/event/29485/)
• 18 декабря, Санкт-Петербург: [SymСode St. Petersburg Meetup #8 @ JetBrains](https://www.meetup.com/ru-RU/symcode/events/267106695/)
• 21 декабря, Нижний Новгород: [Второй митап сообщества PHP NN](https://www.it52.info/events/2019-12-21-vtoroy-mitap-soobschestva-php-nn)
### Инструменты
* [Infection 0.15.0](https://infection.github.io/2019/09/29/whats-new-in-0.15.0/) — Обновление инструмента для мутационного тестирования в PHP. В новой версии: Поддержка Codeception, PHP 7.4, Symfony 4.4 и 5.0, пара новых мутаторов и другое.
* [clue/phar-composer](https://github.com/clue/phar-composer) — Инструмент для создания phar-архива из любого проекта на основе Composer. [Пост](https://clue.engineering/2019/introducing-phar-composer) в поддержку.
* [phplrt/phplrt](https://github.com/phplrt/phplrt) — Инструмент для создания парсеров на PHP по заданной грамматике. Пример: [парсер json5](https://github.com/SerafimArts/json5/).
* [shivammathur/setup-php](https://github.com/shivammathur/setup-php) — GitHub action для добавления в свой воркфлоу, который подготовит среду PHP для дальнейших шагов.
* [vlucas/phpdotenv V4.0](https://github.com/vlucas/phpdotenv/releases/tag/v4.0.0) — Автоматическая загрузка переменных окружения из файла .env.
* [totten/pogo](https://github.com/totten/pogo) — Инструмент позволяет писать однофайловые скрипты, указывая Composer-зависимости непосредственно в PHP-файле. Идея уже была реализована в [sensiolabs/melody](https://github.com/sensiolabs/melody).
* [PHPStan 0.12](https://medium.com/@ondrejmirtes/phpstan-0-12-released-f1a88036535d) — Статический анализатор для PHP в новой версии с [поддержкой дженериков](https://medium.com/@ondrejmirtes/generics-in-php-using-phpdocs-14e7301953) через PHPDoc аннотации.
### Symfony
* [Неделя Symfony #675 (2 — 8 декабря 2019)](https://symfony.com/blog/a-week-of-symfony-675-2-8-december-2019)
* [Предзагрузка PHP 7.4 в Symfony 4.4](https://symfony.com/blog/new-in-symfony-4-4-preloading-symfony-applications-in-php-7-4)
*  [Логгирование изменений сущностей в Symfony 4](https://antonshell.me/post/symfony-entity-history)
*  [Как создать RESTful API на Symfony 5 + API Platform для проекта на MODX](https://habr.com/ru/post/479168/)
*  [Пятиминутка PHP № 72](https://5minphp.ru/episode72/) — С [Валентином Удальцовым](https://twitter.com/vudaltsov) про SymfonyCon 2019, про обработку событий предметной области (Domain Events), про компоненты Messenger, Mailer и про планы дальнейшего развития Symfony 5. И [продолжение в выпуске № 73](https://5minphp.ru/episode73/) о SymfonyCloud, надёжной доставке сообщений, статическом анализе PHP кода.
### Laravel
* Об использовании [View model](https://stitcher.io/blog/laravel-beyond-crud-08-view-models) — Новая глава из серии [Laravel beyond CRUD](https://stitcher.io/laravel-beyond-crud).
* [Кейс и рекомендации по переносу приложения на Laravel Vapor](https://usefathom.com/news/moved-to-vapor)
* [Streamlining Laravel](https://jasonmccreary.me/articles/changes-to-streamline-laravel/) — Несколько идей по улучшению Laravel.
* [Form Requests — больше, чем валидация](https://pociot.dev/22-laravel-form-requests-more-than-validation) —  [Перевод](https://laravel.demiart.ru/form-requests-more-than-validation/).
*  [Astrocasts — Делаем командную шину на Laravel и Tactician 2.x](https://www.youtube.com/watch?v=qjhwXKygbjY)
### Yii
* [hunwalk/yii2-basic-firestarter](https://github.com/hunwalk/yii2-basic-firestarter) — Модифицированная версия базового шаблона с предварительно настроенными функциями для быстрого старта проекта.
* [Минимальной версией интерпретатора для Yii 3 будет PHP 7.4](https://forum.yiiframework.com/t/upping-requirements-to-php-7-4/127930)
### Zend
* [Новости о Laminas](https://www.zend.com/blog/laminas-transition-update) — Проект Apigility будет переименован в Laminas API Tools (неймспейс `Laminas\ApiTools`), а Expressive будет называться Mezzio. Официальный релиз Laminas запланирован на январь 2020.
### Async PHP
*  [Ускоряем PHP-коннекторы для Tarantool с помощью Async, Swoole и Parallel](https://habr.com/ru/company/mailru/blog/478336/)
### Материалы для обучения
* [Бенчмарк 4 способов генерирования UUID в PHP](https://jolicode.com/blog/uuid-generation-in-php) — Сравнение PECL расширения [uuid](https://pecl.php.net/package/uuid), [свежего](https://symfony.com/blog/introducing-the-new-symfony-uuid-polyfill) полифила расширения [symfony/polyfill-uuid](https://github.com/symfony/polyfill-uuid), популярного пакета [ramsey/uuid](https://github.com/ramsey/uuid) и биндинга libuuid через FFI [jolicode/ffi-uuid](https://github.com/jolicode/ffi-uuid).
* [4 ключевых момента при запуске PHP приложений на нескольких серверах](https://tideways.com/profiler/blog/four-key-considerations-when-running-php-applications-on-multiple-servers) — И подкаст  [The Undercover ElePHPant #3](https://undercover-elephpant.com/episodes/running-php-on-multiple-servers) с [Larry Garfield](https://twitter.com/Crell) и [Robert Douglass](https://twitter.com/robertDouglass).
* [Уроки, извлечённые из тестирования и рефакторинга легаси-проектов](https://24daysindecember.net/2019/12/04/lessons-learned-from-testing-and-refactoring-legacy/)
*  [Как узнать, равны ли два float в PHP](https://rmcreative.ru/blog/post/kak-uznat--ravny-li-dva-float-v-php)
*  [Анонимные функции в PHP: сеанс чёрной магии с разоблачением](https://habr.com/ru/company/funcorp/blog/478596/)
*  [Школа магии PHP](https://habr.com/ru/company/oleg-bunin/blog/478618/)
*  [Прекратите использовать Else в ваших программах](https://habr.com/ru/post/478158/)
*  [О serverLess PHP](https://habr.com/ru/company/otus/blog/477370/)
### Аудио/Видео
*  [Laravel EU 2019](https://www.youtube.com/playlist?list=PLMdXHJK-lGoDhWZ6YJW5B79CDoHWZwDN1)
*  [PHP.Barcelona 2019](https://www.youtube.com/playlist?list=PLrNlZtxTX8XTw7YLlvLAxviKXIFtVFi9I)
*  [Бесплатный курс по Blackfire от SymfonyCasts](https://symfonycasts.com/screencast/blackfire)
*  [Ноябрьский PHP-митап в офисе Skyeng](https://www.youtube.com/watch?v=wfkLPF0pJmQ)
*  [Встреча PHP-разработчиков Уфы](https://www.youtube.com/watch?v=az0j5sfEwM8)
### Занимательное
*  [Как разработчику развиваться в небольшом и не самом айтишном городе](https://habr.com/ru/company/skyeng/blog/476480/)
*  [Как завести pet project и не получить выгоды](https://habr.com/ru/post/479122/)
* Поддержите разработчиков пакетов, которыми вы пользуетесь с помощью [symfony/thanks](https://github.com/symfony/thanks):
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
Больше новостей и комментариев в Telegram-канале **[PHP Digest](https://t.me/phpdigest)**.
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Поиск ссылок по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 168](https://habr.com/ru/post/477318/) | https://habr.com/ru/post/479306/ | null | ru | null |
# Скрипт для рекурсивного сравнения директорий
В этом посте хочу поделиться с вами простым, но весьма полезным скриптом на питоне, который я написал для сравнения директорий тестового и рабочего проектов Django.
#### Проблема
На работе для решения внутренних задач я использую Django. Как результат — написан софт, с которым через браузер работает большая часть сотрудников — тех. поддержка, операторы, техническая служба нашей компании (сфера деятельности — телеком).
Довольно часто необходимо вносить изменения, но делать это сразу в рабочем проекте нельзя, т.к. простои вследствие возможных ошибок очень нежелательны. Поэтому была создана копия проекта, в который сначала и вносятся все изменения, а после тестирования измененные файлы копируются в рабочий проект.
Проблема состоит в том, что трудно вспомнить, какие файлы были изменены или добавлены, а записывать каждый раз в блокнот, как я раньше делал, неэффективно.
#### Решение
Было решено написать скрипт, который сравнивает директории тестового и рабочего проектов и выводит на экран консоли список измененных или добавленных файлов. Например, у нас тестовая директория называется **myproject**, а рабочий проект находится в директории **intranet**. Запускаем наш скрипт и видим на экране:
`/var/django_projects/myproject$ ./cmp.py
[*] /var/django_projects/myproject/templates/base.html
[-] /var/django_projects/myproject/templates/calls/call_add.html
[*] /var/django_projects/myproject/templates/calls/call_edit.html
[*] /var/django_projects/myproject/site_media/main.css`
Измененные файлы — [\*], новые (которых нет в рабочем проекте) — [-]. Очень удобно :)
##### Исходный код скрипта cmp.py
> `1. #!/usr/bin/env python
> 2. #------------------------------------------------------------
> 3. # Compare directories 'myproject' and 'intranet' recursively
> 4. #------------------------------------------------------------
> 5.
> 6. import os, filecmp
> 7.
> 8. # путь к тестовому проекту - с этой директории будем начинать обход
> 9. dir\_src = '/var/django\_projects/myproject'
> 10.
> 11. # будем сравнивать только файлы и директории из этого списка
> 12. check\_list = (
> 13. '/var/django\_projects/myproject/apps/',
> 14. '/var/django\_projects/myproject/templates/',
> 15. '/var/django\_projects/myproject/scripts/',
> 16. '/var/django\_projects/myproject/site\_media/main.css',
> 17. )
> 18.
> 19. for root, dirs, files in os.walk(dir\_src):
> 20. for name in files:
> 21. f\_src = os.path.join(root, name)
> 22. need\_check = f\_src.startswith(check\_list)
> 23. if need\_check and not f\_src.endswith('.pyc'):
> 24. f\_dst = f\_src.replace("myproject", "intranet")
> 25. if not os.path.exists(f\_dst):
> 26. print "[-] ", f\_src
> 27. elif not filecmp.cmp(f\_src, f\_dst):
> 28. print "[\*] ", f\_src`
Как видно из кода, основную работу делает метод **os.walk**, а для проверки на существование и сравнения файлов используются соответственно **os.path.exists** и **filecmp.cmp**.
Вот и все, надеюсь, кому-нибудь пригодится :)
**UPD:** Прежде чем написать очередной комментарий о системах контроля версий, обратите, пожалуйста, внимание на название блога :) Тем не менее, спасибо всем тем, кто уже затронул эту тему, думаю, для полноты картины будет полезно. | https://habr.com/ru/post/50152/ | null | ru | null |
# Цена регресса. Как мы организовали инфраструктуру для Е2Е-тестов
Мы, команда автоматизации Страхового Дома ВСК, подготовили небольшой рассказ о нашей инфраструктуре. Эта статья может быть входной точкой для специалистов, желающих внедрить автотестирование у себя в компании. Расскажем, какие системы, паттерны и фреймворки можно использовать, а также как интегрировать это в релизный цикл. Материал подойдёт как юным автоматизаторам, так и тем, кто желает поближе познакомиться с темой. Большое внимание уделим не только абстрактным вопросам, но и организации кода проекта. Добро пожаловать под кат.
Изложение поделено на две логические части. В первой опишем инфраструктуру и процесс, а во второй рассмотрим некоторые детали написания кода. Но для начала немного обрисуем рабочую среду:
* задачи ведём в Jira;
* тест-кейсы и тест-планы готовим в TestRail;
* очередь запускаемых тестов определяется Sprut;
* за деплой отвечает Azure DevOps;
* за виртуалки в докере — Selenoid;
* стек разработки автотестов — C# .NET 5.0.
Кому и зачем нужна команда автоматизаторов
------------------------------------------
Очевидно, что компании стремятся к уменьшению релизного цикла разрабатываемого ПО. Для достижения этой цели команды разработчиков прибегают к различным гибким методологиям. Однако всё равно отделу контроля качества приходится раз за разом выполнять регрессионное тестирование, занимающее от нескольких дней до нескольких недель. Именно поэтому существуют такие команды, как наша, стремящиеся сократить время регресса за счёт автоматизации.
Т. к. команда ручного тестирования является нашим заказчиком, мы постарались максимально прозрачно интегрироваться в их процесс.
Страховой Дом ВСК использует TestRail как систему управления тестированием. Выполнение регрессионного тестирования сводится к следующим простым этапам:
1. Создание тестового плана, где выбирается необходимый список тестов. Сюда попадают как обычные, так и автоматизированные кейсы.
2. Запуск тестов. После создания плана наша система (о ней чуть позже) распознаёт автоматизированные кейсы, ставит их в очередь и результат прогона возвращает обратно в TestRail.
3. Получение результатов. После завершения всех тестов тестлид видит общий отчёт по состоянию ручного и автоматического тестирования.
4. Анализ результатов. В том случае, если автотест упал по неизвестной причине, пользователь может посмотреть результат и при необходимости пройти кейс вручную, либо дождаться исправления.
Инфраструктура и автотестовый дашборд
-------------------------------------
Как уже упоминалось, процессом запуска автотестов руководит отдельная система. Многие компании предпочитают разрабатывать подобную инфраструктуру самостоятельно, чтобы лучше контролировать процесс. Мы не исключение, поэтому знакомьтесь со Sprut.
В первую очередь на Sprut возложена работа с очередью запускаемых тестов, мониторингом и управлением процессами. (За деплой отвечает Azure DevOps, а за виртуалки в докере — Selenoid. В будущем планируем внедрить автодеплой при запуске.) Также Sprut выполняет постобработку результатов прогонов: классификацию и кластеризацию. Из-за того, что тестам свойственно падать пачками, Sprut предоставляет прогон тестплана в сгруппированном по ошибкам виде. Автотестеру проще работать с такой системой, чем с TestRail.
Для каждого упавшего теста можно посмотреть логи, скриншоты и другие артефакты. Если тест упал из-за Assert, система относит инцидент к категории «Ошибка ПО» (т. е. не прошла целевая проверка). В силу природы самих Е2Е-тестов падения, которые случились не в секции Assert, попадают в отдельную категорию, где дежурный разработчик тестов уже проводит анализ, т. к. нельзя однозначно определить, это «Ошибка в автотесте» или «Ошибка ПО».
В ходе анализа Sprut позволяет сразу создать тикет в Jira и назначить ответственного. После исправления автотестов система позволяет выполнить перезапуск не прошедших ранее кейсов, а результат аккумулируется с предыдущим раном в тестовом плане. Так за несколько итераций мы можем разобрать все проблемы.
О сложности Е2Е-тестов
----------------------
Проект автотестов — это такой же программный продукт, код которого нужно писать и поддерживать. И этот код следовало бы тоже тестировать, но тогда мы войдём в бесконечную рекурсию (тесты, которые тестируют тесты, которые тестируют...). Е2Е-тесты по своей сути обеспечивают самый высокий уровень защиты от багов, но являются очень хрупкими и нестабильными. Поэтому мы подошли к архитектуре со всей ответственностью и разработали структуру, о которой дальше пойдёт речь.
Наш способ организации проекта позволяет бороться с усложнением системы, возникающим из-за увеличения числа автоматизированных тестов.
Для наглядности предлагаю разработать автотест для следующего упрощённого кейса:
1. Пользователь заходит на страницу поиска авто.
2. Вбивает несуществующий, но валидный номер паспорта ТС (транспортного средства).
3. Указывает регистрационный номер ТС.
4. Жмёт кнопку «Поиск».
***Ожидаемый результат***: появляется сообщение с предупреждением «Автомобиль не существует в базе».
Модель данных
-------------
В нашей системе модель содержит всю необходимую для выполнения теста информацию. Мы выделяем два основных типа моделей:
● Общие модели
Это классы, описывающие бизнес-объекты тестируемого приложения и принципы генерации их полей. Например: ФЛ (физическое лицо), Паспорт, Договор.
● Модели менеджера
Являются композицией общих моделей и включают некоторую служебную информацию теста и специфичные данные для конкретного тестового метода (например, TestID).
Создадим для нашего примера общую модель:
```
public sealed class CarData {
public string PasportNumber { get; set; }
= RandomString.GenerateByTemplate("00DD 0000");
public string RegNumber { get; set; };
}
```
Обратите внимание, что значение свойства по умолчанию генерируется случайным образом. Такой подход позволяет нам избегать коллизий и тестировать систему с широким диапазоном входных данных.
А регистрационный номер не является обязательным и, раз не задан, не станет подставляться в поле поиска по умолчанию. Модель менеджера будет включать в себя только одно свойство:
```
public sealed class CarFindData : ModelBase {
public CarData Car { get; set; }
= new CarData();
}
```
ModelBase содержит определение служебных полей: TestID, Login, Password. Но прежде чем мы перейдём к написанию теста — ещё пара слов о модели.
Для каждого тестового метода мы подготавливаем отдельный XML-файл, который будет десериализоваться в конкретный объект, переопределяя интересующие свойства. Так, для нашего теста создадим файл, где будет переопределённый ID теста:
```
xml version="1.0" encoding="utf-8" ?
19773
```
В большинстве случаев нас будут устраивать значения свойств по умолчанию. Но если тесты похожи, мы можем переиспользовать тестовый метод путём вставки в XML дополнительных блоков. В XML мы указываем только специфичные для данного теста свойства. Этот трюк во многом облегчает поддержку: для изменения входных данных не требуется знаний языка программирования и можно безболезненно расширять модели CarFindData и CarData.
Например, в следующем примере, указав дополнительные наборы данных в той же XML, мы получили новые тесты, ничего не меняя в коде, и можем запускать их отдельно при необходимости.
```
xml version="1.0" encoding="utf-8" ?
19773
19774
62ОК 112112
a222cc750
19775
р333оо84
```
Тестирование UI
---------------
Мы выделяем три основных типа объектов:
* ***Тестовый класс***. Содержит тестовые методы, схожие по шагам и тестовым параметрам.
* ***Менеджер***. Предоставляет набор законченных логических операций — шагов теста в конкретной области приложения или отдельных проверок результатов.
* ***FormObject/PageObject/APIObject***. Инкапсулируют сложность взаимодействия с интерфейсом, предоставляя атомарные действия над элементами страницы. Для APIObject это может быть поиск конкретных значений по тегам в ответе сервиса.
Теперь напишем код теста для нашего примера:
```
[TestFixture]
public sealed class CarFindTest : BaseTest {
public IEnumerable NotFoundWarningWhenNotFoundCarDataFromXML() {
return ModelDataFromXmlFile("NotFoundWarningWhenNotFoundCar.xml");
}
[Test, TestCaseSource(nameof(NotFoundWarningWhenNotFoundCarDataFromXML))]
public void NotFoundWarningWhenNotFoundCarTest(CarFindData data) {
Main.Manager.Login(data)
.OpenFindCar()
.FindCar(data)
.CheckCarNotFound();
}
}
```
Мы разбиваем тестовый метод на два этапа. Этап подготовки данных читает XML-файл, который мы создали ранее, и возвращает список десериализованных моделей. Метод NotFoundWarningWhenNotFoundCarTest будет запущен для каждой модели из списка, что позволяет автоматизировать сразу несколько похожих тест-кейсов, используя один и тот же код.
Для описания последовательности шагов мы пользуемся Fluent-синтаксисом, что в совокупности с IntelliSense делает написание кода таким же лёгким, как и его чтение. Main.Manager является точкой входа для работы с любыми другими менеджерами. Код в нём может содержать действия корректной инициализации и будет специфичен для каждого отдельного приложения. Его мы рассматривать не будем и перейдём сразу к созданию менеджера страницы поиска автомобиля:
```
public sealed class CarFindManager : BaseManager {
private readonly CarFindPage _carFindPage;
public CarFindManager(){
_carFindPage = new CarFindPage();
}
public CarFindManager FindCar (CarFindData data) {
_carFindPage.InputPasportNumber(data.PasportNumber);
If (data.RegNumber!=String.Empty)
{
_carFindPage.InputRegNumber(data.RegNumber);
}
_carFindPage.FindButton.Click();
return this;
}
public CarFindManager CheckCarNotFound() {
Assert.AreEquals(_carFindPage.Warning.Text, "Автомобиль не существует в базе");
return this;
}
}
```
Менеджеры должны отделять действия от проверок, предоставляя для этого различные методы. Метод принимает модель данных и сам определяет, какие свойства ему нужны. Допускается, что менеджер может изменять модель для того, чтобы передать какую-либо информацию другой части теста.
Реализация CarFindPage зависит от конкретного типа приложения. В наших проектах мы используем два богатых фреймворка: Selenium (для работы с браузером) и FlaUI (для тестирования WinForm). Более подробно о них вы можете узнать в других статьях на Хабре.
Итак, мы рассмотрели в общем виде структуру наших проектов. Хороший автотест должен содержать простой, понятный и стабильный код. А каждый метод — писаться с мыслью о повторном использовании в будущем. Такая архитектура позволяет успешно масштабировать количество тестов за счёт переиспользования кода. Чтобы с ростом проекта код оставался таким же чистым, нужно не забывать о таких практиках, как:
* обязательное code review,
* единый code style и конвенция наименования типов.
Пишем логи правильно
--------------------
Ещё одна важнейшая характеристика автотеста — его максимальная прозрачность и понятность. Т. к. с результатами прогона теста работают не только его создатели, требуется, чтобы ошибка была понятна и тестировщику, и разработчику без дополнительных пояснений. Это экономит гигантское количество времени для всей компании.
Добиваемся данной цели следующими способами:
* отделяем целевые проверки от шагов,
* автоматически делаем скриншот в момент падения теста,
* логируем каждое действие теста.
Первые два пункта более-менее очевидны, а про третий мы бы хотели рассказать поподробнее. Вот так выглядит наш файл с логом:
Помимо этого лога формируется лог для AllureТакой лог очень легко прочесть. Как можно заметить, в него попадают шаги вышеупомянутых менеджеров и действия с FormObject. Чтобы наглядно продемонстрировать, как в коде выглядит объявление этих шагов, модифицируем наш предыдущий пример:
```
[TraceAspect(Level.Manager)]
public sealed class CarFindManager : BaseManager {
private readonly CarFindPage _carFindPage;
public CarFindManager(){
_carFindPage = new CarFindPage();
}
///
/// Выполнить поиск автомобиля по номеру паспорта {data.PasportNumber}
///
///
public CarFindManager FindCarByPasportNumber(CarFindData data) {
_carFindPage.InputPasportNumber (data.PasportNumber);
_carFindPage.FindButton.Click();
return this;
}
///
/// Проверить, что появилось предупреждение о том,
/// что автомобиля не существует в бд
///
///
public CarFindManager CheckCarNotFound() {
Assert.AreEquals(_carFindPage.Warning.Text, "Автомобиль не существует в базе");
return this;
}
}
```
Нам всего лишь пришлось добавить один атрибут и обычные комментарии к методам. Атрибут TraceAspect сообщает, что для данного класса нужно сгенерировать код, отвечающий за логирование шагов. Такой трюк возможен с помощью NuGet-пакета [Aspect Injector](https://github.com/pamidur/aspect-injector). А сам текст шага будет взят из XML-документации, которую можно сгенерировать на этапе билда.
Аналогичным способом реализуются и другие часто повторяющиеся операции. Например, есть аспект для проверки передаваемых аргументов на null в методы страницы.
Для добавления этого функционала к любому PageObject необходимо прописать аннотацию [NotNullArgumentAspect] к этому классу.
Алгоритм работы следующий:
1. Если применено не к наследнику PageBase — будет вызвано исключение.
2. Если метод не публичный, или тип результата метода не совпадает с PageObject, в котором хранится метод, или если это вообще не метод, а LINQ-запрос — управление передаётся методу без дополнительных проверок.
3. Проверяются все аргументы, переданные в метод. Если хотя бы один из них равен null — записывается сообщение в лог и метод не выполняется (возвращается корректный PageObject). Если с аргументами всё хорошо — метод выполняется.
Подводим итоги
--------------
Суть автоматизации, как и разработки любого продукта, — сделать систему, позволяющую упростить и ускорить работу пользователей. Мы считаем, что успешно справились с данной задачей, т. к. построили инструмент, которому тестировщики доверяют и который активно используют. На этом наша работа ещё не закончена: в ближайших планах есть много интересных задач по улучшению. Например, чтобы в момент запуска теста в Docker-контейнере автоматически стартовало динамическое развёртывание и тестовый проект сразу подстраивался под среду, указанную в параметрах запуска.
Мы постарались показать вертикальный срез нашей инфраструктуры тестирования. Невозможно в рамках одной статьи рассказать обо всех нюансах. Мы готовы ответить на ваши вопросы в комментариях и будем рады, если вы расскажете о своих техниках: как справляетесь с теми или иными проблемами. | https://habr.com/ru/post/572202/ | null | ru | null |
# Учебный курс по React, часть 4: родительские и дочерние компоненты
Публикуем очередную часть перевода учебного курса по React. Нашей сегодняшней темой будут взаимоотношения родительских и дочерних компонентов.
[](https://habr.com/company/ruvds/blog/434118/)
→ [Часть 1: обзор курса, причины популярности React, ReactDOM и JSX](https://habr.com/post/432636/)
→ [Часть 2: функциональные компоненты](https://habr.com/post/433400/)
→ [Часть 3: файлы компонентов, структура проектов](https://habr.com/post/433404/)
→ [Часть 4: родительские и дочерние компоненты](https://habr.com/company/ruvds/blog/434118/)
→ [Часть 5: начало работы над TODO-приложением, основы стилизации](https://habr.com/company/ruvds/blog/434120/)
→ [Часть 6: о некоторых особенностях курса, JSX и JavaScript](https://habr.com/company/ruvds/blog/435466/)
→ [Часть 7: встроенные стили](https://habr.com/company/ruvds/blog/435468/)
→ [Часть 8: продолжение работы над TODO-приложением, знакомство со свойствами компонентов](https://habr.com/company/ruvds/blog/435470/)
→ [Часть 9: свойства компонентов](https://habr.com/company/ruvds/blog/436032/)
→ [Часть 10: практикум по работе со свойствами компонентов и стилизации](https://habr.com/company/ruvds/blog/436890/)
→ [Часть 11: динамическое формирование разметки и метод массивов map](https://habr.com/company/ruvds/blog/436892/)
→ [Часть 12: практикум, третий этап работы над TODO-приложением](https://habr.com/company/ruvds/blog/437988/)
→ [Часть 13: компоненты, основанные на классах](https://habr.com/ru/company/ruvds/blog/437990/)
→ [Часть 14: практикум по компонентам, основанным на классах, состояние компонентов](https://habr.com/ru/company/ruvds/blog/438986/)
→ [Часть 15: практикумы по работе с состоянием компонентов](https://habr.com/ru/company/ruvds/blog/438988/)
→ [Часть 16: четвёртый этап работы над TODO-приложением, обработка событий](https://habr.com/ru/company/ruvds/blog/439982/)
→ [Часть 17: пятый этап работы над TODO-приложением, модификация состояния компонентов](https://habr.com/ru/company/ruvds/blog/439984/)
→ [Часть 18: шестой этап работы над TODO-приложением](https://habr.com/ru/company/ruvds/blog/440662/)
→ [Часть 19: методы жизненного цикла компонентов](https://habr.com/ru/company/ruvds/blog/441578/)
→ [Часть 20: первое занятие по условному рендерингу](https://habr.com/ru/company/ruvds/blog/441580/)
→ [Часть 21: второе занятие и практикум по условному рендерингу](https://habr.com/ru/company/ruvds/blog/443210/)
→ [Часть 22: седьмой этап работы над TODO-приложением, загрузка данных из внешних источников](https://habr.com/ru/company/ruvds/blog/443212/)
→ [Часть 23: первое занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/443214/)
→ [Часть 24: второе занятие по работе с формами](https://habr.com/ru/company/ruvds/blog/444356/)
→ [Часть 25: практикум по работе с формами](https://habr.com/ru/company/ruvds/blog/446208/)
→ [Часть 26: архитектура приложений, паттерн Container/Component](https://habr.com/ru/company/ruvds/blog/446206/)
→ [Часть 27: курсовой проект](https://habr.com/ru/company/ruvds/blog/447136/)
Занятие 9. Родительские и дочерние компоненты
---------------------------------------------
→ [Оригинал](https://scrimba.com/p/p7P5Hd/cQ726Sr)
Сегодня мы поговорим о родительских и дочерних компонентах. Использование подобных конструкций сделает наше приложение гораздо более сложным, чем в случае, когда в нём был всего один компонент, выводимый в DOM, такой, как `MyInfo`. Вместо этой простой структуры в приложении может присутствовать сложная иерархия компонентов, которая, в итоге, преобразуется в JSX-элементы.
Начнём с уже знакомого вам шаблона приложения. Для того чтобы вспомнить пройденное, можете, по памяти, в пустом файле `index.js`, написать код для вывода на страницу заголовка первого уровня с текстом `Hello World!` средствами React. Вот как может выглядеть подобный код:
```
import React from "react"
import ReactDOM from "react-dom"
ReactDOM.render(
Hello World!
============
,
document.getElementById("root")
)
```
В прошлый раз там, где в вышеприведённом коде находится описание элемента , присутствовал код для вывода компонента `MyInfo`. Теперь же мы собираемся создать компонент `App` и вывести его. Для этого нам понадобится код следующего вида:
```
import React from "react"
import ReactDOM from "react-dom"
ReactDOM.render(
,
document.getElementById("root")
)
```
Компонент `App` будет точкой входа в наше приложение. Вероятно, вы уже заметили, что в коде предыдущего примера кое-чего не хватает. Это действительно так — мы пока не импортировали сюда `App`. Сделаем это:
```
import React from "react"
import ReactDOM from "react-dom"
import App from "./App"
ReactDOM.render(
,
document.getElementById("root")
)
```
Но такой код всё ещё остаётся нерабочим. Нам нужен файл компонента `App` (`App.js`), расположенный в той же папке, что и `index.js`. Именно к такому файлу мы обращаемся в команде импорта `import App from "./App"`. Напомним, что имена компонентов React записываются в верблюжьем стиле и начинаются с заглавной буквы. Создадим нужный нам файл и опишем в нём компонент `App`. Попытайтесь сделать это самостоятельно. А именно — напишите код, благодаря которому компонент `App` выведет на страницу текст `Hello again`.
Вот как выглядит этот код:
```
import React from "react"
function App(){
return (
Hello again
===========
)
}
export default App
```
Тут функция `App` возвращает единственный элемент, но напомним, что из подобных функций можно возвращать и более сложные структуры. Самое главное — не забывать о том, что возвратить можно лишь один элемент, который, если, на самом деле, вывести нужно несколько элементов, представляет собой контейнер, включающий их в себя. Например, вот как будет выглядеть возврат разметки, описывающей заголовок первого уровня и маркированный список:
```
import React from "react"
function App(){
return (
Hello a third time!
===================
* Thing 1
* Thing 2
* Thing 3
)
}
export default App
```
Возможно, сейчас мы решим, что то, что формируется средствами компонента `App`, должно представлять собой некий веб-сайт. У него будет навигационный блок () и область основного содержимого (). Это решение приведёт к формированию следующего кода:
```
import React from "react"
function App(){
return (
Hello a third time!
===================
* Thing 1
* Thing 2
* Thing 3
This is where most of my content will go...
)
}
export default App
```
Вот как всё это будет выглядеть в браузере.
*Приложение в браузере*
Тут ещё можно стилизовать список для того, чтобы он стал больше похожим на навигационную панель.
Можно заметить, что код компонента уже стал довольно большим. Это идёт вразрез с целью, ради которой мы используем React. Ранее мы говорили о том, что фрагменты HTML-кода можно представлять в виде отдельных компонентов, а в нашем компоненте всё свалено в одну кучу. Поэтому сейчас мы создадим компоненты для каждого самостоятельного фрагмента разметки.
Взгляните на эту схему для того, чтобы лучше разобраться в том, о чём идёт речь.
*Компонент App выводит компонент MyInfo, выводящий элемент*
Тут мы выводим на страницу компонент `App`. При этом компонент `App` решает вывести ещё один компонент — `MyInfo`. А уже компонент `MyInfo` выводит некий JSX-элемент. Обратите внимание на разницу между понятиями «компонент» и «элемент». Элементы — это сущности, которые превращаются в обычный HTML-код. Так, в элементе, представленном в нижней части схемы, используется простой тег , его имя начинается с маленькой буквы, что говорит нам о том, что это — обычный элемент, а не один из созданных нами компонентов. С другой стороны, имя `MyInfo` начинается с большой буквы. Это помогает понять, что перед нами — компонент.
Вы могли слышать о том, что DOM (Document Object Model, объектная модель документа) часто называют «деревом». Корневым элементом этого дерева является элемент . В нашем случаем корневым элементом дерева, представленного на схеме, является компонент `App`. Возможности этого компонента не ограничиваются выводом другого компонента, `MyInfo` в нашем случае. Он может, например, вывести ещё один компонент, представляющий собой «подвал», нижнюю часть страницы. Скажем, этот компонент будет носить имя `AwesomeFooter`.
*Компонент App выводит два компонента*
Этот компонент, в свою очередь, может вывести элемент , который будет содержать HTML-код нижней части страницы.
Если у нас имеется «подвал» страницы, то она может содержать и «шапку», оформляющую её верхнюю часть.
*Компонент App выводит три компонента*
Верхняя часть страницы представлена на нашей схеме компонентом `AwesomeHeader`. Такие имена этим компонентам даны для того, чтобы не путать их с элементами. Компонент `AwesomeHeader`, как и компонент `App`, может выводить не только JSX-разметку, но и другие компоненты. Например, это может быть компонент `NavBar`, представляющий собой навигационную панель, и компонент `Logo`, выводящий логотип. А эти компоненты уже выведут обычные элементы — такие, как `![]()` и .
По мере рассмотрения этой схемы вы можете заметить, что React-приложение, в ходе его развития, может становиться всё более и более сложным. И то, что мы тут рассмотрели, на самом деле, представляет собой пример крайне простой структуры приложения.
Теперь давайте создадим в нашем учебном приложении компонент, который будет представлять собой «подвал» страницы.
Для этого создадим, в той же папке, где находится файл `index.js`, новый файл. Назовём его `Footer.js` и поместим в него следующий код:
```
import React from "react"
function Footer() {
return (
### ▍This is my footer element
)
}
export default Footer
```
Обратите внимание на то, что имя функционального компонента начинается с большой буквы (`Footer`), а имя элемента `(`) — с маленькой. Как уже было сказано, это помогает отличать элементы от компонентов.
Если теперь обновить страницу, то разметка, формируемая компонентом `Footer`, в её нижней части выведена не будет. Это совершенно ожидаемо, так как для того, чтобы её вывести, нужно внести соответствующие изменения в код компонента `App`.
А именно, речь идёт о том, что в коде файла компонента `App` нужно импортировать компонент `Footer` и создать его экземпляр. Отредактируем код файла `App.js`:
```
import React from "react"
import Footer from "./Footer"
function App(){
return (
Hello a third time!
===================
* Thing 1
* Thing 2
* Thing 3
This is where most of my content will go...
)
}
export default App
```
Теперь страница, которую формирует приложение, будет выглядеть так, как показано ниже.
*Компонент App выводит в нижней части страницы разметку, формируемую другим компонентом — Footer*
Можно заметить, что сейчас в коде, выводимом компонентом `App`, имеется странная смесь из обычных JSX-элементов с компонентами. Куда лучше было бы, если бы то, что выводит компонент `App`, было бы похоже на нечто вроде оглавления книги, чтобы в нём присутствовали, в основном, компоненты. А именно, речь идёт о том, чтобы код компонента выглядел бы примерно так:
```
import React from "react"
import Footer from "./Footer"
function App() {
return (
)
}
export default App
```
Если приложение имеет подобную структуру (в нашем случае, так как файлы компонентов `Header` и `MainContent` пока не созданы, код работать не будет), то описание элементов, формирующих различные части страницы, будет находиться в файлах соответствующих компонентов. При этом компоненты, импортируемые в компонент `App`, могут содержать другие вложенные компоненты. Так могут быть сформированы довольно обширные структуры, размеры которых определяются нуждами конкретного приложения.
Здесь мы поговорили о том, как работать с вложенными компонентами. Вы вполне можете попробовать на практике то, что только что узнали, приведя проект, файл `App.js` которого выглядит так, как показано выше, в рабочее состояние.
Занятие 10. Практикум. Родительские и дочерние компоненты
---------------------------------------------------------
→ [Оригинал](https://scrimba.com/p/p7P5Hd/caQwRHM)
### ▍Задание
Создайте React-приложение с нуля. Выведите на страницу корневой компонент `App` (определённый в отдельном файле). Внутри этого компонента выведите следующие компоненты:
1. `Navbar`
2. `MainContent`
3. `Footer`
Компоненты, выводимые `App`, должны быть описаны в отдельных файлах, каждый из них должен выводить какие-нибудь JSX-элементы.
### ▍Решение
В качестве основы для решения этой задачи используется стандартный проект, создаваемый средствами `create-react-app` (если вы не знаете как такой проект создать — взгляните на [этот](https://habr.com/company/ruvds/blog/432636/) материал). Тут используется стандартный `index.html`.
Код файла `index.js`:
```
import React from "react"
import ReactDOM from "react-dom"
import App from "./App"
ReactDOM.render(
,
document.getElementById("root")
)
```
Вот код файла `App.js`. Обратите внимание на то, что для хранения файлов компонентов мы будем использовать папку `components`.
```
import React from "react"
import Header from "./components/Header"
import MainContent from "./components/MainContent"
import Footer from "./components/Footer"
function App() {
return (
)
}
export default App
```
Код файла `Header.js`:
```
import React from "react"
function Header() {
return (
This is the header
)
}
export default Header
```
Код файла `MainContent.js`:
```
import React from "react"
function MainContent() {
return (
This is the main section
)
}
export default MainContent
```
Код файла `Footer.js`:
```
import React from "react"
function Footer() {
return (
This is the footer
)
}
export default Footer
```
Работу с компонентами вы можете организовать так, как вам будет удобнее. То есть, можно, например, сначала написать в файле `App.js` весь необходимый код, выполняющий импорт компонентов и вывод их экземпляров, а потом создать файлы компонентов. Можно сделать всё наоборот — сначала создать файлы компонентов с кодом, а потом уже работать над файлом `App.js`. Самое главное, чтобы в итоге получилось работающее приложение.
Вот как выглядит проект в VSCode.
*Проект в VSCode*
А вот как выглядит страница, которую сформировало это приложение.
*Страница приложения в браузере*
Наше React-приложение работает, но то, что оно выводит на страницу, выглядит как-то совсем неинтересно. Исправить это можно, стилизовав содержимое страницы.
Итоги
-----
Сегодня мы поговорили о родительских и дочерних компонентах. В следующий раз мы начнём работу над нашим первым большим учебным проектом и поговорим о стилизации элементов страницы.
**Уважаемые читатели!** Если вы занимаетесь по этому курсу — просим рассказать о том, как вы выполняете практические занятия. А именно — пишете ли код, что называется, «из головы», или поглядываете на текст предыдущего занятия? А, может быть, вы пытаетесь найти то, что забыли, в интернете?
[](https://ruvds.com/ru-rub/news/read/95)
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/434118/ | null | ru | null |
# UPD: Cisco и 2 провайдера
Проблема стара как мир и сегодня мы ее решим :)
Дано: 2 провайдера (ISP1 и ISP2), внутренняя сеть и между ними маршрутизатор.
Задача: настроить один основной (ISP1) и один резервный канал (ISP2), при падении первого переключится на второй, при поднятии первого переключится обратно.
[](http://www.radikal.ru)
UPD: Обновил, дописал ip sla, пока без объяснений.
Будем исходить из того что коммутаторы у нас тоже фирмы Cisco :) и для начала настроим 3 Vlan'а:
Vlan 10 — внутренняя сеть
Vlan 12 — ISP1
Vlan 14 — ISP2
`C2970#vlan data
C2970(vlan)#vlan 10 name OurNet
VLAN 10 added:
Name: OurNet
C2970(vlan)#vlan 12 name ISP1
VLAN 12 added:
Name: ISP1
C2970(vlan)#vlan 14 name ISP2
VLAN 13 added:
Name: ISP2
C2970-Servers(vlan)#exit
APPLY completed.
Exiting....
C2970#`
Порт номер 1 принадлежит Vlan'у 12 -ISP1, порт 2 принадлежит Vlan'у 14 (ISP2), третий порт транковый — для рутера, остальные порты принадлежат Vlan'у 10 — наша внутренняя сеть.
`interface FastEthernet0/1
description -=I=- ISP1 -=I=-
switchport access vlan 12
switchport mode access
no cdp enable
interface FastEthernet0/2
description -=I=- ISP2 -=I=-
switchport access vlan 14
switchport mode access
no cdp enable
interface FastEthernet0/3
description -=I=- RTR -=I=-
switchport mode trunk
no mdix auto
interface FastEthernet0/4
switchport access vlan 10
switchport mode access
no cdp enable
...
interface FastEthernet0/24
switchport access vlan 10
switchport mode access
no cdp enable`
С коммутацией разобрались переходим к нашему рутеру, у меня за пример взят Cisco 2811 с иосом c2800nm-adventerprisek9\_ivs-mz.124-24.T1.bin (хотя будет работать и на другом рутере с другим ИОС'ом)
Настроим интерфейсы:
`interface FastEthernet0/0
no ip address
duplex auto
speed auto
no cdp enable
!
interface FastEthernet0/0.12
description -=I=- Internet over ISP1 -=I=-
encapsulation dot1Q 12
ip address 164.122.12.9 255.255.255.248
ip access-group ACL_INET_OUT_ISP1 out
ip nat outside
ip virtual-reassembly
no cdp enable
!
interface FastEthernet0/0.14
description -=I=- Internet over ISP2 -=I=-
encapsulation dot1Q 14
ip address 122.164.8.17 255.255.255.248
ip access-group ACL_INET_OUT_ISP2 out
ip nat outside
ip virtual-reassembly
no cdp enable
!
interface FastEthernet0/1
no ip address
duplex auto
speed auto
!
interface FastEthernet0/1.10
description to -=I=- LAN -=I=-
encapsulation dot1Q 10
ip address 10.10.10.200 255.255.255.0
ip nat inside
ip virtual-reassembly
no cdp enable`
Настроим пулы для NAT'а:
`ip nat pool ISP1-PUBLIC-IP 164.122.12.9 164.122.12.9 netmask 255.255.255.248
ip nat pool ISP2-PUBLIC-IP 122.164.8.17 122.164.8.17 netmask 255.255.255.248`
Акцесс-листы (ACL):
ACL'и для интерфейсов, чтобы никто не прорвался :)
`ip access-list extended ACL_INET_OUT_ISP1
deny ip any 10.0.0.0 0.255.255.255 log-input
deny ip any 172.16.0.0 0.15.255.255 log-input
deny ip any 192.168.0.0 0.0.255.255 log-input
permit ip host 164.122.12.9 any
deny ip any any log-input
ip access-list extended ACL_INET_OUT_ISP2
deny ip any 10.0.0.0 0.255.255.255 log-input
deny ip any 172.16.0.0 0.15.255.255 log-input
deny ip any 192.168.0.0 0.0.255.255 log-input
permit ip host 122.164.8.17 any
deny ip any any log-input`
ACL'и для тех кто в сети:
`ip access-list extended ACL_NAT-INET_OUT_ISP1
remark /--------------------------------------
remark Black Hole RFC 1918
remark --------------------------------------/
deny ip any 10.0.0.0 0.255.255.255 log-input
deny ip any 172.16.0.0 0.15.255.255 log-input
deny ip any 192.168.0.0 0.0.255.255 log-input
remark /--------------------------------------
remark SMTP For Exchange
remark --------------------------------------/
permit tcp host 10.10.10.254 any eq smtp
deny tcp any any eq smtp log-input
remark /--------------------------------------
remark WSUS
remark --------------------------------------/
permit ip host 10.10.10.251 any
remark /--------------------------------------
remark Full Aceess for Odmins
remark --------------------------------------/
permit ip host 10.10.10.10 any
remark /--------------------------------------
remark Access for Exchange
remark --------------------------------------/
permit ip host 10.10.10.254 any
remark /--------------------------------------
remark Deny SMTP for TI (gate)
remark --------------------------------------/
deny tcp host 10.10.10.249 eq smtp any log-input
remark /--------------------------------------
remark Access to Internet for TI (gate)
remark --------------------------------------/
permit ip host 10.10.10.249 any
remark /--------------------------------------
remark Self
remark --------------------------------------/
permit ip host 164.122.12.9 any
remark /--------------------------------------
remark Deny All
remark --------------------------------------/
deny ip any any log-input
ip access-list extended ACL_NAT-INET_OUT_ISP2
remark /--------------------------------------
remark Black Hole RFC 1918
remark --------------------------------------/
deny ip any 10.0.0.0 0.255.255.255 log-input
deny ip any 172.16.0.0 0.15.255.255 log-input
deny ip any 192.168.0.0 0.0.255.255 log-input
remark /--------------------------------------
remark SMTP For Exchange
remark --------------------------------------/
permit tcp host 10.10.10.254 any eq smtp
deny tcp any any eq smtp log-input
remark /--------------------------------------
remark WSUS
remark --------------------------------------/
permit ip host 10.10.10.251 any
remark /--------------------------------------
remark Full Aceess for Odmins
remark --------------------------------------/
permit ip host 10.10.10.10 any
remark /--------------------------------------
remark Access for Exchange
remark --------------------------------------/
permit ip host 10.10.10.254 any
remark /--------------------------------------
remark Deny SMTP for TI (gate)
remark --------------------------------------/
deny tcp host 10.10.10.249 eq smtp any log-input
remark /--------------------------------------
remark Access to Internet for TI (gate)
remark --------------------------------------/
permit ip host 10.10.10.249 any
remark /--------------------------------------
remark Self
remark --------------------------------------/
permit ip host 122.164.8.17 any
remark /--------------------------------------
remark Deny All
remark --------------------------------------/
deny ip any any log-input`
Route-map:
`route-map NAT-TO-ISP1 permit 10
description -= Routing/NAT to ISP1, outgoing traffic =-
match ip address ACL_NAT-INET_OUT_ISP1
match interface FastEthernet0/0.12
!
route-map NAT-TO-ISP2 permit 10
description -= Routing/NAT to ISP2, outgoing traffic =-
match ip address ACL_NAT-INET_OUT_ISP2
match interface FastEthernet0/0.14`
И вот теперь самое интересное — трекинг:
`track 100 list boolean and
object 101
object 102
object 103`
**object 104**
`delay down 2 up 3
!
track 101 interface FastEthernet0/0.12 line-protocol
delay down 2 up 5
!
track 102 interface FastEthernet0/1 line-protocol
delay down 2 up 5
!
track 103 ip route 164.122.12.9 255.255.255.248 reachability
delay down 2 up 5
!`
**track 104 ip sla 104
delay down 2 up 5**
`!
track 200 list boolean and
object 201
object 202
object 203`
**object 204**
`delay down 2 up 3
!
track 201 interface FastEthernet0/0.14 line-protocol
delay down 2 up 5
!
track 202 interface FastEthernet0/1 line-protocol
delay down 2 up 5
!
track 203 ip route 122.164.8.17 255.255.255.248 reachability
delay down 2 up 5
!`
**track 204 ip sla 204
delay down 2 up 5**
и маршруты:
`ip route 0.0.0.0 0.0.0.0 164.122.12.9 10 tag 100 name -=[ISP1]=- track 100
ip route 0.0.0.0 0.0.0.0 122.164.8.17 20 tag 200 name -=[ISP2]=- track 200`
а теперь собственно то, чем мы проверяем доступность наших шлюзов:
ip sla 104
icmp-echo 164.122.12.9 source-interface FastEthernet0/0.12
request-data-size 1
timeout 700
threshold 600
frequency 30
ip sla schedule 104 life forever start-time now
ip sla 204
icmp-echo 122.164.8.17 source-interface FastEthernet0/0.14
request-data-size 1
timeout 700
threshold 600
frequency 30
ip sla schedule 204 life forever start-time now | https://habr.com/ru/post/70801/ | null | ru | null |
# Python v3.x: обработчик исключений для корутин и синхронных функций. Вобщем, для всего
В свободное время я работаю над своим [небольшим проектом](https://github.com/sergio-ivanuzzo/idewave-core). Написан на Python v3.x + SQLAlchemy. Возможно, я когда-нибудь напишу и о нем, но сегодня хочу рассказать о своем декораторе для обработки исключений. Его можно применять как для функций, так и для методов. Синхронных и асинхронных. Также можно подключать кастомные хэндлеры исключений.
Декоратор на текущий момент выглядит так:
```
import asyncio
from asyncio import QueueEmpty, QueueFull
from concurrent.futures import TimeoutError
class ProcessException(object):
__slots__ = ('func', 'custom_handlers', 'exclude')
def __init__(self, custom_handlers=None):
self.func = None
self.custom_handlers: dict = custom_handlers
self.exclude = [QueueEmpty, QueueFull, TimeoutError]
def __call__(self, func, *a):
self.func = func
def wrapper(*args, **kwargs):
if self.custom_handlers:
if isinstance(self.custom_handlers, property):
self.custom_handlers = self.custom_handlers.__get__(self, self.__class__)
if asyncio.iscoroutinefunction(self.func):
return self._coroutine_exception_handler(*args, **kwargs)
else:
return self._sync_exception_handler(*args, **kwargs)
return wrapper
async def _coroutine_exception_handler(self, *args, **kwargs):
try:
return await self.func(*args, **kwargs)
except Exception as e:
if self.custom_handlers and e.__class__ in self.custom_handlers:
return self.custom_handlers[e.__class__]()
if e.__class__ not in self.exclude:
raise e
def _sync_exception_handler(self, *args, **kwargs):
try:
return self.func(*args, **kwargs)
except Exception as e:
if self.custom_handlers and e.__class__ in self.custom_handlers:
return self.custom_handlers[e.__class__]()
if e.__class__ not in self.exclude:
raise e
```
Разберем по порядку. [\_\_slots\_\_](https://stackoverflow.com/a/28059785/5397119) я использую для небольшой экономии памяти. Бывает полезно, если объект используется ну ооочень часто.
На этапе инициализации в \_\_init\_\_ мы сохраняем custom\_handlers (в случае, если понадобилось их передать). На всякий случай обозначил, что мы ожидаем там увидеть словарь, хотя, возможно, в будущем, есть смысл добавить пару жестких проверок. В свойстве self.exclude лежит список исключений, которые обрабатывать не нужно. В случае такого исключения функция с декоратором вернет None. На текущий момент список заточен под мой проект и возможно есть смысл его вынести в отдельный конфиг.
Самое главное происходит в \_\_call\_\_. Поэтому при использовании декоратора его нужно вызывать. Даже без параметров:
```
@ProcessException()
def some_function(*args):
return None
```
Т.е. вот так уже будет неправильно и будет вызвана ошибка:
```
@ProcessException
def some_function(*args):
return None
```
В этом случае мы получим текущую функцию, которую, в зависимости от степени ее асинхронности обработаем либо как обычную синхронную, либо как корутин.
На что здесь можно обратить внимание. Первое, это проверка на проперти:
```
if self.custom_handlers:
if isinstance(self.custom_handlers, property):
self.custom_handlers = self.custom_handlers.__get__(self, self.__class__)
```
Зачем я это делаю.
```
Конечно же
не потому, что
я айти-Маяковский
и мне платят построчно.
```
Два **if** здесь для улучшения читабельности (да-да, ведь код может саппортить человек с садистскими наклонностями), а self.custom\_handlers.\_\_get\_\_(self, self.\_\_class\_\_) мы делаем для того, чтобы не терять класс, в случае, если мы решили хэндлеры хранить в @property класса.
Например, так:
```
class Math(object):
@property
def exception_handlers(self):
return {
ZeroDivisionError: lambda: 'Делить на ноль нельзя, но можно умножить'
}
@ProcessException(exception_handlers)
def divide(self, a, b):
return a // b
```
Если не сделать self.custom\_handlers.\_\_get\_\_(...), то вместо содержимого @property мы будем получать что-то типа .
Собственно, в примере выше показан способ подключения кастомных хэндлеров. В общем случае это делается так:
```
@ProcessException({ZeroDivisionError: lambda: 'Делить на ноль можно, но с ошибкой'})
def divide(a, b):
return a // b
```
В случае с классом (если мы собираемся передавать свойства/методы) нужно учесть, что на **этапе инициализации декоратора** класса как такового еще нету и методы/свойства суть простые функции. Поэтому мы можем передать только то, что объявлено выше. Поэтому вариант с @property — это возможность применять через self все функции, которые ниже по коду. Ну либо можно использовать лямбды, если self не нужен.
Для асинхронного кода справедливы все вышеописанные примеры.
Напоследок хочу обратить внимание, что если исключение на своем пути не встретило кастомных хэндлеров, то оно просто рейзится (raise) дальше.
Жду ваших комментариев. Спасибо за то, что уделили внимание моей статье. | https://habr.com/ru/post/473596/ | null | ru | null |
# Пишем игровую логику на C#. Часть 2/2
Это продолжение [предыдущей статьи](https://habrahabr.ru/post/322258/). Мы шаг за шагом создаем движок, на котором будет работать игровая логика нашей экономической стратегии. Если вы видите это впервые — настоятельно рекомендую начать с **[Части 1](https://habrahabr.ru/post/322258/)**, так как это зависимое продолжение и требует ее контекста.
Как и раньше — внизу статьи вы можете найти полный код на ГитХаб и ссылку на бесплатное скачивание.
---
### План работы
1. ~~Настраиваем проекты~~
2. ~~Создаем ядро (базовые сооружения)~~
3. ~~Добавляем и тестируем первые команды — построить строение и модуль~~
4. ~~Выносим настройки строений и модулей в отдельный файл~~
5. ~~Добавляем течение времени~~
6. Добавляем Constructible, строения теперь строятся некоторое время
7. Добавляем ресурсы, для постройки необходимы ресурсы
8. Добавляем цикл производства — модуль потребляет и выдает ресурсы
Добавляем Constructible
-----------------------
Давайте теперь что-то привяжем к течению времени. Пусть постройки и модули строятся не сразу, а несколько ходов (зависимо от конфигурации). Для начала во все настройки добавим пункт ConstructionTime. Если ConstructionTime равно нулю — структуру построить невозможно.
>
> ```
> public class BuildingConfig
> {
> // ...
> public int ConstructionTime;
> }
>
> ```
>
> ```
> public class ModuleConfig
> {
> // ...
> public int ConstructionTime;
> }
>
> ```
>
Не забываем добавить настройки в фабрику:
>
> ```
> public class Factory
> {
> // ...
> Type = BuildingType.PowerPlant,
> ConstructionTime = 8,
> // ...
> Type = BuildingType.Smeltery,
> ConstructionTime = 10,
> // ...
> Type = BuildingType.Roboport,
> ConstructionTime = 12,
>
> // ...
>
> Type = ModuleType.Generator,
> ConstructionTime = 5
> // ...
> Type = ModuleType.Furnace,
> ConstructionTime = 6
> // ...
> Type = ModuleType.Digger,
> ConstructionTime = 7
> // ...
> Type = ModuleType.Miner,
> ConstructionTime = 8
> // ...
> }
>
> ```
>
Теперь создадим класс Progression, которым мы будем реализовывать любые прогрессии, которые текут во времени, например, строительство.
>
> ```
> public class Progression
> {
> public readonly int Time;
>
> public int Progress { get; private set; }
>
> public bool IsFake {
> get { return Time == 0; }
> }
>
> public bool IsReady {
> get { return IsFake || Progress >= Time; }
> }
>
> public bool IsRunning
> {
> get { return !IsReady && Progress > 0; }
> }
>
> public Progression (int time)
> {
> Time = time;
> Progress = 0;
> }
>
> public void AddProgress ()
> {
> if (!IsReady) Progress++;
> }
>
> public void Complete ()
> {
> if (!IsReady) Progress = Time;
> }
>
> public void Reset ()
> {
> Progress = 0;
> }
> }
>
> ```
>
Теперь добавим в наши комнаты и модули возможность постройки.
>
> ```
> public class Building
> {
> // ...
>
> public readonly Progression Constructible;
>
> // ...
>
> public Building (BuildingConfig config)
> {
> // ...
> Constructible = new Progression(config.ConstructionTime);
> }
>
> ```
>
>
>
> ```
> public class Module
> {
> // ...
>
> public readonly Progression Constructible;
>
> public Module (ModuleConfig config)
> {
> // ...
> Constructible = new Progression(config.ConstructionTime);
> }
>
> ```
>
И запретим постройку модулей в еще не построенной комнате:
>
> ```
> public class ModuleConstruct : Command
> {
> // ...
>
> protected override bool Run ()
> {
> // ...
> if (!Building.Constructible.IsReady) {
> return false;
> }
>
> ```
>
Само собой после этого упали тесты, потому мы добавим в тесты CorrectConstruction, IncorrectConstruction, CantConstructInWrongBuilding и ModulesLimits после успешного выполнения команды BuildingConstruct вызов метода Complete (да-да, специально для этого мы его и создали)
```
room.Building.Constructible.Complete()
```
А для проверки на невозможность построить в еще не законченной комнате напишем отдельный тест:
>
> ```
> [TestMethod]
> public void CantConstructInUncompleteBuilding ()
> {
> var core = new GameLogic.Core();
> var room = core.Ship.GetRoom(0);
>
> new BuildingConstruct(
> room,
> core.Factory.ProduceBuilding(BuildingType.PowerPlant)
> )
> .Execute(core);
>
> Assert.IsFalse(
> new ModuleConstruct(
> room.Building,
> core.Factory.ProduceModule(ModuleType.Generator),
> 2
> )
> .Execute(core)
> .IsValid
> );
> }
>
> ```
>
Но теперь давайте сделаем, чтобы комната строилась не только по мановению руки богов мира нашей игры, но и просто со временем. Для этого создадим специальную команду и будем вызывать ее каждый ход:
>
> ```
> public class NextTurn : Command
> {
> protected override bool Run ()
> {
> new ConstructionProgress().Execute(Core);
> // ..
> }
> }
>
> ```
>
>
>
> ```
> public class ConstructionProgress : Command
> {
> protected override bool Run ()
> {
> foreach (var room in Core.Ship.Rooms) {
> BuildingProgress(room.Building);
> }
>
> return true;
> }
>
> private void BuildingProgress (Building building)
> {
> building.Constructible.AddProgress();
>
> foreach (var module in building.Modules) {
> module.Constructible.AddProgress();
> }
> }
> }
>
> ```
>
И сразу покроем тестами, которые покажут, что код работает прекрасно:
>
> ```
> [TestMethod]
> public void Constructible ()
> {
> const int smelteryTime = 10;
> const int furnaceTime = 6;
>
> var core = new GameLogic.Core();
> var room = core.Ship.GetRoom(0);
>
> // Smeltery
>
> new BuildingConstruct(
> room,
> core.Factory.ProduceBuilding(BuildingType.Smeltery)
> )
> .Execute(core);
>
> Assert.IsFalse( room.Building.Constructible.IsReady );
>
> new NextTurnCount(smelteryTime - 1).Execute(core);
>
> Assert.IsFalse(room.Building.Constructible.IsReady);
>
> new NextTurn().Execute(core);
>
> Assert.IsTrue(room.Building.Constructible.IsReady);
>
> // Furnace
> new ModuleConstruct(
> room.Building,
> core.Factory.ProduceModule(ModuleType.Furnace),
> 2
> ).Execute(core);
>
> var module = room.Building.GetModule(2);
>
> Assert.IsFalse( module.Constructible.IsReady );
>
> new NextTurnCount(furnaceTime - 1).Execute(core);
>
> Assert.IsFalse(module.Constructible.IsReady);
>
> new NextTurn().Execute(core);
>
> Assert.IsTrue(module.Constructible.IsReady);
> }
>
> ```
>
Добавляем ресурсы
-----------------
Для того, чтобы что-то создать сначала необходимо что-нибудь разрушить и собрать металлолом. Давайте реализуем ресурсы, чтобы игроку пришлось оплачивать свои постройки. Ресурсов будет три — Энергия, Руда и Металл.
>
> ```
> public enum ResourceType
> {
> Energy,
> Ore,
> Metal
> }
> ```
>
Также создадим Банк, где игрок будет хранить и откуда забирать ресурсы.
>
> ```
> public class Bank
> {
> private readonly Dictionary resources = new Dictionary();
>
> public int Get (ResourceType type)
> {
> return resources.ContainsKey(type) ? resources[type] : 0;
> }
>
> public void Change (ResourceType type, int value)
> {
> var current = Get(type);
>
> if (current + value < 0) {
> throw new ArgumentOutOfRangeException("Not enought " + type + " in bank");
> }
>
> resources[type] = current + value;
> }
> }
> ```
>
>
>
> ```
> public class Core
> {
> // ...
> public readonly Bank Bank = new Bank();
> }
> ```
>
Теперь добавляем цену производства в настройки модулей и строений:
>
> ```
> public class BuildingConfig
> {
> // ...
> public Dictionary ConstructionCost;
> }
> ```
>
>
>
> ```
> public class ModuleConfig
> {
> // ...
> public Dictionary ConstructionCost;
> }
> ```
>
>
>
> ```
> public class Factory
> {
> // ...
> Type = BuildingType.PowerPlant,
> ConstructionCost = new Dictionary() {{ ResourceType.Metal, 20 }},
> // ...
> Type = BuildingType.Smeltery,
> ConstructionCost = new Dictionary() {{ ResourceType.Metal, 20 }},
> // ...
> Type = BuildingType.Roboport,
> ConstructionCost = new Dictionary() {{ ResourceType.Metal, 20 }},
> // ...
> // ...
> Type = ModuleType.Generator,
> ConstructionCost = new Dictionary() {{ ResourceType.Metal, 10 }},
> // ...
> Type = ModuleType.Furnace,
> ConstructionCost = new Dictionary() {{ ResourceType.Metal, 10 }},
> // ...
> Type = ModuleType.Digger,
> ConstructionCost = new Dictionary() {{ ResourceType.Metal, 10 }},
> // ...
> Type = ModuleType.Miner,
> ConstructionCost = new Dictionary() {{ ResourceType.Metal, 40 }},
> // ...
> }
> ```
>
Теперь добавим команду, которая позволяет платить ресурсы и сразу же попробуем ее в деле (в тестах):
>
> ```
> public class Pay : Command
> {
> public readonly Dictionary Cost;
>
> public Pay (Dictionary cost)
> {
> Cost = cost;
> }
>
> protected override bool Run ()
> {
> // Если хотя бы одного ресурса не хватаем - отменяем всю оплату и возвращаем ошибку
> if (Cost.Any(item => Core.Bank.Get(item.Key) < item.Value)) {
> return false;
> }
>
> // Если всех хватает - забираем из банка
> foreach (var item in Cost) {
> Core.Bank.Change(item.Key, -item.Value);
> }
>
> return true;
> }
> }
>
> ```
>
>
>
> ```
> [TestClass]
> public class Player
> {
> [TestMethod]
> public void Payment ()
> {
> var core = new Core();
>
> core.Bank.Change(ResourceType.Metal, 100);
> core.Bank.Change(ResourceType.Ore, 150);
>
> Assert.IsFalse(
> new Pay(new Dictionary{
> { ResourceType.Metal, 100 },
> { ResourceType.Ore, 2000 }
> })
> .Execute(core)
> .IsValid
> );
>
> Assert.AreEqual(100, core.Bank.Get(ResourceType.Metal));
> Assert.AreEqual(150, core.Bank.Get(ResourceType.Ore));
>
> Assert.IsTrue(
> new Pay(new Dictionary{
> { ResourceType.Metal, 100 },
> { ResourceType.Ore, 30 }
> })
> .Execute(core)
> .IsValid
> );
>
> Assert.AreEqual(0, core.Bank.Get(ResourceType.Metal));
> Assert.AreEqual(120, core.Bank.Get(ResourceType.Ore));
> }
> }
> ```
>
Оплата работает корректно и начать платить за постройки и модули довольно просто — добавим вызов команды Pay в качестве последней валидации (она должна быть последней, если мы не хотим, чтобы после оплаты другая проверка не дала построить конструкцию):
>
> ```
> public class BuildingConstruct : Command
> {
> // ...
>
> protected override bool Run ()
> {
> // ...
>
> if (!new Pay(Building.Config.ConstructionCost).Execute(Core).IsValid) {
> return false;
> }
>
> Room.Building = Building;
>
> return true;
> }
> }
>
> ```
>
>
>
> ```
> public class ModuleConstruct : Command
> {
> // ...
>
> protected override bool Run ()
> {
> // ...
>
> if (!new Pay(Module.Config.ConstructionCost).Execute(Core).IsValid) {
> return false;
> }
>
> Building.SetModule(Position, module);
>
> return true;
> }
> }
> ```
>
К счастью, у нас снова отвалились тесты (к счастью, потому что это значит, что они отлично выполняют свою работу).
В старых тестах добавим игроку ресурсы и напишем новый тест, который в будущем будет проверять, что внезапно не появилась возможность бесплатно построить конструкцию. Добавляем во все сломанные тесты поближе к началу:
```
core.Bank.Change(ResourceType.Metal, 1000);
```
И пишем тест на постройку с недостачей ресурсов:
>
> ```
> [TestMethod]
> public void CantBuiltCostly ()
> {
> var core = new GameLogic.Core();
> var room = core.Ship.GetRoom(0);
>
> core.Bank.Change(ResourceType.Metal, 3);
>
> Assert.IsFalse(
> new BuildingConstruct(
> room,
> core.Factory.ProduceBuilding(BuildingType.Smeltery)
> )
> .Execute(core)
> .IsValid
> );
> }
>
> ```
>
Добавляем цикл производства
---------------------------
Забирать ресурсы, конечно, приятно, но давать значительно приятнее. Давайде запрограммируем возможность запускать производственные цепочки. Каждый модуль сможет скушать определенное количество сырья и потом выдать готовый материал. Снова начинаем с конфигурации:
>
> ```
> public class ModuleConfig
> {
> // ...
>
> public int CycleTime; // сколько времени модуль будет перетравливать сырье
> public Dictionary CycleInput; // сколько сырья
> public Dictionary CycleOutput; // какой выход готовой продукции
> }
>
> ```
>
>
>
> ```
> public class Module
> {
> // ...
> public readonly Progression Cycle;
>
> public Module (ModuleConfig config)
> {
> // ...
>
> Cycle = new Progression(config.CycleTime);
> }
> }
>
> ```
>
>
>
> ```
> public class Factory
> {
> // ...
>
> { ModuleType.Generator, new ModuleConfig() {
> // ...
>
> CycleTime = 12,
> CycleInput = null, // электростанция ничего не требует, только дает
> CycleOutput = new Dictionary() {
> { ResourceType.Energy, 10 }
> },
> }},
> { ModuleType.Furnace , new ModuleConfig() {
> // ...
>
> CycleTime = 16,
> CycleInput = new Dictionary() {
> { ResourceType.Energy, 6 },
> { ResourceType.Ore, 4 },
> },
> CycleOutput = new Dictionary() {
> { ResourceType.Metal, 5 }
> }
> }},
> { ModuleType.Digger , new ModuleConfig() {
> // ...
>
> CycleTime = 18,
> CycleInput = new Dictionary() {
> { ResourceType.Energy, 2 }
> },
> CycleOutput = new Dictionary() {
> { ResourceType.Ore, 7 }
> }
> }},
> { ModuleType.Miner , new ModuleConfig() {
> // ...
>
> CycleTime = 32,
> CycleInput = new Dictionary() {
> { ResourceType.Energy, 8 }
> },
> CycleOutput = new Dictionary() {
> { ResourceType.Ore, 40 }
> }
> }}
>
> ```
>
Теперь добавим в каждый ход прогресс по производству:
>
> ```
> public class NextTurn : Command
> {
> protected override bool Run ()
> {
> new CycleProgress().Execute(Core); // Добавьте его в начало, это будет важно в тестах
> // ...
> }
> }
>
> ```
>
>
>
> ```
> public class CycleProgress : Command
> {
> protected override bool Run ()
> {
> foreach (var room in Core.Ship.Rooms) {
> BuildingProgress(room.Building);
> }
>
> return true;
> }
>
> private void BuildingProgress (Building building)
> {
> if (!building.Constructible.IsReady) return;
>
> foreach (var module in building.Modules) {
> ModuleProgress(module);
> }
> }
>
> private void ModuleProgress (Module module)
> {
> if (!module.Constructible.IsReady || module.Cycle.IsFake) {
> return;
> }
>
> // Добавляем прогресс только если модуль уже запущен (ресурсы были заплачены)
> // Или если мы можем запустить его сейчас (заплатить ресурсы)
> if (module.Cycle.IsRunning || TryStartCycle(module)) {
> AddStep(module);
> }
> }
>
> private void AddStep (Module module)
> {
> module.Cycle.AddProgress();
>
> // Если после добавления прогресса работа модуля завершена...
> if (module.Cycle.IsReady) {
> // ... отдаем игроку его ресурсы
> CycleOutput(module);
> // ... и обнуляем прогресс, следующий раз ему придется запускаться сначала
> module.Cycle.Reset();
> }
> }
>
> private bool TryStartCycle (Module module)
> {
> if (module.Config.CycleInput == null) {
> return true;
> }
>
> // Пытаемся заплатить ресурсы и если удается - модуль запущен
> return new Pay(module.Config.CycleInput).Execute(Core).IsValid;
> }
>
> private void CycleOutput (Module module)
> {
> foreach (var item in module.Config.CycleOutput)
> {
> // Отдаем игроку каждый ресурс, который ему был нужен
> Core.Bank.Change(item.Key, item.Value);
> }
> }
> }
>
> ```
>
Класс получился крупноват, но мы всегда можем его отрефакторить, если сложность будет завысокая. Теперь пишем тест. Он будет довольно длинный, проверять и корректность производства, и незапуск в случае недостачи ресурсов. Также я специально для теста создал отдельные настройки для модуля и строения (вдруг ГД их поменяет и у меня тесты упадут). В идеале все тесты можно было бы поменять на специальные тестовые настройки:
>
> ```
> public class Cycle
> {
> [TestMethod]
> public void CheckCycle ()
> {
> var buildingConfig = new BuildingConfig() {
> Type = BuildingType.Smeltery,
> ModulesLimit = 1,
> AvailableModules = new [] { ModuleType.Furnace }
> };
>
> var moduleConfig = new ModuleConfig() {
> Type = ModuleType.Furnace,
>
> ConstructionTime = 2,
> ConstructionCost = new Dictionary() {
> { ResourceType.Metal, 10 }
> },
>
> CycleTime = 4,
> CycleInput = new Dictionary() {
> { ResourceType.Ore, 10 },
> { ResourceType.Energy, 5 }
> },
> CycleOutput = new Dictionary() {
> { ResourceType.Metal, 1 }
> }
> };
>
> var core = new Core();
> core.Bank.Change(ResourceType.Metal, 10);
> core.Bank.Change(ResourceType.Ore, 80);
> core.Bank.Change(ResourceType.Energy, 10);
>
> var building = new Building(buildingConfig);
> core.Ship.GetRoom(0).Building = building;
>
> var module = new Module(moduleConfig);
>
> Assert.IsTrue(
> new ModuleConstruct(building, module, 0)
> .Execute(core)
> .IsValid
> );
>
> new NextTurn().Execute(core);
>
> Assert.IsFalse(module.Cycle.IsRunning);
>
> new NextTurn().Execute(core);
>
> Assert.IsTrue(module.Constructible.IsReady);
> Assert.IsFalse(module.Cycle.IsRunning);
>
> new NextTurn().Execute(core);
> Assert.IsTrue(module.Cycle.IsRunning);
> Assert.AreEqual(1, module.Cycle.Progress);
>
> Assert.AreEqual(70, core.Bank.Get(ResourceType.Ore));
> Assert.AreEqual(5, core.Bank.Get(ResourceType.Energy));
> Assert.AreEqual(0, core.Bank.Get(ResourceType.Metal));
>
> new NextTurnCount(3).Execute(core);
> Assert.IsFalse(module.Cycle.IsRunning);
>
> Assert.AreEqual(70, core.Bank.Get(ResourceType.Ore));
> Assert.AreEqual(5, core.Bank.Get(ResourceType.Energy));
> Assert.AreEqual(1, core.Bank.Get(ResourceType.Metal));
>
> new NextTurn().Execute(core);
> Assert.IsTrue(module.Cycle.IsRunning);
>
> Assert.AreEqual(60, core.Bank.Get(ResourceType.Ore));
> Assert.AreEqual(0, core.Bank.Get(ResourceType.Energy));
> Assert.AreEqual(1, core.Bank.Get(ResourceType.Metal));
>
> new NextTurnCount(3).Execute(core);
> Assert.IsFalse(module.Cycle.IsRunning);
>
> Assert.AreEqual(2, core.Bank.Get(ResourceType.Metal));
>
> new NextTurn().Execute(core); // Cant launch because of Energy leak
> Assert.IsFalse(module.Cycle.IsRunning);
> Assert.AreEqual(60, core.Bank.Get(ResourceType.Ore));
> Assert.AreEqual(0, core.Bank.Get(ResourceType.Energy));
> }
> }
>
> ```
>
Конец
-----
Итак, тесты запустились корректно и мы смогли сделать минимальную версию нашего продукта. Класс Factory получился раздутым, но если вынести настройки в JSON, то и он будет вполне ничего. Используя Json.NET нам необходимо написать что-то вроде этого:
**Настройки в JSON**
>
> ```
> var files = Directory.GetFiles(path + "/Items/Modules", "*.json", SearchOption.AllDirectories);
> var modules = new List();
>
> foreach (var file in modules) {
> var content = File.ReadAllText(file);
> modules.Add( JsonConvert.DeserializeObject(content) );
> }
>
> ```
>
>
>
>
>
> ```
> {
> "Type": "Generator",
>
> "ConstructionTime": 5,
> "ConstructionCost": {
> "Metal": 10
> },
>
> "CycleTime": 12,
> "CycleInput": {
> "Energy" 6,
> "Ore": 4,
> },
> "CycleOutput": {
> "Energy": 10
> }
> }
>
> ```
>
Для тех, кто просто любит код — есть [отдельный репозиторий на ГитХаб](https://github.com/theshock/GameLogicArticle)
Кроме этого, если вас интересуют вопросы по разработке SpaceLab — задавайте, отвечу на них в комментариях или в отдельной статье
Скачать для Windows, Linux, Mac бесплатно и без СМС, а так же поддержать нас можно на [странице SpaceLab на GreenLight](http://steamcommunity.com/sharedfiles/filedetails/?id=868755125) | https://habr.com/ru/post/322268/ | null | ru | null |
# Катаем «смоляной шарик» или создание собственных правил сборки с помощью Qbs
[Qbs](https://doc.qt.io/qbs/index.html) (Qt Build System) — система сборки, позволяющая описывать процесс сборки проектов на простом языке QML (javascript-подобный декларативный язык), ускоряющий процесс сборки продуктов за счет построения подробного графа зависимостей. Хоть эта система и создана разработчиками Qt, но она жестко не привязана к Qt и позволяет собирать любые продукты, для любых языков программирования и даже использоваться не для программирования, а например для администрирования. Как заявлено в официальной документации:
> A product is the target of a build process, typically an application, library or maybe a tar ball
Сегодня и рассмотрим процесс создания своих продуктов. Поехали…
Знакомство с это системой сборки хорошо описал [mapron](https://habrahabr.ru/users/mapron/) в [данной статье](https://habrahabr.ru/post/144127/), мы же не будем на этом останавливаться и приступим сразу к делу.
К сожалению в документации и сети слишком мало информации о деталях работы Qbs и значении свойств элементов. По этому я попробую восполнить некоторые пробелы в этом, опираясь на свой опыт работы с данной системой сборки. И буду благодарен читателям за дополнение или указания неточностей в данном материале.
Итак Qbs выполняет преобразования одних данных в другие с помощью элемента **[Rule](https://doc.qt.io/qbs/rule-item.html)**. Данный элемент создает правило преобразования, которое преобразует входные данные **inputs** в выходные **outputs** при помощи набора команд, созданных в скрипте **prepare**. Каждая команда может как сама выполнять преобразования, так и делегировать эту работу внешней программе.
### Входные артефакты
В качестве входных артефактов для правила преобразования выступают файлы собираемого продукта с тегом указанным в свойстве **inputs**, а также артефакты полученные из зависимостей собираемого продукта с тегом указанным в свойстве **inputsFromDependencies** (неявным является тег "***installable***", который присваивается всем файлам которые необходимо проинсталлировать, т.е. ***qbs.install: true***).
Например:
```
---product1.qbs---
Application {
name: "simpleApplication";
targetName: "appSimple"
files: ["main.cpp", "app.h", "app.cpp"]
Depends {name: "cpp"}
}
---product2.qbs---
Product {
type: "exampleArtefact"
name: "example"
targetName: "myArtefact"
Depends {name: "simpleApplication" }
Depends {name: "exampleModule" }
Group {
files: ["description.txt", "readme.txt"]
fileTags: ["txtFiles"]
}
Group {
files: ["imgA.png", "imgB.png", "imgC.png"]
fileTags: ["pngFiles"]
}
Group {
files: ["fontA.ttf", "fontB.ttf"]
fileTags: ["fontFiles"]
}
}
---exampleModule.qbs---
Module {
Rule {
inputs: ["pngFiles", "fontFiles"]
inputsFromDependencies: ["application"]
Artifact {
filePath: product.targetName + ".out"
fileTags: ["exampleArtefact"]
}
...
}
...
}
```
В данном примере у нас есть 2 продукта и 1 модуль:
1. Продукт с названием **simpleApplication** имеющий тип application (элемент Application по сути является ***Product {type: «application»}***) содержащая 3 файла: main.cpp, app.h, app.cpp. Этот продукт зависит от модуля cpp, что указывает на то, что будет выполняться компиляция этого продукта компилятором C++ и на выходе получится артефакт помеченный тегом «application» и названием указанным в свойстве targetName, т.е. appSimple.exe (для windows или appSimple для unix платформ).
2. Продукт с названием **example** имеющий тип exampleArtefact содержащий 7 файлов помеченных тремя тегами. Этот продукт зависит от продукта simpleApplication, что указывает на то, что он будет обрабатываться после создания продукта simpleApplication. А также от модуля exampleModule, что указывает на то, что для создания данного продукта будут браться правила преобразования и свойства из этого модуля. И на выходе ожидается артефакт с названием myArtefact типа (с тегом) exampleArtefact.
3. Модуль **exampleModule** содержит правило преобразования файлов с тегами pngFiles и fontFiles, а также артефактов имеющих тег application, которые берутся из зависимостей собираемого продукта.
При сборке продукта будет определен список модулей от которых зависит продукт и сами модули. В них будет осуществлен поиск правил преобразования файлов помеченных входными тегами в выходные артефакты, которые соответствуют типу собираемого продукта. Сначала собирается продукт simpleApplication, т.к. он имеет зависимость только от модуля cpp. В нем ищутся правила преобразования файлов продукта в тип application. В модуле cpp есть элементы [FileTagger](https://doc.qt.io/qbs/filetagger-item.html) которые по шаблону задают для файлов продукта теги. Преобразование входных файлов в выходной(ые) может быть выполнено как сразу, так и по цепочке преобразований файлов одного типа в другой, а затем в итоговый. На выходе обработки продукта simpleApplication, мы получим приложение appSimple имеющее тип (тег) application.
Затем начнется сборка продукта example. Для его файлов будет искаться правило, на выходе дающее артефакты типа exampleArtefact. Это правило требует для входа файлы типа (с тегом) pngFiles, fontFiles и application. При этом файлы типа application ищутся только в продуктах от которых зависит собираемый продукт. Так как продукт example уже содержит такие файлы, то на вход правила поступают файлы: imgA.png, imgB.png, imgC.png, fontA.ttf, fontB.ttf и appSimple.exe. А на выходе получим файл myArtefact.out типа exampleArtefact, который и будет являться нашим конечным продуктом.
### Выходные артефакты
В качестве выходных артефактов для правила могут быть как один, так и несколько артефактов. Для описания выходных артефактов используется элемент **[Artifact](https://doc.qt.io/qbs/artifact-item.html)**:
```
Artifact {
filePath: input.fileName + ".out"
fileTags: ["txt_output"]
}
```
Этот элемент описывает, какой артефакт получается на выходе правила. Через свойство **filePath** — указывается имя выходного файла. Если указывать относительный путь, то Qbs будет создавать этот артефакт относительно каталога сборки текущего собираемого продукта. Через свойство **fileTags** указывается список тегов, которые будет иметь артефакт после его создания. Это необходимо, для того чтобы другие правила сборки могли использовать выходные артефакты данного правила, как свои входные артефакты. Также если продукт будет иметь этот же тег в качестве своего типа, то эти артефакты будут являться результатом сборки этого продукта.
У каждого правила должен быть хоть один выходной тег, иначе правило работать не будет. Если артефактов несколько, то можно описать несколько элементов Artifact либо можно воспользоваться свойствами outputArtifacts и outputFileTags для элемента Rule.
Свойство **outputArtifacts** описывает список JavaScript объектов имеющих свойства, как у элемента Artifact. Используется это свойство для случаев, когда набор выходов не фиксирован, а зависит от содержания входных данных. Например:
```
outputArtifacts: [{
var artifactNames = inputs["pngFiles"].map(function(file){
return "pictures/"+file.fileName;
});
artifactNames = artifactNames.concat(inputs["fontFiles"].map(function(file){
return "fonts/"+file.fileName;
}));
artifactNames = artifactNames.concat(inputs["application"].map(function(file){
return "app/"+file.fileName;
}));
var artifacts = artifactNames.map(function(art){
var a = {
filePath: art,
fileTags: ["exampleArtefact"]
}
return a;
});
return artifacts;
}]
```
В данном примере показано, что для входных файлов с тегом pngFiles, правило подготовит выходной артефакт с таким же названием и поместит его в папку pictures. Для тегов fontFiles и application, также поместив их соответственно в папки fonts и app. При этом т.к. пути будут относительные, то эти папки создадутся в папке сборки продукта.
Если мы решили использовать свойство outputArtifacts, то необходимо указать и свойство **outputFileTags**, которое является списком выходных тегов, которые правило потенциально производит. Для нашего примера:
```
outputFileTags:
["exampleArtefact"]
```
Все полученные при сборке продукта артефакты, помеченные выходным тегом совпадающим с типом продукта, при установке продукта, будут скопированы из каталога сборки в каталог установки.
### Правило преобразования
Когда определены входные и выходные артефакты, необходимо подготовить саму последовательность команд для выполнения преобразования. Для этого используется свойство **prepare** элемента Rule. Это свойство является JavaScript сценарием, который возвращает список команд для преобразования входов в выходы. Код в этом скрипте рассматривается как функция с сигнатурой ***function(project, product, inputs, outputs, input, output)***.
Параметры **input** и **output** не определены (undefined), если для этого правила имеется несколько артефактов ввода (и вывода соответственно). Служат они как синтаксический сахар: input = inputs[0] и output = outputs[0] и являются списками с одним элементом. Параметры **project** и **product**, являются JavaScript объектами, через которые доступны свойства текущего проекта и продукта соответственно. Особый интерес вызывают объекты inputs и outputs. Рассмотрим их более подробно.
#### Объекты inputs и outputs
Параметры **inputs** и **outputs** являются объектами JavaScript, ключи свойств которых являются файловыми тегами, а значениями свойств — являются списки объектов, представляющих артефакты, соответствующие этим тегам. В нашем примере переменная inputs имеет 3 ключа: pngFiles, fontFiles, application. А каждый входной артефакт доступен через inputs[«pngFiles»] (или inputs.pngFiles что равнозначно). Каждый артефакт в этом списке имеет следующие свойства:
* **baseName** — базовое имя файла (например для файла c:\123\test.plugin.dll это будет test)
* **completeBaseName** — название файла без расширения (например для файла c:\123\test.plugin.dll это будет test.plugin)
* **fileName** — название файла (например для файла c:\123\test.plugin.dll это будет test.plugin.dll)
* **filePath** — полный путь до файла с его полным именем
* **fileTags** — список тегов присвоенных артефакту
Помимо этого артефакты содержат в себе все свойства для каждого модуля, который используется в продукте. Эта особенность может использоваться для доступа к свойствам модуля. Например, свойство ***inputs.application[0].cpp.defines*** вернет для артефакта simpleApplication список определений, который будет передан при компиляции соответствующего файла. Это очень удобный и важный момент, позволяющий артефактам задать через свойства какого-нибудь модуля свои значения и группировать такие артефакты или обрабатывать их как-то по особенному.
*\* Было подмечено на Qbs версии 1.7.2, что если продукт подменяет свойства модуля в котором находится правило сборки, то эти свойства недоступны в артефакте. По этому эти свойства я выносил в отдельный модуль.**\* Также inputs.application[0].cpp.defines не всегда срабатывает, по этому я использую функцию **inputs.application[0].moduleProperty(«cpp», «defines»)**. Если эту функцию применять к входному артефакту, то будут возвращаться свойства которые использует **артефакт** в указанном модуле. Если же применять ее к продукту (например product.moduleProperty(«cpp», «defines»), то возвращаться будут свойства указанного модуля, которые использует собираемый в данный момент конечный **продукт**.*
*\* Очень удобной функцией является **dumpObject(object)** из модуля ModUtils, которая выводит в консоль информацию о свойствах переданного в него параметра. Правда и она не всегда показывает свойства используемых в артефактах модулей.*
#### Команды
В качестве результата выполнения скрипта выступает список команд. Команда — это то, что Qbs выполняет во время сборки. Команда всегда создается в сценарии подготовки правила. Команды бывают двух типов:
1. **Command**, который запускает внешний процесс
2. **JavaScriptCommand**, который выполняет произвольный код JavaScript (хотя может также запускать внешние процессы)
Для обоих типов команд доступны свойства:
* **description** — строка, показываемая в консоли при выполнении данной команды
* **extendedDescription** — строка детальной информации, показываемой в консоли при расширенном выводе
* **highlight** — тип (тег) команды. Влияет на то, как будет показываться description в консоли. Может быть: compiler, linker, codegen, filegen и пр.
* **silent** — скрывать ли вывод description при выполнении команды
Для использования **Command**, необходимо создать объект передав в его конструктор полный путь до исполняемой программы и список аргументов.
```
var myCommand = new Command("dir", ["/B", "/O", ">>", output.filePath]);
```
Например данная команда запишет вывод команды dir в выходной файл правила сборки.
Полезными свойствами, позволяющими обойти ограничение Windows на длину командной строки являются свойства:
* **responseFileThreshold** содержит значение. Если это значение больше нуля и меньше длины полной командной строки, и если responseFileUsagePrefix не пуст, то содержимое командной строки перемещается во временный файл, путь которого становится полным содержимым списка аргументов. Затем программа должна прочитать полный список аргументов из этого файла. Этот механизм будет работать только с программами, которые явно поддерживают его.
* **responseFileArgumentIndex** — указывает индекс первого аргумента для включения в файл ответов.
* **responseFileUsagePrefix** — содержит префикс, который сообщает программе, что остальная часть аргумента — это путь к файлу, содержащему фактическую командную строку.
Для обработки вывода выполняемой команды могут применяться свойства:
* **stderrFilterFunction** — функция с входным параметром равным выводу программы в stderr и которая должна вернуть преобразованную строку для дальнейшего вывода.
Если не задана, то обработки не будет производиться.
* **stdoutFilterFunction** — аналогичная stderrFilePath, только работающая с stdout
* **stdoutFilePath** — название файла, кода направляется отфильтрованный ранее вывод stdout. Если не задан, то вывод будет производиться в консоль
* **stderrFilePath** — аналогичная stdoutFilePath, только работает с stderr
**JavaScriptCommand** команда — представляет собой JavaScript функцию, которая будет выполняться при сборке. Задается это функция в свойстве **sourceCode**. В исходном коде функции доступны project, product, inputs и outputs (дающий доступ к свойствам проекта, продукта, входных и выходных артефактов соответственно). Чтобы передать в функцию произвольные данные, то для команды надо добавить произвольные свойства и присвоить им нужные значения. Например так:
```
var cmd = new JavaScriptCommand();
cmd.myFirstData = "This is 1 string";
cmd.mySecondData = "This is 2 string";
cmd.sourceCode = function() {
console.info("String from source code"); // -->> "String from source code"
console.info("Property 1: "+myFirstData); // -->> "Property 1: This is 1 string"
console.info("Property 2: "+mySecondData); // -->> "Property 2: This is 2 string"
};
```
В функции, также можно использовать разные [доступные сервисы](https://doc.qt.io/qbs/list-of-builtin-services.html):
* **Environment Service** — для доступа к системной среде и среде разработки
* **File Service** — для работы с файлами (копирование, перемещение, удаление файлов, проверки существования файла и даты модификации, создания путей и сканирования директории на содержимое)
* **FileInfo Service** — операции обработки пути к файлу (получение базового имени файла, пути к нему, получение относительного пути и т.п.)
* **General Services** — дополнительные функции расширяющие функционал обработки строк, массивов и т.п.
* **Process Service** — функции позволяющие запускать и управлять внешними программами, а также работать с его входом и выходом
* **PropertyList Service** — функции для работы со списками свойств в форматах JSON, XML, binaty и OpenStep для платформ Darwin (iOS, macOS, tvOS, и watchOS)
* **TemporaryDir Service** — функции для создания и управления временным каталогом
* **TextFile Service** — функции для работы с текстовыми файлами и позволяющие читать/писать из/в них.
* **Utilities Service** — функции для получения хешей
### Прочие свойства элемента Rule
У элемента Rule также есть несколько дополнительных свойств:
Свойство **multiplex**, необходимо для указания порядка обработки входных артефактов. При multiplex=true, создается одна копия правила для всех входных артефактов и они обрабатываются все скопом. Таким образом в свойстве inputs будут все входные артефакты. Применяется в случаях, когда надо производить групповую обработку входных артефактов. Если же multiplex=false, то для каждого входного артефакта будет создаваться отдельная копия правила преобразования и будет создаваться свой выходной артефакт. Таким образом свойство inputs будет содержать всегда один элемент. По умолчанию это свойство имеет значение false.
Свойство **condition**, указывает на условие выполнения правила. Например, указать, что преобразование будет выполняться только в режиме release и для платформы windows.
```
qbs.buildVariant === "release" && qbs.targetOS.contains("windows")
```
Свойство **explicitlyDependsOn** представляет собой список тегов. Каждый артефакт, тег которого совпадает с тегом перечисленным в этом свойстве, ставится в зависимость для каждого выходного артефакта. Таким образом на выходе мы можем получить выходные артефакты с уже подготовленными зависимостями для дальнейшей обработки.
Свойство **alwaysRun** указывает, на условия выполнения команд в правиле. Если alwaysRun=true, то команды будут всегда выполняться, даже не взирая на то, что выходные артефакты уже обновлены. По умолчанию равно false.
### Пример подготовки правила преобразования
В качестве примера правила приведу следующую задачу:
Имеется проект, из нескольких программ и библиотек, для которого необходимо скопировать все необходимые для работы программ Qt библиотеки и плагины в заданную директорию. Для этого создаем модуль с правилом преобразования и самостоятельный продукт, который будет зависеть от всех продуктов проекта, для которых и необходимо подготовить Qt библиотеки. Дополнительно надо подготовить тестовый файл с указанием всех подготовленных Qt библиотек.
**winDeployQt - деплой Qt библиотек для проекта**
```
-- MyWindowsDeploy.qbs --
import qbs
import qbs.ModUtils
Module {
Rule {
condition: qbs.targetOS.contains("windows") //запускается только для windows
multiplex: true //обрабатываем все входные артефакты одним трансформером
alwaysRun: true //всегда выполнять правило
inputsFromDependencies: ["installable"] //брать устанавливаемые артефакты от зависимостей собираемого продукта
Artifact {
filePath: "Copied_qt_libs.txt";
fileTags: ["deployQt"];
}
prepare: {
var cmdQt = new JavaScriptCommand();
//определяем путь до windeployqt.exe
cmdQt.windeployqt = FileInfo.joinPaths(product.moduleProperty("Qt.core", "binPath"), "windeployqt.exe");
//задаем строку для вывода в консоли
cmdQt.description = "Copy Qt libs and generate text file: "+output.fileName;
//указываем развернутую информацию по выполняемой команде
cmdQt.extendedDescription = cmdQt.windeployqt + ".exe " +
["--json"].concat(args).concat(binaryFilePaths).join(" ");
//путь до папки, куда надо копировать qt библиотеки ("<папка установки>/QtLibs")
var deployDir = FileInfo.joinPaths(product.moduleProperty("qbs","installRoot"),
product.moduleProperty("qbs","installDir"));
deployDir = FileInfo.joinPaths(deployDir, "QtLibs");
cmdQt.qtLibsPath = deployDir;
//определяем аргументы запуска программы
cmdQt.args = [];
cmdQt.args.push("--libdir", deployDir);
cmdQt.args.push("--plugindir", deployDir);
cmdQt.args.push("--no-translations");
cmdQt.args.push("--release");
//полное имя файла для записи вывода.
cmdQt.outputFilePath = output.filePath;
//определяем список путей установки программ и библиотек, от которых зависит продукт
cmdQt.binaryFilePaths = inputs.installable.filter(function (artifact) {
return artifact.fileTags.contains("application")
|| artifact.fileTags.contains("dynamiclibrary");
}).map(function(a) { return ModUtils.artifactInstalledFilePath(a); });
cmdQt.sourceCode = function(){
var process;
var tf;
try {
//выводим значения параметров
console.info("windeployqtRule: outputFilePath: "+outputFilePath);
console.info("windeployqtRule: qtLibsPath: "+qtLibsPath);
console.info("windeployqtRule: windeployqt: "+windeployqt);
console.info("windeployqtRule: windeployqtArgs: "+windeployqtArgs.join(", "));
console.info("windeployqtRule: binaryFilePaths: "+binaryFilePaths.join(", "));
//создаем папку куда будут скопированы библиотеки Qt
File.makePath(qtLibsPath);
//создаем процесс
process = new Process();
//запускаем процесс
process.exec(windeployqt,
["--json"].concat(windeployqtArgs).concat(binaryFilePaths), true);
//читаем вывод программы
var out = process.readStdOut();
//парсим выходной JSON
var inputFilePaths = JSON.parse(out)["files"].map(function (obj) {
//определяем полный путь доя скопированной библиотеки
var fn = FileInfo.joinPaths(
FileInfo.fromWindowsSeparators(obj.target),
FileInfo.fileName(
FileInfo.fromWindowsSeparators(
obj.source)));
return fn;
});
//создаем файл
tf = new TextFile(outputFilePath, TextFile.WriteOnly);
//пишем заголовок
tf.writeLine("Copied Qt files:");
inputFilePaths.forEach(function(qtLib){
tf.writeLine(qtLib); //записываем в выходной файл полный путь до скопированной библиотеки
});
} finally {
if (process)
process.close();
if (tf)
tf.close();
}
}
return [cmdQt];
}
}
}
```
**Пример продукта**
```
-- ProductDeploy.qbs --
import qbs
Product {
//продукт представляет собой результат деплоя Qt библиотек для продуктов от которых он
//зависит в виде скопированных библиотек и текстового файла
type: ["deployQt"]
// указываем зависимость от модуля в котором есть правило преобразования
Depends { name: "MyWindowsDeploy" }
// указываем зависимость от продуктов, для которых
// надо подготовить Qt библиотеки, плагины и пр.
Depends { name: "libratyA" }
Depends { name: "libratyB" }
Depends { name: "applicationA" }
Depends { name: "applicationB" }
Depends { name: "applicationC" }
condition: qbs.targetOS.contains("windows") // собирать только для windows
builtByDefault: false // собирать ли продукт при общей сборке проекта
qbs.install: true
qbs.installDir: "MyProject/qtDeploy"
}
```
### Ссылки
* [doc.qt.io/qbs/index.html](https://doc.qt.io/qbs/index.html) — официальная документация
* [habrahabr.ru/post/144127](https://habrahabr.ru/post/144127/) — знакомство с Qbs
* [www.opennet.ru/opennews/art.shtml?num=33102](https://www.opennet.ru/opennews/art.shtml?num=33102) — новость о презентации Qbs
* [stackoverflow.com/questions/tagged/qbs](https://stackoverflow.com/questions/tagged/qbs) — вопрос-ответ по возникающим проблемам
* [github.com/qt-labs/qbs](https://github.com/qt-labs/qbs) — git репозиторий | https://habr.com/ru/post/330218/ | null | ru | null |
# Работа с MySQL: как масштабировать хранилище данных в 20 раз за три недели
[](https://habrahabr.ru/company/latera/blog/282798/)
Ранее в блоге на Хабре мы рассказывали о развитии нашего продукта — [биллинга для операторов связи «Гидра»](http://www.hydra-billing.ru/), а также рассматривали вопросы работы с инфраструктурой и использования новых технологий. К примеру, мы рассмотрели [плюсы Clojure](https://habrahabr.ru/company/latera/blog/280734/), ситуации, когда стоит и [не стоит использовать MongoDB](https://habrahabr.ru/company/latera/blog/280196/) и [ограничения в PostgreSQL](https://habrahabr.ru/company/latera/blog/282281/).
Сегодня речь пойдет о масштабировании. Разработчики open-source почтового приложения Nylas опубликовали в своем блоге [материал](https://nylas.com/blog/growing-up-with-mysql/) о том, как им удалось масштабировать систему в 20 раз за три недели с помощью инструмента ProxySQL. Для этого им пришлось переехать с Amazon RDS на MySQL на EC2. Мы представляем вашему вниманию основные моменты этой интересной заметки.
#### Одним прекрасным днем…
История началась летом 2015. Солнце пробивалось сквозь туман, зависший над Сан-Франциско, по радио играл хит [Bad Blood](https://www.youtube.com/watch?v=QcIy9NiNbmo) Тейлор Свифт и Кендрика Ламара. В распоряжении Nylas были лишь две машины синхронизации и одна база MySQL, управляемая через Amazon RDS. Это было самое простое решение, которое компании удалось на тот момент найти.
Инженерам компании удалось добиться хорошей производительности этой конфигурации так что они неспешно работали над улучшением логики синхронизации и телеметрии. Команда понимала все опасности преждевременной оптимизации продукта. Все считали, что лучший способ преуспеть в горизонтальном масштабировании системы (шардинге) – это откладывать его, насколько возможно. Поэтому, чтобы выиграть время, инженеры занимались оптимизацией работы с дисками, апгрейдом инстансов и сжатием данных
#### А затем появились пользователи
Все изменилось 5 октября 2015. В этот день вышел Nylas N1 – открытое email-приложение с красивым пользовательским интерфейсом и современной архитектурой с использованием плагинов. Ссылка на продукт была опубликована в Hacker News. По заверениям команды Nylas, это привело к появлению десятков тысяч новых пользователей за считанные минуты. А вместе с пользователями пришли большие объемы новой информации.
За час база на MySQL перестала справляться с такими объемами, а задержка работы API побила все рекорды. Пришлось временно отключить возможность регистрации. В компании еще не осознали всю глубину проблем, но одна вещь была очевидна всем: нужно масштабироваться как можно скорее.
#### На баррикады
В течение нескольких дней после запуска Nylas N1 удалось обнаружить сразу несколько узких мест в коде. Пришлось столкнуться с ограничениями Redis и MySQL на интенсивность записи данных. Инженеры узнали много нового и о работе с AWS.
Но самой серьезной проблемой была база данных. День и ночь команда Nylas пыталась исправить ошибки вроде утечки MySQL-соединений, а также плохо оптимизированные запросы, негативно влиявшие на производительность. Помимо того, чтобы залатать дыры, нужно было подумать о перспективе. Единственный вариант – применить горизонтальное масштабирование данных, чтобы обеспечить качественную поддержку новых пользователей. То есть все-таки пришло время шардинга системы.
#### Почему MySQL
В 2013, когда компания Nylas была основана, ее инженеры выбрали MySQL, не только исходя из специфических характеристик, но и потому что этот инструмент зарекомендовал себя в работе высоконагруженных проектов. Технологии Cassandra, MongoDB, и Postgres выглядели впечатляющими и быстро прогрессировали, но инженеры были уверены, что с помощью MySQL смогут создать систему обрабатывающую петабайты данных. Об этом говорил и опыт таких компаний как Facebook, Dropbox, Pinterest, и Uber. Использование MySQL позволяло опираться на опыт этих технологических гигантов.
Эта база проста в работе, а требования Nylas изначально были не особенно масштабными. Исходя из этого, было решено использовать хостинг Amazon RDS. RDS не дает root-доступа к хосту MySQL, зато многие процессы автоматизированы. Например, бэкапы и точечные обновления.
#### Время масштабировать
К моменту возникновения сложностей с производительностью инженеры уже сжали длинные текстовые колонки в базе, что помогло сэкономить 40% места на диске, а также перешли на использование 6-терабайтных дисков. Но InnoDB в СУБД MySQL имеет [ограничение 2 ТБ](http://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Limits.html#RDS_Limits.FileSize) на таблицу, что представляло собой проблему.
Инженеры рассматривали вариант с использованием Amazon Aurora — MySQL-совместимого хранилища с автомасштабированием до 64 Тб. Однако даже в этом случае, при превышении заданного лимита в 64 терабайта, чтобы уместиться в ограничения InnoDB, пришлось бы разбивать данные по различным таблицам. К тому же команде не хотелось настолько сильно зависеть от технологий Amazon в долгосрочной перспективе.
Вместо этого инженеры Nylas осуществили горизонтальное масштабирование с помощью разбиения данных по простой схеме, а также с помощью создания дополнительных MySQL-кластеров, работающих на версиях базы от Oracle на обычных инстансах EC2. Главной целью была простота конфигурации, что позволило завершить оптимизацию за три недели.
#### Прощай, RDS
В процессе масштабирования было решено отказаться от RDS. Причина в недостатке возможностей по контролю, а также неудачный опыт реализации решений для оптимизации. Казалось, что RDS — просто не решение для создания надежных систем с нулевым временем простоя.
Кроме того, в RDS крайне ограничены возможности настройки репликации. Да, в ней есть опция multi-AZ для синхронного копирования данных, но производительность таких операций оставляла желать лучшего. Однажды ее использование привело к 3-часовому простою в работе приложения Nylas. Пришлось связаться с инженерами Amazon и ждать, пока они исследуют проблему.
Также в Nylas пробовали создавать асинхронные копии для заданной мастер-базы, но оказалось, что активируется такая копия с задержкой в несколько минут. RDS не поддерживает последовательное копирование, которое планировалось использовать для разнесения шардов по инстансам базы.
Вместо этого выяснилось, что многие задачи можно успешно решать с помощью EC2. Да, с отдельными инстансами могут возникать проблемы, но можно было, по крайней мере, создать архитектуру базы, устойчивую к влиянию описанных выше проблем. В компании решили отказаться от RDS и управлять базой самостоятельно.
#### Запуск MySQL на EC2
Перевод MySQL на EC2 – не совсем простой процесс. Нужно было написать собственные скрипты для управления задачами, которые в RDS были автоматизированы — например провижининг новых серверов, создание и распределение slave-инстансов в случае сбоя master-базы и создание и восстановление резервных копий. В Nylas написали такие скрипты с нуля, но существует и [ряд открытых инструментов](https://engineering.pinterest.com/blog/open-sourcing-pinterest-mysql-management-tools), решающих те же задачи.
Один из шард-кластеров в MySQL состоит из управляющего узла и подчиненного узла. Второй поддерживает обновления через лог копирования MySQL, и обычно используется для бэкапов. В процессе перенастройки системы, перевода узлов на разные типы инстансов, кластер должен иметь более одного slave-инстанса. Если дополнительные слейвы не активны, они помечены тегом «debug» EC2, что исключает их из мониторинга, бэкапов и других процессов для активных узлов.
#### Аварийное переключение
Для каждого кластера базы нужно было предусмотреть ситуацию, когда узел мастера отказывается правильно функционировать. Это может произойти, когда процессы в базе сбиваются или виснут, хост становится недоступен, или происходит что-то еще в таком духе. На этот случай нужно иметь в запасе возможность восстановления, вручную или автоматически, когда slave-узел заменяет на время master-узел и получает одновременно запросы чтения и записи.
Чтобы решить эту задачу, был написан специальный скрипт, позволяющий инженерам вручную работать с slave-узлом таким образом. Как только в команде убедились, что эту операцию можно проводить, не опасаясь потерь данных, скрипт интегрировали в стандартный инструмент [mysqlfailover](https://dev.mysql.com/doc/mysql-utilities/1.5/en/mysqlfailover.html), с некоторыми добавлениями, позволяющими идентифицировать принадлежность узлов. Если происходит сбой в узле мастера, mysqlfailover узнает об этом через механизм проверки состояния и определяет слейв как нового мастера. Конструкция mysqlfailover, помимо прочего, обновляет теги EC2 для отображения новой конфигурации.
Восстановление работает автоматически, но инженеры получают оповещения. После чего, один из них может вручную выявлять узел, на котором произошел сбой, и преобразовывать его в новый слейв для кластера. Если такой возможности нет — например, в случае повреждения данных, предыдущий мастер выводится из эксплуатации, а новый слейв создается из самого последнего бэкапа. Система стала устойчивой к сбоям, и ей стало легче управлять.
Шардинг приложения
При переходе с одной базы данных к нескольким базам данных на разных машинах необходимо разработать новый механим маппинга ID объектов на конкретные серверы. Это особенно актуально, если приложение ссылается на базу по первичному ключу во вторичном хранилище, как это происходит у Redis.
Инженеры Nylas подобрали простое решение этой задачи: значение первичного ключа таблицы — это 64-битное целое число, верхние же биты содержат ID шарда, нижние биты являются локальным счетчиком автоматических числовых ключей.
```
|<--16bits-->|<--------48bits------->|
+------------+-----------------------+
| shard id | autoincrement |
+------------+-----------------------+
```
Это позволяет легко рассчитывать шард-ID по первичному ключу. Запрос на любой объект может быть направлен в правильный шард просто через первичный ключ. Чем проще система – тем надежнее работа с ней в перспективе.
Например, уровень аутентификации приложения способен конвертировать хэшированные токены доступа в ID аккаунта для доступа к API. Команде проекта удалось провести шардинг сервиса без изменения ключевых его компонентов. Поскольку движок Nylas так же как и приложение — открытый продукт, любой желающий может изучить [особенности реализации](https://github.com/nylas/sync-engine/blob/master/inbox/models/session.py#L106) такой системы на GitHub.
#### Создание новых шардов
Каждый логический шард – это отдельно пронумерованная MySQL-схема. Все шарды имеют одинаковую табличную структуру и разные шарды обычно размещены в одном инстансе.
При создании нового шарда рассчитать биты высокого порядка просто через:
`N = (shard_id<<48) + 1`
Значение автоматических чистовых ключей рассчитывается так:
```
ALTER TABLE mailsync_. AUTO\_INCREMENT=N
```
Новые ряды в таблице, соответственно, будут иметь первичные ключи N, N+1 и так далее. В данном случае таблицы базы имеют автоматические ключ, начинающиеся со значения 1. Инженеры Nylas советуют при использовании этого метода обращать внимание на ошибку MySQL под [номером #199](https://bugs.mysql.com/bug.php?id=199). Этому багу уже 13 лет, но он до сих пор не исправлен. Чтобы избежать проблем с ним, код приложения должен быть защищен от некорректных значений автоматических ключей — вот [здесь](https://github.com/nylas/sync-engine/blob/master/inbox/ignition.py#L170) представлено описание решения этой задачи (на английском).
#### Минимизация времени ожидания при отказе
После проведения шардинга, была обнаружена еще одна проблема. Конфигурация mysqlfailover использовала [вторичный IP-адрес Amazon VPC](http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/vpc-ip-addressing.html) в качестве виртуального IP, чтобы отправлять трафик приложения к узлу мастера. Но обнаружение сбоя в узле и переключение трафика через этот виртуальный айпи занимало порядка 10 минут. Все запросы в течение этого промежутка, разумеется, отклонялись.
Следовательно, нужно было реализовать гладкое аварийное переключение. Что-то наподобие того, как HAProxy может удерживать запросы при перезапуске сервиса приложения, только в приложении к MySQL.
Здесь можно использовать HAProxy в сочетании с хранилищем значений ключей, а можно использовать кластерные инструменты MySQL: [Orchestrator](https://github.com/outbrain/orchestrator) или [Galera](http://galeracluster.com/). В данном случае компания выбирала самое простое решение из доступных. В идеале – чтобы не было дополнительных сервисов, которые надо обслуживать.
#### ProxySQL
Такое решение было найдено в [ProxySQL](https://github.com/sysown/proxysql) – новом инструменте с открытой лицензией. Если не вдаваться в подробности, его можно рассматривать как HAProxy, только заточенный под запросы SQL. После того, как Nylas перешла на работу с ProxySQL, время ожидания при переключении узлов снизилось с 10 минут до 10 секунд.
*Переключение без ProxySQL (простой 10 минут)*
*Переключение с ProxySQL (простой 10 секунд)*
В процессе обнаружились другие преимущества работы с ProxySQL:
* динамическая маршрутизация;
* автоматические ограничения для запросов или транзакций, предотвращающие случайные спады производительности;
* статистика запросов: позволяет сравнивать запросы по узлам приложения, то есть понять, как загрузка распределена по шардам;
* возможность резко снижать количество экспортных соединений к актуальной базе данных машины.
Инженеры Nylas используют ProxySQL локально для каждого сервиса, подключающегося к базе, включая внутренние инструменты управления и скрипты. Использование прокси в локальном режиме вместо централизованного позволяет добиться встроенной избыточности, а также сводит к минимуму вероятность возникновения задережек трафика на прокси. В итоге шарды в системе могут динамически меремещаться между экземплярами базы данных — время простоя кластера при этом не превышает 12 секунд.
#### Перевод данных на другую платформу
В марте 2016 года компания осуществила миграцию шард 0 (RDS) на “in-house” MySQL на EC2 посредством функции [репликации](http://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/MySQL.Procedural.Exporting.NonRDSRepl.html). Это позволило обновить первичные ключи для самой крупной таблицы с 32 до 64 бит, чего нельзя было представить с RDS. Первичное пространство ключей (4 млрд рядов) было выбрано полностью за пару месяцев.
#### Планы
Облачная инфраструктура Nylas продолжает динамично развиваться. После обновления уровня базы данных пришло время обновления уровня самого приложения. Текущий проект включает разделение логики синхронизации по нескольким микросервисам и обновление топологии процессов с магистральным источником данных, типа Kafka. Есть также вариант реализовать денормализацию схем для уровня хранилища API, чтобы сделать дальнейшую работу с приложением более гибкой.
#### Другие технические статьи от «[Латеры](http://www.latera.ru/)»:
* [Автоматизируем учет адресов и привязок в IPoE-сетях](http://blog.hydra-billing.ru/stories/574)
* [DoS своими силами: К чему приводит бесконтрольный рост таблиц в базе данных](https://habrahabr.ru/company/latera/blog/277331/)
* [Архитектура open source-приложений: Как работает nginx](https://habrahabr.ru/company/latera/blog/273283/)
* [Как повысить отказоустойчивость биллинга: Опыт «Гидры»](https://habrahabr.ru/company/latera/blog/267083/) | https://habr.com/ru/post/282798/ | null | ru | null |
# Objects without reference cycles and cyclic GC
Each instance of a class in CPython created using the [class](https://docs.python.org/3/tutorial/classes.html#class-definition-syntax) syntax is involved in a [cyclic GC](https://pythoninternal.wordpress.com/2014/08/04/the-garbage-collector/) mechanism. This increases the memory footprint of each instance and can create memory [problems](https://instagram-engineering.com/dismissing-python-garbage-collection-at-instagram-4dca40b29172) in heavily loaded systems.
> Is it possible to use only basic [reference counting](https://docs.python.org/3/c-api/refcounting.html) mechanism when necessary?
Let's analyze one approach based on [recordclass](https://pypi.org/project/recordclass/) library that will help to create classes whose instances will only be deleted using the reference counting mechanism.
Note: this is translation from original [post](https://habr.com/ru/post/463269/) (in russian).
### A little bit about garbage collection in CPython
The primary mechanism for garbage collection in Python is reference counting. Each object contains a field that contains the current value of the references to it. An object is destroyed as soon as the value of the reference counter becomes zero. However, it does not allow the disposal of objects that contain cyclic references. For example:
```
lst = []
lst.append(lst)
del lst
```
In such cases, after deleting the object, the counter of references to it remains more than zero. To solve this problem, Python has an additional mechanism that tracks objects and breaks loops in the graph of references between objects. There is a good article on how the cyclic garbage collection mechanism works in CPython3 [article](https://habr.com/en/post/417215/).
### Memory overhead associated with the garbage collection mechanism
Typically, the garbage collection mechanism does not cause problems. But there is certain overhead associated with it:
> The header [PyGC\_Head](https://habr.com/en/post/193890/) is added to each instance of the class during memory allocation: at least 24 bytes in Python <= 3.7 and 16 bytes in 3.8 on a 64-bit platform.
This can create a memory shortage problem if you run many instances of the same process, in which you need to have at the same time a very large number of objects with a relatively small number of attributes, and the amount of memory is limited.
### Is it sometimes possible to limit oneself to the basic mechanism of reference counting?
The garbage collection mechanism **may** be redundant when the class represents a non-recursive data type. For example, records containing values of a simple type (numbers, strings, date/time). To illustrate, consider a simple class:
```
class Point:
x: int
y: int
```
If used correctly, reference cycles are not possible. Although in Python, nothing prevents "to shoot yourself in the foot":
```
p = Point(0, 0)
p.x = p
```
That is, if cyclic GC is disabled, then in this case the object will not be disposed of.
However, for the `Point` class, just *could be* limited to a reference counting mechanism. Of course, provided that when the program is executed, reference cycles will not be created, that is, the x and y attributes will take only integer values, as was stated when defining the class. But there is no standard way to refuse cyclic GC for user defined class yet.
Modern CPython is designed so that when defining custom classes in the [structure](https://docs.python.org/3/c-api/typeobj.html), which is responsible for the type that defines the custom class, the flag [Py\_TPFLAGS\_HAVE\_GC is always set](https://docs.python.org/3/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC). It determines that class instances will be included in the garbage collection mechanism. For all such objects, when created, the header [PyGC\_Head](https://habr.com/en/post/193890/) is added, and they are included in the list of monitored objects. If the flag `Py_TPFLAGS_HAVE_GC` is not set, then only the basic reference counting mechanism works. However, a single reset of `Py_TPFLAGS_HAVE_GC` will not work. You will need to make changes to the core CPython responsible for creating and destroying instances. This is still problematic because it is too big a change in the core of CPython.
### About one implementation
As an example of the implementation of the idea, consider using of base class `dataobject` from the [recordclass](https://pypi.org/project/recordclass/) project. Using it, you can create classes whose instances do not participate in the mechanism of cyclic GC (`Py_TPFLAGS_HAVE_GC` is not seted and, accordingly, there is no additional header `PyGC_Head`). They have exactly the same structure in memory as class instances with [\_\_slots\_\_](https://stackoverflow.com/questions/472000/usage-of-slots), but without `PyGC_Head`:
```
from recordclass import dataobject
class Point(dataobject):
x:int
y:int
>>> p = Point(1,2)
>>> print(p.__sizeof__(), sys.getsizeof(p))
32 32
```
For comparison, we give a similar class with `__slots__`:
```
class Point:
__slots__ = 'x', 'y'
x:int
y:int
>>> p = Point(1,2)
>>> print(p.__sizeof__(), sys.getsizeof(p)) # this is in python 3.7
32 64
```
The size difference is exactly the size of the `PyGC_Head` header. For instances with several attributes, such an increase in the size of its memory footprint may be significant. For instances of the `Point` class, adding`PyGC_Head` results in a 2-fold increase in its size.
To achieve this effect, a special metaclass `datatype` is used, which provides the setting of subclasses of `dataobject`. As a result of the configuration, the flag `Py_TPFLAGS_HAVE_GC` is reset, the base instance size [tp\_basicsize](https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_basicsize) increases by the amount necessary to store additional slots for fields. The corresponding field names are listed when the class is declared (the class `Point` has two of them: `x` and `y`). The `datatype` metaclass also provides setting the values of the slots [tp\_alloc](https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_alloc), [tp\_new](https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_new), [tp\_dealloc](https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_dealloc), [tp\_free](https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_free), which implement the correct algorithms for creating and destroying instances in memory. By default, instances lack [\_\_weakref\_\_](https://stackoverflow.com/questions/36787603/what-exactly-is-weakref-in-python) and [\_\_dict\_\_](https://codesachin.wordpress.com/2016/06/09/the-magic-behind-attribute-access-in-python/) (as with class instances with `__slots__`).
### Conclusion
As one could see, in CPython, if necessary, it is possible to disable the mechanism of cyclic garbage collection for a particular class, when there is confidence that its instances will not form cyclic references. This will also reduce the size of each instance in memory by the size of the `PyGC_Head` header.
In the next article we will try to demonstrate ability to reduce memory usage using classes based on dataobject. | https://habr.com/ru/post/475120/ | null | en | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.