text
stringlengths 20
1.01M
| url
stringlengths 14
1.25k
| dump
stringlengths 9
15
⌀ | lang
stringclasses 4
values | source
stringclasses 4
values |
|---|---|---|---|---|
# Облачное хранилище: новые функции API
Недавно мы рассказали о [переходе на новую платформу](https://habrahabr.ru/company/selectel/blog/304032/), благодаря которой нам удалось улучшить работу облачного хранилища. Мы подробно описали, как мы доработали логику и архитектуру хранилища и переписали некоторые компоненты на Go, благодаря чему всё стало работать гораздо быстрее и стабильнее, чем раньше.
При этом мы рассказали далеко не обо всём: за время работы над API мы запустили несколько новых функций, которые, как мы надеемся, окажутся полезными для вас.
Аутентификация
--------------
Наше хранилище полностью поддерживает [OpenStack Swift API](http://developer.openstack.org/api-ref-objectstorage-v1.html), для которого существует множество сторонних клиентов.
Для совместимости с этими клиентами реализована поддержка аутентификации Swift v1, а также ограниченно реализованы варианты аутентификации Keystone v2 и v3. Таким образом, в нашем API теперь доступны три способа аутентификации.
Первый почти не отличается от того, что использовался раньше (изменился только URI авторизации для большего соответствия стандарту):
```
$ curl -i https://api.selcdn.ru/auth/v1.0 -H "X-Auth-User:[имя пользователя]" -H "X-Auth-Key:[пароль]
```
Во втором способе (аутентификации по типу Keystone v2) используется не GET-, а POST-запрос; имя пользователя и пароль передаются в массиве JSON:
```
$ curl -i -X POST https://api.selcdn.ru/v2.0/tokens -H 'Content-type: application/json' -d '{"auth": {"passwordCredentials": {"username": [имя пользователя], "password": [пароль]}}}'
```
Ответ на такой запрос API также вернёт в формате JSON.
Аутентификация согласно Keysone v3 выглядит так:
```
$ curl -i https://api.selcdn.ru/v3/auth/tokens -XPOST -d '{"auth": { "identity": { "methods": ["password"], "password": { "user": { "id": [имя пользователя], "password": [пароль]}}}}}'
```
Обращаем ваше внимание на то, что Keystone API в хранилище реализован не полностью: работают только функции аутентификации по логину и паролю. Никакие расширения протокола Keystone у нас не поддерживаются.
Изменился также и базовый адрес хранилища. Теперь он выглядит так: [api.selcdn.ru/v1/SEL\_XXX](http://api.selcdn.ru/v1/SEL_XXX) (вместо ХХХ нужно, естественно, подставить ID пользователя).
Еще одним изменением, связанным с системой аутентификации, является новый механизм временных токенов. Появилась возможность генерировать дополнительные токены с ограниченным сроком действия, обеспечивающие доступ только в строго определённый контейнер. Чем-то это напоминает [Security Service в Amazon S3](http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html):
```
$ curl -i -X GET https://api.selcdn.ru/v1/temptokens -H "X-Auth-Token: [токен основного пользователя]" -H "X-Container:[контейнер]" -H "X-ExpireAfter: 8600"
```
В заголовке X-Auth-Token передается валидный токен основного пользователя, в X-Container указывается контейнер, для которого будет действовать токен, а в X-Expire-After — время действия этого токена в секундах.
Работа с файлами
----------------
В новом API расширены возможности работы с файлами. Так, архивы в форматах tar, .tar.gz, gzip можно распаковывать в фоновом режиме после полной загрузки файла в хранилище. Предыдущий вариант распаковки предполагал распаковку архивов «на лету», т.е. нужно было поддерживать соединение с нашими серверами, пока не выполнятся запросы на создание всех файлов из загружаемого архива. И при разрыве соединения приходилось всё загружать заново.
Теперь всё гораздо проще. Если вам, например, требуется загрузить в хранилище архив, содержащий несколько тысяч файлов, это можно сделать с помощью PUT-запроса на адрес контейнера с дополнительным query-параметром extract-archive-v2. После полной отправки архива сразу же отдаётся код 201 и запускается фоновая распаковка на стороне хранилища:
```
curl -i -X PUT https://api.selcdn.ru/v1/SEL_XXX/[имя контейнера]/?extract-archive-v2=tar.bz2 -H "X-Auth-Token: [токен]" -T "photos.tar.bz2"
HTTP/1.1 100 Continue
HTTP/1.1 201 Created
Access-Control-Expose-Headers: X-Backend-Timestamp, Etag, Last-Modified, X-Object-Manifest, X-Timestamp
Content-Length: 0
Content-Type: text/html
Etag: a1adb438cb26e91228870158a2062ef2
Extract-Id: 6a62579d-9ee2-2a32-26a4-207d5a47af2a
```
Обратите внимание на заголовок Extract-Id, присутствующий в ответе. С его помощью можно узнать, на какой стадии находится операция распаковки:
```
$ curl -i https://api.selcdn.ru/v1/extract-archive/[Extract-Id] -H "X-Auth-Token: [токен]"
HTTP/1.1 200 OK
Number Files Created: 1185
Response Body:
Response Status: 201 Created
Errors:
```
В нашем случае ответ с кодом 200 означает, что операция распаковки была завершена успешно. В параметре Number Files Created указывается количество файлов, извлечённых из архива.
Новые функции
-------------
В API появилось много новых функций, в частности управление пользователями, доменами, сертификатами и работа с CDN. Подробнее о них мы расскажем ниже.
### Управление пользователями
Раньше добавлять и удалять дополнительных пользователей можно было исключительно через панель управления. Сейчас это можно делать посредством стандартных HTTP-запросов к API.
Посмотреть список пользователей можно так:
```
$ curl -i -XGET https://api.selcd.ru/v1/users[?format=json] -H "X-Auth-Token: [токен]"
```
Создание нового пользователя осуществляется с помощью запроса:
```
$ curl -i -XPUT https://api.selcd.ru/v1/users/new_user -H "X-Auth-Token: [токен]" -H "X-Auth-Key: 123456" -H "X-User-ACL-Containers-W: container1, container2, container3" -H "X-User-ACL-Containers-R: container4" -H "X-User-Store-Password: yes" -H "X-User-Active: on"
```
К нам уже не раз поступали просьбы расширить управление правами для пользователей. Эти просьбы мы выполнили, и это видно из только что приведённого примера запроса: обратите внимание на заголовки X-User-ACL-Containers-W и X-User-ACL-Containers-R. В первом указываются контейнеры, в которые новый пользователь может записывать информацию, а во втором — контейнеры, доступ к которым будет открыт только для чтения.
В заголовке X-Auth-Key указывается пароль создаваемого пользователя. X-User-Store-Password является эквивалентом опции «Хранить пароль на серверах Selectel» в панели управления. Заголовок X-User-Active со значением on указывает, что новый пользователь будет активен.
Изменить данные уже созданного пользователя можно так:
```
$ curl -i -XPOST https://api.selcd.ru/v1/users/new_user -H "X-Auth-Token: [токен]" -H "X-Auth-Key: 123456" -H "X-User-ACL-Containers-W: container1, container4" -H "X-User-ACL-Containers-R: container4" -H "X-User-Store-Password: yes" -H "X-User-Active: on"
```
Удаление пользователя осуществляется с помощью DELETE-запроса:
```
$ curl -i -XDELETE https://selcdn.ru/users/[имя пользователя] -H "X-Auth-Token: [токен]"
```
Для основного пользователя можно изменять только пароль. Это делается с помощью POST-запроса с заголовком X-Auth-Key на адрес [api.selcd.ru/v1/users](https://api.selcd.ru/v1/users/)[имя основного пользователя].
### Управление доменами
Работать с доменами раньше тоже можно было исключительно через графический интерфейс. Сейчас все операции можно выполнять и через API.
Вот так, например, можно просмотреть список всех доменов, привязанных к контейнерам:
```
$ curl -i https://api.selcdn.ru/v1/domains -H "X-Auth-Token: [токен]"
```
Прикрепить домен можно с помощью POST-запроса к соответствующему контейнеру с заголовком X-Add-Container-Domains:
```
$ curl -i https://api.selcdn.ru/v1/SEL_XXX/{container_name} -XPOST -H "X-Add-Container-Domains: domain1.ru" -H "X-Auth-Token: [токен]"
```
Для удаления домена используется аналогичный запрос, только имя домена передаётся в заголовке X-Remove-Container-Domains:
```
$ curl -i https://api.selcdn.ru/v1/SEL_XXX/{container_name} -XPOST -H "X-Remove-Container-Domains: domain1.ru" -H "X-Auth-Token: [токен]"
```
Чтобы полностью изменить список привязанных к контейнеру доменов, нужно выполнить POSТ-запрос на адрес этого контейнера и передать обновленный список в заголовке X-Container-Domains:
```
$ curl -i https://api.selcdn.ru/SEL_XXX/[имя контейнера] -H "X-Auth-Token: [токен]" -XPOST -H "X-Сontainer-Domains: domain1.ru domain2.ru"
```
Если к контейнеру прикреплены несколько доменов и их требуется удалить, то в заголовке X-Container-Domains можно просто передать цифру 0:
```
$ curl -i https://ххххх.selcdn.ru/[имя контейнера] -H "X-Auth-Token: [токен]" -XPOST -H "X-Сontainer-Domains: 0"
```
Запрос логов
------------
Через API можно запрашивать логи сетевого доступа к пользовательским контейнерам за указанный период:
```
$ curl -i -XPOST https://api.selcdn.ru/v1/logs -H "X-Auth-Token: [токен]" -H "X-Start-Time: 2016-02-02 09:00:00" -H "X-End-Time: 2016-05-02 12:00:00" -H "X-Limit: 10000"
```
В заголовках X-Start-Time и X-End-Time, как не трудно догадаться, указываются начало и конец периода.
В факультативном заголовке X-Limit указывается максимальное количество записей логов, которые будут выданы в данном запросе (по умолчанию вы получите все логи за указанный временной интервал).
По завершении выборки в хранилище будет автоматически создан приватный контейнер logs, куда и будут помещены логи.
Управление SSL-сертификатами
----------------------------
Ещё одна новая функция — управление SSL-сертификатами. Работать с сертификатами можно как через графический интерфейс, так и через API.
Вот так, например, можно просмотреть список всех сертификатов, привязанных к контейнерам:
```
$ curl -i https://api.selcdn.ru/v1/ssl -XGET -H "X-Auth-Token: [токен]"
```
Для просмотра информации о сертификате используется запрос вида:
```
$ curl -i https://api.selcdn.ru/v1/ssl/{cert_name} -XGET -H "X-Auth-Token: [токен]"
```
Запрос на добавление сертификата выглядит так:
```
$ curl -i https://api.selcdn.ru/v1/ssl/{cert_name} -XPUT -H "X-Auth-Token: [токен]"
```
Имя сертификата ({cert\_name}) передаётся в формате 001\_cert1, где число — логин пользователя, а второй компонент — произвольное имя. Имена сертификатов не могут дублировать друг друга. Сам сертификат и приватный ключ передаются в теле запроса в виде одного файла.
Чтобы удалить сертификат, нужно отправить DELETE-запрос вида:
```
$ curl -I https://api.selcdn.ru/v1/ssl/001_cert1 -H "X-Auth-Token: [токен]" -XDELETE
```
Работа с CDN
------------
Появилась в API и возможность работы с CDN. Вы можете отправлять запросы на очистку кэша (раньше это можно было делать только через графический интерфейс), а также просматривать статус выполнения этих запросов.
Очистка кэша CDN осуществляется при помощи PURGE-запроса:
```
$ curl -i -X PURGE https://api.selcdn.ru/v1/cdn -H "X-Auth-Token: [токен]" -d 'https://api.selcdn.ru/v1/SEL_XXX/container1/file1\nhttps://XXX.selcdn.ru/container1/file1'
```
Сейчас мы используем akamai ccu v3 с fast purge, и после отправки такого запроса кэш должен быть очищен в течение примерно 5 секунд. Ответ на запрос выглядит так:
```
{"estimatedSeconds": 5, "purgeId": "0bb4d6fa-4ce4-11e6-b75e-9fdde8cfe544", "supportId": "17PY1468845301403318-210404544", "httpStatus": 201, "detail": "Request accepted"}
```
Заключение
----------
В этой статье мы рассказали о новых функциях API облачного хранилища. В скором времени работа по усовершенствованию хранилища будет продолжена. И если у вас есть свои пожеланию по улучшению и расширению функциональности — высказывайтесь в комментариях к этому посту. Наиболее интересные идеи мы примем к сведению и постараемся реализовать.
|
https://habr.com/ru/post/306560/
| null |
ru
| null |
# Web UI, WebSocket и проблема самоподписанных сертификатов
Доброго времени суток всем!
В этой заметке я постараюсь рассмотреть проблематику зашифрованного соединения с Web-сервером (HTTPS) и такого же соединения с Comet-сервером с использованием WebSocket (WSS) при использовании самоподписанных сертификатов, а так же варианты для решения данной проблемы.
В данный момент времени я занимаюсь разработкой Web UI к некоему продукту компании, который будет использоваться внутри клиентских корпоративных сетей.
Изначальные условия: доступ к Web UI прямо по IP адресу сервера, желательно использование стандартных портов 80/443, чтобы облегчить деплоймент, ОС сервера — Windows Server 2012.
Comet-сервер нужен нам для организации связи между неким сервисом, который формирует отчеты по заданным параметрам, и непосредственно Web UI, через который клиент отправляет запрос, получает статус о выполнении и завершении задания, а так же для передачи разных сервисных сообщений о событиях (например — пользователь вошел в систему, данные пользователя были изменены администратором и т.п.).
Для Comet-сервера и бэкенда Web UI мы используем Node.JS.
Вообще опыта использования Node.JS у меня особого нет, но как оказалось подобные задачи делать на нем весьма удобно — не вдаваясь в детали на само написание первой версии с глобальным бродкастом сообщений между всеми участниками без «комнат» или «каналов» у меня ушло буквально пару часов. И большая куча времени на инвестигирование модулей Node.JS, на которых можно реализовать WebSocket сервер (Socket.IO, WS) — тут время ушло на исследование стыковки C# серверного компонента и Comet-сервера. Socket.IO нам не подошел — в версии > 1 там реализовано много «поверх», решили по разным причинам использовать более нативную реализацию и взяли [модуль WS](https://github.com/einaros/ws).
Скажу сразу, что Comet-сервер имеет два интерфейса: первый это обычный HTTP интерфейс (внутренний с авторизацией запросов), по которому происходит авторизация пользователей и компонентов, отправка команд серверу; второй это непосредственно WebSocket интерфейс (WS), к которому подключаются авторизованные пользователи и компоненты для получения сообщений о событиях в системе.
В связке HTTP+WS все естественно работает на «ура» и никаких проблем, но по заданию нам нужен SSL, и соответственно HTTPS+WSS.
Создать самоподписанный сертификат при помощи OpenSSL [дело несложное](http://help.ubuntu.ru/wiki/apache_%D0%B8_https), прикрутить к Web UI тоже [буквально пара строчек](http://stackoverflow.com/questions/5998694/how-to-create-an-https-server-in-node-js), к интерфейсу Comet [тоже просто](https://github.com/einaros/ws/blob/master/examples/ssl.js).
И вот тут началось самое интересное.
Как все знают, при использовании самоподписанных сертификатов любой браузер выдает предупреждение и просит пользователя подтвердить, что он доверяет этому сертификату.
Итак, мы идем на тестовый Web UI с эмуляцией клиента по адресу `127.0.0.1`, подтверждаем сертификат, далаем попытку соединения по адресу `wss://127.0.0.1:4433/` — и получаем ошибку соединения. Потому что для адреса 127.0.0.1 и порта 4433 сертификат надо подтверждать второй раз. Браузер при этом ну никаких дополнительных сообщений о том, что сертификат нужно подтвердить, не выдает. Просто молча сбрасывает запрос и все, он даже до сервера не доходит.
Из четырех тестируемых браузеров — IE, Firefox, Opera, Chrome — второй раз не спрашивают подтверждения на другой порт по тому же адресу Chrome и Opera, IE и Firefox запрос молча обрубают с выдачей ошибки в консоль.
Поскольку скорее всего у клиента будет IE (все-таки Windows это массовая ОС у корпоративных клиентов), то это большая проблема.
#### Решение 1
Самое простое решение, которое приходит в голову — это проксировать запросы. В Linux я бы поставил Nginx и проксировал через него, но у нас Windows. Взял уже имеющийся у меня Apache 2.2, настроил SSL и дал вот такую директиву:
```
ProxyPass /wss/ ws://127.0.0.1:8095/
ProxyPass / http://127.0.0.1:8080/
```
То есть запросы на /wss/ пробрасываем к WS интерфейсу, все остальное — на Web UI.
Не заработало. Гугление и прочее выдало что надо Apache 2.4 с модулем mod\_proxy\_wstunnel. Поставил, подключил — все прекрасно, Web UI выдает запрос один раз, WSS соединение устанавливается без проблем.
Но Apache в данном получается все-таки лишним компонентом, и несколько портит производительность, которую дает асинхронное приложение на Node.JS.
Решил попробовать написать прокси-сервер на Node.JS, не вышло. Если вкратце, то одновременные запросы на любой один порт с поднятием WS и HTTPS интерфейсов HTTPS интерфейс в упор не ловит запросов по WSS протоколу. Совсем. Проксировать отдельно HTTPS на внутренний HTTP и отдельно WSS на внутренний WS проксирует, а вот поймать урл при запросе `wss://127.0.0.1/wss/` — никак.
Хорошо, вернемся к первому варианту и двум портам с подтверждением сертификатов.
В Node.JS WSS сервер создается на основе HTTPS-сервера и умеет отдавать некий контент при прямом запросе `127.0.0.1:4433`, чем я и решил воспользоваться:
```
var ws = require('ws');
var https = require('https');
var fs = require('fs');
var processRequest = function( req, res ) {
res.statusCode = 200;
res.end('Hello, world!' + "\n");
};
var options = {
key: fs.readFileSync(PathToKey),
cert: fs.readFileSync(PathToCert)
};
var cometApp = https.createServer(options, processRequest).listen(4433, function() {
console.log('Comet server [WSS] on *:4433');
});
var cometServerOptions = {
server: cometApp,
verifyClient: function(request) {
// Some client verifying
return true;
}
};
var cometServer = new ws.Server(cometServerOptions);
cometServer.on('connection', function(socket) {
socket.on('message', function(data) {
console.log('New message received');
}
});
});
```
Ради смеха решил попробовать iframe. В iframe выдается предупреждение… И никаких кнопок для пользователя чтобы подтвердить сертификат. Да и в любом случае я никак не могу отследить, подтвердил там чего пользователь или нет, чтобы потом установить соединение. Прописать в техтребованиях, чтобы пользователь обязательно сходил на два адреса? Тоже как-то некрасиво… AJAX-запрос на другой порт по тому же адресу вообще не работает из-за внутренней безопасности — для Javascript это два разных сайта.
#### Решение 2
Оказалось несколько бредовым, но весьма рабочим. Итак, нам надо два раза подтвердить сертификат. А что если мы попросим пользователя сначала сходить на HTTPS интерфейс WSS-сервера, а потом после подтверждения сделаем редирект на основной WebUI?
```
var ws = require('ws');
var https = require('https');
var fs = require('fs');
var processRequest = function( req, res ) {
res.setHeader("Location", redirectUrl);
res.statusCode = 302;
res.end();
};
var options = {
key: fs.readFileSync(PathToKey),
cert: fs.readFileSync(PathToCert)
};
var cometApp = https.createServer(options, processRequest).listen(4433, function() {
console.log('Comet server [WSS] on *:4433');
});
var cometServerOptions = {
server: cometApp,
verifyClient: function(request) {
// Some client verifying
return true;
}
};
var cometServer = new ws.Server(cometServerOptions);
cometServer.on('connection', function(socket) {
socket.on('message', function(data) {
console.log('New message received');
}
});
});
```
Работает! При запросе `127.0.0.1:4433/` меня теперь просит подтвердить сертификат, потом автоматически перебрасывает в Web UI `127.0.0.1`, где тоже просит подтвердить сертификат, после чего связка HTTPS на одном + WSS на другом порту прекрасно работает и больше ничего не спрашивает.
**NB!** Выше я ничего не написал про доменные имена. Конечно, их можно использовать, чтобы получить нормальные сертификаты, но у меня есть определенные ограничения в виде корпоративной сети, из которой далеко не всегда есть доступ к центру сертификации, выдавшему сертификат. Да и требовать заводить доменные имена во внутренней сети для продакшена в моем случае это лишняя головная боль. Еще один сервер для Web UI на Linux, например, с проксей в виде Nginx в силу разных причин мы тоже не рассматриваем.
#### Выводы
Для решения данной проблемы нашлось два пути:
1. Проксирование с прямого адреса по части url (при помощи Apache или Nginx)
2. Редирект с HTTPS-интерфейса WS-сервера на основной Web UI с подтверждением сертификатов два раза
Буду рад любым комментариям, может есть еще какие решения.
##### **UPDATE**
для Node.JS все-таки получилось сделать проксирование WS запросов (я брал [node-http-proxy](https://github.com/nodejitsu/node-http-proxy)) по части урла (спасибо [xdenser](https://habrahabr.ru/users/xdenser/)) средствами самого Node.JS на событие Upgrade, причем проксирование оптимально добавить прямо в http-сервер Web UI, чтобы не плодить компоненты, примерно таким образом:
```
var httpProxy = require('http-proxy');
var proxy = httpProxy.createProxyServer({});
function proxyWebsocketResponse(req, res, head) {
try {
var hostname = req.headers.host.split(":")[0];
var pathname = url.parse(req.url).pathname;
if (pathname === config.comet.websocket.path) {
var options = {
target: 'ws://' + config.comet.websocket.host + ':' + config.comet.websocket.port + '/',
ws: true
};
proxy.ws(req, res, head, options);
proxy.on('error', function(e) {
console.log('WebSocket error: ' + e.message);
res.end();
});
} else {
res.statusCode = 501;
res.end('Not Implemented');
}
} catch (e) {
console.log('Error: ' + e.message);
}
}
httpServer.addListener('upgrade', proxyWebsocketResponse);
```
|
https://habr.com/ru/post/235435/
| null |
ru
| null |
# Решение проблем настроек web-сервера при публикации web-приложений
При публикации веб-приложения из Visual Studio разработчик может столкнуться с некоторыми проблемами, и не всегда текст ошибки может помочь избавиться от проблем и правильно настроить сервер.
Ниже я опишу наиболее распространенные из них.
Надеюсь, что данная статья поможет сэкономить время, большое количество которого я потратил при изучении проблем.
Давайте попробуем развернуть приложение на чистый сервер Windows 2008 R2, на котором установлена роль «Web Server (IIS)».
1. Для этого в Visual Studio (у меня Visual Studio 2012 Professional) кликаем правой мышкой на проекте и выбираем пункт меню «Publish...»
Откроется окно мастера публикации, в котором нужно создать профиль
Вводим имя профиля (я назвал профиль также, как называется мой веб-сервер — «app10») и нажимаем кнопку «ОК».
Затем заполняем поля ввода и нажимаем кнопку «Validate Connection».
И тут начинается самое интересное.
2. Валидация завершилась с ошибкой.
Для того, чтобы посмотреть текст ошибки, нужно щелкнуть на гиперссылке «Failed (click for details)»
3. Первая ошибка:
`Could not connect to the destination computer ("app10"). On the remote computer, make sure that Web Deploy is installed and that the required process ("The Web Management Service") is started.)`
Студия не получила ответа от сервера.
Необходимо проверить настройки веб-сервера (в моем случае он имеет доменное имя «app10»), для чего необходимо зайти в Server Manager (у меня на сервере установлена англоязычная версия Windows 2008 R2, поэтому я буду писать английский наименования пунктов меню и заголовков окон).
4. Откройте диспетчер служб IIS и выберите узел с именем машины:
Я скрыл имя пользователя на скриншоте.
5. В разделе «Management» нужно проверить наличие пунктов «IIS Manager Permissions», «IIS Manager Users» и «Management Service».
У меня их нет, поэтому нужно установить.
Для этого щелкните правой мышкой на пункт «Web Server (IIS)» в левой части окна «Server Manager» и выберите пункт «Add Role Services».
Откроется окно выбора роли.
В разделе «Management Tools» отметьте пункт «Management Service» и нажмите кнопку «Next».
В следующем окне мастера добавления роли нажмите кнопку «Install».
Необходимо дождаться окончания процесса добавления роли и убедиться, что все прошло успешно:
Закрываем окно добавления роли и опять переходим к разделу «Management» (см. пункт 5).
Необходимые нам пункты появились.
6. Необходимо проверить, что Брендмауэр Windows не мешает установлению соединения.
Для этого откройте оснастку «Windows Firewall with Advanced Security», которая находится в меню «Пуск» — «Administrative Tools».
Необходимо убедиться, что входящие соединения на порт 8172 разрешены.
(У меня брендмауэр вообще отключен).
7. Необходимо убедиться, что Web Management Service слушает порт 8172.
Для этого откройте в настройках сервера дважды щелкните мышкой по пункту «Management Service»
В открывшемся окне проверьте, что указан порт 8172, а также разрешите удаленные подключения, установив галочку «Enable remote connection».
Если не поставить эту галочку, то в мастере публикации в Visual Studio будет возникать ошибка:
`Could not connect to the remote computer ("app10") using the specified process ("The Web Management Service") because the server did not respond. Make sure that the process ("The Web Management Service") is started on the destination computer. The remote server returned an error: (403) Forbidden.`
Теперь нажмите кнопку «Apply» с зеленой галочкой в правой части окна надстроек.
После применения настроек нажмите там же кнопку «Start», что приведет к запуску службы.
8. Переключаемся в Visual Studio и снова нажимаем кнопку «Validate Connection» в мастере публикации.
У меня открылась ошибка сертификата, но ее можно просто игнорировать и нажать кнопку «Accept», предварительно поставив галочку «Save this certificate for future sessions of Visual Studio».
9. После этого у меня возникла ошибка 404:
`Could not connect to the remote computer ("app10"). On the destination computer, make sure that Web Deploy is installed and that the required process ("The Web Management Service") is started. The remote server returned an error: (404) Not Found.`
Необходимо убедиться, что установлен инструмент «Microsoft Web Deploy 2.0».
Для этого пройдите в «Пуск» — «Control Panel» — «Programs and Features» и проверьте наличие установленного продукта «Microsoft Web Deploy 2.0».
Если его нет, то скачайте его [отсюда](http://www.microsoft.com/en-us/download/details.aspx?id=25230) и установите на сервере.
Во время установки нужно выбрать тип установки «Custom» и выбрать для установки все пункты, предлагаемые инсталлятором:
Выполните установку.
После чего обновите окно «Programs and Features» и он у вас появится.
10. После установки «Microsoft Web Deploy 2.0» необходимо перезапустить службу «Web Management Service».
Теперь нажимаем кнопку «Validate Connection» в мастере публикации в Visual Studio и ВУАЛЯ!!!
Проверка успешно пройдена.
Нажимаем кнопку «Next» дважды и публикуем приложение на веб-сервер, нажав кнопку «Publish».
В завершение данной статьи хочу сказать, что наиболее информативные сообщения при возникновении ошибок во время публикации веб-приложения можно найти в файле логов IIS, который по умолчанию находится по следующему пути:
`%SystemDrive%\Inetpub\logs\WMSvc`
Только помните, что как и в случае с другими журналами IIS, данные не записываются в журнал сразу, так что вам, возможно, придется подождать пару минут, чтобы увидеть последние сообщения, или перезапустить службы веб-управления, чтобы сбросить данные журнала в лог-файл.
Удачи!
**UPDATE 03.08.2015**
Если во время проверки соединения с сервером (при нажатии на кнопку «Validate Connection») возникает ошибка:
`Could not complete an operation with the specified provider ("contentPath") when connecting using the Web Management Service.`
необходимо в диспетчере служб IIS выбрать узел с именем машины и дважды кликнуть левой клавишей мыши на пункте «Management Service Delegation»:
**Бывает так, что пункт 'Management Service Delegation' отсутствует**Для устранения данной проблемы необходимо еще раз запустить инсталлер WebDeploy, выбрать пункт «Change» и доустановить компоненты.
Затем перезапускаем оснастку управления сервером и данный пункт появится.
В открывшемся окне необходимо добавить новое правило, нажав в правой верхней части на ссылку «Add Rule...» и выбрав пункт «Deploy Applications with Content» и нажав кнопку «ОК»:
В открывшемся окне необходимо указать пользователя, учетные данные которого вы используете для публикации из Visual Studio:
А также в выпадающем меню **Providers** необходимо дополнительно выбрать пункты «createApp» и «setAcl»:
После нажатия кнопки «ОК» откроется окно добавления пользователя.
Здесь в поле «Name» можно поставить **\*** и нажать кнопку ОК:
После выполнения данных действий, окно правил «Management Service Delegation» будет иметь следующий вид:
И описанная ошибка исчезнет.
**UPDATE 19.01.2017**
Если во время проверки соединения с сервером (при нажатии на кнопку «Validate Connection») возникает ошибка:
`Could not connect to the remote computer ("serverName") using the specified process ("Web Management Service") because the server did not respond. Make sure that the process ("Web Management Service") is started on the remote computer...`
а в конце текста ошибки написано «The remote server returned an error: (550)».
Это говорит о том, что вы опечатались в параметре «Site name» в окне настроек публикации.
Проверьте имя сайта и сравните его с тем, куда публикуете своё приложение.
|
https://habr.com/ru/post/198452/
| null |
ru
| null |
# Позитивное продолжение истории с hc.ru
Вчера мною был опубликован [топик](http://agh.habrahabr.ru/blog/75612/), о том как в столь уважаемой конторе как hc.ru, я вынужден 2 раза платить по сути за одну услугу (Регистрация домена + Primary и Secondary DNS)
Сегодня в почте было обнаружено письмо следующего содержания.
`Здравствуйте, Сергей!
Меня зовут ###### Дмитрий, я представляю службу контроля Хостинг-Центра.
Мы обнаружили Ваше сообщение agh.habrahabr.ru/blog/75612 .
Нам очень важно мнение наших клиентов. Мы в ближайшее время планируем
пересмотреть политику предоставления возможности управления зоной по доменным
именам, которые находится у нас на обслуживании.
Услуга Primary и Secondary DNS для доменного имени ########k.ru теперь будет
Вам предоставляться бесплатно до тех пор пока доменное имя #######k.ru
находится на обслуживании в нашей компании.
С уважением,
####### Дмитрий
Сектор контроля
Департамент технической поддержки
Хостинг-Центр`
И вот такое случается в наше время :) **Хабр — сила** :)
|
https://habr.com/ru/post/75706/
| null |
ru
| null |
# Настройка голосовых команд Mac OS для запуска произвольного кода
Предыстория
===========
Когда вышла Mac OS Sierra, одной из громких новостей было появление Siri. Меня, как пещерного человека, очень удивила и заинтересовала возможность управления ноутбуком с помощью голоса (да-да, это не инновации, но лично я с этим до этого никогда не пользовался и считал это чем-то бесполезным).
После пары часов чтения разных материалов я был огорчен тем, что нельзя очень быстро расширить возможности Siri (среди которых я нашел мало полезного для себя). Хотелось иметь возможность запустить какой-нибудь баш-скрипт, но способы запуска были не очень удобные (на мой вкус).
Но тут я неожиданно узнал о голосовых командах, которые есть в маке уже черт знает сколько времени (лет?)
Запуск произвольных скриптов с помощью Диктовки Mac OS
======================================================
Для начала идем в "Системные настройки" → "Клавиатура" (внезапно) → "Диктовка" и включаем ее. После этого идем в "Системные настройки" → "Универсальный доступ" → "Диктовка".
Для начала включим *ключевые фразы диктовки*. Это нужно для того, чтобы распознавание речи работало постоянно, а не по требованию. Далее открываем команды. Здесь вы увидите множество уже предопределенных команд. Лично я их отключил.
Давайте создадим свою, пользовательскую. Настройки всего три: текст команды, контекст и действие. К сожалению, мы все еще не можем запускать баш-скрипты, но зато можем запускать приложения. А что является приложением в Mac OS? Всего-лишь директория с определенной структурой и суффиксом `.app`. Решение напрашивается само собой — сделать `.app` из скрипта.
Я не буду останавливаться на структуре приложения. Лично я уже давно написал ruby-скрипт, который превращает произвольный скрипт в `.app`. [Вот он](https://github.com/Nondv/script2app).
Собственно, вот и все. "Выполнить" → "Запустить процесс" → "Другое" и выбираем наше "приложение".
Как я это использовал
=====================
Не могу не похвастаться своим маленьким ноу-хау. У меня дома музыка играется не с моего ноутбука, а с отдельного устройства, подключенного к колонкам на другом конце комнаты. Раньше это был телефон с установленным на нем Plex, но буквально вчера я купил Raspberry Pi и установил на него `mpd`.
С помощью своего ruby-скрипта я наделал приложений, которые выполняют по одной команде вида
```
ssh pi@raspberry 'mpc '
```
и назначил их на голосовое управление.
Вот небольшая демка (прошу прощения за звук и беспорядок):
**upd.** [altervision](https://geektimes.ru/users/altervision/) [сообщил](https://geektimes.ru/post/284414/#comment_9802946) о том, что вместо `.app` можно использовать `.command` файлы, что для каких-то мелких команд должно быть намного удобнее.
|
https://habr.com/ru/post/373043/
| null |
ru
| null |
# Один способ вычисления логарифма по основанию 2
Вычисление логарифмов довольно распространённая операция в цифровой обработке сигналов. Чаще пожалуй приходится считать только свёртки (умножение с накоплением) и амплитуды с фазами. Как правило для вычисления логарифмов на FPGA применяется [алгоритм CORDIC](https://ru.wikipedia.org/wiki/CORDIC) в гиперболическом варианте, требующий только таблицы и простых арифметических операций. Однако это не всегда бывает удобно, особенно если проект большой, кристалл маленький и начинаются танцы с оптимизацией. Именно с такой ситуацией и пришлось мне однажды столкнуться. Оба порта блока RAM (Cyclone IV) уже плотненько были в работе, не оставляя свободных окон. Использовать ещё один блок под гиперболический CORDIC не хотелось. Зато был умножитель, для которого во временной диаграмме получалось приличное свободное окно. Денёк подумав, я сочинил следующий алгоритм, в котором не используется таблиц, но есть умножение, точнее возведение в квадрат. И поскольку схемотехнически возведение в квадрат проще общего случая умножения, возможно этот алгоритм представляет интерес для специализированных микросхем, хотя для FPGA разницы конечно нет. Подробнее под катом.
Объяснять что к чему, тут проще для действительных чисел. С них и начнём. К целочисленной реализации перейдём потом.
Пусть есть число **X**. Требуется найти число **Y** такое, чтобы .
Положим так же что **X** лежит в интервале от 1 до 2. Это не слишком ограничивает общность, поскольку **X** всегда можно перевести в этот интервал умножением или делением на степень двойки. Для **Y** это будет означать добавление или вычитание целого числа, что делается легко. Итак **X** лежит в интервале от 1 до 2. Тогда **Y** будет лежать в интервале от 0 до 1. Запишем **Y** как бесконечную двоичную дробь:
Коэффициенты **** в этой записи есть ни что иное, как просто биты двоичного представления числа **Y**. Причём поскольку **Y** меньше 1, очевидно что ****=0.
Возведём наше первое уравнение в квадрат:  и как и ранее, запишем двоичное представление числа **2Y**. Очевидно, что 
Т.е. биты  остались теми же, просто сдвинулись степени двойки. Бита  в представлении нет, потому что он равен нулю.
Возможны два случая:
1) , 2Y > 1, 
2) , 2Y < 1, 
В первом случае в качестве нового значения **X** примем , во втором — .
В итоге задача свелась к прежней. Новое **X** опять лежит в интервале от 1 до 2, новое **Y** от 0 до 1. Но мы узнали один бит результата. Делая такие же шаги в дальнейшем, мы можем получить сколько угодно битов **Y**.
Посмотрим как это работает в программе на С:
```
#include
#include
int main()
{
double w=1.4;
double s=0.0;
double a=0.5;
double u=w;
for(int i=0; i<16; i++)
{
u=u\*u;
if(u>2)
{
u=u/2;
s+=a;
}
a\*=0.5;
}
w=log2(w);
double err=100\*abs(2\*(s-w)/(s+w));
printf("res=%f, log=%f, err=%f%c\n",s,w,err,'%');
return 0;
}
```
Мы посчитали логарифм с точностью до 16 бит и сравнили с тем, что даёт математическая библиотека. Программа вывела:
res=0.485413, log=0.485427, err=0.002931%
Результат совпал с библиотекой с точностью 0.003%, что показывает работоспособность нашего алгоритма.
Перейдём к целочисленной реализации.
Пусть N-разрядные двоичные беззнаковые числа, отображают интервал [0, 1]. Для удобства будем считать единицей число , а не , и соответственно двойкой число . Напишем программу по образу и подобию предыдущей, но работающую с целыми числами:
```
#include
#include
#define DIG 18 //разрядность чисел
#define N\_BITS 16 //число бит которое считаем
unsigned ONE=1<<(DIG-1); //единица
unsigned TWO=ONE<<1; //двойка
unsigned SCALE=1<<(N\_BITS+1); //масштаб логарифмов
unsigned myLog(unsigned w)
{
unsigned s=0;
unsigned long long u=w;
for(int i=0; i>(DIG-1); //берём только старшие разряды !
if(u&TWO) //тут достаточно одного бита для сравнения
{
u>>=1;
s+=1;
}
printf("%X\n", (int)u);
}
return s;
}
int main()
{
double w=1.2345678;
unsigned iw=(unsigned)(ONE\*w);
double dlog=log2(w);
unsigned ilog=myLog(iw);
unsigned test=(unsigned)(SCALE\*dlog);
int err=abs((int)(ilog-test));
printf("val=0x%X, res=0x%X, log=0x%X, err=%d\n",iw,ilog,test,err);
return 0;
}
```
Поиграв в программе с разными разрядностью чисел (DIG), точностью вычислений (N\_BITS), и аргументами логарифма (w), видим, что всё вычисляется правильно. В частности с теми параметрами, которые заданны в этом исходнике, программа выдаёт:
val=0x27819, res=0x9BA5, log=0x9BA6, err=1
Теперь всё готово для того, чтобы реализовать на верилоге железку, делающую точно то же самое, что и функция **myLog** на С. Переменные **s** и **u** в нашей функции можно распечатать в цикле и сравнивать с тем, что выдает симулятор верилога. Соответствие этих переменных железной реализации весьма прозрачно и понятно. **u** это рабочий регистр, принимающий во время итераций новые значения **X**. **s** это сдвиговый регистр, в котором накапливается результат. Интерфейс нашего модуля будет выглядеть вот так:
```
module logarithm(
input clk, //клок
input wr, //сигнал записи данных
input[17:0] din, //входная шина данных
output[nbits-1:0] dout, //выходная шина данных
output rdy //сигнал готовности
);
parameter nbits=16; //точность вычисления
```
Входная шина принята 18-разрядной, соответственно разрядности умножителей в Cyclone IV. Числа на наш модуль должны поступать нормализованные. Т.е. со старшим битом, равным единице. В моём проекте это выполнялось автоматически. Но в случае чего реализовать нормализатор, думаю никому труда не составит. Точность вычислений задаётся параметром nbits, по умолчанию равным 16. Модуль считает по одному биту за такт, и за 16 тактов вычислит логарифм с точностью до 16 битов. Если надо быстрее с той же точностью или точнее с той же скоростью, надеюсь никому не составит особого труда разделить модуль на несколько устройств и конвейеризовать.
**Вот полный код модуля и теста**
```
//--------------------- logarithm.v ------------------------------//
module logarithm(
input clk, //клок
input wr, //сигнал записи данных
input[17:0] din, //входная шина данных
output[nbits-1:0] dout, //выходная шина данных
output rdy //сигнал готовности
);
parameter nbits=16; //точность вычисления
reg[4:0] cnt; //счетчик
reg[17:0] acc; //рабочий регистр-аккумулятор
reg[nbits-1:0] res; //результат
always @(posedge clk)
if(wr) cnt<=nbits+1;
else
if(cnt != 0)
cnt<=cnt-1;
wire[35:0] square=acc*acc; //квадрат аккумулятора
wire bit=square[35]; //бит результата
wire[17:0] next = bit ? square[35:18] : square[34:17]; //новый аккумулятор
always @(posedge clk)
if(wr) acc<=din;
else
if(cnt != 0) begin
acc<=next;
#10 $display("%X", acc);
end
always @(posedge clk)
if(wr) res<=0;
else
if(cnt != 0) begin
res[nbits-1:1]<=res[nbits-2:0];
res[0]<=bit;
end
assign dout=res;
assign rdy=(cnt==0);
endmodule
//======================== testbench.v =====================//
module testbench();
reg clk; //клок
always
#100 clk=~clk;
reg wr; //запись
reg[17:0] din; //вход
wire rdy; //готовность
wire[15:0] dout; //выход
logarithm log2(
.clk (clk),
.wr (wr),
.din (din),
.dout (dout),
.rdy (rdy)
);
// ждёт n клоков и немного ещё
task skipClk(integer n);
integer i;
begin
for(i=0; i
```
Запустим тест вот таким скриптом:
```
#!/bin/sh
rm -f *.vvp
rm -f *.vcd
iverilog -o testbench.vvp logarithm.v testbench.v
vvp testbench.vvp
gtkwave testbench.vcd testbench.gtkw
```
Запустив тест, видим окончательный вывод симулятора — value=27819, result=9ba5. Верилог выдал то же самое что С. Временная диаграмма тут довольно тривиальна и особого интереса не представляет. Поэтому её не привожу.
**Сравним промежуточный вывод симулятора (acc) и программы на С (s):**`Verilog C
30c5d 30C5D
252b1 252B1
2b2bc 2B2BC
3a3dc 3A3DC
35002 35002
2be43 2BE43
3c339 3C339
38a0d 38A0D
321b0 321B0
273a3 273A3
30163 30163
24214 24214
28caf 28CAF
34005 34005
2a408 2A408
37c9d 37C9D
30a15 30A15`
Убеждаемся, что они совпадают бит в бит. Итого, реализация на верилоге повторяет с точностью до бита модель на С. Это и есть тот результат, которого следует достигать, реализуя алгоритмы в железе.
На этом пожалуй всё. Надеюсь кому-то этот мой опыт окажется полезен.
|
https://habr.com/ru/post/469327/
| null |
ru
| null |
# Обновлённый jQuery Wysiwyg 0.6
Рад сообщить, что обновлённый [jQuery Wysiwyg 0.6](http://code.google.com/p/jwysiwyg/) [вышел в свет](http://code.google.com/p/jwysiwyg/downloads/detail?name=jwysiwyg-0.6.zip&can=2&q=).
[](http://jwysiwyg.googlecode.com/svn/trunk/examples/02-full.html)
Он так и остался крохотным редактором с минимумом возможностей, но теперь у Вас есть возможность сделать так:
`$('#ed').wysiwyg('insertHtml', 'my funny HTML');`
Также поправлено некоторое число недоработок под браузерами Firefox, Safari и MSIE.
[Демонстрация](http://jwysiwyg.googlecode.com/svn/trunk/examples/02-full.html).
Важно: Теперь требуется jQuery не ниже 1.3.
|
https://habr.com/ru/post/79086/
| null |
ru
| null |
# VMware View Client с поддержкой PCoIP и пробросом USB на Linux
Как вы уже догадались с темы поста речь сегодня пойдет о установке VMware View Client (не VMware View Open Client) с поддержкой PCoIP и поддержкой проброса USB на Linux. Сразу хотел бы предупредить, что *данное решение не является официальным, мало того, мне неизвестно насколько оно легально, т.к. в нем используются бинарные пакеты от HP которые официально предназначены для тонких клиентов HP ThinPro*. И так, всех, кого не смущает мое предупреждение, прошу под кат.
Итак, мы имеем установленный и настроенный vCenter, один или несколько ESXi серверов, сервер VMware View Connection Server (подробнее об этом можно прочитать [здесь](http://www.vladan.fr/vmware-view-5-install-configure-how-to-in-my-lab/) или [здесь](http://vtexan.com/2011/11/03/how-to-install-configure-and-deploy-vmware-view-5-on-vsphere-5/), ну или [тут](http://www.vm4.ru/2010/10/view-45-how-to.html)). В качестве клиентских рабочих станций у меня выступают несколько стареньких ПК (Celeron 1.7/128MB/20Gb/100Mbit) с ОС Debian 6.0.3 i386 (хотя можно использовать любой линукс, но предпочтительно использовать дебианоподобные дистрибутивы) в минимальной инсталяции. Я подозреваю что можно использовать и более старые ПК (запускал в виртуальной машине с лимитом частоты процессора в 400Mhz и 64Mb RAM, но производительность современного серверного железа с физическим 7-10 летней давности нельзя), а под рукой не оказалось таких для эксперимента.
Итак, приступим к настройке клиентской рабочей станции. Для начала устанавливаем Debian 6.0.3 в минимальной конфигурации на последнем этапе выбрав помимо стандартных системных утилит только ssh сервер (для удаленного управление рабочей станцией). Далее ставим «иксы» и дополнительные зависимости VMware View Client:
`root@viewclient:~# aptitude install xinit libqtgui4 libcurl3 libpcsclite1 libsamplerate0 libasound2 libgtk2.0-0 sudo`
А теперь приступаем к установке самого клиента. Скачиваем необходимые пакеты с ftp сервера HP:
`root@viewclient:~# wget ftp.hp.com/pub/tcdebian/pool/thinpro33/non-free/hptc-manticore_3.2.1_i386.deb
root@viewclient:~# wget ftp.hp.com/pub/tcdebian/pool/thinpro32/main/hptc-rdesktop_1.6.0-1.35_i386.deb
root@viewclient:~# wget ftp.hp.com/pub/tcdebian/pool/thinpro33/non-free/hptc-sudo-edit_0.1_i386.deb
root@viewclient:~# wget ftp.hp.com/pub/tcdebian/pool/thinpro33/non-free/vmware-view-client_4.6.0-366101-2_i386.deb`
К сожалению на данный момент нет пакетов для 5-й версии, но клиент версии 4.6 может свободно работать с сервером 5-й версии, за исключением новых фич, которые доступны в VMware View Client 5.0. Я думаю вы заметили что пакет hptc-rdesktop скачивается не из то директории, в которой расположены остальные файлы, хоть он там и есть, да еще и более новой версии. Дело в том, что новая версия собрана с поддержкой библиотеки libao2, но в репозитарии Debian Squeezze имеется только libao4. libao2 доступен в Debian Lenny. Если в вашем дистрибутиве есть libao2 можно использовать более свежий пакет [hptc-rdesktop](ftp://ftp.hp.com/pub/tcdebian/pool/thinpro33/main/hptc-rdesktop_1.6.0-1.41_i386.deb).
Инсталлируем их в следующей последовательности:
`root@viewclient:~# dpkg -i hptc-manticore_3.2.1_i386.deb
root@viewclient:~# dpkg -i hptc-rdesktop_1.6.0-1.35_i386.deb
root@viewclient:~# dpkg -i hptc-sudo-edit_0.1_i386.deb
root@viewclient:~# dpkg -i vmware-view-client_4.6.0-366101-2_i386.deb`
Создаем симлинк, дял корректной работы проброса USB:
`root@viewclient:~# ln -s /usr/lib/vmware/vmware-view-usb /etc/vmware/usb.link`
И пробуем запустить клиент следующей командой:
`root@viewclient:~# vmware-view`
Если запуск произошел без ошибок можно открыть первую бутылку пива.
Теперь необходимо привести все это добро в удобоваримый для конечного пользователя вид. В процессе установки ОС был создан пользователь view, под которым будет запускаться VMware View Client. Для начала настроим автоматический запуск «иксов» при загрузке системы под пользователем view. Для этого редактируем файл rc.local добавив перед заключительной строкой exit 0 следующую строчку:
`su - view -c startx`
Перезагружаемся что бы удостовериться что «иксы» стартовали успешно. Если все ок, последним этапом настраиваем автоматический старт VMware View Client при старте «иксов» и выключение ПК после его закрытия. Для этого в домашней директории пользователя создаем файл .xinitrc следующего содержания:
`. /usr/local/bin/vmwareview.sh`
Создаем скрипт vmwareview.sh:
`#!/bin/sh
/usr/bin/vmware-view && sudo /sbin/shutdown -hP now`
И редактируем файл sudoers, разрешив пользователю view выключать ПК:
`view ALL = NOPASSWD: /sbin/shutdown -hP now`
Еще раз перегружаемся и убеждаемся что все работает как запланировано. Открываем вторую бутылку пива.
На этом пожалуй все. В данной статье я рассмотрел только базовую настройку ОС клиентского ПК для запуска VMware View Client под Linux, но ее достаточно для комфортной работы.
P.S. Сферой применение подобной схемы может быть тестовое внедрение VDI на базе VMware View без закупки дополнительного оборудования (тонких клиентов), использование в образовательных целях (изучение VMware View) и т.д.
|
https://habr.com/ru/post/133033/
| null |
ru
| null |
# «Доска позора» с юзерами, выдающими приватную информацию
18-летний студент юрфака и PHP-разработчик Колум Хэйвуд (Callum Haywood) запустил настоящий социальный эксперимент на сайте [We Know What You’re Doing](http://www.weknowwhatyouredoing.com/) («Мы знаем, что ты делаешь»). Сайт вытягивает информацию об отдельных пользователях через Facebook Graph API выкладывает её на всеобщее обозрение. Причём выкладывает не просто так, а с разбивкой по категориям: 1) список пользователей, которые «хотят, чтобы их уволили» с соответствующими цитатами из социальной сети; 2) список пользователей, которые находятся в похмелье с цитатами и фотографиями; 3) список тех, кто только что закурил марихуану или принял другой наркотик; 4) список пользователей, которые опубликовали свой новый номер телефона.
Выставляя юзеров на посмешище, то есть на всеобщее обозрение, основатель сервиса надеется привлечь внимание к проблеме утечки приватных данных через Facebook. Многие пользователи не задумываются о том, что их личная информация в реальности открыта всему миру, а их сообщения могут увидеть миллиарды жителей Земли. Своеобразная «доска почёта» привлекает внимание к таким пользователям, хотя здесь нет никакой секретной информации из подзамочных записей, всё это действительно лежит в открытом доступе на Facebook и доступно через простой GET-запрос типа `graph.facebook.com/search?q=hate%20my%20boss&type=post&locale=en_GB`, на что приходит ответ JSON-формате. На сайте просто происходит фильтрация полученной информации и обновление статусов с опозданием примерно на час.
Смысл «доски почёта» в том, что она показывает информацию, которую пользователи не хотели бы демонстрировать всем подряд, но на практике делают именно это. Может, таким способом людей удастся перевоспитать и они научатся пользоваться настройками приватности?
Идея веб-сайта появилась из замечательной презентации Тома Скотта «[Я знаю, что ты сделал пять минут назад](http://www.tomscott.com/five/)».
Жаль, что на сайте нет колонки с теми пользователями Facebook, которые читают «Хабрахабр». Например, вот этот юзер:
<http://www.facebook.com/profile.php?=743264506>
|
https://habr.com/ru/post/146555/
| null |
ru
| null |
# Управляем бесколлекторными двигателями, господа
**Привет Хабровчане!**
Решил я рассказать «всему свету» о проблеме, с которой столкнулся при постройке своего проекта, и как мне удалось её решить.
А речь сегодня пойдет о бесколлекторных двигателях, о регуляторах хода и как ими управлять.
Что же такое бесколлекторный двигатель, я не буду долго расписывать (сами можете посмотреть [Wiki](http://ru.wikipedia.org/wiki/%D0%92%D0%B5%D0%BD%D1%82%D0%B8%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B4%D0%B2%D0%B8%D0%B3%D0%B0%D1%82%D0%B5%D0%BB%D1%8C)), а скажу в 2х словах, это 3х фазный двигатель постоянного тока.
И приводится в движение сие чудо благодаря специальному регулятору, который последовательно переключает обмотки с определенной частотой.
Управляя частотой переключения обмоток мы управляем скоростью вращения ротора.
Ну что же, надеюсь тут все понято, идем дальше.
**Первые проблемы**
Были закуплены 2 комплекта двигатель + регулятор, ждал около месяца, пришли.
Мною овладел приступ безудержного веселья по этому поводу, но, к сожалению, это было ненадолго….
Рассмотрев эти чудеса техники я решил подключить их к источнику питания, и тут то первое разочарование, тихий хлопок (как от КЗ) и тишина, светодиоды не горят, писка нет (а он должен быть), только крутится кулер на регуле, беда…
Побежал в ближайший Хобби магазин, и добрый консультант вынес вердикт: сгорел!
Со вторым такая же история, в общем ребята, не повезло, оба бракованные…
Ну хоть кошечка порадовалась:
Пришлось раскошелиться и купить у них регулятор по цене обоих комплектов (поджимали сроки).
Купил, подключил, все пищит, горит, работает, прям аж душа радуется! (на фото он выделен):
**Проблема номер два**
Теперь настала пора покрутить двигателем.
А покрутить нужно не с сервотестера или аппы радиоуправления, а с микроконтроллера, а точнее вот с такой платки:
Перелопатив тонны сайтов, перечитав сотни форумов и ответов на мой вопрос, так как же управлять этим регулятором я слышать только одно: «…чувак да там простой ШИМ…», «… ШИМ тебе в помощь…».
Ну ШИМ, так ШИМ.
Написал простенькую программу:
```
#include
Servo motor;
int mot\_pin = 7; //Подключаем левый мотор к пину 7
int js\_position = 800;
int max\_position = 3000;
void setup()
{
motor\_teft.attach(mot\_pin, js\_position, max\_position); //Инициальзация мотора
}
void loop()
{
motor.write(1800); //Записываем положение и отправляем на регулятор
}
```
Залил, ноль эмоций…
Бился 2 дня, пока не наткнулся на случайный пост, о том, что у регулятора есть защита, и он начинает функционировать только при подаче на его вход ШИМ сигнала 1,5 мс.
Окей, будет сделано.
Дальше я подцепил обыкновенный резистор через АЦП, и опытным путем подобрал крайние значения ШИМ регулятора.
Код получившийся в итоге:
```
#include
Servo motor\_teft;
Servo motor\_right;
int mot\_pin\_left = 7; //Подключаем левый мотор к пину 7
int mot\_pin\_right = 8; //Подключаем правый мотор к пину 8
int js\_position = 1500; //Начальная позиция, всегда 1.5 мс для регуляторов бесколлекторных двигателей
int max\_position = 2300; //Максимальное значение ШИМ 2.3 мс
int min\_position = 800; //Минимальное значени ШИМ 0.8 мс
int start = 1; //Флаг задержки запуска
void setup()
{
motor\_teft.attach(mot\_pin\_left, js\_position, max\_position); //Инициальзация левого мотора (порт, начальная позиция, максимальная позиция) !!!
motor\_right.attach(mot\_pin\_right, js\_position, max\_position); //Инициальзация правого мотора (порт, начальная позиция, максимальная позиция) !!!
}
void loop()
{
//Начальная установка регуляторов в нулевое положение
if(start == 1) {
motor\_teft.write(js\_position);
motor\_right.write(js\_position);
delay(700);
start = 0;
}
js\_position = analogRead(A0); //Считывание положения потенциометра
js\_position = map(js\_position, 0, 1023, 75, 140); //Преобразование положения потенциометра в угол поворота
motor\_left.write(js\_position); //Записываем положение и отправляем на регулятор левого мотора
motor\_right.write(js\_position); //Записываем положение и отправляем на регулятор правого мотора
delay(20); //Задержка цикла 20 мс
}
```
И все заработало.
Теперь все крутиться, шумит, пищит и просто радует.
P.S. Это код для управления сразу 2мя двигателями.
**И последняя проблема, питание…**
Здесь расскажу немного, а именно, от регулятора идет 3 провода:
Центральная колодка, по порядку *Черный — минус, Красный — плюс и Белый — провод управления*.
И загвоздка в том, что в отличие от сервоприводов, это не входы под питание, а выходы, т.е. питаемся от них.
К чему я это, да к тому, что подключив регулятор как серву, я чуть не спалил порты на ноутбуке, ибо плата в это время была запитана от USB.
Но к счастью у моего старичка сработала защита и все обошлось перезагрузкой…
Видео работы:
Спасибо большое за внимание.
Надеюсь мой опыт будет полезен для вас.
До скорых встреч.
|
https://habr.com/ru/post/219723/
| null |
ru
| null |
# Spring Boot @ConfigurationProperties и коллекции
**Дано:**
Сервис на **spring boot(2.6.4)** + **kotlin(1.5.31)** по выгрузке произвольного количества отчётов по крону. Каждый отчет имеет свои настройки. Для конфигурирования списка свойств отчётов используется собственно список. Для инжекта в приложение используется data class с аннотацией @ConfigurationProperties, где одно из свойств - список data class.
**Выглядит это примерно так:**
```
#application.yml
report-export:
cron: 0 0 12 * *
reports:
- file-prefix: REPORT1
region-name: Москва
sftp-host: host1
sftp-port: 22
sftp-user: user1
sftp-password: pwd1
- file-prefix: REPORT2
region-name: Подольск
sftp-host: host1
sftp-port: 22
sftp-user: user1
sftp-password: pwd2
```
```
@ConfigurationProperties("report-export")
@ConstructorBinding
data class ReportExportProperties(
val cron: String,
val reports: List
) {
data class ReportProperties(
val filePrefix: String,
val regionName: String,
val sftpHost: String,
val sftpPort: Int,
val sftpUser: String
)
}
```
Оказалось, что это не лучшее решение использовать список, если вы планируете размещать часть свойств его элементов в разных property source. Конкретно в моем случае, секрет sftp-password должен был быть размещен в Vault.
Согласно [документации](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#features.external-config.typesafe-configuration-properties.merging-complex-types) списки для @*ConfigurationProperties* мёрджутся не так, как для остальных сложенных структур. Если положить в Vault только секреты *sftp-password*, то остальные свойства data class из списка будут инициализироваться дефолтными свойствами, если они заданы ( если не заданы - контекст не поднимется). **Т.е. список не мёрджится, а берется из property source с большим приоритетом как есть.**
Ниже тест, показывающий, показывающий, что для вложенных классов и свойств, мёрдж работает, а для списков - нет:
```
#application.yml
tpp:
test:
root:
root-field1: default
nested:
nested-field1: default
nested-list:
- nested-list-field1: default1
- nested-list-field1: default2
#application-dev.yml
tpp:
test:
root:
root-field2: dev
nested:
nested-field2: dev
nested-list:
- nested-list-field2: dev1
- nested-list-field2: dev2
```
```
@ConfigurationProperties("tpp.test.root")
@ConstructorBinding
data class RootPropperties(
val rootField1: String = "",
val rootField2: String = "",
val nested: NestedProperties = NestedProperties(),
val nestedList: List = listOf()
) {
data class NestedProperties(
val nestedField1: String = "",
val nestedField2: String = ""
)
data class NestedListProperties(
val nestedListField1: String = "",
val nestedListField2: String = ""
)
}
```
```
@ActiveProfiles("dev")
@SpringBootTest
internal class ConfigurationPropertiesTest {
@Autowired
lateinit var rootPropperties: RootPropperties
@Test
fun `configuration properties binding`() {
assertEquals("default", rootPropperties.rootField1)
assertEquals("dev", rootPropperties.rootField2)
assertEquals("dev", rootPropperties.nested.nestedField2)
assertEquals("default", rootPropperties.nested.nestedField1)
assertTrue(rootPropperties.nestedList.isNotEmpty())
assertEquals("dev1", rootPropperties.nestedList[0].nestedListField2)
assertEquals("dev2", rootPropperties.nestedList[1].nestedListField2)
// Здесь падает
// org.opentest4j.AssertionFailedError:
//Expected :default1
//Actual :
assertEquals("default1", rootPropperties.nestedList[0].nestedListField1)
// Здесь падает
// org.opentest4j.AssertionFailedError:
//Expected :default2
//Actual :
assertEquals("default2", rootPropperties.nestedList[1].nestedListField1)
}
}
```
Интересно, что если переписать тест, запрашивая все значения из [Environment](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/core/env/Environment.html), то мы получим корректные значения для всех вложенных структур:
```
@ActiveProfiles("dev")
@SpringBootTest
internal class ConfigurationPropertiesTest {
@Autowired
lateinit var environment: Environment
@Test
fun `environment binding`() {
assertEquals("default", environment.getProperty("tpp.test.root.root-field1"))
assertEquals("dev", environment.getProperty("tpp.test.root.root-field2"))
assertEquals("default", environment.getProperty("tpp.test.root.nested.nested-field1"))
assertEquals("dev", environment.getProperty("tpp.test.root.nested.nested-field2"))
assertEquals("default1", environment.getProperty("tpp.test.root.nested-list[0].nested-list-field1"))
assertEquals("dev1", environment.getProperty("tpp.test.root.nested-list[0].nested-list-field2"))
assertEquals("default2", environment.getProperty("tpp.test.root.nested-list[1].nested-list-field1"))
assertEquals("dev2", environment.getProperty("tpp.test.root.nested-list[1].nested-list-field2"))
}
}
```
В ответе на вопрос в моем [issue](https://github.com/spring-projects/spring-boot/issues/32165#issuecomment-1227717648) сказано, что так сделано намеренно и каких-либо изменений для списков не планируется. Предложенный workaround - использовать Map вместо коллекций. Ниже приведен пример, как можно переписать предыдущий тест:
```
#application.yml
tpp:
test:
root-map:
root-field1: default
nested:
nested-field1: default
nested-map:
1:
nested-map-field1: default1
2:
nested-map-field1: default2
#application-dev.yml
tpp:
test:
root-map:
root-field2: dev
nested:
nested-field2: dev
nested-map:
1:
nested-map-field2: dev1
2:
nested-map-field2: dev2
```
```
@ActiveProfiles("dev")
@SpringBootTest
internal class ConfigurationPropertiesMapTest {
@Autowired
lateinit var environment: Environment
@Autowired
lateinit var rootPropperties: RootMapPropperties
@Test
fun `configuration properties binding`() {
Assertions.assertEquals("default", rootPropperties.rootField1)
Assertions.assertEquals("dev", rootPropperties.rootField2)
Assertions.assertEquals("default", rootPropperties.nested.nestedField1)
Assertions.assertEquals("dev", rootPropperties.nested.nestedField2)
Assertions.assertTrue(rootPropperties.nestedMap.isNotEmpty())
Assertions.assertEquals("default1", rootPropperties.nestedMap["1"]!!.nestedMapField1)
Assertions.assertEquals("dev1", rootPropperties.nestedMap["1"]!!.nestedMapField2)
Assertions.assertEquals("default2", rootPropperties.nestedMap["2"]!!.nestedMapField1)
Assertions.assertEquals("dev2", rootPropperties.nestedMap["2"]!!.nestedMapField2)
}
}
```
У меня нет однозначного мнения относительно ответа от команды spring, что не планируется пересматривать алгоритм мёрджа для коллекций. С одной стороны понятно, что есть некая неоднозначность относительно того, что делать, если например в одном property source 2 элемента, в другом 3. Как это интерпретировать, мёрджить ли этот список сложением элементов например? Мое мнение, что можно мёрджить элементы списка также, как Map относительно индексов. Т.е. первые 2 элемента мёрджутся согласно приоритетам property source, а 3й полностью берется как есть, т.к. он задан только в одном property source. Как показано выше Environment вполне себе справляется с разрешением этих неоднозначностей. А как думаете Вы?
Это мой первый пробный пост. Надеюсь, он не получился слишком поверхностным.
|
https://habr.com/ru/post/686726/
| null |
ru
| null |
# Установка micropython на ESP8266 и работа с ним под Linux (для начинающих)
Привет, Хабр!
Это мой первый опыт с микроконтроллерами в целом, и ESP8266 (в виде Nodemcu v2) в частности. Возможно, для кого-то этот опыт окажется полезным.
Почему именно micropython? Ответ простой — мой скромный опыт в области программирования ограничен Паскалем в ВУЗе, и написанием конфигурационных скриптов для Procera на Python, так что он оказался ближе всего. Примеры будут под Linux (ubuntu 18.04), но, полагаю, в других дистрибутивах Linux принципиальной разницы не будет.
#### Подготовка:
Ставим python3, pip и picocom, если они ещё не установлены:
```
sudo apt install python3 python3-pip picocom
```
Проверяем версию python:
```
python --version
Python 3.6.9
```
Если версия python 2.7, меняем на 3:
```
sudo update-alternatives --install /usr/bin/python python /usr/bin/python3 10
update-alternatives: using /usr/bin/python3 to provide /usr/bin/python (python) in auto mode
```
Обновляем pip и проверяем версию:
```
sudo pip3 install --upgrade pip
pip --version
pip 20.0.2 from /usr/local/lib/python3.6/dist-packages/pip (python 3.6)
pip3 --version
pip 20.0.2 from /usr/local/lib/python3.6/dist-packages/pip (python 3.6)
```
Ставим более свежую версию esptool 2.8 из pip (т.к. версия 2.1 из репозитория ubuntu выдаёт ошибку «A fatal error occurred: ESP8266 ROM does not support function erase\_flash.» при прошивке):
```
pip3 install esptool
```
Качаем прошивку [здесь](http://micropython.org/download#esp8266). Я использовал stable билд [1.12](http://micropython.org/resources/firmware/esp8266-20191220-v1.12.bin).
Далее возможно два варианта:
* #### 1. Восход солнца вручную (с использованием терминала и REPL):
Очищаем flash на ESP8266:
```
esptool.py --port /dev/ttyUSB0 erase_flash
```
Вывод команды:
```
esptool.py v2.8
Serial port /dev/ttyUSB0
Connecting....
Detecting chip type... ESP8266
Chip is ESP8266EX
Features: WiFi
Crystal is 26MHz
MAC: c8:2b:96:00:63:35
Uploading stub...
Running stub...
Stub running...
Erasing flash (this may take a while)...
Chip erase completed successfully in 9.5s
Hard resetting via RTS pin...
```
Заливаем прошивку:
```
esptool.py --port /dev/ttyUSB0 --baud 460800 write_flash --flash_size=detect 0 Downloads/esp8266-20191220-v1.12.bin
```
Вывод команды:
```
esptool.py v2.8
Serial port /dev/ttyUSB0
Connecting....
Detecting chip type... ESP8266
Chip is ESP8266EX
Features: WiFi
Crystal is 26MHz
MAC: c8:2b:96:00:63:35
Uploading stub...
Running stub...
Stub running...
Changing baud rate to 460800
Changed.
Configuring flash size...
Auto-detected Flash size: 4MB
Flash params set to 0x0040
Compressed 619828 bytes to 404070...
Wrote 619828 bytes (404070 compressed) at 0x00000000 in 9.1 seconds (effective 543.8 kbit/s)...
Hash of data verified.
Leaving...
Hard resetting via RTS pin...
```
И, при желании, проверяем корректность контрольной суммы:
```
esptool.py --port /dev/ttyUSB0 --baud 460800 verify_flash --flash_size=detect 0 Downloads/esp8266-20191220-v1.12.bin
```
После чего, пробуем подключиться к МК и увидеть консоль [REPL](https://docs.micropython.org/en/latest/esp8266/esp8266/tutorial/repl.html):
```
picocom /dev/ttyUSB0 -b115200
```
```
picocom v2.2
port is : /dev/ttyUSB0
flowcontrol : none
baudrate is : 115200
parity is : none
databits are : 8
stopbits are : 1
escape is : C-a
local echo is : no
noinit is : no
noreset is : no
nolock is : no
send_cmd is : sz -vv
receive_cmd is : rz -vv -E
imap is :
omap is :
emap is : crcrlf,delbs,
Type [C-a] [C-h] to see available commands
Terminal ready
>>> help()
Welcome to MicroPython!
For online docs please visit http://docs.micropython.org/en/latest/esp8266/ .
For diagnostic information to include in bug reports execute 'import port_diag'.
Basic WiFi configuration:
import network
sta_if = network.WLAN(network.STA_IF); sta_if.active(True)
sta_if.scan() # Scan for available access points
sta_if.connect("", "") # Connect to an AP
sta\_if.isconnected() # Check for successful connection
# Change name/password of ESP8266's AP:
ap\_if = network.WLAN(network.AP\_IF)
ap\_if.config(essid="", authmode=network.AUTH\_WPA\_WPA2\_PSK, password="")
Control commands:
CTRL-A -- on a blank line, enter raw REPL mode
CTRL-B -- on a blank line, enter normal REPL mode
CTRL-C -- interrupt a running program
CTRL-D -- on a blank line, do a soft reset of the board
CTRL-E -- on a blank line, enter paste mode
For further help on a specific object, type help(obj)
>>>
```
П.С.: для выхода из picocom использовать Ctrl+a и сразу Ctrl+x
* #### 2. С использованием IDE
Хотя первый вариант вполне работоспособен (по крайней мере, помигать светодиодом можно и в нём), с IDE все же гораздо удобнее. Я попробовал пару вариантов, в итоге остановился на [Thonny](https://thonny.org/).
Установка:
Ставим python3-tk из репозиториев, и собственно Thonny через pip:
```
sudo apt install python3-tk
```
```
sudo pip3 install thonny
```
Залить прошивку на МК можно непосредственно через Thonny:
После чего, моргать светодиодом становится существенно удобнее:
#### Итого
На выходе имеем МК esp8266 с прошитым micropython, и удобную в использовании IDE для работы с ним.
П.С.: [вторая часть (Самоходная платформа на МК esp8266 с micropyhon)](https://habr.com/ru/post/495576/)
|
https://habr.com/ru/post/494630/
| null |
ru
| null |
# Перебор, бессмысленный и беспощадный
Этот кусок AS1-кода задаёт поведение нескольких кнопок. Орфография и пунктуация сохранены. Я уж прямо не знаю, смеяться или плакать — мне такого кода выдали пару десятков тысяч строк и сказали доделать…
`onMouseDown = function() {;
if (btn_right._visible && btn_right.enabled) {;
if(btn_right.hitTest(_xmouse, _ymouse, 0)){;
btn_right_release();
};
};
if (ready._visible && ready.enabled) {;
if(ready.hitTest(_xmouse, _ymouse, 0)){;
ready_release();
};
};
if (ready2._visible && ready2.enabled) {;
if(ready2.hitTest(_xmouse, _ymouse, 0)){;
ready2_release();
};
};
if (yesno.no._visible && yesno.no.enabled) {;
if(yesno.no.hitTest(_xmouse, _ymouse, 0)){;
no_release();
};
};
if (yesno2.no._visible && yesno2.no.enabled) {;
if(yesno2.no.hitTest(_xmouse, _ymouse, 0)){;
no2_release();
};
};
};`
|
https://habr.com/ru/post/54265/
| null |
ru
| null |
# Вышел релиз GitLab 14.3 с правилами сканирований безопасности для проекта и SAST нового поколения
Мы рады представить вам релиз GitLab 14.3 с [правилами запуска сканирований безопасности для проектов](#pravila-zapuska-skanirovaniy-bezopasnosti-dlya-proektov), [следующим поколением SAST для снижения количества ложных срабатываний в Ruby](#sast-novogo-pokoleniya-dlya-snizheniya-kolichestva-lozhnyh-srabatyvaniy-v-ruby), [установкой разрешений для защищённых окружений на уровне группы](#ustanovka-razresheniy-dlya-zaschischyonnyh-okruzheniy-na-urovne-gruppy), [групповым доступом к GitLab Kubernetes Agent](#gruppovoy-dostup-k-gitlab-kubernetes-agent) и многим другим!
Это — лишь несколько основных из более чем 40 улучшений этого релиза. Читайте далее, и вы узнаете всё об этих классных обновлениях.
Чтобы узнать, что выйдет в следующем месяце, зайдите на страницу [предстоящих релизов](https://about.gitlab.com/direction/kickoff/), где вы найдёте видео по релизу 14.4.
[Приглашаем на наши встречи](https://about.gitlab.com/events/).
[MVP](https://about.gitlab.com/community/mvp/) этого месяца — [feistel](https://gitlab.com/feistel)
---------------------------------------------------------------------------------------------------
feistel работает над GitLab Pages с сентября 2020 года. Только за последние 4 месяца благодаря feistel появилось множество новых фич и было исправлено немало багов, а также была предоставлена значительная помощь в разборе бэклога по Pages. В релизе 14.3 feistel по собственной инициативе берётся за работу над некоторыми из [задач, поставленных нашей релизной группой](https://gitlab.com/gitlab-org/ci-cd/release-group/release/-/issues/66#deliverables-fox), что позволяет нам сосредоточиться на ревью и оставляет больше времени для работы над другими проблемах.
Кроме того, feistel работает и над другими проектами на Go, такими как [GitLab Runner](https://gitlab.com/gitlab-org/gitlab-runner/-/merge_requests/3101), [GitLab Shell](https://gitlab.com/gitlab-org/gitlab-shell/-/merge_requests/509), [реестр контейнеров](https://gitlab.com/gitlab-org/container-registry/-/merge_requests/738) и не только, а также участвует в [ревью кода](https://gitlab.com/gitlab-org/gitlab-pages/-/merge_requests/458#note_649747756). Недавно благодаря вкладу feistel появился простой [CLI-инструмент](https://gitlab.com/feistel/canwebumpgoyet), с помощью которого вы можете проверить, возможно ли обновить версию Go в проекте. Пример использования этого инструмента можно посмотреть [в этом мерж-реквесте](https://gitlab.com/gitlab-org/gitlab-pages/-/merge_requests/547). Вот [полный список вкладов feistel](https://gitlab.com/groups/gitlab-org/-/merge_requests?scope=all&state=opened&author_username=feistel). Спасибо за эту работу!
Основные фичи релиза GitLab 14.3
--------------------------------
### Правила запуска сканирований безопасности для проектов
(SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Protect](https://about.gitlab.com/stages-devops-lifecycle/protect/)
Мы завершили первый шаг [на пути к внедрению единых правил безопасности в GitLab](https://about.gitlab.com/direction/protect/security_orchestration/). Теперь пользователи могут устанавливать выполнение DAST-сканирований и сканирований на обнаружение секретных ключей по расписанию или в рамках CI-конвейеров (в русской локализации GitLab «сборочные линии») проекта, независимо от содержимого файла `.gitlab-ci.yml`. Это позволяет командам безопасности управлять этими требованиями к сканированиям напрямую, не отдавая эту задачу разработчикам. Найти эти правила и приступить к работе над ними вы можете на странице **Безопасность и комплаенс > Policies** (**Security & Compliance > Policies**) в вашем проекте.
[Документация по правилам запуска сканирований безопасности](https://docs.gitlab.com/ee/user/application_security/policies/) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/5362).
### Групповой доступ к GitLab Kubernetes Agent
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Configure](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Агент для Kubernetes от GitLab (GitLab Kubernetes Agent) обеспечивает безопасное соединение между кластером Kubernetes и GitLab. Ранее CI/CD-туннель предоставлял возможность пушить в кластер только из того же проекта, в котором был зарегистрирован агент. С релизом 14.3 агенту может быть предоставлен доступ к целым группам. В результате каждый проект в настроенной группе будет иметь доступ к кластеру без необходимости регистрировать агент для каждого проекта.
[Документация по групповому доступу к GitLab Kubernetes Agent](https://docs.gitlab.com/ee/user/clusters/agent/repository.html#authorize-groups-to-use-an-agent) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/5784).
### Визуальное редактирование таблиц в WYSIWYG-редакторе вики
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Редактирование таблицы Markdown из 9 столбцов и 25 строк — это одно. Но добавлять ещё один столбец к этой же таблице в Markdown — уже совсем другое. Эта задача требует повторяющихся правок в каждой строке, а в таких условиях легко ошибиться. Всего одна неточность или неправильно поставленный символ `|` и таблица не будет отрендерена.
WYSIWYG-редактор Markdown в вики позволяет быстро и легко вставить таблицу с помощью соответствующей кнопки на панели инструментов. Однако после начального выбора количества строк и столбцов редактирование структуры таблицы может вызвать больше трудностей. Теперь вы можете нажать на значок с изображением стрелки вниз в правом верхнем углу любой выделенной ячейки, чтобы добавить или удалить столбцы и строки, как до, так и после этой ячейки. При увеличении объёма содержимого сложность работы с таблицей не будет увеличиваться.
[Документация по редактору вики-контента](https://docs.gitlab.com/ee/user/project/wiki/#content-editor) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/328759).
### Установка разрешений для защищённых окружений на уровне группы
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
Как правило, в крупных организациях существует явное разграничение полномочий между разработчиками и специалистами по эксплуатации. Разработчики могут разворачивать и тестировать приложение в окружениях нижнего уровня, например, в окружениях для разработки. Специалисты по эксплуатации отвечают за развёртывание в окружениях более высокого уровня, например, в продакшен. Кроме того, в организациях, где потенциально могут быть тысячи проектов в одной группе, обеспечение подходящей конфигурации всех защищённых окружений на уровне проектов не является легко масштабируемым решением.
В этом релизе мы представляем защищённые окружения группового уровня, использующие в качестве идентификатора [типы окружений для развёртывания](https://docs.gitlab.com/ee/ci/environments/index.html#deployment-tier-of-environments). Это позволит операторам контролировать развёртывание на более высоких уровнях окружений, не мешая разработчикам выполнять работу мейнтейнеров (в русской локализации GitLab «сопровождающий») в их индивидуальных проектах.
[Документация по групповым защищённым окружениям](https://docs.gitlab.com/ee/ci/environments/protected_environments.html#group-level-protected-environments) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/215888).
### SAST нового поколения для снижения количества ложных срабатываний в Ruby
(SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Исторически в основе SAST (Static Application Security Testing, статическое тестирование безопасности приложений) в GitLab лежали [более десятка различных статических анализаторов безопасности с открытым исходным кодом](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks). Каждый месяц наши анализаторы выявляли миллионы уязвимостей для разработчиков, использующих GitLab. Эти инструменты используют множество различных подходов для выявления уязвимостей — от базового сопоставления паттернов regex до парсинга абстрактного синтаксического дерева, что может привести к проблемам с ложными срабатываниями. Инструменты GitLab Secure уже предлагают идентификацию отпечатков (fingerprints) уязвимостей, позволяя вам отсеивать эти ложные срабатывания. Однако мы хотим продвинуться ещё на шаг дальше и отказаться от этой ручной сортировки.
Сегодня мы выпускаем первую версию нашего собственного движка для статического тестирования безопасности приложений, разработанного нашими собственными силами и поддерживаемого командами GitLab по статическому анализу и исследованию уязвимостей. Первоначально этот инструмент ориентирован на Ruby и Rails, чтобы помочь уменьшить количество ложных срабатываний. Механизм GitLab SAST нового поколения использует знания, полученные нами за годы работы и поддержки инструментов безопасности с открытым исходным кодом, на которых основан GitLab SAST, и применяет самые современные методы анализа программ.
Этот новый механизм использует представления программ, включающие анализ потоков данных и управления, а также новый язык извлечения паттернов, который можно использовать как для обнаружения уязвимостей, так и для устранения уязвимостей, которые могли быть ошибочно обнаружены другими интегрированными инструментами безопасности. Этот механизм также обеспечивает базу для интеграции различных видов тестирования безопасности, предлагаемых в GitLab Ultimate, чтобы сделать их всё более интеллектуальными.
Будучи поставщиком услуг по управлению исходным кодом, CI/CD и сканированиям безопасности, GitLab обладает уникальными возможностями для глубокой интеграции тестирования безопасности в жизненный цикл разработки программного обеспечения (SDLC), благодаря чему вы получаете быстрые, точные и масштабируемые результаты в области безопасности. Мы надеемся на успех этого нового проприетарного движка и рассчитываем расширить его доступность, покрытие языков и возможности обнаружения в будущих релизах.
[Документация по обнаружению ложных срабатываний](https://docs.gitlab.com/ee/user/application_security/sast/#false-positive-detection) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/338292).
### Использование ключевых слов include и rules вместе в конфигурациях CI/CD
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
[`include`](https://docs.gitlab.com/ee/ci/yaml/index.html#include) — одно из самых популярных ключевых слов, используемых при написании полных CI/CD-конвейеров. Если вы создаёте масштабные конвейеры, вы, вероятно, используете ключевое слово `include` для включения внешней YAML-конфигурации в ваш конвейер.
В этом релизе мы расширяем возможности этого ключевого слова, чтобы вы могли использовать `include` с условиями [`rules`](https://docs.gitlab.com/ee/ci/yaml/index.html#include). Теперь вы можете решать, когда внешняя CI/CD-конфигурация должна или не должна быть добавлена в конвейер. Благодаря этому вы сможете написать стандартизированный конвейер, способный динамически меняться на основе выбранных вами условий.
[Документация по ключевым словам include и rules](https://docs.gitlab.com/ee/ci/yaml/index.html#rules-with-include) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/276515).
### Использование переменных в других переменных
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Сценарии выполнения конвейера CI/CD могут зависеть от содержания переменных, объявленных в конвейере, или от использования предопределённых переменных GitLab внутри вашего объявления переменных. В релизе 14.3 мы включаем фичу «переменные внутри других переменных» на GitLab SaaS. Теперь вы можете определить переменную и использовать её в других определениях переменных в рамках того же конвейера. Вы также можете использовать предопределённые переменные GitLab внутри других объявлений переменных. Это упрощает создание конвейера и помогает избежать в управлении конвейерами проблем, вызванных дублированием переменных. Обратите внимание, что для пользовательских инстансов GitLab эта фича по умолчанию отключена. Чтобы включить её, администратору GitLab необходимо включить соответствующую [переключаемую фичу](https://docs.gitlab.com/ee/ci/variables/where_variables_can_be_used.html#nested-variable-expansion).
[Документация по использованию переменных внутри других переменных](https://docs.gitlab.com/ee/ci/variables/#use-variables-in-other-variables) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-runner/-/issues/1809).
Другие улучшения в релизе GitLab 14.3
-------------------------------------
### События аудита для изменений в настройках защищённых веток
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
GitLab теперь записывает новые события аудита при внесении изменений в защищённые ветки. В частности, теперь события создаются при внесении изменений в следующие настройки:
* Кому разрешён пуш в ветку
* Кому разрешён мерж в ветку
* Требуется ли подтверждение от владельца кода
* Разрешён ли force push
Это позволит вам получить более полное представление о том, что происходит в GitLab, и убедиться, что необходимые настройки были установлены верно и не были изменены. Также это может помочь вам успешно пройти аудит, требующий разграничения обязанностей. Если эти настройки были изменены, события аудита помогут вам узнать, когда и кто внёс изменения, и подробнее разобраться в причинах.
Спасибо [Adrien Gooris](https://gitlab.com/adrien.gooris) из [Michelin](https://www.michelin.com/en/) за эту фичу!
[Документация по событиям аудита](https://docs.gitlab.com/ee/administration/audit_events.html#project-events) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/336211).
### События аудита для изменений параметров подтверждения мерж-реквеста
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Теперь, если в проекте изменились [параметры подтверждения мерж-реквестов](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/settings.html), также создаются события аудита. Вы сможете увидеть, внесены ли изменения в следующие правила:
* Требование пароля пользователя для подтверждений.
* Разрешение изменять подтверждения мерж-реквеста.
* Необходимость получать новые подтверждения при добавлении коммита в мерж-реквест.
Теперь вы можете быть уверены, что после настройки параметров подтверждения вы сможете быстро узнать об изменениях в них. Это отличный способ показать аудиторам, что нужные средства контроля на месте, не были удалены или изменены.
Спасибо [Adrien Gooris](https://gitlab.com/adrien.gooris) из [Michelin](https://www.michelin.com/en/) за эту фичу!
[Документация по событиям аудита](https://docs.gitlab.com/ee/administration/audit_events.html#project-events) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/336211).
### Фильтрация в аналитике цикла разработки на уровне проекта
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Использование аналитики цикла разработки (Value Stream Analytics) стало значительно удобнее. Теперь вы можете фильтровать элементы на стадии по майлстоуну (в русской локализации GitLab «этап»), метке, автору или назначенному исполнителю, и узнать время выполнения стадии для наиболее интересующих вас тикетов (в русской локализации GitLab «обсуждения») и мерж-реквестов (в русской локализации GitLab «запросы на слияние»).
[Документация по аналитике цикла разработки](https://docs.gitlab.com/ee/user/analytics/value_stream_analytics.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/326701).
### Токены доступа OAuth по умолчанию выдаются со сроком действия
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
По умолчанию все токены доступа OAuth, выпущенные после выхода релиза GitLab 14.3, будут иметь 2-часовой срок действия. Ранее срок действия токенов доступа OAuth не устанавливался, из-за чего их использование было не очень безопасным. Вы можете отключить эту опцию, сняв флажок **Expire Access Token** в пользовательском интерфейсе приложения OAuth.
[Документация по использованию OAuth в GitLab](https://docs.gitlab.com/ee/integration/oauth_provider.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/21745).
### Фильтрация дорожных карт по выбранным датам
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Когда вы просматриваете прогресс вашей команды за большой промежуток времени, горизонтальное представление дорожной карты (в русской локализации GitLab «план развития») приводит к огромной горизонтальной прокрутке.
Теперь вы можете уменьшить время этой бесконечной прокрутки, используя выбор заданного диапазона дат в верхней левой части строки поиска дорожной карты. Вы можете выбрать нужные вам даты, и дорожная карта увеличит масштаб до интересующей вас области.
[Документация по просмотру дорожной карты по заданным интервалам времени](https://docs.gitlab.com/ee/user/group/roadmap/#date-range-presets) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/204994).
### Фильтрация конвейеров по источнику
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Список конвейеров проекта в **CI/CD > Сборочные линии** (**CI/CD > Pipelines**) отображает все конвейеры проекта, но ранее вы не могли отфильтровать этот список по **источнику конвейера**. С релизом GitLab 14.3 вы можете фильтровать список конвейеров по их источникам, например `api`, `schedule`, `merge_request_event`.
[Документация по списку конвейеров](https://docs.gitlab.com/ee/ci/pipelines/#view-pipelines) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/233495).
### Обработчик заданий GitLab для IBM POWER9 (Linux OS)
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Если вы используете системы IBM POWER9 (вычислительная архитектура `ppc64le`) для интенсивных вычислительных нагрузок, вам ранее не были доступны обработчики заданий GitLab (GitLab Runner). Вам приходилось полагаться на собственный обработчик заданий или же на обработчик, поддерживаемый IBM. Хотя это и позволяло вам запускать задания GitLab CI/CD на POWER9, такая схема была далека от идеала, так как не была частью жизненного цикла релиза и поддержки обработчика заданий GitLab. Теперь для выполнения заданий GitLab CI/CD на IBM POWER9 (Linux OS) вы можете установить и использовать обработчик заданий, созданный и поддерживаемый GitLab.
[Документация по установке обработчика заданий GitLab на Linux](https://docs.gitlab.com/runner/install/linux-manually.html#install-1) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-runner/-/issues/2941).
### Новый API для прокси зависимостей
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Чтобы сократить время сборки, избежать ограничений скорости Docker Hub и уменьшить количество внешних зависимостей, вы можете использовать прокси зависимостей от GitLab (Dependency Proxy) для проксирования и кэширования образов контейнеров из Docker Hub.
Раньше у вас не было возможности узнать, как используется прокси зависимостей. Возможно, вы хотели бы узнать, сколько образов контейнеров было добавлено в кэш для вашей группы в GitLab, или просмотреть подробности об элементах, уже находящихся в кэше.
Теперь вы можете использовать GitLab GraphQL API, чтобы быстро выяснить эти важные детали. Используйте этот API для получения подробной информации об образах и их базовых компонентах, и точно знайте, какие образы контейнеров и теги используются в вашей группе.
Далее мы будем использовать этот API для значительного обновления пользовательского интерфейса. В [тикете 250865](https://gitlab.com/gitlab-org/gitlab/-/issues/250865) идёт работа над добавлением полезных метаданных для быстрого поиска.
[Документация по использованию GraphQL API для прокси зависимостей](https://docs.gitlab.com/ee/api/graphql/reference/#dependencyproxyblob) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/322839).
### Проверка лицензий теперь поддерживает Java 15
(SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Проверка лицензий (License Compliance) теперь поддерживает проекты Java 15. Установите для переменной `LM_JAVA_VERSION` значение `15`, чтобы использовать эту версию Java в вашем проекте.
[Документация по License Compliance и выбору версии Java](https://docs.gitlab.com/ee/user/compliance/license_compliance/#selecting-the-version-of-java) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/293899).
### GitLab Pages поддерживают подстановочные знаки и перенаправления с плейсхолдеров
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
Страницы GitLab (GitLab Pages) поддерживают множество правил перенаправления, включая [редиректы](https://docs.gitlab.com/ee/user/project/pages/redirects.html#redirects) и [правила переписывания URL](https://docs.gitlab.com/ee/user/project/pages/redirects.html#rewrites). В этом релизе теперь вы также можете использовать подстановочные знаки (splat, wildcard) и плейсхолдеры для перенаправления.
[Документация по редиректам](https://docs.gitlab.com/ee/user/project/pages/redirects.html#splats) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-pages/-/issues/500).
### Поддержка Kubernetes 1.20
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Configure](https://about.gitlab.com/stages-devops-lifecycle/configure/)
В GitLab 14.3 мы добавили поддержку Kubernetes версии 1.20. Пользователи GitLab могут воспользоваться преимуществами последних кластерных версий во многих фичах, таких как [агент для Kubernetes](https://docs.gitlab.com/ee/user/clusters/agent/) [Auto DevOps](https://docs.gitlab.com/ee/topics/autodevops/) и [Проект управления кластером](https://docs.gitlab.com/ee/user/clusters/management_project.html).
Вы можете найти список [поддерживаемых версий и связанных с ними сроков в нашей документации](https://docs.gitlab.com/ee/user/project/clusters/#supported-cluster-versions).
[Документация по поддержке кластерных версий](https://docs.gitlab.com/ee/user/project/clusters/#supported-cluster-versions) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/6509).
### Geo реплицирует развёртывание страниц
(self-managed: PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement)
С помощью [GitLab Pages](https://docs.gitlab.com/ee/user/project/pages/) вы можете публиковать статические веб-сайты непосредственно из репозитория в GitLab. В сценарии аварийного восстановления уже можно было повторно создавать сайты страниц после переключения на новый первичный сайт.
Теперь Geo также копирует развёртывания страниц. Это обеспечивает дополнительную защиту от потери данных и сокращает время восстановления, устраняя необходимость в повторном создании страниц после отработки отказа.
[Документация по репликации Geo](https://docs.gitlab.com/ee/administration/geo/replication/datatypes.html#data-types), оригинальные [тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/331931) и [эпик](https://gitlab.com/groups/gitlab-org/-/epics/589).
### Ключ GPG отображается на странице профиля пользователя
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
В предыдущих версиях GitLab не было простого способа просмотреть ключ GPG пользователя. Мы добавили на страницы профиля кнопку, которая позволяет вам одним щелчком мыши увидеть GPG-ключ пользователя.
[Документация по настройке GPG-подписи для коммитов](https://docs.gitlab.com/ee/user/project/repository/gpg_signed_commits/#adding-a-gpg-key-to-your-account) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/333242).
### API-метрика частоты развёртывания теперь в Premium
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Это изменение позволяет использовать API-метрику DORA, частоту развёртывания, в аналитике цикла разработки на уровне группы для пользователей плана Premium. Эта метрика поможет вам понять, как часто вы поставляете продукт своим пользователям. Кроме того, более высокая частота развёртывания означает, что вы можете быстрее получать обратную связь и начать что-то делать для улучшения старых или выпуска новых фич.
[Документация по метрикам аналитики цикла разработки](https://docs.gitlab.com/ee/user/group/value_stream_analytics/#how-metrics-are-measured) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/337256).
### Предварительный просмотр мультимедиа-контента в новом редакторе вики
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Включение мультимедиа в вики-страницу — отличный способ эффективно и результативно показывать сложный контент. GitLab Flavored Markdown поддерживает встраивание и воспроизведение [видео- и аудиоконтента](https://docs.gitlab.com/ee/user/markdown.html#videos). Однако во время редактирования страницы такие файлы представляются в коде только в виде пути к файлу, что может привести к путанице или неопределённости в отношении того, нужная ли это версия файла.
В GitLab 14.3 WYSIWYG редактор Markdown отображает и воспроизводит добавленный ранее видео- и аудиоконтент прямо на вики-странице. Теперь вы можете не выходя из редактора проверить, что прикреплённый вами файл "recording\_final.mp3" или "walkthrough.mp4" действительно тот, что нужно. Пока это работает только с медиафайлами, уже добавленными в страницу на момент открытия страницы в редакторе. В одном из ближайших майлстоунов мы добавим поддержку и для [вставки нового видео- и аудиоконтента](https://gitlab.com/gitlab-org/gitlab/-/issues/332088) в редакторе.
Спасибо [Lee Tickett](https://gitlab.com/leetickett) за эту полезную фичу!
[Документация по GitLab Flavored Markdown](https://docs.gitlab.com/ee/user/project/wiki/#gitlab-flavored-markdown-support) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/332074).
### Поддержка мержа массивов правил CI/CD с помощью !reference
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Тег YAML [`!reference`](https://docs.gitlab.com/ee/ci/yaml/index.html#reference-tags), добавленный ранее в этом году, помогает повторно использовать и комбинировать настройки в конфигурации YAML. Этот способ позволяет объединить часто используемую конфигурацию с конфигурацией для конкретного задания, чтобы использовать их в одном или нескольких заданиях. Однако ранее этот способ нельзя было использовать с ключевым словом [`rules`](https://docs.gitlab.com/ee/ci/yaml/index.html#rules). В 14.3 мы добавили поддержку `!reference` для ключевого слова `rules`, так что теперь вам будет легче смешивать и сопоставлять `rules`, в том числе с конфигурациями из разных файлов. Вы можете использовать редактор конвейера CI/CD для [просмотра объединённой конфигурации](https://docs.gitlab.com/ee/ci/pipeline_editor/#view-expanded-configuration).
[Документация по повторному использованию правил в разных заданиях](https://docs.gitlab.com/ee/ci/jobs/job_control.html#reuse-rules-in-different-jobs) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/322992).
### Поиск PyPI.org для пакетов, не найденных в GitLab
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Вы можете использовать реестр пакетов GitLab в качестве приватного индекса PyPI вместе с вашим исходным кодом и конвейерами. Обычно команды полагаются на комбинацию приватных и публичных индексов. PyPI поддерживает это, предлагая аргументы `-index` и `extra-index-url`, которые позволяют указать несколько индексов для загрузки. При установке пакета `pip` загружает наилучшее соответствие, которое он может найти, среди всех доступных индексов, но не в порядке приоритета индексов. Например, последняя версия пакета будет выбрана независимо от каких-либо приоритетов между индексами, просто потому, что это последняя версия. Это создаёт проблемы с безопасностью для некоторых организаций, поскольку может сделать вас уязвимыми для атак, связанных с подменой зависимостей. Например, разработчик может установить пакет, думая, что он был получен из приватного проекта GitLab, а на самом деле он загружается из общедоступного репозитория.
Теперь, при попытке [установить пакет PyPI](https://docs.gitlab.com/ee/user/packages/pypi_repository/#install-a-pypi-package) из вашего проекта GitLab, если пакет не найден, запрос направляется на [PyPI.org](https://pypi.org/). Другими словами, если имя пакета существует в вашем частном реестре, оно исключается из поиска в общедоступном репозитории. Это делается для того, чтобы злоумышленник не мог внедрить код, загрузив пакет в PyPI с тем же именем и более новой версией.
Эта новая фича автоматически включена для GitLab.com, пользователи самостоятельно управляемых инстансов могут её отключить в [настройках администрирования CI/CD](https://docs.gitlab.com/ee/user/admin_area/settings/continuous_integration.html). В настоящее время эта фича доступна только для клиентов уровня Premium, но работа по перемещению её в план `Core` уже ведётся в [тикете #337862](https://gitlab.com/gitlab-org/gitlab/-/issues/337862).
[Документация по настройкам PyPI для CI](https://docs.gitlab.com/ee/user/admin_area/settings/continuous_integration.html#pypi-forwarding) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/233413).
### Обновления анализаторов SAST
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Статическое тестирование безопасности приложений (SAST) в GitLab включает в себя [множество анализаторов безопасности](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks), активно управляемых, поддерживаемых и обновляемых командой статического анализа GitLab. Ниже представлены обновления анализаторов, выпущенные в релизе 14.3. В этих обновлениях появилось расширенное покрытие и другие улучшения, а также были исправлены ошибки.
* Brakeman обновили до версии 5.1.1: [мерж-реквест](https://gitlab.com/gitlab-org/security-products/analyzers/brakeman/-/merge_requests/85), [список изменений](https://gitlab.com/gitlab-org/security-products/analyzers/brakeman/-/merge_requests/85/diffs#diff-content-ab09011fa121d0a2bb9fa4ca76094f2482b902b7). Улучшили производительность.
* Eslint обновили до версии 7.30.0: [мерж-реквест](https://gitlab.com/gitlab-org/security-products/analyzers/eslint/-/merge_requests/90), [список изменений](https://gitlab.com/gitlab-org/security-products/analyzers/eslint/-/merge_requests/90/diffs#diff-content-ab09011fa121d0a2bb9fa4ca76094f2482b902b7).
* PMD Apex обновили до версии 3.38.0: [мерж-реквест](https://gitlab.com/gitlab-org/security-products/analyzers/pmd-apex/-/merge_requests/68), [список изменений](https://gitlab.com/gitlab-org/security-products/analyzers/pmd-apex/-/blob/1dee0e49fbe4f417b7d4122186608741534c2cdd/CHANGELOG.md).
* Spotbugs обновили до версии 2.28.6: [мерж-реквест](https://gitlab.com/gitlab-org/security-products/analyzers/spotbugs/-/merge_requests/112), [список изменений](https://gitlab.com/gitlab-org/security-products/analyzers/spotbugs/-/tags/v2.28.6).
* Semgrep обновили до версии 0.65.0: [мерж-реквест](https://gitlab.com/gitlab-org/security-products/analyzers/semgrep/-/merge_requests/79), [список изменений](https://gitlab.com/gitlab-org/security-products/analyzers/semgrep/-/merge_requests/79/diffs#diff-content-ab09011fa121d0a2bb9fa4ca76094f2482b902b7). Повысили производительность, добавили игнорирование минифицированных файлов, улучшили сообщения об ошибках.
Если вы [используете поставляемый GitLab шаблон SAST](https://docs.gitlab.com/ee/user/application_security/sast/#configure-sast-manually) ([SAST.gitlab-ci.yml](https://gitlab.com/gitlab-org/gitlab/blob/master/lib/gitlab/ci/templates/Security/SAST.gitlab-ci.yml)), то вам не нужно ничего делать, чтобы получить эти обновления. Однако если вы переопределяете его или используете свой собственный шаблон CI, вам потребуется обновить конфигурации CI.
Если вы хотите использовать определённую версию любого анализатора, теперь вы можете [закрепить минорную версию анализатора](https://docs.gitlab.com/ee/user/application_security/sast/#pinning-to-minor-image-version). Закрепление одной из предыдущих версий отменит автоматические обновления анализатора, и вам потребуется вручную менять версию анализатора в шаблоне CI.
[Документация по настройке анализаторов SAST](https://docs.gitlab.com/ee/user/application_security/sast/analyzers) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/338292).
### Период приостановки развёртывания теперь можно удалить через пользовательский интерфейс
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
Чтобы предотвратить непреднамеренное развёртывание заданий CI/CD, вы можете установить периоды приостановки развёртывания. До недавнего времени удалить период приостановки развёртывания можно было только через API. В релизе 14.3 это стало удобнее: удалить период приостановки развёртывания теперь можно непосредственно из интерфейса GitLab. Эта фича — вклад от сообщества GitLab. Спасибо [@jayaddison](https://gitlab.com/jayaddison) за добавление этой полезной фичи!
[Документация по приостановке развёртывания](https://docs.gitlab.com/ee/user/project/releases/index.html#prevent-unintentional-releases-by-setting-a-deploy-freeze) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/212451).
### Конечная точка API для получения дежурного пользователя
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Monitor](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Определение того, кто сейчас дежурный по проекту, должно быть быстрым и лёгким, особенно если произошёл какой-либо инцидент. В этом релизе добавлен вызов API, который возвращает дежурных пользователей для каждого правила эскалации в проекте. Реагирующие на инциденты могут использовать предпочитаемый способ, пользовательский интерфейс GitLab или API, чтобы узнать, к кому им нужно обращаться.
[Документация по инцидентам и дежурным пользователям](https://docs.gitlab.com/ee/api/graphql/reference/#incidentmanagementoncallschedule) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/251140).
### Версия 1.2 GitLab Environment Toolkit
(self-managed: PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement)
[Инструментарий окружения GitLab (GitLab Environment Toolkit, GET)](https://gitlab.com/gitlab-org/quality/gitlab-environment-toolkit) нужен для развёртывания и эксплуатации продакшен-инстансов GitLab на основе наших [эталонных архитектур](https://docs.gitlab.com/ee/administration/reference_architectures). Теперь он обновился до версии 1.2.
Основные моменты версии 1.2 включают поддержку AWS RDS, Elasticache, Geo в облачных нативных гибридных развёртываниях, а также все настройки в Omnibus и Helm. Чтобы узнать больше о GET, полном списке всех изменений, а также о предстоящих критических изменениях, [прочитайте release notes](https://gitlab.com/gitlab-org/quality/gitlab-environment-toolkit/-/releases/v1.2.0#further-updates-and-improvements).
[Документация по GitLab Environment Toolkit](https://gitlab.com/gitlab-org/quality/gitlab-environment-toolkit/-/releases/v1.2.0) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/6017).
---
Полный текст релиза и инструкции по обновлению/установке вы можете найти в оригинальном англоязычном посте [GitLab 14.3 releases Project Security Policies & Next Gen SAST](https://about.gitlab.com/releases/2021/09/22/gitlab-14-3-released/).
Над переводом с английского работали [cattidourden](https://habr.com/ru/users/cattidourden/), [ainoneko](https://habr.com/ru/users/ainoneko/) и [rishavant](https://habr.com/ru/users/rishavant/).
|
https://habr.com/ru/post/584112/
| null |
ru
| null |
# Windows 8. Контракт «поиск» в деталях
Поиск внутри приложений одна из новых, наиболее важных и интересных функций Windows 8. Поиск предоставляет возможность искать не только файлы и документы на устройстве, но также позволяет искать внутри установленных приложений.
В этой статье рассматривается:
1. Интеграция поиска в метро приложение
2. Контекстные подсказки (suggestions).
3. Обработка запроса по мере ввода данных.
4. Неосторожное использование контракта поиска (обычные ошибки интеграции).
**1. Интеграция поиска в метро приложение**
По умолчанию приложения не поддерживают контракт поиска. В этой статье рассмотрим, как можно добавить поиск внутри приложения.
Самым простым способом добавления поддержки контракта поиска является использование готового шаблона в студии:
В VS2012 есть встроенный шаблон SearchContract который добавляет соответствующую запись в манифест (если этого не было сделано), добавляет запись в app.xaml.cs(переопределение метода OnSearchActivated если этого еще не было сделано), и добавляет страницу принимающий поисковой запрос с минимальной логикой обработки.
Мы не будем детально рассматривать использования этого шаблона и пошагово рассмотрим добавление поддержки контракта поиска:
В первую очередь в манифесте приложения (файл Package.appxmanifest) нам необходимо указать, что наше приложение поддерживает контракт поиска. Для этого открыв этот манифест в студии, во вкладке “declarations” добавляем контракт поиска.
Далее в классе приложения “app.xaml.cs” мы можем переопределить алгоритм активации приложения через контракт поиска и указать нужную нам логику. Для простоты сделаем, что бы у нас всегда открывалась отдельная страница (SearchPage.xaml) при активации по контракту поиска.
```
protected override void OnSearchActivated(SearchActivatedEventArgs args)
{
var frame = Window.Current.Content as Frame;
if(frame==null)
{
frame=new Frame();
Window.Current.Content = frame;
}
frame.Navigate(typeof(SearchPage), args.QueryText);
Window.Current.Activate();
}
```
В этом методе мы перенаправляем пользователя на страницу SearchPage где в качестве параметра указан поисковой запрос.
Надо учитывать, что если приложение не было запущено, приложение запускается через метод OnSearchActivated. В связи с этим текущий фрейм может быть еще не создан. Проверка на null осуществляется для инициализации фрейма при первом запуске приложения.
На странице SearchPage теперь мы можем отобразить результаты поиска, получив поисковой запрос из переданного параметра:
```
protected override void OnNavigatedTo(NavigationEventArgs e)
{
var query = (string)e.Parameter;
SearchByQuery(query);
}
private void SearchByQuery(string queryText)
{
pageTitle.Text = "Search result for \"" + queryText + "\":";
//Логика обработки поискового запроса
}
```
**2. Контекстные подсказки (suggestions).**
API контракта поиска позволяет нам добавлять контекстные подсказки при наборе поисковой фразы.
Контекстные подсказки приложения могут работать только тогда, когда пользователь выберет (активирует) приложение для поиска.
*2. 1. Текстовые подсказки*
Добавить поддержку довольно просто, в конструкторе страницы мы можем подписаться на событие запроса контекстных подсказок.
```
public SearchPage()
{
this.InitializeComponent();
SearchPane.GetForCurrentView().SuggestionsRequested += SearchPage_SuggestionsRequested;
}
```
Далее в методе SearchPage\_SuggestionsRequested мы можем добавить необходимые контекстные подсказки:
```
void SearchPage_SuggestionsRequested(SearchPane sender, SearchPaneSuggestionsRequestedEventArgs args)
{
var products=new[] { "apple", "cheese", "bread", "onion", "orange", "potato"}
args.Request.SearchSuggestionCollection.AppendQuerySuggestions(products);
}
```
Теперь, если мы в конструкторе подпишемся на событие выбор запроса:
SearchPane.GetForCurrentView().QueryChanged += SearchPage\_QueryChanged;
Мы сможем обрабатывать выбор пользователя из подсказок.
```
void SearchPage_QueryChanged(SearchPane sender, SearchPaneQueryChangedEventArgs args)
{
SearchByQuery(args.QueryText);
}
```
*2.2. Сложные подсказки*
API SearchContract позволяет нам реализовать более сложные виды контекстных подсказок:
Предположим у нас есть некий слой логики (LogicLayer) который возвращает нам продукт с полями:
```
public class Product
{
public string Name { get; set; }
public string Image { get; set; }
public string Description { get; set; }
public string Id { get; set; }
}
```
Теперь в методе SearchPage\_SuggestionsRequested мы должны использовать метод args.Request.SearchSuggestionCollection.AppendResultSuggestion для добавления более сложных подсказок.
```
void SearchPage_SuggestionsRequested(SearchPane sender, SearchPaneSuggestionsRequestedEventArgs args)
{
foreach (var product in LogicLayer.SearchProduct(args.QueryText))
{
var image = RandomAccessStreamReference.CreateFromUri(newUri(product.Image));
args.Request.SearchSuggestionCollection.AppendResultSuggestion(product.Name, product.Description, product.Id, image, String.Empty);
}
}
```
Здесь мы в качестве тегов передаем Id продукта. При выборе пользователем сложных подсказок не срабатывает событие QueryChanged. Для обработки сложных подсказок есть специальное
событие ResultSuggestionChosen.
Мы можем добавить в конструктор обработку этого события.
SearchPane.GetForCurrentView().ResultSuggestionChosen += SearchPage\_ResultSuggestionChosen;
Теперь мы можем получить ссылку на идентификатор продукта и обработать его:
```
void SearchPage_ResultSuggestionChosen(SearchPane sender, SearchPaneResultSuggestionChosenEventArgs args)
{
var id = args.Tag;
SearchById(query);
}
```
*2.3. Контекстные подсказки на всех страницах.*
В небольших приложениях скорее всего будет проще сделать контекстные подсказки не отдельно для каждой страницы, а одну подсказку для всего приложения.
Мы можем подписаться на события поиска в экземпляре приложения. При этом, так как приложение может быть активировано несколько раз, мы должны быть уверены что подпишемся только один раз.
Добавим метод SubscribeToSearchEvents в App.xaml.cs
```
private bool isSubscribed;
public void SubscribeToSearchEvents()
{
if (!isSubscribed)
{
isSubscribed = true;
SearchPane.GetForCurrentView().SuggestionsRequested += SearchPage_SuggestionsRequested;
SearchPane.GetForCurrentView().ResultSuggestionChosen += SearchPage_ResultSuggestionChosen;
SearchPane.GetForCurrentView().QueryChanged += SearchPage_QueryChanged;
}
}
```
Теперь достаточно вызвать его в методах OnLaunched и OnSearchActivated
```
protected override void OnLaunched(LaunchActivatedEventArgs args)
{
SubscribeToSearchEvents();
...
}
```
```
protected override void OnSearchActivated(SearchActivatedEventArgs args)
{
SubscribeToSearchEvents();
}
```
**3. Обработка запроса по мере ввода данных.**
Если нам требуется реализовать еще более сложные сценарии подсказок, или если мы можем быстро обработать запрос и сразу показать результат поискового запроса до завершения ввода, мы можем подписаться на события изменения поискового запроса (QueryChanged).
Для этого можем добавить в конструктор следующий метод:
SearchPane.GetForCurrentView().QueryChanged += SearchPage\_QueryChanged;
Аналогично остальным событиям мы можем обработать поисковый запрос:
```
void SearchPage_QueryChanged(SearchPane sender, SearchPaneQueryChangedEventArgs args)
{
SearchByQuery(args.QueryText);
}
```
**4. Исправляем типичные ошибки интеграции поиска:**
Описанные здесь рекомендации относиться к версии Windows 8 RP и наверняка будут исправлены в релизе. Тем не менее сейчас есть несколько «симптом» присущих практически всем приложениям (включая встроенные системные приложения, такие как «Люди»).
*4.1. Потеря возможности попасть на главную страницу.*
*Если приложение не было до этого запущено, при первом запуске приложения по контракту поиска открывается страница поиска. Теперь если пользователь перейдет в главное меню и снова запустит приложение, он снова увидит страницу поиска и у него не будет возможности перейти в главное меню, так как кнопка «назад» появляется на странице поиска только в том случае если перед поиском приложение было запущено. Единственной возможностью попасть на главную страницу остается только закрытие приложения и повторный запуск.*
Исправить эту проблему достаточно просто. В методе активации приложения по поиску (OnSearchActivated) при инициализации фрейма мы также добавим лишний переход на главную страницу.
```
protected override void OnSearchActivated(SearchActivatedEventArgs args)
{
var frame = Window.Current.Content as Frame;
if(frame==null)
{
frame=new Frame();
Window.Current.Content = frame;
```
```
//Переход на главную страницу
frame.Navigate(typeof(MainPage));
}
frame.Navigate(typeof(SearchPage), args.QueryText);
Window.Current.Activate();
}
```
*4.2. Многочисленные экземпляры страницы поиска*
*Если ввести несколько поисковых фраз подряд, то каждый раз создается еще один экземпляр страницы, и попытка попасть на главную страницу по кнопке «назад» приводит к тому что мы попадаем на предыдущую страницу поиска. Возможно это не баг а фича, в таком случае надо учитывать что событие поиска срабатывает в каждом созданном экземпляре и обработка запросов от нескольких экземпляров может привести к серьезным проблемам с производительностью.*
Лично мое мнение это баг, так как довольно часто меня раздражала небходимость по несколько раз нажимать кнопку «назад» что бы снова вернуться на главную страницу.
Одно из решений довольно простое. При активации приложения по поиску проверять, является ли текущая страница страницей поиска и возвращаться назад в таком случае:
```
protected override void OnSearchActivated(SearchActivatedEventArgs args)
{
RemoveSearchPage();
var frame = Window.Current.Content as Frame;
if(frame==null)
{
frame=new Frame();
Window.Current.Content = frame;
frame.Navigate(typeof(MainPage));
}
frame.Navigate(typeof(SearchPage), args.QueryText);
Window.Current.Activate();
}
```
Соответственно реализация метода RemoveSearchPage:
```
private void RemoveSearchPage()
{
var frame = Window.Current.Content as Frame;
if (frame== null)
{
return;
}
var page=frame.Content as Page;
if (page == null)
{
return;
}
if (page.GetType()==typeof(SearchPage))
{
frame.GoBack();
}
}
```
[Исходный код (288,51 kb)](http://akhmed.ru/blogimages/contractsearch/CompleteDemoProductList.zip)
P.S. Спасибо хабраюзеру [Стасу Павлову](http://habrahabr.ru/users/stasus/) за ценные замечания при подготовке статьи.
|
https://habr.com/ru/post/146518/
| null |
ru
| null |
# Тестирование производительности аналитических запросов в PostgreSQL, ClickHouse и clickhousedb_fdw (PostgreSQL)
В этом исследовании я хотел посмотреть, какие улучшения производительности можно получить, используя источник данных ClickHouse, а не PostgreSQL. Я знаю, какие преимущества производительности при использовании ClickHouse я получаю. Будут ли эти преимущества сохранены, если я получу доступ к ClickHouse из PostgreSQL с помощью внешней оболочки данных (FDW)?
Исследуемыми средами баз данных являются PostgreSQL v11, clickhousedb\_fdw и база данных ClickHouse. В конечном счете, из PostgreSQL v11 мы будем запускать различные SQL-запросы, маршрутизируемые через наш clickhousedb\_fdw в базу данных ClickHouse. Затем мы увидим, как производительность FDW сравнивается с теми же запросами, выполняемыми в нативном PostgreSQL и нативном ClickHouse.
### База данных Clickhouse
ClickHouse — это система управления базами данных на основе колонок с открытым исходным кодом, которая может достигать производительности в 100-1000 раз быстрее, чем традиционные подходы к базам данных, способная обрабатывать более миллиарда строк менее чем за секунду.
### Clickhousedb\_fdw
clickhousedb\_fdw — оболочка внешних данных базы данных ClickHouse, или FDW, является проектом с открытым исходным кодом от Percona. [Вот ссылка на репозиторий проекта GitHub](https://github.com/Percona-Lab/clickhousedb_fdw).
[В марте я написал блог, который рассказывает вам больше о нашем FDW](https://www.percona.com/blog/2019/03/29/postgresql-access-clickhouse-one-of-the-fastest-column-dbmss-with-clickhousedb_fdw/).
Как вы увидите, это обеспечивает FDW для ClickHouse, который позволяет SELECT from, и INSERT INTO, базу данных ClickHouse с сервера PostgreSQL v11.
FDW поддерживает расширенные функции, такие как aggregate и join. Это значительно повышает производительность за счет использования ресурсов удаленного сервера для этих ресурсоемких операций.
### Benchmark environment
* Supermicro server:
+ Intel® Xeon® CPU E5-2683 v3 @ 2.00GHz
+ 2 sockets / 28 cores / 56 threads
+ Memory: 256GB of RAM
+ Storage: Samsung SM863 1.9TB Enterprise SSD
+ Filesystem: ext4/xfs
* OS: Linux smblade01 4.15.0-42-generic #45~16.04.1-Ubuntu
* PostgreSQL: version 11
### Benchmark tests
Вместо того, чтобы использовать какой-то набор данных, сгенерированный машиной, для этого теста, мы использовали данные «Производительность по времени, сообщаемая о времени работы оператора» с 1987 по 2018 год. Вы можете получить доступ к данным [с помощью нашего скрипта, доступного здесь](https://github.com/Percona-Lab/ontime-airline-performance/blob/master/download.sh).
Размер базы данных составляет 85 ГБ, обеспечивая одну таблицу из 109 столбцов.
#### Benchmark Queries
Вот запросы, которые я использовал для сравнения ClickHouse, clickhousedb\_fdw и PostgreSQL.
| **Q#** | **Query Contains Aggregates and Group By** |
| --- | --- |
| Q1 | SELECT DayOfWeek, count(\*) AS c FROM ontime WHERE Year >= 2000 AND Year <= 2008 GROUP BY DayOfWeek ORDER BY c DESC; |
| Q2 | SELECT DayOfWeek, count(\*) AS c FROM ontime WHERE DepDelay>10 AND Year >= 2000 AND Year <= 2008 GROUP BY DayOfWeek ORDER BY c DESC; |
| Q3 | SELECT Origin, count(\*) AS c FROM ontime WHERE DepDelay>10 AND Year >= 2000 AND Year <= 2008 GROUP BY Origin ORDER BY c DESC LIMIT 10; |
| Q4 | SELECT Carrier, count(*) FROM ontime WHERE DepDelay>10 AND Year = 2007 GROUP BY Carrier ORDER BY count(*) DESC; |
| Q5 | SELECT a.Carrier, c, c2, c*1000/c2 as c3 FROM ( SELECT Carrier, count(*) AS c FROM ontime WHERE DepDelay>10 AND Year=2007 GROUP BY Carrier ) a INNER JOIN ( SELECT Carrier,count(\*) AS c2 FROM ontime WHERE Year=2007 GROUP BY Carrier)b on a.Carrier=b.Carrier ORDER BY c3 DESC; |
| Q6 | SELECT a.Carrier, c, c2, c*1000/c2 as c3 FROM ( SELECT Carrier, count(*) AS c FROM ontime WHERE DepDelay>10 AND Year >= 2000 AND Year <= 2008 GROUP BY Carrier) a INNER JOIN ( SELECT Carrier, count(\*) AS c2 FROM ontime WHERE Year >= 2000 AND Year <= 2008 GROUP BY Carrier ) b on a.Carrier=b.Carrier ORDER BY c3 DESC; |
| Q7 | SELECT Carrier, avg(DepDelay) \* 1000 AS c3 FROM ontime WHERE Year >= 2000 AND Year <= 2008 GROUP BY Carrier; |
| Q8 | SELECT Year, avg(DepDelay) FROM ontime GROUP BY Year; |
| Q9 | select Year, count(\*) as c1 from ontime group by Year; |
| Q10 | SELECT avg(cnt) FROM (SELECT Year,Month,count(\*) AS cnt FROM ontime WHERE DepDel15=1 GROUP BY Year,Month) a; |
| Q11 | select avg(c1) from (select Year,Month,count(\*) as c1 from ontime group by Year,Month) a; |
| Q12 | SELECT OriginCityName, DestCityName, count(\*) AS c FROM ontime GROUP BY OriginCityName, DestCityName ORDER BY c DESC LIMIT 10; |
| Q13 | SELECT OriginCityName, count(\*) AS c FROM ontime GROUP BY OriginCityName ORDER BY c DESC LIMIT 10; |
| | **Query Contains Joins** |
| Q14 | SELECT a.Year, c1/c2 FROM ( select Year, count(*)*1000 as c1 from ontime WHERE DepDelay>10 GROUP BY Year) a INNER JOIN (select Year, count(\*) as c2 from ontime GROUP BY Year ) b on a.Year=b.Year ORDER BY a.Year; |
| Q15 | SELECT a.”Year”, c1/c2 FROM ( select “Year”, count(*)*1000 as c1 FROM fontime WHERE “DepDelay”>10 GROUP BY “Year”) a INNER JOIN (select “Year”, count(\*) as c2 FROM fontime GROUP BY “Year” ) b on a.”Year”=b.”Year”; |
*Table-1: Queries used in benchmark*
#### Query executions
Вот результаты каждого из запросов при выполнении в разных настройках базы данных: PostgreSQL с индексами и без них, собственный ClickHouse и clickhousedb\_fdw. Время показывается в миллисекундах.
| **Q#** | **PostgreSQL** | **PostgreSQL (Indexed)** | **ClickHouse** | **clickhousedb\_fdw** |
| --- | --- | --- | --- | --- |
| Q1 | 27920 | 19634 | 23 | 57 |
| Q2 | 35124 | 17301 | 50 | 80 |
| Q3 | 34046 | 15618 | 67 | 115 |
| Q4 | 31632 | 7667 | 25 | 37 |
| Q5 | 47220 | 8976 | 27 | 60 |
| Q6 | 58233 | 24368 | 55 | 153 |
| Q7 | 30566 | 13256 | 52 | 91 |
| Q8 | 38309 | 60511 | 112 | 179 |
| Q9 | 20674 | 37979 | 31 | 81 |
| Q10 | 34990 | 20102 | 56 | 148 |
| Q11 | 30489 | 51658 | 37 | 155 |
| Q12 | 39357 | 33742 | 186 | 1333 |
| Q13 | 29912 | 30709 | 101 | 384 |
| Q14 | 54126 | 39913 | 124 | 1364212 |
| Q15 | 97258 | 30211 | 245 | 259 |
*Table-1: Time taken to execute the queries used in benchmark*
Просмотр результатов
График показывает время выполнения запроса в миллисекундах, ось X показывает номер запроса из таблиц выше, а ось Y показывает время выполнения в миллисекундах. Результаты ClickHouse и данные, полученные из postgres с помощью clickhousedb\_fdw, показаны. Из таблицы видно, что существует огромная разница между PostgreSQL и ClickHouse, но минимальная разница между ClickHouse и clickhousedb\_fdw.
Этот график показывает разницу между ClickhouseDB и clickhousedb\_fdw. В большинстве запросов накладные расходы FDW не так велики и едва ли значительны, кроме Q12. Этот запрос включает в себя объединения и предложение ORDER BY. Из-за предложения ORDER BY GROUP/BY и ORDER BY не опускаются до ClickHouse.
В таблице 2 мы видим скачок времени в запросах Q12 и Q13. Повторюсь, это вызвано предложением ORDER BY. Чтобы подтвердить это, я выполнил запросы Q-14 и Q-15 с предложением ORDER BY и без него. Без предложения ORDER BY время завершения составляет 259 мс, а с предложением ORDER BY — 1364212. Для отладки этого запроса я объясняю оба запроса, а здесь приведены результаты объяснения.
Q15: Without ORDER BY Clause
```
bm=# EXPLAIN VERBOSE SELECT a."Year", c1/c2
FROM (SELECT "Year", count(*)*1000 AS c1 FROM fontime WHERE "DepDelay" > 10 GROUP BY "Year") a
INNER JOIN(SELECT "Year", count(*) AS c2 FROM fontime GROUP BY "Year") b ON a."Year"=b."Year";
```
Q15: Query Without ORDER BY Clause
```
QUERY PLAN
Hash Join (cost=2250.00..128516.06 rows=50000000 width=12)
Output: fontime."Year", (((count(*) * 1000)) / b.c2)
Inner Unique: true Hash Cond: (fontime."Year" = b."Year")
-> Foreign Scan (cost=1.00..-1.00 rows=100000 width=12)
Output: fontime."Year", ((count(*) * 1000))
Relations: Aggregate on (fontime)
Remote SQL: SELECT "Year", (count(*) * 1000) FROM "default".ontime WHERE (("DepDelay" > 10)) GROUP BY "Year"
-> Hash (cost=999.00..999.00 rows=100000 width=12)
Output: b.c2, b."Year"
-> Subquery Scan on b (cost=1.00..999.00 rows=100000 width=12)
Output: b.c2, b."Year"
-> Foreign Scan (cost=1.00..-1.00 rows=100000 width=12)
Output: fontime_1."Year", (count(*))
Relations: Aggregate on (fontime)
Remote SQL: SELECT "Year", count(*) FROM "default".ontime GROUP BY "Year"(16 rows)
```
Q14: Query With ORDER BY Clause
```
bm=# EXPLAIN VERBOSE SELECT a."Year", c1/c2 FROM(SELECT "Year", count(*)*1000 AS c1 FROM fontime WHERE "DepDelay" > 10 GROUP BY "Year") a
INNER JOIN(SELECT "Year", count(*) as c2 FROM fontime GROUP BY "Year") b ON a."Year"= b."Year"
ORDER BY a."Year";
```
Q14: Query Plan with ORDER BY Clause
```
QUERY PLAN
Merge Join (cost=2.00..628498.02 rows=50000000 width=12)
Output: fontime."Year", (((count(*) * 1000)) / (count(*)))
Inner Unique: true Merge Cond: (fontime."Year" = fontime_1."Year")
-> GroupAggregate (cost=1.00..499.01 rows=1 width=12)
Output: fontime."Year", (count(*) * 1000)
Group Key: fontime."Year"
-> Foreign Scan on public.fontime (cost=1.00..-1.00 rows=100000 width=4)
Remote SQL: SELECT "Year" FROM "default".ontime WHERE (("DepDelay" > 10))
ORDER BY "Year" ASC
-> GroupAggregate (cost=1.00..499.01 rows=1 width=12)
Output: fontime_1."Year", count(*) Group Key: fontime_1."Year"
-> Foreign Scan on public.fontime fontime_1 (cost=1.00..-1.00 rows=100000 width=4)
Remote SQL: SELECT "Year" FROM "default".ontime ORDER BY "Year" ASC(16 rows)
```
Вывод
Результаты этих экспериментов показывают, что ClickHouse предлагает действительно хорошую производительность, а clickhousedb\_fdw предлагает преимущества производительности ClickHouse из PostgreSQL. Хотя при использовании clickhousedb\_fdw есть некоторые накладные расходы, они незначительны и сопоставимы с производительностью, достигнутой при естественном запуске в базе данных ClickHouse. Это также подтверждает, что fdw в PostgreSQL обеспечивает замечательные результаты.
Телеграм чат по Clickhouse <https://t.me/clickhouse_ru>
Телеграм чат по PostgreSQL <https://t.me/pgsql>
|
https://habr.com/ru/post/511992/
| null |
ru
| null |
# Интеграция сценарного тестирования в процесс разработки решений на базе платформы 1С
Эта статья является практическим пособием по внедрению тестирования на основе сценариев в процесс разработки программного обеспечения на базе платформы 1С: Предприятие 8.3. Документ отличает прикладная направленность, в нем содержится много кода, подходов и конкретики. Все рассмотренные примеры основаны на использовании бесплатной конфигурации Тестер.
* [Вступление](#Intro)
* [О конфигурации Тестер](#About)
* [Базовые определения](#BaseDefinitions)
* [Концепция](#Concept)
* [Быстрый старт](#QuickStart)
* [Интерфейс](#Interface)
+ [Дерево сценариев](#ScenariosTree)
+ [Вкладка Поля](#FieldsPage)
* [Перед внедрением](#Implementation)
* [Установка](#Install)
* [Базы данных](#Databases)
* [Создание и обновление начальной базы](#InitialDB)
* [Эталонная база](#MasterDatabase)
* [Данные для тестирования](#DataForScenarios)
* [Структура сценария](#TestStructure)
* [Практика](#Practice)
+ [Постановка задачи](#Task)
+ [Разработка](#StagesDefinition)
+ [Этап 1](#Stage1)
+ [Этап 2](#Stage2)
- [Метод для создания поставщика](#CreateVendor)
- [Метод для создания покупателя](#CreateCustomer)
- [Метод для создания товаров](#CreateItem)
- [Метод для создания складов](#CreateWarehouse)
- [Метод для создания документа ПоступлениеТоваровУслуг](#CreateVendorInvoice)
- [Метод для создания документа РеализацияТоваровУслуг](#CreateInvoice)
- [Создание теста ПродажаСДатойСогласования](#CreateSale)
+ [Этап 3](#Stage3)
+ [Этап 4](#Stage4)
* [Заключение](#Conclusion)
Вступление
==========
Независимо от того, какой философии придерживается компания, одно остается неизменным – процесс программирования приложений с пользовательским интерфейсом, включает в себя запуск программы, эмуляцию действий пользователя, зрительный анализ ситуации, возврат к доработке кода, и так далее, с последующим повторением итерации. Принципиально, в этой схеме можно выделить два отрезка времени: программирование и проверка. Время, которое тратится на программирование, превращается в код. Время, которое тратится на проверки, уходит безвозвратно. В силу специфики процесса разработки, когда мы снова и снова запускаем приложение, повторяя итерации, компенсация потерянного времени достигается за счет уменьшения второго временного отрезка, либо сдвига всех проверок на некую «финальную» итерацию или запуск BDD-теста. Отсутствие возможности повторить опыт проверок, отрицательно сказывается на качестве программного продукта.
Во многом, эти вопросы решаются внедрением специальных методик, например, TDD, BDD, организацией дополнительных процессов по тестированию. Однако, везде есть свои нюансы.
Например, TDD существенно пересматривает взгляд программиста на разработку, и в случае интерактивных приложений с глубокой завязкой бизнес-логики на базе данных, особенно при создании конфигураций с гибкой системой прав и функциональных опций, методику применять не просто.
BDD, за счет человеческого языка сценариев Gherkin, идеологически сшивает в одном месте специалистов прикладной и технической областей, а используемая конструкция описания сценариев Given-When-Then универсальна. Однако, BDD больше о процессе создания продукта, а не только о его тестировании. BDD основывается на ролевом взаимодействии сотрудников компании, что делает её требовательной (и в какой-то мере хрупкой) ко всем звеньям цепи разработки. Другой важной проблемой является не высокая эффективность языка Gherkin при разработке сложных (с точки зрения BDD) сценариев. К автоматическому документированию, как бонусу BDD, также, немало вопросов. Руководства пользователя к продуктам известных вендоров, не строятся по принципу Given – When – Then, а с техническим документированием, многие выбирают подход “Лучше устаревшая, но понятная, чем актуальная, но непонятная (или понятная только автору сценариев) документация.
Исторически, TDD, BDD и другие, пришли из мира, где системы 1С нет как класса, где идет очень четкая специализация, и разрыв между понимаем задачи техническим специалистом и бизнесом, как правило, велик. Например, в типовой 1С-франчайзи, очень часто задачи идут конвейером, могут приниматься по телефону, скайпу или электронной почте. Организация заседаний на каждую доработку в формате трех друзей (Three Amigos), выглядит несерьёзно, а значит почти вся методика BDD искажается или даже ломается.
В тоже время, на крупных проектах, эти переговоры необходимы. В идеале там будет аналитик, тестировщик и разработчик (BA+QA+Developer), но там не будет всего отдела программистов. А им, в конечном итоге, писать код, проводить тестирование, зачастую, намного более глубокое, с пограничными значениями, отклонениями, и другими особенностями реализации, возникновение которых рождается в коде и не может быть описано в приемочном тесте или постановке задачи. И это будет не TDD, а реальные сценарные тесты, которые программисты как правило не автоматизируют, а выполняют вручную в рамках процесса кодирования.
Другой пример из жизни программиста 1С: считается вполне типовым сценарий (пример описан не для российского законодательства): Расчет отпуска сотруднику, где нужно учесть предыдущие начисления за прошлые три месяца, включая количество праздников за период расчета, праздников, выпавших на выходные дни, если они предусмотрены графиком его работы, квартальные, годовые и фиксированной суммой премии, которые могут быть начислены не в периоде их расчетов, смена должности и/или графика работы, учет системы прямого табелирования или методом отклонений, а также, период самого отпуска должен быть очищен от праздников. В случае, если сотрудник часть отпуска проболел – следующее продление должно учитывать предыдущие начисления, кроме этого, нужно предусмотреть пересечение периодов начислений (неделя/две недели/месяц/вахта) с периодом отпуска и другие характеристики. В качестве сценария в данном случае, обычно выступает законодательный акт или статья из бухгалтерской периодики, что в большинстве случаев считается для программиста 1С включенной в область его ответственности задачей. Попытка организовать (а не только написать) сценарное тестирование на языке Gherkin для данного, вполне стандартного сценария, может стать настоящим испытанием.
Несмотря на популярность тех или иных подходов к борьбе за качество программ, для развитых технологий быстрой разработки 1С-приложений, требуется их адаптация. Вопрос не в том, возможно или невозможно применять в отделе программистов ту или иную методику, вопрос в том – насколько это эффективно, и если программисты 1С сами себе начинают писать BDD-сценарии, скорее всего, что-то пошло не так.
Так или иначе, при правильном подходе, любой вид тестирования, как по методике, степени автоматизации и месту применения очень полезен. Например, тестирование, выполняемое тестировщиками, очень важный фильтр вылова ошибок в жизненном цикле разработки программ, и не просто потому что больше – лучше, а потому что специалисты тестирования не предрасположены к совершению ошибок, свойственных разработчикам.
В реальности, приходится сталкиваться не только с выбором методик тестирования, но и с проблемой итоговой стоимости достигаемого качества, эффективностью. К сожалению, в силу превалирования теоретических материалов с историями успеха над практическими методиками, не мало коллективов почти справедливо считают автоматизированное тестирование роскошью или баловством, которое могут себе позволить большие компании или отпетые энтузиасты.
О конфигурации Тестер
=====================
Бесплатное решение для проведения сценарного тестирования приложений на базе 1С: Предприятие 8.3, управляемые формы. Тестер призван сохранить и воспроизвести опыт программиста, время на приобретение которого было потрачено на ручные проверки и тестирование. Основным профитом от использования Тестера является повышение качества программ, без существенных организационных изменений, изменений принципов программирования, и других долгосрочных инвестиций времени на выпуски очередных версий продуктов. Тестер может использоваться как независимый инструмент, так и совместно с BDD, выступая в качестве платформы для разработки сложных тестов.
Возможности:
------------
* Программирование и запуск сложных сценарных тестов в одной среде
* Глубокое тестирование интерфейса и бизнес логики
* Запись работы пользователя с переводом сценария в программный код
* Организация коллективной работы по созданию базы тестов
* Гибкий ролевой доступ, раздельный RLS-доступ пользователей к тестируемым конфигурациям
* Инкрементальная выгрузка/загрузка тестов во внешние файлы
* Формирование протоколов и сводных отчетов по выполненным сценариям
* Настройка рассылки результатов тестов по электронной почте
* Тестирование по расписанию, организация непрерывного процесса прогона тестов в рамках CI
Особенности:
------------
* Быстро устанавливается, не требует специальных (кроме 1С) знаний и программного обеспечения
* Быстро интегрируется в процесс разработки
* Не требует фундаментального пересмотра философии программирования
* Сфокусирован на процесс создания реальных тестов
* Не требует подготовки отдельных баз и эталонных данных
Другое применение:
------------------
Тестер может быть использован как автоматизатор рутинных операций, как в процессе разработки, так и в режиме реальной эксплуатации продуктовых баз. Среди таких задач можно выделить:* Выгрузка загрузка данных, пакетный запуск 1С для административных задач
* Запуск и манипуляции обработками, отчетами. Тестером можно написать сценарий, который будет формировать отчет, проверять какие-то данные или открывать обработку и нажимать там нужные кнопки и выбирать поля
* Формирование начальных или тестовых данных для ваших решений (вместо использования конвертации данных)
* Нагрузочное тестирование. Например, у вас есть доработка и вы хотите проверить работу этого функционала под нагрузкой. Для этого можно написать сценарий запуска Тестера нужное кол-во раз с передачей целевого тестируемого сценария в качестве параметра
| | |
| --- | --- |
| Последние обновления | <https://github.com/grumagargler/tester> |
| Депо общих тестов | <https://github.com/grumagargler/CommonTests> |
| Депо демо тестов для ERP2 (демо) | <https://github.com/grumagargler/ERP2> |
| Сайт проекта | <http://www.test1c.com> |
| Язык | Интерфейс: Английский, Русский
Справка: Английский (частично), Русский |
Базовые определения
===================
Процесс тестирования приложений при помощи Тестера основывается на взаимодействии Тестера с запущенной конфигурацией 1С в режиме 1С: Предприятие.
При этом считается, что Тестер выступает в роли Менеджера тестирования, а тестируемая конфигурация – в роли Клиент тестирования.
Тестер является системой сценарного тестирования. Это означает, что взаимодействие с тестируемым приложением происходит в режиме эмуляции действий пользователя.
Всё, что требуется тестировать должно быть описано алгоритмом на языке программирования 1С. Совокупность программируемой логики определяет понятие Сценарий. Все сценарии разрабатываются и хранятся в Тестере.
Тестер может взаимодействовать с тестируемым приложением только так, как это может делать пользователь, от имени которого производится выполнение сценарных тестов. Отсюда формулируется важное замечание: разрабатываемые механизмы тестируемого приложения должны быть проверяемыми. Например, если стоит задача проверить правильность движений документа, и при этом в системе нет отчета по движениям документа и нет отчета/обработки/формы, через которую пользователь смог бы проверить записи, Тестер не сможет проверить правильность движений (в данном случае, таковой является концепция, однако технически, Тестер может запустить внешнюю обработку, в коде которой программист может выполнить произвольный программный код проверки).
Тестер является средой, где разрабатываются, хранятся и выполняются тесты. Тестер может использоваться как облачное приложение с многопользовательским доступом, в котором может быть создано неограниченное число пользователей, тестов и тестируемых приложений.
Тестер не является системой TDD, и строго говоря, не является идеологически чистым BDD. Тестер старается не привязываться к религии в разработке, он решает те проблемы, с которыми сталкиваются абсолютно все разработчики программного обеспечения. Тестер старается решать эти задачи максимально эффективно.
Тестер предназначен для тестирования конфигураций, разработанных на управляемых формах версии 1С: Предприятие 8.3.x. Обычные формы не поддерживаются.
Предполагаемые пользователи Тестера, это:
| Пользователи | Задачи |
| --- | --- |
| Программисты | Использование системы в процессе разработки. Эволюция процесса ручного тестирования |
| Тестировщики с базовыми знаниями программирования на языке 1С | Написание сценариев, максимально приближенных к сценариям работы пользователей. Эти сценарии, обычно не такие глубокие, как у программистов, но более выраженные с точки зрения бизнес-процесса |
| Бизнес аналитики. Консультанты | Запуск тестов, анализ результатов. Через чтение тестов, понимание работы функционала системы |
Концепция
=========
Источником работы для программиста может служить техническое задание, средства коммуникации, BDD-сценарий, внутреннее вдохновение и многое другое. Вне зависимости от способов формализации процессов в компании, или отсутствию таковых, любое задание адаптируется под внутреннюю специфику работы программистов.
Имея на входе информацию по задаче, мы мысленно разбиваем весь процесс кодирования на небольшие транзакции, рывки. Это является для нас неким краткосрочным планом работ (даже если на входе BDD-сценарий). Затем, мы начинаем методично работать по схеме “написание кода – запуск приложения – проверка ожидаемого поведения – возврат к доработке кода”. Количество таких транзакций и степень их завершенности — очень хрупкие сущности, потому что опираются на способность и возможность программиста быть в сосредоточении.
Даже при идеальных условиях выполнения работ по кодированию, опыт этих транзакций без специальных инструментов – не восстановим. Кроме этого, если в середине намеченного пути, возникает непредусмотренная ситуация, ошибка в связанном коде или недоработка используемого механизма, программисту приходится переключаться в другой контекст для разбора проблемы, нередко делая это в спешке, потому что намеченный план работ начинает ускользать из рабочей памяти нашего мозга. При изменении сопутствующего кода, мы стараемся удержать в голове триггер “нужно протестировать потом этот код”.
Можно использовать специальные метки в коде, инструменты среды разработки, делать скриншоты, аудиозаписи, но это лишь точки возврата к проблемам, ментальный контекст на те моменты времени уже не откатить. Можно применять TDD, но результирующее влияние изменений на поведение системы в целом, проверить будет очень сложно. Например, вы изменили запрос заполнения документа Начисление ЗП, который сильно зависим от условий приема сотрудников на работу, отпусков, больничных, изменений кадровых состояний, и при этом, затрагиваются расчеты налогов, в основе которых лежат эти начисления. Вовлеченность десятков таблиц баз данных, огромного количества начальных значений, может сделать TDD очень сложным, а падающие тесты в таких случаях не всегда понятны из-за отсутствия полного сценарного контекста.
Интегрирование в работу инструмента тестирования, потребует от программиста выработки навыка трансляции мысленно составленного плана работ в программный код сценария. Это дает ему возможность “разгружаться” сериализуясь в код теста. Накапливаемые сценарии, всегда можно воспроизвести, что позволяет сосредоточится на качестве выполняемых работ. Рост количества тестов дает свободу действий не только для рефакторинга, но и других существенных изменениях функциональности разрабатываемого приложения, что является одной из важных концепций инструмента.
Быстрый старт
=============
Для быстрого развертывания инфраструктуры тестирования достаточно выполнить следующие шаги (предполагается, что Тестер скачан и прописан в списке информационных баз):1. Конфигурация Тестер должна быть запущена в режиме 1С: Предприятие с ключом /TESTMANAGER.
Этот параметр может быть прописан непосредственно в профиле информационной базы Тестера, например так:
2. Тестируемая конфигурация должна быть запущена в режиме 1С: Предприятие с ключом /TESTCLIENT.
Этот параметр может быть прописан непосредственно в профиле тестируемой информационной базы, например так:
3. Версия 1С, используемая для тестирования должна быть одинаковой как для Тестера, так и для тестируемой конфигурации.
4. Запуск Тестера и тестируемой конфигурации желательно производить на одном компьютере. Для запуска программ на разных компьютерах, необходимо настроить порт и адрес тестируемого приложения в справочнике Приложения.
С технической точки зрения, для начала разработки тестов и тестирования больше ничего не требуется.
Первый сценарий
---------------
Рассмотрим пример создания теста к конфигурации БСП 2.2.
Напишем элементарный тест, который просто откроет форму списка справочника Партнеры.
1. Запускаем Тестер с ключом /TESTMANAGER.
2. Запускаем БСП с ключом /TESTCLIENT.
3. Переключается в Тестер, открываем меню быстрых функций и создаем новое приложение:
4. Через меню быстрых функций открываем сценарии и создадим новый сценарий:
1. В поле ID напишем Test1
2. В тексте сценария напишем:
3. ```
Подключить (); // Подключаем БСП к Тестеру
Меню ( "Справочники / Демо: Партнеры" ); // Открываем в БСП форму списка
```
4. Переключимся на вкладку Свойства, и в поле Приложение укажем БСП
5. Нажмем на панели кнопку Основной
6. Тест готов. Теперь нажмем кнопку Запустить (или F5 ) и запустим его.
В результате, в БСП должна открыться форма списка справочника Демо: Партнеры. Если бы во время открытия справочника, произошла какая-то ошибка, Тестер бы о ней сообщил.
Второй сценарий
---------------
Добавим в первый тест создание нового партнера, для этого внесем следующие изменения в сценарий:
```
// Подключаем БСП к Тестеру
Подключить ();
// Закроем все окна в БСП
ЗакрытьВсё ();
// Открываем в БСП форму списка
Меню ( "Справочники / Демо: Партнеры" );
// Говорим Тестеру, что мы будем сейчас работать с этим окном
Здесь ( "Демо: Партнеры" );
// Нажмем кнопку Создать
Нажать ( "Создать" );
// Говорим Тестеру, что мы будем сейчас работать с этим окном
Здесь ( "Демо: Партнер (создание)" );
// Установим наименование партнера
Установить ( "Наименование", "Мой тестовый партнер" );
// Кликнем на флажок Поставщик
Нажать ( "Поставщик" );
// Нажмем кнопку Записать и закрыть
Нажать ( "Записать и закрыть" );
```
После выполнения теста, в базе БСП должен быть новый партнер.
После выполнения теста, в окне сообщений Тестера, будет такое предупреждающее сообщение:
```
14: Поле "Создать" найдено в нескольких местах: ФормаСоздать (Тестируемая кнопка формы / Кнопка командной панели), СписокКонтекстноеМенюСоздать (Тестируемая кнопка формы / Кнопка командной панели) {Тест1[14]}
```
Сообщение говорит о том, что в 14 строке кода, метод Нажать нашел несколько мест, где можно нажать Создать.
Для того, чтобы задавать однозначно объекты, с которыми требуется взаимодействие, можно использовать идентификаторы, или полный путь.
Например, в 14 строке можно написать так:
```
// Вариант 1
Нажать ( "!ФормаСоздать" );
// Вариант 2
Нажать ( "!КоманднаяПанель / Создать" );
```
Для получения идентификаторов и внутреннего содержимого форм тестируемого приложения, см раздел [Вкладка Поля](#FieldsPage).
Следующие разделы посвящены полному обзору функций Тестера.
Интерфейс
=========
Интерфейс Тестера организован с позиций удобного написания и запуска тестов. При первом запуске, на домашнюю страницу выводится справка по системе (выкачивается из интернета) и открывается основной сценарий, если он задан. В левой части системы находится текстовый редактор для ввода кода сценария, справа – дерево сценариев.
К сожалению, на момент подготовки этой документации, система еще не поддерживает синтаксическое цветовое оформление программных модулей. Лишь поначалу это может показаться серьёзной проблемой, но спустя непродолжительное время, вы перестанете обращать на это внимание, потому что изначально, код сценария существенно проще, чем стандартный программный код конфигураций.
Некоторые специалисты ненадолго предпочли использование Visual Studio Code с расширением Language 1C (BSL) или обычный конфигуратор 1С для набора текста сценария, с последующим копированием или загрузкой в Тестер. Однако, практика показала, что ценность цветового оформления существенно ниже возможности взаимодействия программиста с полями и структурой тестируемого приложения, деревом сценариев, помощником и другими функциями, доступными только из Тестера.
Дерево сценариев
----------------
Тестер поставляется с демонстрационной базой. В демо-базе содержится небольшой набор универсальных тестов, а также специальные тесты для конфигурации ERP2. Я предлагаю использовать демо-базу в качестве начальной базы для создания вашей собственной инфраструктуры тестов.
Когда вы запускаете Тестер, в правой части экрана находится дерево сценариев. Это дерево позволяет организовать сценарии в виде иерархии. Каждый узел дерева имеет тип. Тип задает смысловое значение сценариев внутри узла, сортировку и пиктограмму. В терминологии 1С, это дерево – обычный иерархический справочник.
На картинке ниже показан пример дерева тестов из демонстрационной базы, и далее дано описание каждого маркера:
### Типы сценариев, Маркер 1
Левее маркера, в зеленом цвете и специальной пиктограмме, находятся такие узлы как Корзина, Общее, Таблица и другие.
Такое оформление означает, что это библиотеки тестов. Признак, что узел является библиотекой, задается при создании/редактировании теста:
На картинке видно, что кроме библиотеки, тест может быть папкой, сценарием или методом.
Строгой технической привязки и контроля типа сценария в Тестере нет. Главное предназначение типов – это организация визуальной логики взаимосвязи сценариев.
В случае, если это библиотека, подразумевается, что внутри данной папки будут храниться только библиотечные сценарии-методы. Метод – это сценарий, который не должен привязываться к конкретной тестируемой логике приложения. Методы обычно могут принимать параметры, они работают как процедуры/функции. Методы не должны запускаться как отдельные, самостоятельные сценарии (запуск сценариев см. [здесь](#Running)).
Пример метода: ПроверитьОшибкуЗаписи.
Пример использования в коде сценария:
```
Вызвать ( "Общее.ПроверитьОшибкуЗаписи", "Не заполнен контрагент" );
```
### Группы сценариев, Маркер 2
На этом маркере изображена папка Документы. Папка – это логическая группировка сценариев. Группировка может быть произвольной. Вы можете создавать папки с тестами по принципу тестируемых подсистем, ролей пользователей или технических заданий. Если вы не чувствуете, какая структура тестов вам нужна, тогда универсальным подходом является проецирование структуры тестов на объекты метаданных вашей конфигурации. Смело можно создавать группы Справочники, Документы и так далее. Внутри этих групп, создавать группы с названиями объектов метаданных, а следующим уровнем, располагать конкретные сценарии. В будущем, если потребуется, вы сможете сделать перегруппировку.
### Обычный сценарий, Маркер 3
Маркером отмечен стандартный сценарий. В данном случае, это сценарий под названием Начало. Обратите внимание, что пиктограмма левее, имеет небольшой желтый шарик справа, а у сценария на маркере 5 такого шарика нет. Наличие желтого шара означает, что внутри данного сценария, кроме скрипта сценария, находится еще и шаблон. Шаблоны используются для проверки бизнес-логики тестируемого приложения. Подробнее о проверке бизнес-логики см. [здесь](http://www.test1c.com/#Businesslogic).
### Сценарий-метод, Маркер 4
Этим маркером отмечен сценарий-метод. В данном случае, метод находится внутри обычной группы сценариев, а не в библиотеке. В этом случае, предполагается, что метод используется основными сценариями для разгрузки логики. Например, сценарий Начало будет вызывать сценарий-метод ЗадолженностьПоставщикам, который в свою очередь будет формировать отчет и проверять правильность показателей. Тестер, в дереве, располагает сценарии выше методов, чтобы они не смешивались.
### Основной сценарий, Маркер 5
Этим маркером отмечен обычный сценарий. Подчеркивание снизу указывает на то, что данный сценарий в настоящий момент текущий (основной). Основной сценарий, это тот сценарий, над которым сейчас работает программист. Любой сценарий может быть установлен основным (правый клик в дереве / Основной). У каждого пользователя системы Тестер может быть свой основной сценарий. Основной сценарий отличается от остальных тем, что его легко найти в дереве (правый клик в дереве / Найти основной сценарий) и легко запустить на выполнение (см. [Запуск тестов](#Running)). Также, основной сценарий автоматически открывается при запуске новой сессии Тестера.
### Приложения, Маркер 6
Под маркером 6 находится колонка с названием приложения, к которому принадлежит соответствующий сценарий.
Приложение устанавливается в форме редактирования сценария, для любого типа сценария:
Поле Приложение можно не устанавливать, оставить пустым. В этом случае, предполагается что сценарий универсальный и может работать для всех приложений в системе.
Обратите внимание, что для библиотечных тестов и групп первого уровня (см. картинку с деревом тестов) приложение не задано, а для группы ЗаказПоставщику, ТестСоздания и т.д. приложение задано. Логика следующая: библиотечные тесты могут работать для любой конфигурации, поэтому при их создании, приложение не задали. Группа тестов Документы тоже будет в любой конфигурации, приложение также не задано. Для группы ЗаказПоставщику, ТестСоздания и т.д. приложение задано, потому что они имеет четкую привязку к тестируемому приложению.
Задавать приложение для сценариев нужно:
1. Для логической группировки сценариев и возможности отбора сценариев в дереве тестов, см. картинку:
2. Для контроля уникальности имен сценариев. Например, может существовать несколько тестов с названием ЗаказПоставщику, если для каждого из них задано отдельное приложение. Создать еще одну группу тестов с названием Документы нельзя, потому что она задана как общая, без указания конкретного приложения.
### Хранилище, Маркер 7
Правее маркера, находится колонка, определяющая в виде пиктограммы статус сценариев в хранилище тестов.
Стратегия редактирования сценариев в Тестере организована по принципу работы со стандартным хранилищем 1С. Для того, чтобы начать редактирование сценария, его нужно захватить (правый клик в дереве / Захватить). Для того, чтобы сценарий сохранить в хранилище тестов, его нужно туда поместить (правый клик в дереве / Поместить). В момент помещения теста в хранилище (или создания нового теста), создается его версия. В тот период времени, пока сценарий захвачен на редактирование, остальные участники тестирования могут использовать захваченный сценарий, но они не могут его изменять. При использовании захваченного сценария, программисты буду получать от Тестера последнюю версию сценария, а не текущую, которая редактируется в настоящий момент.
Например, если вы захватили и редактируете сценарий-метод ЗадолженностьПоставщикам, а другой программист запустил на выполнение сценарий Начало, который в свою очередь из кода вызовет заблокированный вами метод ЗадолженностьПоставщикам, Тестер отдаст этому программисту последнюю версию теста ЗадолженностьПоставщикам, которая была в хранилище до того, как вы начали его редактирование. Таким образом, ваши текущие изменения сценария не повлияют на работу других разработчиков.
При помещении изменений в хранилище, ваши изменения становятся доступны всем пользователям. Если вы разрабатываете определенный функционал, и ваши изменения теста могут затронуть работоспособность других связанных тестов, рекомендуется использовать метод [МояВерсия ()](http://www.test1c.com/#MyVersion).
### Запуск тестов
Любой тест из дерева тестов может быть запущен на выполнение, вне зависимости от его типа. Однако, как было сказано выше, предполагается, что запускаться должны только тесты с типом Сценарий, а сценарии-методы, должны вызываться из кода сценариев.
Основной способ запуска тестов это кнопка F5 или команда Запустить:
> При запуске теста по кнопке F5 (или командe Запустить) Тестер всегда запускает сценарий, установленный как [основной](#CurrentScenario). Таким образом, вне зависимости от кого, какой сценарий вы в данный момент редактируете, запускаться будет только основной.
Такой подход позволяет редактировать группу взаимосвязанных тестов, и быстро запускать весь сценарий на выполнение, без ненужных переключений вкладок. Кроме запуска основного сценария, имеется возможность запуска текущего сценария. Полный набор функций см. в контекстных меню Тестера.
Вкладка Поля
------------
В процессе написания сценария, может возникать необходимость в анализе внутренней структуры окон тестируемого приложения.
Такой анализ нужен для выделения идентификаторов полей и точного к ним обращения из кода теста. Также, такой анализ может единственным способом разобраться в составе полей тестируемой формы в случаях, когда поля формируются динамически.
Для такой задачи на форме сценария присутствует вкладка Поля (для новых сценариев, вкладка скрыта, сценарий должен существовать):
По порядку следования маркеров:
1. Позволяет получить структуру всех окон тестируемого приложения, которые сейчас открыты на экране.
2. Позволяет получить только текущее окно тестируемого приложения.
3. Позволяет быстро найти в дереве элементов текущий активный элемент тестируемого приложения. Очень удобная функция при написании тестов. Например, можно открыть нужную форму и встать на нужный элемент, затем, в Тестере, получить эту форму (п.2) и нажать Синхронизировать. После этого, Тестер попытается найти и активировать строку в дереве с данным элементом. В случае неудачи, генерируется ошибка.
4. При навигации по дереву, Тестер пытается активировать выделенные элементы в тестируемом приложении. Будьте внимательны, фокус может “прыгать” с дерева на тестируемое приложение.
5. Для выделенного поля можно выполнить метод или получить свойство. Набор методов и свойств зависит от типа выделенного элемента и применяется согласно объектной модели тестируемого приложения платформы 1С. Например, на картинке поле ОтборСостояние имеет тип ТестируемоеПолеФормы. В синтаксис помощнике 1С, можно посмотреть, какие методы и свойства доступны объектам этого типа. Одно из них, свойство ТекстЗаголовка, результат получения которого выведен на картинке выше.
Перед внедрением
================
Несмотря на простоту использования Тестера, внедрение тестирования требует определенных усилий. На практике, в среднем, нужно от недели до двух для того, чтобы адаптироваться к разработке с Тестером.
Перед погружением в детали, определимся с тем, когда автоматизированное тестирование применять неэффективно:
1. Вы создаете макет, прототип приложения для демонстрации заказчику
2. Вы вносите точечные исправления в старый код, в те механизмы, сценариев к которым нет и не будет, и вся эта работа без перспектив эволюции модулей
3. Вы прощупываете будущую реализацию, когда еще нет четкого понимания, что это должно быть, документ или справочник, отчет или динамический список. В этом случае, программист нередко переключается в режим “потока” и быстро накидывает объекты метаданных для того, чтобы доказать или опровергнуть самому себе достижимость результата выбранным путем. В таких ситуациях, практически невозможно выработать сценарий, но это и не нужно. Строго говоря, пока не сформируется полное представление о способе выполнения задачи, сценарное тестирование применять не стоит
Процесс внедрения нужно начинать плавно. Вначале это может быть один программист или аналитик и небольшой проект, затем, когда в коллективе уже кто-то будет владеть данной техникой, и сможет оперативно отвечать на вопросы, можно постепенно расширять область действия Тестера.
Установка
---------
Если вы занимаетесь обслуживанием клиентов частным образом, Тестер имеет смысл установить локально на ваш компьютер или ноутбук, файловый вариант. Если вы работаете в команде, вне зависимости от того, работают все программисты над одним проектом или у каждого свой, Тестер желательно установить в локальной сети или облаке. Если ваш коллектив более 3 программистов, я бы рекомендовал установить клиент-серверный вариант платформы.
Даже если ваша команда сильно распределена, с пингом до ~125мс всё еще можно комфортно работать через интернет, разработка Тестера велась с учетом удаленности программистов. Если по каким-то причинам, облачное решение организовать не получается, можно установить программу локально на каждый компьютер специалиста, файловый вариант. Для организации общего хранилища тестов, можно использовать Git. У Тестера есть возможность инкрементальной выгрузки/загрузки тестов в файловую систему.
Кроме этого, для организации ночного тестирования, потребуется установить на выделенном для этого сервере или виртуальной машине тонкий клиент 1С: Предприятие, с возможностью его подключения к облаку, где ведется разработка тестов. В случае использования Git для хранения тестов, нужно будет обеспечить предварительную закачку тестов на сервер тестирования, с использованием утилит от Git. Подробнее, ночное тестирование описано разделе [Запуск тестов по расписанию](http://www.test1c.com/#Schedule).
> Тестер позволяет в одной базе вести работу с тестами для неограниченного числа приложений (конфигураций). Не стоит создавать отдельную базу с Тестером под каждый проект/конфигурацию/клиента. В Тестере возможна настройка ограничения доступа пользователей к приложениям.
Базы данных
-----------
Тестирование при помощи Тестера предполагает наличие двух баз данных: рабочей и начальной.
Рабочая база — это база данных в которой работает программист, и в которой выполняются все тесты. Соответственно, у каждого программиста своя рабочая база.
Начальная база — это база, заполненная начальными данными. Начальная база нужна для того, чтобы периодически создавать/перегружать рабочие базы. Наполненность начальной базы зависит от типа выполняемых работ. Начальная база общая для всех программистов.
Создание и обновление начальной базы
------------------------------------
Если вы разрабатываете типовую конфигурацию, за основу начальной базы можно взять начальную базу, которую вы будете поставлять с вашей конфигурацией. В этой базе (подготавливаемой для тестирования, а не поставки в решении), рекомендуется включить все функциональные опции, добавить несколько пользователей с разными ролями, заполнить стандартную нормативно-справочную информацию, создать как минимум одну организацию, склад, подразделение и другое, в зависимости от специфики вашего решения.
Если вы дорабатываете типовую конфигурацию, в качестве начальной базы может выступать база клиента, или демонстрационная база типового решения, обновленная и настроенная спецификой вашего заказчика.
Кроме самого факта существования начальных данных, я рекомендую разработать и поддерживать тест, который будет проверять начальную базу на согласованность данных. Например, вам для работы тестов требуется определенный курс валюты, или наличие графика работ Пятидневка, или должен быть заполнен регистр адресации бизнес-процессов типовыми ролями и исполнителями и т.д. С ростом функционала вашей системы, и возможным, в этой связи, расширением начальных данных – доработка теста проверки начальной базы будет всегда гарантировать понимание базовых условий.
Использовать такой тест удобно в следующих случаях:
* Каждый программист/аналитик/тестировщик может четко проверить консистентность своей рабочей базы перед тем как вообще что-то тестировать (напомню, рабочая база создается на основании начальной)
* Данный тест можно запускать первым в списке тестов для ночного тестирования, по результатам которого, определить целесообразность дальнейшего тестирования
* Тест хорошо работает как напоминание разработчику, какие данные можно брать не думая об их существовании, а какие нужно создавать дополнительно. В процессе работы, рабочая база превращается в хлам, и помнить, какие данные там начальные, а какие нет, сложно. Разворачивать каждый раз начальную базу последней версии – может быть не всегда удобно или возможно, при этом, быстрое определение происхождения данных при написании сценария очень важный момент. Например, в базе есть группа материалов “Детали насосно-компрессорного оборудования”, и если есть тест проверки начальных данных, в нем можно произвести поиск по коду и вычислить, происхождение этой группы, буквально в несколько кликов.
> Примечание: в качестве решения проблемы загрязнения рабочей базы я не рассматриваю откат транзакций в сценарном цикле, что вы можете найти как подход в некоторых авторитетных источниках. По моему опыту, используя такой подход говорить о сколь-нибудь серьёзном тестировании не приходится.
Начальную базу нужно подключить к хранилищу, куда сливаются финальные обновления конфигурации. Это необходимо для оперативного обновления начальной базы новым функционалом, обновления и/или заполнения базы новыми начальными данными.
Если над решением трудится коллектив, начальную базу нужно расположить в общедоступном месте, чтобы каждый специалист мог в любой момент "обнулить" свою рабочую базу, загрузив в неё начальную.
Если новый функционал требует обновления/добавления начальных данных, такую задачу можно решить двумя способами:
1. Ответственный разработчик, открывает обновленную начальную базу, дополняет вручную нужными данными, дорабатывает тест проверки начальных данных, запускает этот тест, убеждается в согласованности данных, и выгружает полученную базу в общедоступное место
2. Всё тоже самое что в п.1 с той разницей, что вместо ручного обновления, ответственный разработчик, пишет сценарный тест.
Второй вариант дольше, но предпочтительней, потому что позволит всем участникам команды обновлять свои рабочие базы без обнуления начальной выгрузкой данных.
Начальные данные желательно использовать в режиме “только чтение" по отношению к тестируемому функционалу. Например, если у вас в начальных данных определена организация по умолчанию, и у вас есть тест, который проверяет механизм ввода новой/изменения/удаления организации, то лучше в этом тесте не использовать в качестве тестовой организации, существующую организацию в начальной базе. Даже если вашим тестом предусмотрен откат изменений к начальному состоянию, нет гарантии, на каком этапе упадет ваш тест. Когда это произойдет, он оставит после себя испорченные начальные данные, что может привести к цепной реакции падения тестов, выполняемых ночью, по расписанию.
Если вашим тестам нужно изменять начальные данные, тогда в начале таких тестов проверяйте, и при необходимости, устанавливайте их начальное состояние. После отработки сценария, верните эти настройки в исходное положение. Если такой тест упадет, тогда другой тест, зависимый от этих же настроек, восстановит начальные значения в исходное состояние перед своим стартом.
Например, если ваш тест проверяет работу механизма контроля остатков в зависимости от системной настройки приложения, вашему тесту придётся изменять эту настройку. Если ваш тест упадет, настройка не будет возвращена в первоначальное положение и следующий запуск этого теста уже вряд ли отработает правильно, даже если с функциональной точки зрения всё в порядке. Таким образом, вначале желательно тестом сходить в настройки, установить требуемое значение и затем продолжить основной сценарий. К слову, подобные проверки не всегда требуются в оперативной работе, поэтому их запуск имеет смысл делать по условию, например, по имени пользователя ночного тестировщика, или флагу глобальных настроек (см. [API Тестера](http://www.test1c.com/#Modules)).
Эталонная база
--------------
Эталонная база данных используется для тестирования бизнес-логики приложения.
Использование эталонной базы при интеграции тестирования в процесс разработки не эффективно и не используется Тестером по следующим причинам:
1. Требуется особый уход за эталонными данными, их корректировка в соответствии с изменениями функционала решения
2. Эталонные данные инертны: новый функционал требует новых эталонных данных, которые могут пересекаться с уже существующими эталонными данными. Вытекающая отсюда осторожность при манипуляции с эталонными данными ограничивает или замедляет развитие спектра тестируемого функционала
3. Оперативный прогон тестов практически невозможен, выгружать/обновлять/загружать эталонные базы долго. Под оперативностью понимается тестирование при каждом запуске программистом приложения на выполнение, а не увеличение числа релизов и закачки схемы на CI-сервере с прогоном тестов в течение дня
4. Количество эталонных баз стремится расти, это осложняет их обслуживание и весь процесс тестирования
Вместо хранения эталонных данных в эталонной базе, проверяемую бизнес-логику нужно хранить в самом Тестере. С точки зрения Тестера, проверка бизнес-логики – это совокупность программного кода сценария, в котором проверяются значения тестируемых полей, и результирующая отчетность по данным информационной системы. Подробнее о тестировании бизнес-логики см. [здесь](http://www.test1c.com/#Businesslogic).
Данные для тестирования
-----------------------
Данные для тестирования это входящая для сценариев информация, требуемая для успешного их прохождения. Если ваш тест открывает форму списка справочника изделий и устанавливает фильтр по заводу-производителю, вашими тестовыми данными как минимум будут: запись в справочнике заводов-изготовителей, запись в справочнике изделий, с заполненным реквизитом завода-изготовителя. Тестовыми данными в этом случае будут и пользователь, под которым была запущена информационная база, единица измерения для изделия и другие сущности.
Тестовые данные состоят из двух слоёв:
1. Начальные данные, которые хранятся в начальной базе и обеспечивают минимальный набор типовой, редко изменяемой информации
2. Создаваемые данные, которые необходимы для тестирования конкретного функционала
Наибольший интерес представляет второй слой. Существует много подходов создания тестовых данных, но в их совокупности можно выделить две стратегии:
1. Выгрузка заготовленных данных из предварительно подготовленных баз или шаблонов, и последующая их загрузка перед началом или во время тестирования. Вариантов выгрузки/загрузки в данном подходе много. Это может быть конвертация данных, универсальный обмен данными, макеты с данными, выгрузки в dt-файлы или обычная сериализация прикладных объектов в JSON или XML.
Рассмотрим плюсы и минусы такого подхода:
| Плюсы | Минусы |
| --- | --- |
| Очевидность подхода | Сложность поддержки согласованности данных в развивающемся функционале приложения, проблемы загрузки данных при измененной структуре метаданных, смене владельцев, появлению полей обязательных для заполнения, переименованию или удалению объектов и их реквизитов. |
| Быстрый старт в подготовке данных | Потенциальная опасность получения не консистентных данных и ложного положительного прохождения теста. Такие тестовые данные как правило загружаются в специальном режиме, без дополнительных проверок и срабатывания обработчиков форм. Фактически, тестовые данные готовятся не так, как это бы сделал пользователь. |
| | Сложность логистики хранения, взаимосвязанности наборов файлов, данных и тестов. |
| | Статичность. Данные загружаются как есть и их сложно менять под вариативность тестов в случае необходимости. |
| | Проблемы с удалением тестовых данных для повторных запусков сценариев. |
2. Формирование тестовых данных самим сценарием. При этом подходе, все тестовые данные должны создаваться, а не храниться для загрузки. Сам процесс создания не должен отличаться от процесса разработки целевых сценарных тестов. Другими словами, сегодня вы пишите тест проверки создания нового товара, а завтра этот тест уже может быть использован как метод для создания тестовых данных, для тестирования создания документа Реализация товаров.
Плюсы и минусы такого подхода:
| Плюсы | Минусы |
| --- | --- |
| Гибкость создания требуемого окружения тестовых данных под различные вариации тестов. Возможность разработки сложных взаимосвязанных тестов. | Сложно без опыта выстроить структуру библиотечных тестов для создания тестовых данных |
| Высокое качество тестов за счет дополнительного тестирование всего стека используемых объектов при подготовке данных. Это очень важный нюанс, потому что создание тестовых данных таким образом, выполняется для разных видов целевых сценариев, что автоматически покрывает тестами разнообразие условий создания объектов.
Например, у нас может быть тест-метод создания поставщика. Но поставщик может создаваться из разных контекстов: из формы списка контрагентов или из поля ввода на форме документа. И если тестовые данные загружать “извне”, можно не отловить ошибку создания контрагента из документа. Тест проверки документа пройдет успешно, хотя фактически, пользователь документ ввести не сможет (потому что не сможет создать для документа поставщика). | Требуется первоначальная инвестиция времени в разработку тестов-методов |
| Консистентность полученного тестового окружения, заполненность реквизитов, отработка возможных событий и программных оповещений об изменении данных, другими словами — полная штатная эмуляция работы приложения. | |
| Слабая связанность с изменчивостью структуры метаданных. Если изменяется структура данных объекта, достаточно изменить (если необходимо) один тест-метод, при этом все остальные тестовые данные менять не придётся. | |
| Простота хранения. Все тест-методы хранятся в одной среде, и не являются внешними по отношению к системе тестирования. | |
| Использование одних и тех же тестовых данных даже в случае, когда их версии метаданных отличаются. В этом случае, в тест-методах можно организовывать условия по обработке/заполнению полей в зависимости от версии используемой программистом конфигурации (см. функцию [МояВерсия ()](http://www.test1c.com/#MyVersion)) | |
Тестер исповедует вторую стратегию в подготовке тестовых данных. С точки зрения Тестера, формирование тестовых данных не должно быть в отрыве от целевого тестирования, тестовые данные должны быть подвижны, и они не должны готовиться отдельно от системы разработки тестов.
Структура сценария
------------------
Перед написанием тестов, нужно задуматься и определить сценарии, которые будут соответствовать вашему краткосрочному планированию. Важно не отвлекаться в этот момент и мысленно не накидывать возможные отклонения. Для каждого отклонения, можно будет потом определить приоритетность и разработать отдельный тест. Даже если вы в состоянии представить большой сценарий, рекомендуется его разделить на несколько небольших и взаимосвязанных тестов.
Для успешного внедрения тестирования, очень важно, чтобы скорость создания и прогона тестов была высокой. Чтобы быстро создавать тесты, нужны две составляющих: тренировка мышления, для быстрого выбора шаблона сценария под задачу и библиотека готовых тестов-методов, для создания всего необходимого по ходу тестирования. Эти вещи приходят со временем.
Чтобы быстро прогонять тесты, нужно чтобы они были следующей структуры:
1. Определение окружения
2. Создание окружения
3. Целевая часть
Определение окружения – это функция в модуле вашего сценария, которая задает параметры теста в виде структуры. Примеры параметров теста: список приходуемых товаров, с ценами и количеством, наименование поставщика, валюта договора и т.д.
Создание окружения – процедура в модуле теста, которая по переданным параметрам создаст необходимое тесту окружение. В этой же процедуре, должна быть проверка уже созданного ранее окружения, чтобы оно не создавалось при повторном запуске сценария.
Целевая часть – это непосредственно код, который будет проверять то, что вы запланировали сделать, и ничего более.
Скорость прогона тестов достигается за счет выполнения тестом только целевой его части, то есть фактически той, которая выполняется вручную при каждом запуске приложения после модификации программистом. Конечно, создание окружения тоже займет какое-то время, и как минимум один раз, тест должен выполнить эту часть сценария, но и это ровно то, что программист бы сделал вручную. Технически, создание окружения вручную может быть быстрее, но лишь на короткий отрезок жизни приложения.
Яснее на примере. Давайте представим, что вы занимаетесь доработкой документа Списание ТМЗ, который нужно дополнить особыми движениями по регистрам. Для тестирования (неважно как, вручную или нет) вам понадобится материал на складе, себестоимость которого вы знаете, установленные параметры учетной политики, на которые вы полагаетесь, и другие настройки системы, например, вариант контроля остатков. Таким образом, вам нужно будет вручную, как минимум один раз проверить, что настройки системы в порядке. Затем, нужно будет создать несколько материалов, возможно отдельный склад и как минимум одно поступление ТМЗ, и вы не забудете дату поступления сделать днем ранее. Таким образом – вы определяете и создаете окружение, чтобы затем выполнить целевую часть – провести списание и проверить, что особые движения появились и они правильные. Другими словами – выполняются все три описанных выше структурных действия для разработки автоматизированного сценария.
Такой несложный подход не просто перекладывает ручные действия в код, он позволяет вам существенно продвинуться в вопросах развития нового функционала, и тестирования отклонений.
Пример. Добавим в описанную задачу необходимость проверки сообщения об ошибке при списании количества материала, большего, чем есть на складе. Я сильно не ошибусь, если предскажу работу смекалки программиста: он просто откроет уже проведенное списание (предварительно добавив его в избранное для максимальной “скорости”), отменит его проведение, в колонку с количеством введет 999999, запишет документ, а потом проведет его и проанализирует сообщение об ошибке. Если сообщения не будет, программист вернется в код, сделает необходимые доработки и будет повторять итерацию до тех пор, пока сообщение об ошибке не появится.
И тут начинаются проблемы. Во-первых, проверить нормальное поведение списания уже так просто не получится. Нужно будет привести данные в порядок, убрать 999999 и вернуть то количество, которое было на момент, когда мы проверяли правильность доработанных движений. И нам уже вряд удастся быстро вспомнить, каким именно было то первоначальное количество. Во-вторых, даже если программист предварительно скопирует документ, перед тем как менять данные – максимум он потом сможет проверить отсутствие ошибок проведения, но расчетные показатели, результат проведения, он проверить уже не сможет.
Другими словами, имеем классическую картину: последующая доработка механизма потенциальна опасна для предыдущего функционала. И при отсутствии возможности быстрого восстановления окружения теста и его оперативного прогона (а не ночью), потенциальная опасность, рано или поздно перейдет в кинетическую, реальную ошибку.
> Дело не только в том, когда мы обнаружим проблему, сейчас, после ночного тестирования, или тестирования тестировщиками, а в том, что когда мы находимся глубоко в коде, нередко нужно здесь и сейчас проверить механизмы, чтобы определиться с выбранным направлением, понять, что наращиваемый функционал не конфликтует и не искажает другие алгоритмы.
Я хотел бы обратить внимание, что даже при условии, когда тесты программиста проходят, они могут содержать методологические ошибки или ошибки понимания задачи. Такие ошибки может выловить отдельный департамент, специальные тестировщики или в конце концов заказчик. Но это отнюдь не означает, что вся история с тестированием программистами не имеет смысла. Наоборот, на основе готовых тестов, программисту достаточно будет скорректировать целевую часть (третья часть сценария), а всю остальную работу по подготовке данные и их проверке выполнит система.
Практика
--------
Перейдем к практической части: поработаем с Тестером в режиме создания нового функционала для конфигурации УТ11 на базе постановки задачи от бизнес-аналитика.
### Постановка задачи
Компания торгует сигарами. Необходимо доработать документ Реализация товаров и услуг (далее Реализация) для возможности указания даты согласования следующих продаж по выбранным позициям.
Предполагается следующий сценарий:
— Менеджер вводит документ реализации, для выбранных позиций, на своё усмотрение он устанавливает дату, когда ему нужно было бы перезвонить клиенту и уточнить, насколько хорошо продаются сигары. Например, из всего перечня, его интересуют только сигары со вкусом ментола.
— У менеджера есть список, который он открывает каждый день и видит, когда, по каким клиентам и каким позициям ему нужно провести переговоры с клиентом для организации следующих поставок интересующих его позиций.
— Менеджер выбирает нужную позицию из списка, звонит клиенту, и вводит в систему результат переговоров
**Документ Реализация**
Необходимо в документ Реализация, в табличную часть, добавить поле для ввода даты согласования (без времени).
Поле не обязательно для заполнения. Если поле задано – тогда данная позиция считается отмеченной для согласования. По таким позициям необходимо предусмотреть обособленный учет на базе регистра сведений Согласование. Записи в данный регистр производить при проведении документа. При повторном проведении документа, существующие записи регистра сведений не обновлять, только добавлять новые.
**Регистр сведений Согласование**
Это новый, независимый регистр сведений, с возможностью редактирования.
Регистр должен хранить такие данные:1. Документ Реализация, Клиент, Менеджер, Товар, Количество, Сумма – автоматически должны заполняться при проведении реализации и не должны быть доступны для редактирования
2. Флаг Отработано – будет устанавливаться пользователем
3. Флаг Комментарий – будет вводиться пользователем и фиксировать результат переговоров. Поле должно быть доступно для редактирования только если флаг Отработано = истина.
Для регистра необходимо разработать форму списка и форму элемента. В форме списка должны быть предусмотрены отборы по менеджеру, клиенту и товару.
Запретить пользователю вводить новые записи в данный регистр интерактивно. Примечание: запрет на ввод нового сделать программно с выводом соответствующего сообщения. Не использовать вместо этого настройку команд и ролей пользователя.
Объект расположить в подсистеме Продажи / Оптовые продажи.
**Тесты**
Необходимо разработать следующий тест:
1. Ввод одной реализации с двумя позициями, одна из которых будет отмечена для согласования
2. Открытие списка на согласование, отбор по клиенту, открытие формы регистра на редактирование, установка галочки, сохранение и закрытие
3. Убедиться, что позиция ушла из списка
Примечание: данный тест требуется автором технического задания. Исполнитель (программист) волен разработать столько дополнительных тестов, сколько ему потребуется для обеспечения надлежащего качества выполнения работ.
### Разработка
По этой задаче мы можем прикинуть ход разработки и тесты, которые нам понадобятся. Условимся, что начальная база у нас уже есть, в ней проведены нужные настройки, отключены окна-подсказки, проверки контрагентов и так далее (о начальной базе см. [здесь](#Databases)). В моем случае, начальной базой будет демо-база УТ11.
Можно выделить как минимум четыре этапа:
Этап 1: добавить реквизит Дата согласования в табличную часть, в процедуре ОбработкаПроверкиЗаполнения реализовать проверку, чтобы дата согласования была больше даты документа
Этап 2: доработать процедуру ОбработкаПроведения, добавить туда логику формирования записей по регистру сведений
Этап 3: реализовать форму списка с фильтрами, как требует бизнес-аналитик
Этап 4: реализовать форму редактирования записи регистра для ввода данных по согласованным позициям.
### Этап 1
В таблице ниже состыкуем работу по кодированию и тестированию:
| Программирование | Тестирование |
| --- | --- |
| В Конфигураторе: 1. Добавляем реквизит ДатаСогласования в табличную часть Товары документа Реализация
2. В процедуре ОбработкаПроверкиЗаполнения реализуем проверку даты
| В Тестере :
Создадим тест ПроверкаДатыСогласования, где:1. Введем новую реализацию, добавим строку, впишем в строку некорректную дату
2. Попытаемся провести, и в списке сообщений найдем требуемое сообщение об ошибке
3. Затем изменим дату на правильную, проведем и убедимся, что сообщения об ошибке уже нет
|
Так как это будет наш первый тест для конфигурации УТ11, нам нужно произвести разовую настройку приложения в Тестере.
Необходимо создать приложение УТ11, см. Меню функций / Приложения. Для создаваемого приложения нужно задать актуальную на момент написания теста версию, например так:
Затем, это приложение нужно установить приложением по умолчанию, для этого нужно переключиться в дерево сценариев, открыть Опции, выбрать в поле Приложение УТ11 и нажать кнопку справа:
Следующий шаг – это создание папки РеализацияТоваровУслуг внутри папки Документы, и следом, создание нашего теста ПроверкаДатыСогласования.
В итоге, должно получится так:
Откроем выделенный на картинке сценарий, переключимся в текстовый редактор и введем этот текст:
```
// Сценарий:
// - Вводим новый документ Реализация
// - Устанавливаем неправильную дату согласования, проверяем наличие ошибки
// - Устанавливаем правильную дату, проверяем отсутствие ошибки
Подключить ();
ЗакрытьВсё ();
// Вводим новый документ
Коммандос ( "e1cib/data/Document.РеализацияТоваровУслуг" );
Здесь ( "Реализация *" );
// Определяем даты
дата = Дата ( Взять ( "!Дата" ) );
плохая = Формат ( дата - 86400, "DLF=D" );
хорошая = Формат ( дата + 86400, "DLF=D" );
// Вводим плохую дату
Нажать ( "!ТоварыДобавить" );
Установить ( "!ТоварыДатаСогласования", плохая );
// Проводим документ
Нажать ( "!ФормаПровести" );
если ( НайтиСообщения ( "Дата согласования*" ).Количество () = 0 ) тогда
Стоп ( "Должна быть ошибка неверной установки даты согласования" );
конецесли;
// Вводим хорошую дату
товары = Получить ( "!Товары" );
Установить ( "!ТоварыДатаСогласования [1]", хорошая, товары );
// Проводим документ
Нажать ( "!ФормаПровести" );
если ( НайтиСообщения ( "Дата согласования*" ).Количество () > 0 ) тогда
Стоп ( "Не должно быть ошибок неверной установки даты согласования" );
конецесли;
// Закрываем документ не сохраняя
Закрыть ();
Нажать ( "Нет", "1*" );
```
Комментарии по коду:
1. В этом тесте у нас нет эталонных данных, мы их формируем кодом сценария. Например, правильную и неправильную дату мы вычисляем согласно дате документа, которая нигде в свою очередь не хранится, а присваивается системой автоматически при вводе нового документа
2. Может показаться, что для простого тестирования корректности даты, сценарий получился большой. В данном конкретном случае, возможно и не стоило создавать специальный тест для такой задачи, ведь мы всё равно следующими шагами будем проверять формирование движений по регистру, и если что-то пойдет не так, оно пойдет не так и в следующих тестах. Однако, с точки зрения подачи информации, и постепенного раскрытия темы, я посчитал нужным наличие этого сценария. Кроме этого, всё-таки этот сценарий теперь у нас навсегда, мы можем запускать еще ночью, и мы можем быть спокойны, что делая какие-то глобальные замены мы не повредим (например) текст сообщения об ошибке
3. В этом тесте нет всей трехступенчатой структуры, которую я описывал ранее (см. [здесь](#TestStructure)), но здесь это и не нужно в силу простоты сценария и как следствие – скорости его прогона
Настало время запуска сценария. Для этого убедитесь, что в конфигураторе настроен запуск приложения в режиме клиента тестирования:
(эта настройка сохраняется и её не придётся устанавливать каждый раз)
Запускаем приложение, затем переключаемся в Тестер, устанавливаем наш сценарий основным и нажимаем кнопку Запустить:
Если вы на момент запуска теста еще не реализовали процедуру проверки даты согласования, наш тест упадет.
Реализуем теперь в модуле реализации, в обработчике ОбработкаПроверкиЗаполнения, такую проверку:
```
пустая = Дата ( 1, 1, 1 );
для каждого строка из Товары цикл
согласование = строка.ДатаСогласования;
если ( согласование = пустая ) тогда
продолжить;
иначеесли ( согласование < Дата ) тогда
Сообщить ( "Дата согласования установлена неверно" );
Отказ = истина;
конецесли;
конеццикла;
```
Запускаем приложения на выполнение, переключаемся в Тестер и жмем там F5. В результате чего, тест должен завершиться без ошибок.
### Этап 2
Переходим ко второму запланированному рывку. В таблице ниже состыкуем работу по кодированию и тестированию:
| Программирование | Тестирование |
| --- | --- |
| В Конфигураторе: 1. Добавляем регистр сведений Согласование
2. Дорабатываем обработку проведения для формирования записей в регистр
| В Тестере:
Создадим тест ПродажаСДатойСогласования, где:1. Определим окружение:
1. Наименование Поставщика
2. Наименование Покупателя
3. Товар1 с ценой и количеством
4. Товар2 с ценой, количеством и датой согласования
2. Создадим окружение
1. Создадим поставщика, покупателя и товары
2. Сделаем поступление
3. Создадим и проведем реализацию
3. Целевая часть
1. Откроем список реализаций и найдем там созданную реализацию
2. Откроем реализацию и проведем
3. Откроем регистр согласований и проверим наличие нашей записи
|
Этот тест сложнее, потому что перед проверкой целевой части, нам потребуется создать окружение. Напомню, что окружение будет создано только один раз, при первом запуске сценария, а затем, будет прогоняться только его целевая часть. Этот трюк будет понятен из кода сценария, который будет разработан в конце этого этапа.
Для создания окружения, нам будут нужны следующие объекты:
1. Поставщик
2. Товар
3. Склад
4. Покупатель
5. Поступление
В реальных проектах, создание окружения простая операция, но мы делаем всё с ноля, у нас еще нет библиотечных тестов, поэтому перед написанием логики окружения, нам нужны тест-методы для создания объектов (о тест-методах см. [здесь](#TestMethod)).
### Метод для создания поставщика
Практически все тест-методы имеют одинаковую структуру: они создаются в группе тестов, соответствующей прикладной модели объектов 1С. Это не жесткое правило, в своих проектах вы можете создавать тест-методы по-своему, но предлагаемый подход уже себя зарекомендовал.
Создадим первый тест-метод. В дереве сценариев, в папке Справочники, создадим папку Поставщики, внутри неё метод Создать, а следом метод Параметры, с тем, чтобы получилась такая структура:
В результате, у нас получился метод Создать и подчиненный ему метод Параметры. Для того, чтобы в каком-нибудь сценарии воспользоваться этим методом, нам достаточно будет написать такой код:
```
// Вначале вызовем тест-метод для получения параметров
параметры = Вызвать ( "Справочники.Поставщики.Создать.Параметры" );
// Заполняем параметры
параметры.Наименование = "ТОО Ромашка";
// Запускаем главный метод передавая ему параметры
Вызвать ( "Справочники.Поставщики.Создать", параметры );
```
Справку по всем функциям Тестера см. в разделе [API Тестера](http://www.test1c.com/#Modules).
Для создания сценариев-методов, в форме элемента сценария, на вкладке Свойства, нужно назначить соответствующий тип:
Подробнее о дереве и свойствах сценариев см. [здесь](#ScenariosTree).
Перейдем в редактор кода сценария Параметры, введем следующий текст:
```
// Параметры создания нового элемента
//
// Возврат:
// Структура параметров
СтандартнаяОбработка = ложь;
п = новый Структура ();
п.Вставить ( "Наименование" );
п.Вставить ( "Доступ", "Поставщики" );
возврат п;
```
Затем, откроем редактор сценария Справочники.Поставщики.Создать и введем:
```
// Создает нового поставщика по переданным параметрам
//
// Параметры:
// Структура параметров, полученная методом "Справочники.Поставщики.Создать.Параметры"
//
// Возврат:
// Код созданного поставщика
Коммандос ( "e1cib/data/Справочник.Партнеры" );
форма = Здесь ( "Партнер (соз*" );
// *********************************************
// Заполнение полей
// *********************************************
Установить ( "!НаименованиеПолноеКомпания", _.Наименование );
Нажать ( "Поставщик" );
Установить ( "!ГруппаДоступа", _.Доступ );
// *********************************************
// Запись, получение кода
// *********************************************
Нажать ( "!ФормаЗаписать" );
код = Взять ( "!Код" );
// *********************************************
// Создание контрагента
// *********************************************
Нажать ( "Контрагенты", ПолучитьСсылки () );
список = Здесь ( "Контрагенты*" );
Нажать ( "!ФормаСоздать" );
Здесь ( "Контрагент (соз*" );
Установить ( "!Наименование", _.Наименование );
Нажать ( "!ФормаЗаписатьИЗакрыть" );
Закрыть ( список );
возврат код;
```
Параметризированный метод создания нового поставщика готов. Перейдем к созданию остальных методов.
### Метод для создания покупателя
Проделаем в дереве сценариев практически те же действия для разработки сценария создания покупателя:
Затем введем код сценариев, Справочники.Покупатели.Создать.Параметры:
```
// Параметры создания нового элемента
//
// Возврат:
// Структура параметров
СтандартнаяОбработка = ложь;
п = новый Структура ();
п.Вставить ( "Наименование" );
п.Вставить ( "Доступ", "Прочие" );
п.Вставить ( "Сделка", "Произвольная продажа" );
возврат п;
```
и Справочники.Покупатели.Создать:
```
// Создает нового покупателя по переданным параметрам
//
// Параметры:
// Структура параметров, полученная методом "Справочники.Покупатели.Создать.Параметры"
//
// Возврат:
// Код созданного поставщика
Коммандос ( "e1cib/data/Справочник.Партнеры" );
форма = Здесь ( "Партнер (соз*" );
// *********************************************
// Заполнение полей
// *********************************************
Установить ( "!НаименованиеПолноеКомпания", _.Наименование );
Нажать ( "!Клиент" );
Установить ( "!ГруппаДоступа", _.Доступ );
// *********************************************
// Запись, получение кода
// *********************************************
Нажать ( "!ФормаЗаписать" );
код = Взять ( "!Код" );
// *********************************************
// Создание контрагента
// *********************************************
Нажать ( "Контрагенты", ПолучитьСсылки () );
список = Здесь ( "Контрагенты*" );
Нажать ( "!ФормаСоздать" );
Здесь ( "Контрагент (соз*" );
Установить ( "!Наименование", _.Наименование );
Нажать ( "!ФормаЗаписатьИЗакрыть" );
Закрыть ( список );
возврат код;
```
### Метод для создания товаров
Справочники.Номенклатура.Создать.Параметры
```
// Параметры создания нового элемента
//
// Возврат:
// Структура параметров
п = новый Структура ();
п.Вставить ( "Наименование" );
п.Вставить ( "Единица", "шт" );
п.Вставить ( "Вид", "Товар" );
п.Вставить ( "СтавкаНДС", "18%" );
возврат п;
```
Справочники.Номенклатура.Создать
```
// Создает новую номенклатуру по переданным параметрам
//
// Параметры:
// Структура параметров, полученная методом "Справочники.Номенклатура.Создать.Параметры"
//
// Возврат:
// Код созданной номенклатуры
Коммандос ( "e1cib/data/Справочник.Номенклатура" );
форма = Здесь ( "Номенклатура (соз*" );
// *********************************************
// Заполнение полей
// *********************************************
//установитьВид ( форма, _.Вид );
Установить ( "!ВидНоменклатурыОбязательныеПоля", _.Вид );
Установить ( "Рабочее наименование", _.Наименование );
Установить ( "Единица хранения", _.Единица );
Установить ( "Ставка НДС", _.СтавкаНДС );
// *********************************************
// Запись, получение кода и завершение
// *********************************************
Нажать ( "!ФормаЗаписать" );
код = Взять ( "!Код" );
Закрыть ();
возврат код;
```
### Метод для создания складов
Справочники.Склады.Создать.Параметры
```
// Параметры создания нового элемента
//
// Возврат:
// Структура параметров
п = новый Структура ();
п.Вставить ( "Наименование" );
возврат п;
```
Справочники.Склады.Создать
```
// Создает новый склад по переданным параметрам
//
// Параметры:
// Структура параметров, полученная методом "Справочники.Склады.Создать.Параметры"
Коммандос ( "e1cib/data/Справочник.Склады" );
форма = Здесь ( "* (соз*" );
// *********************************************
// Заполнение полей
// *********************************************
Установить ( "!Наименование", _.Наименование );
Установить ( "!ТипСкладаОптовый", "Оптовый склад" );
// *********************************************
// Запись, получение кода и завершение
// *********************************************
Нажать ( "!ФормаЗаписатьИЗакрыть" );
```
### Метод для создания документа ПоступлениеТоваровУслуг
Документы.ПоступлениеТоваровУслуг.Создать.Параметры
```
// Параметры создания нового документа
//
// Возврат:
// Структура параметров
СтандартнаяОбработка = ложь;
п = новый Структура ();
п.Вставить ( "Дата" );
п.Вставить ( "Организация", __.Организация );
п.Вставить ( "Склад" );
п.Вставить ( "Поставщик" );
п.Вставить ( "Товары", новый Массив ); // Массив Документы.ЗаказПоставщику.Создать.Строка
п.Вставить ( "ОставитьОткрытым", ложь ); // Закрыть или оставить на экране форму документа
возврат п;
```
Документы.ПоступлениеТоваровУслуг.Создать.Товар
```
// Параметры создания новой строки документа
//
// Возврат:
// Структура параметров
СтандартнаяОбработка = ложь;
п = новый Структура ();
п.Вставить ( "Товар" ); // Наименование или Код товара
п.Вставить ( "Количество" );
п.Вставить ( "Цена" );
возврат п;
```
Документы.ПоступлениеТоваровУслуг.Создать
```
// Создает новый документ Поступление товаров и услуг по переданным параметрам
//
// Параметры:
// Структура параметров, полученная методом "Документы.ПоступлениеТоваровУслуг.Создать.Параметры"
//
// Возврат:
// Номер созданного заказа
Коммандос ( "e1cib/data/Документ.ПоступлениеТоваровУслуг" );
форма = Здесь ( "Поступление товаров и услуг (соз*" );
// *********************************************
// Заполнение шапки
// *********************************************
дата = _.Дата;
если ( дата <> неопределено ) тогда
Установить ( "!Дата", Формат ( дата, "DLF=DT" ) );
конецесли;
Установить ( "!Партнер", _.Поставщик );
Установить ( "!Организация", _.Организация );
значение = _.Склад;
если ( значение <> неопределено ) тогда
Установить ( "!Склад", значение );
конецесли;
// *********************************************
// Заполнение товаров
// *********************************************
таблица = Фокус ( "!Товары" );
для каждого товар из _.Товары цикл
Нажать ( "!ТоварыДобавить", таблица );
Установить ( "!ТоварыНоменклатура", товар.Товар );
Установить ( "!ТоварыКоличествоУпаковок", товар.Количество );
Установить ( "!ТоварыЦена", товар.Цена );
конеццикла;
// *********************************************
// Запись документа, получение номера
// *********************************************
Нажать ( "!ФормаЗаписать" );
номер = Взять ( "!Номер" );
// *********************************************
// Проведение документа и возврат номера
// *********************************************
Нажать ( "!ФормаПровести" );
закрыть = не _.ОставитьОткрытым;
если ( закрыть ) тогда
Закрыть ();
конецесли;
возврат номер;
```
### Метод для создания документа РеализацияТоваровУслуг
Документы.РеализацияТоваровУслуг.Создать.Параметры
```
// Параметры создания нового документа
//
// Возврат:
// Структура параметров
СтандартнаяОбработка = ложь;
п = новый Структура ();
п.Вставить ( "Дата" );
п.Вставить ( "Организация", __.Организация );
п.Вставить ( "Склад" );
п.Вставить ( "Покупатель" );
п.Вставить ( "Товары", новый Массив ); // Массив Документы.ЗаказПоставщику.Создать.Строка
п.Вставить ( "ОставитьОткрытым", ложь ); // Закрыть или оставить на экране форму документа
п.Вставить ( "Комментарий" );
возврат п;
```
Документы.РеализацияТоваровУслуг.Создать.Товар
```
// Параметры создания новой строки документа
//
// Возврат:
// Структура параметров
СтандартнаяОбработка = ложь;
п = новый Структура ();
п.Вставить ( "Товар" ); // Наименование или Код товара
п.Вставить ( "Количество" );
п.Вставить ( "Цена" );
п.Вставить ( "Согласование" );
возврат п;
```
Документы.РеализацияТоваровУслуг.Создать
```
// Создает новый документ Реализация товаров и услуг по переданным параметрам
//
// Параметры:
// Структура параметров, полученная методом "Документы.РеализацияТоваровУслуг.Создать.Параметры"
//
// Возврат:
// Номер созданного заказа
Коммандос ( "e1cib/data/Документ.РеализацияТоваровУслуг" );
форма = Здесь ( "Реализация товаров и услуг (соз*" );
// *********************************************
// Заполнение шапки
// *********************************************
дата = _.Дата;
если ( дата <> неопределено ) тогда
Установить ( "!Дата", Формат ( дата, "DLF=DT" ) );
конецесли;
Установить ( "!Партнер", _.Покупатель );
Установить ( "!Организация", _.Организация );
значение = _.Склад;
если ( значение <> неопределено ) тогда
Установить ( "!Склад", значение );
конецесли;
значение = _.Комментарий;
если ( значение <> неопределено ) тогда
Установить ( "!Комментарий", значение );
конецесли;
// *********************************************
// Заполнение товаров
// *********************************************
таблица = Фокус ( "!Товары" );
никогда = Дата ( 1, 1, 1 );
для каждого товар из _.Товары цикл
Нажать ( "!ТоварыДобавить", таблица );
Установить ( "!ТоварыНоменклатура", товар.Товар );
Установить ( "!ТоварыКоличествоУпаковок", товар.Количество );
Очистить ( "!ТоварыВидЦены" );
Установить ( "!ТоварыЦена", товар.Цена );
согласование = товар.Согласование;
если ( согласование <> никогда ) тогда
Установить ( "!ТоварыДатаСогласования", Формат ( согласование, "DLF=D" ) );
конецесли;
конеццикла;
// *********************************************
// Запись документа, получение номера
// *********************************************
Нажать ( "!ФормаЗаписать" );
номер = Взять ( "!Номер" );
// *********************************************
// Проведение документа и возврат номера
// *********************************************
Нажать ( "!ФормаПровести" );
закрыть = не _.ОставитьОткрытым;
если ( закрыть ) тогда
Закрыть ();
конецесли;
возврат номер;
```
На этом, подготовка методов закончена.
### Создание теста ПродажаСДатойСогласования
Переходим к написанию конечного теста для второго этапа. Для этого, в дереве сценариев, создадим такой тест:
Сделаем его основным, и внесем следующий код:
```
// Сценарий:
// - Создадим окружение в результате которого будет существовать документ
// реализация с двумя товарами, для второго товара указана дата согласования
// - Откроем список реализаций
// - Найдем созданную реализацию и (пере)проведем её
// - Откроем регистр согласований и найдем там запись, которую должна была сделать реализация
// - Проверим правильность сформированной записи
Вызвать ( "Общее.Начало" );
ЗакрытьВсё ();
ид = "25C555B6";
тест = окружение ( ид );
создатьОкружение ( тест );
// ************************************
// Целевой сценарий
// ************************************
// Откроем реализации
Коммандос ( "e1cib/list/Документ.РеализацияТоваровУслуг" );
Здесь ( "Документы реализации" );
// Перейдем к нашему документу
Кстроке ( "!СписокРеализацииТоваровУслуг", "Клиент", тест.Покупатель );
// Проведем
Нажать ( "!СписокРеализацииТоваровУслугПровести" );
// Откроем регистр согласований
Коммандос ( "e1cib/list/РегистрСведений.Согласование" );
Здесь ( "Согласование" );
// Перейдем к записи
ок = Кстроке ( "!Список", "Клиент", тест.Покупатель );
если ( не ок ) тогда
Стоп ( "После проведения реализации не сформировались записи в регистре Согласование" );
конецесли;
// Проверим правильность сформированной записи.
// Выведем стандартный список
Нажать ( "!ФормаВывестиСписок" );
Здесь ( "Вывести список" );
// Включим флажок "Только выделенные"
было = Взять ( "!OnlySelectedElement" );
если ( было = "Нет" ) тогда
Нажать ( "!OnlySelectedElement" );
конецесли;
// Укажем, что выводить будем в табличный документ
Подобрать ( "!DocumentTypeElement", "Табличный документ" );
// Формируем мини-отчет
Нажать ( "!Ok" );
// Просим тестер проверить этот отчет
Здесь ( "Список" );
ПроверитьШаблон ( "" );
// *********************************************
// Процедуры
// *********************************************
Функция окружение ( ИД )
дата = ТекущаяДата ();
п = новый Структура ();
п.Вставить ( "ИД", ИД );
п.Вставить ( "Дата", дата );
п.Вставить ( "Согласование", ТекущаяДата () + 172800 ); // Через два дня
п.Вставить ( "ДатаПоступления", дата - 86400 );
п.Вставить ( "Поставщик", "Поставщик " + ИД );
п.Вставить ( "Покупатель", "Покупатель " + ИД );
п.Вставить ( "Склад", "Склад " + ИД );
п.Вставить ( "Товары", определитьТовары ( п ) );
возврат п;
КонецФункции
Функция определитьТовары ( Тест )
ид = Тест.ИД;
список = новый Массив ();
список.Добавить ( новыйТовар ( "Товар1 " + ид, 5, 150, 250 ) );
список.Добавить ( новыйТовар ( "Товар2 " + ид, 15, 250, 350, Тест.Согласование ) );
возврат список;
КонецФункции
Функция новыйТовар ( Товар, Количество, Стоимость, Цена, Согласование = неопределено )
п = новый Структура ();
п.Вставить ( "Товар", Товар );
п.Вставить ( "Количество", Количество );
п.Вставить ( "Стоимость", Стоимость );
п.Вставить ( "Цена", Цена );
п.Вставить ( "Согласование", Согласование );
возврат п;
КонецФункции
Процедура создатьОкружение ( Тест )
ид = Тест.ИД;
// *****************************************************
// Проверяем, нужно ли создавать данные для тестирования
// *****************************************************
если ( Вызвать ( "Общее.ОкружениеСоздано", ид ) ) тогда
возврат;
конецесли;
// ******************************************************************
// Проверим, чтобы в настройках были отключены соглашения с клиентами
// ******************************************************************
Коммандос ( "e1cib/command/Обработка.ПанельАдминистрированияУТ.Команда.Продажи" );
Здесь ( "Продажи" );
опция = Взять ( "!ИспользованиеСоглашенийСКлиентами" );
если ( опция <> "Не использовать" ) тогда
Стоп ( "В целях обучения, этап создания соглашений с клиентами в сценариях не предусмотрен.
|В окне, которые сейчас на экране с тестируемым приложением, откройте группу
|Оптовые продажи и в поле Использование соглашений с клиентами, выберите Не использовать" );
конецесли;
// ******************
// Создаем склад
// ******************
п = Вызвать ( "Справочники.Склады.Создать.Параметры" );
п.Наименование = Тест.Склад;
Вызвать ( "Справочники.Склады.Создать", п );
// ******************
// Создаем поставщика
// ******************
п = Вызвать ( "Справочники.Поставщики.Создать.Параметры" );
п.Наименование = Тест.Поставщик;
Вызвать ( "Справочники.Поставщики.Создать", п );
// ******************
// Создаем покупателя
// ******************
п = Вызвать ( "Справочники.Покупатели.Создать.Параметры" );
п.Наименование = Тест.Покупатель;
Вызвать ( "Справочники.Покупатели.Создать", п );
// **************
// Создаем товары
// **************
для каждого товар из Тест.Товары цикл
п = Вызвать ( "Справочники.Номенклатура.Создать.Параметры" );
п.Наименование = товар.Товар;
Вызвать ( "Справочники.Номенклатура.Создать", п );
конеццикла;
// *******************
// Создаем поступление
// *******************
товары = новый Массив ();
для каждого позиция из тест.Товары цикл
товар = Вызвать ( "Документы.ПоступлениеТоваровУслуг.Создать.Товар" );
товар.Товар = позиция.Товар;
товар.Количество = позиция.Количество;
товар.Цена = позиция.Стоимость;
товары.Добавить ( товар );
конеццикла;
п = Вызвать ( "Документы.ПоступлениеТоваровУслуг.Создать.Параметры" );
п.Товары = товары;
п.Дата = тест.ДатаПоступления;
п.Поставщик = тест.Поставщик;
п.Склад = тест.Склад;
Вызвать ( "Документы.ПоступлениеТоваровУслуг.Создать", п );
// *******************
// Создаем реализацию
// *******************
товары = новый Массив ();
для каждого позиция из тест.Товары цикл
товар = Вызвать ( "Документы.РеализацияТоваровУслуг.Создать.Товар" );
товар.Товар = позиция.Товар;
товар.Количество = позиция.Количество;
товар.Цена = позиция.Цена;
товар.Согласование = позиция.Согласование;
товары.Добавить ( товар );
конеццикла;
п = Вызвать ( "Документы.РеализацияТоваровУслуг.Создать.Параметры" );
п.Товары = товары;
п.Дата = тест.Дата;
п.Покупатель = тест.Покупатель;
п.Склад = тест.Склад;
Вызвать ( "Документы.РеализацияТоваровУслуг.Создать", п );
// ********************************
// Регистрируем созданное окружение
// ********************************
Вызвать ( "Общее.ШтампОкружения", ид );
КонецПроцедуры
```
Так как это наш главный сценарий для второго этапа, разберем его подробней.
Сценарий начинается с Вызвать ( "Общее.Начало" );. Я делаю этот вызов для задания глобальных переменных и выполнения общих задач перед началом работы любого теста. Посмотрим, что внутри теста Общее.Начало:
```
// Начальный скрипт для инициализации глобального окружения процесса тестирования
// В скрипте могут задаваться общие параметры, которые могут быть доступны во всех
// остальных сценариях
СтандартнаяОбработка = ложь;
если ( __ = неопределено ) тогда
__ = новый Структура ();
иначе
возврат;
конецесли;
// *************************************************************************
// Используем переменную "__" для задания произвольных глобальных параметров
// *************************************************************************
__.Вставить ( "ПроверятьЛогику", истина );
__.Вставить ( "ЛокальнаяВалюта", "РУБ" );
если ( ИмяПриложения = "УТ11" ) тогда
__.Вставить ( "Организация", "Торговый дом ""Комплексный""" );
конецесли;
// ***********************************************
// Выполняем подключение к тестируемому приложению
// ***********************************************
Подключить ();
```
Если вы используете демо-базу Тестера, тогда тест Общее.Начало там уже есть. Откройте этот тест и внесите в него изменения, в частности, нам нужна вот эта часть модуля:
```
если ( ИмяПриложения = "УТ11" ) тогда
__.Вставить ( "Организация", "Торговый дом ""Комплексный""" );
конецесли;
```
Работает это всё следующим образом. Когда тест ПродажаСДатойСогласования будет запущен, он в свою очередь запустит тест Общее.Начало, который определит несколько переменных и подключится к тестируемому приложению. Все тесты, которые будут запускаться дальше, уже будут знать, что в переменной “\_\_” хранится имя организации, локальная валюта и другие параметры. Это своего рода глобальное параметризирование тестируемой среды (использование двойного подчеркивания в качестве глобальной переменной выбрано для независимости от варианта языка 1С).
Затем, тест закрывает все окна в тестируемом приложении. Это нужно для того, чтобы случайно не активировать те формы, которые используется в процессе работы теста, но находятся в несогласованном с ним состоянии.
Следующие три строки определяют и создают окружение (см. [Структура сценария](#TestStructure)):
```
// Переменная "ид" задает идентификатор окружения.
// Идентификатор окружения может быть любой, но я рекомендую использовать
// указанный ниже шаблон алфавитно-цифровой последовательности,
// которая может быть автоматически сгенерирована в редакторе модуля
// по комбинации клавиш: Ctrl+Shit+I
// Таким образом, чтобы пересоздать окружение, нужно будет просто сменить "ид".
// Почему это так - будет понятно ниже.
ид = "25C555B6";
// В переменную "тест" функция окружение () вернет структуру с параметрами
// нашего теста. Эти параметры и есть определение окружения.
тест = окружение ( ид );
// Процедура создатьОкружение () выполняет создание необходимых тестовых данных.
// Внутри этой процедуры будут вызываться тесты-методы, которые мы создавали в разделах выше.
создатьОкружение ( тест );
```
Посмотрим, что происходит внутри функции окружение () :
```
Функция окружение ( ИД )
дата = ТекущаяДата ();
п = новый Структура ();
п.Вставить ( "ИД", ИД );
п.Вставить ( "Дата", дата );
п.Вставить ( "Согласование", ТекущаяДата () + 172800 ); // Через два дня
п.Вставить ( "ДатаПоступления", дата - 86400 );
п.Вставить ( "Поставщик", "Поставщик " + ИД );
п.Вставить ( "Покупатель", "Покупатель " + ИД );
п.Вставить ( "Склад", "Склад " + ИД );
п.Вставить ( "Товары", определитьТовары ( п ) );
возврат п;
КонецФункции
```
Ничего необычного, готовится структура с параметрами, но концептуальным является использование входящего параметра ИД.
Тестовые данные создаются, а значит, они должны быть уникальны. В противном случае, будут создаваться дубли объектов, которые практически, будет невозможно использовать. Действительно, если мы будем создавать “ТОО Ромашка" каждый раз, какую тогда "ТОО Ромашка" выбрать при создании документа? Таким образом, строки кода "Поставщик " + ИД, "Покупатель " + ИД и другие, гарантируют создание уникальных тестовых данных. Это также позволяет выполнять ваши тесты у других участников разработки, без синхронизации заготовленных шаблонов, использования предзаполненных баз данных и других внешних файлов.
Вероятно, данный подход вызывает недоумение, потому что база со временем превращается в месиво из ничего незначащих идентификаторов. Но на практике, любая база разработчика превращается в обрывки экспериментов из “порванных” данных, это лишь вопрос времени. Если вы в рабочих базах бережно храните некую информацию, на которую опирается ваша разработка – перенести эти данные в начальную базу. Если базы содержат ошибки для воспроизведения – напишите тесты, которые эти ошибки воспроизводят. Другими словами, если у вас в рабочей базе есть что-то ценное с прикладной точки зрения – напишите сценарий. Это высвободит вас от содержания хозяйства из информационных баз, даст возможность другим разработчикам проверить ваши варианты в их базах на любом этапе разработки. Весь полезный опыт, сосредоточенный в данных, лучше перевести в код сценария, что бы его всегда можно было повторить.
Другой, кажущийся тревожным момент – это глубина уникальности тестовых данных и их объем. И тут нужно отметить, что не все тестовые данные нужно делать уникальными. Уникальности требует только то, что вам нужно для тестирования (включая проверку бизнес логики). К примеру, для нашего теста нужна уникальность наименований поставщика, покупателя, склада и товаров. Нам не требуется уникальность единиц измерений, договоров, соглашений, групп товаров и других связанных данных. Рост данных также не будет проблемой. Даже если вы каждые 5 минут запускаете тест создающий окружение (что крайне маловероятно), то в течение дня таких запусков будет не больше 100, что для дневного роста базы ничтожно мало. На практике, необходимость в обнулении рабочей базы загрузкой в неё начальной, возникает примерно раз в полгода. Согласитесь, что программисты, тестирующие всё вручную, примерно с той же периодичностью выводят из строя свои рабочие базы.
Следующий участок кода, процедура создатьОкружение (). Внутри этой процедуры происходит создание тестовых данных. Создание окружения процесс не быстрый, но и не обязательный для каждого запуска сценария в процессе программирования задачи. Для того, чтобы окружение не создавалось каждый раз, можно использовать два подхода.
Первый – комментировать вызов процедуры создатьОкружение () после того, как оно однажды было создано. Однако со временем, это начинает утомлять.
Второй – вначале процедуры, проверять, было ли окружение уже создано, и если нет, в конце процедуры фиксировать факт его создания:
```
Процедура создатьОкружение ( Тест )
ид = Тест.ИД;
// *****************************************************
// Проверяем, нужно ли создавать данные для тестирования
// *****************************************************
если ( Вызвать ( "Общее.ОкружениеСоздано", ид ) ) тогда
возврат;
конецесли;
//...код создания окружения...
// ********************************
// Регистрируем созданное окружение
// ********************************
Вызвать ( "Общее.ШтампОкружения", ид );
КонецПроцедуры
```
Для хранения идентификатора созданного окружения можно использовать “простой” объект конфигурации, куда можно легко помещать и извлекать значения. Вот что происходит в библиотечном сценарии Общее.ОкружениеСоздано :
```
// Описание:
// По переданному ИД определяет было ли создано окружение
//
// Параметры:
// Строка, идентификатор окружения
//
// Возврат:
// Булево, истина - окружение уже создано, ложь - окружение еще не создано
Коммандос ( "e1cib/list/Справочник.Заметки" );
Здесь ( "Заметки" );
попытка
создано = КСтроке ( "!Список", "Тема", _ );
исключение
создано = ложь;
конецпопытки;
Закрыть ();
возврат создано;
```
Таким образом, в качестве объекта для хранения окружения используется справочник Заметки.
Примечание 1: Переход к строке сделан через попытку, потому что в версиях платформы <= 8.3.9 есть ошибка работы метода перехода к строке. В случае отсутствия искомой строки, платформа ошибочно генерирует исключение вместо возврата булевого значения.
Примечание 2: Данный подход к хранению идентификатора окружения не эстетичен, напрашивается более элегантное решение, например — хранение ИД внутри самого Тестера. К сожалению, не все описываемые решения пришли в один момент, это был долгий путь из проб и ошибок, который продолжается по сей день. Концепция работы с идентификаторами доказала свою пригодность, и я обязательно рассмотрю реализацию этого функционала на уровне конфигурации Тестер в обозримом будущем.
Остальная и основная часть процедуры создатьОкружение () содержит рутину по заполнению параметров и вызову сценариев-методов. Несмотря на простоту логики создания объектов, может потребоваться многократный запуск кода создания окружения при его разработке. В этом случае, запускать полный цикл теста может быть не эффективно. Одним из часто используемых трюков является временный вынос кода в начало основного сценария, с вставкой оператора возврат; до начала основного теста, например так:
```
Подключить ();
// Отлаживаем по-быстрому...
п = Вызвать ( "Справочники.Склады.Создать.Параметры" );
п.Наименование = "Тестовый склад";
Вызвать ( "Справочники.Склады.Создать", п );
возврат; // Когда отладим, вырежем этот код в тело процедуры создатьОкружение ()
// Сценарий:
// - Создадим окружение в результате которого будет существовать документ
// реализация с двумя товарами, для второго товара указана дата согласования
// - Откроем список реализаций
// - Найдем созданную реализацию и (пере)проведем её
// - Откроем регистр согласований и найдем там запись, которую должна была сделать реализация
// - Проверим правильность сформированной записи
Вызвать ( "Общее.Начало" );
ЗакрытьВсё ();
//....
```
Таким образом, кусок за куском логики можно отлаживать и переносить в процедуру создатьОкружение (). Обратите внимание, что для пересоздания всего окружения, вам просто нужно будет сменить ИД в начале теста.
Я описал определение и создание окружения, перейдем теперь к целевой части сценария ПродажаСДатойСогласования :
```
// Откроем реализации
Коммандос ( "e1cib/list/Документ.РеализацияТоваровУслуг" );
Здесь ( "Документы реализации" );
// Перейдем к нашему документу
Кстроке ( "!СписокРеализацииТоваровУслуг", "Клиент", тест.Покупатель );
// Проведем
Нажать ( "!СписокРеализацииТоваровУслугПровести" );
// Откроем регистр согласований
Коммандос ( "e1cib/list/РегистрСведений.Согласование" );
Здесь ( "Согласование" );
// Перейдем к записи
ок = Кстроке ( "!Список", "Клиент", тест.Покупатель );
если ( не ок ) тогда
Стоп ( "После проведения реализации не сформировались записи в регистре Согласование" );
конецесли;
// Проверим правильность сформированной записи.
// Выведем стандартный список
Нажать ( "!ФормаВывестиСписок" );
Здесь ( "Вывести список" );
// Включим флажок "Только выделенные"
было = Взять ( "!OnlySelectedElement" );
если ( было = "Нет" ) тогда
Нажать ( "!OnlySelectedElement" );
конецесли;
// Укажем, что выводить будем в табличный документ
Подобрать ( "!DocumentTypeElement", "Табличный документ" );
// Формируем мини-отчет
Нажать ( "!Ok" );
// Просим тестер проверить этот отчет
Здесь ( "Список" );
ПроверитьШаблон ( "" );
```
Последовательность шагов вполне очевидна, привлекает интерес часть кода проверки сформированных движений. Для этого используется стандартная функция платформы по выводу любого табличного поля в табличный документ:
```
Нажать ( "!ФормаВывестиСписок" );
Здесь ( "Вывести список" );
// и далее...
```
и возможность Тестера сравнивать табличный документ с макетом, сохраненным в сценарии:
```
Здесь ( "Список" );
ПроверитьШаблон ( "" );
```
На картинке совмещено для наглядности тестируемое приложение (находится выше) и Тестер (находится ниже). Как вы понимаете, я немного забежал вперед, шаблон сохраненный в Тестере был предварительно скопирован из тестируемого приложения, на момент готовности программного кода по формированию этих движений, но программированием второго рывка мы еще не занимались. Это вынужденная мера, мне нужно было логически завершить описание трех-структурного подхода к организации сценариев.
Если мы сейчас запустим сценарий на выполнение, он упадет на этапе создания окружения, ведь у нас кроме логики проведения, еще нет реквизита ДатаСогласования в табличной части Товары документа РеализацияТоваровУслуг.
Займемся программированием:
— Добавим нужный реквизит:
— Выведем на форму:
— В процедуру ОбработкаПроведения модуля объекта, добавим код:
```
Процедура ОбработкаПроведения(Отказ, РежимПроведения)
с = "
|выбрать Товары.Ссылка.Менеджер как Менеджер, Товары.Ссылка.Партнер как Клиент,
| Товары.Номенклатура как Товар, Товары.Количество как Количество, Товары.Сумма как Сумма,
| Товары.КодСтроки как Строка, Товары.ДатаСогласования как ДатаСогласования, &Ссылка как Реализация
|из Документ.РеализацияТоваровУслуг.Товары как Товары
| //
| // Согласованные
| //
| левое соединение РегистрСведений.Согласование как Согласованные
| по Согласованные.Строка = Товары.КодСтроки
|где Товары.Ссылка = &Ссылка
|и Товары.ДатаСогласования <> датавремя ( 1, 1, 1 )
|и не isnull ( Согласованные.Отработано, ложь )
|";
з = новый Запрос ( с );
з.УстановитьПараметр ( "Ссылка", Ссылка );
таблица = з.Выполнить ().Выгрузить ();
для каждого строка из таблица цикл
запись = РегистрыСведений.Согласование.СоздатьМенеджерЗаписи ();
ЗаполнитьЗначенияСвойств ( запись, строка );
запись.Записать ();
конеццикла;
//...далее идет типовой код конфигурации
```
Примечание: Чтобы оставаться в фарватере изложения, я опускаю некоторые детали реализации. Например, вы наверняка обратили внимание на отсутствие отработки ситуации удаления строки из табличной части, ранее которая была на согласовании.
Запускаем приложение, запускаем тест. После завершения теста, у вас должно получиться это:
Выделите в УТ11 этот макет и скопируйте в Тестер на вкладку Шаблон сценария ПродажаСДатойСогласования. Затем, в Тестере, выделите значимую область, вызовите правым кликом контекстное меню и укажите Отметить область:
Для того, чтобы шаблон не проверялся как есть, нам нужно его параметризировать. Для этого, в каждой ячейке, которая может меняться в зависимости от времени и условий запуска теста, в контекстном меню произведем замену значения на шаблон:
Проделаем так с каждым полем, чтобы получилась в итоге следующая картина:
Обратите внимание, что значения ячеек Количество и Сумма оставлены как есть. Это важно, потому что в отличие от предыдущих полей, которые могу изменяться в зависимости от идентификатора окружения, эта часть фиксированная, прописана в условии теста и должна быть гарантированно такой (более полный пример проверки бизнес логики см. [Проверка бизнес логики](http://www.test1c.com/#Businesslogic)).
Запускаем сценарий на выполнение и убеждаемся, что тест проходит успешно.
Переходим к следующему запланированному этапу.
### Этап 3
В этом рывке нам нужно разработать форму списка для регистра Согласование с фильтрами по клиенту, товару и менеджеру.
В таблице ниже состыкуем работу по кодированию и тестированию:
| Программирование | Тестирование |
| --- | --- |
| В Конфигураторе: 1. Добавляем форму списка в регистр сведений Согласование
2. Создаем три реквизита формы соответствующих типов, выкладываем их на форму
3. Настраиваем свойства и обработчики
4. Прописываем код обработчиков фильтрации
| В Тестере:
Создадим тест ФильтрацияСписка, где:1. Определим окружение:
1. Наименование Поставщика
2. Наименование Покупателя
3. Наименование Потенциального клиента, по которому продаж нет
4. Товар с датой согласования
2. Создадим окружение
1. Создадим поставщика, покупателей и товар
2. Сделаем поступление
3. Создадим и проведем реализацию
3. Целевая часть
1. Откроем список регистра Согласование
2. Установим отбор по покупателю, проверим список
3. Установим отбор по потенциальному клиенту, проверим пустой список
4. Установим/снимем отборы по товару и менеджеру
|
Для разнообразия, в этот раз начнем с программирования, а затем напишем тест.
=============================================================================
— Добавим основную форму списка, добавим реквизиты формы, расположим на форме:
— В модуле формы списка, определим обработчики полей фильтрации:
```
&НаКлиенте
Процедура КлиентФильтрПриИзменении ( Элемент )
ОбщегоНазначенияКлиентСервер.УстановитьЭлементОтбораДинамическогоСписка(Список,
"Клиент",
КлиентФильтр,
ВидСравненияКомпоновкиДанных.Равно,
,
ЗначениеЗаполнено(КлиентФильтр));
КонецПроцедуры
&НаКлиенте
Процедура ТоварФильтрПриИзменении ( Элемент )
ОбщегоНазначенияКлиентСервер.УстановитьЭлементОтбораДинамическогоСписка(Список,
"Товар",
ТоварФильтр,
ВидСравненияКомпоновкиДанных.Равно,
,
ЗначениеЗаполнено(ТоварФильтр));
КонецПроцедуры
&НаКлиенте
Процедура МенеджерФильтрПриИзменении ( Элемент )
ОбщегоНазначенияКлиентСервер.УстановитьЭлементОтбораДинамическогоСписка(Список,
"Менеджер",
МенеджерФильтр,
ВидСравненияКомпоновкиДанных.Равно,
,
ЗначениеЗаполнено(МенеджерФильтр));
КонецПроцедуры
```
На этом этапе с программированием всё. Перейдем к разработке теста. Для этого, как и в прошлые разы, в дереве сценариев, создадим новый сценарий. Установим этот сценарий основным, и назовем его ФильтрацияСписка :
Введем следующий код сценария:
```
// Сценарий:
// - Создадим окружение в результате которого будет существовать проведенный документ
// реализация с товаром, для которого указана дата согласования
// - Откроем список Согласование
// - Установим отбор по покупателю, убедимся, что в списке есть отфильтрованная запись
// - Установим отбор по потенциальному клиенту, убедимся, что список пуст
// - Очистим фильтры по товару и менеджеру, проверим что они отрабатывают,
// допускаем, что если нет ошибок тогда фильтрация происходит
Вызвать ( "Общее.Начало" );
ЗакрытьВсё ();
ид = "25CB69CB";
тест = окружение ( ид );
создатьОкружение ( тест );
// ************************************
// Целевой сценарий
// ************************************
// Откроем регистр согласований
Коммандос ( "e1cib/list/РегистрСведений.Согласование" );
Здесь ( "Согласование" );
// Установим фильтр по покупателю
покупатель = тест.Покупатель;
Ввести ( "!КлиентФильтр", покупатель );
// Найдем его в списке
ок = Кстроке ( "!Список", "Клиент", покупатель );
если ( не ок ) тогда
Стоп ( "В списке не найдена отфильтрованная по клиенту запись" );
конецесли;
// Установим фильтр по потенциальному клиенту
Ввести ( "!КлиентФильтр", тест.ПотенциальныйКлиент );
// Список должен быть пустой
пусто = 0 = Вызвать ( "Таблица.Количество", Получить ( "!Список" ) );
если ( не пусто ) тогда
Стоп ( "Список должен быть пуст" );
конецесли;
Очистить ( "!КлиентФильтр" );
// Установим и очистим фильтр по товару
Ввести ( "!ТоварФильтр", тест.Товары [ 0 ].Товар );
Очистить ( "!ТоварФильтр" );
// Очистим фильтр по менеджеру
Очистить ( "!МенеджерФильтр" );
// *********************************************
// Процедуры
// *********************************************
Функция окружение ( ИД )
дата = ТекущаяДата ();
п = новый Структура ();
п.Вставить ( "ИД", ИД );
п.Вставить ( "Дата", дата );
п.Вставить ( "Согласование", дата + 172800 ); // Через два дня
п.Вставить ( "ДатаПоступления", дата - 86400 );
п.Вставить ( "Поставщик", "Поставщик " + ИД );
п.Вставить ( "Покупатель", "Покупатель " + ИД );
п.Вставить ( "ПотенциальныйКлиент", "Потенциальный клиент " + ИД );
п.Вставить ( "Склад", "Склад " + ИД );
п.Вставить ( "Товары", определитьТовары ( п ) );
возврат п;
КонецФункции
Функция определитьТовары ( Тест )
ид = Тест.ИД;
список = новый Массив ();
список.Добавить ( новыйТовар ( "Товар1 " + ид, 15, 250, 350, Тест.Согласование ) );
возврат список;
КонецФункции
Функция новыйТовар ( Товар, Количество, Стоимость, Цена, Согласование = неопределено )
п = новый Структура ();
п.Вставить ( "Товар", Товар );
п.Вставить ( "Количество", Количество );
п.Вставить ( "Стоимость", Стоимость );
п.Вставить ( "Цена", Цена );
п.Вставить ( "Согласование", Согласование );
возврат п;
КонецФункции
Процедура создатьОкружение ( Тест )
ид = Тест.ИД;
// *****************************************************
// Проверяем, нужно ли создавать данные для тестирования
// *****************************************************
если ( Вызвать ( "Общее.ОкружениеСоздано", ид ) ) тогда
возврат;
конецесли;
// ******************
// Создаем склад
// ******************
п = Вызвать ( "Справочники.Склады.Создать.Параметры" );
п.Наименование = Тест.Склад;
Вызвать ( "Справочники.Склады.Создать", п );
// ******************
// Создаем поставщика
// ******************
п = Вызвать ( "Справочники.Поставщики.Создать.Параметры" );
п.Наименование = Тест.Поставщик;
Вызвать ( "Справочники.Поставщики.Создать", п );
// *******************
// Создаем покупателей
// *******************
п = Вызвать ( "Справочники.Покупатели.Создать.Параметры" );
п.Наименование = Тест.Покупатель;
Вызвать ( "Справочники.Покупатели.Создать", п );
п.Наименование = Тест.ПотенциальныйКлиент;
Вызвать ( "Справочники.Покупатели.Создать", п );
// **************
// Создаем товары
// **************
для каждого товар из Тест.Товары цикл
п = Вызвать ( "Справочники.Номенклатура.Создать.Параметры" );
п.Наименование = товар.Товар;
Вызвать ( "Справочники.Номенклатура.Создать", п );
конеццикла;
// *******************
// Создаем поступление
// *******************
товары = новый Массив ();
для каждого позиция из тест.Товары цикл
товар = Вызвать ( "Документы.ПоступлениеТоваровУслуг.Создать.Товар" );
товар.Товар = позиция.Товар;
товар.Количество = позиция.Количество;
товар.Цена = позиция.Стоимость;
товары.Добавить ( товар );
конеццикла;
п = Вызвать ( "Документы.ПоступлениеТоваровУслуг.Создать.Параметры" );
п.Товары = товары;
п.Дата = тест.ДатаПоступления;
п.Поставщик = тест.Поставщик;
п.Склад = тест.Склад;
Вызвать ( "Документы.ПоступлениеТоваровУслуг.Создать", п );
// *******************
// Создаем реализацию
// *******************
товары = новый Массив ();
для каждого позиция из тест.Товары цикл
товар = Вызвать ( "Документы.РеализацияТоваровУслуг.Создать.Товар" );
товар.Товар = позиция.Товар;
товар.Количество = позиция.Количество;
товар.Цена = позиция.Цена;
товар.Согласование = позиция.Согласование;
товары.Добавить ( товар );
конеццикла;
п = Вызвать ( "Документы.РеализацияТоваровУслуг.Создать.Параметры" );
п.Товары = товары;
п.Дата = тест.Дата;
п.Покупатель = тест.Покупатель;
п.Склад = тест.Склад;
Вызвать ( "Документы.РеализацияТоваровУслуг.Создать", п );
// ********************************
// Регистрируем созданное окружение
// ********************************
Вызвать ( "Общее.ШтампОкружения", ид );
КонецПроцедуры
```
Комментарии по коду теста:
1. Фактически, этот сценарий является упрощенной версией сценария, который мы создали на предыдущем этапе.
2. Я опустил в этом сценарии проверку настройки соглашений с клиентами, в реальном проекте вы эту настройку выделите в отдельный тест проверки окружения и не будете включать в каждый ваш тест.
3. В этом сценарии используется библиотечный тест Вызвать ( "Таблица.Количество", Получить ( "! Список" ) ). Хороший пример того, как можно общую логику по работе с объектами системы выделять в отдельные тесты.
4. Чистого времени на разработку этого теста, у освоившего Тестер программиста уходит до 7 минут.
5. Не стесняйтесь копировать сценарии, всё-таки код сценария не совсем тоже самое, что код решения. Во многих случаях, лучше не злоупотреблять возможностью организации в тестах изощренных зависимостей ради ухода от повторения кода. Ведь тесты падают и время на анализ “почему?” тоже нужно брать в расчет. При сложных зависимостях, это будет сделать не просто (хотя полный стек ошибок и отладчик в Тестере есть).
6. При копировании тестов не забывайте менять идентификатор окружения.
Запустите тест, он должен пройти без ошибок. Этот этап готов, идем дальше.
### Этап 4
На этом этапе нам нужно разработать форму редактирования записи для регистра Согласование. Форма для редактирования нужна пользователю для фиксации результатов переговоров с заказчиком (условия задачи были описаны [здесь](#Task)).
В таблице ниже состыкуем работу по кодированию и тестированию:
| Программирование | Тестирование |
| --- | --- |
| В Конфигураторе: 1. Добавляем форму записи в регистр сведений Согласование
2. Формируем внешний вид
3. Пишем логику работы формы
| В Тестере:
Создадим тест РедактированиеФормыСогласования, где:1. Определим окружение:
1. Наименование Поставщика
2. Наименование Покупателя
3. Товар с датой согласования
2. Создадим окружение
1. Создадим поставщика, покупателя и товар
2. Сделаем поступление
3. Создадим и проведем реализацию
3. Целевая часть
1. Откроем список регистра Согласование
2. Установим отбор по покупателю и откроем единственную в списке запись
3. Убедимся, что поле Комментарий недоступно для редактирования
4. Нажмем галку Отработано, убедимся, что поле Комментарий теперь доступно.
5. Сохраним и закроем форму
6. Откроем её еще раз и убедимся, что поле Комментарий доступно
7. Снимем галку Отработано, затем опять включим и убедимся, что поле Комментарий очищено
8. Попробуем в списке создать новую запись
9. Проверим, получил ли пользователь предупреждение о запрете на непосредственный ввод записей в регистр
|
Этот рывок будем делать комбинированно. Начнем с создания макета формы, в конфигураторе, создадим такую запись регистра:
Запустим приложение. Переключимся в Тестер, и в дереве сценариев создадим и зададим как основной тест РедактированиеФормыСогласования:
И введем такой код:
```
// Сценарий:
// - Создадим окружение в результате которого будет существовать проведенный документ
// реализация с товаром, для которого указана дата согласования
// - Откроем список регистра Согласование
// - Установим отбор по покупателю и откроем единственную в списке запись
// - Убедимся, что поле Комментарий недоступно для редактирования (условия задачи были описаны здесь)
// - Нажмем галку Отработано, убедимся, что поле Комментарий теперь доступно.
// - Сохраним и закроем форму
// - Откроем её еще раз и убедимся, что поле Комментарий доступно
// - Снимем галку Отработано, затем опять включим и убедимся, что поле Комментарий очищено
// - Попробуем в списке создать новую запись
// - Проверим, получил ли пользователь предупреждение о запрете на непосредственный ввод записей в регистр
Вызвать ( "Общее.Начало" );
ЗакрытьВсё ();
ид = "25CB8B15";
тест = окружение ( ид );
создатьОкружение ( тест );
// ************************************
// Целевой сценарий
// ************************************
// Откроем регистр согласований
Коммандос ( "e1cib/list/РегистрСведений.Согласование" );
список = Здесь ( "Согласование" );
// Установим фильтр по покупателю
покупатель = тест.Покупатель;
Ввести ( "!КлиентФильтр", покупатель );
// Найдем его в списке
Кстроке ( "!Список", "Клиент", покупатель );
// Откроем запись
Нажать ( "!ФормаИзменить" );
Здесь ( Приложение.ПолучитьАктивноеОкно ().ПолучитьОбъект () );
// Проверим, что с галкой, может с прошлого раза осталась включенной
если ( "Да" = Взять ( "!Отработано" ) ) тогда
Нажать ( "!Отработано" ); // выключим шалку
конецесли;
// Комментарий должен быть недоступен
ПроверитьСтатус ( "!Комментарий", "Доступность", ложь );
// Жмем галку Отработано
Нажать ( "!Отработано" );
// Комментарий должен быть доступен
ПроверитьСтатус ( "!Комментарий", "Доступность" );
// Вводим что-то в комментарий
Установить ( "!Комментарий", "Тестовый комментарий" );
// Нажимаем Записать и закрыть
Нажать ( "!ФормаЗаписатьИЗакрыть" );
// Возвращаемся в список и опять открываем эту запись
Здесь ( список );
Нажать ( "!ФормаИзменить" );
Здесь ( Приложение.ПолучитьАктивноеОкно ().ПолучитьОбъект () );
// Комментарий должен быть доступен
ПроверитьСтатус ( "!Комментарий", "Доступность" );
// Снимаем галку Отработано и устанавливаем заново
Нажать ( "!Отработано" );
Нажать ( "!Отработано" );
// Комментарий должен быть очищен
Проверить ( "!Комментарий", "" );
Нажать ( "!ФормаЗаписатьИЗакрыть" );
// Закроем форму, вернемся в список и попробуем ввести новую запись
Здесь ( список );
Нажать ( "!ФормаСоздать" );
// Проверим обязательное наличие сообщения об ошибке
если ( НайтиСообщения ( "*формируются автоматически*" ).Количество () = 0 ) тогда
Стоп ( "Отсутствует сообщение об ошибке" );
конецесли;
Закрыть ();
// *********************************************
// Процедуры
// *********************************************
Функция окружение ( ИД )
дата = ТекущаяДата ();
п = новый Структура ();
п.Вставить ( "ИД", ИД );
п.Вставить ( "Дата", дата );
п.Вставить ( "Согласование", дата + 172800 ); // Через два дня
п.Вставить ( "ДатаПоступления", дата - 86400 );
п.Вставить ( "Поставщик", "Поставщик " + ИД );
п.Вставить ( "Покупатель", "Покупатель " + ИД );
п.Вставить ( "Склад", "Склад " + ИД );
п.Вставить ( "Товары", определитьТовары ( п ) );
возврат п;
КонецФункции
Функция определитьТовары ( Тест )
ид = Тест.ИД;
список = новый Массив ();
список.Добавить ( новыйТовар ( "Товар1 " + ид, 15, 250, 350, Тест.Согласование ) );
возврат список;
КонецФункции
Функция новыйТовар ( Товар, Количество, Стоимость, Цена, Согласование = неопределено )
п = новый Структура ();
п.Вставить ( "Товар", Товар );
п.Вставить ( "Количество", Количество );
п.Вставить ( "Стоимость", Стоимость );
п.Вставить ( "Цена", Цена );
п.Вставить ( "Согласование", Согласование );
возврат п;
КонецФункции
Процедура создатьОкружение ( Тест )
ид = Тест.ИД;
// *****************************************************
// Проверяем, нужно ли создавать данные для тестирования
// *****************************************************
если ( Вызвать ( "Общее.ОкружениеСоздано", ид ) ) тогда
возврат;
конецесли;
// ******************
// Создаем склад
// ******************
п = Вызвать ( "Справочники.Склады.Создать.Параметры" );
п.Наименование = Тест.Склад;
Вызвать ( "Справочники.Склады.Создать", п );
// ******************
// Создаем поставщика
// ******************
п = Вызвать ( "Справочники.Поставщики.Создать.Параметры" );
п.Наименование = Тест.Поставщик;
Вызвать ( "Справочники.Поставщики.Создать", п );
// *******************
// Создаем покупателей
// *******************
п = Вызвать ( "Справочники.Покупатели.Создать.Параметры" );
п.Наименование = Тест.Покупатель;
Вызвать ( "Справочники.Покупатели.Создать", п );
// **************
// Создаем товары
// **************
для каждого товар из Тест.Товары цикл
п = Вызвать ( "Справочники.Номенклатура.Создать.Параметры" );
п.Наименование = товар.Товар;
Вызвать ( "Справочники.Номенклатура.Создать", п );
конеццикла;
// *******************
// Создаем поступление
// *******************
товары = новый Массив ();
для каждого позиция из тест.Товары цикл
товар = Вызвать ( "Документы.ПоступлениеТоваровУслуг.Создать.Товар" );
товар.Товар = позиция.Товар;
товар.Количество = позиция.Количество;
товар.Цена = позиция.Стоимость;
товары.Добавить ( товар );
конеццикла;
п = Вызвать ( "Документы.ПоступлениеТоваровУслуг.Создать.Параметры" );
п.Товары = товары;
п.Дата = тест.ДатаПоступления;
п.Поставщик = тест.Поставщик;
п.Склад = тест.Склад;
Вызвать ( "Документы.ПоступлениеТоваровУслуг.Создать", п );
// *******************
// Создаем реализацию
// *******************
товары = новый Массив ();
для каждого позиция из тест.Товары цикл
товар = Вызвать ( "Документы.РеализацияТоваровУслуг.Создать.Товар" );
товар.Товар = позиция.Товар;
товар.Количество = позиция.Количество;
товар.Цена = позиция.Цена;
товар.Согласование = позиция.Согласование;
товары.Добавить ( товар );
конеццикла;
п = Вызвать ( "Документы.РеализацияТоваровУслуг.Создать.Параметры" );
п.Товары = товары;
п.Дата = тест.Дата;
п.Покупатель = тест.Покупатель;
п.Склад = тест.Склад;
Вызвать ( "Документы.РеализацияТоваровУслуг.Создать", п );
// ********************************
// Регистрируем созданное окружение
// ********************************
Вызвать ( "Общее.ШтампОкружения", ид );
КонецПроцедуры
```
Комментарии по коду сценария:
1. Этот тест был создан путем копирования предыдущего, окружение практически не модифицировалось, я убрал создание потенциального клиента
2. Может вызвать интерес такая строка кода: Здесь ( Приложение.ПолучитьАктивноеОкно ().ПолучитьОбъект () );. В данном случае показан пример работы с тестируемым приложением через стандартные методы платформы. В переменной Приложение, Тестер хранит объект ТестируемоеПриложение, через который можно вызывать все остальные методы платформы в режиме клиента тестирования (подробнее см. [API Тестера](http://www.test1c.com/#Modules)).
Итак, запускаем тест и убеждаемся, что он падает, так как у нас не реализована логика работы формы. Далее, возвращаемся в конфигуратор, переключаемся в модуль формы записи и вводим такой код:
```
// *****************************************
// *********** События формы
&НаСервере
Процедура ПриЧтенииНаСервере ( ТекущийОбъект )
оформить ();
КонецПроцедуры
&НаСервере
Процедура оформить ( Зависимость = неопределено )
если ( Зависимость = неопределено или есть ( Зависимость, "Отработано" ) ) тогда
Элементы.Комментарий.Доступность = Запись.Отработано;
конецесли;
КонецПроцедуры
&НаСервере
Функция есть ( Зависимость, Список )
возврат СтрРазделить ( Список, "," ).Найти ( Зависимость ) <> неопределено;
КонецФункции
&НаСервере
Процедура ПриСозданииНаСервере ( Отказ, СтандартнаяОбработка )
если ( Запись.ИсходныйКлючЗаписи.Пустой () ) тогда
ошибка ();
Отказ = истина;
конецесли;
КонецПроцедуры
&НаСервере
Функция ошибка ()
Сообщить ( Нстр ( "ru = 'Записи в данном регистре формируются автоматически, при проведении документа Реализация товаров и услуг'" ) );
КонецФункции
// *****************************************
// *********** Группа Форма
&НаКлиенте
Процедура ОтработаноПриИзменении ( Элемент )
применитьОтработано ();
оформить ( "Отработано" );
КонецПроцедуры
&НаКлиенте
Процедура применитьОтработано ()
если ( не Запись.Отработано ) тогда
Запись.Комментарий = "";
конецесли;
КонецПроцедуры
```
Затем, переключимся в форму и зададим обработчики событий: ПриЧтенииНаСервере, ПриСозданииНаСервере, ОтработаноПриИзменении. Запустите приложение, запустите тест и убедитесь, что он проходит.
Заключение
----------
Мы рассмотрели теоретическую и практическую части применения системы Тестер для организации работы программиста через тестирование управляемого кодом клиентского приложения. Многие выкладки можно найти спорными и даже прямо противоположными учениям авторитетов в области построения процессов тестирования. Не вопреки, а с осознанием этого, готовился данный материал. Основной целью было показать практическое применение методики и средств сценарного тестирования.
Я допускаю, что в каждом разработанном сценарии, кто-то найдет “перебор” по части объема тестируемого функционала, а кто-то “недобор”. Мне остается лишь надеяться, что в этой статье был достигнут баланс между всем надоевшей простотой и малоинтересной сложностью. Не менее важной задачей, было показать, как можно вживить в разработку автоматизированное сценарное тестирование, чтобы оно не казалось аппендиксом или очередной надстройкой над сущностью программирования.
Большое спасибо, что не оставили без внимания этот труд. Удачных вам тестов, друзья!
|
https://habr.com/ru/post/331532/
| null |
ru
| null |
# Почему разметка должна быть не только валидной, но и логичной. Пример из жизни
Я работаю в веб-студии, постоянно пользующейся услугами верстальщиков-фрилансеров. И если несколько лет назад верстальщики частенько присылали код, пестревший ошибками разметки, то сейчас это уже большая редкость. К сожалению совсем другая картина с логикой разметки, автоматического валидатора которой, насколько мне известно, пока нет. В надежде, привлечь внимание верстальщиков к этой стороне их работы, хочу рассказать о недавнем случае, показывающем, что логичность разметки не менее важна чем её валидность.
А дело было так. Заказчик захотел чтобы на сайте были «красивые» поля ввода в формах. Верстальщик применил для этого скрипт [custom-form-elements.js](http://ryanfait.com/resources/custom-checkboxes-and-radio-buttons/). Однако, когда вёрстку установили на CMS, выяснилось, что в некоторых браузерах, к примеру в FireFox, для изменения состояния чек-боксов требуется двойной клик, а не одинарный, как обычно. Программист, занимавшийся сайтом, первым делом заподозрил custom-form-elements.js. Другой скрипт аналогичного назначения проблему с чек-боксами решил, но не подошёл по другим соображениям. Программист занялся отладкой первого скрипта. Когда это ничего не дало, он обратился ко мне. Я тоже начал с отладки скрипта и обнаружил, что обработчик «onclick» мистическим образом вызывается дважды. Тогда я решил взглянуть на разметку, и вот что увидел:
`|
Машина в кредит: |
|`
Обратите внимание на выделенный label. Скрипт custom-form-elements.js скрывает input с классом «styled» и ставит перед ним span «изображающий» из себя чек-бокс. При клике по span custom-form-elements.js изменяет состояние скрытого input. Но помимо span событие, порождённое этим же кликом, передаётся и обрамляющему span элементу label. Который [транслирует это событие первому вложенному в него input-у](http://www.w3.org/TR/html5/forms.html#the-label-element). Таким образом состояние чек-бокса меняется дважды — один раз JS, второй — браузером, что и приводит к описанной проблеме. При всём при этом, label здесь совершенно не нужен, т. к. собственно метки (подписи) он и не содержит. Подпись размещается совсем в другом теге label.
Если бы верстальщик следовал логике, он бы не обернул этот input в label, скрипт custom-form-elements.js отработал бы правильно и ни программист, ни сам верстальщик не тратили бы лишнее время на устранение проблемы с чек-боксами.
|
https://habr.com/ru/post/37345/
| null |
ru
| null |
# Руководство по выживанию с MongoDB
Все хорошие стартапы либо быстро умирают, либо дорастают до необходимости масштабироваться. Мы смоделируем такой стартап, который сначала про фичи, а потом про перфоманс. Перфоманс будем улучшать с MongoDB — это популярное NoSQL-решение для хранения данных. С MongoDB легко стартовать, и многие проблемы имеют решения «из коробки». Однако, когда нагрузка растет, вылезают грабли, о которых вас заранее никто не предупреждал… до сегодняшнего дня!
Моделирование проводит **Сергей Загурский**, который отвечает за инфраструктуру бэкенда вообще, и MongoDB в частности, в [Joom](https://habr.com/ru/company/joom/). Также был замечен в серверной части разработки MMORPG Skyforge. Как сам себя описывает Сергей — «профессиональный набиватель шишек собственным лбом и граблями». Под микроскопом — проект, который использует стратегию накопления для управления техническими долгом. В этой текстовой версии [доклада](https://youtu.be/j6TVaEk4x2U) на HighLoad++ будем двигаться в хронологическом порядке от возникновения проблемы до решения с помощью MongoDB.
Первые сложности
----------------
Мы моделируем стартап, который набивает шишки. Первый этап жизни — в наш стартап запускаются фичи и, неожиданно, приходят пользователи. На наш маленький-маленький MongoDB-сервер сваливается нагрузка, о которой мы даже не мечтали. Но мы же в облаке, мы же стартап! Мы делаем самые простые вещи из возможных: смотрим запросы — ой, а у нас тут вся коррекция вычитывается для каждого пользователя, тут индексы построим, там железа добавим, а здесь закэшируем.
Всё — живем дальше!
> Если проблемы можно решить подобными простыми средствами — их так и надо решать.
А вот дальнейший путь успешного стартапа — это медленное, мучительное оттягивание момента горизонтального масштабирования. Попытаюсь дать советы, как пережить этот период, добраться до масштабирования и не наступить на грабли.
Медленная запись
----------------
Это одна из проблем, с которой можно столкнуться. Что делать, если вы её повстречали, а методы выше не помогают? Ответ: **режим гарантии** **durability** **в MongoDB по умолчанию**. В трех словах он устроен так:
* Мы пришли на primary реплику и сказали: «Пиши!».
* Primary реплика записала.
* После этого с нее прочитали secondary реплики и сказали primary: «Мы записали!».
В тот момент, когда большинство secondary реплик это сделали, запрос считается выполненным и управление возвращается в драйвер в приложении. Такие гарантии позволяют быть уверенными, что когда управление вернулось в приложение,durability никуда не денется, даже если MongoDB ляжет, кроме совсем уже страшных катастроф.
> К счастью, MongoDB — это такая БД, которая позволяет уменьшать гарантии durability на каждый отдельный запрос.
Для важных запросов мы можем оставить максимальные гарантии durability по умолчанию, а для некоторых запросов — уменьшить.
### Классы запросов
Первый слой гарантий, который мы можем снять — **не ждать подтверждение записи большинством реплик**. Это сэкономит latency, но никак не добавит пропускной способности. Но иногда latency — это то, что нужно, особенно, если кластер чуть перегружен и secondary реплики работают не так быстро, как хотелось бы.
```
{w:1, j:true}
```
Если мы пишем записи с такими гарантиями, то в момент, когда получаем управление в приложение, уже не знаем, будет ли запись жива после какой-то аварии. Но, обычно, она все-таки жива.
Следующая гарантия, которая влияет на пропускную способность и на latency тоже — это **отключение подтверждения записи в журнал**. Запись в журнал пишется в любом случае. Журнал — один из основополагающих механизмов. Если мы отключаем подтверждение записи в него, то не делаем две вещи: [**fsync**](https://docs.mongodb.com/manual/reference/command/fsync/) **на журнале** и **не ждем, когда он закончится**. Этим можно хорошо **сэкономить ресурсы дисковой системы** и получить **кратный прирост пропускной способности**, просто поменяв durability гарантии.
```
{w:1, j:false}
```
Самые «жёсткие» гарантии durability — это **отключение любых подтверждений**. Мы получим только подтверждение, что запрос дошел до primary реплики. Это сэкономит latency и никак не увеличит пропускную способность.
```
{w:0, j:false} — отключаем любые подтверждения.
```
Мы также получим разные другие вещи, например, запись не прошла из-за конфликта с уникальным ключом.
### К каким операциям это применимо?
Расскажу про применение к сетапу в Joom. Кроме нагрузки от пользователей, в которой нет никаких послаблений durability, есть нагрузка, которую можно описать как фоновую batch-нагрузку: обновление, пересчет рейтингов, сбор данных аналитики.
Эти фоновые операции могут проходить часами, но разработаны так, что при обрыве, например, падения бэкенда, они не потеряют результат всей своей работы, а возобновятся с точки в недавнем прошлом. Для подобных задач уменьшение гарантии durability полезно, тем более, что fsync в журнал, как и любые другие операции, будут увеличивать latency также на чтение.
Масштабирование чтения
----------------------
Следующая проблема — это **недостаточная пропускная способность по чтению**. Вспомним, что у нас в кластере есть не только primary реплики, а еще и secondary, **из которых можно читать**. Давайте так и сделаем.
Читать можно, но есть нюансы. Из secondary реплик будут приходить немного устаревшие данные — на 0,5–1 секунды. В большинстве случаев это нормально, но поведение secondary реплики отличается от поведения primary реплик.
На secondary есть процесс применения oplog, которого нет на primary реплике. Этот процесс не то, чтобы разработан под низкую latency — просто разработчики MongoDB на этом не заморачивались. При некоторых условиях процесс применения oplog с первичной на secondary может давать задержки до 10 с.
> Для пользовательских запросов secondary реплики не подходят — user experiences бодрым шагом идёт в мусорное ведро.
На нешардированных кластерах это спайки заметны меньше, но все равно есть. Шардированные кластеры страдают, потому что на применение oplog особенно сильно влияет удаление, а **удаление — это часть работы балансировщика**. Балансировщик смачно, со вкусом удаляет документы десятками тысяч за короткий промежуток времени.
Количество соединений
---------------------
Следующий фактор для размышлений — **ограничение по количеству соединений на инстансах MongoDB**. По умолчанию никаких ограничений нет, **кроме ресурсов ОС —** можно подключаться пока она разрешает.
Однако, чем больше параллельных конкурентных запросов, тем медленнее они выполняются. **Производительность деградирует нелинейно**. Поэтому, если к нам прилетел спайк запросов, лучше обслужить 80%, чем не обслужить 100%. Количество соединений нужно ограничить непосредственно на MongoDB.
Но есть баги, которые могут из-за этого доставить неприятности. В частности, **connection pool на стороне MongoDB общий как для пользовательских, так и для служебных внутрикластерных подключений**. Если приложение «съело» все соединения из этого пула, то в кластере может нарушиться целостность.
Мы узнали об этом, когда собирались перестроить индекс, а так как нам нужно было снять с индекса уникальность, то процедура проходила в несколько этапов. В MongoDB нельзя построить рядом с индексом такой же, но без уникальности. Поэтому мы хотели:
* построить похожий индекс без уникальности;
* удалить индекс с уникальностью;
* построить индекс без уникальности вместо удаленного;
* удалить временный.
Когда временный индекс еще достраивали на secondary, мы начали удалять уникальный индекс. В этот момент secondary MongoDB объявило о своей блокировке. Какие-то метаданные заблокировались, и в majority остановились все записи: они висели в [connection pool](https://en.wikipedia.org/wiki/Connection_pool) и ждали, пока им подтвердят, что запись прошла. Все чтения на secondary тоже остановились, потому что был захвачен глобальный log.
Кластер в таком интересном состоянии еще и потерял связанность. Иногда она появлялась и когда две реплики друг с другом соединялись, они пытались провести в своем состоянии выбор, который провести не могли, потому что у них глобальная блокировка.
> Мораль истории: за количеством соединений надо следить.
Есть известная грабля MongoDB, на которую все равно настолько часто наступают, что я решил коротко по ней пройтись.
Не теряем документы
-------------------
Если в MongoDB отправить запрос по индексу, то **запрос может вернуть не все документы**, которые удовлетворяют условию, причем в совершенно неожиданных случаях. Это связано с тем, что когда мы идем по началу индекса, документ, который в конце, перемещается в начало за те документы, что мы прошли. Это связано исключительно **с мутабельностью индекса**. Для надежной итерации применяйте **индексы по немутабельным полям** и сложностей не будет.
MongoDB имеет свои виды на то, какие индексы использовать. Решается просто — **с помощью $hint в обязательном порядке заставляем MongoDB использовать индекс, который указали**.
Размеры коллекций
-----------------
Наш стартап развивается, данных становится много, но не хочется добавлять диски — уже добавляли три раза за последний месяц. Давайте посмотрим, что хранится у нас в данных, посмотрим на размеры документов. Как понять, где в коллекции можно уменьшить размер? По двум параметрам.
* **По размеру** **конкретных документов**, чтобы поиграться с их длиной: `Object.bsonsize()`;
* **По среднему** **размеру документа в** **ко****ллекции**: `db.c.stats().avgObjectSize`.
### Как повлиять на размер документа?
У меня неспецифичные ответы на этот вопрос. Первый - **длинное название поля увеличивает размер документа.** В каждом документе копируются все названия полей, поэтому если в документе длинное название поля, то размер названия нужно прибавить к размеру каждого документа. Если у вас коллекция с огромным количеством маленьких документов на несколько полей, то называйте поля короткими именами: «A», «B», «CD» — максимум две буквы. **На диске это компенсируется сжатием**, но в кэше все хранится как есть.
Второй совет — иногда **некоторые поля с низким cardinality можно вынести в название коллекции**. Например, таким полем может быть язык. Если у нас есть коллекция с переводами на русский, английский, французский и поле с информацией о хранимом языке — значение этого поля можно вынести в название коллекции. Так мы **уменьшим размеры документов** и можем **уменьшить количество и размер индексов** — сплошная экономия! Это не всегда можно провернуть, потому что иногда есть индексы внутри документа, которые не будут работать, если коллекцию разнести по разным коллекциям.
Последний совет по размеру документов — **используйте поле \_id**. Если в ваших данных имеется естественный уникальный ключ — поместите его прямо в поле\_id. Даже если ключ составной — используйте составной id. Он отлично индексируется. Есть только одна маленькая грабля — если у вас marshaller иногда меняет порядок полей, то id с одинаковыми значениями полей, но с разным порядком будут считаться разными id с точки зрения уникального индекса в MongoDB. В некоторых случаях так может случиться в Go.
Размеры индексов
----------------
**Индекс хранит копию полей, которые в него входят**. Размер индекса состоит из тех данных, которые проиндексированы. Если мы пытаемся проиндексировать большие поля, то готовьтесь к тому, что размер индекса будет большим.
Сильно раздувает индексы второй момент: **поля-массивы в индексе мультиплицируют другие поля из документа в этом индексе**. Будьте осторожны с большими массивами в документах: либо не индексируйте что-то еще к массиву, либо поиграйтесь с порядком перечисления полей в индексе.
**Порядок полей имеет значение**, **особенно, если одно из полей индекса — массив**. Если поля отличаются по cardinality, и в одном поле количество возможных значений сильно отличается от количества возможных значений в другом, то имеет смысл их выстраивать по увеличению cardinality. **Можно легко сэкономить 50% размера индекса, если поменять местами поля с разным cardinality.** Перестановка полей может дать и более значимое уменьшение размера.
Иногда, когда поле содержит большое значение, нам не нужно сравнивать это значение больше-меньше, а достаточно сравнения по четкому равенству. Тогда **индекс по полю с тяжелым содержимым** можно **заменить на индекс по hash от этого поля**. В индексе будут храниться копии hash, а не копии этих полей.
Удаление документов
-------------------
Я уже упоминал, что удаление документов — это неприятная операция и **лучше не удалять, если возможно.** Когда разрабатываете дизайн схемы данных, постарайтесь предусмотреть либо минимум удаления отдельных данных, либо удаление целых коллекций. удалять их было можно целыми коллекциями. Удаление коллекций — это дешевая операция, а удаление тысяч отдельных документов — тяжелая операция.
Если все-таки получилось так, что требуется удалять много документов, обязательно **делайте троттлинг**, иначе массовое удаление документов скажется на latency чтения и будет неприятно. Особенно это плохо влияет на latency на secondary.
Стоит сделать какую-то «ручку», чтобы крутить троттлинг — с первого раза очень тяжело подобрать уровень. Мы так много раз через это проходили, что троттлинг угадывается с третьего, четвертого раза. Изначально предусмотрите возможность его подкрутить.
**Если вы удаляете больше 30% большой коллекции, то переложите живые документы в соседнюю коллекцию**, а старую коллекцию удалите целиком. Понятно, что есть нюансы, потому что со старой на новую коллекцию переключается нагрузка, но по возможности перекладывайте.
Еще один способ удаления документов — **TTL-индекс** — это индекс, в котором индексируется поле, в котором лежит Mongo timestamp, в котором содержится дата смерти документа. Когда придет это время, MongoDB удалит этот документ автоматически.
TTL-индекс удобен, но **в реализации нет троттлинга.** MongoDB не заботится о том, чтобы эти удаления затроттлить. Если вы попытаетесь удалить миллион документов одновременно — на несколько минут у вас будет неработоспособный кластер, который занимается только удалением и больше ничем. Чтобы этого не происходило, добавьте какой-то рандом, **размажьте TTL** настолько, насколько позволяет ваша бизнес-логика и спецэффекты на latency. Размазывание TTL обязательно, если у вас естественные причины в бизнес-логике, которые концентрируют удаление в один момент времени.
Шардирование
------------
Мы пытались отсрочить этот момент, но он настал — нам все-таки приходится масштабироваться горизонтально. Применительно к MongoDB — это шардирование.
> Если вы сомневаетесь, что вам нужно шардирование — значит оно вам не нужно.
Шардирование усложняет жизнь разработчика и девопса разнообразными способами. В компании мы называем это налогом на шардирование. Когда мы шардируем коллекцию, то **удельная производительность коллекции снижается**: в MongoDB требуется поддерживать отдельный индекс для шардирования, и нужно передавать дополнительные параметры в запрос, чтобы он мог эффективнее исполняться.
Некоторые вещи с шардированием просто плохо работают. Например, плохая идея использовать запросы со `skip`, особенно если у вас много документов. Вы отдаете команду: «Skip 100 000 документов».
MongoDB считает так: «Первый, второй, третий… стотысячный, пошли дальше. А это мы вернем пользователю».
В нешардированной коллекции MongoDB выполнит операцию где-то внутри себя. В шардированной — все 100 000 документов она действительно прочитает и передаст в шардирующий прокси — в [mongos](https://docs.mongodb.com/manual/reference/program/mongos/), который уже на своей стороне как-то отфильтрует и отбросит первые 100 000. Неприятная особенность, о которой следует помнить.
**С шардированием обязательно будет усложняться код** — во многие места придется протащить ключ шардирования. Это не всегда удобно, и не всегда возможно. Некоторые запросы пойдут либо broadcast, либо multicast, что тоже не добавляет масштабируемости. Подходите к выбору ключа по которому пойдет шардирование аккуратнее.
**В шардированных коллекциях ломается операция `count`**. Она начинает возвращать число больше, чем в действительности — может соврать в 2 раза. Причина лежит в процессе балансировки, когда документы переливаются с одного шарда на другой. Когда документы перелились на соседний шард, а на исходном еще не удалились — `count` их все равно посчитает. Разработчики MongoDB не называют это багом — это такая фича. Не знаю, будут они это чинить или нет.
**Шардированный кластер гораздо тяжелее в администрировании**. Девопсы перестанут с вами здороваться, потому что процедура снятия бэкапа становится радикально сложнее. При шардировании необходимость автоматизации инфраструктуры мигает как пожарная сигнализация — то, без чего можно было и обойтись раньше.
### Как устроено шардирование в MongoDB
Есть коллекция, мы ее хотим как-то раскидать по шардам. Для этого**MongoDB делит коллекцию на чанки** с помощью ключа шардирования, пытаясь поделить их в пространстве шард-ключа на равные кусочки. Дальше включается балансировщик, который старательно **раскладывает эти чанки по шардам в кластере**. Причем балансировщику все равно, сколько эти чанки весят и сколько в них документов, так как балансировка идет в чанках поштучно.
Ключ шардирования
-----------------
Вы все-таки решили, что надо шардировать? Хорошо, первый вопрос — как выбрать ключ шардирования. У хорошего ключа несколько параметров: **высокий cardinality**, **немутабельность** и он **хорошо ложится в частые запросы**.
Естественный выбор ключа шардирования — это первичный ключ — поле id. Если вам подходит для шардирования поле id, то лучше прямо по нему и шардировать. Это отличный выбор — у него и cardinality хороший, он и немутабельный, но а насколько хорошо ложится в частые запросы — это ваша бизнес-специфика. Отталкивайтесь от вашей ситуации.
Приведу пример неудачного ключа шардирования. Я уже упоминал коллекцию переводов — translations. В ней есть поле language, которое хранит язык. Например, коллекция поддерживает 100 языков и мы шардируем по языку. Это плохо — cardinality количество возможных значений всего 100 штук, что мало. Но это не самое плохое — может быть, для этих целей cardinality достаточно. Хуже, что как только мы пошардировали по языку, мы тут же узнаем, что у нас англоязычных пользователей в 3 раза больше, чем остальных. На несчастный шард, на котором находится английский язык, приходит в три раза больше запросов, чем на все остальные вместе взятые.
Поэтому надо учитывать, что иногда шард-ключ естественным образом тяготеет к неравномерному распределению нагрузки.
### Балансировка
Мы подходим к шардированию, когда у нас назрела необходимость в нем — наш кластер MongoDB поскрипывает, похрустывает своими дисками, процессором — всем, чем можно. Куда деваться? Некуда, и мы героически шардируем пяток коллекций. Шардируем, запускаем, и внезапно узнаем, что **балансировка не бесплатна**.
Балансировка проходит несколько стадий. Балансировщик выбирает чанки и шарды, откуда и куда будет переносить. Дальнейшая работа идет в две фазы: сначала **документы копируются** с источника в цель, а потом документы, которые были скопированы, **удаляются**.
Шард у нас перегружен, в нем лежат все коллекции, но первая часть операции для него легкая. А вот вторая — удаление — совсем неприятная, потому что уложит на лопатки шард и так страдающий под нагрузкой.
Проблема усугубляется тем, что если мы балансируем много чанков, например, тысячи, то с настройками по умолчанию все эти чанки сначала копируются, а потом приходит удалятор и начинает их скопом удалять. В этот момент на процедуру уже не повлиять и приходится только грустно наблюдать за происходящим.
Поэтому если вы подходите к тому, чтобы шардировать перегруженный кластер, вам нужно планировать, так как **балансировка занимает время.** Желательно это время брать не в прайм-тайм, а в периоды низкой нагрузки. Балансировщик — отключаемая запчасть. Можно подойти к первичной балансировке в ручном режиме, отключать балансировщик в прайм-тайм, и включать, когда нагрузка снизилась, чтобы позволить себе больше.
Если возможности облака все еще позволяют масштабироваться вертикально, то лучше шард-источник заранее улучшить по железу, чтобы все эти спецэффекты немного уменьшить.
**К шардингу нужно тщательно готовиться.**
> [HighLoad++ Siberia 2019](https://www.highload.ru/siberia/2019) наступит в Новосибирске уже 24 и 25 июня. HighLoad ++ Siberia — это возможность для разработчиков из Сибири послушать доклады, поговорить на хайлоад-темы и окунуться в среду «где все свои», не летая за три тысячи километров в Москву или Питер. Из 80 заявок Программный комитет одобрил 25, а обо всех остальных изменениях в программе, анонсах докладов и других новостях мы рассказываем в нашей рассылке. [Подписывайтесь](http://eepurl.com/VYVaf), чтобы быть в курсе.
|
https://habr.com/ru/post/454748/
| null |
ru
| null |
# Alpine собирает Docker билды под Python в 50 раз медленней, а образы в 2 раза тяжелей
Alpine Linux — часто рекомендованный как базовый образ для Docker`а. Вам говорят, что использование Alpine сделает ваши билды меньше, а процесс сборки быстрей.
Но если вы используете Alpine Linux для Python приложений, то он:
* Делает ваши билды намного медленней
* Делает ваши образы больше
* Тратит ваше время
* И в итоге может стать причиной ошибок в рантайме
Давайте рассмотрим почему же Alpine рекомендуют, но почему вам все же не стоит использовать его вместе с Python.
### Почему люди рекомендуют Alpine?
Давайте предположим, что нам необходим gcc как часть нашего образа и мы хотим сравнить Alpine Linux vs Ubuntu 18.04, по скорости сборки и конечному размеру образа.
Для начала, скачаем два образа и сравним их размер:
```
$ docker pull --quiet ubuntu:18.04
docker.io/library/ubuntu:18.04
$ docker pull --quiet alpine
docker.io/library/alpine:latest
$ docker image ls ubuntu:18.04
REPOSITORY TAG IMAGE ID SIZE
ubuntu 18.04 ccc6e87d482b 64.2MB
$ docker image ls alpine
REPOSITORY TAG IMAGE ID SIZE
alpine latest e7d92cdc71fe 5.59MB
```
Как вы видите, базовый образ для Alpine намного меньше. Давайте теперь попробуем установить gcc и начнем с Ubuntu:
```
FROM ubuntu:18.04
RUN apt-get update && \
apt-get install --no-install-recommends -y gcc && \
apt-get clean && rm -rf /var/lib/apt/lists/*
```
> Написание идеальных Dockerfile выходит за рамки этой статьи
Замерим скорость сборки:
```
$ time docker build -t ubuntu-gcc -f Dockerfile.ubuntu --quiet .
sha256:b6a3ee33acb83148cd273b0098f4c7eed01a82f47eeb8f5bec775c26d4fe4aae
real 0m29.251s
user 0m0.032s
sys 0m0.026s
$ docker image ls ubuntu-gcc
REPOSITORY TAG IMAGE ID CREATED SIZE
ubuntu-gcc latest b6a3ee33acb8 9 seconds ago 150MB
```
Повторяем все то же самое для Alpine (Dockerfile):
```
FROM alpine
RUN apk add --update gcc
```
Собираем, смотрим на время и размер сборки:
```
$ time docker build -t alpine-gcc -f Dockerfile.alpine --quiet .
sha256:efd626923c1478ccde67db28911ef90799710e5b8125cf4ebb2b2ca200ae1ac3
real 0m15.461s
user 0m0.026s
sys 0m0.024s
$ docker image ls alpine-gcc
REPOSITORY TAG IMAGE ID CREATED SIZE
alpine-gcc latest efd626923c14 7 seconds ago 105MB
```
Как и обещано, образы на базе Alpine собираются быстрей и сами по себе меньше: 15 секунда вместо 30 и размер образа 105MB против 150MB. Это довольно хорошо!
Но если мы переключимся на сборку Python приложения, то все не так радужно.
### Python образ
Python приложения часто используют pandas и matplotlib. Поэтому, один из вариантов взять официальный образ на базе Debian, используя такой Dockerfile:
```
FROM python:3.8-slim
RUN pip install --no-cache-dir matplotlib pandas
```
Собираем его:
```
$ docker build -f Dockerfile.slim -t python-matpan.
Sending build context to Docker daemon 3.072kB
Step 1/2 : FROM python:3.8-slim
---> 036ea1506a85
Step 2/2 : RUN pip install --no-cache-dir matplotlib pandas
---> Running in 13739b2a0917
Collecting matplotlib
Downloading matplotlib-3.1.2-cp38-cp38-manylinux1_x86_64.whl (13.1 MB)
Collecting pandas
Downloading pandas-0.25.3-cp38-cp38-manylinux1_x86_64.whl (10.4 MB)
...
Successfully built b98b5dc06690
Successfully tagged python-matpan:latest
real 0m30.297s
user 0m0.043s
sys 0m0.020s
```
Получаем образ размером в 363MB.
Получится у нас лучше с Alpine? Давайте попробуем:
```
FROM python:3.8-alpine
RUN pip install --no-cache-dir matplotlib pandas
```
```
$ docker build -t python-matpan-alpine -f Dockerfile.alpine .
Sending build context to Docker daemon 3.072kB
Step 1/2 : FROM python:3.8-alpine
---> a0ee0c90a0db
Step 2/2 : RUN pip install --no-cache-dir matplotlib pandas
---> Running in 6740adad3729
Collecting matplotlib
Downloading matplotlib-3.1.2.tar.gz (40.9 MB)
ERROR: Command errored out with exit status 1:
command: /usr/local/bin/python -c 'import sys, setuptools, tokenize; sys.argv[0] = '"'"'/
tmp/pip-install-a3olrixa/matplotlib/setup.py'"'"'; __file__='"'"'/tmp/pip-install-a3olrixa/matplotlib/setup.py'"'"';f=getattr(tokenize, '"'"'open'"'"', open)(__file__);code=f.read().replace('"'"'\r\n'"'"', '"'"'\n'"'"');f.close();exec(compile(code, __file__, '"'"'exec'"'"'))' egg_info --egg-base /tmp/pip-install-a3olrixa/matplotlib/pip-egg-info
...
ERROR: Command errored out with exit status 1: python setup.py egg_info Check the logs for full command output.
The command '/bin/sh -c pip install matplotlib pandas' returned a non-zero code: 1
```
Что происходит?
### Alpine не поддерживает wheels
Если вы посмотрите на билд, который базируется на Debian, то вы увидите, что он скачивает matplotlib-3.1.2-cp38-cp38-manylinux1\_x86\_64.**whl**.
Это бинарник для wheel. Alpine же скачивает исходники `matplotlib-3.1.2.tar.**gz**`, так как он не поддерживает стандартный [wheels](https://pythonwheels.com/).
Почему? Большинство Linux дистрибутивов используют GNU версию (glibc) стандартной библиотеки C, который по факту необходим каждой программе написанной на C, включая Python. Но Alpine использует `musl`, а так как те бинарники предназначены для `glibc`, они попросту не вариант.
Поэтому, если вы используете Alpine, вам необходимо компилировать весь код, написанный на C, в каждом пакете Python.
Ах, да, список всех таких зависимостей которые, нужно компилировать придется искать самим.
В данном случае получаем такое:
```
FROM python:3.8-alpine
RUN apk --update add gcc build-base freetype-dev libpng-dev openblas-dev
RUN pip install --no-cache-dir matplotlib pandas
```
И время билда занимает…
… 25 минут 57 секунд! А размер образа 851MB.
Образы на базе Alpine собираются намного дольше, сами по себе они большего размера и вам еще нужно искать все зависимости. Можно конечно уменьшить размер сборки используя [multi-stage builds](https://pythonspeed.com/articles/smaller-python-docker-images/) но это означает, что нужно проделать еще больше работы.
Это еще не все!
### Alpine может быть причиной неожиданных багов в рантайме
* В теории musl совместим с glibc, но на практике различия могут стать причиной многих проблем. И если они будут, то наверняка неприяные. Вот некоторые проблемы, которые могут возникнуть:
* Alpine по умолчанию имеет меньший размер стека потока, что может привести к [ошибкам в Python](https://bugs.python.org/issue32307)
* Некоторые пользователи обнаружили, что [Python приложения работают медленней](https://superuser.com/questions/1219609/why-is-the-alpine-docker-image-over-50-slower-than-the-ubuntu-image) из-за того как, musl выделяет память (отличается от glibc).
* Один из пользователей [обнаружил ошибку при форматировании даты](https://github.com/iron-io/dockers/issues/42#issuecomment-290763088)
Наверняка эти ошибки уже исправили, но кто знает сколько их еще.
### Не используйте образы Alpine для Python
Если не хотите возиться с большими и долгими билдами, поиском зависимостей и потенциальными ошибками — не используйте Alpine Linux в качестве базового образа. [Сhoosing a good base image](https://pythonspeed.com/articles/base-image-python-docker-images/).
|
https://habr.com/ru/post/486202/
| null |
ru
| null |
# Кому нужны флексы
> Кому нужны флексы, если на них не делают сайты?
Делают, 12% сайтов уже используют флексы. А нужны они всем нам, чтобы было удобнее верстать.
Флексы, или Flexible Box Layout, с нами аж с 2006 года. Это получается одиннадцать лет! Их тогда внедрили в Mozilla для построения интерфейсов Firefox. Представьте себе, что вы настраиваете панель браузера: кнопочки разбегаются по краям, отталкиваются и ровно встают по горизонтали. Самый настоящий флексбокс. В 2009 году Mozilla предложила добавить эту систему в CSS.
С тех пор много чего случилось: тот самый первый флекс появился в Safari и других браузерах на WebKit. Вторая версия появилась в IE 10 в 2012 году. Флексы в текущем виде, с переносами flex-wrap, стали широко поддерживаться в 2014 году с выходом Firefox 28. Сейчас почти 98% браузеров по миру поддерживают флексбокс хоть какой-то версии. Даже Opera Mini на последнем вздохе движка Presto научилась флексам.
Зачем они вообще нужны? Это первая система раскладки в CSS, которая не хак. Таблицы, флоаты и инлайн-блоки придумали совсем для другого. Представьте три простых примера. Колонки одинаковой резиновой высоты: одна растёт по содержимому, другие идут за ней, что бы ни было. Или горизонтальный блок, внутри элементы распределены равномерно, сколько бы их ни было. Или блок произвольных размеров внутри родителя — ровно по центру.
Знаю, знаю — всё это можно имитировать десятком способов. CSS очень гибкий и кроме флоатов, инлайн-блоков и табличных свойств, можно применять хитрое позиционирование. Сам много лет это имитировал и набил руку на хаках и трюках. Но по-настоящему просто и явно это делает только флекс.
```
.center {
position: absolute;
top: 50%; left: 50%;
transform:
translate(
-50%, -50%
);
}
```
Что это вообще такое? Флекс — это такой контекст форматирования: вы задаёте родителю display: flex и его дети начинают подозрительно хорошо себя вести. Ещё есть старинный контекст display: table, когда блоки прикидываются внутренностями таблицы, и совсем новый — грид, ещё круче флекса. Гриды и флексы имеют кое-что общее и очень ценное.
Мало раскидать резиновые блоки, это можно сделать хоть на флоатах. Нужно ещё сказать, где они начинаются по главной оси, как делят пустое место внутри родителя и как выравниваются поперёк оси — во флексах ведь можно менять её направление. Этими вопросами занимается отдельная спецификация Box Alignment.
```
.flex {
display: flex;
justify-content:
space-between;
align-items:
stretch;
flex-direction:
column;
}
```
Флексы и гриды включают Box Alignment для своих детей и это то, чего нам всем очень не хватало. Когда-нибудь свойства justify-content, align-self, justify-items и другие заработают в других контекстах. Ведь до сих пор самый популярный вопрос по вёрстке — это как выровнять блок по вертикали. Проще всего это сделать на флексах.
Ладно, флексы классные, дайте две. Но почему тогда главные студии страны выпускают сайты для главных компаний страны, где всё по-прежнему на флоатах? А для надёжности иногда даже на таблицах. Варианта здесь два: либо им нужна поддержка IE 9, либо там работают упёртые староверы. У них всё и так работает на флоатах, зачем что-то менять?
Оставим консервативных верстальщиков в покое и разберёмся с браузерной поддержкой. Если вам нужны старые Android 4.3, iOS 6 или Firefox 27, то флексы у вас будут только в одной строке, без переносов: flex-wrap там ещё не работает. Сделать удобный список карточек одинаковой высоты, которые переносятся друг за другом по строкам, не получится.
В старых WebKit и в очень старом Firefox 21 поддерживается версия флексбокса 2009 года с немного другим синтаксисом, за префиксами -webkit и -moz. В IE 10 и 11 синтаксис уже ближе к современному и с поддержкой переносов, но за префиксом -ms. Если вы пишете современный флекс, а потом расставляете префиксы с помощью Автопрефиксера, то он вам добавит старых свойств, чтобы всё работало как нужно. Но никакой магии: переносы не заработают и баги никуда не денутся.
```
.flex {
display: -webkit-box;
display: -moz-box;
display: -ms-flexbox;
display: -webkit-flex;
display: flex;
}
```
Про баги отдельно: в старых реализациях с префиксами в Firefox, Safari и IE багов хватает. Но все они более-менее описаны в коллекции Flexbugs Филипа Уолтона. Прежде всего, вам нужно определиться с браузерами, которые вы поддерживаете и может быть вместо старых флексов с префиксами просто отдать им флоаты?
Да, это самое приятное: вы можете сделать простую вёрстку на флоатах или в контексте table, а потом объявить display: flex и сделать ещё лучше для браузеров которые умеют флексы. Сайты не должны выглядеть одинаково во всех браузерах, что бы там ни требовали заказчики. Тем более в старых, где главная задача — сохранить доступное содержимое.
Флоаты придумали чтобы текст обтекал картинку и нашей вёрстке давно пора перестать куда-то плыть. Мы в Академии уже перевели программы [базового](https://htmlacademy.ru/intensive/htmlcss) и [продвинутого](https://htmlacademy.ru/intensive/adaptive) интенсивов по вёрстке на флексы — и вам рекомендуем. Уже можно.
Видеоверсия
-----------
Вопросы можно задавать [здесь](https://htmlacademy.ru/shorts).
|
https://habr.com/ru/post/338824/
| null |
ru
| null |
# Тюнинг для папки Public в Dropbox
Dropbox — это просто замечательный сервис. Бесплатные 2 гигабайта, синхронизация между несколькими компьютерами и мобильными устройствами под различными ОС. А сколько различных применений находят ему народные умельцы не счесть — это и автоматизация торрент-загрузок, и сайты-визитки, и даже программные RAID-массивы.
Однако, такое простое задание как поделится файлами с незарегистрированным пользователем будет весьма накладно: придется давать ссылку на каждый файл (предварительно поместив их в папку Public), который требуется передать. Поэтому Вы наверняка воспользуетесь либо одним из известных файлообменников или же простой электронной почтой. Но почему бы не организовать такой файл-хостинг с удобным интерфейсом у себя в Dropbox?
Те, кто близко знаком с папкой Public в Dropbox знают, что public ссылки на файлы полностью сохраняют относительные пути файлов. Они имеют вид `dl.dropbox.com/u/user_id/{путь_в_папке_public}`. Этим фактом пользуются при создании сайтов-визиток и блогов на Dropbox. Но допустим, что существует достаточно большое количество файлов и папок с достаточно сложной структурой, которыми хотелось бы поделиться. Причем, не обязательно всеми файлами, а предложить выбрать пользователю именно то, что ему нужно. Логичное решение — создать «файл-карту» с соответствующими адресами и ссылками на файлы. Но как создать полное дерево каталогов с необходимыми ссылками? В Linux на помощь придет команда tree с ключом -H. В Windows встроенных средств для этого нет (да, тут тоже есть команда tree, но подставлять ссылки она не умеет). Конечно, можно попытаться написать свой собственный рекурсивный скрипт, который будет эмулировать линуксовский tree -H: проходить по папкам, подставлять ссылки, выводить все это в файл, но давайте согласимся, что кому-то не хватит умений и знаний, а иногда и просто свободного времени на написание, отладку и поддержку.
Одно из решений нам предлагает пользователь Dropbox [Eliphas Q.](http://forums.dropbox.com/profile.php?id=243) и его детище — pyndexer.
Что такое pyndexer?
-------------------
[Pyndexer](http://dl.dropbox.com/u/552/pyndexer/index.html) — это скрипт на Python, который создает список Ваших файлов, которые находятся в папке Public.
Скрипт рекурсивно исследует папки, указанные в файле настроек и создает index.html файлы в каждом каталоге. Созданные файлы подхватывает уже сам Dropbox и синхронизирует с облаком. Таким образом, каждая папка в представлении pyndexer — это отдельный index.html файл, между которыми и происходит навигация (такой своеобразный персональный FTP в облаке Dropbox).
Скрипт поддерживает большое число типов файлов, причем можно добавить свои, слегка подправив код. Кроме того, он умеет игнорировать некоторые из папок или закрывать доступ к ним с помощью пароля, встроенный jwplayer может воспроизводить аудио и видео файлы (по умолчанию mp3 и mp4), а также прикреплять readme в footer страницы-листинга. Даже если и этого мало, то можно прикрутить еще и Google Analytics.
Как начать использовать?
------------------------
Скрипт успешно работает в Linux, Mac OS X и Windows (у меня скомпилированный .exe никак не хотел работать, поэтому потребовалась установка среды Python).
Установка в Linux:
```
cd ~/Dropbox/Public
wget http://dl.getdropbox.com/u/552/pyndexer/pyndexer.py
chmod +x pyndexer.py
python pyndexer.py
```
Установка в Windows:
1. При отсутствии среды Python загружаем скомпилированный [.exe](http://dl.dropbox.com/u/552/pyndexer/1.2/pyndexer.exe?dl). Иначе нам потребуется просто сам [скрипт](http://dl.dropbox.com/u/552/pyndexer/1.2/pyndexer.py).
2. Запускаем в папке Public.
После запуска скрипт загрузит для себя файл конфигурации pyndexer.ini и шаблон pyndexer.template.html. Непосредственно в pyndexer.ini нужно указать абсолютный путь к папке Public (это необходимо из-за шифрования путей в Dropbox 1.2.x и выше), а также в квадратный скобках относительные пути директорий, которые необходимо проиндексировать.
Например, я хочу проиндексировать две папки (Somethings и Savegames), но хочу поставить пароль на Somethings, и не индексировать в ней подпапку NotSoPublic; а в папке Savegames, я хочу показать текст после списка файлов, который находится в другом файле sometext.txt. Тогда в файле pyndexer.ini следует указать:
```
[Somethings]
password=ItsSecret
[Somethings/NoSoPublic]
skipdir=yes
[Savegames]
readme=sometext.txt
```
Следует обратить внимание, что пароли хранятся в открытую, поэтому такое хранение весьма небезопасно, поскольку можно легко получить доступ к файлу конфигурации простой подстановкой пути в адресную строку.
Также предусмотрена возможность приглашения рефералов (ссылка-логотип Dropbox вверху списка файлов). Ссылкой управляет параметр dropbox\_referrer в файле pyndexer.ini.
После окончания работы скрипта, даем ссылку (public link) на index.html в любом каталоге и пользуемся приятным веб-интерфейсом в стиле Dropbox.
Полное описание скрипта и возможные трудности при работе можно найти в [readme файле](http://dl.dropbox.com/u/552/pyndexer/1.2/_README-FIRST.html) от автора.
Ссылки:
1. [Демо от автора](http://dl.dropbox.com/u/552/pyndexer/test%20folders/index.html)
2. [Сам скрипт](http://dl.dropbox.com/u/552/pyndexer/1.2/pyndexer.py) (версия 1.2)
3. [Readme по скрипту](http://dl.dropbox.com/u/552/pyndexer/1.2/_README-FIRST.html)
4. [Обсуждение на форуме Dropbox](http://forums.dropbox.com/topic.php?id=3075)
|
https://habr.com/ru/post/129240/
| null |
ru
| null |
# Декораторы в PHP. Реализация расширения
 По результатам опроса в [первой статье](http://habrahabr.ru/post/180827/), решено было сделать обзор реализации расширения. К этому моменту в угоду существующим IDE немного изменился синтаксис, который, пожалуй, был наиболее о~~б~~суждаемым моментом.
Это не еще-одна-статья-о-hello-world-расширении, т.к. желающим разобраться в основах легко найти массу материалов как [на](http://habrahabr.ru/post/98862/) [самом](http://habrahabr.ru/post/125597/) [Хабре](http://habrahabr.ru/post/144582/), так и в [русскоязычном](http://highloadblog.ru/articles/10.html) [RTFG](http://adobkin.com/blog/categories/development-extensions-to-php/).
Статья о предпосылках, реализации и подводных камнях. В ней будет мало PHP, в основном C.
Предпосылки
-----------
Если не интересно читать tl;dr, то можно сразу перейти к [Реализации](#code).
**Начну издалека**Мне нравится Python, особенно некоторые моменты его синтаксиса. А так как последнее время пишу я в основном на PHP, то хочется, чтобы рабочий инструмент был удобнее и функциональнее. PHP в последних версиях неплохо так развивается, но тех же декораторов всё нет. Так что приходится брать всё в свои руки. Сначала была идея унификации в плане имён и передачи параметров core функций (*другое [моё расширение](https://github.com/AterCattus/unifiedphp/blob/master/README_ru.md), которое пока в стадии формирования идеи. Если нужно, могу и про его создание написать*), теперь вот декораторы и ещё кое-какие наработки.
Декораторы функций (методы не упоминаются здесь и далее, т.к. для декорирования они ничем не отличаются) позволяют изменить работу последних, оборачивая их вызовы дополнительным слоем логики. В декларативной форме описывается список обёрток, которые в итоге должны вернуть нечто, чем будет заменена исходная функция. В python синтаксисе получаем [следующее](http://www.python.org/dev/peps/pep-0318/):
```
@decomaker(argA, argB, ...)
def func(arg1, arg2, ...):
# ...
# Эквивалентно:
func = decomaker(argA, argB, ...)(func)
```
В PHP такой возможности нет. Сначала я решил взять этот синтаксис как есть и перенести его без изменений (кроме передачи параметров декоратора при вызове; об этом ниже). В первой статье именно такой синтаксис и описывается. Однако IDE с проверкой синтаксиса и один из двух лагерей комментаторов заставили задуматься. В итоге синтаксис сделан более переносимым. Теперь описание декоратора должно описываться в однострочном комментарии #:
* # частично является deprecated, так что его применение будет заметнее обычных //, /\* и /\*\*;
* Однострочный комментарий не сворачивается и его тяжелее упустить из виду;
* ~~Вдруг в php 5.x декораторы-таки появятся и необходимость в этом расширении со странным синтаксисом отпадет.~~
Определившись с форматом описания нужно решить, как сами декораторы будут реализовываться. Функция-декоратор должна возвращать функцию, которая замещает собой исходную декорируемую. Тут как нельзя кстати приходятся анонимные функции и замыкания:
**немного PHP кода**
```
php
function decor($func) {
echo "Decorator!\n";
return function () use($func) {
return call_user_func_array($func, func_get_args());
};
}
function a($v)
{
var_dump($v);
}
$b = decor('a');
$b(42);
/* Вывод:
Decorator!
int(42)
*/
</code
```
В PHP опосредованный вызов функции с передачей ей параметров, конечно, многословен, этого не отнять.
В итоге получается синтаксис с изображения в начале статьи:
```
php
function decor($func) {
return function(){}
}
# @decor
function original()
{
// ...
}
</code
```
И вот это хочется получить без [переписывания лексера Zend'а](http://habrahabr.ru/post/179441/), чтобы не пришлось пересобирать сам PHP (~~работает — не трожь~~).
Реализация
----------
Для выполнения задуманного есть два варианта:
* Менять исходный код до того, как он попадет к лексеру PHP;
* Менять уже готовый opcode, но тогда синтаксис должен быть совместим с существующим.
Второй вариант выглядел сомнительным в вопросе совместимости со всякими opcode кешерами и оптимизаторами. Да и первоначальный вариант синтаксиса декораторов (без # комментария) в этом случае бы не работал.
Выбран был первый вариант.
В Zend есть два источника «поступления» исходного кода:
* Просто строка с кодом (аналог eval): [zend\_eval\_string[l][\_ex]](http://lxr.php.net/xref/PHP_5_5/Zend/zend_execute.h#66), которые все в итоге сводятся к вызову [zend\_compile\_string](http://lxr.php.net/xref/PHP_5_5/Zend/zend_compile.c#101);
* Файл, полученный из разных источников (stdin, stream, etc. Все варианты указаны в перечислении [zend\_stream\_type](http://lxr.php.net/xref/PHP_5_5/Zend/zend_stream.h#zend_stream_type)). В этом случае нас интересует [zend\_compile\_file](http://lxr.php.net/xref/PHP_5_5/Zend/zend_compile.c#zend_compile_file).
В обоих случаях у нас есть указатели на функции с конкретной реализацией. Стандартные реализации можно найти, посмотрев на инициализацию указателей в [zend\_startup](http://lxr.php.net/xref/PHP_5_5/Zend/zend.c#zend_startup):
* zend\_compile\_file реализуется в [compile\_file](http://lxr.php.net/xref/PHP_5_5/Zend/zend_language_scanner.c#compile_file);
* zend\_compile\_string — в столь же очевидной [compile\_string](http://lxr.php.net/xref/PHP_5_5/Zend/zend_language_scanner.c#compile_string).
Обе функции принимают на вход в той или иной форме исходный код и выдают массив opcode'ов в виде структурки [\_zend\_op\_array](http://lxr.php.net/xref/PHP_5_5/Zend/zend_compile.h#_zend_op_array). К сожалению, несмотря на схожесть выполняемых задач, реализация у них разная. Так что влиять будем на обе.
Влияние на подобные указатели на функции в Zend и PHP расширениях поставлено на поток. К примеру, та же zend\_compile\_file подменяется в [ZendAccelerator](http://lxr.php.net/xref/PHP_5_5/ext/opcache/ZendAccelerator.c#2549) и [phar](http://lxr.php.net/xref/PHP_5_5/ext/phar/phar.c#3533). Это не считая сторонних расширений.
Для подмены, нужно лишь реализовать свой аналог, и подменить указатель, сохранив оригинал. Всё как всегда. **Получится примерно следующее**
```
PHP_MINIT_FUNCTION(decorators);
PHP_MSHUTDOWN_FUNCTION(decorators);
zend_module_entry decorators_module_entry = {
// ...
decorators_functions,
PHP_MINIT(decorators),
PHP_MSHUTDOWN(decorators),
// ...
};
zend_op_array *(*decorators_orig_zend_compile_string)(zval *source_string, char *filename TSRMLS_DC);
zend_op_array *(*decorators_orig_zend_compile_file)(zend_file_handle *file_handle, int type TSRMLS_DC);
zend_op_array* decorators_zend_compile_string(zval *source_string, char *filename TSRMLS_DC);
zend_op_array* decorators_zend_compile_file(zend_file_handle *file_handle, int type TSRMLS_DC);
/* {{{ PHP_MINIT_FUNCTION
*/
PHP_MINIT_FUNCTION(decorators)
{
decorators_orig_zend_compile_string = zend_compile_string;
zend_compile_string = decorators_zend_compile_string;
decorators_orig_zend_compile_file = zend_compile_file;
zend_compile_file = decorators_zend_compile_file;
return SUCCESS;
}
/* }}} */
/* {{{ PHP_MSHUTDOWN_FUNCTION
*/
PHP_MSHUTDOWN_FUNCTION(decorators)
{
zend_compile_string = decorators_orig_zend_compile_string;
zend_compile_file = decorators_orig_zend_compile_file;
return SUCCESS;
}
/* }}} */
zend_op_array* decorators_zend_compile_string(zval *source_string, char *filename TSRMLS_DC) /* {{{ */
{
return decorators_orig_zend_compile_string(source_string, filename TSRMLS_CC);
}
/* }}} */
zend_op_array* decorators_zend_compile_file(zend_file_handle *file_handle, int type TSRMLS_DC) /* {{{ */
{
return decorators_orig_zend_compile_file(file_handle, type TSRMLS_CC);
}
/* }}} */
```
При инициализации модуля (нашего расширения) подменили указатели, при завершении работы не забыли всё вернуть. Непосредственно в подменённых функциях вызываем оригинальные реализации.
Не всё можно делать при инициализации модуля, но в нашем случае этого вполне достаточно.
И если с compile\_string все более-менее ясно (на вход приходит исходная строка), то вот с compile\_file не все так радужно — исходника-то у нас нет, только описание источника в [zend\_file\_handle](http://lxr.php.net/xref/PHP_5_5/Zend/zend_stream.h#zend_file_handle). Причем в разных случаях используются разные наборы полей. **Непосредственное чтение исходника закопано довольно далеко**
```
ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSRMLS_DC)
{
// ...
open_file_for_scanning(file_handle TSRMLS_CC)
// ...
}
ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC)
{
// ...
zend_stream_fixup(file_handle, &buf, &size TSRMLS_CC)
// ...
}
```
И самое интересное тут для нас — [zend\_stream\_fixup](http://lxr.php.net/xref/PHP_5_5/Zend/zend_stream.c#zend_stream_fixup), функция, которая унифицирует все источники поступления исходного кода и выдает на выходе считанный буфер и его размер. Вот вроде бы то, что нам нужно, но повлиять на работу zend\_stream\_fixup и open\_file\_for\_scanning мы не можем, у нас есть контроль только над compile\_file. *Кто-то пошел копипастить к себе эти функции и все их зависимости, но мы сделаем проще.* Если посмотреть на исходник zend\_stream\_fixup, то видно, что все типы сводятся в итоге к единому ZEND\_HANDLE\_MAPPED, у которого в file\_handle->handle.stream.mmap.buf и file\_handle->handle.stream.mmap.len содержится исходный код и его длина соответственно. Причем, если в file\_handle уже указан этот тип данных, то практически ничего уже менять не надо и всё выдается как есть.
Выходит, если мы передадим в compile\_file() zend\_file\_handle \*file\_handle уже в формате ZEND\_HANDLE\_MAPPED с корректным значением всех полей, то compile\_file это примет как так и было. А сделать это мы может вызвав zend\_stream\_fixup (которая является функцией Zend API, а не подменяемым указателем) еще разок до вызова compile\_file. Тогда повторный вызов внутри open\_file\_for\_scanning просто ничего не изменит. **Пробуем**
```
zend_op_array* decorators_zend_compile_file(zend_file_handle *file_handle, int type TSRMLS_DC) /* {{{ */
{
char *buf;
size_t size;
if (zend_stream_fixup(file_handle, &buf, &size TSRMLS_CC) == FAILURE) {
return NULL;
}
// теперь в file_handle у нас гарантированно ZEND_HANDLE_MAPPED
return decorators_orig_zend_compile_file(file_handle, type TSRMLS_CC);
}
/* }}} */
```
Ура, работает. Более того, у нас в file\_handle->handle.stream.mmap.buf/len содержится исходник, откуда бы PHP его не взял: stdin, fd, include http stream… Осталось положить туда наш измененный вариант кода и вызвать оригинальную zend\_compile\_file.
*Как работает decorators\_preprocessor() писать не буду: очевидное получение строки, ее передача препроцессору и отдача результирующей строки. Ниже и так будут куски кода из этой функции.*
Осталось рассмотреть сам препроцессор.
**Передача разрозненных исходных данных в единую функцию**
```
void preprocessor(zval *source_zv, zval *return_value TSRMLS_DC)
{
// Из исходной строки source_zv формирую строку в return_value
}
/* {{{ DECORS_CALL_PREPROCESS */
#define DECORS_CALL_PREPROCESS(result_zv, buf, len) \
do { \
zval *source_zv; \
ALLOC_INIT_ZVAL(result_zv); \
ALLOC_INIT_ZVAL(source_zv); \
ZVAL_STRINGL(source_zv, (buf), (len), 1); \
preprocessor(source_zv, result_zv TSRMLS_CC); \
zval_dtor(source_zv); \
FREE_ZVAL(source_zv); \
} while (0); \
/* }}} */
/* {{{ proto string decorators_preprocessor(string $code)
*/
PHP_FUNCTION(decorators_preprocessor)
{
char *source;
int source_len;
zval *result;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &source, &source_len) == FAILURE) {
return;
}
DECORS_CALL_PREPROCESS(result, source, source_len);
// ...
}
/* }}} */
zend_op_array* decorators_zend_compile_string(zval *source_string, char *filename TSRMLS_DC) /* {{{ */
{
zval *result;
DECORS_CALL_PREPROCESS(result, Z_STRVAL_P(source_string), Z_STRLEN_P(source_string));
// ...
}
/* }}} */
zend_op_array* decorators_zend_compile_file(zend_file_handle *file_handle, int type TSRMLS_DC) /* {{{ */
{
// ...
zval *result;
DECORS_CALL_PREPROCESS(result, file_handle->handle.stream.mmap.buf, file_handle->handle.stream.mmap.len);
// ...
}
/* }}} */
```
### Найти и переделать!
Задача препроцессора — найти описания декораторов и модифицировать код функций, на которые декораторы влияют. А для этого лучше всего работать с токенами исходного текста. Чтобы не изобретать велосипед, был использован родной Zend'овский лексический сканер [lex\_scan](http://lxr.php.net/xref/PHP_5_5/Zend/zend_compile.h#430), пример использования которого в своих целях можно посмотреть в реализации [token\_get\_all](http://lxr.php.net/xref/PHP_5_5/ext/tokenizer/tokenizer.c#180) и [tokenize](http://lxr.php.net/xref/PHP_5_5/ext/tokenizer/tokenizer.c#tokenize), вызываемой внутри token\_get\_all.
1. Сохраняем текущее окружение сканера, в котором работает наш код:
> zend\_lex\_state original\_lex\_state;
>
> zend\_save\_lexical\_state(&original\_lex\_state TSRMLS\_CC);
>
>
2. Подготавливаем исходную строку к парсингу:
> zend\_prepare\_string\_for\_scanning(&source\_z, "" TSRMLS\_CC)
3. Задаем начальное состояние лексера (все варианты [тут](http://lxr.php.net/xref/PHP_5_5/Zend/zend_language_scanner_defs.h)):
> LANG\_SCNG(yy\_state) = yycST\_IN\_SCRIPTING;
В отличие от token\_get\_all мы парсим уже PHP код, так что наличие открывающего тега нам не обязательно. Соотвественно, начальное состояние у нас не yycINITIAL, а yycST\_IN\_SCRIPTING.
4. В цикле получаем все лексемы исходной строки:
> zval token\_zv;
>
> int token\_type;
>
> while (token\_type = lex\_scan(&token\_zv TSRMLS\_CC)) {
>
> //…
>
> }
>
>
token\_type — тип лексемы:
* <256 — код символа односимвольной лексемы;
* >= 256 — значение константы [T\_\*](http://lxr.php.net/xref/PHP_5_5/Zend/zend_language_parser.y#57). Строковое описание по token\_type можно получить через PHP\_FUNCTION(token\_name)/get\_token\_type\_name.
token\_zv содержит само значение лексемы. Однако, в качестве альтернативы можно использовать поля yy\_text и yy\_leng структуры [zend\_lex\_state](http://lxr.php.net/xref/PHP_5_5/Zend/zend_language_scanner.h#zend_lex_state), хранящие адрес первого байта текущей лексемы и её длину соотвественно. Доступ к этим полям, как и многое в Zend, реализуется через соответствующие макросы:
> #define zendtext LANG\_SCNG(yy\_text)
>
> #define zendleng LANG\_SCNG(yy\_leng)
>
>
Теперь пользуемся char\* zendtext и unsigned int zendleng.
Чтобы не было memory leak'ов нужно учитывать, что значение token\_zv иногда берется как есть из исходного буфера, а иногда под него выделяется память. Которую нужно освобождать. Интересующиеся могут посмотреть код lex\_scan(), а сейчас просто возьмем необходимый кусок логики из token\_get\_all.
5. Восстанавливаем окружение сканера, в котором работает наш код:
> zend\_restore\_lexical\_state(&original\_lex\_state TSRMLS\_CC);
Всё, у нас есть лексический разбор исходного кода. Но хотелось бы осветить еще некоторые моменты парсинга.
При ошибках разбора PHP обработчик генерит ошибку или исключение, имя файла и номер строки в тексте которых берутся из состояния [\_zend\_compiler\_globals](http://lxr.php.net/xref/PHP_5_5/Zend/zend_globals.h#_zend_compiler_globals). Имя файла, например, берётся из поля compiled\_filename. Которое задается при вызове zend\_prepare\_string\_for\_scanning(). А используется внутри [zend\_error](http://lxr.php.net/xref/PHP_5_5/Zend/zend.c#zend_error) (используемая для генерации всякие E\_\* ошибок; она же используется и в этом расширении для генерации E\_PARSE). Но compiled\_filename в zend\_error() используется только если Zend находится в состоянии компилирования (zend\_bool in\_compilation; всё в том же \_zend\_compiler\_globals). Который сам по себе не активируется, если мы парсим исходник.
Так что перед парсингом мы переключаемся на «компилирование»:
> zend\_bool original\_in\_compilation = CG(in\_compilation);
>
> CG(in\_compilation) = 1;
>
>
А по окончанию возвращаем всё обратно:
> CG(in\_compilation) = original\_in\_compilation;
>
>
Теперь, если мы передадим в zend\_prepare\_string\_for\_scanning корректный filename, то возможные ошибки будут гораздо информативней. Получить текущее имя файла можно через zend\_get\_compiled\_filename(), который, правда, может вернуть NULL, от которого php (если NULL передать в zend\_prepare\_string\_for\_scanning) упадет в segfault.
**Осталось задать корректное имя файла в decorators\_preprocessor и decorators\_zend\_compile\_file**
```
PHP_FUNCTION(decorators_preprocessor)
{
// ...
char *prev_filename = zend_get_compiled_filename(TSRMLS_CC) ? zend_get_compiled_filename(TSRMLS_CC) : "";
zend_set_compiled_filename("-" TSRMLS_CC);
DECORS_CALL_PREPROCESS(result, source, source_len);
zend_set_compiled_filename(prev_filename TSRMLS_CC);
// ...
}
zend_op_array* decorators_zend_compile_file(zend_file_handle *file_handle, int type TSRMLS_DC) /* {{{ */
{
// ...
char *prev_filename = zend_get_compiled_filename(TSRMLS_CC) ? zend_get_compiled_filename(TSRMLS_CC) : "";
const char* filename = (file_handle->opened_path) ? file_handle->opened_path : file_handle->filename;
zend_set_compiled_filename(filename TSRMLS_CC);
zval *result;
DECORS_CALL_PREPROCESS(result, file_handle->handle.stream.mmap.buf, file_handle->handle.stream.mmap.len);
zend_set_compiled_filename(prev_filename TSRMLS_CC);
// ...
}
```
В decorators\_zend\_compile\_string имя файла у нас и так известно.
### Модификация исходного кода
Получив всё, что нужно для препроцессинга, осталось его собственно и произвести. Задача в переводе текста, составленного из кусков (лексем) в итоговый текст могла бы быть не так проста в C из-за активной работы со склейкой строк. Однако, в [/PHP/ext/standard/php\_smart\_str.h](http://lxr.php.net/xref/PHP_5_5/ext/standard/php_smart_str.h) есть реализация smart строк, которые нам очень пригодятся.
**Коротко**
```
smart_str str = {0};
smart_str str2 = {0};
smart_str_appendc(&str, '!');
smart_str_appendl(&str, "hello", 5);
smart_str_append(&str, &str2);
smart_str_append_long(&str, 42);
// и т.д.
// результирующая строка длиной size_t str.len может быть получена через char* str.c
// освобождение памяти:
smart_str_free(&str);
```
В цикле разбора лексем клеим результирующую строку из лексем (zendtext, zendleng), где нужно меняя/добавляя от себя. Непосредственно алгоритм замены декораторов, имхо, не столь интересен. Из потенциально интересного — проверка, что лексема типа T\_COMMENT похожа на описание декоратора: идет проверка регулярки '^#[ \t]\*@' (простым циклом, без regexp) и возвращается адрес '@'.
### Немного PHP напоследок
При обработке декораторов немного меняется исходный код декорируемой функции: тело функции заворачивается в анонимную функцию, которая передается параметром ближайшему декоратору. Т.е. для кода
```
// comment
@a(A)
@b
@c(C, D)
/**
* yet another comment
*/
function x(X)
{
Y
}
```
в результате препроцессинга получится следующий код:
```
// comment
/**
* yet another comment
*/
function x(X)
{ return call_user_func_array(a(b(c(function(X) {
Y
}, C, D)), A), func_get_args());}
```
Под A, C, D, X подразумевается произвольный код, который копируется as is.
Из этого вытекают следующие последствия:
* Если декорируемая функция объявлена с параметрами, имеющими значение по умолчанию, то в анонимной функции всё будет также:
> function foo($a, $b=42, $c=array(100, 500))
>
> {…
>
> =>
>
> function foo($a, $b=42, $c=array(100, 500))
>
> { return call\_user\_func\_array(...(function($a, $b=42, $c=array(100, 500)) {…
>
>
* При ошибках в описании имен декораторов, строкой кода при описании ошибки будет строка с открывающей тело функции '{'. Аналогично с параметрами декораторов — они будут на строке с закрывающей тело функции '}';
* Параметрам декораторов можно задавать имена переменных декорируемой функции. Получается read/write контроль над параметрами;
* Т.к. для передачи параметров используется func\_get\_args(), то передача параметра по ссылке в декорируемую функцию в данный момент не работает.
Ну вот и всё. Если вы и правда до сюда дочитали, то, надеюсь, было интересно.
Приведу и в этой статье ссылку на [github](https://github.com/AterCattus/php-decorators).
|
https://habr.com/ru/post/180939/
| null |
ru
| null |
# Смешанный (клиент/сервер) алгоритм формирования цифровой подписи xmlDsig на основе CryptoPro Browser Plugin
На хабре уже была обзорная [статья](http://habrahabr.ru/post/136572/) о механизмах создания ЭЦП в браузере, где было рассказано о связке Крипто-Про CSP +их же плагин к браузерам. Как там было сказано, предварительные требования для работы — это наличие CryptoPro CSP на компьютере и установка сертификата, которым собираемся подписывать. Вариант вполне рабочий, к тому же в версии 1.05.1418 плагина добавлена работа с подписью XMLDsig. Если есть возможность гонять файлы на клиент и обратно, то для того, чтобы подписать документ на клиенте, достаточно почитать КриптоПрошную справку. Все делается на JavaScript вызовом пары методов.
Однако, что если файлы лежат на сервере и хочется минимизировать трафик и подписывать их, не гоняя на клиент целиком?
Интересно?
Итак, клиент/серверный алгоритм формирования цифровой подписи XMLDSig.
Информацию об спецификации по XMLDsig можно найти по адресу [тут](http://www.w3.org/TR/xmldsig-core/).
Я буду рассматривать формирование enveloping signature (обворачивающей подписи) для xml-документа.
Простой пример подписанного xml:
```
....
not(ancestor-or-self::dsig:Signature)
...
...
...
```
Чтобы лучше понять, что из себя представляет enveloping signature, предлагаю краткий перевод описания тэгов из спецификации:
* Signature -содержит данные подписи, включая саму подпись и сертификат.
* SignedInfo -содержит информация о подписываемых данных и алгоритмах, которые будут применяться при формировании подписи.
* CanonicalizationMethod -указывает канокализирующий алгоритм, который будет применен к SignedInfo перед вычислением подписи.
* SignatureMethod -указывает алгоритм, используемый для генерации и валидации подписи. На вход алгоритму приходит канокализированный тэг SignedInfo.
* Reference -может встречаться 1 или больше раз. Содержит информацию о подписываемых данных, включая местоположение данных в документе, алгоритм вычисления хэша от данных, преобразования, и сам хэш.
* Transforms и Transform -перобразования над данными. На вход первого transform приходит результат разыменовании(dereferencing ) атрибута URI тэга Reference. На вход каждому последующему transform приходит результат предыдущего, результат последнего transform приходит на вход алгоритма, указанного в DigestMethod. Обычно в transform указывают XPath, определяющий защищаемые части документа.
* DigestMethod -алгоритм вычисления хэша от результатов Transforms.
* DigestValue -значение хэша от результатов Transforms.Часто это хэш от данных, на которые указывает Reference URI.
* SignatureValue -собственно сама подпись, ради формирования которой все и затевается.
* KeyInfo — информация о ключе, на тут интересует тэг X509Certificate, который содержит base64encoded сертификат из ключа, которым подписаны данные.
Итак, исходные данные:
* на сервере имеем xml-документ, который надо подписать. Также я использовал на сервере CryptoPro .Net, но можно и без него.
* на клиенте нам нужны ОС, поддерживающая работу с CryptoPro CSp 3.6 (в моем случае это была Windows 7), браузер, поддерживающий работу с КриптоПро ЭЦП Browser Plugin, и, собственно, ключ, которым собираемся подписывать (в моем случае ключ был на флешке).
Подготовка клиента:
* устанавливаем CryptoPro CSP 3.6
* устанавливаем КриптоПро ЭЦП Browser Plugin
* устанавливаем сертификат с флешки в локальное хранилище (см. [инструкцию](http://www.cryptopro.ru/sites/default/files/docs/instruction_manual_csp_r3.pdf)
пункт «2.5.2.2. Установка личного сертификата, хранящегося в контейнере закрытого ключа»)
**Шаг №1. (сервер)**
*Подготавливаем шаблон подписи для документа, который собираемся подписать.*
На этом этапе мы должны получить заготовку тэга Signature c посчитанными хэшами (DigestValue) от защищаемых данных. Алгоритм ручного высчитывания этих хэшей подробно описан [здесь](http://www.di-mgt.com.au/xmldsig.html), но так как у нас в конторе куплен КриптоПро .Net и на его основе написана внутренняя библиотека по работе с подписями, то я просто подписывал с помощью этой библиотеки документ на сервере другим ключом, в результате получал нужный мне шаблон с посчитанными хэшами от данных, но с невалидными SignatureValue и X509Certificate.
**Шаг №2. (сервер)**
*Каноникализируем SignedInfo, сформированный на шаге №1*
Алгоритм следующий (взято [отсюда](http://www.di-mgt.com.au/xmldsig.html) с дополнениями. В спорных местах оставил оригинальный текст):
* первый символ "<", последний ">".
* все помежуточные пробелым внутри тэгов сохраняются (оригинал All leading space characters inbetween are retained.)
* элементы вида
```
```
заменяем на
```
```
* окончания строк заменяем на LF (0x0A).
* выставляем namespace xmlns=«[www.w3.org/2000/09/xmldsig#](http://www.w3.org/2000/09/xmldsig#)» тэгу SignedInfo (оригинал на английском The namespace xmlns=«[www.w3.org/2000/09/xmldsig#](http://www.w3.org/2000/09/xmldsig#)» is propagated down from the parent Signature element.)
* атрибуты тэгов должны быть расположены внутри тэгов в алфавитном порядке (эта проблема проявилась при формировании подписи, содержащей SignatureProperties)
Код на C#, который заработал в моем случае:
```
XmlNode xmlNode = xmlElement.GetElementsByTagName("SignedInfo")[0];
XmlDocument xmlDocumentSignInfo = new XmlDocument();
xmlDocumentSignInfo.PreserveWhitespace = true;
xmlDocumentSignInfo.LoadXml(xmlNode.OuterXml);
result = Canonicalize(xmlDocumentSignInfo);
```
где:
```
public string Canonicalize(XmlDocument document)
{
XmlDsigExcC14NTransform xmlTransform = new XmlDsigExcC14NTransform();
xmlTransform.LoadInput(document);
string result = new StreamReader((MemoryStream)xmlTransform.GetOutput()).ReadToEnd();
//C# метод канокализации не добавляет в XPath неймсппейс
result = s.Replace("", "");
return result ;
}
```
**Шаг №3.**
*Берем хэш от канокализированного SignedInfo.*
Тут возможны 2 варианта-серверный и клиентский.
**3.1)** Взятие хэша на клиенте. Именно его я использую, так что опишу его первым:
На сервере кодируем канокализированный SignedInfo в base64
C#:
```
string b64CanonicalizeSignedInfo= Convert.ToBase64String(Encoding.UTF8.GetBytes(s));
```
и отправляем эти данные на клиент.
На клиенте берем хэш с помощь криптопрошного плагина
JavaScript:
```
var CADESCOM_HASH_ALGORITHM_CP_GOST_3411 = 100;
var CADESCOM_BASE64_TO_BINARY = 1;
var hashObject = CreateObject("CAdESCOM.HashedData");
hashObject.Algorithm = CADESCOM_HASH_ALGORITHM_CP_GOST_3411;
hashObject.DataEncoding = CADESCOM_BASE64_TO_BINARY;
hashObject.Hash(hexCanonicalSignedInfo);
```
Посмотреть хэш можно с помощью hashObject.Value
**3.2)**Считаем хэш на сервере и отправляем на клиент. Этот вариант у меня так и не заработал, но честно сказать я особо и не пытался.
Берем хэш(сервер C#):
```
HashAlgorithm myhash = HashAlgorithm.Create("GOST3411");
byte[] hashResult = myhash.ComputeHash(сanonicalSignedInfoByteArr);
```
Возможно хэш надо преобразовывать в base64.
Отправляем на клиент, там используем
```
var hashObject = CreateObject("CAdESCOM.HashedData");
hashObject.SetHashValue(hashFromServer);
```
Именно на методе hashObject.SetHashValue у меня падала ошибка. Разбираться я не стал, но криптопрошном форуме говорят, что можно как-то заставить ее работать.
Если соберетесь реализовывать серверный алгоритм генерации хэша, то вот пара полезных советов:
1) Посчитайте хэш на клиенте и на сервере от пустой строки. он должен совпадать, это значит ваши алгоритмы одинаковые.
Для GOST3411 это следующие значения:
base64: mB5fPKMMhBSHgw+E+0M+E6wRAVabnBNYSsSDI0zWVsA=
hex: 98 1e 5f 3c a3 0c 84 14 87 83 0f 84 fb 43 3e 13 ac 11 01 56 9b 9c 13 58 4a c4 83 23 4c d6 56 c0
2) Добейтесь, чтобы у вас совпадали хэши для произвольных данных, генерируемые на клиенте и на сервере.
После этого можно пересылать клиенту только хэш от SignedInfo вместо всего SignedInfo.
**Шаг №4.(клиент)**
*Генерируем SignatureValue и отсылаем на сервер SignatureValue и информацию о сертификате*
```
var certNumber=2; //номер нужного вам сертификата из хранилища
var CAPICOM_CURRENT_USER_STORE = 2;
var CAPICOM_MY_STORE = "my";
var CAPICOM_STORE_OPEN_MAXIMUM_ALLOWED = 2;
var oStore = CreateObject("CAPICOM.Store");
oStore.Open(CAPICOM_CURRENT_USER_STORE, CAPICOM_MY_STORE, CAPICOM_STORE_OPEN_MAXIMUM_ALLOWED);
var certificate=oStore.Certificates.Item(certNumber)
var rawSignature = CreateObject("CAdESCOM.RawSignature");
var signatureHex = rawSignature.SignHash(hashObject, certificate);
//в base64 и переворачиваем
var binReversedSignatureString = utils.reverse(utils.hexToString(signatureHex));
var certValue = certificate.Export(certNumber);
```
Возвращем на сервер binReversedSignatureString и certValue.
Код функций из utils не выкладываю. Мне его подсказали на форуме криптоПро и его можно посмотреть в этой [теме](http://www.cryptopro.ru/forum2/default.aspx?g=posts&t=6444#post40406)
**Шаг №5. (сервер)**
*Заменяем в сгенерированном на шаге №1 тэге Signature значения тэгов SignatureValue и X509Certificate значениями, полученными с клиента*
**Шаг №6. (сервер)**
*Верифицируем карточку.*
Если верификация прошла успешно, то все хорошо. В результате мы получаем на сервере документ, подписанный клиентским ключом, не гоняя туда-обратно сам файл.
*Примечание:* если работа ведется с документом, уже содержащим подписи, то их надо отсоединить от документа до шага №1 и присоединить к документу обратно после шага №6
В заключение хочется сказать большое спасибо за помощь в нахождении алгоритма участникам форума КриптоПро dmishin и Fomich.
Без их советов я бы плюхался с этим в разы дольше.
|
https://habr.com/ru/post/189596/
| null |
ru
| null |
# nginx + apache. Кеширование
Привет, %username%
Тут я хочу рассказать о том, как я настраивал кеширование на одном сервере, точнее VDS. Характеристики сервера: 2000MHz, 2GB RAM, 80Gb HDD, технология виртуализации — OpenVZ.
Было решено использовать Nginx версии **0.7.64**. На сервере находилось около 200 сайтов. И несколько высоко нагруженных проектов. Вот эти самые проекты и давали ощутимые тормоза и нагрузку на сервер. Мы будем рассматривать DLE в этом примере.
Итак, основные моменты кеширования:
* Кешировать «гостей» сайта
* Залогиненных посетителей отправлять напрямую к апачу
#### 0. Придумываем «технологию»
Если в урлах встречаются строки: *index.php?action=logout* и *admin.php* то мы будем посылать эти запросы напрямую к апачу. Потом, нам нужно научить nginx отделять залогиненых пользователей от гостей. Разделять мы их будем с помощью кукисов. В моем случае, Кукисы **dle\_user\_id** и **dle\_password** означают, что пользователь залогинен и мы не хотим отдавать ему страничку 5-ти минутной давности. И плюс, нам нужно отправлять POST заброс на авторизацию вне кеша, я думаю понятно почему и зачем (:.
#### 1. Поехали. Пишем конфиг
Собственно, я не буду описывать полный конфиг, я буду описывать только те моменты, которые необходимы для кеширования. Я не претендую на правильность и оптимальность моего решения, но то что здесь показано, работает, и неплохо работает в боевых условиях. Сильно не пинайте, я не так давно полез в дебри nginx'a, но чувствуется что документации и тех пример очень не хватает!
Основные директивы конфига — кликабельны, ведут на оф документацию.
#### 1.1 Сам конфиг
`http {
proxy_cache_path /var/cache/nginx/cache levels=1:2 keys_zone=one:16m inactive=7d max_size=1024m;
proxy_temp_path /var/cache/nginx/temp; #эта директива будет наследоваться из http секции, если не задано другое.
server {
listen 127.0.0.1:80;
server_name example.com www.example.com;
proxy_temp_path /var/cache/nginx/example.com;
location @nocached {
proxy_pass 127.0.0.1:8080;
proxy_redirect example.com:8080/ /;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Real-IP $remote_addr;
}
location / {
proxy_pass 127.0.0.1:8080;
proxy_redirect example.com:8080/ /;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Real-IP $remote_addr;
#здесь мы фильтруем наших залогиненых пользователей
if ($cookie_dle_user_id) { return 412; }
if ($cookie_dle_password) { return 412; }
if ($request_method = POST ) {
return 412;
}
error_page 412 = @nocached;
proxy_cache one;
proxy_cache_key "$request_method|$is_args|$host|$request_uri";
proxy_hide_header "Set-Cookie";
proxy_ignore_headers "Cache-Control" "Expires";
proxy_cache_valid 200 302 304 5m;
proxy_cache_valid 301 1h;
proxy_cache_valid 503 4s;
proxy_cache_valid any 1m;
proxy_cache_use_stale http_502 http_503 http_504;
}
location ~ (admin.php|index.php?action=logout) {
proxy_pass 127.0.0.1:8080;
proxy_redirect example.com:8080/ /;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Real-IP $remote_addr;
}
location ~* ^.+\.(jpg|jpeg|gif|png|svg|htm|js|css|mp3|ogg|mpe?g|avi|zip|gz|bz2?|rar)$ {
root /var/www/example/data/www/example.com;
expires 1y;
access_log /var/www/httpd-logs/example.com.access.log;
error_page 404 = @fallback;
}
location @fallback {
proxy_pass 127.0.0.1:8080;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Real-IP $remote_addr;
}
}
}`
$cookie\_name, эта переменная равная cookie name;
Собственно, далее будем разбирать, что же мы здесь намулевали. Предложения по улучшениям и правкам приветствуются!
#### 2. Разбор полетов
Итак, нам необходимо было разграничить пользователей на 2 типа, и в зависимости от типа, давать или не давать ему кеш.
В **location @nocached** мы будем пускать тех, кто является владельцем двух кук — *dle\_user\_id*, *dle\_password*, следовательно эти пользователи будут у нас ходить напрямую, не кешируясь. Я уже писал, что для авторизации используются POST запросы, как и для регистрации ;), следовательно нам не нужно их кешировать. В этом случае, мы просто добавляем проверку на $request\_method.
**error\_page 412 = @nocached** собственно и посылает обладателей кукисов, или кто пытается залогинится, напрямую к апачу.
Хотелось бы отметить директиву **proxy\_cache\_key**. В ней, для ключа, я указываю лишь «уникальность» страницы, тоесть, если ктонибудь обратился к любой нашей странице «Гостем», то nginx, проксируя первый ответ, сразу кладет его в кеш. После этого, любой другой пользователь, который уложился в отведенное время жизни страницы (proxy\_cache\_valid 200… 5m) получает ту самую страницу, которую сгенерировал апач для предыдущего пользователя, так будет продолжаться, пока не кончится срок жизни, в нашем случае для ответа 200 выделяется — 5 минут. После этого все будет продолжаться по тому же самому сценарию.
Дальше, я хотел бы отметить 2 строчки: *proxy\_hide\_header, proxy\_ignore\_headers* которые **обязательны** при кешировании. Вы ведь не хотите чтобы Вася Пупкин смог получить кукисы Пети Васечкиного, и тем самым делать от его имени… ??? Вторая строчка, **proxy\_ignore\_headers** Позволяет нам сохранять ответы апача, которые помечены, как *не кешировать* или еше чемнибудь в этом роде. Ведь даже для таких вещей нам придется дергать неповоротливый апач, когда можно один раз закешировать, и отдавать быстрым nginx'ом.
Придавать особого внимания параметру *proxy\_cache\_valid* я не буду, все и так хорошо описано в документации.
**proxy\_cache\_use\_stale** очень правильная директива, она позволяет нам отдать клиенту закешированную «нормальную» страницу в то время, когда апач или повесился, или сдох или еще чего… 502, и 504 ошибки соответственно.
В следущем **location ~ (admin.php|index.php?action=logout)** мы говорим что хотим отправлять запросы в которых содержаться строки напрямую к апачу.
Два следущих **location** говорят nginx'у что статику (картинки таблицы стилей видюшечки и т.д.) отдавать самому. И если nginx не нашел такого файла на диске, то может быть он просто находится в .htaccess и апач нам его отдаст.
Ну вот, надеюсь что все. Я очень надеюсь, что мой хабра топик вам помог, или поможет в будущем избежать некоторых неприятных моментов.
Спасибо за внимание.
**P.S.** Парсер съел мои http://, а nginx'у они нужны, как мне их восстановить? Иначе при копировании моего куска конфига у вас nginx может заругаться, а если нет, то уже не известно что будет.
[Кросспост](http://bkmz.org/80)
|
https://habr.com/ru/post/79876/
| null |
ru
| null |
# История про ExecJS или как выполнять джаваскрипт в руби
Допустим, вы пишите крутой вебдванольный проект на рельсах. У вас есть друг Петя — сильный программист на джаваскрипте. Поскольку Петя пишет много и задорно, он решил облегчить себе жизнь и придумал новый язык с красивым и простым синтаксисом, который будет транслироваться в джаваскрипт.
Еще Петя — большой любитель зеленого чая, поэтому назвал он свой новый язык GreenTeaScript.
Кроме Пети, у вас есть еще один друг-программист-на-джаваскрипте Вася. Вася как-то раз придумал написать программу, которая разбирала бы JS на AST, оптимизовала его, а потом собирала обратно в красивый, структурированный код, отсекая всякое лишнее и форматируя по Кроуфорду. Назвал он свое детище BeautifyJS. Кстати, BeautifyJS еще умел собирать AST в минимизированный сжатый код и делал это быстрее и лучше остальных существующих в природе альтернатив.
Поскольку и Петя и Вася ни на чем, кроме джаваскрипта, программировать не умели, свои продукты они на нем и написали.
И тут вам, опять же допустим, первому в мире в голову пришла идея прикрутить эти замечательные штуки к своему крутому вебдванольному проекту на рельсах. Писать фронтенд на GreenTeaScript вам сильно понравилось, а сжатие скриптов с помощью BeautifyJS наверняка сильно ускорило бы сайт.
Теперь начинается самое интересное.
#### JavaScriptCore
Обе программы написанны на джаваскрипте, а нам нужно как-то их выполнять из рельс. Быстрый гуглинг подсказывает вам, что в макоси, которой вы, допустим, пользуетесь, есть встроенный в систему JavaScriptCore, который можно запустить из консоли командой `/System/Library/Frameworks/JavaScriptCore.framework/Versions/A/Resources/jsc`. Вы быстренько пишете класс, который берет кусок джаваскрипта, скармливает этой штуке, парсит результат и вуаля — все работает! Ништяк.
#### JScript
Показываете прототип проекта инвестору со своего ноутбука, инвестору нравится, но он говорит, что запуститься надо через неделю. Блин, за неделю вы никак не успеете дописать весь фукнционал, поэтому решаете нанять себе в помощники программиста Диму.
А программист Дима использует операционную систему Windows, поэтому у него макосевый JavaScriptCore не работает. Дима быстренько гуглит и находит решение — [JScript](http://msdn.microsoft.com/en-us/library/9bbdkx3k.aspx), после чего пишет рядом второй класс для работы под винду. И все снова ништяк и работает. На этот раз и под Макось и под Виндоус.
#### NodeJS
За неделю вы кое-как успеваете дописать все что надо, инвестор сильно доволен и дает команду запускаться. Радостно покупается линуксовый сервер, происходит деплой, и тут все ломается. Ну правильно, вы же забыли предусмотреть возможность выполнения джаваскрипта под линуксом.
Не беда, решение приходит достаточно быстро. Нужно всего лишь поставить на сервер NodeJS и дописать существущие классы для работы с ним. Сказано — сделано. Теперь вся эта бодяга работает и в линуксе тоже.
#### therubyracer
Проект стремительно набирает популярность, под дверью скапливается очередь из инвесторов, желающих срочно отвалить вам кучи денег, а сервер перестает справляться. Вы нанимаете сисадмина, в задачи которого будет входить установка и настройка новых серверов. Сисадмин смело берется за дело, накатывает 5 новых серверов, деплоит на них и все снова ломается. Оказывается, на новых серверах версия NodeJS слегка отличается от той, что на первом сервере. А еще лежит она не в `/bin/node`, а в `/usr/local/bin/node`. Да и вообще, по мнению админа, внешние зависимости — это не круто и надо, мол, от них избавляться.
Вы вооружаетесь учебником «С++ с нуля за 3 часа» и смело садитесь писать новый гем, который позволял бы использовать движок NodeJS V8 напрямую из руби. В итоге у вас получается [therubyracer](https://github.com/cowboyd/therubyracer). При установке гем собирает у себя в песочнице свой собственный V8 нужной версии и напрямую его использует. Лепота!
Теперь можно вычистить ту гору костылей, которая отвечала за выполнение джаваскрипта и заменить все это красивым классом, который просто использует therubyracer. В Gemfile.lock везде прописанна одна версия, все работает быстро и одинаково во всех операционных системах, все счастливы.
#### therubyrhino
Как-то раз вы вычитываете статью на хабре про JRuby. В статье, среди прочего, написанно что мол, JRuby очень быстрый и вообще крутой. В качестве эксперимента вы решаете запустить свой проект на JRuby и погонять бенчмарки. Естественно, все затыкается на therubyracer, который под JRuby не работает.
Так что вы собираете на коленке новый гем, [therubyrhino](https://github.com/cowboyd/therubyrhino), который в общем-то делает все то же самое, что и therubyracer, но использует на мозилловский джаваскриптовый движок и работает в JRuby. Погоняли бенчмарки и успокоились, вобщем.
#### Все вместе
Проект растет ввысь и вширь, количество серверов увеличивается, вы нанимаете по 5 новых программеров в неделю. Каждому новому программеру вы покупаете компьютер, а потом полдня рассказываете, как установить туда компилятор со всеми причиндалами, чтобы therubyracer собрался. А потом он еще собирается минут 10. Вы с грустью вспоминаете дни, когда все работало на встроенном JavaScriptCore без всяких компиляторов и сразу.
К чему весь этот длинный рассказ? А к тому, что в новом Rails 3.1 по умолчанию добавлена поддержка CoffeeScript и UglifyJS. Это почти то же самое, что наши воображаемые GreenTeaScript и BeautifyJS, только всамделишные. И Rails Core Team столкнулось с теми же проблемами, что и мы, только по-настоящему.
Как они их разрулили? Они написали [ExecJS](https://github.com/sstephenson/execjs) — гениальный гем, который позволит использовать все возможные способы выполнения джаваскрипта из руби и при этом не добавляет никаких зависимостей. Он проверяет каждый из способов на доступность, а затем предлагает использовать лучший из найденных.
Таким образом, у разработчика на макоси все будет выполняться через JavaScriptCore, в его соседа на винде через JScript, а под линуксом оно попытается зацепиться за NodeJS или вежливо предложит поставить therubyracer.
Работает все примерно так:
```
require 'rubygems' # если вы все еще на 1.8
require 'execjs'
# очень полезная функция на джаваскрипте
jsfunc = < 100
# а можно и напрямую
ExecJS.eval 'Math.pow(10, 2)' # => 100
```
Как видите, все достаточно прозрачно и просто. Не обязательно вникать в детали, оно просто работает самым оптимальным из доступных способов.
Таким образом получается, что гонять джаваскрипт в руби теперь проще пареной репы. По-моему, это очень круто!
|
https://habr.com/ru/post/121167/
| null |
ru
| null |
# Yet another инструкция по получению ssl-сертификата Let's Encrypt
Тема получения сертификата Let's Encrypt уже подымалась на хабре (см. [тут](https://habrahabr.ru/post/270273/)), да и в сети можно найти много рецептов разного качества.
Читал я и ужасался: [одни](https://hellsman.ru/admin/linux/ustanovka-ssl-sertifikata-ot-letsencrypt-s-nginx-v-centos-7) пишут, что то нужно nginx или apache остановить («на пару минуточек всего»), [другие](https://mihanentalpo.me/2015/12/ssl-%D1%81%D0%B5%D1%80%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82-lets-encrypt-%D0%BD%D0%B0-nginx/) предлагают файлы подкладывать в папку веб-сервера (в соседней ssh-сессии), третьи — о том, как важно соблюсти правильный Content-type для файлов проверки домена…
Давайте попробуем обойтись без всего этого: чтобы не было мучительно больно ни на стадии установки, ни очередном продлении — даже если придётся обновлять сразу много доменов. Собственно, вот и вся цель моей небольшой заметки: это не пошаговый степ-бай-степ, не длинная теоретическая статья о том, как функционирует Let's Encrypt — просто описывается правильный на мой взгляд подход, который будет правилен для конфигурации любой сложности.
Вся суть в двух словах: пусть Let's Encrypt запустит веб-сервер на 9999 порту, а мы допишем конфиг nginx, чтобы он пробросил запрос на этот бекенд. Кому интересны детали — прошу под кат
Установка Let's Encrypt в настоящее время рекомендуется из репозитория на гитхабе:
```
git clone https://github.com/letsencrypt/letsencrypt && cd letsencrypt
```
Для некоторых операционок уже есть готовые пакеты (более того — вместо команды letsencrypt-auto (которая по сути есть лишь обёртка для letsencrypt) можно использовать letsencrypt), но установка из репозитория меня, как программиста вполне устраивает.
Далее — нужно подготовить наш сервер.
В принципе, всё, что от нас требуется — это чтобы по адресу [mysubdomain.mydomain.tld/.well-known/acme-challenge/6il4rb2ErDWuBnUsTw\_qrJc\_tXGNv43p2a4kQQc0CvE](http://mysubdomain.mydomain.tld/.well-known/acme-challenge/6il4rb2ErDWuBnUsTw_qrJc_tXGNv43p2a4kQQc0CvE) отдавался заранее определённый контент с нужными заголовками.
Переложим эту работу на сам Let's Encrypt: пусть сам подымет на 127.0.0.1:9999 собственный веб-сервер, а мы — лишь допишем в конфиг nginx правило для проброса запросов на этот бекенд. Не нужно ни останавливать ничего, ни тем более создавать файлы вручную.
Итак. Создаём файл /etc/nginx/template/letsencrypt.conf следующего вида:
```
location ~ ^/(.well-known/acme-challenge/.*)$ {
proxy_pass http://127.0.0.1:9999/$1;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header Host $http_host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
```
И подключим в конфиг-файлы нужных поддоменов:
```
include template/letsencrypt.conf;
```
Собственно, это всё. Дальше можно запустить одну-единственную команду — собственно запустить Let's encrypt:
```
letsencrypt-auto --agree-tos --renew-by-default --standalone --standalone-supported-challenges http-01 --http-01-port 9999 --server https://acme-v01.api.letsencrypt.org/directory certonly -d mydomain.tld -d www.mydomain.tld -d i1.mydomain.tld -d i2.mydomain.tld
```
Здесь я получаю сертификат сразу для четырёх поддоменов, указываю, что нужно запустить веб-сервер на порту 9999, согласиться с лицензионным соглашением. (В принципе, можно указать в командной строке е-мейл, чтобы вообще не пришлось в интерактивный режим входить и довносить эту информацию: читайте описание ключей в документации)
В принципе, больше описывать нечего. Как внести сертификат в конфиг-файл nginx достаточно хороших и правильных описаний.
Единственное — осталось добавить в cron команду автоматического продления:
```
letsencrypt-auto renew >> /dev/null 2>&1
```
В getting-started [приведены](https://letsencrypt.org/getting-started/) другие примеры скриптов обновления, рекомендую посмотреть: можно предусмотреть допустим отправку письма в случае, если обновление закончилось неудачей или автоматически рестартовать демон веб-сервера.
Вот и всё. От себя добавлю, что очень не люблю быть в первых рядах новой технологии («пока не выйдет первый сервис-пак — нет смысла обновлять винду на новую»), но в принципе, вижу, что Let's Encrypt уже можно потихоньку начинать использовать в продакшн.
PS В качестве основы для своей заметки я взял [статью](https://www.kami-no.ru/?p=94) Дмитрия из его блога. Не знаю, есть ли он на хабре, в любом случае от меня — большое спасибо.
|
https://habr.com/ru/post/279695/
| null |
ru
| null |
# ExpvarMon — консольный мониторинг сервисов на Go
Для Go-программ существует удобнейший стандартный пакадж [expvar](http://golang.org/pkg/expvar/), позволяющий одной строчкой подключить вывод дебаг информации в JSON-формате. И чтобы максимально быстро и наглядно мониторить текущее состояние, была написана консольная программа Expvarmon, требующая минимум конфигурации для вывода метрик и дебаг-информации для ваших Go-сервисов.
Функции:
* single- и multi-services режимы
* мониторинг локальных и удаленных программ
* произвольное количество сервисов и переменных
* поддержка значений для памяти, временных интервалов, bool и произвольных чисел/строк
* sparkline-графики
* отображение максимальных значений
* отображение упавших/рестартовавших сервисов
* авто-ресайз при изменении размеров шрифта или окна
#### Введение
В стандартной библиотеке Go есть очень полезный пакадж [expvar](http://golang.org/pkg/expvar/), который позволяет одной строчкой добавить вывод дебаг информации в json-формате по адресу /debug/vars. По-умолчанию выводятся данные об использовании памяти и работе сборщика мусора (GC), и легко добавляются любые свои метрики/счетчики/переменные. Обычно эти данные собирает отдельный процесс, который кладет в какую-нибудь time-series базу данных, и затем это превращается в удобные и красивые дашборды.
Но зачастую, даже во время разработки или отладочных сессий, хочется просто мониторить состояние программы, быть уверенным, что ресурсы используются адекватно нагрузкам, нет утечек памяти или горутин и так далее. Поднимать для этого целую инфраструктуру для мониторинга — часто накладно и неоправданно, а сырой json не сильно презентабелен.
Именно для таких случаев и была за пару выходных написана программа для мониторинга переменных expvar прямо в терминале, которая требует почти нулевую конфигурацию и не использует никаких сторонних баз и ресурсов. Программа использует отличнейший пакадж [TermUI](https://github.com/gizak/termui) от любителя терминалов [gizak](http://gizak.github.io) (посмотрите его [домашнюю страничку](http://gizak.github.io)!).
#### Установка
Установка программы, как и любой другой программы на Go предельно проста:
```
go get github.com/divan/expvarmon
```
Надеюсь, $GOPATH/bin у вас прописан в $PATH.
#### Использование
##### expvar
###### Короткое объяснение
```
import _ "expvar"
```
###### Длинное объяснение
Если вы еще не знакомы с пакетом [expvar](http://golang.org/pkg/expvar/), то краткое объяснение и инструкция.
В функции [init()](http://golang.org/src/expvar/expvar.go?s=6520:6531#L332) этого пакета написано следующее:
```
func init() {
http.HandleFunc("/debug/vars", expvarHandler)
Publish("cmdline", Func(cmdline))
Publish("memstats", Func(memstats))
}
```
Первая строка регистрирует хендлер для обработки URL "/debug/vars" для стандартного http.DefaultServeMux из стандартного пакета net/http. Если вы пока не знаете, как устроен net/http, возможно это будет отдельной статьей, но сейчас вам достаточно знать, что если ваша программа стартанет стандартный http-сервер (скажем, *http.ListenAndServe(":1234", nil)*), то у нее автоматически появится обработчик GET-запроса по адресу /debug/vars. И ответ этого запроса будет по умолчанию содержать примерно следующий JSON:
```
$ curl -s http://localhost:1234/debug/vars | json_pp | head
{
"cmdline" : [
"./expvar.demo",
"-bind=:1234",
],
"memstats" : {
"NumGC" : 5,
"Alloc" : 114016,
"DebugGC" : false,
"HeapObjects" : 519,
"HeapSys" : 868352,
"StackInuse" : 180224,
```
Это JSON-репрезентация двух переменных, определенных следующими двумя строчками — командная строка и текущие значения [runtime.Memstats](http://golang.org/pkg/runtime/#MemStats). Последняя содержит массу подробностей про текущее использование памяти и работу сборщика мусора, большая часть из которых ну уж слишком подробная. Обычно для мониторинга используются значения Alloc, Sys, HeapAlloc — реально используемая память, запрошенная у OS, используемая память в куче соответственно.
Поскольку init() вызывает автоматически при импорте пакаджа, в программе достаточно добавить одну строчку:
```
import _ "expvar"
```
##### expvarmon
Данная же программа предельно проста — она с указанным интервалом вычитывает этот JSON для указанного сервиса или сервисов, и отображает его в удобном для мониторинга виде, при этом показывает sparkline-графики для числовых значений. Все что ей нужно для запуска, это порт или «хост: порт» сервиса(-ов) которые вы хотите мониторить. К примеру:
```
expvarmon -ports="80"
expvarmon -ports="23000-23010,80"
expvarmon -ports="80,remoteapp.corp.local:80-82"
```
Можно указывать как одну, так и 30+ портов/сервисов — на сколько у вас хватит размеров терминала.
Программа может также мониторить саму себя:
```
expvarmon -self
```
Интервал по умолчанию — 5 секунд, но можно указать меньше или больше. Имейте ввиду, что слишком короткий интервал не рекомендован, так как даже обновление memstats влияет на сборщик мусора и увеличивает паузы. Если ваша аппликация бежит под большой нагрузкой, сильно короткий интервал (100ms) может повлиять на продуктивность.
```
expvarmon -self -i 5m
expvarmon -self -i 30s
```
По умолчанию мониторятся следующие переменные:
* mem:memstats.Alloc
* mem:memstats.Sys
* mem:memstats.HeapAlloc
* mem:memstats.HeapInuse
* memstats.EnableGC
* memstats.NumGC
* duration:memstats.PauseTotalNs
Значения переменных берутся в том виде, в каком они есть в JSON, с записью через точку. Модификаторы «mem:», «duration:», «str:» — опциональны, и влияют на форматирование/отображение. Если указывать переменные без модификатора, то они будут отображаться как есть. Модификатор «mem:» будет конвертировать значения в «KB, MB, etc» представление, а «duration:» — конвертировать int64 значение в time.Duration(«ns, ms, s, m, etc»). Модификатор «str:» просто говорит, что значение не цифровое, и sparkline-график для этой переменной рисовать не нужно.
К примеру:
```
expvarmon -ports="80" -vars="mem:memstats.Alloc,duration:Response.Mean,Goroutines,str:Uptime"
```
Опять же, можно указать как одну переменную, так и пару десятков, насколько у вас хватит размера терминала.
В программе есть два режима — для одного сервиса и для нескольких сервисов. В первом случае графики отображаются для всех переменных, во втором — только для первых двух, в том порядке, в котором они указаны. Для графиков отображаются максимальные значения, которые наблюдались за сессию мониторинга.
#### Дополнительно
Expvarmon отображает иконками сервисы, которые падали и которые лежат в данный момент. К сожалению, если интервал опроса больше, чем время падения/рестарта сервиса, то падение сервиса программа не словит.
Также важно понимать, что данные никуда не записываются и не сохраняются. На графиках показываются последние значения — и масштаб графиков зависит от интервала и размера терминала. Ни зума, ни истории, ни поиска по времени тут нет. Это решение для более простой задачи — мгновенного мониторинга текущих значений.
Благодаря возможностям TermUI, программа динамически меняет размеры всех виджетов при изменении размера шрифта или окна терминала.
#### Дополнительные переменные
Лично мне в стандартном перечне переменных expvar не хватает двух вещей — количества запущенных горутин и аптайм сервиса. Вот демо-враппер, который экспортит три дополнительные переменные. Просто подключаете его в свою программу, одним импортом.
```
package myexpvars
import (
"expvar"
"math/rand"
"runtime"
"time"
)
var (
startTime = time.Now().UTC()
)
// goroutines is an expvar.Func compliant wrapper for runtime.NumGoroutine function.
func goroutines() interface{} {
return runtime.NumGoroutine()
}
// uptime is an expvar.Func compliant wrapper for uptime info.
func uptime() interface{} {
uptime := time.Since(startTime)
return int64(uptime)
}
// responseTime fake var.
func responseTime() interface{} {
resp := time.Duration(rand.Intn(1000)) * time.Millisecond
return int64(resp)
}
func init() {
expvar.Publish("Goroutines", expvar.Func(goroutines))
expvar.Publish("Uptime", expvar.Func(uptime))
expvar.Publish("MeanResponse", expvar.Func(responseTime))
}
```
#### Что делать, если используется сторонний http-роутер, вместо стандартного
Многие веб-сервисы на Go пишутся с использованием дополнительных веб-фреймворков или более продвинутых http-роутеров. expvar из коробки с ними работать не будет. Для него вам нужно будет таки стартануть стандартный http.ListenAndServer() на другом порту. А это даже лучше, так как открывать наружу /debug/vars крайне не рекомендуется, если речь идет о публичных веб-сервисах.
Если же вы используете стандартный net/http, но хотите, чтобы expvar был на другом порту, проще всего сделать так. «Основной» ServeMux запустить следующим образом:
```
mux := http.NewServerMux()
server := &http.Server{Addr: “:80”, Handler: mux}
server.ListenAndServe()
```
а /debug/vars повесить на стандартный
```
http.ListenAndServe(":1234", nil)
```
#### Скриншоты
[](https://habrastorage.org/files/050/acc/a2c/050acca2ca19472eabd30283683a5276.png) [](https://habrastorage.org/files/232/a2c/d13/232a2cd13fed4f9c82ee6572765933a5.png)
[](https://habrastorage.org/files/fcb/1c2/623/fcb1c262373846ceb562259b6c0822bb.png) [](https://habrastorage.org/files/c4f/12a/443/c4f12a4437754ed89512b92e23c3bc29.png)
#### Ссылки
Github: [github.com/divan/expvarmon](https://github.com/divan/expvarmon)
Expvar docs: [golang.org/pkg/expvar](http://golang.org/pkg/expvar/)
runtime.Memstats: [golang.org/pkg/runtime/#MemStats](http://golang.org/pkg/runtime/#MemStats)
|
https://habr.com/ru/post/257593/
| null |
ru
| null |
# Программируем Windows 7: Taskbar. Часть 6 – AppId
Недавно я писал о том, как можно организовать отображение вкладок для дочерних окон нашего приложения. В этом случае нам требовалось отобразить дочерние окна нашего приложения. Для этих целей мы пользовались классом CustomWindowManager.
Такого же эффекта можно добиться, если мы запустим несколько экземпляров одного и того же нашего приложения. В этом случае Windows 7 определит что это одно и то же приложение и сгруппирует окна в один значок.
Давайте попробуем разобраться как это работает. В основе всего лежит такое понятие как Application ID. Для каждого окна мы можем задать свой ID. Эту особенность также можно использовать тогда, когда необходимо избежать такого поведения. В этом случае нужно задать различные AppId для каждого такого окна. Сделать это можно используя .NET Interop Sample Library. Для этого необходимо вызвать метод SetAppId.
`private void SetAppIdButton_Click(object sender, EventArgs e)
{
WindowsFormsExtensions.SetAppId(this, “SomeAppId”);
}`
Таким образом, мы можем задать различные AppId для каждого окна и они не будут группироваться.
Однако, аналогичным образом также возможно сгруппировать несколько окон от разных приложений. Для этого необходимо задать одинаковый AppId для каждого из окон. И в этом случае панель задач Windows 7 сгруппирует эти приложения в один значок. Например, в данном случае я задал одинаковый AppId для разных окон из разных приложений и эти окна оказались сгруппированными в панели задач Windows 7.
Демонстрационное приложение:
[Taskbar-AppId.zip](http://blogs.gotdotnet.ru/personal/sergun/ct.ashx?id=8348e8de-6a20-4cc2-ae82-436e08408f02&url=http%3a%2f%2fblogs.gotdotnet.ru%2fpersonal%2fsergun%2fcontent%2fbinary%2fWindowsLiveWriter%2fWindows7Taskbar.6AppId_DD99%2fTaskbar-AppId.zip)
|
https://habr.com/ru/post/60360/
| null |
ru
| null |
# Определение местоположения пользователя с помощью Сервисов Google Play
Добрый день, Друзья!
Вопрос определения местоположения пользователя на максимальном количестве девайсов мучил меня примерно полгода. Дело доходило даже до велосипедов, описанных [тут](http://hashcode.ru/questions/243575/java-locationlistener-%D0%BF%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC%D0%B0-%D0%B2-%D0%BE%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B8-%D0%BA%D0%BE%D0%BE%D1%80%D0%B4%D0%B8%D0%BD%D0%B0%D1%82-%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8F) и [тут](http://hashcode.ru/questions/243148/android-%D0%BE%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B8%D1%82%D1%8C-%D0%BC%D0%B5%D1%81%D1%82%D0%BE%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8F). Дело было в том, что находились устройства, на которых местоположение не определялось, по неизвестной причине, однако другие приложения работали вполне хорошо. Очередной раз, копаясь в коде и рыская в просторах гула в поисках того, что я упускаю, и реализации, которой я еще не опробовал, наткнулся на свеженькую [статью-мануал](https://developer.android.com/intl/ru/training/location/retrieve-current.html) от google и, о боги(!), это заработало.
В данной статье я хочу рассказать, как я использовал это в своих целях и привести простой пример.
**Хочу исходники**[проект на github](https://github.com/rovkinmax/LocationWithGooglePlayServices)
В официальном примере показывается как все это сделать в одном activity, так как им важно показать только возможности, а мне нужно было удобство, поэтому я все вынес в отдельный класс.
Для начала работы, необходимо инициализировать экземпляры классов **LocationClient** и **LocationRequest**. Первый отвечает за доступ к основным методам API определения местоположения и Geofence, второй обслуживает LocationClient и отвечает за обновления, т.е через него осуществляются колбэки(callbacks). С помощью LocationRequest, как в примере ниже, можно задавать интервалы обновления, приоритет для точности позиционирования и интервалы обновления.
```
private LocationRequest mLocationRequest;
private LocationClient mLocationClient;
private LocationListenerGPServices(final Context context)
{
mLocationRequest = LocationRequest.create();
mLocationRequest.setInterval(UPDATE_INTERVAL_IN_MILLISECONDS);
mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
mLocationRequest.setFastestInterval(FAST_INTERVAL_CEILING_IN_MILLISECONDS);
mLocationClient = new LocationClient(context, this, this);
}
```
Далее есть два варианта развития событий: мы можем взять последнее известное местоположение или запросить поиск нового.
В моем случае, я комбинирую эти два варианта, т.е в начале я получаю последнее известное местоположение и, если оно меня устраивает, использую его, иначе я запрашиваю обновления. В коде ниже, после вызова метода **mLocationClient.connect()** должен сработать метод **onConnected(final Bundle bundle)** у интерфейса ***GooglePlayServicesClient.ConnectionCallbacks***, который означает, что нам удалось подключиться к Сервисам Google Play, т.е. теперь мы можем подписаться на обновление местоположения.
```
public void enableMyLocation()
{
log("enableMyLocation");
mLocation = null;
mLocationClient.connect();
}
private boolean useCurrentLocation()
{
final Location location = mLocationClient.getLastLocation();
if (System.currentTimeMillis() - location.getTime() < HALF_MINUTE)
{
log("useCurrentLocation");
disableMyLocation();
if (locationRunnable != null)
locationRunnable.locationUpdate(location);
return true;
}
return false;
}
```
Когда мы запросили определение местоположения, чтобы скоротать как то время и не грузить UI — поток, я использую AsynkTask в качестве таймаута, который работает какое-то заданное время, и по завершению возвращает приложению найденное местоположение и отписывается от обновлений местоположения.
```
@Override
public void onConnected(final Bundle bundle)
{
if (!useCurrentLocation())
{
mLocationClient.requestLocationUpdates(mLocationRequest, this);
if (findLocation != null && !findLocation.isCancelled())
findLocation.cancel(true);
findLocation = new FindLocation();
findLocation.execute();
}
}
private Location endFind()
{
long sec = System.currentTimeMillis();
while (this.mLocation == null && System.currentTimeMillis() - sec < TIME_OUT)
{}
return this.mLocation;
}
private class FindLocation extends AsyncTask
{
@Override
protected Location doInBackground(final Void... params)
{return endFind();}
@Override
protected void onPostExecute(final Location location)
{
if (locationRunnable != null)
locationRunnable.locationUpdate(location);
disableMyLocation();
}
}
@Override
public void disableMyLocation()
{
if (mLocationClient.isConnected())
mLocationClient.removeLocationUpdates(this);
mLocationClient.disconnect();
}
public interface LocationRunnable
{ public void locationUpdate(Location location);}
```
Собственно как это использовать пример с github:
Для начала нужно получить экземпляр класса, для себя я реализовал singletone, так как он более подходит, для моего случая
```
locationListener = LocationListenerGPServices.getInstance(this);
```
Затем подписаться на получение местоположения и делать все, что вздумается с ним.
```
locationListener.setLocationRunnable(new ILocationListener.LocationRunnable() {
@Override
public void locationUpdate(final Location location)
{}});
```
Собственно вот и все, что я хотел рассказать по данной теме. Тут я постарался рассказать вкратце, и привел минимум кода по тексту, в исходниках на github я показал на примере, как найти местоположение пользователя и отсортировать список станций метро по расстоянию до пользователя.
Спасибо за внимание, надеюсь кому-то это поможет и избавит от мучений.
|
https://habr.com/ru/post/191290/
| null |
ru
| null |
# Дисциплина, точность, внимание к деталям, часть вторая (OLAP, SSAS)
**Введение**
------------
В этой статье я продолжу рассказ о своем опыте работы с Microsoft Analysis Services. В дополнение к предыдущей статье, я хочу написать про нестандартные решения, которые были сделаны в последнем проекте. Эти решения более тесно сблизили меня с Microsoft Analysis Services, я стал больше его уважать и делать с его помощью то, что ранее мне казалось невероятным.
**Сумма средних за период**
---------------------------
Заказчик просил сумму средних значений по каждому элементу за период, как показано на картинке ниже:
****
То есть идея в том, чтобы в разрезе элементов elem1, elem2, …, elemN куб считал среднее по каждому элементу за выбранный период, во всех остальных случаях считалась сумма. Требуется, как бы поменять поведение куба для одного измерения, а для всех остальных оставить стандартное (в описываемом случае стандартное поведение это СУММА).
#### **Варианты решений:**
1. **Первый вариант:**
Для этого варианта надо создать скрытое измерение [ELEM COPY], просто создав копию [ELEM] и поставив ему свойство Visible на False. Далее в разделе куба “Calculations” выбрать “New Calculated Member”, как показано на рисунке:
и в появившемся окне для ввода выражений написать:
```
iif (
not isleaf([ELEM].[ELEM SK].currentmember),
sum(EXISTING [ELEM COPY].[ELEM SK].currentmember.Children,[Measures].[FCT VAL]),
[Measures].[FCT VAL]
)
```
, где [ELEM COPY].[ELEM SK] – это ключевой атрибут скрытого измерения.
[Measures].[FCT VAL] – это AvarageOfChildren агрегация, т.е. при сборке куба создали измерение типа AvarageOfChildren и он его автоматически рассчитал. Пример того как создать измерение с AvarageOfChildren агрегацией показан на рисунке ниже:
2. **Решение с использованием SCOPE:**
Это решение показал мне мой коллега, на мой взгляд, оно более простое для понимания, хоть и чуть сложнее в реализации.
**Что надо сделать:**
Переписать селект для таблицы фактов:
Вместо:
```
SELECT [DATE]
,ID_CO
,ID_CUST
,ID_SYS
,ID_VOL
,ID_QUAL
,GB_used_DATA
FROM [000_REP].NAS_FACTS
```
Написать:
```
SELECT [DATE]
,ID_CO
,ID_CUST
,ID_SYS
,ID_VOL
,ID_QUAL
,GB_used_DATA
,CONVERT(VARCHAR(10), [DATE], 120) + '|' + CAST(ID_VOL AS VARCHAR(MAX)) AS VolDate
,NULL AS Avg_GB_used_DATA
FROM [000_REP].NAS_FACTS
```
, где GB\_used\_DATA это факт, который мы хотим добавить в куб. Нестандартное поведение мы хотим сделать для измерения с ключом ID\_VOL, для остальных измерений с ключами ID\_CO, ID\_CUST, ID\_SYS и ID\_QUAL поведение должно быть стандартным и в нашей задаче всё должно просто суммироваться. Только по ID\_VOL должно считаться среднее за период по каждому элементу, а итог по ID\_VOL элементам так же должен суммироваться, должна получиться сумма средних значений по ID\_VOL.
**Во втором запросе добавили 2 колонки:**
* 1-ая колонка уникально определят связку даты с ID элементами, по которым надо считать сумму средних значений. В кубе по этой колонке добавляется измерение с функцией агрегации DistinctCount. Пример на рисунке ниже:
* 2-ая колонка всегда хранит значение NULL во всех строках таблицы. У второй колонки важно её название, оно нужно для того чтобы можно было создать измерение в кубе, к которому можно было бы привязаться с помощью функции SCOPE. Так же важно то, что для данной меры используется функция агрегации Sum. Пример ниже:
Далее в разделе куба “Calculations” выбрать “Script View”, и в окне для редактирования скрипта надо вставить такой код:
```
SCOPE([Measures].[Avg GB Used DATA]);
SCOPE([ID_VOL Items].[ID VOL].[ID VOL].MEMBERS);
THIS = [Measures].[Sum GB Used DATA]/[Measures].[Vol Date Distinct Count];
END SCOPE;
END SCOPE;
```
где [ID\_VOL Items] это измерение, ключ у которого ID\_VOL.
На рисунке показана последовательность действий для этого шага:
В этом решении мы суммируем только то выражение, которое прописано в SCOPE, так как без формулы в SCOPE у нас там хранится значение NULL, которое приходит из запроса к Базе Данных.
Оба решения дали один и тот же результат и на выходе считали сумму средних, что и требовалось в задании.
**Statistical Average**
-----------------------
Спустя какое-то время заказчик вернулся к теме подсчета средних величин. На этот раз, он потребовал не сумму средних, а классическое среднее, то есть тот же функционал, что и у функции AVERAGE в Excel. Заказчик постоянно оперировал понятием “Statistical Average”, отсюда название этой главы.
Требовалось рассчитать среднее значение по всему диапазону. Берётся среднее по всем элементам за каждый день, суммируется и делится на количество дней в периоде. В итоге получается усредненное значение на один элемент за период. Было предложено следующее решение:
```
CREATE MEMBER CURRENTCUBE.[Measures].[Avg GB Used DATA (AvgAll Only valid days)]
as
[Measures].[Sum GB Used DATA]/[Measures].[Count VCMDB Only valid days],
VISIBLE = 1 ;
CREATE MEMBER CURRENTCUBE.[Measures].[Count VCMDB Only valid days]
as
Count(NonEmpty({crossjoin([DIM Business Time HD].[DAY].currentmember.Children,[DIM NAS Provider Configuration Item HD].[NAS Volume CMDBID].currentmember.Children)}, [Measures].[Sum GB Free Data] )),
VISIBLE = 1 ;
```
В данном решении брались только дни, где были значения у элементов. Так же использовался трюк со скрытым измерением (это измерения [DIM Business Time HD].[DAY] и [DIM NAS Provider Configuration Item HD].[NAS Volume CMDBID]). Количество дней, когда были значения, я получил с помощью crossjoin.
Если же надо получить среднее по всем значениям за все дни, где отсутствие значения за какой либо день приравнивается к 0, то я использовал следующее выражение:
```
CREATE MEMBER CURRENTCUBE.[Measures].[Count VCMDB All days]
as
[Measures].[NAS Volume CMDBID Distinct Count] * [Measures].[NAS BTIME Count],
VISIBLE = 1 ;
CREATE MEMBER CURRENTCUBE.[Measures].[Count VCMDB All days]
as
[Measures].[NAS Volume CMDBID Distinct Count] * [Measures].[NAS BTIME Count],
VISIBLE = 1 ;
```
где [Measures].[NAS Volume CMDBID Distinct Count] и [Measures].[NAS BTIME Count] это меры куба, построенные по таблицам для измерений (временное измерение и измерение элемента):
**Ещё одна полезная функция**
-----------------------------
В процессе работы с кубом выдвигались требования, в которых расчет значений менялся от того, на каком уровне иерархии его хотели видеть. То есть, если выбраны дни, то мы видим, среднее за период, если месяцы то сумму. Это было сделано с помощью функции level:
```
CREATE MEMBER CURRENTCUBE.[Measures].[ML]
as
case
when [DIM Business Time].[HIERARCHY CAL].currentmember.level is [DIM Business Time].[HIERARCHY CAL].[YEAR] then 3
when [DIM Business Time].[HIERARCHY CAL].currentmember.level is [DIM Business Time].[HIERARCHY CAL].[PERIOD KAL] then 2
when [DIM Business Time].[HIERARCHY CAL].currentmember.level is [DIM Business Time].[HIERARCHY CAL].[DAY] then 1
else 4
end,
VISIBLE = 1;
```
**Итог**
--------
Честно говоря, когда я видел требования по расчету средних значений, мне хотелось смеяться и плакать одновременно. Смеяться от того, что порой среднее значение было либо больше всех значений в выбранном диапазоне (как в примере с суммой средних), либо меньше. Случай с меньше я не стал описывать в статье, так как не смог понять смысл — заказчик требовал делить значение за каждый день на количество дней в месяце. А плакать приходилось от того, что эти требования надо было как-то реализовывать.
Попытки ограничится стандартным AvarageOfChildren, которая суммирует все показатели за день, затем складывает эти суммы и делит на количество дней в периоде, успеха не имели. Заказчик настойчиво требовал соответствия реальности его картине мира. Все наши решения подвергались жесткому и скрупулёзному тестированию. Вопрос о доверии между нами и клиентом отпал на ранних этапах взаимодействия. Он постоянно искал подвоха и решение, вместо простого и интуитивно понятного, превратилось в нечто странное и монструозное. Но во всем есть своя польза. Благодаря таким требованиям, пришлось более детально разобраться с работой OLAP куба и научится работать с произвольными агрегациями. Чтобы этот опыт был не напрасен и помогал в будущем решать похожие задачи не только мне, я решил поделиться им с Вами. В общем, как в анекдоте про сантехников:
> К сантехнику прикрепили практиканта. Вызывают на выезд. Приезжают. Канализационный люк. Из него течет дерьмо. Сантехник подходит к люку и ныряет.
>
> Через минуту выныривает, кричит:
>
> — Ключ на 19.
>
> Снова ныряет. Через полминуты выныривает:
>
> — Прокладку No.6.
>
> Опять ныряет. Выныривает:
>
> — Ключ на 26.
>
> Ныряет. Через минуту выныривает. Выходит, отряхивается и закуривает. Сел, отдышался и говорит практиканту:
>
> — Вот так!.. Учись, студент! А то так и будешь всю жизнь ключи подавать...
|
https://habr.com/ru/post/328688/
| null |
ru
| null |
# Знакомство с MSP432: пишем простую программу
В этом году Texas Instruments запустили в производство новую серию микроконтроллеров MSP432. Пока в серии только один МК MSP432P401R, который уже доступен для заказа в конторах, торгующих электронными компонентами. Также для этой серии имеется отладочная плата MSP432-Launchpad, в которую интегрирован отладчик XDS110. Основные характеристики серии:
* 32-х разрядное ядро Cortex-M4 с FPU
* Тактовая частота до 48 МГц
* Заявлена совместимость по периферии с MSP430
* Ультранизкое энергропотребление (как для MSP430)
* Совместимость с GCC для ARM
Об остальных характеристиках можно прочитать на сайте TI. Для меня наиболее важным является заявленная совместимость с MSP430, поэтому я приобрёл MSP432-Launchapd, и решил проверить это на практике. Периферия для MSP430 значительно проще в программировании, чем STM32 и 8-битные МК, поэтому MSP432 выглядит очень заманчиво.
Под катом будет рассказано как собрать и прошить минимальный проект (светодиодоморгалку) для MSP432, используя GCC для ARM на платформе Linux. Никакая IDE не используется.
Железо
------
Внешний вид платы MSP432-Launchpad можно видеть на КДПВ до ката. Здесь ничего особенного. На плате собственно сам МК, разъём microUSB, гребёнка для подключения к портам МК, разъём JTAG, три кнопки (RESET и для подключены к портам МК) и два светодиода (красный и трёхцветный). Имеется встроенный преобразователь USB-UART. К МК подключен кварц, от которого работает система тактирования.
Подготовка инструментов
-----------------------
### Компилятор
Первым делом понадобится установить то, чем мы собираемся компилировать и прошивать. В качестве компилятора можно использовать любую сборку GCC для ARM, которая поддерживает Cortex M4. Внутри у MSP432 обычный Cortex, и никаких особенностей здесь нет. Например GCC для ARM можно установить, используя пакетный менеджер вашего дистрибутива. Нужно установить пакет `gcc-arm-none-eabi`. Если его нет, то GCC для ARM можно взять здесь: <https://launchpad.net/gcc-arm-embedded/+download>
### Прошивка
С прошивальщиком для MSP432 дела обстоят значительно хуже. OpenOCD не поддерживает эту архитектуру. Поэтому здесь возможны два выхода:
* Использовать утилиту Uniflash от TexasInstruments <http://www.ti.com/tool/uniflash> Она доступна для всех платформ.
* Использовать экспериментальную сборку OpenOCD отсюда: <https://github.com/ungureanuvladvictor/openocd-code>
#### Использование Uniflash
Uniflash — это утилита для прошивки, которая работает в режиме GUI или CLI. Использовать её не так удобно, как OpenOCD, но другого варианта пока нет.
После того как скачали и установили Uniflash, нужно сгенерировать Shell-скрипт и XML-конфиг для прошивки. Для этого нужно запустить GUI Uniflash, возможно от пользователя `root`. GUI это исполняемый файл `nw` в каталоге `node-webkit`. Подключаем плату и запускаем его. Видим следующее окно, в котором нужно выбрать
`MSP->MSP432 Launchpad` и XDS110.
Теперь нужно сгенерировать конфиг и скрипт-прошивальщик. Для этого нажимаем Start и выбираем Satndalone Command Line. Потом жмём Generate:
Создаётся архив, содержащий сгенерированный прошивальщик. Распаковываем его куда-либо и следуем инструкции, отображаемой в окне Uniflash. Чтобы запустить прошивку, нам нужен будет скрипт `dslite.sh` и путь к файлу конфигурации для нашей платы. Допустим, мы распаковали сгенерированный архив в `/opt/uniflash`, а прошивка находится в файле `device.hex`. Тогда прошить плату можно командой:
```
/opt/uniflash/dslite.sh --config=/opt/uniflash/user_files/configs/msp432p401r.ccxml device.hex
```
Прошивка получается после компиляции проекта. Об этом будет рассказано в следующем разделе.
#### Неофициальная сборка OpenOCD
OpenOCD не поддерживает MSP432. В поставке имеются файлы конфигурации для MSP432. Используя драйвер CMSIS-DAP, можно успешно соединиться с платой. Но при попытке записи во флэш выдаётся ошибка, т.к. драйвер флеша для MSP432 отсутствует.
Имеется неофициальная версия openOCD с поддержкой MSP432. Исходный код доступен здесь: <https://github.com/ungureanuvladvictor/openocd-code> Чтобы его использовать, нужно собрать и установить openOCD. Так как данная ветка неофициальная, заменять им системный openOCD не рекомендуется. Лучше его установить например в `/opt/oocd-msp432` Сборка и установка производится стандартно:
```
git clone https://github.com/ungureanuvladvictor/openocd-code
cd openocd-code
./bootstrap
./configure --enable-cmsis-dap --prefix=/opt/oocd-msp432
make
make install
```
Теперь можно соединиться с платой, используя мой конфиг для MSP432: [msp432.cfg](https://raw.githubusercontent.com/ra3xdh/msp432_template/master/msp432.cfg) :
```
/opt/oocd-msp432/bin/openocd -f msp432
```
Прошить файл `device.bin` можно при помощи следующей последовательности команд OpenOCD, которую следует вписать куда-либо в Makefile:
```
init
reset halt # Стоп
msp432p4 init 0 # Инициализация Flash
msp432p4 mass_erase 0
msp432p4 init 0
flash write_image device.bin # Запись во Flash здесь
reset run # Заупск
shutdown
```
Если всё нормально, то получаем следующий вывод от OpenOCD:
```
Open On-Chip Debugger 0.9.0-dev-g42aa8fa-dirty (2016-11-17-13:37)
Licensed under GNU GPL v2
For bug reports, read
http://openocd.sourceforge.net/doc/doxygen/bugs.html
Info : only one transport option; autoselect 'cmsis-dap'
Info : CMSIS-DAP: SWD Supported
Info : CMSIS-DAP: JTAG Supported
Info : CMSIS-DAP: Interface Initialised (SWD)
adapter speed: 1000 kHz
adapter_nsrst_delay: 100
cortex_m reset_config sysresetreq
Info : CMSIS-DAP: FW Version = 1.0
Info : SWCLK/TCK = 0 SWDIO/TMS = 1 TDI = 0 TDO = 0 nTRST = 0 nRESET = 1
Info : DAP_SWJ Sequence (reset: 50+ '1' followed by 0)
Info : CMSIS-DAP: Interface ready
Info : clock speed 1000 kHz
Info : IDCODE 0x2ba01477
Info : cortex_m.cpu: hardware has 6 breakpoints, 4 watchpoints
```
#### Правила udev
Чтобы можно было работать с платой от обычного пользователя, следует создать файл правил для `udev` в каталоге `/etc/udev/rules.d` Например, назовём его `60-msp432-launchpad.rules`. Содержимое фала следующее:
```
KERNEL=="hidraw*",ATTRS{idVendor}=="0451",ATTRS{idProduct}=="bef3",MODE="0666"
SUBSYSTEM=="usb",ATTR{idVendor}=="0451",GROUP="plugdev",MODE="0666"
SUBSYSTEM=="usb_device",ATTR{idVendor}=="0451",GROUP="plugdev",MODE="0666"
```
Затем нужно перезагрузить правила udev.
Светодиодоморгалка для MSP432
-----------------------------
### Структура проекта
Чтобы написать и собрать программу для MSP432 понадобится CMSIS и скрипт линкера. Всё можно взять с сайта TI: Нужен [msp432-gcc-support-files.zip](http://software-dl.ti.com/msp430/msp430_public_sw/mcu/msp430/MSP432GCC/latest/exports/msp432-gcc-support-files.zip), в котором находится всё вышеназванное. Но можно воспользоваться моим шаблоном проекта, который содержит CMSIS, Makefile, и минимальную программу. Только следует исправить пути к компиляторам и т.п. Взять его можно здесь: <https://github.com/ra3xdh/msp432_template> Далее будем рассматривать этот тестовый проект.
Итак, проект на MSP432 должен иметь следующую структуру:
```
msp432_template\
│
├── Makefile
├── cmsis
│ ├── include
│ │ ├── CMSIS
│ │ │ ├── cmsis_gcc.h
│ │ │ ├── core_cm4.h
│ │ │ ├── core_cmFunc.h
│ │ │ ├── core_cmInstr.h
│ │ │ └── core_cmSimd.h
│ │ ├── msp.h
│ │ ├── msp432.h
│ │ ├── msp432p401m.h
│ │ ├── msp432p401m.lds
│ │ ├── msp432p401m_classic.h
│ │ ├── msp432p401r.h
│ │ ├── msp432p401r.lds
│ │ ├── msp432p401r_classic.h
│ │ ├── msp_compatibility.h
│ │ ├── system_msp432p401m.h
│ │ └── system_msp432p401r.h
│ └── src
│ ├── interrupts_msp432p401m_gcc.c
│ ├── interrupts_msp432p401r_gcc.c
│ ├── startup_msp432p401m_gcc.c
│ ├── startup_msp432p401r_gcc.c
│ ├── system_msp432p401m.c
│ └── system_msp432p401r.c
└── main.c
```
В корне лежит файл `main.c` и `Makefile`, в подкаталоге `cmsis` находится CMSIS. Здесь содержатся заголовки общие для Cortex-M4 и описание периферии MSP432 в файле `msp432.h`.
Makefile можно посмотреть в моём шаблоне проекта. Опции компилятора и линковщика — стандартные для Cortex-M. Команда `make` без целей собирает проект. Получаются файлы ELF, BIN, и HEX, которые нужно прошивать в МК. Цель `make burn` программирует МК при помощи Uniflash, а `make flash` — при помощи OpenOCD.
### Минимальная программа
Собственно программа находится в файле `main.c`. Вот его содержимое:
```
#include "msp432.h"
int main(void)
{
SystemInit();
P1DIR = 0x01;
P1OUT = 0x01;
while(1);
return 0;
}
```
Здесь мы зажигаем красный светодиод, подключенный к ножке P1.0 и уходим в бесконечный цикл. Как можно видеть, пример значительно проще чем аналогичный для STM32. Не требуются ни SPL, ни Cube, ни HAL, ни Libopencm3. От аналогичного примера для MSP430 отличается только двумя строками: вместо `msp430.h` нужно писать `msp432.h`, и появляется функция `SystemInit()`. На ней нужно остановиться подробнее. Функция берётся из CMSIS и инициализирует систему тактирования, WDT и т.п. В частоности, там инициализируется тактовая частота. Чтобы её поменять, нужно найти файл `cmsis/src/system_msp432p401r.c` и отредактировать в нём строку:
```
#define __SYSTEM_CLOCK 3000000
```
Из названия понятно, что макрос `__SYSTEM_CLOCK` задаёт тактовую частоту в Герцах. Последняя строка `return 0` нужна, чтобы подавить warning от GCC.
Как видим, пока всё хорошо, заявленная совместимость с MSP430 выполняется на 100%.
Скомпилировать и прошить этот проект можно стандартным способом:
```
make
make burn
```
### Светодиодоморгалка
Напишем более сложную светодиодоморгалку. Будем мигать трёхцветным светодиодом (он подключен к порту P2) и параллельно красным светодиодом. Для этого будем использовать таймер TMRA, который присутствовал в MSP430. Нам понадобится использовать прерывания. Код светодиодомоглаки `main.c` выглядит так:
```
#include "msp432.h"
#include
int main(void)
{
SystemInit();
P1DIR = 0x01;
P1OUT = 0x00;
P2DIR = 0x07;
P2OUT = 0x00;
// Инициализируем таймер А
TA0CTL = TASSEL\_1 + MC\_1 + TACLR + TAIE ;
TA0CCTL0 = CCIE;
TA0CCR0 = 0xF000;
// Разрешаем прерывания
NVIC\_EnableIRQ(TA0\_0\_IRQn);
\_\_enable\_irq();
\_\_wfi();
for (;;) {
for (uint32\_t i=0;i<0xFFFFF;i++) {
\_\_no\_operation();
}
P1OUT ^= 0x01;
}
return 0;
}
// Прерывание по таймеру
void TA0\_0\_IRQHandler()
{
static uint16\_t led = 0;
if (TA0IV==0x0E) {
led ++;
if (led>7) led = 0x00;
P2OUT=led;
}
TA0CCTL0 &= (~CCIFG);
}
```
Здесь требуется переписывать реализацию прерываний. В первый раз это не очень понятно как сделать, но потом становится ясно. Отличия от MSP430 следующие:
* Разрешать прерывания нужно двумя макросами:
```
__enable_irq();
__wfi();
```
В MSP430 для этой цели служил один ```__enable_interrupt()`. Здесь же первый макрос собственно разрешает IRQ, а второй означает "ждать прерывания" (wait for interrupt).
* Кроме того, нужно разрешить номер IRQ через NVIC. Обозначения прерываний можно найти в файле `interrupts_msp432p401r_gcc.c`
Но тем не менее, совместимость с MSP430 на хорошем уровне. Код инициализация таймера и тело обработчика прерываний совпадают с аналогичным кодом для MSP430 на 100%. Программировать под MSP432 приятней, чем под STM32, что отмечают все, кто работал с этими двумя семействами МК. Прошиваем и запускаем эту программу и видим мигающие светодиоды на плате:
Заключение
----------
В данной статье рассмотрено создание простейшего проекта для MSP432. Как видно, MSP432 имеет достаточно хорошую совместимость с MSP430. Код для MSP430 может быть портирован после некоторой адаптации. Поэтому данная архитектура может заинтересовать тех, кто уже знаком с MSP430. Также периферия MSP432 отличается значительной простотой. Чтобы программировать, не требуется библиотек наподобие SPL или Libopencm3. Но имеются и недостатки. Это плохая поддержка со стороны open-source решений для прошивки и отладки и недостаток информации по данной архитектуре. Для STM32 имеется громадной количество статей и примеров, развитое сообщество, форумы и т.п. Для MSP432 же основной источник информации — даташиты и руководства от TexasInstruments.
Полезные ссылки
---------------
* MSP432 Family guide: <http://www.ti.com/lit/pdf/SLAU356>
* Даташит MSP432P401R: <http://www.ti.com/lit/gpn/msp432p401r>
* Руководство по портированию кода с MSP430 на MSP432 (MSP432 porting guide) <http://www.ti.com/lit/an/slaa656b/slaa656b.pdf>
* Шаблон проекта для MSP432 и GCC-ARM: <https://github.com/ra3xdh/msp432_template>
* Неофициальный форк OpenOCD c поддержкой MSP432: <https://github.com/ungureanuvladvictor/openocd-code>
|
https://habr.com/ru/post/315612/
| null |
ru
| null |
# Angular обертка для Apache Cordova плагина для работы с серсивисом Card.IO
#### Всем доброго времени суток
Последние несколько месяцев занимаюсь разработкой гибридных мобильных приложений, с использованием Ionic фраемворка и Cordova плагинов. Поскольку сам Ionic использует AngularJs, то использование библиотеки [ngCordova](http://ngcordova.com/) было очень удобным из-за Angular обертки.
Но возникла необходимость внедрить в проект поддержку сервиса [CardIO.](https://www.card.io/) CardIO предоставляет функционал для сканирования фронтальной части кредитной карты. Информация о cvv вводится вручную.
Поискав на сайте Cordova плагин для этого сервиса, и выбрав среди нескольких существующих вариантов, остановился на этом — [Plugin](http://plugins.cordova.io/#/package/com.keepe.cardio). Использовать его в чистом виде не хотелось, потому решил написать Angular обертку для этого плагина, для его дальнейшего использования.
В итоге получилось следующее [angular-cordova-cardio](https://github.com/daruwanov/angular-cordova-cardio)
Данная Библиотека предоставляет Сервис и Провайдер для его настройки.
Пример использования библиотеки:
```
angular.module('habraExample', ['ngCardIO'])
.config(['$cordovaNgCardIOProvider', function ($cordovaNgCardIOProvider) {
$cordovaNgCardIOProvider.setScanerConfig(
{
"expiry": true,
"cvv": true,
"zip": false,
"suppressManual": false,
"suppressConfirm": false,
"hideLogo": true
}
);
$cordovaNgCardIOProvider.setCardIOResponseFields(
[
"card_type",
"redacted_card_number",
"card_number",
"expiry_month",
"expiry_year",
"cvv",
"zip"
]
);
}]
)
.controller('TestCtrl', function ($scope, $cordovaNgCardIO) {
$scope.scan = function () {
$cordovaNgCardIO.scanCard().then(
function (response) {
//response is an object with scan data
}
);
}
}
);
```
Сервис Возвращает promise.
В случае его resolve — возвращается данные карты.
В случае reject, я все время возвращаю null. (из-за того что в самой библиотеке в errorСallback не возвращается ничего. Да и как таковой ошибки тут возникнуть не может. Объясню:
Работа плагина заключается в следующем:
— Мы нажимаем сканировать карту, открывается окно с поиском и сканирования
— В случае первого запуска идет запрос на получения прав доступа приложения к камере. Если мы не разрешили, или камера сломана, или не доступна по любой причине, автоматически откроется диалог ручного ввода данных карты.
— Так же есть кнопка переключения между ручным вводом и камерой(если она доступна).
— Если данные не удалось распознать то не достающие данные вводятся вручную.
— После чего кнопка Done и вызовет successCallback.
— Только в случае отмены сканирования или ручного ввода — вызовет errorCallback — в который ничего не передается. И я просто возвращаю null.
Что касается $cordovaNgCardIOProvider, то он имеет два метода.
setScanerConfig — для установки параметров сканирования.
```
"expiry": true, //Использовать expire date в ручном вводе или при сканировании
"cvv": true, //Использовать cvv в ручном вводе или при сканировании
"zip": false, //Использовать zip в ручном вводе или при сканировании
"suppressManual": false, // Это и 3 параметра ниже не уверен для чего они... судя по названию должны подавлять (запрещать) ручной ввод... но этого не происходит.
"suppressConfirm": false,
"hideLogo": true
```
setCardIOResponseFields — После сканирования в successCallBack идет возврат всех полей которые были считаны. Используя этот параметр, мы можем отсечь часть данных перед возвратом пользователю.
```
//список полей которые можно передать.
"card_type", //Тип карты Visa|MasterCard etc
"redacted_card_number", // Номер карты в скрытом режиме **** **** **** 1234
"card_number", //Полный номер карты 1234 5678 9000 1234
"expiry_month", //Месяц 01 02 etc
"expiry_year", // Год 2015 2016
"cvv", // сvv
"zip" // Если был запрошен в параметре выше
```
В ближайшее время выложу в bower репозитории, и планирую сделать PR в ngCordova.
Так же хочу расширить возвращаемые данные что бы год возвращался в формате 2 чисел, а не 4 как возвращает Сordova plugin.
|
https://habr.com/ru/post/260437/
| null |
ru
| null |
# Разработка Chrome Extension вместе с Angular CLI
Разработкой расширений к Chrome я занимаюсь давно и за это время я прошел целый путь от Greasemonkey юзер-скриптов до полноценного Angular-приложения в оболочке chrome-extension. Моя задача в том, что я патчу некоторые уже работающие сайты, чтобы изменить их функционал и автоматизировать некоторые процессы на этих сайтах. Иногда моё приложение разрастается до больших масштабов и поддерживать plain-js расширение становится сложно (в приложении много настроек, CRUD функционала и тд). И тут на помощь приходит Angular.
В этой статье я расскажу вам как я подружил *Chrome Extension* и *Angular CLI*, и наладил процесс разработки, а также с какими трудностями я сталкивался и как их решал.
Создаем новую папку и инициализируем в ней новое приложение
```
mkdir new-project
cd new-project
ng new frontend --routing=true --skipGit=true --style=scss --skipTests=true
```
В стадии development *Angular* генерирует динамический html-файл, в котором происходит разработка, а хромовскому расширению нужно скармливать статичный html-файл, чтобы видеть результат работы. Конечно, можно отдельно собрать Ангуляровский проект и затем build-версию уже прописать в дополнение, но будет удобно, если это будет происходить автоматически.
После генерации нового приложения заходим в папку frontend и в файле package.json в раздел scripts добавляем новый скрипт для сборки нашего проекта
```
"developing": "ng build --watch --deploy-url /frontend/dist/frontend/ --base-href /frontend/dist/frontend/index.html?/"
```
Обратите внимание на `deploy-url` и `base-href`.
Затем в корне проекта создаем еще одну папку *extension* и в ней создадим файл *extension.js*, который будет являться *background*-скриптом для нашего расширения. Текущая структура проекта:
```
| new-project/
| | extension/
| | | extension.js
| | frontend/
| | | ...
```
Содержимое *extension.js*
```
const ANGULAR_HTML_URL = "../../frontend/dist/frontend/index.html";
chrome.browserAction.onClicked.addListener(function () {
chrome.tabs.create({
url: chrome.runtime.getURL(ANGULAR_HTML_URL)
});
});
```
Это будет *browserAction*, который откроет новую вкладку с нашим ангуляр-приложением, которое в собранном виде будет уже храниться по этому пути.
**Добавим manifest.json в наш проект**
```
{
"manifest_version": 2,
"name": "Simple Chrome Ext",
"description": "Simple Chrome Extension as an example",
"version": "1.00",
"author": "Bogdan",
"content_security_policy": "script-src 'self' 'unsafe-eval'; object-src 'self'",
"background": {
"persistent": true,
"scripts": ["/extension/extension.js"]
},
"browser_action": {
"default_title": "Chrome ext"
}
}
```
Теперь мы можем собрать наш проект в расширение. Заходим в *chrome://extensions/*, включаем режим разработчика и выбираем *Загрузить распакованное расширение*.
**Результат**
Удобство в том, что у нас есть почти hot-reloading. Мы запустили *ng build* с флагом *watch* и при изменении кода проект будет пересобираться и js-файлы будут подменяться. То есть, на странице расширения нам нужно всего лишь перезагрузить страницу и все обновления подхватятся. Это значительно ускоряет разработку дополнений.
Еще один момент, на котором я собаку съел, это что в конфигурации роутинга:
```
{
useHash: true
}
```
а также вернемся выше, *base-href* при билде мы прописали как */frontend/dist/frontend/index.html?/* — обратите внимание на знак вопроса перед последним слэшем. Дело в том, что на некоторых системах, при переходе по ссылкам в ангуляровском приложении, все крашится без этого знака. Судя по всему, статический веб-сервер движка хрома воспринимал изменение URL как запрос к другому файлу (даже несмотря на useHash: true) и при обновлении страницы возвращал 404 ошибку. Только в таком сочетании мне удалось добиться стабильной работы на всех системах.
Вернемся к *package.json* нашего приложения и добавим еще один скрипт
```
"prod": "ng build --sourceMap false --prod true --deploy-url /frontend/dist/frontend/ --base-href /frontend/dist/frontend/index.html?/"
```
Это будет скрипт для сборки нашего приложения для production версии.
В Chrome Web Store постится zip-архив с расширением и чтобы упростить сборку я сделал скрипт для этих целей
**update.sh**
```
#!/bin/bash
rm -rf ./prod-build
mkdir -p prod-build/frontend
cd frontend
npm run prod
cd ..
cp -R ./frontend/dist ./prod-build/frontend
cp -R ./extension ./prod-build
cp ./manifest.json ./prod-build
zip -r prod-build{.zip,}
rm -rf ./prod-build
```
Исходный код можно посмотреть [**тут**](https://github.com/mbogdan0/chrome-extension).
Итого: мы создали заготовку для разработки Angular Chrome Extension с правильным роутингом и удобным обновлением/сборкой приложения.
P.S.: чтобы избавиться от такого */frontend/dist/frontend/* пути, можно настроить environment и в продакшн сборке по-другому прописывать путь, но это уже не ключевой момент.
|
https://habr.com/ru/post/458556/
| null |
ru
| null |
# Разработчики теперь могут использовать сетевой API Valve для своих игр в Steam
Последние несколько лет Valve работали над улучшением качества мультиплеера в Dota 2 и CS:GO при помощи ретрансляции трафика и его переноса на свою сетевую магистраль. Это позволяет защищать игры от DoS-атак, понижает пинг и повышает качество соединения. В SDK Steamworks версии 1.44 [Valve выкатили новый API](https://partner.steamgames.com/doc/api/ISteamNetworkingSockets), предоставляющее доступ к этой службе всем партнёрам Steam.
Valve опубликовали [специальный пост](https://steamcommunity.com/groups/steamworks#announcements/detail/1791775741704351698). API включает в себя:
* Доступ к сети Valve, что позволяет защитить игроков от атак, предоставляет надёжное стопроцентное прохождение NAT и улучшенное соединение.
* Инструменты для мгновенной оценки пинга между двумя произвольными узлами без отправки пакетов.
* Высококачественное соединение по надёжному UDP-протоколу со сквозным шифрованием.
### Доступ к сети Valve
У Valve имеются узлы ретрансляции, развёрнутые в 30 сетевых точках подключения по всему миру с пропускной способности несколько терабит. Можно выделить, как минимум, несколько преимуществ сети.
Во-первых, ретрансляция трафика анонимна и защищает игровые серверы и пользователей от DoS-атак. Кроме того, поскольку решения о маршрутизации осуществляются клиентом динамично, если узел ретрансляции становится недоступным, клиент может переключиться на другой узел в течение нескольких секунд или, при необходимости, на другую точку подключения. Злоумышленник сможет нарушить игровой процесс, только если его атака способна перегрузить сразу несколько центров обработки данных.
Во-вторых, клиенты смогут выбирать маршрут, как можно скорее переводящий их с общедоступного интернет-соединения на выделенные. На своей сетевой магистрали Valve гарантирует оптимальную маршрутизацию, так как они сотрудничают с более чем 2500 интернет-провайдерами. Кроме того, чувствительный к задержкам игровой трафик имеет приоритет над загрузками контента по HTTP. Это возможно, поскольку доля игрового трафика в используемой пропускной способности относительно невелика. На сетевой магистрали внезапный всплеск трафика, не относящегося к играм, не повлияет на качество игры.
Вишенкой на торте является уменьшение пинга! Протокол Valve даёт клиенту возможность выбрать маршрут, по которому будут рутиться запросы. Клиент учитывает каждую точку подключения ретрансляции, определяет сквозную задержку на маршруте и затем выбирает маршрут с наименьшей задержкой.
Если разрешить клиентам выбирать маршрут, их соединение будет лучше дефолтного на удивление часто. Проанализировав 16 млн. подключений уникальных клиентских IP-адресов к выделенным серверам в центрах обработки данных Valve, они получили следующие результаты:
* Время пинга уменьшилось у 43% игроков.
* У 25% игроков время пинга уменьшилось на 10 и более мс.
* У 10% игроков время пинга уменьшилось на 40 и более мс.
Объём улучшений по регионам различается.
### Инструменты оценки пинга
Функции интерфейса [`ISteamNetworkingUtils`](https://partner.steamgames.com/doc/api/ISteamNetworkingUtils) включают инструменты для оценки пинга, основанные на сети ретрансляции. Измеряя время пинга до разных узлов ретрансляции, мы генерируем координаты, описывающие расположение хоста в интернете. С помощью двух таких наборов координат Valve может весьма точно оценить время пинга между двумя произвольными узлами без отправки пакетов. Эта функция чрезвычайно полезна при подборе игр и выборе узла одноранговой сети.
### Сквозной протокол с открытым исходным кодом
`SteamNetworkingSockets` не только предоставляет доступ к функциям на основе сети ретрансляции Valve и к сетевой магистрали для партнёров Steam, но и является универсальной транспортной библиотекой для игр, предлагая следующие возможности:
* Фрагментация, сборка и ретрансляция. В своём коде вы отправляете и получаете сообщения, которые могут быть меньше или больше сетевых пакетов. Для повышения эффективности протокол объединяет несколько небольших сообщений в один пакет, разбивает большие сообщения на несколько пакетов, собирает их на принимающей стороне и повторно передаёт сегменты надёжных сообщений, утерянных из-за потери пакетов.
* Шифрование и аутентификация. Безопасность — это не второстепенная задача для современной сетевой игры: уязвимость может испортить впечатление от игры. Надлежащее шифрование — действительно сложная задача. Valve руководствовались современными стандартами для надёжных трансляций и применили их к ненадёжным сообщениям, используемым играми. Встроенное шифрование по умолчанию защищает данные от перехвата. Защита от атак с перехватом требует, чтобы доступ к сертификату или общему секрету выдавал доверенный сторонний участник. Steam является таковым для своих игр: чтобы злоумышленник мог перехватывать или видоизменять пакеты, он должен находиться внутри игрового процесса, где его обнаружит система VAC.
* Базовые функции этого API также доступны в [версии с открытым исходным кодом](https://github.com/ValveSoftware/GameNetworkingSockets). Valve хочет, чтобы разработчики в полной мере пользовались преимуществами [API](https://suvitruf.ru/2019/03/14/4372/steam_devs_can_now_use_the_networking_apis_created_for_csgo_and_dota_2/), и это было бы невозможно без уверенности в том, что доступ к исходному коду бесплатен.
### Это ещё не всё
Это первое из серии обновлений, направленных на улучшение работы игр по сети для партнёров Steam. Пока что Valve только улучшили работу одноранговых сетей, но помимо этого они планируют дать партнёрам доступ к наработкам, использующимся для их выделенных серверов.
|
https://habr.com/ru/post/443782/
| null |
ru
| null |
# Контейнеры и безопасность: seccomp
Для работы с потенциально опасными, непроверенными или просто «сырыми» программами часто используются так называемые песочницы (sandboxes) — специально выделенные среды с жёсткими ограничениями. Для запускаемых в песочницах программ обычно сильно лимитированы доступ к сети, возможность взаимодействия с операционной системой на хост-машине и считывать информацию с устройств ввода-вывода.
В последнее время для запуска непроверенных и небезопасных программ всё чаще используются контейнеры.
Но контейнер (даже несмотря на большое количество общих черт) полным аналогом песочницы не является — уже хотя бы потому, что песочницы, как правило, «заточены» под конкретные приложения, а контейнеризация представляет собой более универсальную технологию. И приложение, запущенное в контейнере, вполне может получить доступ к ядру и компрометировать его. Именно поэтому в современных инструментах контейнеризации используются механизмы для повышения уровня безопасности. В сегодняшней статье мы бы хотели поговорить об одном из таких механизмов — [seccomp](https://www.kernel.org/doc/Documentation/prctl/seccomp_filter.txt).
Сначала мы разберём принципы работы seccomp, а затем продемонстрируем, как он используется в Docker.
Seccomp: первое знакомство
--------------------------
Seccomp (сокращение от secure computing) — механизм ядра Linuх, позволяющий процессам определять системные вызовы, которые они будут использовать. Если злоумышленник получит возможность выполнить произвольный код, seccomp не даст ему использовать системные вызовы, которые не были заранее объявлены.
Seccomp — разработка Google. Он используется, в частности, в браузере Google Chrome для запуска плагинов.
Для активации seccomp используется системный вызов [prctl()](http://man7.org/linux/man-pages/man2/prctl.2.html).
Посмотрим, как это работает, на примере простой программы:
```
#include
#include
#include
#include
int main () {
pid\_t pid;
printf("Step 1: no restrictions yet\n");
prctl (PR\_SET\_SECCOMP, SECCOMP\_MODE\_STRICT);
printf ("Step 2: entering the strict mode. Only read(), write(), exit() and sigreturn() syscalls are allowed\n");
pid = getpid ();
printf ("!!YOU SHOULD NOT SEE THIS!! My PID = %d", pid);
return 0;
}
```
Сохраним эту программу под именем seccomp1.c, скомпилируем и запустим:
```
$ gcc seccomp1.c -o seccomp1
$ ./seccomp1
```
Мы увидим на консоли следующий вывод:
```
Step 1: no restrictions yet
Step 2: entering the strict mode. Only read(), write(), exit() and sigreturn() syscalls are allowed
Killed
```
Чтобы понять, откуда взялся именно такой вывод, воспользуемся strace:
```
$ strace ./seccomp1
/приводим небольшой фрагмент вывода/
prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT) = 0
write(1, "Step 2: entering the strict mode"..., 100Step 2: entering the strict mode. Only read(), write(), exit() and sigreturn() syscalls are allowed
) = 100
+++ killed by SIGKILL +++
Killed
```
Итак, что же произошло? С помощью системного вызова prctl мы активировали seccomp и включили строгий режим. После этого наша программа попыталась узнать PID текущего процесса с помощью системного вызова getpid(), но наложенные ограничения не дали этого сделать: процесс получил сигнал SIGKILL и был тут же завершён.
Как видим, seccomp прекрасно справляется со своими задачами. Но строгий режим неудобен тем, что не даёт возможности выбирать, какие системные вызовы разрешать, а какие — нет. Для решения этой задачи мы можем воспользоваться механизмом [BPF (Berkeley Packet Filters)](https://lwn.net/Articles/475043/).
Seccomp и фильтры BPF
---------------------
Механизм BPF (сокращение от Berkeley Packet Filters) был изначально создан для фильтрации сетевых пакетов, но впоследствии сфера его применения существенно расширилась. Сегодня BPF используется, например, для трассировки ядра Linux (вот [интересная публикация](http://www.brendangregg.com/blog/2016-03-05/linux-bpf-superpowers.html) на эту тему в блоге Брендана Грегга). В 2012 году он был интегрирован с seccomp; появилась расширенная версия, которая так и называется — seccomp-bpf.
Писать для BPF — дело очень сложное (кое-что об этом можно почитать, например, [здесь](http://events.linuxfoundation.org/sites/events/files/slides/limiting_kernel_attack_surface_with_seccomp-ContainerCon.eu_2016-Kerrisk.pdf)). Мы же особенности синтаксиса BPF обсуждать не будем (эта тема выходит далеко за рамки нашей статьи) и воспользуемся библиотекой libseccomp, которая предоставляет простой и удобный API для фильтрации системных вызовов.
Устанавливается она при помощи стандартного менеджера пакетов:
```
$ sudo apt-get install libseccomp-dev
```
Попробуем теперь написать небольшую программу:
```
#include
#include
#include
int main() {
pid\_t pid;
scmp\_filter\_ctx ctx = seccomp\_init(SCMP\_ACT\_KILL);
seccomp\_rule\_add(ctx, SCMP\_ACT\_ALLOW, SCMP\_SYS(read), 0);
seccomp\_rule\_add(ctx, SCMP\_ACT\_ALLOW, SCMP\_SYS(write), 0);
seccomp\_rule\_add(ctx, SCMP\_ACT\_ALLOW, SCMP\_SYS(sigreturn), 0);
seccomp\_rule\_add(ctx, SCMP\_ACT\_ALLOW, SCMP\_SYS(exit\_group), 0);
printf ("No restrictions yet\n");
seccomp\_load(ctx);
pid = getpid();
printf("!! YOU SHOULD NOT SEE THIS!! My PID is%d\n", pid);
return 0;
}
```
Прокомментируем этот код построчно.
```
scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_KILL);
```
Здесь мы инициализируем фильтр и указываем, какое действие нужно осуществлять по умолчанию — в нашем случае это SCMP\_ACT\_KILL, то есть немедленная остановка процесса, который выполнит запрещённый системный вызов.
Далее идут правила seccomp; в них мы указываем системные вызовы, которые будет разрешено выполнять нашему процессу:
```
seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 0);
seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 0);
seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(sigreturn), 0);
seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0);
seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 0);
```
Далее мы активируем правила:
```
seccomp_load(ctx);
```
Как и в предыдущем примере, мы пытаемся вывести на консоль PID текущего процесса. Но получится ли у нас это сделать?
Скомпилируем и запустим программу:
```
$ gcc -o seccomp2 seccomp2.c -lseccomp
$ ./seccomp2
```
Мы увидим следующий вывод:
```
No restrictions yet
Bad system call
```
Что произошло во время выполнения этой программы? Как и в предыдущем случае, ответить на этот вопрос нам поможет strace:
```
$ strace ./seccomp2
/приводим фрагмент вывода/
prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, {len = 9, filter = 0x1ef5fe0}) = 0
+++ killed by SIGSYS +++
```
Мы видим, что сработал фильтр: процесс выполнил системный вызов getpid, запрещённый правилами, после чего был тут же остановлен.
Чтобы лучше понять, как работают фильтры seccomp, в качестве действия по умолчанию в коде полезно указать не SCMP\_ACT\_KILL, а SCMP\_ACT\_TRAP:
```
scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_TRAP);
```
Вывод strace будет куда более подробным:
```
$ strace ./seccomp2
/приводим фрагмент вывода/
syscall_18446744073709551615(0xffffffff, 0x7feb8c47ab28, 0, 0x22b, 0x130c0c0, 0) = 0x27
--- SIGSYS {si_signo=SIGSYS, si_code=SYS_SECCOMP, si_call_addr=0x7feb8c18366f, si_syscall=__NR_getpid, si_arch=AUDIT_ARCH_X86_64} ---
+++ killed by SIGSYS +++
```
В нашем случае (ОС Ubuntu 16.04, ядро 4.4.) в выводе прямо указывается запрещённый системный вызов, попытка выполнения которого повлекла за собой остановку процесса: si\_syscall=\_\_NR\_getpid.
В других дистрибутивах и в других версиях ядра в выводе может быть приведено не имя системного вызова, а его номер из файла /asm/unistd.h.
Seccomp в Docker
----------------
В предыдущих разделах мы разобрали основные принципы работы seccomp. Рассмотрим теперь на примере Docker, как seccomp используется в конкретных инструментах контейнеризации.
Впервые профили seccomp для контейнеров появились в runc, о котором мы [уже писали](https://blog.selectel.ru/upravlenie-kontejnerami-s-runc/).
В Docker Engine они были добавлены начиная с версии 1.10.
По умолчанию во всех контейнерах Docker заблокированы 44 системных вызова (всего в современных 64-битных Linux-системах несколько сотен системных вызовов). К числу запрещённых относится, например, системный вызов reboot(): вряд ли можно представить себе ситуацию, когда требуется перезагрузить ОС на хост-машине из контейнера.
Ещё один хороший пример — системный вызов keyctl(), для которого не так давно была обнаружена уязвимость ([CVE 2016-0728](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=2016-0728)). Теперь в Docker он блокируется по умолчанию.
Профили seccomp по умолчанию — это хорошее нововведение, полезное уже тем, что ограничивает возможности для злоумышленников и снижает вероятность атак. Но этого явно недостаточно: у многих из незаблокированных вызовов есть уязвимости. Запретить все потенциально опасные вызовы по вполне понятным причинам просто-напросто невозможно!
Именно поэтому в контейнерах предусмотрена возможность фильтрации системных вызовов. Все фильтры прописываются в конфигурационных файлах в формате JSON.
Приведём простой пример:
```
{
"defaultAction":"SCMP_ACT_KILL",
"syscalls":[
{
"name":"chmod",
"action":"SCMP_ACT_ERRNO"
}
]
}
```
Как видим, здесь всё делается точно так же, как и в приводимых выше примерах кода. Сначала мы указываем, какое действие следует совершать по умолчанию. Далее мы перечисляем запрещённые вызовы, а также действия, которые нужно осуществить при выполнении одного их этих вызовов.
Сохраним этот файл под именем config.json и попытаемся запустить контейнер с прописанными выше настройками seccomp:
```
$ docker run --security-opt seccomp:chmod.json busybox chmod 400 /etc/hostname
chmod: /etc/hostname: Operation not permitted
```
Как видим, фильтр сработал в соответствии со сформулированными правилами: запрещённый системный вызов chmod был блокирован.
Заключение
----------
В этой статье мы рассказали, как работает seccomp и как он используется в Docker. Если у вас есть вопросы, замечания и пожелания — добро пожаловать в комментарии.
В заключение мы, как обычно, приводим полезные ссылки для желающих узнать больше:
* <http://blog.viraptor.info/tag/seccomp.html> — неплохое введение в тему;
* <https://blog.yadutaf.fr/2014/05/29/introduction-to-seccomp-bpf-linux-syscall-filter/> — ещё одна интересная публикация вводного характера;
* [https://eigenstate.org/notes/seccomp](https://eigenstate.org/notes/seccomp&) — подробная статья о фильтрах seccomp;
* <https://lwn.net/Articles/494252/> — статья о библиотеке libseccomp;
* <http://events.linuxfoundation.org/sites/events/files/slides/limiting_kernel_attack_surface_with_seccomp-ContainerCon.eu_2016-Kerrisk.pdf> — очень подробная и интересная презентация доклада о seccomp;
* <https://docs.docker.com/engine/security/seccomp/> — справка по использованию seccomp в Docker;
* <https://coreos.com/rkt/docs/latest/seccomp-guide.html> — cправка по использованию seccomp в контейнерах rkt.
|
https://habr.com/ru/post/322046/
| null |
ru
| null |
# Как взламывают корпоративный Wi-Fi: новые возможности
Статей о взломе Wi-Fi в Интернете достаточно много, но большинство из них касаются режима работы WEP/WPA(2)-Personal, в котором необходимо перехватить процедуру «рукопожатия» клиента и Wi-Fi-точки. Во многих корпоративных Wi-Fi-сетях используется режим безопасности WPA2-Enterprise, с аутентификацией по логину и паролю — как наименее затратный способ. При этом аутентификация осуществляется с помощью RADIUS-сервера.
[](http://i1288.photobucket.com/albums/b492/Alexander_Lashkov/1_zpsyolzifny.png)
ОС клиента устанавливает соединение с RADIUS-сервером, используя шифрование при помощи TLS, а проверка подлинности в основном происходит при помощи протокола MS-CHAPv2.
Для тестирования на проникновение в такой сети мы можем создать поддельную Wi-Fi-точку с RADIUS-сервером — и получить логин, запрос и ответ, которые использует MS-CHAPv2. Этого достаточно для дальнейшего брутфорса пароля.
Нам необходимы Kali Linux и карточка, поддерживающая работу в режиме Access Point, что можно проверить при помощи команды iw list, нас интересует строка:
`* #{ AP, mesh point } <= 8,`
Еще год назад нужно было проделать множество [манипуляций](http://www.blackhat.com/presentations/bh-usa-05/bh-us-05-beetle-update.pdf) для того, чтобы подделать такую точку доступа с возможностью получения учетных данных. Необходимо было пропатчить, собрать и правильно настроить определенные версии hostapd и FreeRADIUS. В августе 2014 года появился набор инструментов [Mana Toolkit](https://www.defcon.org/html/defcon-22/dc-22-speakers.html#DWhite), позволяющий автоматизировать множество векторов атак на беспроводные клиенты.
Поскольку использовать ноутбук не всегда удобно, будем использовать более компактный вариант — [телефон](http://habrahabr.ru/post/250133/). Кроме того, можно использовать Raspberry Pi + [FruityWifi](http://www.fruitywifi.com/index_eng.html). WiFi Pineapple, к сожалению, не поддерживает Mana.
Запускаем Kali
Подключаем Wi-Fi-карточку через USB-OTG-кабель. Запускаем приложение NetHunter.
Первое, что необходимо сделать, — определить интерфейс подключенной Wi-Fi-карточки. Для этого в меню выбираем Kali Launcher и запускаем Wifite.
[](http://i1288.photobucket.com/albums/b492/Alexander_Lashkov/78_zpszkvvvko0.png)
В нашем случае это интерфейс wlan1.
В меню выбираем MANA Evil Access Point.
Настраиваем точку:
* интерфейс, определенный на предыдущем шаге (interface),
* SSID взламываемой Wi-Fi-сети (ssid)
* использование протокола аутентификации 802.1x(ieee8021x=1),
* опции wpa(wpa) (**0** = без WPA/WPA2; **1** = WPA; **2** = IEEE 802.11i/RSN (WPA2); 3 = WPA и WPA2),
* список принимаемых алгоритмов управления ключами (wpa\_key\_mgmt=WPA-EAP),
* набор принимаемых алгоритмов шифрования (wpa\_pairwise),
Отключаем karma (enable\_karma=0), указываем буфер, в который будут направляться полученные логины и хеши (ennode).
[](http://i1288.photobucket.com/albums/b492/Alexander_Lashkov/10_zpsii2dnbml.png)
В нашем распоряжении комплект из пяти скриптов, которые запускают, помимо точки доступа, дополнительные утилиты для осуществления MITM-атак. Нас интересует скрипт mana-noupstream-eap, который предназначен для точек с аутентификацией 802.1x.
По умолчанию скрипт пытается «сбрутить» полученный хеш, подключить клиент и провести MITM-атаку. Поскольку взлом хешей на телефоне — не самая лучшая идея, комментируем ненужные строки, добавляем команду, которая будет записывать перехваченные данные в файл на флешке, — и запускаем Mana.
[](http://i1288.photobucket.com/albums/b492/Alexander_Lashkov/12_zpsnlvotg6d.png)
Как только Wi-Fi-клиент окажется достаточно близко к нашей точке доступа, он попробует аутентифицироваться на ней. Хорошее место для засады — у входа в офис или бизнес-центр, время — начало или конец рабочего дня, когда потенциальные жертвы минуют проходную.
Останавливаем Mana и проверяем, что же мы поймали.
[](http://i1288.photobucket.com/albums/b492/Alexander_Lashkov/1314_zpsp2xz9buc.png)
Формат полученных данных: Protocol | Login | Challenge | Response
Теперь можно в спокойной обстановке на нормальном компьютере взламывать полученные хеши.
В этом нам помогут:
— Asleap (используется в оригинальном скрипте),
— John the Ripper (требуется слегка модифицировать полученные хеши: `cat HASHES.txt | sed 's/://g' | sed 's/\([^|]*\)|\([^|]*\)|\([^|]*\)|\([^|]*\)/\2:$NETNTLM$\3$\4/' > john-HASHES.txt`)
Полученные учетные записи можно использовать для дальнейшего проникновения в корпоративную сеть через Wi-Fi или VPN, а также для получения доступа к корпоративной почте.
Как оказалось, перехватить хеши пользователей можно не всегда. Настольные ОС (Windows, MacOS, Linux), а также пользователи iOS защищены лучше всего. При первичном подключении ОС спрашивает, доверяете ли вы сертификату, который используется RADIUS-сервером в данной Wi-Fi-сети. При подмене легитимной точки доступа ОС спросит про доверие к новому сертификату, который использует RADIUS-сервер. Это произойдет даже при использовании сертификата, выданного доверенным центром сертификации (Thawte, Verisign).
При использовании устройств на базе Android сертификат по умолчанию не проверяется, но существует возможность указать корневой сертификат, который может использоваться в данной Wi-Fi-сети.
Устройства на основе Windows Phone по умолчанию проверяют сертификат. Также доступны опции проверки сертификата сервера:
* нет;
* всегда спрашивать;
* центр сертификации.
Резюмируя все сказанное, эксперты Positive Technologies рекомендуют следующие меры безопасности:
* пользователям — проверять сертификаты при подключении не только к интернет-банку, но и к корпоративному Wi-Fi;
* пользователям Android — установить корневой сертификат, который используется в корпоративной сети;
* администраторам — перейти на использование аутентификации на основе сертификатов (или не удивляться, если перед входом в офис периодически будут появляться люди с телефоном и антенной).
**Автор:** Дмитрий Трифонов, исследовательский центр Positive Technologies
|
https://habr.com/ru/post/252055/
| null |
ru
| null |
# Простая игра на SFML
Будем делать игру «пятнашки» на языке C++ с использованием библиотеки SFML. Пятнашки — это широко известная головоломка, которая выглядит следующим образом:
На игровом поле размером 4х4 случайным образом расположены 15 плашек с номерами от 1 до 15 и одно свободное место. Передвигать плашки можно только по одной и только на свободное место. Целью игры является выстроение плашек на игровом поле в порядке, соответствующем их номерам.
Итак, начнем.
Запускаем Visual Studio и создаем новый пустой проект. Можете назвать его как хотите, я назвал «15». В этом проекте создаем новый файл main.cpp и пустую функцию main:
```
// main.cpp
int main()
{
return 0;
}
```
Далее скачиваем библиотеку SFML с сайта [sfml-dev.org](http://sfml-dev.org) и распаковываем ее. В распакованной библиотеке есть нужные нам папки: **include**, **lib** и **bin**. В свойствах проекта в разделе C/C++ в *Additional Include Directories* добавляем путь к папке **include**:
Там же в разделе Linker в *Additional Library Directories* добавляем путь к папке **lib**:
А из каталога **bin** нужно скопировать DLL-файлы и сложить их в каталог с exe-файлом нашего проекта:
Кроме того, в разделе Linker, в подразделе Input, нужно в *Additional Dependencies* добавить используемые файлы библиотеки. В нашем случае достаточно добавить три файла: sfml-system-d.lib, sfml-window-d.lib и sfml-graphics-d.lib:
Символ **-d** в названии файла означает, что это отладочная версия и должна использоваться в конфигурации Debug. В настройках релизной версии нужно будет задавать файлы без символа **-d** в названии.
Хорошая инструкция по подключению библиотеки SFML к проекту Visual Studio находится на [сайте](https://www.sfml-dev.org/tutorials/2.5/start-vc.php) библиотеки.
Попробуем теперь задействовать библиотеку в нашем проекте. Создадим окно и запустим цикл обработки событий:
**main.cpp**
```
// main.cpp
#include
int main()
{
// Создаем окно размером 600 на 600 и частотой обновления 60 кадров в секунду
sf::RenderWindow window(sf::VideoMode(600, 600), "15");
window.setFramerateLimit(60);
sf::Event event;
while (window.isOpen())
{
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed) window.close();
if (event.type == sf::Event::KeyPressed)
{
// Получаем нажатую клавишу - выполняем соответствующее действие
if (event.key.code == sf::Keyboard::Escape) window.close();
}
}
// Выполняем необходимые действия по отрисовке
window.clear();
window.display();
}
return 0;
}
```
Результатом будет квадратное окно размером 600 на 600 пикселей с черным фоном:
Окно можно закрыть обычным способом мышью, либо через клавишу Esc. Обработчик нажатий клавиш клавиатуры также включен в цикл обработки сообщений.
Прежде чем приступить к делу, нам понадобится какой-нибудь шрифт для вывода текста на экран. Я для примера взял шрифт TrueType Calibri.
Теперь можем начинать делать свою игру.
Создаем новый класс Game:
Класс будет отвечать за работу игры и за отрисовку игрового поля. Для этого будем наследовать наш класс от классов Drawable и Transformable библиотеки SFML.
Итак, начинаем описывать наш класс
**Game.h**
```
#pragma once
#include
const int SIZE = 4; // Размер игрового поля в плашках
const int ARRAY\_SIZE = SIZE \* SIZE; // Размер массива
const int FIELD\_SIZE = 500; // Размер игрового поля в пикселях
const int CELL\_SIZE = 120; // Размер плашки в пикселях
enum class Direction { Left = 0, Right = 1, Up = 2, Down = 3 };
class Game : public sf::Drawable, public sf::Transformable
{
protected:
int elements[ARRAY\_SIZE];
int empty\_index;
bool solved;
sf::Font font;
public:
Game();
void Init();
bool Check();
void Move(Direction direction);
public:
virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const;
};
```
Первым делом подключаем библиотеку Graphics:
```
#include
```
Тут же объявляем некоторые константы, требуемые для игры:
```
const int SIZE = 4; // Размер игрового поля в плашках
const int ARRAY_SIZE = SIZE * SIZE; // Размер массива плашек
const int FIELD_SIZE = 500; // Размер игрового поля в пикселях
const int CELL_SIZE = 120; // Размер плашки в пикселях
```
Также объявляем свой тип enum, определяющий направление перемещения плашки:
```
enum class Direction { Left = 0, Right = 1, Up = 2, Down = 3 };
```
Ну и наконец сам класс:
```
class Game : public sf::Drawable, public sf::Transformable
{
protected:
int elements[ARRAY_SIZE];
int empty_index;
bool solved;
sf::Font font;
public:
Game();
void Init();
bool Check();
void Move(Direction direction);
public:
virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const;
};
```
Самое главное что у нас в нем есть — это массив elements, содержащий целочисленные значения, соответствующие состоянию игрового поля. Элементы в массиве соответствуют элементам игрового поля слева направо, сверху вниз, то есть первые 4 элемента массива соответствуют первой строке поля, вторые 4 элемента — второй строке и т.д.
Далее две переменные, которые будут вычисляться каждый ход — это **empty\_index** (индекс в массиве, соответствующий свободной ячейке) и **solved** (признак того, что головоломка решена).
Кроме того, в классе задана переменная font, определяющая шрифт, который будет использоваться при выводе текста в окне.
Теперь напишем реализацию методов нашего класса.
**Game.cpp**
```
#include "Game.h"
Game::Game()
{
// Подгружаем шрифт для отрисовки элементов
font.loadFromFile("calibri.ttf");
Init();
}
void Game::Init()
{
// Заполняем массив плашек
for (int i = 0; i < ARRAY_SIZE - 1; i++) elements[i] = i + 1;
// Ставим пустую плашку в правую нижнюю позицию
empty_index = ARRAY_SIZE - 1;
elements[empty_index] = 0; // Пустая плашка имеет значение = 0
solved = true;
}
bool Game::Check()
{
// Проверка собранности головоломки
for (unsigned int i = 0; i < ARRAY_SIZE; i++)
{
if (elements[i] > 0 && elements[i] != i + 1) return false;
}
return true;
}
void Game::Move(Direction direction)
{
// Вычисляем строку и колонку пустой плашки
int col = empty_index % SIZE;
int row = empty_index / SIZE;
// Проверка на возможность перемещения и вычисление индекса перемещаемой плашки
int move_index = -1;
if (direction == Direction::Left && col < (SIZE - 1)) move_index = empty_index + 1;
if (direction == Direction::Right && col > 0) move_index = empty_index - 1;
if (direction == Direction::Up && row < (SIZE - 1)) move_index = empty_index + SIZE;
if (direction == Direction::Down && row > 0) move_index = empty_index - SIZE;
// Перемещение плашки на место пустой
if (empty_index >= 0 && move_index >= 0)
{
int tmp = elements[empty_index];
elements[empty_index] = elements[move_index];
elements[move_index] = tmp;
empty_index = move_index;
}
solved = Check();
}
void Game::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
states.transform *= getTransform();
sf::Color color = sf::Color(200, 100, 200);
// Рисуем рамку игрового поля
sf::RectangleShape shape(sf::Vector2f(FIELD_SIZE, FIELD_SIZE));
shape.setOutlineThickness(2.f);
shape.setOutlineColor(color);
shape.setFillColor(sf::Color::Transparent);
target.draw(shape, states);
// Подготавливаем рамку для отрисовки всех плашек
shape.setSize(sf::Vector2f(CELL_SIZE - 2, CELL_SIZE - 2));
shape.setOutlineThickness(2.f);
shape.setOutlineColor(color);
shape.setFillColor(sf::Color::Transparent);
// Подготавливаем текстовую заготовку для отрисовки номеров плашек
sf::Text text("", font, 52);
for (unsigned int i = 0; i < ARRAY_SIZE; i++)
{
shape.setOutlineColor(color);
text.setFillColor(color);
text.setString(std::to_string(elements[i]));
if (solved)
{
// Решенную головоломку выделяем другим цветом
shape.setOutlineColor(sf::Color::Cyan);
text.setFillColor(sf::Color::Cyan);
}
else if (elements[i] == i + 1)
{
// Номера плашек на своих местах выделяем цветом
text.setFillColor(sf::Color::Green);
}
// Рисуем все плашки, кроме пустой
if (elements[i] > 0)
{
// Вычисление позиции плашки для отрисовки
sf::Vector2f position(i % SIZE * CELL_SIZE + 10.f, i / SIZE * CELL_SIZE + 10.f);
shape.setPosition(position);
// Позицию текста подбирал вручную
text.setPosition(position.x + 30.f + (elements[i] < 10 ? 15.f : 0.f), position.y + 25.f);
target.draw(shape, states);
target.draw(text, states);
}
}
}
```
Конструктор класса загружает шрифт из внешнего файла и вызывает метод инициализации игры:
```
Game::Game()
{
// Подгружаем шрифт для отрисовки элементов
font.loadFromFile("calibri.ttf");
Init();
}
```
Метод инициализации игры заполняет массив элементами в правильном порядке и устанавливает признак решенной головоломки:
```
void Game::Init()
{
// Заполняем массив плашек
for (int i = 0; i < ARRAY_SIZE - 1; i++) elements[i] = i + 1;
// Пустая ячейка - в последнем элементе массива
empty_index = ARRAY_SIZE - 1;
elements[empty_index] = 0; // Пустая плашка имеет значение = 0
solved = true;
}
```
Да, изначально у нас игра будет инициализироваться как решенная, а перед началом игры мы будем перемешивать плашки с помощью случайных ходов.
Следующий метод проверяет, решена ли головоломка и возвращает результат проверки:
```
bool Game::Check()
{
// Проверка собранности головоломки
for (unsigned int i = 0; i < ARRAY_SIZE; i++)
{
if (elements[i] > 0 && elements[i] != i + 1) return false;
}
return true;
}
```
И наконец, метод, реализующий перемещение плашки в игре:
```
void Game::Move(Direction direction)
{
// Вычисляем строку и колонку пустой плашки
int col = empty_index % SIZE;
int row = empty_index / SIZE;
// Проверка на возможность перемещения и вычисление индекса перемещаемой плашки
int move_index = -1;
if (direction == Direction::Left && col < (SIZE - 1)) move_index = empty_index + 1;
if (direction == Direction::Right && col > 0) move_index = empty_index - 1;
if (direction == Direction::Up && row < (SIZE - 1)) move_index = empty_index + SIZE;
if (direction == Direction::Down && row > 0) move_index = empty_index - SIZE;
// Перемещение плашки на место пустой
if (empty_index >= 0 && move_index >= 0)
{
int tmp = elements[empty_index];
elements[empty_index] = elements[move_index];
elements[move_index] = tmp;
empty_index = move_index;
}
solved = Check();
}
```
Последний метод класса — это метод, который отрисовывает игровое поле:
**draw**
```
void Game::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
states.transform *= getTransform();
sf::Color color = sf::Color(200, 100, 200);
// Рисуем рамку игрового поля
sf::RectangleShape shape(sf::Vector2f(FIELD_SIZE, FIELD_SIZE));
shape.setOutlineThickness(2.f);
shape.setOutlineColor(color);
shape.setFillColor(sf::Color::Transparent);
target.draw(shape, states);
// Подготавливаем рамку для отрисовки всех плашек
shape.setSize(sf::Vector2f(CELL_SIZE - 2, CELL_SIZE - 2));
shape.setOutlineThickness(2.f);
shape.setOutlineColor(color);
shape.setFillColor(sf::Color::Transparent);
// Подготавливаем текстовую заготовку для отрисовки номеров плашек
sf::Text text("", font, 52);
for (unsigned int i = 0; i < ARRAY_SIZE; i++)
{
shape.setOutlineColor(color);
text.setFillColor(color);
text.setString(std::to_string(elements[i]));
if (solved)
{
// Решенную головоломку выделяем другим цветом
shape.setOutlineColor(sf::Color::Cyan);
text.setFillColor(sf::Color::Cyan);
}
else if (elements[i] == i + 1)
{
// Номера плашек на своих местах выделяем цветом
text.setFillColor(sf::Color::Green);
}
// Рисуем все плашки, кроме пустой
if (elements[i] > 0)
{
// Вычисление позиции плашки для отрисовки
sf::Vector2f position(i % SIZE * CELL_SIZE + 10.f, i / SIZE * CELL_SIZE + 10.f);
shape.setPosition(position);
// Позицию текста подбирал вручную
text.setPosition(position.x + 30.f + (elements[i] < 10 ? 15.f : 0.f), position.y + 25.f);
// Отрисовываем рамку плашки
target.draw(shape, states);
// Отрисовываем номер плашки
target.draw(text, states);
}
}
}
```
В методе отрисовки первым делом применяем трансформацию координат, путем умножения на матрицу трансформирования. Это нужно для того, чтобы можно было задавать координаты нашему игровому полю. Далее с помощью объектов RectangleShape библиотеки SFML, рисуем рамки игрового поля и рамки каждой плашки в игре. На плашках также еще отрисовываем текст с номером плашки. Кроме того, если головоломка решена, то цвет плашек делаем другим.
Настало время вернуться к функции main:
**main.cpp**
```
// main.cpp
#include
#include "Game.h"
int main()
{
// Создаем окно размером 600 на 600 и частотой обновления 60 кадров в секунду
sf::RenderWindow window(sf::VideoMode(600, 600), "15");
window.setFramerateLimit(60);
sf::Font font;
font.loadFromFile("calibri.ttf");
// Текст с обозначением клавиш
sf::Text text("F2 - New Game / Esc - Exit / Arrow Keys - Move Tile", font, 20);
text.setFillColor(sf::Color::Cyan);
text.setPosition(5.f, 5.f);
// Создаем объект игры
Game game;
game.setPosition(50.f, 50.f);
sf::Event event;
int move\_counter = 0; // Счетчик случайных ходов для перемешивания головоломки
while (window.isOpen())
{
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed) window.close();
if (event.type == sf::Event::KeyPressed)
{
// Получаем нажатую клавишу - выполняем соответствующее действие
if (event.key.code == sf::Keyboard::Escape) window.close();
if (event.key.code == sf::Keyboard::Left) game.Move(Direction::Left);
if (event.key.code == sf::Keyboard::Right) game.Move(Direction::Right);
if (event.key.code == sf::Keyboard::Up) game.Move(Direction::Up);
if (event.key.code == sf::Keyboard::Down) game.Move(Direction::Down);
// Новая игра
if (event.key.code == sf::Keyboard::F2)
{
game.Init();
move\_counter = 100;
}
}
}
// Если счетчик ходов больше нуля, продолжаем перемешивать головоломку
if (move\_counter-- > 0) game.Move((Direction)(rand() % 4));
// Выполняем необходимые действия по отрисовке
window.clear();
window.draw(game);
window.draw(text);
window.display();
}
return 0;
}
```
Вначале подгружаем шрифт и создаем объект Text для вывода на экран строки текста с назначенем клавиш. Далее создаем наш объект игры и устанавливаем позицию поля в точку с координатами (50,50) — так мы делаем отступ от края окна.
Управление игрой я решил делать через клавиатуру, так что на каждое нажатие клавиш стрелок вызываем у объекта игры метод Move — для перемещения плашки в соответствующем направлении.
Нажатие клавиши F2 — это начало новой игры, так что в обработчике этого события заново инициализируем игру (что приведет к расстановке плашек по своим местам), а также выставляем значение счетчика ходов равным 100. Этот счетчик используется дальше для выполнения ходов в случайных направлениях, пока не обнулится, а плашки не перемешаются. Таким образом мы точно получим решаемое состояние головоломки.
Вот в общем-то и все, компилируем, собираем, запускаем:
 
В этой статье я показал, как можно быстро создать простую игру на C++ с использованием библиотеки SFML. Однако архитектура самой программы далека от идеала. В следующей статье мы попробуем с этим что-нибудь сделать.
|
https://habr.com/ru/post/449596/
| null |
ru
| null |
# Простой вызов удалённых сервисных методов в одностраничных приложениях
В этой статье, я хочу поделиться своим подходом в организации клиент-серверного взаимодействия, в одностраничных браузерных приложениях с серверной частью на Java.
Сокращённо, я называю этот подход «Json Remote Service Procedure Call» — JRSPC. (Не очень благозвучно, возможно, но из песни слова не выкинешь.)
Применение jrspc — позволяет отказаться от использования слоёв определений интерфейсов сервисов на клиенте и сервере, что сокращает количество кода, упрощает его рефакторинг, и снижает вероятность появления ошибок.
При использовании этого подхода — мы можем писать только код, отвечающий за бизнес-логику,
не нужаясь в дополнительном коде, при определении нового бизнес-метода.
Например, на сервере, определение бизнес-метода выглядит так:
```
@Component("testService")
public class TestService{
@Remote
public String testMethod(Long userId, String role, boolean test,
List users, User user){
...
return "ok";
}
}
```
а его вызов на клиенте — так:
```
var params = [userId, role, true, [{id:1, login:"111"}, {id:2, login:"222"} ], {id:3, login:"333"}]
Server.call("testService", "testMethod", params, sucessCallback, errorCallback, controlWhichWillDisabledUntilResponse);
```
Больше, при определении метода, нигде, никакого кода не пишется.
### Как это работает
На транспортном уровне, jrspc — использует json-rpc, с возможностью указывать в вызове не только метод, но и сервис. Поэтому, такой json-rpc можно было бы назвать json-rspc (s-service).
Если бы на него существовала спецификация, то она была бы похожа на спецификацию [json-rpc 2.0](http://www.jsonrpc.org/specification), за исключением того, что в объекте запроса было бы добавлено поле «service», а поле «id» — было бы не обязательным, и в ответе — необязателен errorCode.
Для демонстрации, я написал простое [демо-приложение](http://94.127.68.13/jrspc/demo/application.html), в котором реализуются функциональности регистрации, логина, и изменения данных и прав пользователя.
### Клиентская часть
Клиентская часть этого приложения — написана на фреймворке [AngularJS](http://angularjs.org/).
**предупреждение**(Считаю своим долгом — предупредить тех, кто ещё не пробовал писать на нём:
{{user.name}}, Ангуляр — тяжёлый наркотик!
Для попадения в зависимость от него — достатчно словить кайф всего один раз.)
Для оформления используется [Bootstrap](http://getbootstrap.com/).
В серверной части — [Spring](http://projects.spring.io/spring-framework/).
В качестве реализации объекта json, используется `JSONObject` из библиотеки [json-lib](http://json-lib.sourceforge.net/).
Клиентская часть состоит из трёх файлов:
[ajax-connector.js](https://github.com/janson13/demo-jrspc/blob/master/jrspc/src/main/public/demo/ajax-connector.js).
Реализация механизма запросов к серверу, инкапсулированная в объекте `Server`.
(Префикс ajax — используется, чтобы отличать его от вебсокетного ws-connector.js, которым он может быть заменён, без изменения кода user-controller.js.)
[user-controller.js](https://github.com/janson13/demo-jrspc/blob/master/jrspc/src/main/public/demo/user-controller.js)
Здесь находится бизнес-логика приложения, инкапсулированная в функции `userController`.
[application.html](https://github.com/janson13/demo-jrspc/blob/master/jrspc/src/main/public/demo/application.html)
Графический интерфейс приложения с логикой блокировки элементов.
Как видим, в представлении скриптового кода, удалённый сервер — выглядит как объект Server, который должен быть проинициализирован url'ом.
Через этот объект, мы можем обращаться к любому компоненту на сервере и вызывать любые его методы, таким способом:
`Server.call(serviceName, mathodName, [param1, param2, ...], successCallBack, errorCallback, control);`
Ответы или ошибки — приходят в соответствующие коллбэки.
Добавление нового сервиса или метода на сервере — никак не затрагивает клиентский код, и мы можем вызывать эти сервисы и методы сразу, после того как они появились в серверном коде.
Естественно, сказав «любому и любые» — я немного отошёл от истины.
На самом деле, как удалённые сервисы, вызываться могут только классы, производные от `AbstractService`, а вызываемые удалённо методы, должны быть аннотированы `@Remote`.
Для ограничения прав доступа к методам — используется аннотация `@Secured(roleName)`.
Так, например, метод, аннотированный `@Secured("Admin")` — не может быть вызван пользователем с ролью «User».
### Cерверная часть
Весь серверный «фреймворк», если можно так выразиться, занимает меньше 9 кб., и состоит из шести классов, два из которых — уже знакомые нам аннотации: [Remote](https://github.com/janson13/demo-jrspc/blob/master/jrspc/src/main/java/habr/metalfire/jrspc/Remote.java) и [Secured](https://github.com/janson13/demo-jrspc/blob/master/jrspc/src/main/java/habr/metalfire/jrspc/Secured.java), а также [AbstractService](https://github.com/janson13/demo-jrspc/blob/master/jrspc/src/main/java/habr/metalfire/jrspc/AbstractService.java) —
абстрактный класс, от которого должны наследоваться все сервисы, и [CommonServiceController](https://github.com/janson13/demo-jrspc/blob/master/jrspc/src/main/java/habr/metalfire/jrspc/CommonServiceController.java)
В его метод `processAjaxRequest` приходят запросы из скриптового объекта `Service`.
Далее, находится компонент, по имени сервиса, и на нём, после проверки прав доступа, рефлективно, вызвается указанный метод.
[User (entity)](https://github.com/janson13/demo-jrspc/blob/master/jrspc/src/main/java/habr/metalfire/jrspc/User.java), для хранения данных о пользователе, и [UserManager](https://github.com/janson13/demo-jrspc/blob/master/jrspc/src/main/java/habr/metalfire/jrspc/UserManager.java), для операций с объектом `User` (тестовая реализация с эмуляцией персистентности).
Бизнес-логика реализована в двух сервисах: [TestUserService](https://github.com/janson13/demo-jrspc/blob/master/jrspc/src/main/java/habr/metalfire/jrspc/TestUserService.java) — сервис с методами для регистрации, логина, и редактирования данных, и [TestAdminService](https://github.com/janson13/demo-jrspc/blob/master/jrspc/src/main/java/habr/metalfire/jrspc/TestAdminService.java) — сервис с методами для удаления юзера, и изменения его роли.
Код написан максимально self-explanatory, поэтому надеюсь, что разобраться в нём будет легко.
[Код демо-приложения на Гитхабе](https://github.com/janson13/demo-jrspc).
### Что дальше?
В следующей статье, я планирую написать, как, на базе данного подхода, можно организовать клиент-серверное взаимодействие через вебсокеты, и как, на сервере, из вебсокетного контекста, достать сессию http.
**Update2:**
Update1 — перемещён в тело статьи.
|
https://habr.com/ru/post/211937/
| null |
ru
| null |
# Автоматизируем и ускоряем процесс настройки облачных серверов с Ansible. Часть 2: вывод, отладка, и повторное использование playbook
[В предыдущей статье](http://habrahabr.ru/company/infobox/blog/249143/) мы начали изучение Ansible, популярного инструмента для автоматизации настройки и развертывания ИТ-инфраструктуры. Ansible был успешно установлен в [InfoboxCloud](http://infoboxcloud.ru), описаны принципы работы, базовая настройка. В завершении статьи мы показали как быстро установить nginx на несколько серверов.
В этой статье мы продолжим изучение Ansible: разберем вывод playbook, научимся отлаживать их и разделять для удобства повторного использования.
#### **Управление конфигурациями**
##### **Разбор нашего первого playbook**
В прошлой статье мы получили вывод от исполнения нашего первого playbook. Давайте разберем его.
**Gathering facts** – это первая задача по умолчанию в любом playbook. Задача собирает полезные метаданные о серверах в форме переменных, которые могут использоваться в playbook в дальнейшем. Например, такими переменными может быть ip–адрес, архитектура ОС и имя хоста.
Можно посмотреть эти переменные, используя команду:
```
ansible -m setup experiments
```
, где experiments – название секции в вашем inventory.
или записать ее в файл
```
ansible -m setup experiments >> facts
```
Ниже в выводе указаны задачи **TASK**, согласно ходу выполнения playbook: установка nginx, запуск сервиса.
Давайте запустим выполнение playbook повторно.
```
ansible-playbook playbooks/setup_nginx.yml
```
По сравнению с предыдущим выводом задача **Install nginx package** выполнена без изменений. Состояние уже достигнуто: nginx установлен. Задача старта сервиса nginx в обоих случаях выполнена без изменений, так как сервис nginx стартует сам сразу после установки. Если остановить сервис nginx на одном из серверов вручную, после запуска playbook он поднимется.
Как мы видим, выполняется одно из ключевых свойств систем Ansible: **Идемпотентность** (операция, которая если применяется к любому значению несколько раз — всегда получается то же значение, как и при однократном применении). Большинство систем управления конфигурациями следуют этому принципу и применяют его на инфраструктуру.
Давайте посмотрим на секцию **PLAY RECAP** ниже в выводе. Параметр **changed** показывает, сколько раз в задачах менялось состояние сервера. **ok** – количество исполняемых задач вместе с **Gathering facts**.
##### Oтладка playbook
Понимать, что случилось при исполнении playbook, бывает очень полезно для исправления ошибок.
Есть 3 уровня вывода отладочной информации (Verbose).
**-v**. Вывод базовой информации.
```
ansible-playbook playbooks/setup_nginx.yml -v
```
**-vv**. Более подробный вывод.
```
ansible-playbook playbooks/setup_nginx.yml -vv
```
**-vvv**. Самый подробный вывод.
В этом выводе указаны SSH–команды, которые Ansible использует для создания временных файлов на удаленном хосте для запуска скрипта удаленно.
```
ansible-playbook playbooks/setup_nginx.yml -vvv
```
Можно выводить любые переменные ansible для отладки. Для этого добавьте в playbook следующую секцию:
```
- name: Debug
debug: msg={{ ansible_distribution }}
```
При запуске playbook вы увидите вывод этой переменной. Каждая переменная Ansible начинается с префикса **ansible\_**.
Еще одна полезная команда — возможность посмотреть на все задачи, выполняющиеся в playbook. Она особенно полезна, когда есть несколько playbook, исполнающих другие playbook.
```
ansible-playbook playbooks/setup_nginx.yml --list-tasks
```
Можно исполнить только конкретную задачу из playbook:
```
ansible-playbook playbooks/setup_nginx.yml --start-at-task="Debug"
```
#### **Повторное использование в Playbook**
Если задача или набор задач часто используется вами — есть смысл оформить ее в виде отдельного файла, который можно будет использовать в других playbook.
Создайте папку для повторно используемых задач:
```
mkdir ~/ansible/playbooks/tasks
```
Давайте создадим задачу обновления ОС в файле ~/ansible/playbooks/tasks/**os\_update.yml**:
```
---
#Update and upgrade apt-based linux
- name: Update and upgrade apt-based Linux
apt: update-cache=yes state=latest
sudo: yes
```
Tеперь мы можем включить секцию обновления ОС в ~/ansible/playbooks/**setup\_nginx.yml**:
```
---
- hosts: experiments
remote_user: root
tasks:
- include: tasks/os_update.yml
- name: Install nginx package
apt: name=nginx update_cache=yes
sudo: yes
- name: Starting nginx service
service: name=nginx state=started
sudo: yes
```
Теперь до установки nginx Ubuntu на обслуживаемых серверах из Inventory будет обновлена.
Стоит и установку nginx (~/ansible/playbooks/tasks/**pkg\_nginx\_install.yml**) вынести в отдельную задачу, если вы часто ставите nginx.
```
---
#Install NGINX package
- name: Install nginx package
apt: name=nginx update_cache=yes
sudo: yes
- name: Starting nginx service
service: name=nginx state=started
sudo: yes
```
В результате наш playbook станет совсем простым:
```
---
- hosts: experiments
remote_user: root
tasks:
- include: tasks/os_update.yml
- include: tasks/pkg_nginx_install.yml
```
Можно написать и задачу для удаления nginx (~/ansible/tasks/**pkg\_nginx\_remove.yml**):
```
---
#Remove NGINX package
- name: Stopping nginx service
service: name=nginx state=stopped
sudo: yes
- name: Remove nginx package
apt: name=nginx state=removed
sudo: yes
```
и вызвать ее (~/ansible/playbooks/**remove\_nginx.yml**):
```
---
- hosts: experiments
remote_user: root
tasks:
- include: tasks/pkg_nginx_remove.yml
```
```
ansible-playbook ~/ansible/playbooks/remove_nginx.yml -i ~/ansible/inventory
```
, где через -i указываем путь к файлу inventory, что позволяет нам запускать ansible-playbook не только из папки ansible.
В следующей статье мы поговорим о переменных и условиях Ansible. Наконец-то наши playbook будут корректно работать на разных ОС.
#### Заключение
В написании статьи очень помогла книга "[Learning Ansible](http://www.amazon.com/Learning-Ansible-Madhurranjan-Mohaan/dp/1783550635/ref=sr_1_2?ie=UTF8&qid=1422482924&sr=8-2&keywords=ansible)" и конечно [официальная документация](http://docs.ansible.com).
Все эксперименты с Ansible удобно делать в [InfoboxCloud](http://infoboxcloud.ru), так как имеется возможность для каждого виртуального сервера установить именно то количество ресурсов, которое необходимо для задачи (CPU/Ram/диск независимо друг от друга) или использовать автомасштабирование.
Если вы обнаружили ошибку в статье, автор ее с удовольствием исправит. Пожалуйста напишите в ЛС или [на почту](mailto:trukhinyuri@infoboxcloud.com) о ней. Туда же можно задавать вопросы по Ansible для освещения в последующих статьях.
[Часть 3: Переменные и файл inventory](http://habrahabr.ru/company/infobox/blog/252001/)
[Часть 4: работаем с модулями](http://habrahabr.ru/company/infobox/blog/252239/)
[Часть 5: local\_action, условия, циклы и роли](http://habrahabr.ru/company/infobox/blog/252461/)
Успешной работы!
|
https://habr.com/ru/post/250115/
| null |
ru
| null |
# Взаимодействие интерпретаторов Python-IronPython-Jython
Возникла необходимость в решении такой задачи: как обмениваться данными между разными интерпретаторами Python?! Отыскал несколько решений, но хочу рассказать об одном, на мой взгляд, самом удобном.
#### Выбор подхода
Для начала я пытался выбрать наиболее удобное решение из множества. Может не корректно сравнивать message queue, сокеты и RPC, но я исходил от задачи. Вот что доступно:
##### Сокеты TCP
Использование сокетов, наиболее простой способ взаимодействия, можно передавать любые данные, но код придётся насыщать реализацией собственного протокола. Этот путь тернист, и ошибки неизбежны. **Вывод: подходит, но сложно.**
##### Библиотека ZeroMQ
Очень перспективная разработка brokerless очередь сообщений. Реализована как библиотека [pyzmq](http://pypi.python.org/pypi/pyzmq/2.1.11) и [pyzmq-static](http://pypi.python.org/pypi/pyzmq-static/2.2). Для первого случая нужно установить саму ZeroMQ — написанная на C разделяемая библиотека. Вторая уже содержит бинарник. Начиналось всё весьма забавно, код работал отлично, пока я не перешёл к IronPython…
Для IronPython pyzmq не реализована, но не проблема, есть же .NET Integration, что позволяет использовать [clrzmq](https://github.com/zeromq/clrzmq) — биндинг для .NET; и вот здесь начались проблемы. Бинарник доступен через плагин для VisualStudio — nuget, поэтому пришлось бибилотеку компилировать.Скачал исходник, там всё удобно, скрипт собирается командой build, но не всё так просто. Версия 2 не собралась вообще, хотя зависимости разрешила через nuget корректно (может взял битый commit?), 3 бета собралась, но падала даже на примере из tutorial )
В итоге и сети отыскал бинарник 2-ки, но это меня совсем не порадовало. Всё заработало, но API в 3-ке так сильно изменился, что не хотелось потом переписывать код по сто раз. **Вывод: хорошо, но сыро вне чистого Python.**
##### Pyro, поджигай!
Поначалу решил добивать 0mq, но вспомнил о сущеcтвовании такой библиотеки как [Pyro](http://pypi.python.org/pypi/Pyro4): библиотеки из кризисных 90-х, которая прекрасно поживает и развивается. Не буду перечислять все её плюсы, сейчас интересует только один — взаимодействие интерпретаторов. Сразу к делу, пробуем пример из [tutorial](http://packages.python.org/Pyro4/tutorials.html#building-a-warehouse), но с той разницей, что запускаем всё под разными интерпретаторами (код не менял, только вписал свой ник).
Запускаем сервер имён под Jython, кстати, вот и первый огромный плюс, у 0mq сервер имён ещё не доделан:
*Ого! Завелось...*
Теперь регистрируем сервер, который будет работать под IronPython:
*Регистрация прошла успешно.*
Следующий шаг, запуск клиента. Делаем под классическим питоном (у меня их сразу много стоит, но запускал EPD):
*Прекрасно! Всё сработало.*
##### Версия pickle
Как вариант, попробовал ещё запускать одну из частей под Python 3. Без хака не сработало :( Последний использует pickle третьей версии + нет некоторых стандартных модулей (удалены, перенесены), хотя это поведение можно обойти. Но главная причина, Pyro4 иcпользует pickle для сериализации, при этом самую последнюю версию. Вот как удалось обойти этот недостаток и подключиться Python 3 к IronPython 2 и Jython 2:
```
import pickle
pickle.HIGHEST_PROTOCOL = 2
```
Это нужно добавить в код клиента перед импортом Pyro. Всё сработало:
*Обратите внимание на использование 64-битного Python 3 вместе с двойками.*
Кстати, как вариант, можно использовать библиотеку [pyrolite](http://packages.python.org/Pyro4/pyrolite.html) для прямого подключения из .NET или Java без Python интерпретатора. Это фактически мини pickle.
В целом решение с Pyro пока понравилось больше других, если же система содержит очень много компонент разных версий, то, наверное, выгоднее будет использовать 0mq. Хотя я пока остановлюсь всё же на Pyro4.
|
https://habr.com/ru/post/151912/
| null |
ru
| null |
# Бесконечная локализация, или как мы переводим карту в режиме реального времени
Что происходит, когда ваш продукт начинает продаваться в другой стране со своим языком и культурными особенностями? Скорее всего, его ждёт локализация. В большинстве случаев требуется перевести только ресурсные файлы, чтобы меню и элементы интерфейса были на привычном пользователю языке. Но что делать, если основа того, что вы продаёте, — данные, которых много, они поступают постоянно, в большом объёме и требуют регулярного перевода. Причём не на один язык, а сразу на несколько.
Под катом вы найдете историю, как этот вопрос решали в 2ГИС. Я расскажу на примере последнего кейса с Дубаем, но практики применимы для любого языка.
Про арабский язык
-----------------
Вся эта история началась с того, что 2ГИС запустился в Дубае, где в ходу два языка: арабский и английский.
Высокая точность данных — важнейшая ценность компании. Она достигается ручным трудом картографов и специалистов на местности. В Дубае, где и местные специалисты, и конечные пользователи знают английский язык, изначально данные вносились только на нём. В процессе роста решили не останавливаться на достигнутом и добавить арабский язык.
Fiji
----
Для работы картографов у нас есть собственный софт. Эта штука называется Fiji и служит мастер-системой по сбору картографических данных. [Мы уже писали](https://habr.com/company/2gis/blog/341508/), как Fiji помогает картографам редактировать домики и рисовать дороги. Выгруженные из Fiji данные после обработки и подготовки идут в конечный продукт, чтобы радовать пользователей. В статье я рассказываю именно про то, что мы реализовали в Fiji для редактирования / хранения / отображения мультиязычных данных.
Термины
-------
В команде мы используем специфичную лексику. Ниже четыре примера ↓
Система поддерживает работу с двумя типами языков:
**Язык метаданных** — язык, на котором отображаются все пользовательские элементы управления: UI, метаданные.
**Язык данных** — язык, на котором отображаются значения атрибутов гео-объектов, некоторые справочники и классификаторы.
Языки привязаны к территориям. У территории может быть два типа языков:
**Основной язык** территории — язык, официально принятый на данной территории.
**Дополнительный язык** территории — язык, на котором мы хотим выпускать продукт. Идёт в дополнение к основному.
Языки и диалекты
----------------
Диалекты, принятые в разных регионах страны, могут существенно отличаться. Поэтому в некоторых системах отдельно хранят ядро языка (= базовый вариант) и диалекты, а потом при выгрузке их мерджат. Нам такой подход показался очень сложным, поэтому мы решили считать каждый диалект самостоятельным языком.
Нюанс, связанный с арабскими языками и диалектами. Для каждого языка нужно ввести флаг направления каретки с двумя значениями: слева направо и справа налево. По умолчанию каретка должна двигаться слева направо. Если выставлено значение справа налево, то нужно менять направление каретки для всех редактируемых, мультиязычных полей. Как это делалось в конечных продуктах было написано [тут](https://habr.com/company/2gis/blog/358148/). Нам нужно было сделать примерно то же самое.
Привязка к территориям
----------------------
Весь мир у нас поделен на определенные территории — это могут быть страны, области, регионы. Для каждой территории мы задаем несколько языков, один из которых считается основным, а остальные — дополнительными. Перевод происходит с основного языка на дополнительные.
Например, в случае с Дубаем основным языком мы оставили английский, ведь на нём было много данных. Арабский же сделали дополнительным.
Ввод и смена языка
------------------
Для комфортной работы картографов мы переработали наш интерфейс в тех местах, где подразумевается мультиязычный ввод.
На этой картинке видно, что мы разбили языки по вкладкам, где самая левая — это основной язык, а дальше идут дополнительные.
Во вкладках дополнительных языков доступны для редактирования только те поля, у которых в базе данных стоит флаг необходимости перевода. Это служит защитной мерой и помогает сфокусировать внимание пользователя на переводе нужных данных. Всё остальное редактируется на основном языке.
На самом деле редактирование данных на дополнительном языке может понадобиться только в том случае, если картограф сам знает несколько языков и не хочет прибегать к помощи переводчика. Для всех остальных есть CrowdIn.
CrowdIn, или перевод на потоке
------------------------------
Итак, мы дали возможность нашим картографам заполнять данные на разных языках. Но гораздо лучше передать задачу по переводу профессионалам.
Первое, что приходит в голову при переводе приложения, — это отдавать ресурсные файлы переводчикам и после перевода загружать их назад.
В этом деле нам сильно помогла платформа CrowdIn. Она позволяет переадресовать ваши файлы профессиональным переводчикам. Дело оставалось за малым — интегрировать переведённые данные в нашу систему.
Ситуация осложняется тем, что данные к нам поступают непрерывным потоком, поэтому и переводы мы бы хотели получать непрерывно.
Оптимизировали систему так: если изменения внесены на основном языке территории — мы выгружаем изменения на перевод на все дополнительные языки этой территории. Исключения делаем для случаев, когда перевод внёс сам картограф. Тут мы считаем, что он понимает, что делает, и незачем подключать переводчика.
Для каждого справочника или объекта карты у нас заведена сквозная версия, которая инкрементируется при каждом обновлении данных. Так мы можем быстро получать все изменения с определённой версии.
Система версионности очень проста и эффективна, но имеет существенный недостаток: по сути мы имеем единую очередь и не можем ею никак управлять. Наш максимум — это пропустить версию. Потребность перейти на нормальную очередь, например, на RabitMQ или Kafka, есть, но руки пока не дошли.
Для оперативного обновления контента мы написали небольшой сервис, работающий в три потока.
Первый поток (Saver) выгребает все данные, требующие перевода, и формирует из них xml-файлы.
Второй (Export) засылает их на CrowdIn и складывает в нужный проект, где указан основной язык, с которого переводим, и список языков, на которые нужно переводить.
Третий (Import) периодически опрашивает API CrowdIn на наличие файлов, у которых перевод был сделан и заапрувлен на 100%, и импортирует готовые файлы в нашу БД.
Без грабель не обошлось. Мы споткнулись об нашу систему версионности данных.
Когда мы загружали перевод слова, версия данных обновлялась и слово снова попадало на перевод.
Чтобы избежать бесконечного цикла перевода, мы начали вести учёт данных. Каждое переведённое слово маркируется, что позволяет исключить его повторную отправку в CrowdIn.
### Туториал
Теперь расскажу, как происходит сама работа с CrowdIn. Есть несколько способов работы с платформой, например, можно залить файлы в Git-репозиторий и CrowdIn их сам засосёт. Но мы посчитали, что работа через API выглядит удобнее.
У CrowdIn есть довольно подробный [туториал](https://support.crowdin.com/api/api-integration-setup/), но ниже я напишу, как делали мы.
Нужно получить API key, который мы будем цеплять к каждому нашему запросу, чтобы система нас верифицировала. Идём на вкладку API в настройках проекта и смотрим, что написано в графе API key.
Этот ключ нужно дописывать в конце каждого вашего запроса к платформе. Например так:
GET: `https://api.crowdin.com/api/project/{myLitleProject}/download/all.zip?key={project-key}`
2. Создаём папку, куда будем заливать файлы внутри проекта.
```
var uri = $"project/{_projectName}/add-directory?key={apiKey}";
var content = new MultipartFormDataContent { { new StringContent(crowdInDirectoryPath), "name" } };
return PostAsync(uri, content);
```
Тут есть немного корявый момент. Мы пишем сервис, неплохо бы, чтобы он вначале проверял, присутствует ли нужная нам папка, перед тем, чтобы пытаться её создавать. У CrowdIn нет нормального способа проверить наличие папки, поэтому мы отправляем запрос на создание. Если её нет, CrowdIn её создаст и вернёт код 200. Если папка была, он ничего создавать не будет и вернёт код 500.
3. Экспорт файлов. У функции add-file очень много опций и параметров, как читать и откуда. Ниже пример, как мы загружаем данные xml-файлами.
**Пример**Все данные, которые мы собрались переводить, мы складываем в xml-файлы со следующей структурой.
```
…
```
Чтобы CrowdIn мог разобрать, какие данные из файла нужно переводить, ему нужно это указать. Для этого в контент нужно записать массив параметров translatable\_elements с путями до нужных элементов документа. В нашем случае это выглядело так:
```
var uri = $"project/{_projectName}/add-file?key={apiKey}";
var content = new MultipartFormDataContent { { new StringContent("/LocalizableDocument/LocalizableValues/LocalizableValue/Attributes/LocalizableAttributeValue/Value"), "translatable_elements[0]" } };
foreach (var filePath in filePaths)
{
var fileName = Path.GetFileName(filePath);
var fileStream = File.OpenRead(filePath);
var fileContent = new StreamContent(fileStream);
content.Add(fileContent, $"files[{_crowdInDirectoryPath}/{fileName}]", fileName);
}
return PostAsync(uri, content);
```
Обратите внимание: в документации прописано, что CrowdIn может прожевать максимум 20 файлов за раз, при этом размер одного файла не должен превышать 100 MB.
4. Узнаём, какие файлы у нас полностью переведены. Это мы делаем с помощью команды для конкретного языка.
```
var uri = $"project/{_projectName}/language-status?key={apiKey}";
var content = new MultipartFormDataContent {{ new StringContent(langCode), "language" } };
return PostAsync(uri, content);
```
Платформа вернёт нам что-то такое:
```
directory
29812
Version 1.0
file
29827
strings.xml
file
7
0
0
32
0
0
```
Здесь нас интересуют значения и . В первом указан процент переведённых строк в данном файле, во втором — процент одобренных значений, если в воркфлоу кроме переводчика участвует ещё и ревьюер. В зависимости от нашего рабочего процесса, например, при 100 мы считаем документ переведённым и одобренным. Теперь этот файл можно импортировать назад к нам.
5. Импортируем файл обратно в нашу систему.
Это делается с помощью простого GET-запроса.
```
https://api.crowdin.com/api/project/{_projectName}/export-file?file={_crowdInDirectoryPath}/{fileName}&language={langCode}&key={project-key}
```
Полученный файл десериализуется и данные импортируются в нашу систему.
Вместо заключения
-----------------
В общих чертах это всё. Конечно, нам ещё потребовалось дорабатывать отображение подписей на карте Fiji, чтобы они показывались на нужном языке в зависимости от того, какую территорию сейчас правит картограф. Нужно было договориться с другими системами, как мы им будем поставлять мультиязычные данные, но это уже другая история.
В итоге мы получили сервис в духе «включил и забыл». Картографы вносят данные, переводчики — переводят, шейх доволен, сервис заливает данные куда надо, а мы решаем более актуальные задачи, не задумываясь о том, как наша система работает на нескольких языках.
|
https://habr.com/ru/post/425283/
| null |
ru
| null |
# Способы использования Math.random() в JavaScript
`Math.random()` — это один из API JavaScript. Это — функция, которая возвращает случайные числа. Диапазон возвращаемых чисел представлен значениями от 0 (включая 0, то есть, она может вернуть 0) до 1 (не включая 1, то есть — единицу она вернуть не может).
```
Math.random(); // возвращает случайное число
```
Эта функция чрезвычайно полезна при разработке игр, при описании анимаций, при создании наборов данных с использованием метода случайного выбора. Случайные числа применяются в процедуральном искусстве, при создании текстов и во многих других случаях. Эти числа можно использовать в веб-разработке, в мобильной разработке, в обычных настольных приложениях.
[](https://habr.com/ru/company/ruvds/blog/534108/)
[Вот](https://codepen.io/jsundai/pen/vYKxNZp) пример, размещённый на CodePen, позволяющий генерировать случайные числа в диапазоне от 0 до 1 и от 0 до 10 (включая 0 и 10).
*Пример использования Math.random()*
Функцией `Math.random()` можно воспользоваться в тех случаях, когда в программах нужен элемент случайности. Рассмотрим десять способов применения этой функции. Все примеры, которые тут показаны, созданы разными программистами, которые, пользуясь `Math.random()`, добиваются различных интересных эффектов.
Анимация
--------
[Вот](https://codepen.io/towc/pen/mJzOWJ) пример, в котором `Math.random()` используется для создания анимации.
*Анимация*
Здесь объекты создаются и анимируются с использованием `Math.random()`. Светящиеся линии случайным образом формируют анимированные шестиугольники.
Музыка, сгенерированная компьютером
-----------------------------------
[Вот](https://codepen.io/jakealbaugh/pen/zxoOjG) проект, демонстрирующий пример использования `Math.random()` в деле создания компьютерной музыки.
*Компьютерная музыка*
Здесь за основу взята традиционная мелодия «Auld Lang Syne» («[Старое доброе время](https://ru.wikipedia.org/wiki/Auld_Lang_Syne)»). Программа строит итоговую композицию, обрабатывая исходный материал по особому алгоритму, основанному на использовании случайных чисел.
Вывод случайного изображения
----------------------------
В [данном](https://codepen.io/jsd041313/pen/RQEOWm) проекте возможности генератора случайных чисел используются для выбора изображений.
*Вывод изображения, выбранного случайным образом*
Ссылки на изображения хранятся в массиве. Генерируемое случайное число умножается на длину массива (полученную с использованием его свойства `length`). Полученное число округляется с помощью функции `Math.floor()` и применяется при установке свойства `src` элемента `img`, используемого для вывода изображения. Делается это при загрузке страницы или при нажатии на кнопку.
Случайный фоновый цвет
----------------------
[Здесь](https://codepen.io/meodai/pen/RerqjG) можно найти проект, в котором показан случайный выбор фонового цвета.
*Случайный выбор фонового цвета*
Самое интересное происходит в этом фрагменте кода:
```
const random = (min, max) => {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
```
Эта функция возвращает случайное целочисленное значение из заданного диапазона. Она используется для настройки характеристик цветов, таких, как тон, насыщенность и светлота.
Если вас интересует вопрос случайного генерирования цветов — взгляните на [этот](https://css-tricks.com/snippets/javascript/random-hex-color/) материал.
Процедуральное искусство
------------------------
[Вот](https://codepen.io/tjoen/pen/iCgfj) проект, в котором случайные числа используются для создания изображения по заданным правилам.
*Процедуральное искусство*
При построении этих необычных кривых функция `Math.random()` используется дважды. Первый раз — для выбора цветов градиента. Второй раз — для настройки максимального радиуса кривых. Это — прекрасный пример того, как при каждом запуске процесса создания изображения получается что-то новое.
Случайный выбор слов из заранее созданного списка
-------------------------------------------------
[Здесь](https://codepen.io/team/css-tricks/pen/OJRVXXG) можно найти программу, которая выводит на экран слова, случайным образом выбираемые из заранее созданного массива.
*Случайный выбор слов*
Вот код, который используется для выбора слова:
```
var word = words[Math.floor(Math.random() * words.length)] + "!";
```
Этот пример очень похож на тот, где на странице выводится изображение, выбранное случайным образом. Пожалуй, разработка подобной программы хорошо подойдёт новичкам, которые хотят попрактиковаться в работе с веб-технологиями.
Генератор ключей API
--------------------
[Вот](https://codepen.io/corenominal/pen/rxOmMJ) проект, в котором случайные числа используются для создания ключей API.
*Система для создания случайных ключей API*
Это — пример использования генератора случайных чисел, имеющий практическое применение в разработке реальных приложений. Здесь для создания UUID (Universally Unique IDentifier, универсальный уникальный идентификатор) программа генерирует 16 случайных чисел. Такой UUID можно использовать в роли ключа для доступа к некоему API.
Вывод фрагментов текста с использованием переходов, сформированных случайными символами
---------------------------------------------------------------------------------------
[Здесь](https://codepen.io/soulwire/pen/mErPAK) можно найти проект, в котором случайные числа используются при выводе текстов.
*Переходы между фразами, сформированные с использованием генератора случайных чисел*
Здесь имеются несколько фраз, выводимых друг за другом. Переходы между фразами реализованы с использованием случайных символов, подбираемых с использованием `Math.random()`. Кажется, что компьютер собирает каждую фразу, выполняя некие таинственные вычисления.
Игра «Камень, ножницы, бумага»
------------------------------
[Здесь](https://codepen.io/studiojvla/pen/ONjyMo) можно найти реализацию игры «Камень, ножницы, бумага».
*Камень, ножницы, бумага*
В этой классической игре `Math.random()` используется в качестве основы игровой логики. Компьютер делает ход, случайным образом выбирая один из трёх вариантов действий.
Генератор надёжных паролей
--------------------------
[Вот](https://codepen.io/nourabusoud/pen/YeMOVv) программа, представляющая собой генератор надёжных паролей.
*Генератор надёжных паролей*
Здесь `Math.random()` используется для заполнения массива с будущим паролем буквами в верхнем и нижнем регистрах, цифрами и другими символами. Это — ещё один отличный пример практического использования `Math.random()`.
Заметки о Math.random()
-----------------------
Вполне возможно, что у вас, после того, как вы взглянули на примеры использования `Math.random()`, возникли вопросы об этой функции. Вот несколько таких вопросов, с которыми мне доводилось встречаться чаще всего.
### ▍По-настоящему ли случайны числа, которые выдаёт Math.random()?
Они, так сказать, не совсем случайны. Эта функция возвращает псевдослучайные числа. Алгоритм, на котором она основана, называется «генератор псевдослучайных чисел» (Pseudo-Random Number Generator, PRNG). Это значит, что последовательность выдаваемых им чисел может быть, в определённых условиях, воспроизведена.
В частности, работа `Math.random()` основана на алгоритме [xorshift128+](https://en.wikipedia.org/wiki/Xoroshiro128+), именно его реализация, вероятно, и отвечает в вашем браузере за генерирование случайных чисел.
### ▍Как получать уникальные значения, в которых отсутствуют повторы?
Есть много методов получения уникальных значений, в последовательности которых отсутствуют повторы. Например, механизм получения таких значений может быть основан на так называемом «тасовании Фишера-Йетса», на алгоритме, направленном на создание случайных перестановок конечных множеств. В следующем примере функция `Math.random()` используется для «тасования» массива.
```
function shuffle (array) {
var i = 0
, j = 0
, temp = null
for (i = array.length - 1; i > 0; i -= 1) {
j = Math.floor(Math.random() * (i + 1))
temp = array[i]
array[i] = array[j]
array[j] = temp
}
}
```
### ▍Функция Math.random() реализует те же возможности, что и API WebCrypto?
Посмотрев примеры использования `Math.random()`, вы могли убедиться в том, что это — замечательная функция. Но если вы занимаетесь созданием приложений, работающих с ценной информацией, и вам нужен более надёжный способ генерирования случайных чисел, я посоветовала бы прибегнуть к API WebCrypto. Этот API может пригодиться, например, тем, кому нужно работать с временными кодами проверки пользователей, нужно генерировать случайные пароли, организовывать лотереи.
Если случайные числа вам нужны для использования их в сферах кибербезопасности, криптографии или статистики — пользуйтесь функцией `window.crypto.getRandomValues()` и посмотрите документацию по API [WebCrypto](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API).
Пользуетесь ли вы функцией Math.random() в своих проектах?
[](https://ruvds.com/ru-rub/news/read/126?utm_source=perevod&utm_medium=ru_vds&utm_campaign=try-maloizvestnih-fakta-AVIF)
[](https://ruvds.com/?utm_source=perevod&utm_medium=ru_vds&utm_campaign=try-maloizvestnih-fakta-AVIF#order)
|
https://habr.com/ru/post/534108/
| null |
ru
| null |
# Плагинная система на ASP.NET. Или сайт с плагинами, мадемуазелями и преферансом
#### Вместо предисловия
Данный материал является исключительно результатом работы по сбору информации в сети и создания сайта, работающего на основе плагинов. Здесь я постараюсь описать идею работы такой системы и основные компоненты, необходимые для её работы.
Данная статья не претендует на оригинальность, а описанная система не является единственно правильной и красивой. Но если тебе, уважаемый $habrauser$, интересно, как создать такую систему, милости прошу под кат
#### Проблематика и постановка задачи
В данный момент я веду достаточно большой проект, разделенный на четыре большие части. Каждая из этих частей разбита минимум на 2 маленьких задачи. Пока в системе было 2 части, поддержка была не напряжной и выполнение изменений не вызывало никаких проблем. Но со временем система разрослась до гигантских размеров и такая простая задача, как сопровождение кода стала достаточно затруднительной. Поэтому я пришел к выводу, что весь этот зоопарк надо дробить на части. Проект представляет собой ASP.NET MVC сайт в интрасети на котором работают сотрудники фирмы. Со временем пять-семь представлений и два-три контроллера переросли в огромную кучу, которую стало трудно обслуживать.
##### Поиск решения
Для начала я начал искать стандартные пути решения проблемы разделения проекта на части. Сразу в голову пришла мысль о областях(Areas). Но данный вариант был отброшен сразу, так как по сути просто дробил проект на еще более маленькие элементы, что не решало проблему. Также были рассмотрены все «стандартные» методы решения, но и там я не нашел ничего, что меня удовлетворило.
Основная идея была проста. Каждый компонент системы должен быть плагином с простым способом подключения к работающей системе, состоящий из как можно меньшего количества файлов. Создание и подключение нового плагина не должно никак затрагивать корневое приложение. И само подключение плагина не должно быть труднее чем пара кликов мышки.
##### Подход первый
В ходе долгого гугления и поисков на просторах интернета было найдено описание плагинной системы. Автор предоставил исходники проекта, которые были скачаны незамедлительно. Проект красивый, и даже выполняет все, что я хочу видеть в готовом решении. Запустил, посмотрел. Действительно, плагины, представленные в виде отдельных проектов компилируются и «автоматически подключаются» (здесь я написал в кавычках не просто так. Далее я напишу почему) к сайту. Я уже был готов прыгать от радости, но… Вот тут возникло НО, которого никак не ждал. Посмотрев параметры проектов плагинов я обнаружил параметры построения. В них были написаны параметры пост-построения, которыми выполнялось копирование библиотеки классов и областей(Areas) в папку с сайтом. Это было большим расстройством. Совсем не похоже на «удобную плагинную систему». Поэтому я продолжил поиски. И, как ни странно, этот поиск завершился успехом.
##### Подход номер два
Итак, на одном из форумов я нашел описание очень интересной системы. Не буду долго расписывать весь путь поэтому я сразу скажу, что нашел именно то, что искал. Система работает на основе прекомплированных плагинов с встроенными представлениями. Подключение нового плагина осуществляется копированием dll'ки в папку плагинов и перезапуском приложения. Именно эту систему я взял за основу для работы.
#### Начало работы
Для начала откроем Visual Studio и создадим новый проект Web Application MVC 4(на самом деле версия MVC не играет огромной роли). Но кидаться в написание кода мы не будем. Мы создадим необходимые базовые компоненты. Поэтому добавим в решение проект типа Class Library и назовем его Infrastructure.
Сначала необходимо создать интерфейс плагина, который должны реализовывать все плагины.
Код простой и писать о нем я не буду.
**IModule**
```
namespace EkzoPlugin.Infrastructure
{
public interface IModule
{
///
/// Имя, которое будет отображаться на сайте
///
string Title { get; }
///
/// Уникальное имя плагина
///
string Name { get; }
///
/// Версия плагина
///
Version Version { get; }
///
/// Имя контроллера, который будет обрабатывать запросы
///
string EntryControllerName { get; }
}
}
```
Теперь мы создадим еще один проект типа Class Library, назовем его PluginManager. В этом проекте будут все необходимые классы, отвечающие за подключение к базовому проекту.
Создадим файл класса и напишем следующий код:
**PluginManager**
```
namespace EkzoPlugin.PluginManager
{
public class PluginManager
{
public PluginManager()
{
Modules = new Dictionary();
}
private static PluginManager \_current;
public static PluginManager Current
{
get { return \_current ?? (\_current = new PluginManager()); }
}
internal Dictionary Modules { get; set; }
//Возвращаем все загруженные модули
public IEnumerable GetModules()
{
return Modules.Select(m => m.Key).ToList();
}
//Получаем плагин по имени
public IModule GetModule(string name)
{
return GetModules().Where(m => m.Name == name).FirstOrDefault();
}
}
}
```
Этот класс реализует менеджер плагинов, который будет хранить список загруженных плагинов и манипулировать ими.
Теперь создадим новый файл класса и назовем его PreApplicationInit. Именно здесь будет твориться магия, которая позволит автоматически подключать плагины при запуске приложений. За «магию» отвечает атрибут PreApplicationStartMethod (прочитать о нем можно [тут](http://msdn.microsoft.com/en-us/library/system.web.preapplicationstartmethodattribute(v=vs.100).aspx)). Если кратко, метод, указанный при его объявлении, будет выполнен перед стартом веб-приложения. Даже раньше чем Application\_Start. Это позволит нам загрузить наши плагины до начала работы приложения.
**PreApplicationInit**
```
[assembly: PreApplicationStartMethod(typeof(EkzoPlugin.PluginManager.PreApplicationInit), "InitializePlugins")]
namespace EkzoPlugin.PluginManager
{
public class PreApplicationInit
{
static PreApplicationInit()
{
//Указываем путь к папке с плагинами
string pluginsPath = HostingEnvironment.MapPath("~/plugins");
//Указываем путь к временной папке, куда будут выгружать плагины
string pluginsTempPath = HostingEnvironment.MapPath("~/plugins/temp");
//Если папка плагинов не найдена, выбрасываем исключение
if (pluginsPath == null || pluginsTempPath == null)
throw new DirectoryNotFoundException("plugins");
PluginFolder = new DirectoryInfo(pluginsPath);
TempPluginFolder = new DirectoryInfo(pluginsTempPath);
}
///
/// Папка из которой будут копироваться файлы плагинов
///
///
/// Папка может содержать подпапки для разделения плагинов по типам
///
private static readonly DirectoryInfo PluginFolder;
///
/// Папка в которую будут скопированы плагины
/// Если не скопировать плагин, его будет невозможно заменить при запущенном приложении
///
private static readonly DirectoryInfo TempPluginFolder;
///
/// Initialize method that registers all plugins
///
public static void InitializePlugins()
{
Directory.CreateDirectory(TempPluginFolder.FullName);
//Удаляем плагины во временной папке
foreach (var f in TempPluginFolder.GetFiles("*.dll", SearchOption.AllDirectories))
{
try
{
f.Delete();
}
catch (Exception)
{
}
}
//Копируем плагины
foreach (var plug in PluginFolder.GetFiles("*.dll", SearchOption.AllDirectories))
{
try
{
var di = Directory.CreateDirectory(TempPluginFolder.FullName);
File.Copy(plug.FullName, Path.Combine(di.FullName, plug.Name), true);
}
catch (Exception)
{
}
}
// * Положит плагины в контекст 'Load'
// Для работы метода необходимо указать 'probing' папку в web.config
// так:
var assemblies = TempPluginFolder.GetFiles("*.dll", SearchOption.AllDirectories)
.Select(x => AssemblyName.GetAssemblyName(x.FullName))
.Select(x => Assembly.Load(x.FullName));
foreach (var assembly in assemblies)
{
Type type = assembly.GetTypes().Where(t => t.GetInterface(typeof(IModule).Name) != null).FirstOrDefault();
if (type != null)
{
//Добавляем плагин как ссылку к проекту
BuildManager.AddReferencedAssembly(assembly);
//Кладем плагин в менеджер для дальнейших манипуляций
var module = (IModule)Activator.CreateInstance(type);
PluginManager.Current.Modules.Add(module, assembly);
}
}
}
}
}
```
Это практически все, что нужно для организации работы плагинной системы. Теперь [скачаем](https://github.com/csteeg/BoC/tree/master/Src/Commons.Web.PrecompiledViews) библиотеку, которая обеспечит работу с встроенными представлениями, и добавим ссылку на неё к проекту.
Осталось создать код, необходимый для регистрации плагинов.
**Скрытый текст**
```
namespace EkzoPlugin.PluginManager
{
public static class PluginBootstrapper
{
public static void Initialize()
{
foreach (var asmbl in PluginManager.Current.Modules.Values)
{
BoC.Web.Mvc.PrecompiledViews.ApplicationPartRegistry.Register(asmbl);
}
}
}
}
```
Данный модуль выполняет загрузку и регистрацию прекомпилированных ресурсов. Это необходимо сделать, чтобы запросы, пришедшие на сервер были правильно направлены на прекомпилированные представления.
Теперь можно перейти к нашей базовой системе и настроить её для работы с плагинами. Для начала мы откроем web.config файл и добавим следующую строку в раздел runtime
```
```
Без этой настройки плагины работать не будут.
Теперь добавим к проекту ссылки на созданные ранее проект EkzoPlugin.PluginManager.
Теперь открываем Global.asax и добавляем всего две строки. Первой мы подключим пространство имен EkzoPlugin.PluginManager
```
using EkzoPlugin.PluginManager;
```
А вторую добавим первой строкой в Applicaton\_Start()
```
protected void ApplicationStart()
{
PluginBootstrapper.Initialize();
```
Тут немного поясню. Помните PreApplicationInit атрибут? Так вот, перед тем, как ApplicationStart получил управление, была выполнена инициализация модулей и их загрузка в менеджер плагинов. А когда управление получила процедура ApplicationStart мы выполняем регистрацию загруженным модулей, чтобы программа знала как обрабатывать маршруты к плагинам.
Вот и все. Наше базовое приложение готово. Оно умеет работать с плагинами, расположенными в папке plugins.
#### Пишем плагин
Давайте теперь напишем простой плагин для демонстрации работы. Сразу хочу оговориться, что все плагины должны иметь общее пространство имен с базовым проектом и располагаться в подпространстве имен Plugin(на самом деле это не жесткое ограничение, но советую его придерживаться, чтобы избежать неприятностей). Эта та цена, которую приходится платить.
За основу возьмем проект Web Application MVC. Создадим пустой проект.
Добавим новую папку Controllers и добавим новый контроллер. Назовем его SampleMvcController.
По умолчанию Visual Studio создает контроллер с единственным экшеном Index(). Так как мы делаем простой плагин для примера, не будем его менять, а просто добавим для него представление.
После добавления представления, откроем его и напишем что-то, что будет идентифицировать наш плагин.
Например так:
```
### Sample Mvc Plugin
```
Теперь откроем менеджер дополнений Visual Studio и установим RazorGenerator. Данное расширение позволяет добавлять представления в скомпилированный dll файл.
После установки, выделим представление index.cshtml в solution explorer'е и в окне свойств выставим следующие значения:
Build Action: EmbeddedResource
Custom Tool: RazorGenerator
Эти настройки дают указание на включение представления в ресурсы компилируемой библиотеки.
Мы почти закончили. Нам надо сделать все два простых шага для того, чтобы наш плагин заработал.
Первым делом мы должны добавить ссылку на созданный ранее проект EkzoPlugin.Infrastructure, содержащий интерфейс плагина, который мы и реализуем.
Добавим в проект плагина класс и назовем его SampleMVCModule.cs
**SampleMVCModule**
```
using EkzoPlugin.Infrastructure;
namespace EkzoPlugin.Plugins.SampleMVC
{
public class SampleMVCModule : IModule
{
public string Title
{
get { return "SampleMVCPlugin"; }
}
public string Name
{
get { return Assembly.GetAssembly(GetType()).GetName().Name; }
}
public Version Version
{
get { return new Version(1, 0, 0, 0); }
}
public string EntryControllerName
{
get { return "SampleMVC"; }
}
}
}
```
Вот и все. Плагин готов. Просто не правда ли?
Теперь скомпилируем решение и скопируем библиотеку, полученную в результате сборки плагина, в папку plugins базового сайта.
Добавим в файл \_Layout.cshtml базового сайта следующие строки
```
@using EkzoPlugin.Infrastructure
@using EkzoPlugin.PluginManager
@{
IEnumerable modules = PluginManager.Current.GetModules();
Func getModule = name => PluginManager.Current.GetModule(name);
}
....
* @Html.ActionLink("Home","Index","Home",null,null)
@foreach (IModule module in modules)
{
* @Html.ActionLink(module.Title, "Index", module.EntryControllerName)
}
...
```
Таким образом мы добавим ссылки на загруженные модули.
#### Вместо заключения
Вот и готов плагинный сайт на ASP.NET MVC. Не все идеально, не все красиво, согласен. Но свою основную задачу он выполняет. Хочу заметить, что при работе с реальным проектом очень удобным будет настройка команд посткомпиляции проектов плагинов, которые будут сами выкладывать результат в папку плагинов базового сайта.
Также хочу отметить, что каждый модуль может быть разработан и протестирован как отдельный сайт, а после компиляции в готовый модуль достаточно просто подключен к проекту.
Есть небольшая тонкость работы с скриптами и ссылками на сторонние библиотеки. Во-первых, плагин будет использовать скрипты, расположенные в папках базового сайта. То есть, если вы добавили на этапе разработки плагина какой-то скрипт, не забудьте выложить его в соответствующий каталог базового класса (это также актуально для стилей, изображений и т.д.).
Во-вторых, подключенная сторонняя библиотека должна быть размещена в папке bin базового сайта. Иначе вы получите ошибку о том, что не удалось найти необходимую сборку.
В-третьих, ваш плагин будет работать с web.config файлом базового сайта. Таким образом, если в плагине используется строка подключение или другая секция, читаемая из файла конфигурации, вам необходимо вручную перенести её.
Надеюсь, что данная статья будет кому-то интересна.
Проект на GitHub — [ссылка](https://github.com/EkzoMan/EkzoPluginsSystem)
Проект с MetroUI шаблоном — [ссылка](https://github.com/EkzoMan/EkzoPluginsSystem/tree/MetroLayout)
|
https://habr.com/ru/post/202776/
| null |
ru
| null |
# Создание опенсорсных инструментов и совершенствование рабочих процессов команды дизайнеров Discord
В прошлом году вышел API Figma, предназначенный для разработки плагинов. Команда дизайнеров Discord увидела в этом событии потрясающую возможность для улучшения своих техпроцессов.
Примерно в то же время, когда поддержка плагинов платформой Figma находилась на стадии бета-версии, мы серьёзно работали над улучшением доступности нашей тёмной и светлой тем. Ни одна из них не соответствовала нашим стандартам доступности и мы делали всё возможное для того чтобы это исправить.
[](https://habr.com/ru/company/ruvds/blog/540682/)
Для того чтобы получить гарантию работоспособности наших новых схем использования цветов, дизайнерам нужно было проектировать каждый новый элемент в двух вариантах. Значит — приходилось делать двойную работу, что отнимало время, но обойтись без этого было нельзя.
Именно тогда и зажглась искра дизайн-инструментов. Мы задались вопросом о том, можем ли мы создать инструменты, способные нам помочь. Предупреждаю: спойлер. Мы могли создать такие инструменты, мы их создали, и получились они просто замечательными. С тех пор подобные инструменты стали важнейшей частью нашей работы.
Мы видим сильные стороны этих инструментов в следующем:
* Меньше времени тратится на выполнение повторяющихся задач, больше времени остаётся на более важные дела.
* Предотвращается возникновение дизайнерского долга.
* Улучшается взаимодействие между разработчиками и дизайнерами.
* Создание этих инструментов способствует формированию сообщества специалистов, занимающихся дизайн-инструментами. Другие люди могут, беря за основу наши наработки, создавать что-то своё.
Вот основные темы, которые будут подняты в этом материале:
* Проблемы, которые мы хотели решить посредством дизайн-инструментов.
* Методология и образ мыслей, которые мы задействовали при создании этих инструментов.
* Рекомендации по использованию наших инструментов другими командами (ура опенсорсу!).
Экономия времени благодаря автоматизации рутинных задач
-------------------------------------------------------
Инструменты для дизайнеров способны автоматизировать «чёрную работу», действия, которые приходится выполнять по десять раз на дню. Например — это одновременная замена текста во множестве текстовых полей, выбор всех экземпляра слоя, или, как в нашем случае, создание двух версий всех визуальных элементов наших проектов.
### ▍Плагин Auto Theme
[Auto Theme](https://github.com/destefanis/auto-theme) — это плагин для Figma, который мы создали для автоматического применения темы к различным элементам.
*Плагин Auto Theme в действии*
Вместо того, чтобы, имея некий компонент, оформленный в тёмной теме, вручную переключать каждый слой и каждый цвет на использование соответствующего цвета из светлой темы, мы можем просто запустить этот инструмент. Это значительно сокращает нагрузку на человека, связанную с проверкой дизайна двух вариантов компонента.
Например, недавно я работал над улучшением пользовательского опыта, связанного с экраном мобильного приложения для входа в систему. Мне хотелось убедиться в том, что и тёмный, и светлый варианты одинаково хороши. Плагин Auto Theme значительно облегчил мою работу.
*Плагин Auto Theme, кроме прочего, заменяет системные компоненты, а это значит, что нам не нужно пытаться самостоятельно применять темы к чему-то вроде строки состояния iOS*
Работа этого плагина основана на обходе выделенных слоёв. Далее, плагин определяет то, как нужно поменять цвет в зависимости от типа слоя. Это — слой с текстом? Значит нужно воспользоваться основным цветом для заголовков. Этот слой представляет собой фигуру? Тогда нужно использовать основной фоновый цвет.
То, какой именно цвет плагин выбирает для того или иного слоя, определяет пользователь. В нашем случае мы один раз задали соответствующие настройки, после чего они применяются всей нашей командой.
В тех случаях, когда инструмент не знает о том, что ему нужно делать (предположим, он наткнулся на иллюстрацию) — он помечает слой и показывает его в списке необработанных слоёв. Мы сами создали этот инструмент, но одним им мы не ограничились. Он — лишь один из многих плагинов, которые мы используем для автоматизации наших повседневных задач.
Предотвращение накопления дизайнерского долга, улучшение взаимодействия дизайнеров и разработчиков
--------------------------------------------------------------------------------------------------
Уверен, большинство дизайнеров слышало такой вопрос: «Ну что, готово это для передачи в разработку?». Хороший ответ на этот вопрос представлен в подписи к следующему рисунку.
*Да, этот дизайн совершенен. С полной уверенностью можно говорить о том, в нём нет ошибок или чего-то подобного*
Но дизайнеры — это не сверхлюди. Ошибки, так или иначе, происходят. И это совершенно нормально. Особенно часто ошибки встречаются при проектировании некоего действия, реализованного путём перехода между несколькими экранами.
### ▍Плагин Design Lint
[Design Lint](https://www.figma.com/community/plugin/801195587640428208/Design-Lint) — это плагин для Figma, который осуществляет проверку дизайн-макетов и исправление найденных ошибок. Он позволяет обеспечить единообразие дизайна и возможность его поддержки в будущем, а так же — готовность макета к передаче в разработку.
*Приятный дизайн. А ещё, полагаю, стоит упомянуть о том, что плагин Design Lint можно установить в Figma уже сейчас*
Дизайнеры часто встречаются с парой серьёзных вопросов: «Готов ли этот макет для передачи в разработку? Не взвоет ли от ужаса новый дизайнер, который откроет этот файл?». Мы справляемся с этими вопросами посредством инструмента, который помогает нам искать ошибки в дизайн-макетах.
Линтинг — это явление, получившее распространение в программировании. Линтеры помогают программистам искать ошибки в коде, позволяют поддерживать код в аккуратном состоянии. В определённый момент мы подумали о том, что файлы с дизайнерскими материалами, похоже, ничем особо не отличаются от файлов с программным кодом.
Design Lint проверяет файлы с макетами в поиске пропущенных стилей (так в Figma называются дизайн-токены или переменные). Используются ли тут шрифты, которых нет в дизайн-системе? Применяется ли где-то значение свойства `border-radius`, которое не предусмотрено принятыми стандартами? Представлен ли этот новый оттенок чёрного цвета переменной, которая уже есть в системе? Design Lint, если найдёт проблемы с чем-то подобным, укажет на них дизайнеру.
*Design Lint позволяет выделять сразу несколько сообщений об ошибках и быстро все эти ошибки исправлять. Он выводит сведения об ошибках в контексте документа, что облегчает их исправление*
Дизайн-макеты часто состоят из сотен или даже тысяч слоёв. Этот инструмент находит ошибки, что позволяет нам эти ошибки исправить до того, как мы передадим макет разработчикам. Это, кроме прочего, экономит время разработчиков, избавляя их от необходимости задавать вопросы в том случае, если, находя ошибки, они не уверены в том, что это ошибки, а не результаты осознанного отступления от правил.
*Работа с Design Lint*
Проверяя с помощью Design Lint всю нашу дизайн-систему, мы можем находить ошибки до того, как они попадут в файлы. Мы создали этот инструмент таким, чтобы им, только что его установив, мог бы пользоваться кто угодно, не настраивая его. Но, так как инструмент это опенсорсный, его можно гибко конфигурировать, создавая собственные правила линтинга.
Упрощение навигации по файлам для всех сотрудников Discord
----------------------------------------------------------
Мы, продуктовая команда, столкнулись с одной проблемой. Она заключается в том, что перемещаться по файлам в Figma не особенно просто. Для того чтобы решить эту проблему, мы создали плагин, который называется Table of Contents.
### ▍Плагин Table of Contents
Плагин [Table of Contents](https://www.figma.com/community/plugin/865650075456407958/Table-of-Contents) автоматически генерирует страницы, называемые «таблицами содержимого». На этих страницах создаётся фрейм со списком всех страниц, имеющихся в файле, ссылки (их можно использовать для перехода к соответствующим материалам), туда же добавляется и дата.
*Плагин Table of Contents помогает людям, не знакомым с Figma, находить то, что им нужно*
Невозможность найти нужные материалы, особенно — в больших проектах, представляла собой проблему, которая часто беспокоила людей, не относящихся к команде дизайнеров. Этот плагин рассчитан на решение проблемы поиска определённых материалов.
Table of Contents — это [опенсорсный плагин](https://github.com/destefanis/figma-table-of-contents), его можно настроить в расчёте на использование шрифтов, используемых в конкретной компании. Он существует и в виде [шаблона Figma](https://www.figma.com/community/file/865646511096801223/Table-of-Contents).
*Люди, работающие в компании, могу найти с помощью Table of Contents то, что им нужно*
Разработка мета-плагинов для ускорения создания новых инструментов
------------------------------------------------------------------
Для того чтобы упростить создание и поддержку новых инструментов, мы создали соответствующий вспомогательный инструмент. Его можно назвать «инструментом для разработки инструментов».
### ▍Плагин Inspector
Плагин Inspector — это такой инструмент, работа которого проста, но вот объяснить то, как именно он работает, это уже задача более сложная.
Каждый слой в Figma содержит важную мета-информацию Это — имя слоя, его ID, сведения о том, есть ли у него потомки (небольшой кружок и небольшой многоугольник, которые очень хорошо делают своё дело), данные о типе слоя (текст, изображение, фигура) и многое другое.
Inspector выводит эту мета-информацию для выделенного слоя. Это — нечто вроде инструментов разработчика Chrome, но инструмент этот предназначен для Figma. Мы, кроме того, используем этот плагин как вспомогательное средство при обновлении цветов Auto Theme в ходе добавления в систему нового цвета.
*Рад видеть вас, Username, я Дэниел*
Опенсорс в Discord
------------------
Мы, сотрудники Discord, верим в ценности опенсорса. И наши инженеры, и дизайнеры часто используют опенсорсные библиотеки, фреймворки, ресурсы.
Мы хотим поделиться со всеми желающими тем полезным, что даёт нам создание и применение вышеописанных инструментов. Именно поэтому всем тем, о чём я рассказал здесь, могут совершенно бесплатно пользоваться те, кому это нужно.
Некоторые из вышеописанных инструментов можно установить прямо со страницы плагинов Figma. Но мы, всё равно, открыли код этих плагинов. Это позволит любому подстроить их под свои нужды.
Вот перечень наших плагинов с соответствующими ссылками:
* Auto Theme — [GitHub](https://github.com/destefanis/auto-theme).
* Design Lint — [страница плагинов Figma](https://www.figma.com/community/plugin/801195587640428208/Design-Lint) или [GitHub](https://github.com/destefanis/design-lint).
* Inspector — [страница плагинов Figma](https://www.figma.com/community/plugin/760351147138040099/Inspector) или [GitHub](https://github.com/destefanis/figma-style-inspector).
* Table of Contents — [страница плагинов Figma](https://www.figma.com/community/plugin/865650075456407958) или [GitHub](https://github.com/destefanis/figma-table-of-contents).
* Discord Project Scaffold — [GitHub](https://github.com/destefanis/Discord-Figma-Project-Scaffold).
Посмотреть наши опенсорсные дизайн-файлы можно [здесь](https://www.figma.com/@discord).
Нашей команде очень интересно наблюдать за развитием инструментов для дизайнеров. Увидим ли мы средства для автоматического форматирования кода, вроде `prettier.js`, но предназначенные для сферы дизайна? Появятся ли «дизайнерские» версии npm или yarn? Можно ли будет пользоваться интерактивной проверкой типов при использовании дизайн-токенов?
Нам до крайности любопытно увидеть новые инструменты, созданные силами сообщества дизайнеров. А вам, надеемся, пригодится то, что создали мы.
Какими плагинами для Figma вы пользуетесь?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=ruvds&utm_content=router-hack#order)
|
https://habr.com/ru/post/540682/
| null |
ru
| null |
# Как подключиться по RDP c ОС Windows, Ubuntu или Debian (Linux), Mac OS, а также с телефона на Android и iPhone
Создавая виртуальный сервер на **[VPS.house](https://vps.house/)**, вы получаете полностью 100% готовую к использованию операционную систему Windows Server, к которому сразу же можно подключаться по сети с любого внешнего устройства по протолку RDP.
**RDP (Remote Desktop Protocol)** – специальный протокол, разработанный компанией Microsoft для удаленного управления ОС Windows (протокол удалённого рабочего стола). Изначально, разумеется, как и многие вещи под Windows, этот протокол разработали другие люди, но в настоящее время поддерживает его и развивает Microsoft.
Согласно условиям лицензирования, ОС Windows Server допускает по умолчанию не более 2-х одновременных подключений по RDP к серверу, если нужно больше, то понимается терминальный сервер и лицензируется либо количество пользователей, либо количество подключаемых устройств. Но, подключившись к серверу по RDP, вы также можете поставить любое удобное вам решение для удалённого управления рабочим столом: TeamViewer, RAdmin и прочие.
Данная статья описывает процесс подключения к серверу Windows по RDP с многих популярных операционных систем. Ввиду этого получилась она довольно длинной. Моментально перейти к нужному вам разделу вы можете по этому меню:
[](/company/vps_house/blog/358488/#windows) [](/company/vps_house/blog/358488/#ubuntu) [](/company/vps_house/blog/358488/#debian) [](/company/vps_house/blog/358488/#macos) [](/company/vps_house/blog/358488/#ios) [](/company/vps_house/blog/358488/#android)
Подключение в VPS серверу из десктопной Windows
-----------------------------------------------
 Данная инструкция проверена и работает успешно на всех популярных версиях Windows для персональных компьютеров: XP, Vista, Windows 7, 8, 8.1 и 10.
В каждой операционной системе Windows есть встроенное приложение для подключения по RDP – это программа «Подключение к удалённому рабочему столу» (Remote Desktop Connection в англоязычных ОС).
Для запуска ее зайдите по пути:
> `Пуск -> Программы -> Стандартные -> Подключение к удалённому рабочему столу`
Если вы используете Windows 8, тогда:
> `Пуск -> Приложения -> Подключение к удалённому рабочему столу`
Если вы используете Windows 10, тогда:
> `Пуск -> Все приложения (может этого пункта не быть!) -> Стандартные Windows -> Подключение к удалённому рабочему столу`
Или же просто нажмите комбинацию клавиш **Win+R** и в открывшемся окне наберите **mstsc**
В открывшемся окне наберите IP-адрес вашего виртуального сервера и нажмите кнопку «Подключить». IP-адрес сервера вы можете видеть в вашем личном кабинете в разделе «Мои серверы»:
Если вы заказали сервер с 2-я или большим количеством IP-адресов, то для подключения к серверу вы можете использовать любой из них – это ни на что не влияет.
Те, кто впервые стакиваются с созданием удалённого рабочего стола, часто задаются вопросом «Зачем нужны эти IP-адреса и сколько нужно именно им», часто также путают количество IP-адресов с количеством рабочих столов или учётных записей, или полагают, что если зайти на сервер по одному адресу, то открывая браузер именно этот адрес будет браузер использовать. Нас самом же деле это всего лишь список внешних адресов, по которому можно подключиться к серверу, сама работа на сервере уже после подключения никаким образом не меняется.
Чаща всего при подключении по умолчанию настроена автоматическая передача данных из буфера обмена, а также подключаются к серверу и становятся на нём видны локальные диски устройства, с которого вы подключаетесь. При сразу после нажатия на кнопку «Подключить» вы можете увидеть уведомление о возможном вреде, который может нанести как удалённый компьютер вашему, так и ваш удалённому. Такое вполне возможно если вы подключаетесь к чужому серверу, на котором могут быть вирусы или вы подключаетесь к своему проведенному серверу с чужого заражённого ПК.
Подключаясь к только что созданному и чистому серверу можно смело отключить дальнейшие уведомления и продолжить процесс подключения.
Далее вы увидите окно с вводом авторизационных данных:
При создании каждого нового сервера система VPS.house автоматически генерирует новый уникальный пароль для него, при этом на всех серверах Windows по умолчанию остаётся имя пользователя **Administrator**. Пароль от сервера отображается также в личном кабинете возле вашего сервера на странице «Мои серверы»:
В целях безопасности, по умолчанию пароль от сервера скрыт и отображается только по нажатию на ссылку «Показать пароль», при этом сайт попросит вас ввести пароль от вашей учётной записи на VPS.house.
Обратите, пожалуйста, внимание на то, что очень часто при попытке подключения с Windows 7 если копировать и вставлять пароль, система показывает ошибку о неверно введённых учетных данных, тоже самое может возникать и в других версиях. Если вы с этим столкнулись, просто **введите пароль вручную** и обязательно с учётом регистра (заглавные буквы вводите заглавными, а строчные строчными и строго в английской раскладке клавиатуры).
После успешной авторизации перед началом сессии вы получите уведомление о **неуспешной проверке подлинности удаленного компьютера**. Причина этого уведомления в том, что сессия на стороне сервера шифруется по умолчанию с помощью SSL-сертификата, который сгенерировал сам же сервер, а не тем, что мог быть выдан авторизованным центром сертификации.
Данное уведомление не говорит о проблемах безопасности, и вы смело можете отключить его для будущих подключений к этому же серверу, отметив галочкой «Больше не выводить запрос о подключениях к этому компьютеру».
Если вы используете для работы **Windows XP** и при подключении система выдает ошибку с текстом *«Удаленный компьютер требует проверку подлинности на уровне сети, которую данный компьютер не поддерживает»*, значит на ваш ПК очень сильно устарел и нужно дополнительно установить небольшое обновление, где его взять и как установить [мы подробно расписали здесь](https://vps.house/help/credSSP).
Встроенная программа подключения к удалённому рабочему столу позволяет с лёгкостью передавать файлы на сервер, копируя их на вашем ПК и вставляя в любую папку уже на самом сервере и наоборот. Помимо этого, можно включить передачу на сервер практически любых USB-устройств и сетевых принтеров и сканеров.
Для включения этих возможностей перед подключением к серверу нажмите на кнопку «Показать параметры»:
Откроется режим расширенных настроек подключения к вашему VDS серверу. Перейдите на вкладку «Локальные ресурсы» и отметьте галочкой требуемые для вас устройства:
Еще одна очень полезная и популярная функция – это возможность **создать готовый файл подключения (так называемый «ярлык»)**, в котором уже сохранены все нужные вам настройки и данные авторизации на сервере. Это особенно удобно если вы хотите дать доступ сотруднику, который не является опытным пользователем ПК.
Для этого также в расширенных настройках подключения на вкладке «Общие» введите имя пользователя (на серверах VPS.house это всегда по умолчанию Administrator), отметьте галочкой «Разрешить мне сохранять учетные данные», чтобы не приходилось вводить пароль каждый раз и, по завершению внесения всех нужных вам остальных параметров подключения (если таковые есть), нажиме кнопку «Сохранить как»:
В итоге вы получите готовый файл с подключением, который вы можете отправить вашему коллеге и тот в свою очередь подключится к серверу 2-я простыми кликами по нему мышкой.
В целях безопасности по умолчанию в данный файл не будет добавлен пароль от учётной записи, он будет запрошен при первом подключении.
---
Как подключиться к серверу по RDP если вы работаете с Ubuntu
------------------------------------------------------------
 Протокол подключения к уделённому рабочему столу Windows (RDP) – это закрытый протокол компании Microsoft, официальных служб под операционные системы Linux Microsoft не выпускает, но так или иначе уже давно существуют стабильно работающие решения, которые в последних редакциях Ubuntu даже включены в изначальную сборку.
Речи идет о клиенте под названием **Remmina**
По умолчанию если Remmina включена в вашу сборку, вы можете найти ее в Поиске по запросу «Remote Desktop Client», если ее нет, то установите ее при помощи следующих команд в Терминале.
1. Устанавливаем пакет Remmina
> `sudo apt-add-repository ppa:remmina-ppa-team/remmina-next`
2. Устанавливаем обновления
> `sudo apt-get update`
3. Устанавливаем плагин протокола RDP
> `sudo apt-get install remmina remmina-plugin-rdp libfreerdp-plugins-standard`
4. Если ранее у вас уже была установлена какая-либо версия Remmina или была запущена до установки, то ее необходимо перезапустить. Это лучше всего сделать перезагрузкой компьютера или с помощью команды:
> `udo killall remmina`
Если после её выполнения вы получили сообщение об ошибке типа «процесс не найден», значит и так все хорошо и можно было команду и не выполнять.
В меню поиска наберите «remote desktop» или «remmina», чтобы найти установленное приложение:
Remmina позволяет добавлять и сохранять список подключений для быстрого доступа к тому или иному серверу. Для сознания нового нажмите на «+», как показано на изображении:
Заполните поля авторизационными данными, которые [указаны в вашем личном кабинете](#account):
На вкладке «Advanced» вы можете также указать качество подключения к серверу и детализации при передаче изображений:
После сохранения данных вы всегда сможете найти ваш сервер в списке подключений Remmina. Для подключения к серверу теперь достаточно просто кликнуть дважды мышкой по строке сервера:
Если вы подключаетесь к серверу впервые с этого приложения, то оно может показать информацию о ошибке в сертификате безопасности. Почему это происходит [мы описали выше в блоке подключения к серверу из десктопной Windows](#ssl).
Достаточно нажать «ОК» и программа продолжит подключение к вашему серверу:
---
Как подключиться к серверу по RDP если вы работаете с Debian
------------------------------------------------------------
 Протокол RDP (Remote Desktop Protocol) – это закрытый протокол удалённого рабочего стола Microsoft. К сожалению, они не выпускают официальных клиентов для работы подключения к серверам Windows с операционных систем, работающих на базе Linux. Однако уже довольно давно существуют стабильно работающие решения.
Одно из самых популярных – это клиент для всевозможных удалённых **Remmina**, именно его мы и рекомендуем использовать для включения к серверам VPS.house или любым другим под управлением ОС Windows.
1. Указываем путь к установочным файлам
> `echo 'deb http://ftp.debian.org/debian stretch-backports main' | sudo tee --append /etc/apt/sources.list.d/stretch-backports.list >> /dev/null`
2. Запускаем процесс установки
> `sudo apt update`
3. Устанавливаем плагин протокола RDP
> `sudo apt install -t stretch-backports remmina remmina-plugin-rdp remmina-plugin-secret libfreerdp-plugins-standard`
Сразу после установки приложение можно найти через поиск программ:
В отличие стандартного от RDP-клиента ОС Windows, Remmina позволяет сохранять в список все свои подключения к различным серверам и осуществлять моментальный доступ к ним. Для добавления первого сервера в список нажмите «+» в левом верхнем углу:
В открывшемся окне задайте параметры подключения к вашему серверу и введите удобное для запоминания имя сервера. Все необходимые для подключения данных [указаны в вашем личном кабинете](#account):
На вкладке «Advanced» («Дополнительные») вы можете задать параметры передачи звука с сервера на ваш ПК, а также качество передаваемого изображения при подключении:
После сохранения я настроек вы увидите новую строку в списке подключений. Для начала работы с сервером достаточно просто дважды кликнуть по нему мышкой:
В момент первого подключения к серверу Remmina покажет уведомление у недоверенном сертификате шифрования. Это не является какой-либо ошибкой или проблемой безопасности. Причину этого сообщения [мы описали выше](#ssl). Просто нажмите «ОК» и вы увидите рабочий стол вашего сервера, при условии, разумеется, что все данные для подключения ранее были введены корректно.
---
Подключение серверу по RDP из Mac OS
------------------------------------
 Для подключения к удалённому рабочему столу для Mac OS компания Microsoft разработала и поддерживает официальный RDP-клиент. Он стабильно работает с любыми версиями ОС Windows.
Для загрузки его перейдите на сайт iTunes: <https://itunes.apple.com/gb/app/id715768417>
Программа обладает интуитивно понятным интерфейсом и позволяет создавать список серверов для дальнейшего моментального подключения к ним.
Для добавления нового сервера в список нажмите «New», как показано на скриншоте:
 
В открывшемся окне укажите авторизационные данные, как указано [в вашем личном кабинете](#account) (IP-адрес сервера, логин Administrator и его пароль), и укажите произвольное название для нового подключения (Connection Name).
По завершению ввода нажмите на кнопку закрытия окна – все данных сохранятся и появится строчка с вашим сервером в списке подключений:
Кликните на эту строчку дважды мышкой, и вы подключитесь к серверу.
При попытке подключения к вашему VPS серверу если он работает на Windows Server 2008 или более новой версии, программа покажет уведомление о том, что не удалось проверить сертификат шифрования. Это не является проблемой безопасности, а всего лишь говорит о том, что сертификат выдан не сертифицированным центром, а сгенерирован самим же сервером.
Для того, чтобы это сообщение в будущем не возникало для этого сервера, нажмите «Показать сертификат».
Отметьте галочкой «Всегда доверять…» и нажмите «Continue».
Если в настройках подключения все параметры были введены без ошибок (IP-адрес, логин и пароль), то вы сразу же увидите рабочий стол вашего Windows Server:
---
Подключение к VDS серверу со смартфона или планшета на iOS (с iPhone или iPad)
------------------------------------------------------------------------------
 Для iOS копания Microsoft выпускает полноценный официальный RDP-клиент комфортного и стабильного подключения к удалённому рабочему столу. Приложение называется **Microsoft Remote Desktop** или **Удаленный рабочий стол**: <https://itunes.apple.com/ru/app/id714464092>
Microsoft Remote Desktop позволяет заранее настроить целый список используемых вами для частого подключения серверов.
Специфика его работы заключается в том, что информация об учётных записях создаётся и хранится отдельно от самого списка серверов. Соответственно, для начала нам требуется добавить учётную запись пользователя Administrator. Для этого нажмите на кнопку настроек (иконка шестерёнок в верхнем левом углу) и выберите «Учётные записи»:
 
В открывшемся окне нажмите на «Добавление учётной записи пользователя» и введите логин Administrator и его пароль, как отображается [в вашем личном кабинете](#account):
  
По завершению вы увидите, что учётная запись Administrator добавлена в список, далее нажмите кнопку «Готово» и вы вернетесь на стартовый экран.
Следующим шагом добавляется непосредственно информация о самом сервере. Нажмите кнопку «+» в правом верхнем углу приложения и в открывшемся меню выберите «Рабочий стол»:
 
В окне добавления нового подключения укажите IP-адрес вашего сервера и выдерите учётную запись Administrator, добавленную на прошлом шаге:
  
В момент первого подключения вы увидите уведомление вы увидите уведомление о недоверенном сертификате безопасности. Причину этого [мы описали выше](#ssl). Выдерите «Больше не спрашивать для этого ПК» и нажмите «Принять».
В случае если IP-адрес и авторотационные данные указаны без ошибки, вы успешно подключитесь к вашему виртуальному серверу:
---
Как подключиться к VPS серверу со смартфона или планшета на Android
-------------------------------------------------------------------
 Для устройств под управлением Android компания Microsoft выпускает полноценное приложение для работы с удалённым рабочим столом – **Microsoft Remote Desktop**. Скачайте его как любое другое приложение в [Google Play](https://play.google.com/store/apps/details?id=com.microsoft.rdc.android&hl=ru).
В отличие от всех описанных выше приложений для подключений с ПК, мобильное приложение Microsoft Remote Desktop разделяет учётные записи и сам список подключений. Поэтому сначала нужно добавить в список учётную запись пользователя Administrator с его паролем, который показан [в вашем личном кабинете](#account):
  
 
После добавления учётной записи возвращайтесь на главный экран приложения для добавления самого подключения (адреса вашего VDS сервера):
 
В открывшемся окне укажите IP-адрес вашего сервера (указан в [личном кабинете](#account)), выберите добавленную ранее учётную запись Administrator и нажмите «Сохранить» («Save»):
 
На главном экране в списке подключений появится ваш сервер, просто нажмите на него, и программа начтёт подключение. Если вы подключаетесь с этого приложения к серверу впервые, то увидите информационное сообщение о том, что приложению не удалось проверить сертификат шифрования. Почему так происходит [описано в начале статьи](#ssl).
Достаточно отметить галочкой «Never ask again for connections to this PC» и данное уведомление больше появляться не будет. Далее нажмите «Connect» и если все авторотационные данные и IP-адрес сервера указан без ошибок, вы успешно к нему подключитесь:
---
P.S.: У клиентов нашего VPS-хостинга часто возникает вопрос, как подключиться к серверу с того или иного устройства. В поисковиках можно найти все эти инструкции в том числе и с картинками, и с видео. Надеюсь, данная статья, будет полезной и здесь, как содержащая в одном месте инструкции по подключению со всех самых популярных устройств и операционных систем.
|
https://habr.com/ru/post/358488/
| null |
ru
| null |
# Устройство ленивой загрузки в популярных фронтенд-фреймворках
[*Snail steampunk by Avi-li*](https://www.deviantart.com/avi-li/art/Snail-steampunk-747850482)
Команда [Mail.ru Cloud Solutions](https://mcs.mail.ru/) [перевела статью](https://blog.fullstacktraining.com/understanding-lazy-loading-in-popular-frontend-frameworks/) о том, что означает ленивая загрузка в трех фронтенд-фреймворках: Angular, React и Vue.js. Далее текст от лица автора.
Один из моих любимых терминов на сегодняшний день — «ленивая загрузка». Честно говоря, когда несколько лет назад я его услышал, то улыбнулся. В этой статье рассмотрю, что именно означает этот термин применительно к трем наиболее часто используемым фронтенд-фреймворкам: Angular, React и Vue.js.
Нетерпеливая загрузка против ленивой
------------------------------------
**Нетерпеливая загрузка** означает загрузку каждого компонента конкретного приложения, что создает потенциальные узкие места в производительности. **Ленивая загрузка** гарантирует, что данный компонент загружается только тогда, когда это необходимо, и ни секундой ранее.
Теперь вы можете подумать: это здорово, приложение станет более быстрым, будет загружаться быстрее. Однако если в вашем приложении есть модуль или компонент, выполнение и загрузка которого занимает значительное время, это все равно означает замедление работы приложения. По этой причине вы можете использовать предварительную загрузку компонента в фоновом режиме. Эта техника требует отдельной статьи — здесь я не буду вдаваться в детали, а просто познакомлю вас с этой концепцией ближе к концу.
О типовых проектах для примера
------------------------------
Примеры приложений, созданных во всех трех фреймворках, очень похожи. Каждый из них показывает следующие две вещи:
* как использовать ленивую загрузку компонента внутри страницы;
* как использовать ленивую загрузку компонента с помощью маршрутизации.
Чтобы эффективно визуализировать ленивую загрузку, демо-приложение (компонент) будет вычислять 42-е число Фибоначчи. Математические операции считаются блокирующими — это означает, что наша программа не может продвинуться дальше; она должна вернуть результат вычисления. Эта стратегия используется только для имитации того, что происходит, если существует фрагмент кода, выполнение которого занимает много времени, и какое влияние он оказывает на общий опыт использования приложения.
Чтобы получить доступ к проекту, пожалуйста, посетите [репозиторий GitHub](https://github.com/tpiros/lazy-loading).
Angular
-------
Давайте начнем наше обсуждение с Angular, потому что у этого фронтенд-фреймворка есть особенность, когда речь заходит о ленивой загрузке компонентов. На самом деле, в Angular модуль — самая маленькая логическая единица, которую мы можем рассматривать для ленивой загрузки через маршрутизацию, потому что компоненты всегда принадлежат модулям.
### Компонент Фибоначчи
Вот как наш компонент выглядит в Angular:
```
fibonacci: number;
ngOnInit(): void {
const fibonacci = num => {
if (num <= 1) return 1;
return fibonacci(num - 1) + fibonacci(num - 2);
};
this.fibonacci = fibonacci(42);
}
```
Поскольку это отдельный компонент и он уже принадлежит корневому компоненту Angular, мы можем загрузить его на страницу.
### Загрузка компонента на странице
Сначала давайте рассмотрим, как загрузить компонент на страницу. Для этого мы добавим следующее:
```
I am the **home** component.
{{ showFibonacci ? 'Hide' : 'Show' }}
```
Вместе со следующим TypeScript-кодом:
```
export class AppComponents {
showFibonacci:Boolean = false;
showMe() {
this.showFibonacci = !this.showFibonacci
}
}
```
Что действительно интересно в этой ситуации, так это то, что компонент `Fibonacci` будет загружаться только в том случае, если значение `showFibonacci` равно `true`. Это означает, что управлять ленивой загрузкой можно только с помощью директивы `ngIf`. Это происходит потому, что Angular не просто показывает или скрывает компонент в DOM — он добавляет или удаляет его на основе указанного условия.
### Ленивая загрузка или роутинг
Во время обсуждения ленивой загрузки через маршрутизацию в Angular мы установили, что необходимо создать функциональный модуль ([больше про функциональные модули Angular](https://angular.io/guide/feature-modules)).
Создать функциональный модуль в нашем приложении вместе со вторым компонентом можно с помощью Angular CLI: `ng g m fibonacci && ng g c --module=fibonacci fibonacci`.
После создания модуля мы можем назначить ему компонент, а затем добавить его в основной модуль маршрутизации (`app-routing.module.ts`):
```
const routes: Routes = [{
path: 'fibonacci', loadChildren: () =>
import('./fibonacci/fibonacci.module').then(m => m.FibonacciModule)
}];
```
Обратите внимание, что мы используем `loadChildren()`и импортируем модуль как часть определения маршрута. Это означает, что модуль будет загружен только тогда, когда будет активен соответствующий маршрут.
Сравните код выше с этим:
```
import { FibonacciComponent } from './fibonacci/fibonacci.component';
const routes: Routes = [{
path: 'fibonacci', component: FibonacciComponent
}];
```
Этот код будет загружать `FibonacciComponent` сразу. Это вызовет значительную задержку в отображении главной страницы приложения. Зачем блокировать главную страницу с помощью операции в компоненте, который мы даже не видим или не используем?
[Тут можно прочитать больше про ленивую загрузку в Angular](https://angular.io/guide/lazy-loading-ngmodules).
Vue
---
Теперь давайте рассмотрим, как добиться ленивой загрузки при разработке с помощью фреймворка Vue.js. Давайте создадим Vue-приложение с помощью интерфейса командной строки Vue CLI и добавим новый компонент. Взгляните на то, как будет выглядеть часть компонента `</code>:<br/>
<br/>
<pre><code class="cpp">const fibonacci = num => {
if (num <= 1) return 1;
return fibonacci(num - 1) + fibonacci(num - 2);
};
const myFibonacci = fibonacci(42);
export default {
name: 'Fibonacci',
data: () => ({
fibonacci: 0
}),
created() {
this.fibonacci =myFibonacci;
}
};</code></pre><br/>
<strong>Обратите внимание</strong>: причина, по которой нам нужно выполнить вычисление вне блока <code>export default {}</code>, в том, что иначе мы не сможем имитировать операцию блокировки. Естественно, Vue.js имеет как свойство <code>mounted</code>, так и свойство <code>method</code>, доступные для компонентов, что позволит вызывать код только при создании компонента.<br/>
<br/>
<h3>Ленивая загрузка одиночного компонента</h3><br/>
В Vue.js мы можем использовать директиву <code>v-if</code> для добавления или удаления элемента из DOM, и так лениво загружать компонент. Однако есть еще много вещей, которые нам нужно сделать, когда речь заходит о сравнении Vue.js и Angular. Взгляните на следующий код:<br/>
<br/>
<pre><code class="cpp"><div v-if="showFibonacci">
<Fibonacci />
</div>
<script>
import Fibonacci from './Fibonacci.vue';
export default {
name: 'Home',
data: () => ({
showFibonacci: false
}),
methods: {
showMe: function() {
this.showFibonacci = !this.showFibonacci;
}
},
components: {
Fibonacci
}
};`
Это может показаться логичным способом сделать ленивую загрузку, однако при открытии страницы становится очевидным, что начальное время загрузки действительно велико. Это происходит потому, что компонент загружается сразу независимо от условия `v-if`. Другими словами, мы говорим Vue загрузить все компоненты независимо от их добавления в DOM.
Производительность загрузки существенно изменится, если мы внесем следующие изменения в элемент
|
https://habr.com/ru/post/506752/
| null |
ru
| null |
# Пишем простой менеджер кеша в памяти на Go
В процессе работы над небольшими проектами часто возникает необходимость в кешировании данных и бывает так, что нет возможности использовать Redis или Memcache. В таких ситуациях подойдет простой и достаточно эффективный способ без использования дополнительных инструментов — кеширование в оперативной памяти.
В этой статье я расскажу, с чего начать, чтобы самостоятельно написать менеджер кеша в памяти на Go.
*Внимание! Данная статья предназначена для начинающих разработчиков исключительно в академических целях и здесь не рассматриваются такие инструменты как Redis, Memcache и т.д
Кроме того мы не будем углубляться в проблемы выделения памяти.*
Для простоты ограничимся тремя основными методами: установка `Set`, получение `Get` и удаление `Delete`.
Данные будем хранить в формате ключ/значение.
Структура
---------
Первое, что необходимо сделать, это создать структуру описывающую наш контейнер-хранилище:
```
type Cache struct {
sync.RWMutex
defaultExpiration time.Duration
cleanupInterval time.Duration
items map[string]Item
}
```
* `sync.RWMutex` — для безопасного доступа к данным во время чтения/записи (подробнее о мьютексах <https://gobyexample.com/mutexes>),
* `defaultExpiration` — продолжительность жизни кеша по-умолчанию (этот параметр можно будет переопределить для каждого элемента)
* `cleanupInterval` — интервал, через который запускается механизм очистки кеша (Garbage Collector, далее GC)
* `items` — элементы кеша (в формате ключ/значение)
Теперь опишем структуру для элемента:
```
type Item struct {
Value interface{}
Created time.Time
Expiration int64
}
```
* `Value` — значение. Так как оно может быть любое (число/строка/массив и т.д) необходимо указать в качестве типа `interface{}`,
* `Created` — время создания кеша,
* `Expiration` — время истечения (в UnixNano) — по нему будем проверять актуальность кеша
Инициализация хранилища
-----------------------
Начнем с инициализации нового контейнера-хранилища:
```
func New(defaultExpiration, cleanupInterval time.Duration) *Cache {
// инициализируем карту(map) в паре ключ(string)/значение(Item)
items := make(map[string]Item)
cache := Cache{
items: items,
defaultExpiration: defaultExpiration,
cleanupInterval: cleanupInterval,
}
// Если интервал очистки больше 0, запускаем GC (удаление устаревших элементов)
if cleanupInterval > 0 {
cache.StartGC() // данный метод рассматривается ниже
}
return &cache
}
```
Инициализация нового экземпляра кеша принимает два аргумента: `defaultExpiration` и `cleanupInterval`
* `defaultExpiration` — время жизни кеша по-умолчанию, если установлено значение меньше или равно 0 — время жизни кеша бессрочно.
* `cleanupInterval` — интервал между удалением просроченного кеша. При установленном значении меньше или равно 0 — очистка и удаление просроченного кеша не происходит.
На выходе получаем контейнер со структурой `Cache`
Будьте внимательны при установке этих параметров, слишком маленькие или слишком большие значения могут привести к нежелательным последствиям, например если установить `cleanupInterval = 1 * time.Second` поиск просроченных ключей будет происходить каждую секунду, что негативно скажется на производительности вашей программы. И наоборот установив `cleanupInterval = 168 * time.Hour` — в памяти будет накапливаться неиспользуемые элементы.
Установка значений
------------------
После того как контейнер создан, хорошо бы иметь возможность записывать в него данные, для этого напишем реализацию метода `Set`
```
func (c *Cache) Set(key string, value interface{}, duration time.Duration) {
var expiration int64
// Если продолжительность жизни равна 0 - используется значение по-умолчанию
if duration == 0 {
duration = c.defaultExpiration
}
// Устанавливаем время истечения кеша
if duration > 0 {
expiration = time.Now().Add(duration).UnixNano()
}
c.Lock()
defer c.Unlock()
c.items[key] = Item{
Value: value,
Expiration: expiration,
Created: time.Now(),
}
}
```
`Set` добавляет новый элемент в кэш или заменяет существующий. При этом проверка на существования ключей не происходит. В качестве аргументов принимает: ключ-идентификатор в виде строки `key`, значение `value` и продолжительность жизни кеша `duration`.
Получение значений
------------------
С помощью `Set` мы записали данные в хранилище, теперь реализуем метод для их получения `Get`
```
func (c *Cache) Get(key string) (interface{}, bool) {
c.RLock()
defer c.RUnlock()
item, found := c.items[key]
// ключ не найден
if !found {
return nil, false
}
// Проверка на установку времени истечения, в противном случае он бессрочный
if item.Expiration > 0 {
// Если в момент запроса кеш устарел возвращаем nil
if time.Now().UnixNano() > item.Expiration {
return nil, false
}
}
return item.Value, true
}
```
`Get` возвращает значение (или `nil`) и второй параметр `bool` равный `true` если ключ найден и `false` если ключ не найден или кеш устарел.
Удаление кеша
-------------
Теперь когда у нас есть установка и получение, необходимо иметь возможность удалить кеш (если он нам больше не нужен) для этого напишем метод `Delete`
```
func (c *Cache) Delete(key string) error {
c.Lock()
defer c.Unlock()
if _, found := c.items[key]; !found {
return errors.New("Key not found")
}
delete(c.items, key)
return nil
}
```
`Delete` удаляет элемент по ключу, если ключа не существует возвращает ошибку.
Сборка мусора
-------------
У нас есть добавление, получение и удаление. Осталось реализовать поиск просроченных ключей с последующей очисткой (GC)
Для этого напишем метод `StartGC`, который запускается при инициализация нового экземпляра кеша `New` и работает пока программа не будет завершена.
```
func (c *Cache) StartGC() {
go c.GC()
}
func (c *Cache) GC() {
for {
// ожидаем время установленное в cleanupInterval
<-time.After(c.cleanupInterval)
if c.items == nil {
return
}
// Ищем элементы с истекшим временем жизни и удаляем из хранилища
if keys := c.expiredKeys(); len(keys) != 0 {
c.clearItems(keys)
}
}
}
// expiredKeys возвращает список "просроченных" ключей
func (c *Cache) expiredKeys() (keys []string) {
c.RLock()
defer c.RUnlock()
for k, i := range c.items {
if time.Now().UnixNano() > i.Expiration && i.Expiration > 0 {
keys = append(keys, k)
}
}
return
}
// clearItems удаляет ключи из переданного списка, в нашем случае "просроченные"
func (c *Cache) clearItems(keys []string) {
c.Lock()
defer c.Unlock()
for _, k := range keys {
delete(c.items, k)
}
}
```
Пример использования
--------------------
```
import (
memorycache "github.com/maxchagin/go-memorycache-example"
)
// Создаем контейнер с временем жизни по-умолчанию равным 5 минут и удалением просроченного кеша каждые 10 минут
cache := memorycache.New(5 * time.Minute, 10 * time.Minute)
// Установить кеш с ключем "myKey" и временем жизни 5 минут
cache.Set("myKey", "My value", 5 * time.Minute)
// Получить кеш с ключем "myKey"
i := cache.Get("myKey")
```
Что дальше?
-----------
Теперь у нас есть менеджер кеша с минимальным функционалом, его будет достаточно для самых простых задач. Если этого мало (а в 95% случаев так и есть) в качестве следующего шага можно самостоятельно реализовать методы:
Count — получение кол-ва элементов в кеше
GetItem — получение элемента кеша
Rename — переименования ключа
Copy — копирование элемента
Increment — инкремент
Decrement — декремент
Exist — проверка элемента на существование
Expire — проверка кеша на истечение срока жизни
FlushAll — очистка всех данных
SaveFile — сохранение данных в файл
LoadFile — загрузка данных из файла
Это далеко не полный список, но для базового функционала скорее всего хватит.
[Исходники c примером на github](https://github.com/maxchagin/go-memorycache-example)
Если вам необходим готовый менеджер кеша в памяти рекомендую обратить внимание на следующие проекты:
[Реализация go-cache от patrickmn](https://github.com/patrickmn/go-cache)
[MemoryCache от beego](https://github.com/astaxie/beego/tree/master/cache)
|
https://habr.com/ru/post/359078/
| null |
ru
| null |
# Задача классификации глазами школьника: определение наличия автомобиля на парковке по кадрам с камеры видеонаблюдения
Здравствуйте, я школьник 11 классов, интересуюсь программированием, около-IT тематикой.
Пишу данный пост с целью поделиться своим проектом, занявшим 10 часов моей жизни на выходных и выполненным с целью понять возможности современных методов анализа данных. Публикация может рассматриваться как пример удачной реализации для людей, несведущих в этой области знания, а также как просьба указать мои ошибки для людей, соответственно, сведущих.
Дано: видео-поток с камеры видеонаблюдения, на котором имеется фрагмент 100x50 пикселей с изображением конкретно парковочного места, на котором может присутствовать или отсутствовать лишь конкретный автомобиль.
**Изображение с камеры**
**Изображение парковочного места**
Задача: определить наличие или отсутствие автомобиля на парковочном месте.
### Получение изображения с камеры
Я использую библиотеку openCV для получения и предобработки изображения.
Следующий код я использовал для построения датасета, который использую для обучения нейросети: я фотографирую ежечасно парковочное место, и после получения 60 фотографий вручную разделяю их на фото с машиной и без неё.
**dataminer.py**
```
import cv2 as cv
import numpy as np
import time
cap = cv.VideoCapture()
r = 0
while r <=100:
cap.open('http://**.**.***.***:***/*****CG?container=mjpeg&stream=main') #URL-адрес видеопотока
hasFrame, frame = cap.read()#Чтение кадра из потока
frame = frame[100:200, 300:750]
box = [0,335,100,385]
quantframe = frame[box[0]:box[2], box[1]:box[3]]#Сохранение в отдельную переменную части кадра с изображением машины
r+=1
cv.imwrite(str(r)+'.png',quantframe) #Сохранение изображения машины в файл
print('saved')
cap.release()
time.sleep(3600)
key = cv.waitKey(1)
if key & 0xFF == ord('q'):
cv.destroyAllWindows()
break
```
### Обработка изображения
Я посчитал верным решением обучать нейросеть не на исходных изображениях, а на изображениях с контурами автомобиля, найденными посредством функции cv2.findcontours(...).
Вот код, преобразующий исходное изображение в изображение контуров:
**Нахождение контуров**
```
def contoursfinder(image):
img = image.copy()
srcimg = img.copy()
hsv_min = np.array((0, 0, 0), np.uint8)
hsv_max = np.array((255, 255, 60), np.uint8) #Поскольку контуры находятся по различиям в цвете между частями картинки, необходимо подобрать параметры, исходя из цветовой гаммы картинки
hsv = cv.cvtColor( img, cv.COLOR_BGR2HSV )
thresh = cv.inRange( hsv, hsv_min, hsv_max )
contours, _ = cv.findContours(thresh, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
img = np.zeros((100,50,3), np.uint8)
cv.drawContours(img, contours, -1, (255,255,255), 1, cv.LINE_AA)
return cv.cvtColor(img, cv.COLOR_BGR2GRAY)
```
Результат работы функции:
**Скрытый текст**
### Нейронная сеть
Я использовал библиотеку tensorflow(keras).
Архитектура сети списана с примера с интернетов: для меня неочевидно объяснение, почему именно так. Если знающие люди расскажут или подскажут где почитать, почему эта архитектура эффективна или почему какая-та другая будет эффективнее, буду безмерно благодарен.
Модель нейросети: последовательна, состоит из двух плотных скрытых слоев в 256 и 128 нейронов и входного, выходного слоев.
**Код**
```
model = keras.Sequential([
keras.layers.Flatten(input_shape=(100, 50)),
keras.layers.Dense(256, activation=tf.nn.relu),
keras.layers.Dense(128, activation=tf.nn.relu),
keras.layers.Dense(2, activation=tf.nn.softmax)
])
model.compile(optimizer=tf.train.AdamOptimizer(),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(trainingimagesarr, trainingimagesarrlabel, epochs=1, callbacks=[tbCallBack])
```
Перед обучением вся numpy матрица была поделена на 255, дабы давать на вход нейросети числа в диапазоне от 0 до 1.
```
trainingimagesarr = trainingimagesarr / 255.0
trainingimagesarrlabel = np.array(trainingimagesarrlabel)-1
```
Теперь я могу вызвав функцию:
```
def realtest():
cap = cv.VideoCapture()
cap.open('http://**.**.***.***:***/*****CG?container=mjpeg&stream=main')
hasFrame, frame = cap.read()
frame = frame[100:200, 300:750]
quantframe = frame[0:100,275:325]
quantframe = contoursfinder(quantframe)
return model.predict(np.array([quantframe]))[0][1]>0.60
```
получить данные о наличии автомобиля на стоянке.
Сильно не пинайте, но чуть-чуть :-)
Спасибо!
|
https://habr.com/ru/post/440608/
| null |
ru
| null |
# Программирование SoC Zynq
В прошлой [публикации](https://habrahabr.ru/post/319736/) я упомянул, что мой SBC для экспериментов пал смертью храбрых. Само собою, встала проблема нового подопытного.
Простой одноплатник мне как-то не хотелось приобретать, поэтому выбор мой пал на SoC'и. Выбирал я между Zynq и Cyclone V. По названию темы, думаю, догадались, что же я решил выбрать.
Данная публикация будет состоять из небольшого обзора платки с заглавной картинки и того, как «программировать» и «конфигурировать» подобное железо. Кому это интересно прошу под кат.
Board
-----
Приобрёл платку **Z-turn Board** фирмы **Myir**. На ней камень Zynq 7020, 85к логических ячеек, 2 ядра Cortex-A9, 1 GB DDR3. Выведеные на плате интерфейсы: JTAG, HDMI, micro SD host, Ethernet, UART, USB OTG и ~100 GPIO pins. Из периферии есть LED, RGB LED, buzzer, inertial and temperature sensors.
Более подробное описание можете поглядеть по [ссылке](http://www.myirtech.com/list.asp?id=502).
Отмечу, что если собираетесь использовать такой камень, то обязательно приобретайте для него радиатор и стойки для соответствующей платы. А если и этого не хватает, то привинтите туда ещё и вентилятор, т.к. этот зверь греется сильно.
Программирование
----------------
Собственно, программивать Zynq можно двумя путями: 1) как обычный MCU baremetal 2) из под OS.
### Baremetal
В этом случае всё предельно просто: накидываете программку--->компилите--->заливаете JTAG'ом в камень. У этого камня 256 кБ флэша для прошивки. Т.к. JTAG отладчик я не приобретал, то показывать тут нечего =)
### OS
В моём случае на micro SD карточке сборка Линукса. Т.е. путь создания, проверки и отладки программ аналогичен описанному, в прошлой публикации.
Элементарщина: накидываете программку--->компилите toolchain'ом и копируюте на плату/компилите на плате/копируюте на плату скрипт--->отлаживаете/запускаете--->имеете профит!
Думаю, заострять на этом внимание не особо нужно, поэтому просто <>:
```
bash>$ touch hellozynq.py
bash>$ echo '#!/bin/python
> print "Hello Zynq!"
> ' > hellozynq.py
bash>$ cat hellozynq.py
#!/bin/python
print "Hello Zynq!"
```
Копируем наш файлик на борду:
```
bash>$ scp hellozynq.py root@:/root/hellozynq.py
root@'s password:
hellozynq.py 100% 35 0.0KB/s 00:00
```
Запускаем:
```
root@localhost:~# chmod +x hellozynq.py
root@localhost:~# python hellozynq.py
Hello Zynq!
root@localhost:~# uname -a
Linux localhost.localdomain 3.15.0-xilinx #9 SMP PREEMPT Tue May 26 17:26:14 CST 2015 armv7l armv7l armv7l GNU/Linux
```
Конфигурирование
----------------
А вот здесь заострим внимание. Путь конфигурирования FPGA части этого SoC'a ориентировочно таков:
1. Создание проекта в IDE фирмы Xilinx
2. Разработка конфигурации
3. Генерация bitstream'а
4. Прошивка
Создание проекта в IDE фирмы Xilinx и разрабокта программы сами по себе займут по статье. Поэтому я возьму готовый проект, который шёл вместе с бордой.
Сперва запускаем проект. Затем запускаем синтез и имплементацию. После генерируем bitstream файл.
Копируем его на борду:
```
bash>$ scp another_blink.bit root@192.168.100.9:/root/ablink.bit
root@192.168.100.9's password:
hw.bit 100% 3951KB 3.9MB/s 00:00
```
Проверяем каталог:
```
root@localhost:~# ls -lahs *.bit
3.9M -rw-r--r-- 1 root root 3.9M Mar 5 10:35 ablink.bit
3.9M -rw-r--r-- 1 root root 3.9M Mar 1 18:17 blink_conf.bit
3.9M -rw-r--r-- 1 root root 3.9M Mar 2 03:13 hw.bit
0 -rw-r--r-- 1 root root 3.9M Mar 2 18:50 uf.bit
```
И конфигурируем FPGA:
```
root@localhost:~# cat hw.bit > /dev/xdevcfg
```
Ура товарищи! Светодиод горит!
**Заметки**:
Конфигурировать FPGA, естественно, можно и отладчиком. Только у меня его нет. Vivado очень мощная штука и требует много памяти и ресурсов CPU. На моих i5 и 4GB ОЗУ постоянно свапует.
Также нужно быть внимательным разработчиком, т.к. я слышал несколько историй о том, как жгли камни неправильно настраивая вывода FPGA. Быть может, это невалидно для Zynq.
**P.S.**:
Я решил взять эту платку т.к. ~~она самая дешёвая и доступная~~ мне интересны FPGA тем, что в них можно синтезировать любые цифровые интерфейсы, делать мультиплексоры выводов и, самое крутое, синтезировать вычислители (автоматы, процессоры, сопроцессоры типа FPU и т.п.). А в купе с Linux'ом на процессорной части можно творить крутейшие вещи.
|
https://habr.com/ru/post/323224/
| null |
ru
| null |
# Ленивый список в C++
В Scala есть интересная коллекция — Stream. Контейнер, который представляет собой список, элементы которого вычисляются (и сохраняются после этого) при первом обращении:
> The class Stream implements lazy lists where elements are only evaluated when they are needed.
Мне захотелось реализовать нечто подобное на C++.
Цель
====
Хочется получить контейнер, который можно использовать со стандартными алгоритмами и чтобы его элементы могли генерироваться по мере обращения к ним.
**Забегая вперед, приведу пример использования:**
```
typedef lazy::list list\_type;
list\_type fibonacci(int n1, int n2)
{
int next = n1 + n2;
std::cout << "fibonacci(" << n1 << ", " << n2 << ") -> " << n1 << std::endl;
return list\_type(n1, std::bind(&fibonacci, n2, next));
}
int main()
{
list\_type list(fibonacci(0, 1));
auto res3 = std::find\_if(list.begin(), list.end(), [](int v){return v > 3;});
std::cout << "first number greater 3 is " << \*res3 << std::endl;
std::cout << std::endl;
auto res10 = std::find\_if(list.begin(), list.end(), [](int v){return v > 10;});
std::cout << "first number greater 10 is " << \*res10 << std::endl;
return 0;
}
```
На выводе будет:
```
fibonacci(0, 1) -> 0
fibonacci(1, 1) -> 1
fibonacci(1, 2) -> 1
fibonacci(2, 3) -> 2
fibonacci(3, 5) -> 3
fibonacci(5, 8) -> 5
first number greater 3 is 5
fibonacci(8, 13) -> 8
fibonacci(13, 21) -> 13
first number greater 10 is 13
```
Как видно из примера, функция генерации элемента вызывается только один раз для каждого элемента, полученное значение хранится в контейнере и повторно не вычисляется.
Ограничения
===========
Предположим, мы хотим выполнить что-то типа:
```
auto iter = --list.end();
```
Чтобы получить элемент, предшествующий end, необходимо обойти все элементы, генерируемые функцией, а это бесконечность (для примера выше). Соответственно, итератор по ленивому списку будет однонаправленный — ForwardIterator. Аналогичная ситуация будет и при получении количества элементов в списке, и при удалении последнего элемента (pop\_back). Таким образом, этих методов у контейнера не будет.
Для простоты я не стал реализовывать вставку в произвольное место и удаление произвольного элемента. Исключительно из соображения, что последовательность элементов может генерироваться какой-то функцией, и при вставке/удалении эта последовательность будет нарушена. Из этих же соображений элементы не модифицируемые. Но это уже условности.
Что же получилось?
==================
Получился список, в который можно добавлять как элементы, так и функторы, генерирующие ленивый список, который в свою очередь может содержать элементы и функторы. Удалять можно либо первый элемент (pop\_front), либо все элементы (clear). Вставка элементов осуществляется в начало или конец списка.
Итератор по списку однонаправленный, не позволяющий модифицировать элементы списка.
```
template< typename T, typename Allocator = std::allocator > class list;
```
**определение списка**
```
template< typename T, typename Allocator = std::allocator >
class list
{
public:
typedef list self\_type;
typedef T value\_type;
typedef std::function func\_type;
typedef \_\_details\_lazy\_list::const\_iterator iterator;
typedef \_\_details\_lazy\_list::const\_iterator const\_iterator;
friend \_\_details\_lazy\_list::const\_iterator;
list();
list(const self\_type& that);
list(self\_type&& that);
template
explicit list(Args&&... args)
{
push\_others(std::forward(args)...);
}
void push\_back(const value\_type& value);
void push\_back(value\_type&& value);
void push\_back(const func\_type& func);
void push\_back(func\_type&& func);
void push\_back(const self\_type& that);
void push\_back(self\_type&& that);
void push\_front(const value\_type& value);
void push\_front(value\_type&& value);
void push\_front(const func\_type& func);
void push\_front(func\_type&& func);
void push\_front(const self\_type& that);
void push\_front(self\_type&& that);
void clear();
bool empty() const;
const\_iterator begin() const;
const\_iterator end() const;
private:
typedef std::list container\_type;
typedef typename container\_type::iterator inner\_iterator;
typedef value\_type const \* funcs\_map\_key\_type;
typedef std::pair funcs\_map\_value\_type;
typedef std::map funcs\_map\_type;
void forward(const\_iterator& iter) const;
void insert(inner\_iterator pos, self\_type&& that) const;
template
void push\_others(Arg&& arg, Args&&... args)
{
push\_back(std::forward(arg));
push\_others(std::forward(args)...);
}
template
void push\_others(Arg&& arg)
{
push\_back(std::forward(arg));
}
void push\_others() {}
mutable container\_type \_cont;
mutable funcs\_map\_type \_funcs;
};
```
**определение итератора**
```
template< typename lazy_list_type >
class const_iterator:
public std::iterator
{
friend lazy\_list\_type;
public:
typedef std::iterator base\_type;
const\_iterator();
typename base\_type::reference const operator\* () const;
typename base\_type::pointer const operator-> () const;
const\_iterator& operator++();
const\_iterator operator++(int);
bool operator== (const const\_iterator& that);
bool operator!= (const const\_iterator& that);
private:
typedef typename lazy\_list\_type::inner\_iterator inner\_iterator;
const\_iterator(const lazy\_list\_type\* owner, inner\_iterator iter);
const lazy\_list\_type\* \_owner;
inner\_iterator \_iter;
};
```
В конце статьи есть ссылка на репозиторий, где можно взять реализацию с юнит-тестами.
Шаблонные параметры.
--------------------
**T** — тип хранимых элементов
**Allocator** — аллокатор, используемый для размещения элементов.
Внутренние типы
---------------
| Тип | Описание |
| --- | --- |
| value\_type | T |
| self\_type | собственный тип |
| func\_type | тип функтора, используемого для генерации элемента. Функтор возвращает объект self\_type. |
| iterator | константный forward итератор |
| const\_iterator | константный forward итератор |
Методы
------
| Метод | Описание |
| --- | --- |
| push\_front | вставка в начало |
| push\_back | вставка в конец |
| empty | проверка, является ли контейнер пустым |
| clear | удалить все элементы |
| pop\_front | удалить первый элемент |
Методы push\_front и push\_back принимают функтор, генерирующий элементы, значение хранимого элемента или другой объект типа self\_type.
Конструкторы
------------
| Сигнатура | Описание |
| --- | --- |
| `list();` | Создает пустой контейнер |
| `template explicit list(Args&&... args)` | Cоздает контейнер и помещает в него переданные элементы.
Могут быть переданы значения следующих типов:
`value_type`
`func_type`
`self_type` |
Как это работает
----------------
Внутри используются два стандартных контейнера — std::list для хранения значений и std::map для хранения функторов. Функтор должен возвращать ленивый список, т.е. self\_type. Это позволяет, во-первых, рассчитать при необходимости сразу несколько элементов, а во-вторых, не заботиться о случае, когда нет следующего значения — закончилась последовательность, в этом случае можно просто вернуть пустой контейнер.
С добавлением нового элемента все просто — он сразу добавляется во внутренний список.
При добавлении функтора проверяется, есть ли функтор, ассоциированный с элементом, после которого он добавляется (push\_back). Если функтора нет, то переданный функтор добавляется в map, а в качестве ключа берется указатель на предыдущий элемент. При добавлении в начало, в пустой контейнер или после элемента, с которым уже есть ассоциированный функтор, просто вызывается метод функтора operator(), и значения из полученного контейнера вставляются в нужное место (в начало или конец), в map добавляются новые функторы, если они есть в возвращенном контейнере.
Можно было бы хранить в списке пару "значение — функтор", но мне кажется, что в процессе работы количество функторов будет существенно меньше количества вычисленных элементов, и затраты памяти в случае хранения пар будут выше.
Опять же, так как предполагаю, что количество функторов не будет очень большим, то нет особой разницы, что использовать — map или unordered\_map. Единственное, что при использовании map затраты памяти будут чуть меньше, мне так кажется.
Когда инкрементируется итератор, то проверяется наличие функтора для текущего элемента, если он есть, то возвращаемое им значение добавляется в контейнер, а функтор удаляется. После этого инкрементируется итератор на внутренний список. Если функтора нет или он вернул пустой контейнер, то просто производится переход к следующему элементу во внутреннем списке.
Зачем все это?
==============
К реализации такого списка меня подтолкнула задача Water Pouring, представленная в лекции по языку Scala. Суть в следующем: есть несколько стаканов фиксированного объема, кран, из которого можно наполнить любой стакан (мы можем наполнить стакан только полностью), и раковина, куда можно вылить содержимое стаканов. Наполняя, опустошая и переливая воду из одного стакана в другой, нужно получить заданное количество воды в одном из стаканов. Решение — последовательность действий для получения такого состояния.
Например, есть два стакана объемом 3 и 5 литров, мы хотим получить 4 литра.
Будем рассматривать текущее количество воды в каждом из стаканов как состояние. Из каждого состояния можно получить новый набор возможных состояний, применив одну из возможных операций: наполнить, вылить, перелить. Из каждого набора состояний можно получить новый набор. Чтобы не зациклиться, будем отдельно хранить полученные состояния и отбрасывать их при получении набора новых состояний.
В каждом наборе состояний будем смотреть, есть ли искомое состояние — стакан с искомым уровнем воды.
Нам понадобятся возможные варианты воздействия на текущее состояние. Каждый вариант перемещения воды будет наследовать интерфейс imove:
```
class imove
{
public:
virtual state operator()(const state& cur) const = 0;
virtual std::unique_ptr clone() const = 0;
virtual std::string to\_string() const = 0;
virtual ~imove() {}
};
```
Метод `to_string` нужен только для вывода информации на экран.
Для этой задачи возможны следующие типы перемещения:
**Наполнить стакан - fill**
```
class fill: public imove
{
public:
fill(unsigned glass, unsigned capacity);
state operator()(const state& cur) const override;
std::unique_ptr clone() const override;
std::string to\_string() const override;
protected:
const unsigned \_glass;
const unsigned \_capacity;
};
fill::fill(unsigned glass, unsigned capacity) :
\_glass(glass),
\_capacity(capacity)
{}
state fill::operator()(const state& cur) const
{
assert(cur.size() > \_glass);
state next(cur);
next[\_glass] = \_capacity;
return next;
}
std::unique\_ptr fill::clone() const
{
return std::unique\_ptr(new fill(\_glass, \_capacity));
}
std::string fill::to\_string() const
{
return "fill(" + std::to\_string(\_glass) + ")";
}
```
**Вылить воду из стакана - empty**
```
class empty: public fill
{
public:
empty(unsigned glass);
std::unique_ptr clone() const override;
std::string to\_string() const override;
};
empty::empty(unsigned glass) :
fill(glass, 0)
{}
std::unique\_ptr empty::clone() const
{
return std::unique\_ptr(new empty(\_glass));
}
std::string empty::to\_string() const
{
return "empty(" + std::to\_string(\_glass) + ")";
}
```
**Перелить из одного стакана в другой - pour**
```
class pour: public imove
{
public:
pour(unsigned from, unsigned to, unsigned capacity_to);
state operator()(const state& cur) const override;
std::unique_ptr clone() const override;
std::string to\_string() const override;
protected:
const unsigned \_from;
const unsigned \_to;
const unsigned \_capacity\_to;
};
pour::pour(unsigned from, unsigned to, unsigned capacity\_to) :
\_from(from),
\_to(to),
\_capacity\_to(capacity\_to)
{}
state pour::operator()(const state& cur) const
{
assert((cur.size() > \_from) && (cur.size() > \_to));
assert(\_capacity\_to >= cur[\_to]);
unsigned amount = std::min(cur[\_from], \_capacity\_to - cur[\_to]);
state next(cur);
next[\_from] -= amount;
next[\_to] += amount;
return next;
}
std::unique\_ptr pour::clone() const
{
return std::unique\_ptr(new pour(\_from, \_to, \_capacity\_to));
}
std::string pour::to\_string() const
{
return "pour(" + std::to\_string(\_from) + ", " + std::to\_string(\_to) + ")";
}
```
Также нужно хранить информацию о новом состоянии, а именно состояние и набор перемещений, приведших к нему. За это будет отвечать класс `path`:
```
class path
{
public:
path(const state& initial_state);
path(const path& that);
void extend(imove_ptr move);
const state& end_state() const;
std::string to_string() const;
bool empty() const;
private:
std::list \_history;
state \_end\_state;
};
```
И собственно класс, который использует ленивый список и вышеперечисленные вспомогательные классы для нахождения решения:
```
typedef std::list paths\_list;
class water\_pouring
{
public:
water\_pouring(std::initializer\_list capacities);
path solve(unsigned target);
private:
typedef lazy::list list\_of\_paths\_type;
list\_of\_paths\_type extend(const paths\_list& paths);
const std::vector \_capacities;
const std::vector \_posible\_moves;
const state \_initial;
std::set \_explored\_states;
list\_of\_paths\_type \_paths;
};
```
Класс имеет два публичных метода — конструктор, который принимает емкости стаканов, и метод, возвращающий путь достижения требуемого состояния.
Приватный метод extend используется для генерации элементов ленивого списка.
Он хранит емкости стаканов, набор возможных перемещений, начальное состояние, уже "найденные" состояния и собственно ленивый список состояний с историей их получения.
**Для получения возможных перемещений используется функция create\_moves**
```
std::vector create\_moves(const std::vector& capacities)
{
std::vector moves;
for (size\_t i = 0; i < capacities.size(); ++i)
{
moves.emplace\_back(new empty(i));
moves.emplace\_back(new fill(i, capacities[i]));
for (size\_t j = 0; j < capacities.size(); ++j)
{
if (i != j)
moves.emplace\_back(new pour(i, j, capacities[j]));
}
}
return moves;
}
```
Метод `water_pouring::extend`:
```
water_pouring::list_of_paths_type water_pouring::extend(const paths_list& paths)
{
paths_list next;
for (auto& cur_path: paths)
{
for (auto move: _posible_moves)
{
state next_state = (*move)(cur_path.end_state());
if (_explored_states.find(next_state) == _explored_states.end())
{
path new_path(cur_path);
new_path.extend(move);
next.push_back(new_path);
_explored_states.insert(next_state);
}
}
}
if (next.empty())
return list_of_paths_type();
return list_of_paths_type(next, std::bind(&water_pouring::extend, this, next));
}
```
Метод `water_pouring::solve`:
```
path water_pouring::solve(unsigned target)
{
paths_list::const_iterator solution;
auto it = std::find_if(
_paths.begin(),
_paths.end(),
[target, &solution](const paths_list& paths) -> bool {
solution = std::find_if(
paths.begin(),
paths.end(),
[target](const path& p) -> bool {
auto it = std::find(
p.end_state().begin(),
p.end_state().end(),
target);
return it != p.end_state().end();
});
return solution != paths.end();
});
if (it != _paths.end())
return *solution;
return path(state({0}));
}
```
Собственно, для поиска решения используется функция std::find\_if, а в качестве предиката — лямбда функция, просматривающая пути на наличие необходимого состояния. Лямбда захватывает по ссылке solution, чтобы лишний раз не проходиться по списку решений, на которые будет указывать итератор it в случае, если решение было найдено.
В итоге программа выведет следующее решение:
```
fill(1) pour(1, 0) empty(0) pour(1, 0) fill(1) pour(1, 0) --> (3, 4)
```
Придумать другую задачу, где мог бы пригодиться "ленивый" список, я не смог. Надеюсь, идея кому-нибудь приглянется.
Ссылки
======
* [Исходный код lazy\_list](https://bitbucket.org/hokum/lazy_list)
* [Исходный код решения Water Pouring на C++](https://bitbucket.org/hokum/waterpouringcpp)
* [Исходный код решения Water Pouring на Scala](https://bitbucket.org/hokum/waterpouringscala)
* [Курс лекций Functional Programming Principles in Scala в рамках которого была расмотрена и задача Water Pouring](https://www.coursera.org/course/progfun)
* [Для юнит тестов использовал фреймворк Catch](https://github.com/philsquared/Catch)
|
https://habr.com/ru/post/277737/
| null |
ru
| null |
# Oracle Call Interface: как написать клиентское приложение на Си
Хабр, привет! Вообще-то я не настоящий ~~сварщик~~ программист, я системный администратор и администратор БД. Поэтому, когда несколько лет назад передо мной встала задача написать небольшое клиентское приложение для автоматизации рутинных процедур, я потратил немало времени, чтобы разобраться в этом вопросе. Если вдруг у вас примерно такая же ситуация, надеюсь, эта статья сэкономит ваше время и силы.
Что нужно?
----------
Определившись с требованиями получаем следующее.
**Желательно для бинарника:**
* Небольшой размер исполняемого файла.
* Корректная обработка случаев, когда OCI-библиотека недоступна
**Необходимо для бинарника:**
* Работать утилита должна на любом компьютере с ОС Windows выше Windows 7 или Windows Server 2008 без установки каких-либо фреймворков и Runtime Environment. Должен быть установлен только какой-то из продуктов Oracle, включающий OCI-библиотеку.
**Очень желательно для исходников:**
* Чтобы готовый проект можно было без проблем скомпилировать на другом компьютере без установки каких-либо библиотек. Так как у нас есть похожий legacy проект, которую лет 20 назад писал давно ушедший сотрудник. Его рабочую станцию мы храним в виде образа ВМ, так как подготовить окружение на новой рабочей станции - задача крайне нетривиальная.
Какую технологию использовать?
------------------------------
Oracle предлагает следующие варианты:
* **Pro\*C/C++** - Предкомпилятор Oracle. Инструмент программирования, который позволяет встраивать операторы SQL в хост-программу высокого уровня. Предварительный компилятор принимает основную программу в качестве входных данных, преобразует встроенные инструкции SQL в стандартные вызовы библиотеки Oracle во время выполнения и создает исходную программу, которую вы можете скомпилировать, связать и выполнить. Разобраться с этим у меня не получилось, поэтому ничего к этому описанию я добавить не могу
* **C++ Call Interface (OCCI)** - API, который предоставляет приложениям C++ доступ к данным в базе данных Oracle. OCCI позволяет программистам на C++ использовать весь спектр операций с базами данных Oracle, включая обработку инструкций SQL и манипулирование объектами. Так как я С++ в реальных проектах не использовал, этот вариант мне явно не подходил
* **Oracle Call Interface (OCI)** - API, который позволяет создавать приложения, использующие вызовы функций для доступа к базе данных Oracle и управления всеми этапами выполнения инструкций SQL. OCI поддерживает типы данных, соглашения о вызовах, синтаксис и семантику C и C++. Он предоставляет библиотеку стандартных функций доступа к базе данных и поиска в виде библиотеки динамической среды выполнения (библиотеки OCI), которая может быть связана в приложении во время выполнения. Также в описании указано, что все оракловые утилиты (типа sqlplus, exp, imp и прочие) написаны именно с использованием OCI. Что же еще нужно?
* **Oracle Database Programming Interface for C (ODPI-C)** - это C-библиотека с открытым исходным кодом, которая упрощает использование общих функций интерфейса вызовов Oracle (OCI) для драйверов баз данных Oracle и пользовательских приложений. DPIC находится поверх OCI и требует клиентских библиотек Oracle. Проект лежит на [Гитхабе](https://github.com/oracle/odpi). Про этот вариант я прочитал только когда писал эту статью. Но, посмотрев примеры программ, я нисколько не пожалел, что выбрал OCI. Может, это вопрос привычки и опыта, но простой эта библиотека мне не показалась.
Пишем простое приложение
------------------------
### Подключение библиотеки
Для того, чтобы использовать OCI функции в своей программе, нужно подключить библиотеку и получить адреса функций:
Подключение библиотеки и получений адресов функций
```
//подкллючаем библиотеку в Windows
hOCIDll = LoadLibraryW(L"oci.dll");
//или в Линукс
ocimodule = dlopen("libclntsh.so", RTLD_LAZY);
//Определяем тип для указателя функции
typedef sword(*pOCIEnvCreate)(OCIEnv **hOraEnvp,
ub4 mode,
const void *ctxp,
const void *(*malocfp)
(void *ctxp,
size_t size),
const void *(*ralocfp)
(void *ctxp,
void *memptr,
size_t newsize),
const void(*mfreefp)
(void *ctxp,
void *memptr),
size_t xtramemsz,
void **usrmempp);
//выделяем переменную для адреса функции
pOCIEnvCreate OCIEnvCreate;
//Получаем адрес функции на Windows
OCIEnvCreate = (pOCIEnvCreate)GetProcAddress(hOCIDll,
"OCIEnvCreate");
// Или на Linux
OCIEnvCreate = (pOCIEnvCreate)dlsym(ocilib,"OCIEnvCreate");
```
Таком образом нужно получить адреса всех функций, которые мы будем использовать в нашей программе.
Определения функций можно найти либо на <https://docs.oracle.com> в Call Interface Programmer's Guide для вашей версии библиотеки либо в заголовочном файле %ORACLE\_HOME%\OCI\include\ociap.h
### Инициализация окружения
Далее нам нужно инициализировать структуры OCIEnv (хендл окружения) и OCIError (хендл для обработки ошибок).
Инициализация окружения
```
OCIEnv *hOraEnv = NULL;
OCIError *hOraErr = NULL;
OCIEnvCreate((OCIEnv **)&hOraEnv,
(ub4)OCI_DEFAULT | OCI_OBJECT,
(const void *)0,
(const void * (*)(void *, size_t))0,
(const void * (*)(void *, void *, size_t))0,
(const void(*)(void *, void *))0,
(size_t)0, (void **)0));
OCIHandleAlloc((const void *)hOraEnv,
(void **)&hOraErr,
OCI_HTYPE_ERROR,
(size_t)0,
(void **)0));
```
### Создание сессии
Для каждой сессии нам нужно инициализировать хендл OCISvcCtx, именно он используется для выполнения sql-выражений. Я, руководствуясь демонстрационными примерами от Oracle, создавал сессии так:
Установка сессии
```
OCIServer *hOraServer = NULL;
OCISvcCtx *hOraSvcCtxOCI = NULL;
OCISession *hOraSession = NULL;
//Аллоцируем хендл OCIServer
OCIHandleAlloc((const void *)hOraEnv, (void **)&hOraServer,
OCI_HTYPE_SERVER, (size_t)0, (dvoid **)0);
char *dbconnectstring = "servername:1521/ORCL";
//Подключаемся к серверу
OCIServerAttach(hOraServer, hOraErr, (const OraText *)dbconnectstring,
(sb4)strlen(dbconnectstring), (ub4)OCI_DEFAULT);
//Аллоцируем хендл сервисного контекста
OCIHandleAlloc((const void *)hOraEnv, (void **)&hOraSvcCtx,
OCI_HTYPE_SVCCTX, (size_t)0, (dvoid **)0);
//Помещаем хендл сервера в сервисного контекста
OCIAttrSet((void *)hOraSvcCtx, OCI_HTYPE_SVCCTX, (void *)hOraServer,
(ub4)0, OCI_ATTR_SERVER, (OCIError *)hOraErr));
//Аллоцируем хендл для сессии
OCIHandleAlloc((const void *)hOraEnv, (void **)&hOraSession,
(ub4)OCI_HTYPE_SESSION, (size_t)0, (void **)0);
char * username = "SCOTT";
//Помещаем имя пользователя в хендл сессии
OCIAttrSet((void *)hOraSession, (ub4)OCI_HTYPE_SESSION,
(void *)username, (ub4)strlen(username),
(ub4)OCI_ATTR_USERNAME, hOraErr);
char *password = "tiger";
//Помещаем пароль в хендл сессии
OCIAttrSet((void *)hOraSession, (ub4)OCI_HTYPE_SESSION,
(void *)password, (ub4)strlen(password),
(ub4)OCI_ATTR_PASSWORD, hOraErr);
//флаг для указания, является ли пользователь sysdba
bool assysdba = 1;
//Начинаем сессию
OCISessionBegin(hOraSvcCtx, hOraErr,
hOraSession, OCI_CRED_RDBMS,
(ub4)(OCI_DEFAULT | (assysdba ? OCI_SYSDBA : 0)));
//Помещаем сессию в сервисный контекст
OCIAttrSet((void *)hOraSvcCtx, (ub4)OCI_HTYPE_SVCCTX,
(void *)hOraSession, (ub4)0, (ub4)OCI_ATTR_SESSION,
hOraErr);
```
Уже в процессе написания статьи, я увидел, что для этих же целей можно использовать функцию OCILogon2. Судя по всему, это намного проще и удобнее. А главное, нужно меньше писать кода. Но мы уже оставим все, как есть.
### Вставляем данные
Пример функции для загрузки данных в базу:
Выполняем Insert
```
char * insert_statement = "INSERT INTO simple_table\
(id, textfield)\
VALUES\
(:id, :string)";
sword status;
int id;
char stringBuffer[100];
OCIStmt *hOraPlsqlStatement = NULL;
//Аллоцируем хендл для sql-выражения
OCIHandleAlloc((const void *)hOraEnv,
(void **)&hOraPlsqlStatement, OCI_HTYPE_STMT,
(size_t)0, (void **)0);
//Подготавливаем его
OCIStmtPrepare(hOraPlsqlStatement, hOraErr,
(const OraText *)insert_statement,
(ub4)strlen(insert_statement),
(ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT);
//Биндим наши переменные id и stringBuffer в sql-выражение
OCIBind *bnd1p = NULL;
OCIBind *bnd2p = NULL;
OCIBindByName(hOraPlsqlStatement, &bnd1p,
hOraErr, (text *)":id", -1, (void *)&id,
(sb4)sizeof(id), SQLT_INT, (void *)0,
(ub2 *)0, (ub2 *)0, (ub4)0, (ub4 *)0, OCI_DEFAULT);
OCIBindByName(hOraPlsqlStatement, &bnd2p,
hOraErr, (text *)":string", -1,
(void *)stringBuffer, (sb4)(sizeof(stringBuffer)),
SQLT_STR, (void *)0, (ub2 *)0, (ub2 *)0,
(ub4)0, (ub4 *)0, OCI_DEFAULT);
//вставляем данные в цикле
for (id = 1; id < 10; id++)
{
sprintf(stringBuffer, "This is the %d string", id);
status = OCIStmtExecute(hOraSvcCtx, hOraPlsqlStatement, hOraErr, (ub4)1, (ub4)0, (CONST OCISnapshot *) NULL, (OCISnapshot *)NULL, OCI_DEFAULT);
if (status != OCI_SUCCESS && status != OCI_SUCCESS_WITH_INFO)
{
checkerr(hOraErr, status);
OCIHandleFree(hOraPlsqlStatement, OCI_HTYPE_STMT);
return FALSE;
}
}
//освобождаем хендл
OCIHandleFree(hOraPlsqlStatement, OCI_HTYPE_STMT);
```
В целях увеличения быстродействия и экономии ресурсов базы в случае множественных инсертов нужно вначале подготовить выражение с заполнителями типа :id и :string, связать их с соответствующими переменными, и затем изменять значение переменных и выполнять выражение.
### Получаем данные
Код для получения данных из базы:
Получаем данные
```
char * select_statement = "select id, textfield from simple_table order by id";
sword status;
int id;
char stringBuffer[100];
OCIStmt *hOraPlsqlStatement = NULL;
OCIHandleAlloc((const void *)hOraEnv,
(void **)&hOraPlsqlStatement, OCI_HTYPE_STMT,
(size_t)0, (void **)0);
OCIStmtPrepare(hOraPlsqlStatement, hOraErr,
(const OraText *)select_statement,
(ub4)strlen(select_statement),
(ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT);
OCIDefine *OraIdDefine = NULL;
//Привязываем переменную id к первому полю в запросе
OCIDefineByPos(hOraPlsqlStatement, &OraIdDefine,
hOraErr, 1, (void *)&id, (sword)sizeof(id),
SQLT_INT, (void *)0, (ub2 *)0, (ub2 *)0,
OCI_DEFAULT);
OCIDefine *OraStringDefine = NULL;
//Привязываем stringBuffer ко второму полю в запросе
OCIDefineByPos(hOraPlsqlStatement, &OraStringDefine,
hOraErr, 2, (void *)stringBuffer,
(sword)sizeof(stringBuffer),
SQLT_STR, (void *)0, (ub2 *)0,
(ub2 *)0, OCI_DEFAULT);
//Выполняем запрос, не получая никаких данных
status = OCIStmtExecute(hOraSvcCtx, hOraPlsqlStatement, hOraErr, (ub4)0, (ub4)0, (CONST OCISnapshot *) NULL, (OCISnapshot *)NULL, OCI_DEFAULT);
if (status != OCI_SUCCESS && status != OCI_SUCCESS_WITH_INFO)
{
checkerr(hOraErr, status);
OCIHandleFree(hOraPlsqlStatement, OCI_HTYPE_STMT);
return FALSE;
}
printf("id | textfield\n");
//Получаем данные в цикле
while ((status = OCIStmtFetch2(hOraPlsqlStatement, hOraErr, 1, OCI_DEFAULT, 0, OCI_DEFAULT)) == OCI_SUCCESS || status == OCI_SUCCESS_WITH_INFO)
{
printf("%d | %s\n", id, stringBuffer);
}
OCIHandleFree(hOraPlsqlStatement, OCI_HTYPE_STMT);
```
При получении данных поступаем аналогично, привязываем переменные с запрошенными полями в селекте, выполняем выражение и затем в цикле одну за другой получаем строки
### Закрываем сессию
После нужных операции нужно закрыть сессию:
Закрываем сессию
```
OCISessionEnd(hOraSvcCtx, hOraErr, hOraSession, OCI_DEFAULT);
OCIHandleFree(hOraSession, OCI_HTYPE_SESSION);
OCIHandleFree(hOraSvcCtx, OCI_HTYPE_SVCCTX);
OCIServerDetach(hOraServer, hOraErr, (ub4)OCI_DEFAULT);
OCIHandleFree(hOraServer, OCI_HTYPE_SERVER);
```
### Закрываем окружение
После того, как взаимодействие с базой больше не нужно, закрываем окружение:
Закрываем окружение
```
OCIHandleFree(hOraErr, OCI_HTYPE_ERROR);
OCIHandleFree(hOraEnv, OCI_HTYPE_ENV);
OCITerminate(OCI_DEFAULT);
```
Итоги работы
------------
Вот ссылки на проекты на гитхабе для [Windows](https://github.com/Johnny-the-cat/simple_Oracle_client_application_win)(Visual Studio) и [Linux](https://github.com/Johnny-the-cat/simple_Oracle_client_application_lin)(NetBeans)
**О файлах в проекте**
Заголовочные файлы *oci.h, ocidem.h, ocidfn.h, ocikpr.h, oratypes.h, orl.h* взяты из каталога %ORACLE\_HOME%\OCI\include (Может, я их немного модифицировал, чтобы не было неразрешенных зависимостей, но этого я уже точно не помню)
*ocipfndfn.h* - этот файл с определениями типов указателей на функции составлен мной, тут те OCI функции, которые я использовал в своих проектах.
*OraFunction.c* - Основной файл проекта, тут определения функций для работы с БД.
*OraFunction.h* - заголовочный файл с объявлениями функции.
*ParseCmdLine.c* - функция для парсинга командной строки, для получения логина, пароля и строки подключения к базе. Параметры передаются в утилиту стандартным для Оракловых утилит форматом login/pass@dbconnect.
*main.c* - функция main.
**Что утилита делает**
Утилита подключается к базе данных, создает таблицу *simple\_table,* заполняет ее данными, получает из нее данные и удаляет таблицу.
**Как скомпилировать**
Как и было запланировано с самого начала, для компиляции утилиты не требуется никаких дополнительных файлов и библиотек. Для работы, само собой, требуется установленный Oracle Client либо Instant Oracle Cllient, главное, чтобы была доступна OCI-библиотека.
|
https://habr.com/ru/post/587492/
| null |
ru
| null |
# Текстовые игры — новый старый инструмент для автора или «Сделаем Текстовые Квесты снова Великими!»
Такими раньше была интерактивная литератураПро текстовые игры написано довольно много как на Хабре, так и на просторах интернета. Это один из самых первых жанров интерактивных развлечений с использованием ЭВМ и даже без него (просьба поделиться опытом НЕэлектронных текстовых игр в комментариях).
В данной статье я хочу мимолетом задеть вопрос истории и нынешней "полужизни" жанра текстовых игр, пофантазировать на тему будущего данного жанра, привести примеры текстовых игр, которые сейчас пользуются популярностью и подсказать об абсолютно новом переосмыслении старого инструмента для создания текстовых игр, о котором вы 99% не знаете. И все, конечно, исключительно на базе личного опыта.
Все причины в прошлом
---------------------
Лично для меня текстовые игры или интерактивная литература в первую очередь ассоциируются с компьютерной игрой Космические Рейнджеры 1 и 2 (в дальнейшем КР). Не буду рассказывать про то, что это за игра (вы и так знаете или узнаете сами). Оснавная суть в том, что в механике этой игры был встроен целый пласт так называемых "текстовых квестов", каждый из которых представлял из себя небольшой интерактивный рассказ, с уникальными игровыми механиками. В одном из них Вы могли участвовать в охоте на инопланетного зверя, в другой стать участником секретной спецоперации или даже ваша миссия могла провалиться, не успев начаться, и стать битвой за выживание, не говоря уже о легендарной "Тюрьме".
Понятное дело для молодого парня, увлекающегося белетристикой, возможность объединить прозу и игры, показалась очень воодушевляющей и уже вскоре я разбирался с функционалом редактора текстовых квестов для Космических Рейнджеров TGE (вроде как это TextGame Engine). На тот момент я думал, что это самый удобный, лучший, понятный и простой инструмент, который позволит мне реализовать любую задумку в кратчайшие сроки. Как же я был прав.
Внешний вид интерфейса AXMA Story Maker JS.
JS дает большой раздор для фантазии, но не каждому..Прошли года, идея создания текстовой игры подутихла, что бы вспыхнуть вновь с новой силой. Но обладая уже небольшим жизненным и юзерским опытом, я стал искать более современный и удобный инструмент, который позволит мне (и другим пользователям) запускать интерактивные истории не только через самих КР. И на тот момент я нашел их множество:
QSP, URQ, Instead, Twine (тогда он назывался по-другому), AXMA и т.д. Их было много, но после опыта с TGE, все они казались громоздкими, сложными в реализации творческих задумок, устаревшими. Ни один из движков не позволял мне сконцентрироваться на творчестве, но в течении следующих лет я вернусь к каждому из них вновь, узнаю о новых и все так же отложу идею создания текстовой игры на годы - до определенного момента.
Что было сейчас и будет тогда
-----------------------------
Рекламу этой игры многие видели в youtubeТекстовые игры были всегда - лично для меня. Проблема лишь в том, что текстовые игры - это либо готовый выверенный продукт по типу **"The Life and Suffering of Sir Brante"** - реклама которой долго преследовала геймеров в youtube - или **"Vampire: The Masquerade — Coteries of New York",** или - если вспоминать смежный жанр графических новелл - "**Бесконечное Лето"**.Либо же авторские поделки, основная цель которой никогда не заработок, например: **"Дядя, который работает в Нинтендо"** (победитель конкурса интерактивной литературы - КРИЛ 2018) или из зарубежных - **"Ghosts Within"**.
В первом случае, у разработчика есть и финансовые средства, и мотивация создать качественный продукт, который будет продаваться, приносить прибыль - соответственно есть и резон изучать (или нанимать людей, которые уже освоили) сложные движки, нюансы языков программирования и тратить довольно много времени на это всё.
Во втором же случае, а мы говорим о любителях (что ни в коем случае не приуменьшает их беллетристических способностей) со своей основной работой и далеко не всегда способных освоить, пусть и простые, но все же, языки скриптов для написания текстовой игры. Так вот. Во втором же случае есть только потребность в творческой реализации и сложностью таких людей легко отпугнуть.
Возвращение к новому старому
----------------------------
Как выглядит оригинальный редактор квестов TGEВозвращаясь к моему пути. Обыскав всё и вся на тему простых, но функциональных движков для текстовых игр, я неожиданно для себя вернулся снова к TGE - за эти годы он слегка прокачался, давая еще больше свободы для творчества, проблемой оказался только запуск новонаписанных игр, где-то вне самих КР. Но обладая уже небольшим, но опытом, я начал искать. Искал я долго, переодически забрасывая эту идею и возвращаясь к другим движкам и интерпритаторам, бесясь от их сложности и медлительности или отсутствия необходимого функционала.
И довольно символично, что пролистывая выдачу в поисковике на очердной свой вопрос, я наткнулся на [статью Василия Рогина](https://pikabu.ru/story/kvestyi_iz_kosmicheskikh_reyndzherov_v_brauzere_5526211). Этот человек решил вспомнить былое и подготовил удобный плеер для "расшифровки" и запуска текстовых квестов формата КР \*.qm и \*.qmm, так еще и [выложил исходники на GitHub](https://github.com/roginvs/space-rangers-quest).
Редактор всему голова
---------------------
Не так давно Василий организовал в своем плеере и возможность редактировать квесты "на лету", то есть внедрил весь функционал из TGE для создания текстовой игры в свое веб приложение и продолжает развивать его.
**Вы можете делать игры где угодно!**
Тут не будет полной документации по созданию, она распространялась вместе с редактором на форуме разработчика КР и доступна для скачивания из самого веб-плеера. Но я расскажу какие-то нюансы и свои "кейсы" в вопросах реализации задуманного.
Кстати. Не стоит забывать, что редактор может открыть любые классические квесты Космических Рейнджеров, и в них можно подсмотреть реализацию множества игровых механик.
#### Начало Вашей истории
Создание истории базируется на локациях и переходах. Локация описывает окружение или ситуацию, или и то и другое. Переходы связывают две локации в виде выбора игрока.
Предположим у нас есть лошадка. Мы вводим в первой локации эту лошадку.
> Локация 1: "Лошадка стоит и щиплет травку"
>
>
Потом мы можем добавить локацию, где лошадка идет:
> Локация 2: "Лошадка без устали идет в сторону своего пастбища"
>
>
Соответственно между тем, что она стоит и начала идти, должно что-то произойти. И для этого мы соединяем локации между собой переходом, который называем "Начать идти"
Особенность системы TGE в том, что действию мы так же можем задать какой-то отображаемый текст, который становится связующим двух локаций.
> Переход: "Начать идти" - "Лошадка встала и слегка отряхнула голову от налетевших мух. Сначала она сделала неуверенный шаг, потом второй. И вот Лошадка уже идет в сторону своего пастбища. "
>
>
После перехода, до вывода "Локации 2" игроку показывается 1 кнопка "Далее". После нажатия на неё нам и покажут новый текст самой локации.
Ну и перед завершением этого блока. Создадим еще 3 перехода. "Остановиться" - который вернет нас на 1-ю локацию. Так же создадим "Продолжить идти" - что заново вернет нас на 2-ю локацию, что тоже возможно. И "Отдыхать" - который будет показан только на первой локации и вернет нас на неё же.
#### Параметры богу параметров!
##### Движок ценен не этим. Любой вышеназванный Twine или Axma или любой другой подобный им, отлично умеет выводить текст локаций и кнопки переходов без всяких сложных скриптов. Всё меняют "Параметры", скелет системы TGE, позволяющий реализовать почти любую задумку, без сложных скриптов.
Те кто играл в квесты КР помнят, что там у персонажа игрока мог быть свой инвентарь, или статус бар, какая-либо информация, динамически изменяемая в течении квеста. Все это отображалось в специально поле справа в виде строчек с текстом или символами. Это все реализовано с помощью параметров.
Параметр это некая переменная - которая содержит в себе число (через него мы и работаем в течении игры со всеми условиями и отображениями), так же диапазон минимального и максимального значения этого числа и диапазоны со строками этого параметра. Проще на примере.
Создадим нашей лошадке шкалу "Выносливости", но выводить мы её будем не сухими числами, например от 0 до 10, а поделим на 5 диапазонов.
> 0 : "Лошадка выдохлась и не может идти"
>
> 1-3 : "Лошадка почти выдохлась"
>
> 4-6 : "Лошадка сильно устала"
>
> 7-9 : "Лошадка устала"
>
> 10 : "Лошадка бодра и полна сил"
>
>
На начало квеста мы сделаем значение 10.
#### Условия трону условий!
Теперь мы можем при переходе на "Локацию 2", отнять у лошадки 1 усталость и выводить получившуюся строку в интерфейсе игрока. При этом если усталость дойдет до нуля, то нам больше не будет отображаться переход "Продолжить идти", а точнее, мы сделаем так, что он будет отображаться, но не будет активен. TGE умеет делать и так и сяк.
Про условия стоит поговорить отдельно, но не сейчас. Скажу только, что движок понимает много математических и логических операторов, например:
```
/,div, mod,*,-,+,to,in,>=,<=, >,<,=,<>,and,or.
```
Интерфейс редактора прост и понятен даже далекому от IT человекуПри каждом переходе или посещении локации, мы можем изменять значение параметров. Условия же можно задавать только для переходов.
Локациям нельзя выставить условия посещения. Если в них ведет переход, значит все схвачено, вы либо попадете туда если соответствуете условиям перехода, либо нет.
Но есть у локаций и свои особенности - а именно варианты отображения. Официально TGE поддерживает бесконечное их количество, а неофициально - вам хватит и 5-10. Выбираются варианты отображения либо по порядку (от 1-го варианта при первом посещении, второго при втором и т.д.), либо по математической формуле которую задаем мы. При этом мы можем пользоваться значениями параметров.
И вот это дает уже бесконечный разлет фантазии. Пример:
Мы хотим, чтобы при посещении нашей локации, где лошадка идет, каждый раз в зависимости от того насколько она устала у нас менялся текст. В этот раз я использую параметр для того что бы брать его значение при вычислении - наш параметр первый - [p1] - эта переменная в формуле выдаст нам число от 1 до 10, но писать 10 описаний, как то нудно, я сделаю 3 варианта и буду использовать операции сравнения.
```
(([p1]=10)*1)+(([p1]<10 and [p1]>3)*2)+(([p1]<=3)*3)
```
И тут все получается просто - мы создаем булевую проверку возвращающую 1 (истина) или 0 (ложь) и умножаем полученное значение на порядковый номер варианта отображения локации. Очень удобно, а главное просто и быстро.
#### Вывод параметров в текст
Нужно сказать и пару слов о выводе значений параметров в текст. В любом месте мы можем вывести значение переменной или итог целой формулы заключенной в фигурные скобки. например - {[p1]+25} - выведет нам сумму значения параметра и 25.
Так же плеер поддерживает возможность вывода строковой составляющей параметра как при нынешнем значении, так и при определенном значении - для этого [p1] мы меняем на [d1] - для нынешнего значения параметра и [d1:10] - для строки при значении параметра 10.
#### Микровывод
Так это выглядит в онлайн-версии редактораЗаложенный в движок функционал позволяет реализовать почти все что угодно. Например, динамические бои с элементом случайности. Сбоку мой пример боевки по мотивам DnD собранный за примерно час. При каждом ударе делается бросок двадцатигранного "кубика" и в случае успеха, показывается один из нескольких описаний попадания (или промаха).
Все это придает игре жизни, позволяет создавать огромные сложные конструкции, которые в отличии от AXMA - не зависают при малейшей ошибке, заставляя что-то переделывать, переписывать, а одним словом - затягивать реализацию задуманного.
Квесты могут быть протяженными и разветвленнымиЯ не рассказал о многих функциях редактора (как системы создания квестов), дальше я бы хотел подробнее рассказать именно об особенностях самого плеера. Ну или точнее еще пару слов перед этим.
#### Эстетика - музыка, изображение, звуки
Движок позволяет выводить в статичном окошке справа картинку и менять ее при переходе или на заходе на локации, запускать музыку (циклично по кругу для атмосферы) которую вы загрузите и проигрывать звуки (однократно) при переходе или на локации.
Думаю, данный функционал будет расширятся. И в скором времени графические составляющие расширятся.
#### Я выложить хотел бы в интернетах...
С редактором разобрались. Теперь пару слов о публикации вашего творения. Ну тут вариантов несколько:
1. Например. Вы можете загрузить к себе весь репозиторий Василия и развернуть веб-приложение прямо на своем сервере. После чего загрузить свою игру и сопутствующие файлы (картинки, музыку) и теперь все кто зайдет к Вам на сервер, попадут в целый портал, где будут ваши текстовые игры, куда игроки смогут загружать свои квесты и т.д. *Но кстати об этом мы еще поговорим.*
2. Вы можете использовать сервер автора на <https://spacerangers.gitlab.io/>. Зарегистрироваться (доступно через GitHub и Google), а после чего создать и выложить в библиотеку квест, а дальше вы сможете его распространять без необходимости заходить на портал. Ссылка на быстрый запуск.
3. Ну и конечно Вы можете выгрузить свой квест в формате \*.qmm и загрузить в одну из игр серии Космические Рейнджеры, последняя часть которой носит подзаголовок Quest - отражая её суть.
В каждом отдельном случае есть свои нюансы, например пока нет способа загрузить картинки если Вы не разворачиваете систему на своем сервере. Но это дело житейское и думаю автор приложения в скором времени решит этот вопрос.
Мысли о том, что ждет нас в будущем
-----------------------------------
Не знаю, насколько я буду прав в своей оценке. Но глядя на современный рынок интерактивных развлечений, создается ощущение, что невозможно заинтересовать потребителя чем-то без контекста.
Творцы стараются привязаться к какой-то вселенной, тематике, сообществу. В период, когда нам не предоставляют цельный развлекательный продукт, а скорее предлагают собирать его самим из разных форматов.
Приведу пример с компьютерной игрой Dead Space - основная сюжетная линия строится внутри видеоигры, а вот сопутствующие материалы, параллельные сюжеты - внутри комиксов, рассказов и т.п. В конечном счете эти комиксы без контекста игры - наврятли смогли бы существовать.
Иной пример - скорее алегоричен - если мы возьмем за контекст город, а за продукт городскую газету, которую имеет смысл выписывать только жителям данного города. Без контекста города - некоего сообщества - газета бесмысленна и наврятли будет пользоваться популярностью. Но каждый новый житель получит необходимый контекст и будет больше заинтересован в прочтении газеты. А возможно и в написании статей для неё.
В тех же Космических Рейнджерах огромный интерес создавал контекст вселенной игры. Квесты были вписаны в него.
К чему я веду. Интерактивная Литература не как самостоятельное произведение, а как часть какой то более сложной, наративной системы. И в этом плане, веб приложение собранное Василием Рогиным - по факту кастомизируемый портал, который каждая группа/сообщество, сможет подстроить под себя, рождая тем самым метасообщество читателей и создателей текстовых игр. Вот так могут и должны переродиться жанры интерактивной литературы. Опять же все, конечно, исключительно на базе личного опыта.
Напоследок
----------
Попробуйте сами использовать [редактор](https://spacerangers.gitlab.io/) - и создать на нем что нибудь - это интереснее и проще чем кажется. [Также доступен репозиторий проекта](https://github.com/roginvs/space-rangers-quest).
|
https://habr.com/ru/post/647251/
| null |
ru
| null |
# Мои начинания в Scala или учим Scala после Java
Много слышал об этом языке, да вот руки никак не доходили.Вот начал его изучать, и решил поделится с вами.
**Scala** — мультипарадигмальный язык программирования, спроектированный кратким и типобезопасным для простого и быстрого программирования. В нем органично сочетаются возможности функционального и объектно ориентированного программирования.Подробнее читайте тут [http://ru.wikipedia.org/wiki/Scala](http://ru.wikipedia.org/wiki/Scala_(%D1%8F%D0%B7%D1%8B%D0%BA_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F))
Хочу подчеркнуть что Scala язык на виртуальной машине JAVA, что дает ему возможность использовать джава библиотеки, также есть возможность использовать эти два языка в одном проекте и еще много чего…
Scala впитала значительное число концепций и синтаксических соглашений Java и C#. Способ выражения свойств во многом заимствован из Sather. Из Smalltalk взята концепция унифицированной объектной модели.
Думаю хватит слов.Вы и сами поняли что за язык Scala.Перейдем собственно к коду.Так выглядет простейший ХелоуВорлд:
`object HelloWorld {
def main(args: Array[String])={
System.out.println("Hello World")
}
}`
Очень напоминает Java код, объясню разницу ключевое слово object изначально указывает, что это класс является сингелтоном.Очень удобно не правда ли? Объявление методов тут как в Python делается с помощью ключевого слова **def**.В скобках указаны параметры передаваемые в метод `args: Array[String]`
Объявление переменных выглядит так *имя: Тип*.В джаве метод main принимает массив строк, в Scala массивы являются коллекциями типа Array, а внутри символов [] указывается Тип хранящийся в коллекции, это как List в джаве.Scala язык не только ОО но и Функциональный, то есть функции(методы) в нем являются переменными которым можно присвоить значение, что мы и делаем **def main(args: Array[String])={**.Scala может использовать стандартную джава библиотеку классов, которую дополняет своя Scala библиотека, в примере мы используем Java класс System для вывода, как видите Scala и Джава спокойно используют друг друга.
Ссылки на язык [www.scala-lang.org](http://www.scala-lang.org/)
Не судите строго сам только изучаю этот язык.
На этом все если кому то понравилось буду писать дальше, по мере изучения языка
|
https://habr.com/ru/post/77445/
| null |
ru
| null |
# Как я организовал автоматический деплой для своих пет-проектов
Всем привет) Это мой первый пост на Хабре, и сегодня я расскажу про небольшой pet project ([git-trigger](https://github.com/tarmalonchik/git_trigger)) , который я недавно написал для сборки своих проектов на сервере. На данный момент я использую его в нескольких своих проектах для автоматической сборки и пока не было замечено никаких ошибок.
Мне нужен был какой-то легковесный софт, который мог бы мониторить состояние моего проекта на [Github](https://github.com) и при пуше в репозиторий запускать пересборку проекта. Немного поискав какое-то готовое решение, я не нашел ничего подходящего и решил написать свое.
Работает все это дело максимально просто. [git-trigger](https://github.com/tarmalonchik/git_trigger) запускает воркер, который с какой-то периодичностью пытается сделать `git pull origin branchname` и при обнаружении изменений в ветке он запускает сборку проекта через [make](https://ru.wikipedia.org/wiki/Make) команду.
Команда для запуска выглядит примерно так:
```
git_trigger tarmalonchik/project_name /root make_command branch_name
```
Для того чтобы установить этот сервис нужно использовать команду:
```
go install github.com/tarmalonchik/git_trigger@latest
```
Далее можно добавить сервис в [systemd](https://ru.wikipedia.org/wiki/Systemd), вот так примерно выглядит мой конфиг для [systemd](https://ru.wikipedia.org/wiki/Systemd):
```
[Unit]
Description=script which runs git trigger
Wants=network-online.target ssh-agent.service
After=network-online.target ssh-agent.service
[Service]
Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/usr/local/go/bin
Environment=HOME=/root
ExecStart=/root/go/bin/git_trigger tarmalonchik/project_name /root build master
[Install]
WantedBy=multi-user.target
```
Это мой первый проект, который я решил показать публике, поэтому буду рад любой конструктивной критике.
|
https://habr.com/ru/post/700440/
| null |
ru
| null |
# Как сделать бота в Telegram, который открывает дверь с электромагнитным замком, используя Go lang, Raspberry Pi и паяльник
К концу близился ~~60 августа~~ сентябрь, и я, будучи 16-летним школьником, решил сделать что-нибудь интересное и полезное своими руками. В компании, в которой я являюсь стажером, есть дверь с электромагнитным замком, которая открывается с помощью электронного брелка или же кнопки, которая находится внутри. Использовать эти брелки было неудобно, к тому же они часто терялись. И мне предложили сделать бота Telegram, который будет открывать эту дверь.
Принцип работы очень прост:
* Человек отправляет сообщение боту в Telegram
* Rasberry Pi получает новые сообщение через Telegram API
* RPi открывает входную дверь
Для начала я расположил RPi в шкафу, где находятся роутер и модем, и подключил его к интернету. Затем собрал транзисторный ключ:
* n-p-n транзистор кт315 (другого не было)
* Резистор 10КОм
* Пару проводов
Схема выглядит примерно так:
Потом надо было написать код:
**Код**
```
package main
import (
// Системные пакеты
"log"
"io/ioutil"
"path/filepath"
"strings"
"time"
// Парсер yaml файлов
"gopkg.in/yaml.v2"
// Библиетка для работы с rpi
"github.com/stianeikeland/go-rpio"
// Библитека для работы с telegram API
"github.com/Syfaro/telegram-bot-api"
)
type Config struct {
// Токен телеграм бота
Token string `yaml:"token"`
// Разрешенные айдишники чатов
AllowedChatIds []int `yaml:"allowed_chat_ids"`
// Ключевые слова для открывания двери
OpenDoorPhrases []string `yaml:"open_door_phrases"`
TurnLedOnPhrases []string `yaml:"turn_led_on_phrases"`
TurnLedOffPhrases []string `yaml:"turn_led_off_phrases"`
}
var bot *tgbotapi.BotAPI
var config *Config
var OpenDoorPhrases []string
var TurnLedOnPhrases []string
var TurnLedOffPhrases []string
var AllowedChatIds []int
var doorOpened chan *tgbotapi.Message
var ledTurnedOn chan *tgbotapi.Message
var ledTurnedOff chan *tgbotapi.Message
var doorPin = rpio.Pin(10)
var ledPin = rpio.Pin(9)
func readConfig() (*Config, error) {
var yamlFile []byte
var err error
filename, _ := filepath.Abs("./config.yml")
yamlFile, err = ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
var conf Config
if err := yaml.Unmarshal(yamlFile, &conf); err != nil {
return nil, err
}
return &conf, err
}
func main() {
var err error
// Читаем конфиг
if config, err = readConfig(); err != nil {
panic(err)
}
// Инициализируем бота
bot, err = tgbotapi.NewBotAPI(config.Token)
if err != nil {
log.Panic(err)
}
// Для работы с gpio в rpi
if err = rpio.Open(); err != nil {
log.Panic(err)
}
defer rpio.Close()
// Устанавливаем пины на output
ledPin.Output()
doorPin.Output()
// Инициализируем все остальные переменные
doorOpened = make(chan *tgbotapi.Message)
ledTurnedOn = make(chan *tgbotapi.Message)
ledTurnedOff = make(chan *tgbotapi.Message)
AllowedChatIds = config.AllowedChatIds
OpenDoorPhrases = config.OpenDoorPhrases
TurnLedOnPhrases = config.TurnLedOnPhrases
TurnLedOffPhrases = config.TurnLedOffPhrases
log.Printf("Authorized on account %s", bot.Self.UserName)
var ucfg tgbotapi.UpdateConfig = tgbotapi.NewUpdate(0)
ucfg.Timeout = 60
err = bot.UpdatesChan(ucfg)
// Слушаем события
go Listen()
ListenUpdates()
}
func OpenDoor() chan<- *tgbotapi.Message {
// Открываем дверь
go launchDoor()
return (chan<-*tgbotapi.Message)(doorOpened)
}
func TurnLedOn() chan<- *tgbotapi.Message {
// Включаем светодиод
ledPin.High()
return (chan<-*tgbotapi.Message)(ledTurnedOn)
}
func TurnLedOff() chan<- *tgbotapi.Message {
// Выключаем светодиод
ledPin.Low()
return (chan<-*tgbotapi.Message)(ledTurnedOff)
}
// Открывание двери
func launchDoor() {
log.Println("door is beeing opened")
doorPin.High()
ledPin.High()
time.Sleep(100*time.Millisecond)
doorPin.Low()
ledPin.Low()
}
// Проверяет, является ли указанное сообщение ключевым
func tryToDo(text string, phrases []string) bool {
for i:=0; i
```
Что касается config.yml; Это просто конфиг:
```
token:
allowed\_chat\_ids:
-
-
open\_door\_phrases:
- open
- open the door
- open door
- door open
- дверь откройся
- открыть дверь
- открыть
- открыть
- откройся
- открой
- сим-сим, откройся
- abrete sesamo
- -o
- o
- отк
- /open
turn\_led\_on\_phrases:
- led on
- test on
turn\_led\_off\_phrases:
- led off
- test off
```
Оставалось только загрузить скомпилированный файл на RPi и подключить все провода.
*Так выглядит готовый вариант устройства*
*Кнопка, к которой я подключил систему управления*
*Сам замок*
|
https://habr.com/ru/post/366735/
| null |
ru
| null |
# KeybJr – универсальное подключение клавиатуры к PCjr
[](https://habr.com/ru/company/ruvds/blog/663346/)
В качестве продолжения своей [предыдущей статьи об IBM PC и его особенностях](https://habr.com/ru/company/ruvds/blog/663600/) я решил реализовать KeybJr – небольшой открытый проект, позволяющий подключать к PCjr клавиатуру через проводное соединение или ИК-порт. Натолкнуло меня на это отсутствие в системе возможности для подключения нормальной клавиатуры за исключением редких и дорогостоящих сторонних решений.
А ведь Junior, в наши дни ставший уже чисто гиковским устройством, представляет собой не более чем раритетное украшение, который не будет работать без родной клавиатуры. Будь то оригинальная чиклетная «Freeboard» или ее последующая разновидность с более традиционной раскладкой, оба варианта оставляют желать лучшего, когда дело доходит до хлипкой работы их скрипучих резиновых колпачков. И если вы даже отыщете такую, но горестно обнаружите в ней потекшие батареи, то почему бы не подключить к PCjr клавиатуру Model M?
Подключение XT/AT-клавиатуры со 101 клавишей через ИК-интерфейс в режиме эмуляции XT:
В текущей ревизии KeybJr позволяет подключать XT, AT, PS/2 или старые USB-клавиатуры. Нажатия клавиш обрабатываются согласно ожиданиям PCjr, после чего передаются ему как через ИК-интерфейс, так и по проводному соединению. Подключается клавиатура через гнездо “K” сзади, что избавляет от необходимости ее нахождения в радиусе видимости ИК-приемника.
Тем не менее посредством ИК-интерфейса KeybJr может соединить подходящую клавиатуру с PCjr, у которого контакты гнезда повреждены – то есть, когда оригинальные и дорогие клавиатурные адаптеры не работают. Причем олдскульные пользователи могут помнить, насколько легко контактные штыри Junior сгибались и отламывались.
Чтобы вписать проект KeybJr в одни выходные, я выбрал популярную и недорогую платформу – Arduino Uno и ее клона на базе ATmega328P.
*Внутренне это Arduino, но она не требует оригинальной платы и отлично функционирует в виде простой «dead-bug» схемы*
Сам проект можно скачать в виде [исходного кода](https://github.com/climatex/KeybJr), совместимого с Arduino IDE, либо как [двоичный файл](http://boginjr.com/apps/keybjr/KeybJr.zip), содержащий необходимый загрузчик, код и настройки битов блокировки, который затем можно записать через специальный программатор или ICSP-разъем ATmega328P. Структурно исходный код довольно понятен. В зависимости от используемого протокола вызывается либо простой обработчик прерываний для XT-клавиатуры, либо форк библиотеки `PS2KeyAdvanced` для AT. PS/2 или USB-клавиатуры (в сочетании с адаптером).
После этого клавиатура начинает опрашиваться, и программа выполняет необходимый перевод скан-кода, согласно техническому руководству PCjr. Далее код стробирует ИК-светодиоды и при необходимости отправляет данные по кабелю. Затем весь цикл повторяется.
Тем не менее, поскольку при передаче в коде используется прямой доступ к портам AVR с целью реализации ускоренной техники *bit-banging* вместо ардуиновской `digitalWrite()` (клавиатура во время передачи блокируется, а значит работать должна максимально быстро), то любые отклонения цепи для портов ввода-вывода, использованные в схеме, должны быть адресованы в коде заранее.
*Эта схема представляет собой просто голый ATmega328p с внешним тактовым генератором 16МГц. Ее можно запитать напрямую от PCjr, через USB-порт, стабилизатор 5В и т.д.*
Имейте ввиду, что некоторые очень редкие и старые XT-клавиатуры, например первые ревизии IBM Model F (использовалась в 5150 или XT), после подачи питания могут потребовать «аппаратного сброса» через линию контакта DIN №3 (`/RESET`). В схеме это не отражено, но если такое случится – подключите эту линию к PD7 на ATmega (контакт 13 на DIP), и KeybJR при включении/перезагрузке микроконтроллера сделает все остальное.
Если же вы используете AT, PS/2 или старую USB-клавиатуру через адаптер, то Keybjr задействует библиотеку *PS2KeyAdvanced*, которая поддерживает внешний код. Протокол PS/2 по умолчанию двунаправленный, однако, ради простоты и удобства я управляю клавиатурой в синхронном режиме. Это значит, что во время передачи сигнала на Junior прерывания клавиатуры и сигнал `clock` блокируются во избежании проблем с таймингом.
После этого обработанное нажатие клавиши стирается из внутреннего буфера клавиатуры, и цикл повторяется. А сигнал нажатой клавиши, полученный с клавиатуры PS/2, через таблицу перевода преобразуется в XT-совместимый скан-код. Все дело в том, что PCjr ожидает скан-код XT, пусть даже передаваемый в виде иного сигнала или в отличающемся для некоторых нажатий клавиш формате.
*Прототипирование на плате Arduino*
Техническое руководство неплохо описывает, в какой форме PCjr ожидает ввод с клавиатуры. Принцип передачи через ИК-приемник и проводное соединение почти одинаков и предполагает лишь пару отличий. Каждый бит данных кодируется в двухфазном импульсе длиной 440 миллисекунд. Логическая `1` устанавливается в первой половине (220мс) импульса и сбрасывается во второй. Логический `0` ожидает 220мс, устанавливается на последующие 220мс и после этого сбрасывается.
При передаче данных по кабелю вход инвертируется, то есть 5 вольт представляют логический `0`. В случае же ИК-передачи двухфазная продолжительность остается такой же, то есть 220 + 220мс. Но при этом вместо установки цифрового выхода на всю продолжительность полуфазы ИК-приемник для каждой установки ожидает стробирования квадратной волной на частоте 40КГц с коэффициентом заполнения 50% в течение 62.5мс, после чего полуфазу завершает простой продолжительностью 157.5мс.
*Инфракрасное стробирование в течение 62.5мс, происходящее во время передачи каждого бита данных*
При использовании этого протокола передачи сигнала отправка одного нажатия или отпускания клавиши (каждое из которых представлено один байтом скан-кода) на PCjr включает один стартовый бит, 8 бит данных скан-кода, где первым идет младший байт, бит четности и одиннадцать пустых стоп-бит. Их задача просто дать NMI время на обработку всего этого в обработчике прерываний (INT 48).
Каждое валидное нажатие клавиши – это байт значения в диапазоне от 1 до `0x3A`, плюс `0x54` обозначает клавишу *Fn*, а `0x55` фантомную клавишу, то есть команду для PCjr отбросить содержимое буфера. То же касается и отпускания клавиш, о котором сигнализирует *break code*, только для них устанавливается старший бит – то есть *ИЛИ* с `0x80`.
После этого скан-коды XT нельзя непосредственно отправить PCjr без дополнительной подготовки, поскольку тогда правильно будет обработана только буквенно-цифровая часть. Дело в том, что в PCjr для обработки нажатий функциональных клавиш, навигационных, *Pause/Break*, *Printscreen* и так далее используется клавиша *Fn*. Даже конкретные скан-коды, согласующиеся между XT и AT, необходимо передавать на Junior нестандартным способом. Речь идет, к примеру, об обратном слэше (*Alt*+прямой слэш), тильде (*Alt*+правая скобка), точке (*Shift*+*Delete*) и так далее.
*Вместо использования ИК-порта плата подключена к гнезду “K”*
Естественно, есть здесь и несколько подвохов, почти все из которых связаны с односторонним характером связи между PCjr и клавиатурой. Сюда относится KeybJr и любой другой аналог, подключенный хоть через ИК-порт, хоть проводом.
Основная проблема в том, что ввиду своего дизайна PCjr в случае занятости системы даже при подключении оригинальной клавиатуры будет терять сигналы нажатых клавиш, например во время обращения к диску или последовательному интерфейсу. В связи с этим KeybJr пытается конвертировать для PCjr все возможные нажатия, так что, естественно, не стоит ожидать, что будут работать клавиши *SysRq*, *Windows*, контекстного меню, веб или мультимедиа. По дизайну правые и левые Control/Alt не различаются, а *F11* и *F12* вообще не будут регистрироваться.
При перезагрузке системы обратной связи на клавиатуру не поступает, и она об этом событии не узнаёт. Поэтому, если вы используете не XT-клавиатуру, то состояния *CapsLock* и *ScrollLock* (светодиоды) при перезагрузке системы (а также при отключении, если вы запитываете KeybJr от внешнего источника питания, а не от PCjr) рассинхронизируются.
В качестве примера еще добавлю, если вы включите *Caps Lock* или *Scroll Lock* и перезагрузите или отключите питание KeybJr, не отключая PCjr, то светодиоды погаснут, но система будет работать так, будто они активны. Здесь есть одно исключение: состояние *NumLock* будет сохранено. Дело в том, что эту клавишу KeybJr обрабатывает внутренне, а не передает в виде кода системе. Почему я так сделал? Все просто, потому что PCjr клавишу *NumLock* не поддерживает.
Также перед подачей питания на микросхему убедитесь в надежном подключении клавиатуры. KeybJr не поддерживает подключение нагорячую, и соответствующий протокол AT/XT должен выбираться до подачи питания (для этого пин PD4 остается висеть в воздухе либо замыкается на GND с помощью перемычки и т.п.) или, хотя бы, после сброса микроконтроллера кнопкой.
Схему я успешно протестировал на старой USB-клавиатуре Microsoft, а именно Chicony PS/2, LogoStar (Copam) K-450 с переключением XT/AT, а также на оригинальной XT-клавиатуре IBM Model F. Если у вас вдруг возникнут сложности при использовании KeybJr с USB-клавиатурой, то попробуйте взять более старую, которая с большей вероятностью будет поддерживать протокол PS/2. Проверить это можно с помощью переходника USB-PS/2 на компьютере, оснащенным портом PS/2.
На этом, дорогие друзья, все!
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=keybjr_%E2%80%93_universalnoe_podklyuchenie_klaviatury_k_pcjr)
|
https://habr.com/ru/post/663346/
| null |
ru
| null |
# Автодокументирование Perfect сервера
[В прошлый раз](https://habrahabr.ru/post/283260/) мы говорили, что **Perfect** не имеет автодокументирование реализуемого API из коробки. Возможно, что в следующей реализации разработчики пофиксят это досадное упущение. Но ничего не мешает нам позаботится об этом самостоятельно. Благо, необходимо добавить совсем не много кода.
У нас уже есть некоторая заглушка, которая позволяет посмотреть команды поддерживаемые сервером. Попробуем расширить возможности этого подхода.
**Шаг 1**: Запускаем ранее созданный Perfect сервер и вводим команду /cars чтоб получить JSON. Этот JSON копируем в [jsonschema.net/#](http://jsonschema.net/#/) и формируем из него схему, которую добавляем как файл cars.json к проекту. Не забываем зайти в XCode -> Project -> Build phase и добавить созданный файл в список «Copy Files» так же, как мы делали это с index.html
**cars.json**
```
`{
"$schema": "http://json-schema.org/draft-04/schema#",
"type": "object",
"properties": {
"address": {
"type": "object",
"properties": {
"streetAddress": {
"type": "string"
},
"city": {
"type": "string"
}
},
"required": [
"streetAddress",
"city"
]
},
"phoneNumber": {
"type": "array",
"items": {
"type": "object",
"properties": {
"location": {
"type": "string"
},
"code": {
"type": "integer"
}
},
"required": [
"location",
"code"
]
}
}
},
"required": [
"address",
"phoneNumber"
]
}`
```
Большой необходимости в этом нет, но, всегда лучше дать возможность получить схему JSON ответа. Разработчики клиентских приложений будут Вам благодарны.
**Шаг 2**: Добавляем интерфейс IRestHelp
**IRestHelp.swift**
```
`import Foundation
protocol IRestHelp
{
var details:String {get}
var params :String {get}
var schema :String {get}
}`
```
**Шаг 3**: Добавляем класс RestApi
**RestApi.swift**
```
`import PerfectLib
class RestApi
{
var prefix:String?
var commands:[String]? = nil
var handler:RequestHandler?
init(prefix:String?=nil, commands:[String]? = nil, handler:RequestHandler?=nil)
{
self.prefix = prefix
self.commands = commands
self.handler = handler
}
}`
```
Для чего он нужен — станет понятно дальше.
**Шаг 4**: Добавляем класс RestApiReg
**RestApiReg.swift**
```
`import Foundation
import PerfectLib
class RestApiReg
{
typealias APIList = [RestApi]
// MARK: - Public Properties
private var commandList = APIList()
// MARK: - Private Properties
private var globalRegistered = false
// MARK: - Singletone Implementation
private init() {
}
private class var sharedInstance: RestApiReg
{
struct Static {
static var instance: RestApiReg?
static var token: dispatch_once_t = 0
}
dispatch_once(&Static.token) {
Static.instance = RestApiReg()
}
return Static.instance!
}
// MARK: - Methods of class
class func registration(list:APIList)
{
self.sharedInstance.commandList = list
self.sharedInstance.linkAll()
}
class func add(command:RestApi)
{
self.sharedInstance.commandList += [command]
self.sharedInstance.add(command)
}
class var list: APIList {
return self.sharedInstance.commandList
}
// MARK: - Private methods
private func linkAll()
{
Routing.Handler.registerGlobally()
self.globalRegistered = true
for api in self.commandList {
self.add(api)
}
}
private func add(api:RestApi)
{
if !self.globalRegistered {
Routing.Handler.registerGlobally()
}
if let handler = api.handler
{
let prefix = api.prefix == nil ? "*" : api.prefix!
if let commands = api.commands {
Routing.Routes[prefix, commands] = { (_:WebResponse) in handler }
} else {
Routing.Routes[prefix] = { (_:WebResponse) in handler }
}
}
}
}`
```
Мне не удалось придумать более удачного названия для этого класса. Класс опосредует регистрацию новых API сервера.
**Шаг 5**: Заменяем класс HelpHandler следующим кодом:
**HelpHandler.swift**
```
`import Foundation
import PerfectLib
class HelpHandler:RequestHandler, IRestHelp
{
var details = "Show server comands list"
var params = ""
var schema = ""
func handleRequest(request: WebRequest, response: WebResponse)
{
let list = self.createList()
let html = ContentPage(title:"HELP", body:list).page(request.documentRoot)
response.appendBodyString("\(html)")
response.requestCompletedCallback()
}
private func createList() -> String
{
let list = RestApiReg.list
var code = ""
let allPrefixes = list.map { (api) -> String in
api.prefix != nil ? api.prefix! : "/*"
}
let groups = Set(allPrefixes).sort()
for group in groups
{
let commandsApi = self.commandsByGroup(group, list:list)
code += self.titleOfGroup(group)
code += self.tableWithCommnads(commandsApi)
}
return code
}
private func commandsByGroup(group:String, list:RestApiReg.APIList) -> [String:RestApi]
{
var dict = [String:RestApi]()
let commandsOfGroup = list.filter({ (api) -> Bool in
api.prefix == group
})
for api in commandsOfGroup {
if let commands = api.commands {
for cmd in commands {
dict[cmd] = api
}
} else {
dict[""] = api
}
}
return dict
}
private func titleOfGroup(group:String) -> String {
return "
**\(group):**
"
}
private func tableWithCommnads(commands:[String:RestApi]) -> String {
let sortedList = commands.keys.sort()
var table = ""
table += "
"
for name in sortedList
{
let cmd = commands[name]!
table += "|"
table += " [\(name)](\"\(name)\") |"
if let help = cmd.handler as? IRestHelp
{
table += " \(help.details) |"
table += " \(help.params) |"
table += help.schema.characters.count > 0 ? " [/\(help.schema)](\"\(help.schema)\") |" : " |"
} else
{
table += " |"
table += " |"
table += " |"
}
table += "
"
}
table += "
"
return table
}
}`
```
**Шаг 6**: Добавляем реализацию протокола IRestHelp в обработчик каждой команды, которая должна иметь автодокументирование. Этот шаг не обязательный. Те команды которые не будут поддерживать протокол будут иметь пустые значения в соотвествующих полях. К примеру, обработчик команды /list (класс CarsJson) выглядит у меня следующим образом:
**CarsJson.swift**
```
`import Foundation
import PerfectLib
class CarsJson:RequestHandler, IRestHelp
{
var details = "Show complexly JSON object"
var params = "{}"
var schema = "cars.json"
func handleRequest(request: WebRequest, response: WebResponse)
{
let car1:[JSONKey: AnyObject] = ["Wheel":4, "Color":"Black"]
let car2:[JSONKey: AnyObject] = ["Wheel":3, "Color":["mixColor":0xf2f2f2]]
let cars = [car1, car2]
let restResponse = RESTResponse(data:cars)
response.appendBodyBytes(restResponse.array)
response.requestCompletedCallback()
}
}`
```
**Шаг 7**: Заменяем метод PerfectServerModuleInit() новым кодом:
**PerfectServerModuleInit()**
```
`public func PerfectServerModuleInit()
{
RestApiReg.add(RestApi(handler: StaticFileHandler()))
RestApiReg.add(RestApi(prefix: "GET", commands: ["/dynamic"], handler: StaticPageHandler(staticPage: "index.mustache")))
RestApiReg.add(RestApi(prefix: "GET", commands: ["/index", "/list"], handler: StaticPageHandler(staticPage: "index.html")))
RestApiReg.add(RestApi(prefix: "GET", commands: ["/hello"], handler: HelloHandler()))
RestApiReg.add(RestApi(prefix: "GET", commands: ["/help"], handler: HelpHandler()))
RestApiReg.add(RestApi(prefix: "GET", commands: ["/cars", "/car"], handler: CarsJson()))
RestApiReg.add(RestApi(prefix: "POST", commands: ["/list"], handler: CarsJson()))
}`
```
**Запускаем!**
Первоначальная страница осталась прежней.
Пробуем ввести /help в командной строке браузера:
Мы видим, что все команды выстроились в виде таблицы в алфавитном порядке и обзавелись гиперссылками. После входа на страницу помощи, уже нет необходимости вводить каждую из команд в командную строку браузера для ее выполнения. А в крайней правой колонке имеется ссылка на схему, для выполнения валидации этой команды.
В дальнейшем, мы сами можем использовать схему валидации для проверки правильности создаваемого нами ответа, до того, как он уйдет клиентскому приложению. И клиентское приложение, потенциально, может загружать схемы валидации прямо с сервера. C валидацией, таким образом, получается двойной профит.
Таблица, конечно, корявая. Использование CSS может существенно улучшить её эстетический вид. Но для работы, как правило, этого достаточно.
*Первоначально было желание отобразить по запросу /help XML файл со схемой, которая выстроила бы данные в виде аналогичной таблицы. Однако, улучшать внешний вид HTML куда более увлекательное занятие, чем развлекаться с всевозможными отображениями XML.*
**P.S.** Как стало известно, разработчики Perfect во всю трудятся направлении избавления от тяжелого наследия NextStep (Objective-С) с тем, чтоб дать возможность запускать сервер на \* nix системе, и поэтому, некоторые привычные способы работы в пространстве имен NS сейчас считаются не кошерными.
|
https://habr.com/ru/post/283432/
| null |
ru
| null |
# Debouncing с помощью React Hooks: хук для функций
Здравствуйте! Меня зовут Игорь, я главный инженер по разработке в команде SmartData. Занимаюсь fullstack-разработкой внутренней аналитической BI-системы. В нашей компании React принят в качестве основного стандарта для построения пользовательских интерфейсов. Как и большая часть сообщества React, мы активно используем хуки в нашей повседневной работе.
Постоянное обучение — неотъемлемая часть работы любого хорошего разработчика. Поэтому сегодня мне хотелось бы внести свой скромный вклад в этот процесс и представить небольшое руководство для тех, кто начинает активно изучать React и работу с хуками. И попутно дать вам небольшой и полезный инструмент для работы с новым стандартом React.
В переводе статьи [Debouncing с помощью React Hooks](https://habr.com/ru/post/492248/) мы узнали, как можно без сторонних библиотек, используя только возможности React, создать хук в несколько строк кода для работы с отложенными изменениями значений переменных. Теперь я предлагаю рассмотреть еще один полезный хук, который поможет нам отложить вызов функции. Если функция будет вызываться много раз подряд, то фактический вызов произойдет только по прошествии установленного нами интервала задержки. То есть, только для последнего вызова из серии. Решение также очень компактное и легко реализуемое в React. Если вам стало интересно, прошу под кат.
Для опытных пользователей React сразу привожу код хука под спойлером. Можете просто ознакомиться и забрать для использования. Для тех, кто не так хорошо знаком с React и хуками, я подготовил подробный разбор на примере использования этого хука.
**Тут можно найти хук...**
```
import { useRef, useEffect } from "react";
export default function useDebouncedFunction(func, delay, cleanUp = false) {
const timeoutRef = useRef();
function clearTimer() {
if (timeoutRef.current) {
clearTimeout(timeoutRef.current);
timeoutRef.current = undefined;
}
}
useEffect(() => (cleanUp ? clearTimer : undefined), [cleanUp]);
return (...args) => {
clearTimer();
timeoutRef.current = setTimeout(() => func(...args), delay);
};
}
```
Итак, давайте рассмотрим какой-то реальный пример, когда нам будет удобно использовать отложенный вызов функции при её многократном вызове. Допустим, у нас есть ползунок диапазона температуры. Для наглядности и простоты прибегнем к помощи библиотеки компонентов Material-UI.
```
import React from "react";
import { makeStyles, Typography, Slider } from "@material-ui/core";
import useDebouncedFunction from "./useDebouncedFunction";
import apiRequest from "./apiRequest";
const useStyles = makeStyles({
root: {
width: 300
}
});
function valuetext(value) {
return `${value}°C`;
}
export default function RangeSlider() {
const classes = useStyles();
const [value, setValue] = React.useState([20, 37]);
const handleChange = (event, newValue) => {
setValue(newValue);
};
return (
Temperature range
);
}
```
А теперь давайте представим, что нам нужно как-то обрабатывать изменившиеся значения диапазона температуры сразу после того, как пользователь прекратит двигать ползунок. Что именно мы будем делать со значением, в этом примере не так важно. Возможно, мы захотим дополнительно сохранять значение где-то еще после обработки через функцию процессинга, или просто логгировать. В целом, ограничимся абстрактной реализацией этой функции, которая просто сообщит нам актуальное значение через `console.log()`:
```
export default function valueLogging(value) {
console.log(`Request processed. Value: ${value}`);
}
```
Теперь добавим в `handleChange()` вызов нашей функции `valueLogging()` и посмотрим, что из этого получится:
```
const handleChange = (event, newValue) => {
setValue(newValue);
valueLogging(newValue);
};
```
Хммм… это явно не то, чего мы хотим. Функция `valueLogging()` вызывается при каждом изменении значения ползунков. Это слишком часто. А нам нужно только последнее актуальное значение сразу после окончания взаимодействия пользователя с ползунком. Как мы можем поступить?
**Вариант 1.** *Использовать хук `useDebounce` и следить за изменением переменной `value` в теле компонента через хук.*
Для этого у нас будет возвращаемое хуком `useDebounce` значение `debouncedValue`, которое будет меняться только по прошествии установленного нами интервала с момента прекращения взаимодействия пользователя с ползунком. И уже с помощью хука `useEffect` мы вызывали бы `valueLogging()`. Получилось бы что-то вроде этого:
```
export default function RangeSlider() {
const classes = useStyles();
const [value, setValue] = React.useState([20, 37]);
const [changedByUser, setChangedByUser] = React.useState(false);
const debouncedValue = useDebounce(value, 300);
useEffect(() => {
if (changedByUser) {
valueLogging(debouncedValue);
}
}, [debouncedValue]);
const handleChange = (event, newValue) => {
setValue(newValue);
if (!changedByUser) {
setChangedByUser(true);
}
};
return (
Temperature range
);
}
```
Кажется, получилось несколько многословно и не очень красиво, не правда ли? Кроме того, придётся добавлять дополнительную проверку в `useEffect`, чтобы убедиться, что `valueLogging()` не вызовется при задании значения по умолчанию. Нас интересуют только изменения, сделанные пользователем. Без этой проверки, когда `useEffect` отработает при монтировании компонента, будет лишний вызов `valueLogging()`. К тому же, мы обманываем React и не добавляем в зависимости `useEffect` переменную `changedByUser`. Если вы используете линтер, он обязательно отругает вас за это.
Какой еще у нас есть вариант?
**Вариант 2.** *Отложить вызов `valueLogging()` прямо внутри `handleChange()`.*
Давайте пофантазируем, как бы это могло выглядеть в готовом варианте:
```
export default function RangeSlider() {
const classes = useStyles();
const [value, setValue] = React.useState([20, 37]);
const debouncedValueLogging = useDebouncedFunction(valueLogging, 300);
const handleChange = (event, newValue) => {
setValue(newValue);
debouncedValueLogging(newValue);
};
return (
Temperature range
);
}
```
Нам нужно создать хук `useDebouncedFunction`, который примет в качестве аргументов нашу функцию и задержку её фактического вызова.
Попробуем сделать это средствами самого React:
```
import { useRef } from "react";
export default function useDebouncedFunction(func, delay) {
const ref = useRef(null);
return (...args) => {
clearTimeout(ref.current);
ref.current = setTimeout(() => func(...args), delay);
};
}
```
Это всё, что нам нужно. Давайте подробнее разберемся, что же здесь происходит. Во-первых, мы используем хук `useRef` ([`документация по useRef`](https://ru.reactjs.org/docs/hooks-reference.html#useref)). В двух словах: хук возвращает нам своеобразный контейнер, ссылка на который остается постоянной между циклами перерисовки компонентов React. И в этот контейнер мы можем положить что-то, к чему хотели бы иметь стабильный доступ на протяжении всего цикла жизни компонента. Это значение мы можем найти или перезаписать в свойстве `current` возвращаемого контейнера.
> Многие, начиная пользоваться `useRef`, полагают, что он предназначен только для работы со ссылками на DOM-элементы. На самом деле, возможности этого хука намного шире. Он может хранить для нас любые объекты.
Далее мы декорируем передаваемую функцию с помощью `setTimeout()` с заданной нами задержкой. `timeoutId`, возвращаемый функцией `setTimeout()`, мы аккуратно кладем в наш контейнер `ref.current`. И всё это сверху оборачиваем в еще одну функцию, которую и вернет наш хук `useDebouncedFunction`. Каждый новый вызов этой функции сначала возьмет из контейнера `timeoutId` и вызовет с ним `clearTimeout()`. Таким образом, мы отменяем предыдущий вызов переданной в хук функции и заменяем его новым. В итоге, фактический вызов функции `valueLogging()` произойдет только через 300 мс после окончания последнего взаимодействия с ползунком. Всё довольно просто и прозрачно.
**Но, подождите... зачем нам вообще useRef? К чему все эти сложности?**
Мы же можем просто объявить `let timeoutId;` и использовать замыкание:
```
export default function useDebouncedFunction(func, delay) {
let timeoutId;
return (...args) => {
clearTimeout(timeoutId);
timeoutId = setTimeout(() => func(...args), delay);
};
}
```
Ответ кроется в самом React. При каждом новом цикле рендера React пересоздает все функции в теле компонента. Если вы попробуете применить последний пример, то он будет работать так же, как и самый первый пример:
Это происходит из-за того, что каждый раз мы будем получать новую функцию `debouncedValueLogging()` с новой переменной `timeoutId`. И никакого знания о ее содержании из предыдущего рендера мы не получим.
Давайте посмотрим, как это работает:
Эврика! Код стал проще и кода стало меньше. Как раз то, что нам нужно.
Уже в таком варианте хук можно использовать для функций, которые на зависят от состояния монтирования компонента. Этот вариант вам вполне подходит, если вы хотите куда-то логгировать факт взаимодействия пользователя с ползунком. Нам хотелось бы логгировать это событие при каждом его возникновении. Но что если в наш хук передать функцию, которая зависит от того, монтирован компонент или нет?
Представим себе ситуацию, что наш компонент слайдера может быть размонтирован при достижении какого-то условия. И проверим, как себя поведет отложенная функция, которая будет зависеть от этого состояния.
Расширим пример и внесем следующие дополнения.
Во-первых, наш компонент будет через пропсы принимать функцию, которая передаст значение `value` родительскому компоненту. А родительский компонент, в свою очередь, размонтирует наш компонент `RangeSlider` при выставлении на слайде максимальной температуры.
```
import React, { useState } from "react";
import { ThemeProvider, createMuiTheme, Typography } from "@material-ui/core";
import RangeSlider from "./RangeSlider";
const theme = createMuiTheme({});
export default function App() {
const [sliderShown, setSliderShown] = useState(true);
// размонтируем компонент при выставлении максимальной температуры
function handleValueChange(value) {
if (value[1] === 100) {
setSliderShown(false);
}
}
return (
{sliderShown ? (
) : (
Too hot!
)}
);
}
```
Во-вторых, в компонент `RangeSlider` мы добавим функцию, которая будет эмулировать проверку значения и возвращать ответ, который скажет нам о том, находится ли выставленное значение в допустимом диапазоне или в критическом. Представим, что допустимый диапазон может меняться в зависимости от каких-то дополнительных условий, о которых знает эта функция, и что нам нужно проверять только те значения, которые окончательно выставил пользователь. А в качестве результата мы будем менять цвет с зеленого на красный и обратно.
```
import React from "react";
import { makeStyles, Typography, Slider } from "@material-ui/core";
import useDebouncedFunction from "./useDebouncedFunction";
import valueLogging from "./valueLogging";
import checkIfOptimal from "./checkIfOptimal";
const useStyles = makeStyles({
root: {
width: 300
}
});
function valuetext(value) {
return `${value}°C`;
}
export default function RangeSlider(props) {
const classes = useStyles();
const [value, setValue] = React.useState([20, 37]);
const [isOptimal, setIsOptimal] = React.useState(true);
// Отложенное логирование
const debouncedValueLogging = useDebouncedFunction(
newValue => valueLogging(newValue),
300
);
// Отложенная проверка значения
const debouncedValueCheck = useDebouncedFunction(
newValue => checkIfOptimal(newValue, setIsOptimal),
300
);
const handleChange = async (event, newValue) => {
setValue(newValue);
debouncedValueLogging(newValue);
debouncedValueCheck(newValue);
if (props.onValueChange) {
props.onValueChange(newValue);
}
};
return (
Temperature range
);
}
```
В-третьих, добавим простую реализацию функции `checkIfOptimal()`:
```
// Эмулируем проверку значения
export default function checkIfOptimal(newValue, setIsOptimal) {
return setIsOptimal(10 < newValue[0] && newValue[1] < 80);
}
```
Посмотрим, как это будет работать:
Отлично, теперь давайте выставим значение температуры на максимум и проверим, как себя поведет наша отложенная функция `checkIfOptimal()`.
Как видите, React выбрасывает следующее предупреждение:
> Warning: Can't perform a React state update on an unmounted component. This is a no-op, but it indicates a memory leak in your application. To fix, cancel all subscriptions and asynchronous tasks in a useEffect cleanup function.
>
> in RangeSlider (at App.js:20)
Почему это происходит? Наша отложенная функция принимает в качестве второго аргумента коллбэк, который установит результат проверки `true/false` во внутреннем состоянии компонента. Для этого мы передаем туда функцию `setIsOptimal()`. В нашем примере это событие произойдет не ранее, чем через 300 мс. К этому моменту наш компонент уже размонтирован и никакого состояния у него уже нет. Об этом и предупреждает нас React. Это чревато утечками памяти. Как мы можем исправить ситуацию?
Модифицируем наш хук `useDebouncedFunction`: добавим в него флаг `cleanUp`. Если он будет выставлен в `true`, то мы будем подчищать последний выставленный таймер при размонтировании компонента.
```
import { useRef, useEffect } from "react";
export default function useDebouncedFunction(func, delay, cleanUp = false) {
const timeoutRef = useRef();
// Очистка таймера
function clearTimer() {
if (timeoutRef.current) {
clearTimeout(timeoutRef.current);
timeoutRef.current = undefined;
}
}
// Очищаем таймер при анмаунте компонента, если cleanUp выставлен в true
// и тем самым отменяем последний запланированный вызов
useEffect(() => (cleanUp ? clearTimer : undefined), [cleanUp]);
return (...args) => {
clearTimer();
timeoutRef.current = setTimeout(() => func(...args), delay);
};
}
```
> Хук `useEffect` в момент размонтирования компонента вызывает функцию, которую мы возвращаем из тела этого хука. В нашем случае будет вызвана `clearTimer()` и последний запланированный отложенный вызов будет отменен.
Передадим новый флаг в вызов нашего хука.
```
// Отложенная проверка значения
const debouncedValueCheck = useDebouncedFunction(
newValue => checkIfOptimal(newValue, setIsOptimal),
300,
true
);
```
Проверим результат.
Всё работает, как мы и хотели. Факт взаимодействия пользователя с ползунком успешно логгирован, а изменение внутреннего состояния компонента отменено после его размонтирования.
*О чём ещё стоит помнить?*
Если мы внимательно присмотримся к нашему примеру, то увидим один очень важный нюанс. `checkIfOptimal()` — синхронная функция, которая будет выполнена целиком сразу после срабатывания таймера. Если `checkIfOptimal()` будет вести себя асинхронно, допустим, обращаться на сервер и ждать от него ответа, то снова может возникнуть ситуация с изменением состояния размонтированного компонента.
Как это может произойти? Если таймер хука `useDebouncedFunction` уже запустил выполнение отложенной функции, которая затем уснула в ожидании ответа сервера, то при получении ответа может случится так, что наш компонент окажется уже размонтирован.
Как за этим следить и чем еще могут быть чреваты такие отложенные асинхронные вызовы, мы поговорим уже в следующий раз.
На этом всё. Надеюсь, этот хук будет полезен в ваших проектах.
Для тех, кто хочет поиграть с примером в живую, я подготовил маленький интерактив на codesandbox. Можете поэкспериментировать:
[useDebouncedFunction на codesandbox](https://codesandbox.io/s/hungry-hamilton-hvc93?file=/src/RangeSlider.js)
|
https://habr.com/ru/post/510616/
| null |
ru
| null |
# Алгоритм извлечения информации в ABBYY Compreno. Часть 2
И снова здравствуйте!
Надеюсь, вас заинтересовал [наш вчерашний пост](http://habrahabr.ru/company/abbyy/blog/269191/) про систему извлечения информации [ABBYY Compreno](http://www.abbyy.ru/infoextractor/compreno/?utm_source=habrahabr.ru&utm_medium=article&utm_term=compreno&utm_content=post&utm_campaign=habr), в котором мы рассказали про архитектуру системы, семантико-синтаксический парсер и его роль и, самое главное, про информационные объекты.
Теперь настало время поговорить о самом интересном – как устроен сам движок извлечения информации.
#### RDF и мешок утверждений
Итак, целью нашей системы является построить RDF-граф с извлеченной информацией.
Однако генерация RDF-графа происходит только в самом конце работы системы. В процессе работы для хранения извлекаемой информации используется более сложный объект, который мы называем «мешком утверждений». Он представляет собой множество не противоречащих друг другу логических утверждений об информационных объектах и их свойствах.
Вся работа системы извлечения информации может быть описана как процесс наполнения мешка утверждений.
Важные свойства мешка утверждений:
* Утверждения можно только добавлять. Удалять – нельзя.
* Все утверждения в мешке не противоречат друг другу.
* По мешку утверждений в любой момент можно построить аннотированный RDF-граф, согласованный с онтологией.
Основное отличие RDF-графа от мешка утверждений в том, что последний допускает наличие функциональных зависимостей.
Например, можно утверждать, что множество значений некоторого свойства одного объекта всегда включает множество значений какого-то другого свойства другого объекта. Такие зависимости являются динамическими, их пересчет система осуществляет сама.
В данной статье нет возможности разбирать утверждения подробно. Основные типы утверждений приведены на рисунке ниже.
Подробнее об утверждениях мы рассказывали [в статье на конференции Диалог](http://www.dialog-21.ru/digests/dialog2014/materials/pdf/StarostinAS.full.pdf).
#### Логический вывод на основе данных
Кто же заполняет мешок утверждений?
Мешок утверждений заполняется в процессе применения правил. Существует два типа правил:
* Правила извлечения информации.
Мы их уже обсуждали в прошлой статье, они позволяют описывать фрагменты семантико-синтаксических деревьев, при обнаружении которых вступают в силу определенные наборы логических утверждений. Схематично правило может быть представлено так:
```
[Шаблон на дерево разбора]
=>
[набор утверждений]
```
Правила извлечения бывают двух типов: без объектных условий (опираются только на древесный шаблон) и с объектными условиями (опираются и на древесный шаблон, и на ранее выделенные объекты)
* Правила идентификации.
Применяются в тех ситуациях, когда требуется объединить несколько информационных объектов. Схематично может быть представлено так:
```
<% Условие на объект 1 %> <% Условие на объект 2 %>
[Условие на объекты]
=>
[утверждение об идентичности объектов]
```
Если правилу удается сработать, то мешок пополняется новыми утверждениями: в правилах извлечения информации – за счет явно выписанных утверждений в правой части правила; в правилах идентификации – за счет утверждения об идентичности.
#### Алгоритм извлечения информации
Но как происходит срабатывание правил?
Ключевым понятием для понимания алгоритма является сопоставление. Под сопоставлением мы понимаем следующее:
* Для правил извлечения информации – наложение древесного шаблона, описанного в правиле, на фрагмент семантико-синтаксического дерева.
* Для правил идентификации – соотнесение ограничений правила идентификации с конкретными информационными объектами.
Работа алгоритма начинается с того, что система обрабатывает правила, содержащие только шаблоны на деревья разборов (без объектных условий). Ни одного объекта в «мешке утверждений» пока нет, поэтому правила с объектными условиями пока не участвуют в генерации сопоставлений.
Все найденные сопоставления помещаются в специальную отсортированную очередь сопоставлений. Эта очередь является важной структурой, процесс извлечения продолжается, пока эта очередь содержит хотя бы одно сопоставление. Очередь динамически пополняется новыми сопоставлениями в процессе работы, но не будем забегать вперед.
Итак, первые сопоставления были сгенерированы и помещены в очередь. Теперь система начинает обращаться к очереди и на каждом шаге извлекает самое приоритетное сопоставление. На приоритет, с одной стороны, могут влиять онтоинженеры (на множестве правил задано отношение частичного порядка), с другой стороны и сама система может вычислять наиболее удачное сопоставление.
После того, как выбрано самое приоритетное сопоставление, по правой части того правила, из которого оно было получено, формируется набор утверждений. Система пытается сделать так, чтобы эти утверждения вступили в силу, т.е. пытается поместить этот набор в общий мешок утверждений. Тут возможны нюансы – утверждения могут вступить в противоречие с утверждениями, добавленными в мешок ранее.
Противоречия могут быть разных типов:
* Онтологические противоречия (нарушена кардинальность свойств, совместимость концептов одного объекта друг с другом)
* Конфликт с уже добавленным в мешок утверждением-ограничением. Такие условия могут задавать сами онтоинженеры в правилах, как правило, они представляют собой произвольные условия на граф.
Если вставка не удалась (нашлось противоречие), то сопоставление отбрасывается и из очереди выбирается следующее. В случае успешной вставки перед выбором следующего сопоставления запускается механизм поиска новых сопоставлений, и очередь сопоставлений может быть пополнена. Обратите внимание – в результате помещения новых утверждений в мешок могут начать срабатывать новые правила, поскольку меняется общий контекст. Возможны следующие изменения – появление новых объектов и «якорей», заполнение новых атрибутов объекта, появление новых концептов у объекта. Из-за этих изменений и могут начать срабатывать те правила, шаблонная часть которых прежде не могла сопоставиться, и очередь сопоставлений будет пополнена.
Описанный процесс хорошо иллюстрирует следующая диаграмма
Для того чтобы реализовать все это, нам пришлось потрудиться. Одной из самых сложных компонент системы получился механизм поиска сопоставлений. В него встроен интерпретатор байт-кода скомпилированных правил, система специальных индексов над семантико-синтаксическими деревьями, модуль отслеживания изменений в мешке утверждений и некоторые другие механизмы. Отметим некоторые базовые особенности механизма поиска сопоставлений:
* Умеет находить все сопоставления для правил извлечения информации без объектных условий
* Постоянно следит за содержимым мешка утверждений и каждый раз при появлении в нем новых утверждений пытается генерировать новые сопоставления (уже с объектными условиями)
* На каждом шаге работы возможна генерация как сопоставления для новых правил извлечения информации и идентификации, так и сопоставления для правил, для которых до этого уже генерировались другие сопоставления.
Так происходит в тех случаях, когда некоторому объектному условию того или иного правила удовлетворяет более одного информационного объекта – каждый вариант рассматривается в рамках отдельного сопоставления.
В результате работы у нас получился алгоритм, который обладает следующими особенностями:
* Не рассматривает альтернативы. Если какое-то сопоставление вошло в противоречие с текущим состоянием мешка утверждений, оно просто отбрасывается.
Использование такого жадного принципа оказалось возможным в первую очередь за счет того, что языковая омонимия уже снята семантико-синтаксическим парсером – нам почти не приходится строить гипотезы о том, чем является тот или иной узел дерева.
* У онтоинженера есть возможность влиять на порядок срабатывания правил. На множестве правил введено отношение частичного порядка. Если оба срабатывания возможны и между ними задан порядок, то система гарантирует, что срабатывание одного из правил должно происходить раньше срабатывания другого. Для удобства поддержана так же возможность упорядочивать группы правил. Отношение частичного порядка транзитивно. При компиляции системы правил проверяется, что частичный порядок введен корректно, система умеет обнаруживать циклы. В то же время описанный подход существенно отличается от последовательного применения всех правил, т.к. частичный порядок, заданный на правилах, влияет лишь на выбор между очередными срабатываниями, но не блокирует повторное применение одних и тех же правил.
Если вам захочется изучить более формальное описание алгоритма – советуем обратиться к [упомянутой статье с конференции Диалог](http://www.dialog-21.ru/digests/dialog2014/materials/pdf/StarostinAS.full.pdf).
Эта технология предоставляет широкий круг возможностей, позволяющих нам решать различные задачи, ориентированные на актуальные потребности рынка. О том, с какими реальными бизнес-задачами мы сталкиваемся, и как с ними справляется Compreno, мы скоро расскажем в своем блоге.
|
https://habr.com/ru/post/269273/
| null |
ru
| null |
# iPod и Python: сортируем альбомы в хронологическом порядке
#### **Проблема**
Иногда мне кажется, что Apple изо всех сил старается упростить свою продукцию. С одной стороны это замечательно, а с другой — весьма прискорбно. Ведь дополнительные настройки хоть и усложняют нашу жизнь в первые пару недель использования продукта (пока привыкнешь, разберешься), но зато в последствии позволяют подогнать его под себя и получить гаджет (или программу) своей мечты.
Если Вы являетесь счастливым обладателем iPod-a, то наверно заметили, что все альбомы на нем (именно на плеере) сортируются строго в алфавитном порядке. И никак иначе. И никаких Вам настроек и expert-модов. Сказали «в алфавитном», значит в алфавитном. Что примечательно — в iTunes такая кнопочка (**Album by Year**) есть. Но там она мне была меньше всего нужна.
К счастью, эта проблема (как и проблема добавления отдельно скачанных эпизодов в имеющийся iTunes-подкаст) имеет решение. Не столь простое, как хотелось бы, но зато весьма увлекательное.
#### **Решаем в лоб**
Совершенно простое, но не слишком элегантное решение приходит в первые в первые пару секунд. Просто для всех альбомов превращаем содержимое тега **%album%** в **%year% — %album%**, и проблема решена. И сортируется как надо, да еще и год можно прямо на iPod-e посмотреть (без такого рода подготовки год выпуска альбома на самом плеере не выяснить).
Возможно Вас устроит такой вариант, но мне он показался неудовлетворительным. Одно дело папка на диске (их я привык называю в формате %year% — %album%), а другое дело — нарядный альбом с albumart-ом на iPod-e. Ко всему прочему меня не интересует конкретный год, в котором альбом выпустили. Я лишь хочу знать, какие альбомы относятся к раннему творчеству той или иной группы, а какие были выпущены совсем недавно, чтобы видеть, как группа менялась со временем, как менялся ее стиль. Именно это и побудило меня на более детальное изучение проблемы и поиск ее решения.
#### **iTunes**
Нет идеальных программ. iTunes не исключение. И тем не менее это удобное и приятное в работе приложение. По крайней мере так я начал думать после нескольких месяцев использования, когда уже окончательно смирился с этой Apple-овской простотой. А когда выяснилось, что в iTunes есть то, что в определенной степени поможет решить проблему, я окончательно избавился от мыслей о поиске замены iTunes-у.
#### **Он сказал: «Поехали!»**
Вступления позади и наконец-то мы начинаем действовать. Выделяем все треки какого-нибудь альбома и открываем контекстное меню. Там мы обнаруживаем замечательный пункт **Get Info**, за которым скрывается вся информация о выбранных треках. В настоящий момент нас интересует вкладка **Sorting**:
Назначение этих полей я в документации не уточнял, но весь мой жизненный опыт подсказывает, что если поле Sort Album заполнено, то при сортировке альбомов в iTunes (если в колонке альбомов выбрано не **«Album by Year»**, а просто **«Album»**) в качестве ключа будет выступать именно оно (аналогично с остальными sort-полями). И, что самое главное, этот же ключ будет использоваться и при сортировке альбомов непосредственно на самом плеере. Это-то нам и надо. Вводим в указанное поле **«2007 — Are You Listening»** и радуемся, как у нас все складно вышло. Теперь мы имеем ровно один альбом, который сортируется (сам с собой) в хронологическом порядке =)
#### **А впереди — вечность**
Проблема казалось бы уже решена. А на самом деле все еще только начинается. Ведь выпустив плеер на n-ое количество гигабайт, в Apple должно быть просто не ожидали, что столько музыки можно купить в Apple Store (а другие источники в рассчет вероятно не брали). А может они не ожидали, что кому-то в один прекрасный день захочется отсортировать все альбомы по дате. Дело в том, что повторить указанную процедуру с остальными пятьюстами альбомами в своей фонотеке я просто не в состоянии. Как было сказано в недавней C# головоломке: «Never send a human to do a machine's job».
#### **И тут на сцене появляется Python**
Именно его мы и используем, чтобы обработать нашу библиотеку. Всю и сразу.
Как выяснилось, iTunes сохраняет значение поля "**Sort Album**" в теге **TSOA** mp3-файла (про остальные теги iTunes можно почитать [тут](http://www.id3.org/iTunes)). Зная это, мы можем соответствующим образом заполнить этот тег в наших файлах, а затем добавить их в iTunes-библиотеку.
Python библиотек для работы с id3 тегами оказалось не много, но и не мало. Мой выбор пал на **mutagen** (с другими вариантами можно ознакомиться [тут](http://www.id3.org/Implementations)).
[**Mutagen**](http://code.google.com/p/mutagen/) позволяет работать с метаданными достаточно большого количества аудио форматов (ASF, FLAC, M4A, Monkey's Audio, MP3, Musepack, Ogg FLAC, Ogg Speex, Ogg Theora и т.д.) Нас же интересуют именно id3 теги в mp3-файлах. Для манипулирования ими библиотека предоставляет два интерфейса: **ID3** и **EasyID3**. Думаю разницу пояснять не надо. Я сначала поигрался с первым, но потом выяснилось, что и возможностей второго вполне достаточно.
#### **Собственно код**
Сразу оговорюсь, что мой опыт программирования на Python-e стремиться к бесконечности, но пока приблизительно равен нулю. Я старался написать все так, чтобы не стыдно было показать обществу, но не уверен, что получилось достаточно хорошо. Поэтому буду признателен за любые содержательные замечания, выраженные в дружественной форме.
Что же касается алгоритма, то он вполне очевиден: пробегаем по нужным файлам, достаем год выпуска и название альбома из тегов и соответствующим образом заполняем тег **TSOA**. Я пришел к выводу, что меня больше всего устроит формат **%artist% — %year% — %album%**. С таким значением тега **TSOA** альбомы будут сортироваться по исполнителю, затем по году, а затем по алфавиту (если вдруг в один прекрасный год Ваша любимая группа расстаралась более чем на один альбом). Python, говорят, обладает весьма дружественным синтаксисом, поэтому, даже если Вы с ним не знакомы, внести небольшие коррективы по своему вкусу в приведенный ниже скрипт проблем не составит.
В процессе обработки пяти тысяч треков может произойти многое, поэтому я добавил немного служебного вывода, чтобы наблюдать, как продвигается дело, и лог для вывода ошибок о нехватке тегов в файле. Как-никак добавлять в iTunes файл без исполнителя или альбома в тегах — гиблое дело, поэтому будет полезно выяснить, какие файлы у нас еще не готовы к миграции на iPod.
C docstring-ами я поленился, но комментариями код разбавил. Надеюсь это поможет сориентироваться тем, кто не сильно знаком с Python-ом.
Код:
> `Copy Source | Copy HTML1. #!usr/bin/env python
> 2. # -\*- coding: utf-8 -\*-
> 3. # Created by KL-7
> 4.
> 5. import logging
> 6. import sys
> 7. from os import path
> 8.
> 9. from mutagen.easyid3 import EasyID3
> 10. from mutagen.id3 import ID3NoHeaderError
> 11.
> 12. # Количество успешно обработанных файлов
> 13. totalfiles = 0
> 14.
> 15.
> 16. # Вывод информации об ошибках
> 17. def error(err):
> 18. # Настраиваем лог-файл для ошибок
> 19. **logging**.basicConfig(filename="error.log", level=**logging**.ERROR)
> 20. **logging**.error(err)
> 21.
> 22.
> 23. # Получаем значение тега tagname из файла audio
> 24. def gettag(audio, tagname):
> 25. taglist = audio.get(tagname, None)
> 26. if taglist:
> 27. return taglist[ 0]
> 28. else:
> 29. return ""
> 30.
> 31.
> 32. # Заполняем тег TSOA
> 33. def fill\_tsoa(fpath):
> 34. audio = EasyID3(fpath)
> 35.
> 36. artist = gettag(audio, "artist")
> 37. if not artist:
> 38. error("Missing artist in %s" % fpath)
> 39.
> 40. album = gettag(audio, "album")
> 41. if not album:
> 42. error("Missing album in %s" % fpath)
> 43.
> 44. year = gettag(audio, "date")
> 45. if not year:
> 46. error("Missing year in %s" % fpath)
> 47.
> 48. # Формируем значение для тега TSOA
> 49. tsoa = "%s -- %s - %s" % (artist, year, album)
> 50.
> 51. # EasyID3 репамит названия тегов для большей наглядности.
> 52. # Тег TSOA в этих обозначениях называется albumsort.
> 53. audio["albumsort"] = tsoa
> 54. audio.save()
> 55.
> 56.
> 57. def fill\_rec(root):
> 58. # Эта функция будет вызваться в директории root и
> 59. # в каждой ее поддиректории dirname.
> 60. # fnames - содержимое текущей директории dirname.
> 61. # Аргумент arg обязателен, но его мы не используем.
> 62. def process(arg, dirname, fnames):
> 63. for fname in fnames:
> 64. # Конвертируем русские названия в Unicode
> 65. fname = fname.decode("cp1251")
> 66. name, ext = path.splitext(fname)
> 67. fname = path.join(dirname, fname)
> 68. if path.isfile(fname) and ext.lower() == ".mp3":
> 69. try:
> 70. fill\_tsoa(fname)
> 71. global totalfiles
> 72. totalfiles = totalfiles + 1
> 73. print fname
> 74. except ID3NoHeaderError:
> 75. error("No tags in %s" % fname)
> 76.
> 77. # Запускаем рекурсивный обход из директории root
> 78. # с функциией process; None будет передан
> 79. # функции process первым параметром.
> 80. path.walk(root, process, None)
> 81.
> 82.
> 83. if \_\_name\_\_ == "\_\_main\_\_":
> 84. # Если есть параметры, интерпретируем их как директории,
> 85. # которые надо обработать.
> 86. if **sys**.argv[1:]:
> 87. for dirname in **sys**.argv[1:]:
> 88. fill\_rec(dirname)
> 89. # Если параметров нет, то работаем с текущей директорией.
> 90. else:
> 91. fill\_rec(".")
> 92.
> 93. print "\nTotal files: %d" % totalfiles
> 94. **raw\_input**();
> 95.`
Можно скопировать скрипт в директорию с музыкой и запустить без параметров. В таком случае будут обработаны все mp3-файлы в **текущей** директории и во всех **поддиректориях**. А можно самостоятельно передать скрипту в виде параметров список нужных директорий (**поддиректории** будут обработаны и в этом случае).
Когда скрипт завершит работу (длится это не слишком долго), останется обновиться данные в библиотеке iTunes. Если эти файлы Вы еще не добавляли туда, то сейчас самое время. Если же вы редактировали теги в файлах, уже присутствующих в iTunes, то необходимо просто выделить их в окне iTunes, открыть Get Info через контекстное меню и, **ничего там не редактируя**, нажать **Ok**. iTunes просто обновит все теги из выделенных файлов.
#### **AS IS**
Несколько замечаний по поводу скрипта:
1. Если Вы дорожите свой библиотекой, то возможно стоит сначала потестировать скрипт на нескольких файлах — мало ли что может произойти. У меня был back-up всей коллекции, поэтому я не волновался.
2. Вполне возможно, что могут возникнуть проблемы при добавлении в тег **TSOA** слишком длинной строки (я не стал вчитываться в документацию по внутренней структуре тег-блока в mp3-файлах). Самая длинная строка в теге TSOA (с моим форматом %artist% — %year% — %album%), которую мне довелось встретить в своей библиотеке, содержала 93 символа. Тег успешно сохранился в файле и все у него было хорошо.
3. Скрипт без проблем обработал 5000 файлов с англоязычными названиям. Русской музыки у меня в библиотеке не оказалось, но тест показал, что теги в файлы с кириллицей в названии успешно добавляются. Чтобы в консоль (cmd) названия русскоязычных файлов выводились в читабельном виде пришлось добавить декодирование названия (строка 58). Дело было под Windows, как под другими осями — не знаю. Поэтому если Вы не имеете дела с русскими названиями файлов, лучше пожалуй эту строку закомментировать.
4. Немецкие и прочие названия файлов с диакритическими знаками лично у меня обрабатываться не захотели. Как решить проблему я пока не выяснил. Проблема в том, что файл называется, например, «Verf**ü**hrer.mp3», а скрипт получает название «Verf**u**hrer.mp3». Файла с таким именем в папке, ясное дело, нет. Опять-таки это все Windows. Лично у меня диакритические знаки встречаются в тегах (там юникод и все отлично), но в названиях файлов я их избегаю. Поэтому все прошло успешно.
#### **Послесловие**
Если будут еще какие-то замечания или проблемы — пишите. Если будут предложения, как решить проблемы с кодировками — пишите еще быстрее. Если честно, то у меня на всех системах и во всех языках всю мою сознательную жизнь постоянно возникали проблемы с кодировками. Может мы с ними слишком разные, а может мне просто стоит сесть и хорошенько с ними со всеми разобраться. Однажды я этим обязательно займусь.
На этом пока все. Буду рад, если кому-то этот скрипт окажется полезным или по крайней мере интересным.
**PS**
Кто-нибудь может подсказать, что побудило **s-c.me** добавить пробел перед нулем в 22ой строке? В исходнике его не было. Если же в html-е убрать в этом месте nbsp, то вместе с пробелом пропадает и 0. А это не хорошо.
|
https://habr.com/ru/post/83248/
| null |
ru
| null |
# DI в сложных приложениях. Как не утонуть в зависимостях
Всем привет.
При конструировании приложений хорошим тоном является использование Dependency Injection(внедрение зависимостей). Данный подход позволяет делать код слабо связанным, а это в свою очередь обеспечивает легкость сопровождения. Также облегчается тестирование и код становится красивым, универсальным и заменяемым. При разработке наших продуктов с самого начала использовался этот принцип: и в высоконагруженной DSP и в корпоративном [Hybrid](http://hybrid.ru). Мы писали модули, подключали интеграцию с различными системами, количество зависимостей росло и в какой-то момент стало сложно поддерживать само конфигурирование приложения. Плюс к этому добавлялись неявные регистрации(например, кастомный DependencyResolver для Web Api задавался в настройках Web Api) и начали возникать сложности с ***порядком*** вызова модулей конфигурации. В конце концов мы выработали подход для регистрации, конфигурации и инициализации модулей в сложном приложении. О нём и расскажу.
Для начала надо уточнить, что для обслуживания различных задач(даже в рамках одного продукта) у нас работает несколько типов приложений: сервисы, консольные приложения, asp.net. Соответственно система инициализации везде представляла свой зоопарк, единый только в том, что был класс DependencyConfig с чертовой тучей зависимостей на вкус и цвет. Также в каждом из приложений были свои дополнительные настройки. Например, настройка роутинга, конвертеров, фильтров авторизации в asp.net mvc, которая должна была вызываться после регистрации зависимостей и проверки корректности данной регистрации. Соответственно встала задача:
* унифицировать конфигурирование для разных типов приложений
* убрать необходимость задавать последовательность инициализации
* разбить регистрацию модулей на легкие, изолированные друг от друга примитивы.
В итоге мы выделили 3 типа элементарных конфигураций: зависимости(dependency), инициализации(init) и настройки(settings, которые на самом деле объединение двух предыдущих).
Зависимости(IDependency)
------------------------
Зависимость представляет собой примитив для регистрации, ха-ха, зависимостей одного модуля. В общем случае реализует интерфейс IDependency:
```
public interface IDependency
{
void Register(TContainer container);
}
```
где TContainer — IoC-контейнер(В качестве примера контейнера здесь и далее используется SimpleInjector). Соответственно в методе Register регистрируются сервисы одного логического модуля. Также могут регистрироваться другие IDependency-примитивы посредством прямого вызова конструктора и метода Register. Пример:
```
public class TradingDeskDependency : IDependency
{
public void Register(Container container)
{
container.Register(() => new SwiffyClient(new SwiffyOptions{ MillisecondsTimeout = 20000 }));
new DspIntegrationDependency().Register(container);
}
}
```
Инициализации(IInit)
--------------------
Инициализации включают в себя тот код, который должен выполнять после регистрации и проверки зависимостей, но до старта основной логики приложения. Это может быть настройка asp.net mvc и web api или что-то подобное. В общем случае класс инициализации реализует интерфейс IInit:
```
public interface IInit
{
void Init(IDependencyResolver resolver);
}
```
гдe IDependencyResolver нужен, если требуется получение какого-нибудь сервиса из зависимостей, либо для получения самих методов получения зависимостей, как в примере:
```
public class AspNetMvcInit: IInit
{
public void Init(IDependencyResolver resolver)
{
System.Web.Mvc.DependencyResolver.SetResolver(resolver.GetService, resolver.GetServices);
new RouteInit().Init(resolver);
}
}
```
Так же, как и для зависимостей можно использовать вложенные примитивы инициализации.
Настройки(ISettings)
--------------------
Настройки нужны, если в логическом модуле необходима как регистрация зависимостей, так и вызов инициализации после. Описываются они проще всего:
```
public interface ISettings : IDependency, IInit
{
}
```
Соответственно, именно настройки представляют полную функциональность для конфигурирования логического модуля: как регистрацию зависимостей, так и дополнительные настройки.
Общая конструкция
-----------------
Итак, у нас есть примитивы, на которые можно разбить конфигурацию, осталось настроить управление ими. Для этого нам поможет класс Application, реализующий интерфейс IApplication:
```
public interface IApplication
{
IApplication SetDependency(T dependency) where T : IDependency;
IApplication RemoveDependency() where T : IDependency;
IApplication SetInit(T init) where T : IInit;
IApplication RemoveInit() where T : IInit;
IApplication SetSettings(T settings) where T : ISettings;
IApplication RemoveSettings() where T : ISettings;
IAppConfig Build();
}
```
Как видно из кода, IApplication позволяет добавлять все типы настроек(а также удалять их). А метод Build вызывает код, собирающий всё эти настройки: сначала выполняется регистрация зависимостей(+ если нужно — проверка, возможно ли всё зарегистрировать), далее — код из IInit-модулей(и методов Init в ISettings). На выходе получаем объект IAppConfig:
```
public interface IAppConfig
{
IDependencyResolver DependencyResolver { get; }
IAppLogger Logger { get; }
}
```
где DependencyResolver позволяет получать сервисы, а Logger сами знаете для чего. Итоговый код для настройки приложения будет прост и прозрачен(хотя в общем случае с некоторыми усложнениями для универсальности):
```
var container = new Container()
var appOptions = new AppOptions
{
DependencyContainer = container,
GetServiceFunc = container.GetInstance,
GetAllServicesFunc = container.GetAllInstances,
VerifyAction = c => c.Verify(),
Logger = new CustomLogger()
};
var appConfig = new Application(appOptions).SetDependency(new TradingDeskDependency())
.SetInit(new AspNetMvcInit())
.Build();
```
Единственный класс, который придется определять явно — это CustomLogger. Если мы хотим отслеживать ситуации, когда регистрация зависимостей и инициализаций валится с ошибкой, то задать его следует. Логгер описывается простейшим интерфейсом:
```
public interface IAppLogger
{
void Error(Exception e);
}
```
и написать реализацию не составит труда.
В итоге этот подход можно использовать для любого типа приложения, нам не нужно думать о порядке конфигурирования и в управлении зависимостями мы перешли на уровень логических модулей. Таким образом можно навернуть кучу настроек, зависимостей, инициализаций, сохраняя трезвость мысли и крепость духа.
Я написал немного упрощенный(но вполне рабочий и легко расширяемый) вариант библиотеки(Jdart.CoreApp), каковой можно изучить или просто использовать:
1) [GitHub](https://github.com/alvaro-jdart/CoreApp)
2) [Nuget](https://www.nuget.org/packages/Jdart.CoreApp/).
Также доступны адаптеры для
1) [SimpleInjector](https://www.nuget.org/packages/Jdart.CoreApp.SimpleInjector/)
2) [Autofac](https://www.nuget.org/packages/Jdart.CoreApp.Autofac/)
3) [Ninject](https://www.nuget.org/packages/Jdart.CoreApp.Ninject/)
4) [Unity](https://www.nuget.org/packages/Jdart.CoreApp.Unity/)
Всем спасибо.
|
https://habr.com/ru/post/266975/
| null |
ru
| null |
# Тюнинг Оперы: предпросмотр rss потоков и подписка на них через внешние читалки, в примере использовал Google Reader
В Опере перед подпиской на rss поток можно посмотреть, что он из себя представляет. Соединим полезное с удобным — совместим предпросмотр и подписку через **наши** читалки
[](http://img.picbite.com/2008/12/17/24211qymph.png)
**Способ 1**
Сохраняем файл [webfeeds.html](http://files.myopera.com/gr1b0k/files/webfeeds.html) куда угодно и устанавливаем до него путь на странице настроек (`opera:config#UserPrefs|WebfeedsHTMLTemplateFile`)
**Способ 2**
Сохраняем файл [webfeeds.html](http://files.myopera.com/gr1b0k/files/webfeeds.html) в C:\Program Files\Opera\Styles\ (или куда у вас там установлена Опера?). Не забудьте сделать копию для востановления. Готово (перезагружатся не надо). Гаранирую, что работает у меня на 10-й Опере.
**Альтернативный путь**
Если вам не нравится Google Reader или не хотите загружить файл — вот что вам нужно сделать в локальном файле webfeeds.html:
находим строчку
> `(document.getElementById('learn')||{firstChild:{}}).firstChild.nodeValue = opera.locale.getLocaleString( 'S_WEBFEEDS_SUBSCRIBE_HINT' )||'Learn more about feeds';`
и замеяем её на эту (это скроет бесполезную ссылку):
> `document.getElementById('learn').parentNode.style.display="none"`
чуть ниже находим строчку
> `button.firstChild.nodeValue = opera.locale.getLocaleString( 'S_MINI_FEED_SUBSCRIBE' )||'Subscribe';`
и сразу под ней дописываем
> `var button2=document.createElement('button')
>
> var feedReaderName="Google Reader" //Название читалки
>
> var feedReader="http://www.google.com/reader/view/feed/" //Ссылка для подписки через читалку, можно написать «feed:» для открытия во внешних читалках
>
> button2.style.verticalAlign='middle'
>
> button2.textContent=opera.locale.getLocaleString( 'S_MINI_FEED_SUBSCRIBE' )||'Subscribe'+' via '+feedReaderName
>
> button2.addEventListener( 'click', function(){ location.assign(feedReader+escape(location.href))}, false );
>
> heading.appendChild( button2 )`
По [мотивам](http://my.opera.com/shoust/blog/2008/08/29/add-external-feed-reader-links) Симона Хьюстона.
Сделать лучше можно в комментариях.
|
https://habr.com/ru/post/47181/
| null |
ru
| null |
# Зачем Google добавляет while(1); к своим JSON-ответам?
Это позволяет избежать CSRF/XSRF-атак ([подделки межсайтовых запросов](http://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B4%D0%B4%D0%B5%D0%BB%D0%BA%D0%B0_%D0%BC%D0%B5%D0%B6%D1%81%D0%B0%D0%B9%D1%82%D0%BE%D0%B2%D1%8B%D1%85_%D0%B7%D0%B0%D0%BF%D1%80%D0%BE%D1%81%D0%BE%D0%B2)).
Рассмотрим следующий пример: допустим у Google есть URL вида `gmail.com/json?action=inbox`, который возвращает 50 первых сообщений вашего почтового ящика в формате JSON. Злоумышленник, чей сайт находятся на другом домене, не может выполнить AJAX запрос, обратившись по данному URL, чтобы получить данные, ввиду same origin policy ([правило ограничения домена](http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE_%D0%BE%D0%B3%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B4%D0%BE%D0%BC%D0%B5%D0%BD%D0%B0)). Но ничто не мешает злоумышленнику включить вышеуказанный URL на свою страницу с помощью тега ```.
Данному URL будут переданы куки, сохранённые в вашем браузере для домена gmail.com. Путём переопределения глобального конструктора array или методов доступа злоумышленник может вызывать произвольный метод всякий раз, когда устанавливается атрибут объекта (массива или хэша), тем самым получая доступ к содержимому JSON.
Конструкция **while(1);** или **&&&BLAH&&&** позволяет этого избежать. Gmail.com при отправке AJAX-запросов имеет полный доступ к содержимому ответа и благополучно эту дополнительную конструкцию вырезает. Тег же выполняет JavaScript без какой-либо предварительной обработки, в результате чего, происходит либо бесконечный цикл (для **while(1);**) или синтаксическая ошибка (для **&&&BLAH&&&**).
[ Источник ]
**UPD:**
Информация от пользователя [d00kie](https://habrahabr.ru/users/d00kie/):
Это атака — JSON Hijacking, была блокирована в 2007/2008 производителями браузеров. Так что, в данном случае это «страховка» на случай, если изобретут новый способ перехвата и осталось «с тех времен», ибо хуже не будет. То, что в статье на столько старо, что с тех пор, как переопределяли Array() уже был «изобретён» новый способ (после фикса 2007 надо было найти новый способ и его нашли):
Object.prototype.__defineSetter__('Id', function(obj){alert(obj);});`
И он тоже уже пофиксен в фаерфоксе версии >3.0.11…
Всё это история.``
|
https://habr.com/ru/post/168461/
| null |
ru
| null |
# Time Management для Ubuntu'водов
Многих хабровчан интересует вопрос Time Management'а. Именно этим объясняются высокие рейтинги статей, описывающие разные методики и технические средства с ними связанные. Попробую и я внести свою лепту, рассказав о том, как на базе нескольких линуксовых машин (3 х Ubuntu 9.10) мной реализована и используется последние полгода система планирования и составления списка задач ([Getting Things Gnome! 0.2.3 aka GTG](http://gtg.fritalk.com/ "Getting Things Gnome! 0.2.3 aka GTG")), хронометраж ([Time Tracker 2.29.92 aka Project Hamster](http://projecthamster.wordpress.com/ "Time Tracker 2.29.92 aka Project Hamster")) и синхронизация конфигурационных и файлов баз данных с помощью [Dropbox for Linux v.0.7.110](https://www.dropbox.com/referrals/NTcyMTA3Njk) , так сильно любимого на просторах хабра. Первые два приложения написаны на питоне, что делает их ещё более привлекательными, т.к. позволяет самому быстро разобраться в коде и подвинтить их (приложения) под себя. Хотя и в стандартной конфигурации они справляются с поставленными задачами очень даже не плохо.
Начнём с наглядного описания программ, т.е. со скриншотов.
[Getting Things Gnome!](http://gtg.fritalk.com/ "Getting Things Gnome! 0.2.3 aka GTG")
--------------------------------------------------------------------------------------
Пример моего реального списка задач по аспирантуре:
* Новая задача может быть добавлена через строку «быстрого ввода»
* Каждая задача может быть открыта как отдельное окно для редактирования, с возможностью в этом окне добавлять подзадачи и метки
* Задачи объединяются в древовидную структуру. Т.е. любая задача может быть разбита на подзадачи.
* Имеется целый ряд подключаемых плагинов. Из самых интересных взаимодействие с RememderTheMilk и Hamster Project
* Кнопка «Work view» покажет только концы веток, т.е. именно те задачи, которые должны быть выполнены первыми.
* Наличие меток позволяет быстро находить необходимые задачи.
* Каждой задаче можно приписать две даты: начало задачи и окончание. От этого будет зависеть попадёт ли задача в Work View или нет
Перечисленные сверху возможности программы не делают приложение слишком разухабистым. Авторы старались придерживаться принципов минимализма, при написании этого приложения. Но это не мешает разукрасить теги в разные цвета, для быстрой визуальной ориентировке в иногда огромном списке возможных задач (если вы себе их поставите).
[Project Hamster](http://projecthamster.wordpress.com/ "Time Tracker 2.29.92 aka Project Hamster")
--------------------------------------------------------------------------------------------------
Функциональность и потрясающий дизайн — основные черты данной программы. Что ещё больше потрясает, так это то, что весь проект ведёт и поддерживает один-единственный человек: Toms Bauģis. Хотя он с удовольствием принимает изменения от других разработчиков.
Вот отчёт о моём хрометраже за пару месяцев:
Отчёты — это то, ради чего и ведётся весь хронометраж. Именно по отчётам можно узнать на что было потрачено сколько времени. Могу сказать, что именно Hamster отучил меня сидеть за стрелялками часы на пролёт. Вы удивитесь сколько времени пропадает на такие, казалось бы, безобидные вещи, как чтение новостей, игрушки или выход с друзьями на кофе. Я не призываю бросать заниматься этим, я всего лишь советую ознакомиться с числом часов, потраченных на разную деятельность. Эти данные заставляют задуматься.
Вот например оказывается, что я уже больше двух часов трачу на написания этой статьи:
* Hamster — это GNOME Applet, который вешается на гномовскую панель
* Приложению можно приписать быстрые клавиши
* Оно так же сохраняет список категорий, задач и меток, которые были введены ранее
* В результате регистрация новой задачи занимает всего пару секунд
* Можно так же вводить уже завершённые задачи, которые по какой-либо причине не были записаны
* Выборка при просмотре статистики по дням, неделям, месяцам или даже годам.
* Выборка статистики по категориям и/или меткам
[Dropbox](https://www.dropbox.com/referrals/NTcyMTA3Njk)
--------------------------------------------------------
Dropbox не нуждается в представлении. Но всё же, если вы услышали о нём в первый раз, то знайте, это программа мгновенной синхронизации папок, написанная не только для Linux, но ~~не поверите~~ так же для Window и Mac. [Бесплатный аккаунт](https://www.dropbox.com/referrals/NTcyMTA3Njk) позволяет синхронизировать папки размером до 2ГБ.
* Web-интерфейс, с возможностью манипуляций файлами (откат версий, просмотр и т.д.)
* Отличная интеграция с операционной системой. Т.е. для вас это будет просто папка в домашней директории.
* Возможность в один клик получить ссылку на файл, которую можно послать другому человеку. Хороший способ делиться фотографиями.
* Папка или файл могут делиться сразу между несколькими аккаунтами. Т.е. несколько человек будет одновременно иметь доступ и возможность изменять какой-либо файл или директорию
* Реферальная система позволяет увеличить место на виртуальном диске до 10ГБ, или же его можно купить.
Вот такой вот список возможностей. Ну а теперь к ~~интегральной глаболизации!~~ глобальной интеграции.
Напильник
---------
Идея такова, что при установки Dropbox'а он просит указать какая папка будет синхронизироваться. Именно в эту папку мы и собираемся поместить наши конфигурационные файлы для GTG и Hamster. А потом просто сделать линк на эти файлы в тех местах, где программы пытаются их найти.
GTG хранит свои файлы в папке **~/.local/share/gtg**. Hamster хранит SQLite базу данных в **~/.local/share/hamster-applet/hamster.db**. Допустим, что мы согласились с установками по умолчанию, и поставили Dropbox папку в ~/Dropbox/, тогда последовательность действий следующая:
1. Создаём рабочую папку внутри Dropbox'а, например ~/Dropbox/work/
2. Копируем папки ~/.local/share/gtg/ и ~/.local/share/hamster-applet/ в
рабочую папку ~/Dropbox/work/
3. Теперь удаляем папки по их первоначальному месторасположению (программы
лучше при этом пусть будут выключенными)
4. Создаём symbliic link на папки в нужном месте:
`ln -s ~/Dropbox/work/gtg/ ~/.local/share/gtg`
`ln -s ~/Dropbox/work/hamster-applet/ ~/.local/share/hamster-applet`
5. Наслаждаемся плодами цивилизации
Пару **''НО''**:
* GTG записывает свои файлы после каждой нажатой клавиши (авторы параноики), поэтому можно не бояться — синхронизация произойдёт 100%
* Hamster стартует раньше (при загрузке GNOME) и поэтому синхронизация может не успеть. И тогда будут использоваться старые данные. Это лечиться перезапуском Hamster'а. Например следующей командой:
`/bin/kill $(/bin/ps axfv | /bin/grep hamster-applet | /bin/grep python | /usr/bin/head -c 6)`
Команда была записана в скриптовый файл и выложена для быстрого запуска на всю туже самую GNOME панель
* После публикации самой статьи на хабре мне на почту пришло письмо от самого Toms Bauģis'а. Он сказал, что начиная с Хамстера 2.29+ добавлена поддержка автообновление базы данных, если она изменила свой размер. Но оказалось, что эти изменения не фиксируются, если указан не реальный файл, а софтлинк, как в случае с Dropbox'ом. По этому поводу уже открыли багрепорт тут: <https://bugzilla.gnome.org/show_bug.cgi?id=614779> Но способ всё же есть.
1. Нужно оставить файлы Hamster Project там где они и есть ( это при установке на первую машину). Софтлинк организовать в обратную сторону, т.е. например так:
`ln -s ~/.local/share/hamster-applet/ ~/Dropbox/work/hamster-applet`
Dropbox уже умеет следовать линкам и синхронизировать папки и файлы, на которые эти линки указывают
2. Немного странным выглядит подключение второй, третьей и т.д. машины, но это только из-за того, что мы хотим указать Dropbox'у на файл, который как бы уже числиться в его каталоге. Давайте последовательно — так будет проще. Установили на другой компьютер Hamster. Идём в **~/.local/share/hamster-applet/** и естественно видим, что и папка, и файл базы данных уже существует.
3. Копируем из Dropbox'овской директории файл в папку Hamster'а
4. Hamster обнаружит изменение базы данных и откроет новую базу (точнее старую, т.е. ту, в которой были записи с первого компьютера)
5. Теперь нужно сделать софтлинк из папки Hamster'а в папку Dropbox'а. Но это сделать не получиться, т.к файл по месту назначения уже существует. Поэтому мы просто удаляем его. Т.е. если мы решили делать софтлинк на всю директорию целиком, то просто удаляем это всю папку
`rm -r ~/Dropbox/work/hamster-applet`
6. Ну и последнее действие — восстанавливаем файл в папке Dropbox'a.
`ln -s ~/.local/share/hamster-applet/ ~/Dropbox/work/hamster-applet`
Теперь у нас две машины синхронизированы, и Hamster сам обновит базу, если увидит, что что-то было внесено с другой машины.
На этом у меня всё. Спасибо за внимание.
PS: У меня уже стало традицией выкладывать график, показывающий активность в написанной статье:
|
https://habr.com/ru/post/89835/
| null |
ru
| null |
# Что есть sshto?
sshtoМногие, если не все, кому приходится подключаться по *ssh* к серверам начинают использовать *ssh aliases*(конфиг файлы), когда этих серверов становится больше одного. А если их больше двух наступает время автоматизации. Так появился [sshto](https://github.com/vaniacer/sshto). Это моя поделка на *bash*, использующая *dialog* для визуализации *ssh* конфиг файлов в консоли. Фишка в том что не надо делать какой-то специальный список/конфиг/файл и т.д. и т.п. Используется ваш(и) *ssh* конфиг файл(ы) из коробки. Единственное что можно/нужно сделать это добавить комментарии в ваш конфиг чтобы итоговый результат выглядел более информативно(но будет работать и без них). Пример:
```
#Host DUMMY #Rybinsk#
Host rybserver1 #First server
HostName localhost
Host rybserver2 #Second server
HostName localhost
Host rybserver3 #Third server
HostName localhost
#Host DUMMY #Moscow#
Host moserver1 #First server
HostName localhost
Host moserver2 #Second server
HostName localhost
Host moserver3 #Third server
HostName localhost
```
И что из этого получается:
Вот так выглядит диалог sshtoНавигация интуитивная, кнопки курсора, ввод, местами таб и спейс. *Dialog* поддерживает мышь. Как видно из рисунка [sshto](https://github.com/vaniacer/sshto) может не только подключаться но и выполнять команды *"RUN COMMAND"*:
Выполнение команды на сервереА в одном из последних обновлений добавлена возможность выполнять команды на группе серверов(*RUN COMMAND* из меню *CONTENTS*):
Выполнение команды на группе серверовКак это сделано. Небольшой *awk* скриптик перелопачивает конфиги в удобоваримый формат:
```
...
CONFILES=$(echo ~/.ssh/{config,config*[!~]}) # SSH confiles list.
...
declare -A hostnames
while read -r name hostname desc; do
case $name in
'DUMMY') name="{ $desc }" name_length=${#name}
name_left=$[(40-name_length)/2] name_right=$[40-(name_left+name_length)]
printf -v tmp "%${name_left}s_NAME_%${name_right}s"
tmp=${tmp// /-} name=${tmp//_NAME_/$name}
content+=( "$desc" ); desc=$(line - 20);;
'#'*) continue;;
esac
hostnames["$name"]=$hostname #Create host-hostname pairs in hostnames array
fullist+=("$name" "$desc") #Add Host and Description to the list
done < <(awk '
/Host /{
strt=1
host=$2
desc=gensub(/^.*Host .* #(.*)/, "\\1", "g", $0)
desc=gensub(/(.*)#.*/, "\\1", "g", desc)
next
}
strt && host == "DUMMY"{
hostname=$2
print host, "DUMMY", desc
strt=0
}
strt && /HostName /{
hostname=$2
print host, hostname, desc
strt=0
}' $CONFILES)
list=( "${fullist[@]}" )
[[ $filter ]] && new_list
#--{ Go baby, GO!) }--
first_dialog
[[ $OPT =~ name ]] && echo $target || bye
```
Из которого создаются списки для диалога, затем начинается *dialog*:
```
...
first_dialog(){
group= dfilelist=
[[ $OPT =~ name ]] && oklbl='GET NAME' extra= || oklbl='CONNECT' extra='--extra-button'
target=$(dialog --output-fd 1 --colors $extra --help-button \
--extra-label "RUN COMMAND" \
--help-label "CONTENTS" \
--ok-label "$oklbl" \
--cancel-label "EXIT" \
--menu "Select host to connect to. $USERNOTE" 0 0 0 "${list[@]}")
case $target:$? in
-*\ *\ *-:*) first_dialog ;;
*:0) [[ $OPT =~ name ]] && return || { go_to_target; first_dialog; };;
*:2) contents_menu;;
*:3) second_dialog;;
*:*) bye;;
esac
}
...
```
Неожиданно получилась очень удобная штука, которой я постоянно пользуюсь в перерывах между игрой в [PIU-PIU](https://github.com/vaniacer/piu-piu-SH)!) А один зарубежный видео блогер - [Tom Lawrence](https://www.youtube.com/channel/UCHkYOD-3fZbuGhwsADBd9ZQ) даже рассказал о [sshto](https://github.com/vaniacer/sshto) в одном из своих видосов про *ssh* и вот это вот все:
Я даже не подозревал что [sshto](https://github.com/vaniacer/sshto) поддерживает эмодзи)
Диалог в кубе.
--------------
А недавно я начал работать над новой поделкой с использованием *dialog'а -* [kube-dialog](https://github.com/vaniacer/kube-dialog).
Это диалог обертка для *kubectl -* команды для работы с k8s кластерами.
Если у вас тоже есть, попробуйте [kube-dialog](https://github.com/vaniacer/kube-dialog), проект в стадии развития но уже довольно удобен и полезен. Как это выглядит, сначала выбираем кластер(да их может быть больше одного):
Выбор кластера в kube-dialogЗатем выбираем неймспейс(*namespace*):
Выбор неймспейса в kube-dialogМожно выбрать "не выбирать" неймспейс и просто жмякнуть *"All namespaces"*, *kubectl* будет выполнен с опцией *"--all-namespaces"*. После (не)выбора неймспейса(я выбрал *kube-system*) открывается список объектов с которыми можно поиграть:
Выбор объекта для изучения в kube-dialogВозьмём *pod* для примера, откроется окно со списком подов кластера *kubernetes*, в неймспейсе *kube-system*:
Выбор пода в kube-dialogВ одном из последних обновлений добавлена возможность использовать лейблы(*labels*). Их можно вбить руками или выбрать из списка. Выбрав понравившийся под, попадаем в окно с командами доступными для данного объекта, в данном случае пода:
Действия с подом в kube-dialogС подом можно делать вот это вот всё ^^^. Для примера можно посмотреть лог:
Просмотр лога пода в kube-dialogИдея и реализация примерно такая же как и в [sshto](https://github.com/vaniacer/sshto), у вас есть *k8s* конфиги для *kubectl*(в папке *~/.kube*), они и используются для [kube-dialog](https://github.com/vaniacer/kube-dialog)(kd) ничего лишнего.
Вот такие вот интересные *dialog'*и получились. Это простые *bash* скрипты поэтому каждый может подогнать их под себя, добавить/убавить что-то, сделать еще удобнее. Для упрощения модификации я предусмотрел сорсинг конфайлов, для [sshto](https://github.com/vaniacer/sshto) это *~/.sshtorc*. А для [kube-dialog](https://github.com/vaniacer/kube-dialog) - *~/.kdrc*. *Dialog* тоже можно подтюнить создав конфайл:
```
dialog --create-rc ~/.dialogrc
nano ~/.dialogrc
```
Если заинтересовал, заходите в гости в мой [github](https://github.com/vaniacer) пока его не прикрыли, там есть еще интересные штуки.
Творите, выдумывайте, пробуйте!)
Подписывайтесь, ставьте лайки, пальцы и вот это вот все!)
|
https://habr.com/ru/post/661687/
| null |
ru
| null |
# Использование блоков в iOS. Часть 2
В [первой части](https://habrahabr.ru/post/309780/) нашего урока мы использовали Storyboard для настройки view. Во второй и заключительной части мы наконец-то добрались до самих блоков. Мы поговорим о том, что блоки собой представляют, каков их синтаксис, как их использовать и затронем кучу примеров. Будет показано, как использовать блоки с NSArray, UIView-анимациями, Grand Central Dispatch, и многим другим.
Введение
--------
Блоки были впервые введены в iOS 4.0 и Mac OSX 10.6 для упрощения кода. Они могут помочь в его уменьшении, в снижении зависимости от делегатов, и в написании чистого, читабельного кода. Но, несмотря на очевидные преимущества, многие разработчики не используют блоки ввиду неполного понимания принципа их действия.
Давайте разберем все «что, где, когда и почему» блоков.
### Что такое эти «Блоки» и почему они такие важные?
Изнутри блок представляет собой кусок кода, который может быть вызван в некоторый момент в будущем. Блок — это [функция первого класса](https://ru.wikipedia.org/wiki/Функции_первого_класса), поэтому можно сказать, что блоки — обычные объекты Objective-C. А объекты можно передавать как параметры, возвращать из функций и методов, и присваивать переменным. Блоки зачастую называют [замыканиями](https://ru.wikipedia.org/wiki/Замыкание_(программирование)) (closures) в таких языках, как Python, Ruby и Lisp, потому что после объявления они инкапсулируют свое состояние. Блок создает константную копию любой локальной переменной, на которую ссылается.
Когда вам понадобится вызвать выполнение некоторого кода, который бы позже вам вернул что-либо, вероятно вы бы использовали делегаты или NSNotificationCenter, а не блоки. И это бы прекрасно сработало, но куски кода были бы разбросаны повсюду — задача стартует с одной точки, а результат обрабатывается в другой.
Блоки лучше, потому что они держат выполнение задачи в одном месте, что мы скоро и увидим.
### Для кого нужны блоки?
Для ВАС! А если серьезно, блоки — для всех и все используют блоки. Блоки — это будущее, так что вы можете изучить их прямо сейчас. Множество методов встроенных фреймворков переписываются или дополняются блоками на базе существующих функциональных возможностей.
### Как использовать блоки?
Это картинка, из iOS Developer Library хоршо объясняет синтаксис блоков.
Формат описания блоков такой:
```
return_type (^block_name)(param_type, param_type, ...)
```
Если вы уже программировали на любом другом С-языке, эта конструкция вам вполне знакома за исключением этого символа ^. ^ и означает блок. Если вы поняли, что ^ означает «я — блок», — поздравляю — вы только что поняли самую трудную вещь касаемо блоков. ;]
Обратите внимание, что имена для параметров на данный момент не требуются, но по желанию можете их включить.
Ниже приведен образец объявления блока.
```
int (^add)(int,int)
```
Далее, описание блока.
```
^return_type(param_type param_name, param_type param_name, ...) { ... return return_type; }
```
Собственно, так блок и создается. Заметьте, что описание блока отличается от его объявления. Оно начинается с символа ^ и сопровождается параметрами, которые могут быть поименованы и которые обязаны соответствовать типу и порядку параметров в объявлении блока. Далее следует сам код.
В определении блока тип возвращаемого значения указывать необязательно, он может быть идентифицирован из кода. Если возвращаемых значений несколько, они обязаны быть одного типа.
Образец описания блока:
```
^(int number1, int number2){ return number1+number2 }
```
Если совместить описание и объявление блока, то получится следующий код:
```
int (^add)(int,int) = ^(int number1, int number2){
return number1+number2;
}
```
Еще можно использовать блоки таким образом:
```
int resultFromBlock = add(2,2);
```
Теперь давайте посмотрим на пару примеров использования блоков в противопоставлении с таким же кодом без блоков.
### Пример: NSArray
Давайте посмотрим, как блоки меняют принцип выполнения некоторых операций над массивом. Для начала — вот обычный код для цикла:
```
BOOL stop;
for (int i = 0 ; i < [theArray count] ; i++) {
NSLog(@"The object at index %d is %@",i,[theArray objectAtIndex:i]);
if (stop)
break;
}
```
Вы можете не придать значения переменной «stop». Но все станет ясно после того, как вы увидите реализацию этого метода с использованием блока. Способ с блоком содержит переменную «stop», которая позволяет остановить цикл в любой момент, и поэтому мы просто дублируем эту возможность здесь для схожести кода.
Теперь посмотрим на этот же код с использованием быстрого перечисления (fast-enumeration).
```
BOOL stop;
int idx = 0;
for (id obj in theArray) {
NSLog(@"The object at index %d is %@",idx,obj);
if (stop)
break;
idx++;
}
```
И теперь с блоком:
```
[theArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop){
NSLog(@"The object at index %d is %@",idx,obj);
}];
```
В коде выше вы можете задаться вопросом — что за переменная «stop». Это просто переменная, которой может быть присвоено YES внутри блока для остановки процесса. Этот параметр определен как часть блока, которая будет использоваться в методе **enumerateObjectsUsingBlock**.
Вышеуказанный код тривиален, и увидеть в нем преимущества блоков довольно трудно. Но есть две вещи, которые я бы хотел отметить:
* **Простота**. Используя блоки, мы можем получить доступ к объекту, индексу объекта в массиве и стоп-переменной без написания кода. Это приводит к уменьшению кода, что в свою очередь уменьшает количество ошибок.
* **Скорость**. Блочный метод имеет небольшое преимущество в скорости по сравнению с методом быстрого перечисления. В нашем случае это преимущество, возможно, слишком мало для упоминания, но в более сложных случаях оно становится существенным.
### Пример: UIView-анимации
Давайте рассмотрим простую анимацию, которая оперирует на одном UIView. Она меняет параметр **alpha** до 0 и перемещает view вниз и вправо на 50 пунктов, затем удаляет UIView из superview. Просто, не так ли? Код без блоков:
```
- (void)removeAnimationView:(id)sender {
[animatingView removeFromSuperview];
}
- (void)viewDidAppear:(BOOL)animated
{
[super viewDidAppear:animated];
[UIView beginAnimations:@"Example" context:nil];
[UIView setAnimationDuration:5.0];
[UIView setAnimationDidStopSelector:@selector(removeAnimationView)];
[animatingView setAlpha:0];
[animatingView setCenter:CGPointMake(animatingView.center.x+50.0,
animatingView.center.y+50.0)];
[UIView commitAnimations];
}
```
Блочный метод:
```
- (void)viewDidAppear:(BOOL)animated
{
[super viewDidAppear:animated];
[UIView animateWithDuration:5.0
animations:^{
[animatingView setAlpha:0];
[animatingView setCenter:CGPointMake(animatingView.center.x+50.0,
animatingView.center.y+50.0)];
}
completion:^(BOOL finished) {
[animatingView removeFromSuperview];
}];
}
```
Если внимательно посмотреть на эти два метода, можно заметить три преимущества блочного метода:
* **Упрощает код**. С блоком нам не нужно определять абсолютно отдельный метод для завершения обратного вызова, или вызывать **beginAnimations**/**commitAnimations**.
* **Весь код лежит в одном месте**. С использованием блока не нужно начинать анимацию в одном месте, а метод обратного вызова — в другом. Весь код, связанный с анимацией, находится в одном месте, что облегчает его написание и чтение.
* **Так говорит Apple**. Apple переписали существующий функционал, не использовавший блоки, так что Apple официально рекомендует переходить к методам на основе блоков, если возможно.
### Когда использовать блоки?
Я считаю, лучший совет — использовать блоки там, где они нужны. Возможно, вы хотите продолжить использовать старые методы, чтобы сохранить обратную совместимость, или просто потому, что больше больше с ними знакомы. Но каждый раз, когда вы подходите к подобной точке принятия решения, подумайте, смогут ли блоки облегчить вам жизнь написание кода, и стоит ли использовать методы с блочным подходом.
Конечно, со временем вы возможно заметите, что стали все больше нуждаться в блоках просто потому, что большинство фреймворков написаны и переписаны с использованием блоков. Поэтому начните использовать блоки сейчас, чтобы встретиться с ними в будущем во всеоружии.
Возвращаясь к iOS Diner: настраиваем классы модели
--------------------------------------------------
Продолжим с того же места, на котором остановились [в первой части](https://habrahabr.ru/post/309780/). Если вы не читали первую часть, или просто хотите освежить все в памяти, можете скачать проект [здесь](http://www.raywenderlich.com/downloads/iOSDiner-Part1.zip).
Откройте проект в Xcode и переключитесь в **Project Navigator**. Щелкните правой кнопкой мыши по папке **iOSDiner** и выберите **New Group**. Назовем ее «Models».
Теперь правой кнопкой мыши кликаем по созданной папке **Models** и выбираем **New File → Objective-C класс** (или Cocoa Touch Class). Назовем его «IODItem» и в качестве родительского класса выберем **NSObject**.
Повторите вышеуказанные действия, чтобы создать класс **IODOrder**.
Теперь у нас есть все необходимые классы. Настало время кода.
Настройка IODItem
-----------------
Откройте **IODItem.h**. Прежде всего, в класс нужно добавить протокол **NSCopying**. Протоколы
являются неким «соглашением» о методах, которые класс будет реализовывать. Если в классе объявляется протокол, тогда в этом же классе необходимо определить обязательные, или опциональные методы, которые описаны в протоколе. Объявление протокола выглядит следующим образом:
```
@interface IODItem : NSObject
```
Далее, добавим свойства для объекта. У каждого объекта будет имя, цена и имя файла с изображением. **IODItem.h** будет выглядеть так:
```
#import
@interface IODItem : NSObject
@property (nonatomic,strong) NSString\* name;
@property (nonatomic,strong) float price;
@property (nonatomic,strong) NSString\* pictureFile;
@end
```
Теперь переключимся на **IODItem.m**. Тут мы видим предупреждение.
Это предупреждение относится к протоколу **NSCopying**, который мы добавили ранее. Помните, что протоколы могут описывать обязательные методы? Вот и **NSCopying** требует определить `— (id)copyWithZone:(NSZone *)zone`. Пока этот метод не будет добавлен, класс будет считаться незаконченным. Добавьте в **IODItem.m** перед **@end** следующее:
```
- (id)copyWithZone:(NSZone *)zone {
IODItem *newItem = [[IODItem alloc] init];
newItem.name = _name;
newItem.price = _price;
newItem.pictureFile = _pictureFile;
return newItem;
}
```
Вот и все, предупреждение исчезло. Этот код создает новый IODItem-объект, копирует свойства уже существующего объекта, и возвращает этот новый экземпляр.
Дополнительно необходим метод-инициализатор. Он позволяет легко и быстро выставить значения свойств по умолчанию, когда инициализируется объект. Напишите в **IODItem.m**:
```
- (id)initWithName:(NSString *)name
andPrice:(NSNumber *)price
andPictureFile:(NSString *)pictureFile {
if(self = [self init])
{
_name = name;
_price = price;
_pictureFile = pictureFile;
}
return self;
}
```
Вернитесь в **IODItem.h** и добавьте прототип метода перед окончанием файла (@end):
```
- (id)initWithName:(NSString*)inName andPrice:(float)inPrice andPictureFile:(NSString*)inPictureFile;
```
Настройка IODOrder
------------------
Далее, поработаем над другим классом — **IODOrder**. Этот класс будет представлять собой заказ и операции, с ним связанными, — добавление объекта, удаление, вычисление полной стоимости заказа и вывода содержания заказа на экран.
Откройте **IODOrder.h** и перед [interface](https://habrahabr.ru/users/interface/) добавьте импорт заголовочного файла:
```
#import "IODItem.h"
```
А под [interface](https://habrahabr.ru/users/interface/) пропишем свойство:
```
@property (nonatomic,strong) NSMutableDictionary* orderItems;
```
Это словарь, в котором будут храниться объекты, выбранные пользователем.
Настройка ViewController
------------------------
Переключимся в **ViewController.m**, добавим свойства:
```
#import "ViewController.h"
#import "IODOrder.h"
@interface ViewController ()
@property (assign, nonatomic) NSInteger currentItemIndex;
@property (strong, nonatomic) NSMutableArray *inventory;
@property (strong, nonatomic) IODOrder *order;
```
Свойство **currentItemIndex** будет запоминать индекс просматриваемого объекта в инвентаре (**inventory**). Смысл **inventory** легко объяснить — это массив IODItem-элементов, которые мы получим из веб-сервиса. **order** — объект класса **IODOrder**, который хранит объекты, выбранные пользователем.
Далее в методе **viewDidLoad** нужно обнулить **currentItemIndex** и **order**.
```
- (void)viewDidLoad {
[super viewDidLoad];
self.currentItemIndex = 0;
self.order = [[IODOrder alloc] init];
}
```
Теперь начало **ViewController.m** выглядит так:
```
#import "ViewController.h"
#import "IODOrder.h"
@interface ViewController ()
@property (assign, nonatomic) NSInteger currentItemIndex;
@property (strong, nonatomic) NSMutableArray *inventory;
@property (strong, nonatomic) IODOrder *order;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
self.currentItemIndex = 0;
self.order = [[IODOrder alloc] init];
}
```
Постройте проект. Никаких предупреждений быть не должно.
Загружаем инвентарь
-------------------
Метод класса **retrieveInventoryItems**, который мы сейчас добавим, будет загружать и обрабатывать инвентарь, загруженный с веб-сервиса.
**Примечание**. Методы класса начинаются с «+», а методы экземпляра класса — с «-».
В **IODItem.m** сразу после директив **#import** добавим следующее:
```
#define INVENTORY_ADDRESS @"http://adamburkepile.com/inventory/"
```
**Примечание**. Измените адрес, если веб-сервис вы размещали самостоятельно.
Далее добавим метод **retrieveInventoryItems**.
```
+ (NSArray *)retrieveInventoryItems {
// 1 — создаем переменные
NSMutableArray *inventory = [[NSMutableArray alloc] init];
NSError *error = nil;
// 2 — получаем данные об инвентаре
NSArray *jsonInventory = [NSJSONSerialization JSONObjectWithData:[NSData dataWithContentsOfURL:[NSURL URLWithString:INVENTORY_ADDRESS]]
options:kNilOptions
error:&error];
// 3 — смотрим все объекты инвентаря
[jsonInventory enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
NSDictionary *item = obj;
[inventory addObject:[[IODItem alloc] initWithName:item[@"Name"]
andPrice:item[@"Price"]
andPictureFile:item[@"Image"]]];
}];
// 4 — возвращаем копию инвентаря
return [inventory copy];
}
```
А вот и наш первый блок. Давайте подробнее пройдемся по коду.
1. Во-первых, мы объявили массив, в котором будем хранить объекты для возврата, и указатель на возможную ошибку.
2. Мы используем объект **NSData** для загрузки данных с веб-сервера, и затем передаем этот NSData-объект в **JSON**-сервис, чтобы декодировать исходные данные в Objective-C типы (NSArray, NSDictionary, NSString, NSNumber, и т. д.).
3. Далее нам необходим **enumerateObjectsUsingBlock:** метод, которые мы обсуждали ранее, для «конвертирования» объектов из **NSDictionary** в **IODItem**. Мы вызываем этот метод для массива **jsonInventory**, и перебираем его с помощью блока, который передает элемент массива как **NSDictionary** в метод инициализации IODItem-объекта. Затем он добавляет этот новый объект в возвращаемый массив.
4. В заключение, возвращается массив инвентаря **inventory**. Заметьте, что возвращаем копию массива, а не сам массив, потому что мы не хотим возвращать его изменяемую версию. Метод **copy** создает неизменяемую копию.
Теперь откроем **IODItem.h** и добавим прототип метода:
```
+ (NSArray*)retrieveInventoryItems;
```
Dispatch Queue и Grand Central Dispatch
---------------------------------------
Еще одна вещь, которую обязательно нужно знать, — это **dispatch queue** (очереди). Переключимся в **ViewController.m** и добавим свойство.
```
@property (strong, nonatomic) dispatch_queue_t queue;
```
В конце метода **ViewDidLoad** пропишем строку:
```
self.queue = dispatch_queue_create("com.adamburkepile.queue",nil);
```
Первый параметр метода **dispatch\_queue\_create** — это имя очереди. Можете назвать ее, как хотите, но это имя должно быть уникальным. Поэтому Apple рекомендует для этого имени обратный DNS-стиль.
Теперь давайте используем эту очередь. Пропишем во **viewDidAppear**:
```
self.ibChalkboardLabel.text = @"Loading inventory...";
self.inventory = [[IODItem retrieveInventoryItems] mutableCopy];
self.ibChalkboardLabel.text = @"Inventory Loaded\n\nHow can I help you?";
```
Запустите проект. Что-то не так, верно? Мы используем **retrieveInventoryItems** метод, который определили в **IODItem** для вызова веб-сервиса, возвращаем объекты инвентаря и помещаем их в массив.
Помните пятисекундную задержку в PHP-скрипте [из прошлой части](https://habrahabr.ru/post/309780/)? Но, когда мы запускаем программу, мы не видим «Loading inventory...», затем ждем пять секунд, и видим «Inventory Loaded».
Проблема вот в чем: вызов веб-сервиса блокирует и «замораживает» главную очередь, и не позволяет ей изменить текст лейбла. Если бы только у нас была отдельная очередь, которую можно было бы использовать для подобных операций, не обращаяся к главной очереди… Стоп! У нас она уже есть. Вот где **Grand Central Dispatch** и блоки могут нам помочь довольно легко. С **Grand Central Dispatch** мы можем поместить обработку данных в другую очередь, не блокируя главную. Заменим две последние строки во **viewDidAppear** на следующее:
```
dispatch_async(self.queue, ^{
self.inventory = [[IODItem retrieveInventoryItems] mutableCopy];
dispatch_async(dispatch_get_main_queue(), ^{
self.ibChalkboardLabel.text = @"Inventory Loaded\n\nHow can I help you?";
});
});
```
Заметьте, что здесь мы используем два разных блока, которые ничего не возвращают и не имеют параметров.
Снова запустите проект. Вот теперь работает, как надо.
Вы не задавались вопросом, зачем мы вызываем **dispatch\_async** для присвоения текста лейблу? Когда вы ставите текст в лейбл, вы обновляете элемент UI, а все, что относится к UI, должно обрабатываться в главной очереди. Поэтому мы еще раз вызываем **dispatch\_async**, но только берем главную очередь и выполняем блок в ней.
Данный метод довольно распространен, когда операция занимает много времени и необходимо обновление UI-элементов.
**Grand Central Dispatch** — довольно сложная система, роль которой невозможно понять в этом простом уроке. Если вы заинтересованы, почитайте [Multithreading and Grand Central Dispatch on iOS for Beginners](http://www.raywenderlich.com/4295/multithreading-and-grand-central-dispatch-on-ios-for-beginners-tutorial)).
Дополнительные методы
---------------------
Мы используем веб-сервис для загрузки и хранения инвентаря. Теперь нам нужны три метода-помощника, которые будут отображать хранимый инвентарь пользователю.
Первый метод, **findKeyForOrderItem:**, мы добавим в **IODOrder.m**. Он будет полезен для доступа к объекту из словаря.
```
- (IODItem *)findKeyForOrderItem:(IODItem *)searchItem {
//1 - находим соответствующий индекс объекта
NSIndexSet *indexes = [[self.orderItems allKeys] indexesOfObjectsPassingTest:^BOOL(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
IODItem *key = obj;
return ([searchItem.name isEqualToString:key.name] && searchItem.price == key.price);
}];
//2 - возвращаем первый совпавший объект
if([indexes count] >=1) {
IODItem *key = [self.orderItems allKeys][[indexes firstIndex]];
return key;
}
//3 - если ничего не нашли
return nil;
}
```
Давайте разберемся, что этот метод делает. Но прежде чем сделать это, я должен объяснить, почему он вообще нужен. Объект **IODOrder** содержит словарь **orderItems** (пары ключ-значение). Ключом будет **IODItem**, а значением — **NSNumber**, которое показывает, сколько таких **IODItem** было заказано.
В теории все хорошо, но своеобразной причудой класса **NSDictionary** является то, что когда вы хотите назначить объект в качестве ключа, он не присваивает этот объект, а создает его копию и использует в качестве ключа. Это означает, что объект, который вы используете как ключ, должен соответствовать протоколу **NSCopying** (вот поэтому мы в **IODItem** объявляли протокол **NSCopying**).
Ключ в словаре **orderItems** и **IODItem** в массиве **inventory** не являются одним и тем же объектом (хотя и имеют одинаковые свойства), поэтому простой поиск по ключу мы сделать не можем. Вместо этого нам придется сравнивать имя и цену каждого объекта, чтобы определить их совпадение. Это и делает вышеуказанный метод: сравнивает свойства ключей, чтобы найти нужный.
А вот что делает код:
1. Мы перебираем ключи словаря **orderItems**, используя метод **indexesOfObjectsPassingTest:** для нахождения совпадений имени и цены, — еще один пример блока. Обратите внимание на **BOOL** после ^. Это тип возвращаемого значения. Данный метод обрабатывает массив, используя блок для сравнения двух объектов, возвращает индексы всех объектов, которые проходят тест, описанный в блоке.
2. Здесь мы берем первый индекс из возвращенных
3. 3. Возвращаем nil, если совпадающий ключ не был найден.
Не забудьте добавить прототип метода в IODOrder.h.
```
- (IODItem*)findKeyForOrderItem:(IODItem*)searchItem;
```
Переходм в **ViewController.m** и добавляем следующий метод:
```
- (void)updateCurrentInventoryItem {
if (self.currentItemIndex >=0 && self.currentItemIndex < [self.inventory count]) {
IODItem* currentItem = self.inventory[self.currentItemIndex];
self.ibCurrentItemLabel.text = currentItem.name;
self.ibCurrentItemLabel.adjustsFontSizeToFitWidth = YES;
self.ibCurrentItemImageView.image = [UIImage imageNamed:[currentItem pictureFile]];
}
}
```
Используя **currentItemIndex** и массив **inventory**, этот метод отображает имя и картинку для каждого объекта инвентаря.
Прописываем еще один метод:
```
- (void)updateInventoryButtons {
if (!self.inventory || ![self.inventory count]) {
self.ibAddItemButton.enabled = NO;
self.ibRemoveItemButton.enabled = NO;
self.ibNextItemButton.enabled = NO;
self.ibPreviousItemButton.enabled = NO;
self.ibTotalOrderButton.enabled = NO;
} else {
if (self.currentItemIndex <= 0) {
self.ibPreviousItemButton.enabled = NO;
} else {
self.ibPreviousItemButton.enabled = YES;
}
if (self.currentItemIndex >= [self.inventory count]-1) {
self.ibNextItemButton.enabled = NO;
} else {
self.ibNextItemButton.enabled = YES;
}
IODItem* currentItem = self.inventory[self.currentItemIndex];
if (currentItem) {
self.ibAddItemButton.enabled = YES;
} else {
self.ibAddItemButton.enabled = NO;
}
if (![self.order findKeyForOrderItem:currentItem]) {
self.ibRemoveItemButton.enabled = NO;
} else {
self.ibRemoveItemButton.enabled = YES;
}
if (![self.order.orderItems count]) {
self.ibTotalOrderButton.enabled = NO;
} else {
self.ibTotalOrderButton.enabled = YES;
}
}
}
```
Этот метод — самый длинный метод из трех методов-помощников, но довольно простой. Он проверяет состояния программы и определяет, делать ли активной ту или иную кнопку.
Например, если **currentItemIndex** равен нулю, **ibPreviousItemButton** не должна быть активной, потому как нет элементов раньше первого. Если в **orderItems** нет элементов, значит и кнопка **ibTotalOrderButton** не должна быть активной, потому что еще нет заказа, для которого можно было бы посчитать сумму.
Итак, с этими тремя методами теперь можно творить магию. Вернемся в **viewDidAppear** во **ViewController.m** и добавим в самом начале:
```
[self updateInventoryButtons];
```
Затем, замените блок на этот:
```
dispatch_async(queue, ^{
self.inventory = [[IODItem retrieveInventoryItems] mutableCopy];
dispatch_async(dispatch_get_main_queue(), ^{
[self updateInventoryButtons];
[self updateCurrentInventoryItem];
self.ibChalkboardLabel.text = @"Inventory Loaded\n\nHow can I help you?";
});
});
```
Постройте и запустите.
О, а вот и гамбургер. Но мы хотим увидеть и остальную еду, так что давайте заставим кнопки работать.
Методы **ibaLoadNextItem:** и **ibaLoadPreviousItem:** у нас уже есть вo **ViewController.m**. Добавим немного кода.
```
- (IBAction)ibaLoadPreviousItem:(UIButton *)sender {
self.currentItemIndex--;
[self updateCurrentInventoryItem];
[self updateInventoryButtons];
}
- (IBAction)ibaLoadNextItem:(UIButton *)sender {
self.currentItemIndex++;
[self updateCurrentInventoryItem];
[self updateInventoryButtons];
}
```
Благодаря тем методам-помощникам переключение между объектами с изменением **currentItemIndex** и обновлением UI стало очень простым. Скомпилируйте и запустите. Теперь можно увидеть все меню.
Делаем удаление и добавление объекта
------------------------------------
У нас есть меню, но нет официанта, чтобы принимать заказ. Другими словами, кнопки добавления и удаления не работают. Что ж, время настало.
Нужен еще один метод-помощник в классе **IODOrder**. В I**ODOrder.m** пишем следующее:
```
- (NSMutableDictionary *)orderItems{
if (!_orderItems) {
_orderItems = [[NSMutableDictionary alloc] init];
}
return _orderItems;
}
```
Это простой getter-метод для свойства **orderItems**. Если в **orderItems** уже что-то есть, метод вернет объект. А если нет — создаст новый словарь и присвоит его **orderItems**, а потом вернет.
Далее поработаем над методом **orderDescription**. Этот метод даст нам строк для вывода на меловую доску. В **IODOrder.m** пишем:
```
- (NSString*)orderDescription {
// 1 - Создаем строку
NSMutableString* orderDescription = [[NSMutableString alloc] init];
// 2 - Сортируем объекты по имени
NSArray* keys = [[self.orderItems allKeys] sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {
IODItem* item1 = (IODItem*)obj1;
IODItem* item2 = (IODItem*)obj2;
return [item1.name compare:item2.name];
}];
// 3 - перебираем объекты и добавляем имя и количество в строку
[keys enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
IODItem* item = (IODItem*)obj;
NSNumber* quantity = (NSNumber*)[self.orderItems objectForKey:item];
[orderDescription appendFormat:@"%@ x%@\n", item.name, quantity];
}];
// 4 - возвращаем строку с описанием заказа
return [orderDescription copy];
}
```
Немного пояснений:
1. Это строка для описания заказа. Каждый объект заказа будет в нее добавляться.
2. Этот кусочек кода берет массив из ключей словаря orderItems и использует блок **sortedArrayUsingComparator:** для сортировки ключей по имени.
3. Этот код использует уже отсортированный массив ключей и вызывает уже знакомый **enumerateObjectsUsingBlock:**. Каждый ключ преобразуем в **IODItem**, получаем значение (количество), и добавляем строку в **orderDescription**.
4. Наконец, возвращаем строку **orderDescription**, но снова только ее копию.
Идем в **IODOrder.h** и добавляем прототипы этих двух методов.
```
- (void)updateCurrentInventoryItem;
- (void)updateInventoryButtons;
```
Теперь, когда мы можем получить строку описания заказа из объекта, переключаемся в **ViewController.m** и добавляем метод для вызова.
```
- (void)updateOrderBoard {
if (![self.order.orderItems count]) {
self.ibChalkboardLabel.text = @"No Items. Please order something!";
} else {
self.ibChalkboardLabel.text = [self.order orderDescription];
}
}
```
Этот метод проверяет количество объектов в заказе. Если их нет, возвращается строка «No Items. Please order something!». Если иначе, метод использует **orderDescription** метод из класса **IODOrder** для отображения строки с описанием заказа.
Теперь мы можем обновлять доску в соответствии с текущим заказом. Обновляем наш блок из **viewDidAppear**:
```
dispatch_async(self.queue, ^{
self.inventory = [[IODItem retrieveInventoryItems] mutableCopy];
dispatch_async(dispatch_get_main_queue(), ^{
[self updateOrderBoard]; //<----Добавить эту строку
[self updateInventoryButtons];
[self updateCurrentInventoryItem];
self.ibChalkboardLabel.text = @"Inventory Loaded\n\nHow can I help you?";
});
});
```
Я понимаю, что это может казаться бессмысленным, так как пару строчек ниже мы просто переписали исходный текст, но ради аккуратности это можно сделать.
Следующий метод будет добавлять объект в заказ. Идем в **IODOrder.m**.
```
- (void)addItemToOrder:(IODItem*)inItem {
// 1 - ищем объект в заказе
IODItem* key = [self findKeyForOrderItem:inItem];
// 2 - если объект не существует - добавляем
if (!key) {
[self.orderItems setObject:[NSNumber numberWithInt:1] forKey:inItem];
} else {
// 3 - если существует - обновляем количество
NSNumber* quantity = self.orderItems[key];
int intQuantity = [quantity intValue];
intQuantity++;
// 4 - Обновляем заказ с новым количеством
[self.orderItems removeObjectForKey:key];
[self.orderItems setObject:[NSNumber numberWithInt:intQuantity] forKey:key];
}
}
```
Поясняю:
1. Используем ранее добавленный метод для поиска ключа для **orderItem**. Не забудьте, что, если объект не найден, он просто вернет **nil**.
2. Если объект не был найден в заказе, добавляем его в количестве, равным 1.
3. Если же объект был найден, смотрим на его количество и увеличиваем его на 1.
4. Наконец, удаляем исходную запись и записываем новую версию с обновленным количеством.
Метод **removeItemFromOrder:** почти такой же, как и **addItemToOrder:**. В **IODOrder.m** пишем:
```
- (void)removeItemFromOrder:(IODItem*)inItem {
// 1 - ищем объект в заказе
IODItem* key = [self findKeyForOrderItem:inItem];
// 2 - удаляем объект, только если он существует
if (key) {
// 3 - берем количество, и уменьшаем на единицу
NSNumber* quantity = self.orderItems[key];
int intQuantity = [quantity intValue];
intQuantity--;
// 4 - удаляем объект
[[self orderItems] removeObjectForKey:key];
// 5 - добавляем новый объект с обновленным количеством только если количество больше 0
if (intQuantity)
[[self orderItems] setObject:[NSNumber numberWithInt:intQuantity] forKey:key];
}
}
```
Заметьте, что при удалении объекта из заказа нам нужно что-то делать, только если объект найден в заказе. Если он найден, мы смотрим его количество, уменьшаем на 1, удаляем объект из словаря и вставляем туда новый объект, если количество больше 0.
Идем в **IODOrder.h** и добавляем прототипы:
```
- (void)addItemToOrder:(IODItem*)inItem;
- (void)removeItemFromOrder:(IODItem*)inItem;
```
Теперь во ViewController.m можно прописать код для кнопок удаления и добавления объектов:
```
- (IBAction)ibaRemoveItem:(UIButton *)sender {
IODItem* currentItem = self.inventory[self.currentItemIndex];
[self.order removeItemFromOrder:currentItem];
[self updateOrderBoard];
[self updateCurrentInventoryItem];
[self updateInventoryButtons];
}
- (IBAction)ibaAddItem:(UIButton *)sender {
IODItem* currentItem = self.inventory[self.currentItemIndex];
[self.order addItemToOrder:currentItem];
[self updateOrderBoard];
[self updateCurrentInventoryItem];
[self updateInventoryButtons];
}
```
Все, что нам нужно сделать в обоих методах — получить текущий объект из массива инвентаря, передать его в **addItemToOrder:** или **removeItemFromOrder:**, и обновить UI.
Соберите и постройте проект. Теперь объекты можно добавлять и удалять, и доска обновляется.
UIAnimation
-----------
Давайте немного оживим нашу программу. Измените **ibaRemoveItem:** и **ibaAddItemMethod:**
```
- (IBAction)ibaRemoveItem:(UIButton *)sender {
IODItem* currentItem = [self.inventory objectAtIndex:self.currentItemIndex];
[self.order removeItemFromOrder:currentItem];
[self updateOrderBoard];
[self updateCurrentInventoryItem];
[self updateInventoryButtons];
UILabel* removeItemDisplay = [[UILabel alloc] initWithFrame:self.ibCurrentItemImageView.frame];
removeItemDisplay.center = self.ibChalkboardLabel.center;
removeItemDisplay.text = @"-1";
removeItemDisplay.textAlignment = NSTextAlignmentCenter;
removeItemDisplay.textColor = [UIColor redColor];
removeItemDisplay.backgroundColor = [UIColor clearColor];
removeItemDisplay.font = [UIFont boldSystemFontOfSize:32.0];
[[self view] addSubview:removeItemDisplay];
[UIView animateWithDuration:1.0
animations:^{
removeItemDisplay.center = [self.ibCurrentItemImageView center];
removeItemDisplay.alpha = 0.0;
}
completion:^(BOOL finished) {
[removeItemDisplay removeFromSuperview];
}];
}
- (IBAction)ibaAddItem:(UIButton *)sender {
IODItem* currentItem = [self.inventory objectAtIndex:self.currentItemIndex];
[self.order addItemToOrder:currentItem];
[self updateOrderBoard];
[self updateCurrentInventoryItem];
[self updateInventoryButtons];
UILabel* addItemDisplay = [[UILabel alloc] initWithFrame:self.ibCurrentItemImageView.frame];
addItemDisplay.text = @"+1";
addItemDisplay.textColor = [UIColor whiteColor];
addItemDisplay.backgroundColor = [UIColor clearColor];
addItemDisplay.textAlignment = NSTextAlignmentCenter;
addItemDisplay.font = [UIFont boldSystemFontOfSize:32.0];
[[self view] addSubview:addItemDisplay];
[UIView animateWithDuration:1.0
animations:^{
[addItemDisplay setCenter:self.ibChalkboardLabel.center];
[addItemDisplay setAlpha:0.0];
}
completion:^(BOOL finished) {
[addItemDisplay removeFromSuperview];
}];
}
```
Кода много, но он простой. Первая часть создает UILabel и выставляет его свойства. Вторая — анимация, которая перемещает созданный лейбл. Это и есть пример UIView-анимации с блоком, который мы описывали в начале урока.
Запустите проект. Теперь можно увидеть анимацию при нажатии на кнопки добавления и удаления объекта.
Получение суммы (Total)
-----------------------
Последний метод, который нам потребуется добавить в **IODOrder.m** — метод подсчета суммы заказа.
```
- (float)totalOrder {
// 1 - Объявляем и инициализируем переменную для суммы
__block float total = 0.0;
// 2 - Блок для полсчета
float (^itemTotal)(float,int) = ^float(float price, int quantity) {
return price * quantity;
};
// 3 - Перебираем объекты и суммируем стоимость каждого
[self.orderItems enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
IODItem* item = (IODItem*)key;
NSNumber* quantity = (NSNumber*)obj;
int intQuantity = [quantity intValue];
total += itemTotal([item.price floatValue], intQuantity);
}];
// 4 - Возвращаем сумму
return total;
}
```
Пройдемся по коду:
1. Объявляем и инициализируем переменную, которая будет хранить сумму. Обратите внимание на **\_\_block**. Мы будем использовать эту переменную внутри блока. Если мы не напишем **\_\_block**, блок, который мы создали ниже, создаст константную копию этой переменной и использует ее внутри себя. Это означает, что мы не сможем изменить ее внутри блока. Путем добавления этого ключевого слова мы можем читать И менять значение переменной внутри блока.
2. Теперь мы определяем блок, который просто берет цену и количество, и возвращает стоимость объекта.
3. Этот кусок кода через блок **enumerateKeysAndObjectsUsingBlock:** перебирает все объекты в словаре **orderItems** и использует предыдущий блок для нахождения суммы каждого объекта, затем добавляет это значения в сумму всего заказа (именно поэтому нам нужно ключевое слово **\_\_block** для переменной заказа — мы меняем ее внутри блока).
4. Возвращаем общую сумму заказа.
Возвращаемся в **IODOrder.h** и добавляем прототип.
```
- (float)totalOrder;
```
Последнее, что осталось сделать — добавить подсчет суммы в приложение. Вся грязная работа будет сделана методом **totalOrder**, нам останется только показать сумму пользователю по нажатию кнопки **Total**. Заполним метод **ibaCalculateTotal**:
```
- (IBAction)ibaCalculateTotal:(UIButton *)sender {
float total = [self.order totalOrder];
UIAlertController *alert = [UIAlertController
alertControllerWithTitle:@"Total"
message:[NSString stringWithFormat:@"$%0.2f",total]
preferredStyle:UIAlertControllerStyleAlert];
UIAlertAction *cancelButton = [UIAlertAction
actionWithTitle:@"Close"
style:UIAlertActionStyleDefault
handler:^(UIAlertAction * action) {
[alert dismissViewControllerAnimated:YES completion:nil];
}];
[alert addAction:cancelButton];
[self presentViewController:alert animated:YES completion:nil];
}
```
Тут мы считаем сумму заказа и выводим его на экран.
Вот и все! Запустите проект.
Шпаргалка по блокам
-------------------
Прежде чем закончить, приведу список блоков, которые могут пригодиться.
### NSArray
* [enumerateObjectsUsingBlock](https://developer.apple.com/library/ios/documentation/Cocoa/Reference/Foundation/Classes/NSArray_Class/index.html#//apple_ref/occ/instm/NSArray/enumerateObjectsUsingBlock:) — возможно, наиболее часто используемый мною блок для перебора объектов.
* [enumerateObjectsAtIndexes:usingBlock:](https://developer.apple.com/library/ios/documentation/Cocoa/Reference/Foundation/Classes/NSArray_Class/index.html#//apple_ref/occ/instm/NSArray/enumerateObjectsUsingBlock:) — такой же, как и **enumerateObjectsUsingBlock**, только можно перебирать объекты в определенном промежутке.
* [indexesOfObjectsPassingTest:](https://developer.apple.com/library/ios/documentation/Cocoa/Reference/Foundation/Classes/NSArray_Class/index.html#//apple_ref/occ/instm/NSArray/indexesOfObjectsPassingTest:) — блок возвращает множество индексов объектов, которые проходят тест, описываемый блоком. Полезно для поиска определенной группы объектов.
### NSDictionary
* [enumerateKeysAndObjectsUsingBlock:](https://developer.apple.com/library/ios/documentation/Cocoa/Reference/Foundation/Classes/NSDictionary_Class/index.html#//apple_ref/occ/instm/NSDictionary/enumerateKeysAndObjectsUsingBlock:) — перебирает элементы словаря.
* [keysOfEntriesPassingTest:](https://developer.apple.com/library/ios/documentation/Cocoa/Reference/Foundation/Classes/NSDictionary_Class/index.html#//apple_ref/occ/instm/NSDictionary/keysOfEntriesPassingTest:) — возвращает множество ключей, объекты которых прохожят тест, описываемый блоком.
### UIView
* [animateWithDuration:animations:](https://developer.apple.com/library/ios/documentation/UIKit/Reference/UIView_Class/index.html#//apple_ref/occ/clm/UIView/animateWithDuration:animations:) — блок для UIAnimation, полезно для простых анимаций.
* [animateWithDuration:completion:](https://developer.apple.com/library/ios/documentation/UIKit/Reference/UIView_Class/index.html#//apple_ref/occ/clm/UIView/animateWithDuration:animations:completion:) — другой блок UIAnimation. Содержит второй блок для вызова кода по окончании анимации.
### Grand Central Dispatch
* [dispatch\_async](https://developer.apple.com/library/ios/documentation/Performance/Reference/GCD_libdispatch_Ref/index.html#//apple_ref/c/func/dispatch_async) — главная функция для асинхронного GCD кода.
Создаем свои собственные блоки
------------------------------
Ниже приведены образцы кода для создания нестандартных блоков.
```
// Некоторый метод, который принимает блок
- (void)doMathWithBlock:(int (^)(int, int))mathBlock {
self.label.text = [NSString stringWithFormat:@"%d", mathBlock(3, 5)];
}
// вызываем метод с блоком
- (IBAction)buttonTapped:(id)sender {
[self doMathWithBlock:^(int a, int b) {
return a + b;
}];
}
```
Так как блок — это объект Objective-C, его можно хранить в свойстве для вызова в будущем. Это удобно, когда вы хотите вызвать метод после завершения некоторой асинхронной задачи (связанной с сетью, например).
```
// объявляем свойство
@property (strong) int (^mathBlock)(int, int);
// храним блок для вызова в дальнейшем
- (void)doMathWithBlock:(int (^)(int, int))mathBlock {
self.mathBlock = mathBlock;
}
// Вызываем метод с блоком
- (IBAction)buttonTapped:(id)sender {
[self doMathWithBlock:^(int a, int b) {
return a + b;
}];
}
// Позже...
- (IBAction)button2Tapped:(id)sender {
self.label.text = [NSString stringWithFormat:@"%d", self.mathBlock(3, 5)];
}
}
```
Наконец, можно упростить код, используя **typedef**.
```
//typedef для блока
typedef int (^MathBlock)(int, int);
// Создаем свойство, используя typedef
@property (strong) MathBlock mathBlock;
// Метод для хранения блока
- (void)doMathWithBlock:(MathBlock) mathBlock {
self.mathBlock = mathBlock;
}
// Вызываем метод с блоком
- (IBAction)buttonTapped:(id)sender {
[self doMathWithBlock:^(int a, int b) {
return a + b;
}];
}
// Позже...
- (IBAction)button2Tapped:(id)sender {
self.label.text = [NSString stringWithFormat:@"%d", self.mathBlock(3, 5)];
}
```
Блоки и автозавершение
----------------------
Последний совет. Когда вы используете метод, который принимает блок, Xcode может автозавершить блок за вас, позволяя сэкономить время и предотвратить возможные ошибки.
Например, введите:
```
NSArray * array;
[array enum
```
одпрограмма автозаполнения найдет **enumerateObjectsUsingBlock** — нажмите **Enter** для автозавершения. Затем нажмите **Enter** снова для автозавершения блока. Получится вот что:
```
[array enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
code
}
```
Можно написать свой код вместо **code**, закрыть вызов метода, и вуаля — намного проще, чем набирать все вручную.
```
[array enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
// Do something
}];
```
Куда идти дальше?
-----------------
Код проекта можно скачать [здесь](http://www.raywenderlich.com/downloads/iOSDiner-Part2.zip). Если вы знакомы с git, можете взять проект [отсюда](https://github.com/acburk/iOSDiner) с коммитами на каждом шаге. Надеюсь, в процессе создания этого простого приложения вы смогли почувствовать всю простоту и мощь блоков, и набрались некоторых идей для их использования в своих проектах.
Если это было ваше знакомство с блоками — вы сделали огромный шаг. Блоки нужно изучать для работы с многопоточностью, сетью и многим другим.
Больше информации о блоках можно найти здесь:
1. [Apple: Getting Started With Blocks](http://developer.apple.com/library/IOS/#documentation/Cocoa/Conceptual/Blocks/Articles/bxGettingStarted.html)
2. [Apple: Concurrency Programming](https://developer.apple.com/library/ios/documentation/General/Conceptual/ConcurrencyProgrammingGuide/Introduction/Introduction.html)
3. [GCD Tutorial](https://www.raywenderlich.com/4295/multithreading-and-grand-central-dispatch-on-ios-for-beginners-tutorial))
|
https://habr.com/ru/post/309846/
| null |
ru
| null |
# SSH-аутентификация при помощи USB-ключа eToken Pro
В этой заметке я расскажу вам, как настроить SSH-аутентификацию при помощи USB-ключа eToken.
Для этого нам понадобятся:
— Собственно сам USB-ключ eToken Pro (в моем случае это eToken Pro 64k)
— Операционная система Windows с установленными драйверами [eToken PKI Client](http://www.aladdin.ru/support/download/category177)
— Mozilla Firefox с установленным плагином [Key Manager](https://addons.mozilla.org/ru/firefox/addon/4471)
— SSH-клиент с поддержкой смарт-карт. Лично мне нравится [PuTTY SC](http://www.joebar.ch/puttysc/) — модифицированная версия PuTTY.
Предполагается, что у вас уже есть инициализированный USB-ключ с установленным пин-кодом, он подключен к компьютеру и готов к работе.
**Создание открытого/закрытого ключа.**
1) Запускаем Firefox и открываем Key Manager (Инструменты -> Key Manager Tool Box -> Key Manager)
2) Вводим пользовательский пароль для eToken
3) В главном меню Key Manager выбираем «Generate Self-Signed Cert»
4) Заполняем поля как показано на рисунке и нажимаем «Generate Self-Signed Cert». Естественно вам необходимо ввести свои данные, такие как город, страна, и fqdn сервера. Также по желанию можно указать дополнительные свойства сертификата — срок действия и т.д.
5) Выберите нужный токен из списка и нажмите «ОК». Обратите внимание, что если вы генерируете сертификат сразу на токене то экспортировать **закрытый** ключ потом будет невозможно.
6) В главном меню Key Manager выделите только что созданный сертификат, и нажмите кнопку «Export»
7) В появившемся окне выберите формат «OpenSSH Pubkey» и нажмите кнопку «ОК»
В результате получим строку вроде нижеприведенной. Это и есть наш публичный ключ — сохраните его, он нам понадобится на следующем этапе.
`ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDL9ViU3+/80xZka0G91eoDyNuPT4eb1/8ro0iZEBnRI7+B+LwJbWrvqfJxNQluMiGPhftBCao4VjCcby21g0q+1sp42MR1bPD8BgA42ZDuum/sq5gFEM16n+g8+bXxtoZ/kF2bPJ4fGsowmdQCc8I7xECcYazz2AG8oZqU9l0anw==`
**Настройка аутентификации по ключу на сервере.**
В качестве сервера в моем случае выступает машина с установленным Debian Lenny.
Вам необходимо убедиться что в конфигурации **sshd** разрешена аутентификация при помощи публичных ключей. Для этого необходимо в файле **«sshd\_config»** указать значение параметра **«PubkeyAuthentication»** в **«yes»**.
Затем в файл **"~/.ssh/authorized\_keys"** добавляем наш публичный ключ полученный ранее (одной строкой). Обратите внимание, файл **".ssh/authorized\_keys"** находится в домашнем каталоге того пользователя, который потом будет логиниться по публичному ключу.
**Настройка SSH-клиента PuTTY SC на использование смарт-карт.**
PuTTY SC — это модифицированная версия PuTTY. Единственное значительное отличие от оригинальной версии — поддержка смарт-карт.
Настройка в данном случае почти ничем не отличается от обычных соединений — нужно указать адрес сервера, тип подключения, тип клавиатуры, кодировку.
Для использования аутентификации при помощи смарт-карты зайдите в раздел **«Connection -> SSH -> Pkcs11»**, отметьте галочку **«Attempt PKCS#11 smartcard auth (SSH-2)»**, укажите путь к библиотеке eToken — **«C:\Windows\System32\eToken.dll»**, выберите в списке название токена и закрытый ключ, который мы создали ранее.
При подключении вас попросят ввести пользовательский пин-код к USB-ключу.
Поздравляю, теперь вы можете использовать SSH-аутентификацию при помощи eToken Pro!
*Примечание: несомненно, генерировать ключи можно различными способами, используя различное ПО и различные операционные системы. Связка Windows+Firefox была выбрана как наиболее простая и понятная.*
*Еще примечание: по вкусу можно отключить на сервере другие методы аутентификации, оставив только аутентификацию по ключу.*
|
https://habr.com/ru/post/88540/
| null |
ru
| null |
# ТРИЗ, Haskell и функциональное мышление
При слове ТРИЗ, часто вспоминают тезис "идеальная система — та, которой нет (а ее функция при этом выполняется)". Как хороший админ, который не появляется в офисе, а все при этом исправно работает.
Функция и система — критически важные понятия в ТРИЗ, говорят даже о функциональном стиле мышления. Правда при этих словах лично у меня сразу возникает ассоциация с функциональными языками программирования.
Попробуем посмотреть, насколько органично идеи функционального мышления ТРИЗ отображаются на Haskell, одном чистых функциональных языков общего назначения.
### Функция
**Функция** — модель **изменения** свойства объекта функции ("изделия") носителем функции ("инструментом").
*Инструмент* — то, с помощью чего мы совершаем некую работу, т.е. что-то меняем. Как правило именно его требуется усовершенствовать или создать. Соответственно именно носитель функции обычно подразумевается под словом "система" во всех ТРИЗовских рассуждениях про оную.
*Изделие* — то, что мы изменяем (обрабатываем) при помощи инструмента.
Главная функция — потребительское свойство, ради удовлетворения которого создается техническая система.
Сама функция задается обычно простым глаголом, отражающим суть процесса (не специальным термином, чтобы не мешала инерция мышления), в формулировку включают носитель и объект функции.
Например: молоток перемещает гвоздь; метла перемещает мусор; кружка удерживает кофе; пылесос перемещает пыль; топливо перемещает ракету.
Рассмотрим, в частности, чашку с кофе.
Чашка удерживает кофе.
Носитель функции (инструмент) — чашка, объект функции — кофе, функция — удерживать.
```
-- Задаем типы входных данных и результата выполнения
-- Предположим, типы данных Чашки и Кофе уже где-то заданы
hold :: Cup -> Coffee -> Coffee
-- вызываем функцию hold - "удержать" с параметрами в виде конкретных чашки и кофе
cup `hold` coffee
```
Функция hold должна быть полиморфна, поскольку чашка может удерживать не только кофе и кофе можно налить не только в чашку:
```
-- На входе пара сущностей типа а и b, на выходе измененная сущность типа b
hold :: a -> b -> b
-- что будет, если налить кофе в термос
thermos `hold` coffee
-- что будет, если пролить кофе на рубашку
shirt `hold` coffee
```
Инструмент и изделие могут изменяться, а суть их взаимодействия, выраженная функцией, остается прежней. По статистике большинство парных функций между элементами технических систем можно описать тремя десятками глаголов (перемещать, удерживать, нагревать, поглощать, информировать и пр.). Каждый из них с точки зрения Haskell-реализации представляет собой полиморфную функцию. Как, впрочем, и остальные глаголы естественного языка.
### Обратная функция
В реальном мире всегда есть и обратная функция — действие изделия на инструмент (третий закон Ньютона никто не отменял).
Например, обрабатываемый металл затупляет сверло, нерадивый ученик утомляет преподавателя, файл уменьшает свободное место на диске.
В примере с кофе он нагревает и пачкает чашку.
Как правило обратная функция нам вредит (износ инструмента, доп.затраты), однако в иных ситуациях мы можем извлечь из нее пользу. Например, погреть руки о теплую чашку, будучи в прохладном помещении.
```
hold:: a -> b -> b
warm :: a -> b -> b
cup `hold` coffee
coffee `warm` cup
```
### Цепочки функций
В случае, когда число элементов системы больше двух (т.е., фактически, всегда) их рассматривают попарно, получая цепочки функций.
Например, на рисунке ниже рука несет (перемещает) поднос с чашкой, поднос удерживает чашку, чашка удерживает кофе.
```
((arm `move` wrist) `hold` cup) `hold` coffee
```
Избавимся от скобок, задав левую ассоциативность
```
infixl 9 hold
arm `move` wrist `hold` cup `hold` coffee
```
Запись на Haskell очень близка к записи на естественном языке.
И цепочка в обратную сторону: кофе нагревает чашку, чашка нагревает блюдце, блюдце нагружает руку.
```
infixl 9 warm, weight
coffee `warm` cup `warm` wrist `weight` arm
```
Понимание главной функции и взаимодействий между элементами позволяет оптимально выбрать границы системы, включить лишь то, что нужно для выполнения целевой задачи (ничего не упустив) и не усложнять модель сверх необходимого.
### Система, которой нет ...
Нам нужна функция, точнее результат ее применения, а инструмент сам по себе не нужен. Это расходный материал, привлекаемый лишь в силу необходимости.
Удерживать кофе может джезва, чайник, термос, блюдце и стол и рубашка (если кофе неосторожно пролили).
Мы даже были бы не против, если кофе **САМ** себя удерживал. Как это происходит, например, с водой в невесомости на космической станции.
Однако на зацикленных формулировках вроде "кофе удерживает кофе" в ТРИЗ останавливаться не принято, поскольку она бесполезна с практической точки зрения — не дает информации об элементах, за счет которых достигается результат.
С точки зрения программирования такая рекурсивная формулировка плоха тем, что здесь нет условия окончания рекурсии.
Нужно уйти в глубину и указать какие именно части (подсистемы) обеспечивают выполнение функции.
Жидкость принимает в невесомости компактную форму за счет сил поверхностного натяжения. Т.о. более подходящим описанием ситуации будет: поверхностный слой удерживает внутренний объем кофе.
Можно представить весь объем кофе как матрешку слоев, каждый из которых удерживает друг друга. При этом основную работу делает внешний слой.
```
-- Пусть первый слой - поверхностный, пятый - самый глубокий
let coffee = [layer1, layer2, layer3, layer4, layer5]
head coffee `hold` tail coffee
```
Впрочем, если нам важно влияние слоев друг на друга (например, в плане поглощения света),
можно изобрести велосипед и описать последовательные взаимодействия явно.
Рекурсивная природа явления сохраниться, но за счет понимания взаимосвязей подсистем мы сможем задать условия выхода из рекурсии и обратить ее себе на службу.
```
-- Функция "удерживать", которая выводит свою полную формулировку
hold :: String -> String -> String
hold tool "" = tool
hold tool workpiece = tool ++ " -> holds -> " ++ workpiece
-- Функция "удерживать себя".
-- Принимает на вход нарезанный слоями объект и
-- последовательно вызывает обычную функцию "удержать"
-- для каждого слоя и оствшегося объема
selfHold :: [String] -> String
selfHold [] = ""
selfHold (x:xs) = x `hold` selfHold xs
-- запускаем самоудержание трехслойного объекта
selfHold ["Layer1","Layer2","Layer3"]
```
в итоге получим
> Layer1 -> holds -> Layer2 -> holds -> Layer3
Рекурсивность реализации никуда не исчезла, но стала конструктивной, а не бессмысленно зацикленной.
Тоже самое можно записать и короче, через свертку списка:
```
foldl1 hold ["Layer1","Layer2","Layer3"]
```
### Заключение
Видение технической системы как ткани из функций, связывающих ее во едино и определяющих суть и предназначение, чрезвычайно роднит ТРИЗ с функциональными языками программирования, в которых функция — основная управляющая конструкция.
Рассмотренный подход служит хорошим подспорьем в плане декомпозиции задачи и управления сложностью модели.
|
https://habr.com/ru/post/414929/
| null |
ru
| null |
# Cyberpunk 2077 игнорирует многопоточность микропроцессора AMD
Пользователи сайта Reddit [утверждают](https://www.reddit.com/r/Amd/comments/kbp0np/cyberpunk_2077_seems_to_ignore_smt_and_mostly/), что игра Cyberpunk 2077 игнорирует одновременную многопоточность (Simultaneous Multithreading, SMT) и в основном использует только физические ядра ЦП на ПК с процессорами AMD. На компьютерах с чипами Intel игра использует все доступные физические и логические ядра центрального процессора.
На форуме было предложено решение — изменить несколько байт в EXE-файле игры. Нужно в Hex-редакторе найти строку `75 30 33 C9 B8 01 00 00 00 0F A2 8B C8 C1 F9 08` и изменить ее на `EB 30 33 C9 B8 01 00 00 00 0F A2 8B C8 C1 F9 08`. В этом случае на ПК с процессорами AMD станут использоваться все логические ядра центрального процессора, а производительность игры улучшится на 10-20%.
*Пример распределения нагрузки на ядра процессора AMD при запущенной игре Cyberpunk 2077 без изменений в Hex-редакторе.*
*Пример использования всех ядер процессора AMD при запущенной игре Cyberpunk 2077 после внесения изменений в Hex-редакторе.*
Некоторые пользователи [предположили](https://www.reddit.com/r/pcgaming/comments/kbsywg/cyberpunk_2077_used_an_intel_c_compiler_which/), что это происходит из-за того, что Cyberpunk 2077 использует компилятор Intel C++, который препятствует оптимизации игры при работе на процессорах сторонних производителей. Однако, они не нашли подтверждения этой теории.
Сейчас [основная версия](https://www.reddit.com/r/pcgaming/comments/kbsywg/cyberpunk_2077_used_an_intel_c_compiler_which/gfknein) пользователей — при запуске игры происходит проверка производительности текущей системы с помощью библиотеки [GPUOpen](https://github.com/GPUOpen-LibrariesAndSDKs/cpu-core-counts/blob/master/windows/ThreadCount-Win7.cpp#L69), чтобы планировщик игры мог использовать оптимальное количество ядер, в зависимости от семейства процессоров, которые используют игроки. По какой то причине после проверки на ПК с процессорами AMD, которые не на архитектуре Bulldozer, планировщик выделяет для игры меньше потоков.
Один из пользователей [пояснил](https://www.reddit.com/r/pcgaming/comments/kbsywg/cyberpunk_2077_used_an_intel_c_compiler_which/gfl06n2/), что ранее, когда AMD начала продавать процессоры серии FX, то компания подвергалась критике за неправильный маркетинг своей продукции. Проблема заключалась в том, что их «8-ядерные» процессоры вводили покупателей в заблуждение и должны были продаваться как 4-ядерные 8-поточные процессоры или 4-ядерные процессоры с гиперпоточностью. То же самое с другими вариантами подсчета ядер. Другая проблема заключалась в том, что они пытались скрыть этот факт от программного обеспечения, что означало, что, когда программы пытались проверить, сколько ядер и потоков имеет ЦП, он неверно сообщал, что имеет «8 ядер и 8 потоков» вместо «4 ядер и 8 потоков» в примере с «8-ядерным» процессором. AMD устранила эту проблему с процессорами в серии Ryzen. Однако, проверка в Cyberpunk 2077 того, установлен ли процессор AMD, и как нужно соответствующим образом настроить количество ядер, работает неправильно и соответствует подсчету, который использовался до выхода новых процессоров AMD.
Устаревший фрагмент кода для расчета потоков, который, как предположили пользователи, используется в игре:
```
WORD cores, logical;
getProcessorCount(cores, logical);
DWORD count = cores;
char vendor[13];
getCpuidVendor(vendor);
if ((0 == strcmp(vendor, "AuthenticAMD")) && (0x15 == getCpuidFamily())) {
// AMD "Bulldozer" family microarchitecture
count = logical;
```
Новый фрагмент кода для расчета потоков:
```
DWORD cores, logical;
getProcessorCount(cores, logical);
DWORD count = logical;
char vendor[13];
getCpuidVendor(vendor);
if (0 == strcmp(vendor, "AuthenticAMD")) {
if (0x15 == getCpuidFamily()) {
// AMD "Bulldozer" family microarchitecture
count = logical;
}
else {
count = cores;
}
}
```
Пользователи пояснили, что, вероятно, эта проверка не «неправильная» сама по себе, но, возможно, ее не следовало изначально использовать в Cyberpunk 2077 в качестве способа оптимизации производительности системы пользователя и использования потоков. В любом случае, команда разработчиков игры может выпустить новый патч, где будет устранена эта проблема.
Первоначально пользователи [пробовали](https://www.reddit.com/r/Amd/comments/kbuswu/a_quick_hex_edit_makes_cyberpunk_better_utilize) заменять строку `75 30 33 C9 B8 01 00 00 00 0F A2 8B C8 C1 F9 08` на значения `74 30 33 C9 B8 01 00 00 00 0F A2 8B C8 C1 F9 08`. Однако скоро выяснилось, что такая замена не совсем оптимальна, так как она инвертировала некорректную проверку библиотеки GPUOpen, а не нейтрализовала ее проведение. На ПК с процессорами Intel такую замену производить не рекомендуется даже ради тестов.
Вчера руководство студии CD PROJEKT RED [взяло](https://habr.com/ru/news/t/532650/) на себя ответственность за баги и проблемы, обнаруженные пользователями на старте игры Cyberpunk 2077.
11 декабря вышел [патч 1.04](https://en.cdprojektred.com/news/hotfix-1-04/) для Cyberpunk 2077, исправляющий многочисленные ошибки в игре, включая механику квестов, геймплей, визуализацию персонажей, а также улучшающий производительность и стабильность как версий игры на ПК, так и для игровых консолей.
**Обновление публикации.** 19 декабря 2020 года вышел [патч 1.05](https://www.cyberpunk.net/en/news/37166/hotfix-1-05), в котором была решена проблема с производительностью, использованию SMT и процессорами AMD. Правда, разработчики уточнили, что патч улучшает ситуацию только для 4-ядерных и 6-ядерных процессоров AMD Ryzen. Для обладателей 8-ми, 12-ти и 16-ядерных процессоров патч не помогает. Это происходит из-за того, что студия CD Projekt Red совместно с AMD протестировала различные конфигурация и выяснила, что улучшение производительности с SMT происходит только на процессорах с 6 ядрами и менее.
> См. также:
>
>
>
> * «[Проект Proton запускает Cyberpunk 2077 на Linux](https://habr.com/ru/news/t/532336/)»
> * «[Cyberpunk 2077 вызвал эпилептические припадки у первых игроков](https://habr.com/ru/news/t/532096/)»
> * «[Из-за ажиотажа при запуске Cyberpunk 2077 ненадолго слегли серверы Steam и GOG](https://habr.com/ru/news/t/532296/)»
> * «[Запуск Cyberpunk 2077 стал рекордно крупным в истории компьютерного игропроизводства](https://habr.com/ru/news/t/532448/)»
>
|
https://habr.com/ru/post/532748/
| null |
ru
| null |
# Получение URL-адресов системных папок в iOS 16
Работа с файлами и каталогами стала намного проще в iOS 16. Раньше, чтобы получить путь к файлу в папке приложения, приходилось использовать API FileManager, что довольно сложно. Теперь мы можем получать пути к системным папкам непосредственно из статических свойств типа URL.
Например, чтобы получить URL каталога документов в песочнице нашего приложения, мы можем прочитать свойство [URL.documentsDirectory](https://developer.apple.com/documentation/foundation/url/3988456-documentsdirectory).
```
let url = URL.documentsDirectory
```
Мы можем так же легко получить URL-адреса других системных папок. Посмотрите свойства типа в [документации для URL struct](https://developer.apple.com/documentation/foundation/url) для получения полного списка доступных опций.
Еще одно значительное улучшение — новый метод [appending(path:directoryHint:)](https://developer.apple.com/documentation/foundation/url/3988449-appending), который заменяет старый [appendingPathComponent(\_:isDirectory:)](https://developer.apple.com/documentation/foundation/url/1779992-appendingpathcomponent). Новый метод получает параметр [DirectoryHint](https://developer.apple.com/documentation/foundation/url/directoryhint), который указывает, должен ли Foundation выполнить проверку файловой системы, чтобы определить, относится ли путь к папке. Значение по умолчанию — [inferFromPath](https://developer.apple.com/documentation/foundation/url/directoryhint/inferfrompath) подразумевает, что эта информация будет выведена из строки пути, которую мы передаем в метод. Если строка содержит слеш, она будет рассматриваться как путь к каталогу.
До iOS 16 нам приходилось либо передавать булево значение isDirectory в `appendingPathComponent(_:isDirectory:)`, либо вызывать [appendingPathComponent(\_:)](https://developer.apple.com/documentation/foundation/url/1780239-appendingpathcomponent) без булева параметра. Последний вариант может привести к тому, что Foundation framework выполнит операцию с файловой системой, чтобы определить, является ли компонент пути каталогом. Это имеет последствия для производительности и может быть легко предотвращено с помощью нового метода.
Теперь для создания URL-адреса файла мы можем просто написать `url.appending(path: "myfile")`. Foundation на основе пути опеределит, что это не каталог, поскольку в нем нет слеша, и не будет выполнять ненужную проверку файловой системы.
Благодаря всем этим улучшениям мы можем получить URL-адрес файла в каталоге документов в iOS 16 с помощью очень простой строки кода.
```
// iOS 16 example
let fileURL = URL.documentsDirectory
.appending(path: "myfile")
```
Это отличное обновление по сравнению с iOS 15, где для достижения того же результата нам пришлось бы использовать более сложные API FileManager.
```
// iOS 15 example
let fileURL = try FileManager.default
.url(
for: .documentDirectory,
in: .userDomainMask,
appropriateFor: nil,
create: false
)
.appendingPathComponent(
"myfile", isDirectory: false
)
```
За обновлениями блога и рекомендациями по разработке следите за нами в Twitter [@nilcoalescing.](https://twitter.com/nilcoalescing)
---
> Компания Apple только что анонсировала фреймворк Swift Charts, который мы можем использовать для создания диаграмм в приложениях. Приглашаем всех желающих на открытое занятие, на котором рассмотрим возможности API Swift Charts. Регистрируйтесь [**по ссылке.**](https://otus.pw/raSX/)
>
>
|
https://habr.com/ru/post/680388/
| null |
ru
| null |
# Я всегда с собой беру…
[](https://habr.com/ru/company/ruvds/blog/598493/)
Некоторые сотовые провайдеры не разрешают раздавать ~~их~~ безлимитный интернет без дополнительной оплаты. Приобретать отдельное походное устройство по обеспечению широкополосного беспроводного доступа в глобальную сеть с абонентской оплатой более 1к рублей в месяц ради нескольких дней в году может совсем не хотеться. В связи с этими обстоятельствами в статье рассмотрено, как сотовые операторы узнают о раздаче доступа в интернет с мобильных устройств, а также какие возможности имеются на борту RouterOS по обеспечению приватности подобных действий.
В течение длинных новогодних каникул представляю короткую инструкцию по организации походного интернета на скорую руку и примерно как дома. Без особой подготовки, серьёзных материальных затрат и требуемого времени. Многие из нас сейчас собирают чемоданы для поездки на дачу или даже куда-то гораздо подальше. Многим всё равно необходимо пару часов по вечерам проводить за работой. Разумеется, без интернета не обойтись. 4G и 3G сейчас работает хорошо и много где, поэтому в таких поездках я всегда беру с собой дешёвый MikroTik стоимостью 1500 рублей, который подключаю к своему телефону по Wi-Fi. Вопрос этичности подобных действий рассматривать не буду, так как статья техническая и носит исключительно исследовательский характер.
Для начала вооружаемся роутером [hAP mini](https://mikrotik.com/product/RB931-2nD) (в соответствии с маркировкой производителя RB931-2nD). Его кстати после прохождения официального тренинга раздают ~~почти~~ бесплатно.
У этого скромного девайса некоторое время как уже имеется на борту работающая технология [Powerline](https://en.wikipedia.org/wiki/Power-line_communication), которая позволяет использовать специализированные [сетевые адаптеры](https://mikrotik.com/products/group/data-over-powerlines) для построения проводных LAN на основе связанных электрических линий (проводов, несущих ток 220 вольт, спрятанных в стенах и потолках наших домов). Помнится, в уже далёком 2005 году это называлось лозунгом, вроде такого: «Раздаём интернет прямо из розетки»! Более подробную информацию от вендора по настройке технологии можно почитать [здесь](https://mikrotik.com/product/pwr_line_us) и [здесь](https://en.wikipedia.org/wiki/Power-line_communication). Забавная фича, и, кстати, дополнительный ~~полноценный~~ LAN порт. В гостинице можно попытаться поднять собственную проводную локалку между друзьями единомышленниками, находясь при этом на разных этажах. Зарубиться во что-то сетевое, как в старые добрые времена, до прихода в нашу жизнь высокоскоростного интернета и облачных технологий с их игровыми аккаунтами. Этакий дух компьютерных игровых клубов, как коммерческих, так и любительских, развёрнутых внутри студенческих общежитий технических университетов.
Возвращаюсь к предмету статьи. На текущий момент в дикой природе в странах СНГ я встречал только такой способ обнаружения раздачи интернета, применяемый сотовыми операторами, как анализ [TTL](https://ru.wikipedia.org/wiki/Time_to_live) на сетевом уровне. Коротко по существу. Мой сотовый телефон использует для исходящих пакетов TTL, равный 64. Таким образом, на gateway-default провайдера приходят пакеты именно такие. Если я попытаюсь раздать интернет своему laptop, то он уже использует TTL равный 128 (хотя это не важно, в принципе). Раздатчик интернета (телефон) каждому пакету изменит его на 127, следовательно, gateway-default провайдера получит легко узнаваемые пакеты и оправит меня на страницу заглушку, подрубив интернет до значений, близких к нулю. Даже, если интернет будет роздан не ноутбуку, а другому телефону, то всё равно на оборудование провайдера придёт 63, что опять-таки легко распознаваемо.
Из представленного описания видно, что анализ TTL является функцией L3 Firewall, поэтому для препятствования его работы можно воспользоваться маркировкой трафика, отлично функционирующей в рамках RouterOS, и выставить нужное замаскированное значение:
```
/ip firewall mangle
add action=mark-connection chain=postrouting comment="LAN=>WAN connections" new-connection-mark="LAN=>WAN connections" out-interface=wlan1-Station passthrough=yes
add action=mark-packet chain=postrouting comment="LAN=>WAN packets" connection-mark="LAN=>WAN connections" new-packet-mark="LAN=>WAN packets" passthrough=yes
add action=change-ttl chain=postrouting comment="LAN=>WAN packets change TTL to 65" new-ttl=set:65 packet-mark="LAN=>WAN packets" passthrough=yes
```
Обращаю внимание на имя исходящего интерфейса **wlan1-Station**. Людям, хорошо не знакомым с оборудованием MikroTik, может быть непонятно, что оно означает. RouterOS позволяет использовать свои «железные» беспроводные интерфейсы в качестве Wi-Fi клиентов. Это позволяет подключаться к раздатчику интернета (он же сотовый телефон) по беспроводному каналу. Для этого настраиваем профиль безопасности:
```
/interface wireless security-profiles
add authentication-types=wpa2-psk disable-pmkid=yes eap-methods="" mode=\
dynamic-keys name=myPhone supplicant-identity="" wpa2-pre-shared-key=0123456789
```
Затем настраиваем не виртуальный беспроводной интерфейс:
```
/interface wireless
set [ find default-name=wlan1 ] band=2ghz-b/g/n disabled=no frequency=auto \
name=wlan1-Station radio-name="" security-profile=myPhone ssid=”RUVDS" wireless-protocol=802.11
```
Если всё корректно, то можно увидеть информационное сообщение **connected to ess** с прилагаемыми техническими подробностями:
Осталось получить от телефона сетевые настройки, а так как они будут динамическими, то здесь нам понадобится маскарад:
```
/ip dhcp-client add disabled=no interface=wlan1-Station use-peer-dns=no use-peer-ntp=no
/ip firewall nat add action=masquerade chain=srcnat out-interface=wlan1-Station
```
Далее имеется логичная возможность раздать интернет уже посредством MikroTik, для этого проделываем похожие действия:
```
/interface wireless security-profiles
add authentication-types=wpa2-psk comment=ourHome disable-pmkid=yes \
eap-methods="" mode=dynamic-keys name=Home supplicant-identity="" \
wpa2-pre-shared-key=veryStrongPassword!
/interface wireless
add disabled=no keepalive-frames=disabled \
master-interface=wlan1-Station multicast-buffering=disabled name=\
wlan1-Virtual-AP security-profile=Home ssid=Home wps-mode=disabled
```
Интерфейс «*wlan1-Virtual-AP*» является виртуальным и поэтому унаследует большинство технических характеристик от мастер интерфейса «*wlan1-Station*». Важно учитывать, что клиентом Wi-Fi может выступать только не виртуальный интерфейс роутера. Дополнительно, если по какой-то причине мастер интерфейс не подключён к точке доступа, то связанный с ним виртуальный интерфейс так же не будет функционировать. Другими словами, ваша собственная точка доступа Wi-Fi от роутера будет не активна, пока RouterOS не соединится с мобильным телефон, раздающим интернет. В целях снижения утилизации эфирного времени, если имеется более продвинутый MikroTik, то лучше раздать интернет в другом диапазоне. Например, если сотовый телефон работает в режиме модема на беспроводном канале из диапазона 2.4 ГГц, то Wi-Fi на роутере следует запустить в диапазоне 5 ГГц:
```
/interface wireless
set [ find default-name=wlan2 ] band=5ghz-a/n/ac channel-width=20/40mhz-XX \
disabled=no frequency=auto mode=ap-bridge name=wlan2-AP security-profile=\
Home ssid=Home5GHz wireless-protocol=802.11 wps-mode=disabled
```
Ниже представляю оставшийся минимум настроек RouterOS, чтобы не отправлять не подготовленного читателя в увлекательное путешествие по сети интернет при попытках воспроизвести подобное решение:
```
/interface bridge add dhcp-snooping=yes fast-forward=no name=bridgeHome
/ip address add address=10.0.0.1/24 interface=bridgeHome network=10.0.0.0
/ip pool add name=poolHome ranges=10.0.0.2-10.0.0.254
/ip dhcp-server network add address=10.0.0.0/24 dns-server=10.0.0.1 gateway=10.0.0.1 netmask=24
/ip dhcp-server add address-pool=poolHome disabled=no interface=bridgeHome lease-time=12h name=serverHome
/interface bridge port
add bridge=bridgeHome interface=ether1
add bridge=bridgeHome interface=ether2
add bridge=bridgeHome interface=ether3
add bridge=bridgeHome interface=wlan1-Virtual-AP
/ip dns set allow-remote-requests=yes servers=8.8.8.8,8.8.4.4,1.1.1.1
/system clock set time-zone-name=Europe/Moscow
/system identity set name=MikroTik
/system ntp client set enabled=yes primary-ntp=ntp1.stratum2.ru secondary-ntp=ntp2.stratum2.ru
```
Добавлю немного безопасности, чтобы сдавать устройство, готовое к эксплуатации из коробки:
```
/ip firewall filter
add action=accept chain=input comment="Input Established,Related=>Accept" connection-state=established,related
add action=drop chain=input comment="Input Invalid=>Drop" connection-state=invalid
add action=drop chain=input comment="Input !bridgeHome=>Drop" in-interface=!bridgeHome
add action=accept chain=forward comment="Forward Established,Related=>Accept" connection-state=established,related
add action=drop chain=forward comment="Forward Invalid=>Drop" connection-state=invalid
add action=drop chain=forward comment="Forward !dst-nat=>Drop" connection-nat-state=!dstnat in-interface=wlan1-Station
/ip service
set telnet disabled=yes
set ftp disabled=yes
set api disabled=yes
set api-ssl disabled=yes
/interface list add name=LAN
/interface list member add interface=bridgeHome list=LAN
/ip neighbor discovery-settings set discover-interface-list=LAN protocol=mndp
/tool mac-server set allowed-interface-list=none
/tool mac-server mac-winbox set allowed-interface-list=LAN
/tool mac-server ping set enabled=no
```
Стоит упомянуть о том, что изменять TTL можно и на клиентских устройствах. Делается это достаточно просто на операционных системах Windows и Linux (при наличии, конечно, соответствующих прав). Однако, во-первых, в целом это не очень удобно. Во-вторых, не решает вопрос со смартфонами и подобными устройствами. Следовательно, решить проблему с TTL именно на шлюзе – отличная идея.
Добавлю, что в вопросе блокировки трафика со стороны мобильных провайдеров я встречал ~~странную~~ практику. Вместо того, чтобы дропать весь интернет нерадивого клиента, сотовый оператор рубил только DNS пакеты. Вариантов, как это можно перепрыгнуть, достаточно много. Мне нравится подкрутить маршрутизацию, направив DNS пакеты в шифрованный VPN туннель:
```
/ip route
add check-gateway=ping comment="DNS over OVPN" distance=1 gateway=192.168.15.1 routing-mark="DNS routing"
/ip route rule
add action=lookup-only-in-table comment="DNS over VDS" dst-address=1.1.1.1/32 table="DNS routing"
add action=lookup-only-in-table comment="DNS over VDS" dst-address=8.8.8.8/32 table="DNS routing"
add action=lookup-only-in-table comment="DNS over VDS" dst-address=8.8.4.4/32 table="DNS routing"
```
Для любителей загрузить качественное кино гигабайт на 15 размером посредством торрент обменников, могу сказать, что это не понравится ни одному мобильному провайдеру. А соответственно можно ожидать и санкций от них в виде низкой скорости на уровне 5 кбит/с, так что на загрузку может понадобиться несколько недель:
VPN и здесь сделает свое дело. Немного изменяем настройки для dhcp-client, назначаем статические маршруты и дополним Firewall еще одним правилом:
```
/ip dhcp-client add disabled=no interface=wlan1-Station use-peer-dns=no use-peer-ntp=no add-default-route=no
/ip route add dst-address=ipVpnServera gateway=172.20.10.1
/ip route add dst-address=0.0.0.0/0 gateway=192.168.15.1
/ip firewall nat add action=src-nat chain=srcnat comment="SRC-NAT for ovpn-out" out-interface=ovpn-out1 to-addresses=ipVpnClient
```
На сервере не забываем включить ip forward и настроить NAT, например, так:
```
iptables -t nat -A POSTROUTING -s 192.168.15.0/24 -o eth0 -j SNAT --to-source ipVpnServer
echo '1' > /proc/sys/net/ipv4/ip_forward
```
В результате весь трафик будет вложен внутрь VPN туннеля, общая скорость интернета припадёт, но торренты качаться будут уверенно:
Добавлю, что VPN серверы позволяют передать клиентам дополнительные сетевые настройки. Например, если в файле конфигурации OpenVPN сервера указать строку ниже, тогда он будет назначен в качестве шлюза по умолчанию, конечно, если клиентская сторона это разрешит:
```
push "redirect-gateway def1"
```
Для troubleshooting можно воспользоваться сайтом *2ip.ru*, который должен будет показать подробную информацию не о ваших домашних устройствах, а об VDS сервере, на котором вертится VPN. Здесь важно упомянуть, что в представленных схемах при настройке VPN клиентов на RouterOS нужно использовать IP адрес вместо доменного имени сервера, иначе описанные механизмы не смогут завестись по техническим причинам. Также на удалённом сервере можно запустить программу *Tcpdump*, и увидеть пролетающие пакеты:
```
tcpdump -i eth0 port 53
16:04:21.179296 IP ruvds.ru.35058 > dns.google.domain: 31590+ A? fonts.gstatic.com. (35)
16:04:21.180286 IP ruvds.ru.42023 > dns.yandex.ru.domain: 36125+ PTR? 8.8.8.8.in-addr.arpa. (38)
16:04:21.183646 IP dns.yandex.ru.domain > ruvds.ru.42023: 36125 1/0/0 PTR dns.google. (62)
16:04:21.184318 IP ruvds.ru.51949 > dns.yandex.ru.domain: 24509+ PTR? 8.8.88.77.in-addr.arpa. (40)
16:04:21.191127 IP dns.yandex.ru.domain > ruvds.ru.51949: 24509 1/0/0 PTR dns.yandex.ru. (67)
```
Вот в принципе и всё, по предмету разговора. Я всегда с собой беру роутер MikroTik. На новом месте добавляю при необходимости новые «*wireless security-profiles*», немного настраиваю беспроводной интерфейс и пользуюсь интернетом, как дома. А без собственного [облачного сервера](https://ruvds.com/) сейчас IT специалисту ну никак не обойтись.
#### Подведём итоги
Откуда провайдеры мобильного интернета узнают, что за нашим шлюзом зиждется новая компьютерная сеть? Основной способ это, конечно, анализ TTL, который относится по компетенции к работе L3 Firewall. Грамотно настроенный Firewall Filter, NAT и Mangle на RouterOS могут полностью скрыть это на сетевом уровне. Что касается прикладного уровня, то здесь уже начинается участок ответственности IDS (IPS) систем. Конечно, большинство современного интернет-трафика на текущий момент использует шифрование, однако Wireshark доказывает, что всё равно регулярно встречаются использование HTTP в работе различных скриптов даже на сайтах, работающих под HTTPS. Здесь уже есть с чем поработать, например, заголовок **User-Agent** выдаст с потрохами ваш браузер:
Конечно, и на этот способ легко реализовать способы противодействия, так как, в конечном счёте, это бесконечная гонка. Игра в кошки мышки. Что применимо в целом к отрасли информационной безопасности. На этом все, пора вновь присоединяться к праздничному веселью. С наступившим Новым годом, читатели Хабра!
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=olegtsss&utm_content=ya_vsegda_s_soboj_beru)
|
https://habr.com/ru/post/598493/
| null |
ru
| null |
# Повелители серверов и сетей — с праздником
Сегодня не просто пятница. Сегодня последняя пятница июля — а значит, День системного администратора! В эту праздничную пятницу сисадмины не купаются в фонтанах, не куражатся в серверных, не гоняются с витой парой наперевес за маркетологами. Эти труженики серверов и скриптов всё время на посту, оберегают покой юзеров и нервы начальства — чтобы одни щёлкали мышками на сайтах и в 1С, а другим не приходилось подсчитывать убытки от простоев. Давайте скажем искреннее «спасибо» сисадминам за спокойную бесперебойную работу и поднимем за их здоровье стаканы с чаем! И сегодня мы расскажем про типичные дни системного администраторов или Unix-инженеров нашей компании на этой неделе.
```
#!/usr/bin/env python
import time
import os
if (time.strftime("%H:%M")) == "09:30":
os.system("Подъем!")
print("Продрать глаза, налить кофе, в душ. Важный момент — выбор футболки: пусть сегодня будет пингвин, а чертёнка прибережем до лучших времён")
elif (time.strftime("%H:%M")) == "10:00":
os.system('Самокат до метро, время почитать новости на Хабре')
elif (time.strftime("%H:%M")) == "11:00":
os.system('Ура! Офис и опять кофе-кофе')
print("Кстати, я работаю в крупной интернет-компании, я не один, а в группе с другими системными администраторами, мы занимаемся обеспечением доступности сервисов. А сервисов у нас много, и они разные.")
elif (time.strftime("%H:%M")) == "11:15":
os.system('Открываем ноутбук/включаем рабочую станцию, и тут начинается всё-всё самое интересное!')
print("Заглянуть в мониторинг, посмотреть на графики — как там сервис живет, как самочувствие. Самостоятельно починить всё, что приболело за ночь, но не влияло на работу сервиса, и поставить задачек команде. Потом почта и чаты — там тоже много важного: ответить на письма, почитать новости, обмен опытом с коллегами")
elif (time.strftime("%H:%M")) == "12:30":
os.system('Налить колу; Обсудить запуск нового сервиса')
print("Идем к разработчикам, вот-вот запускается новый сервис, надо обсудить архитектуру – Hadoop, Tarantool, Nginx, продумать про мониторинги, healthcheck-и, графики, как сервис будет резервироваться между дата-центрами, репликации, бэкапы, масштабирование (ой, надо всё же доделать тот тикет про мониторинг ресурсов на проекте и эластик!), как будет проходить внедрение изменений, какие нужные еще stage-ы, что тестируем и как. И это только начало! Впереди много работы по проекту, а времени до запуска, как всегда, мало.")
elif (time.strftime("%H:%M")) == "13:15":
os.system('Обед!')
print("Наконец можно пообедать с коллегами и обсудить приятные новости, например, недавнюю конференцию или интересную статью. После обеда можно позволить себе немножко расслабиться в массажном кресле с апельсиновым соком.")
elif (time.strftime("%H:%M")) == "13:50":
os.system('Проапгрейдить софт на серверах')
print("Операция по большей части непростая — собираем всё на тестовом стенде, смотрим, тестируем по-всякому. Заработало! Надо предупредить команду о регламенте, договориться о времени и катить в продуктив.")
elif (time.strftime("%H:%M")) == "15:15":
os.system('Выкладывать новый функционал, который видят наши пользователи') # Делаем аккуратно, параллельно смотрим на графики.
elif (time.strftime("%H:%M")) == "16:07":
os.system('Авария на одном из проектов!')
print("Смс-ки, письма, на графиках что-то идет не так. Бросаем всё, бежим чинить. Тут же рядом оказываются ведущие разработчики и менеджер.")
elif (time.strftime("%H:%M")) == "16:15":
os.system('Починили! Разбираем последствия')
elif (time.strftime("%H:%M")) == "16:45":
os.system('Чай с коллегами') # Немного передохнуть, послушать, как идет день у коллег, какие новости.
elif (time.strftime("%H:%M")) == "17:15":
os.system('Cloud time!')
print('Внедряем Docker, Kubernetes на проект. В облаке все проекты нагруженные, надо придумать, что делать с iops-ами, а то у нас недавно был очередной "шумный сосед", отселили его, конечно, на отдельные ssd')
elif (time.strftime("%H:%M")) == "18:03":
os.system("Как пройдет мой вечер?") # Сейчас узнаю день недели и всё будет понятно!
if (time.strftime("%w")) == "1":
os.system('Звонок руководителя сервиса, завтра рекламная акция и нагрузка на сервис возрастет во много раз')
print("Срочно добавляем ресурсов на проект, мы же умеем масштабироваться. На этом проекте такое впервые. Вместе с техническим директором и разработчиками смотрим на него, анализируем узкие места, тестируем. Придумываем план Б, если что-то пойдет не так")
elif (time.strftime("%w")) == "2":
os.system('Дежурство! Собираю сумку и отправляюсь домой')
print("Еду домой. Приеду, загляну в мониторинг, исправлю проблемы, которые возникли за день. Потом буду сидеть смотреть лекцию по программированию или администрированию. Если случится авария, то мне позвонят, и я ее починю")
elif (time.strftime("%w")) == "3":
os.system('Время заниматься автоматизацией и инфраструктурными задачами !') # прежде загляну в мониторинг — нет ли каких-то проблем на сервисе
elif (time.strftime("%w")) == "4":
os.system('capacity planning')
print("Протестирую новое оборудование из TestLab, запланирую, сколько и каких ресурсов — CPU, RAM, HDD/SSD/NVMe нужно проекту при естественном росте нагрузки.")
elif (time.strftime("%w")) == "5":
os.system('Праздник!')
print("Празднуем с коллегами! Всех с Днем Системного администратора! Ура!")
Man python, man linux, man bash, man man
```
|
https://habr.com/ru/post/418331/
| null |
ru
| null |
# Призраки в облаках или установка Ghost в Windows Azure
Сегодня многие блоггеры считают, что Wordpress стал слишком перегружен лишним функционалом и превращается из платформы для блогов в полноценную и сложную CMS. Это вовсе не плохо — разнообразие плагинов, модулей и тем, доступных сейчас в сети, позволяет использовать возможности платформы практически для любых целей. Однако у этого разнообразия есть и обратная сторона медали. Нагромождение модулей негативно сказывается на производительности сайта, при том, что даже «чистый» вордпресс не может похвастаться выскокой скоростью работы.
#### Ghost
Некоторое время назад на сайта стартапов Kickstarter был запущен проект под названием [Ghost](http://www.kickstarter.com/projects/johnonolan/ghost-just-a-blogging-platform "Ghost on Kickstarter"), слоган которого был «just a blogging platform» (платформа только для блогов). Идея пришлась многим по вкусу и проект собрал почти $200.000, вместо изначальных $25.000. Сейчас проект активно развивается и на [официальном сайте](https://ghost.org/ "Ghost website") уже доступна для скачивания версия 0.3.3.
Меня, как и многих других, очень заинтересовал этот проект. Во-первых, мне нравится минималистичный дизайн. Во-вторых, Wordpress и правда немного избыточен для моих нужд и слегка туповат в работе. А в-третьих, меня завлекло то, что Ghost разрабатывается на [Node.js](http://nodejs.org/ "Node.js website") — технология, о которой очень много говорят в последнее время. Я решил попробовать в действии, что же это за *«just a blogging platform»*, и установить его себе в Windows Azure как дополнение к основному блогу.
#### Создание сайта в Windows Azure
Перед тем, как перейти непосредственно к работе с Ghost, нам сперва потребуется создать службу Web Sites, где мы будем хоститься. Делается это как обычно через [портал управления Windows Azure](https://manage.windowsazure.com "Windows Azure Management Portal"). В меню New (плюсик внизу страницы) выбираем Compute -> Web Site -> Quick Create. На текущем этапе нам нужен пустой сайт без каких-либо предустановленных компонентов. Все, что нам потребуется, мы доставим далее.
После того, как сайт будет создан, нам необходимо произвести пару настроек. Во-первых, нужно сделать определенный финт ушами для того, чтобы Ghost правильно работал (подробнее — ниже). Перейдите на вкладку Configure и найдите там раздел app settings. В нем надо создать такую строку: KEY=NODE\_ENV, VALUE=production.
Во-вторых, нам надо настроить способ, как передать данные с рабочего компьютера в облако. Для этого в Windows Azure есть поддержка систем контроля версий, таких как TFS или Git. Поскольку проект Ghost является Open Source и сам поставялется через GitHub, то мы тоже настроим на своем сайте Git-репозиторий и будем работать с ним. Делается это просто: на вкладке Quick Access (которая с облачком и молнией) есть пункт *Integrate source control*:
Нажимаем на Set up deployment from source control и выбираем *Local Git repository*:
Стоит упомянуть, что среди доступных вариантов есть еще и TFS и прочие системы контроля версии (даже Dropbox), но для нашего случая мы выберем Git.
На этом настройка облака Windows Azure завершена и можно переходить к наиболее интересной части — установке и настройке Ghost.
#### Настройка рабочего окружения
Установить Ghost можно двумя способами. Первый и самый простой — это скачать уже скомпилированные файлы напрямую с [официального сайта проекта](https://ghost.org/download/ "Ghost download"). Этот метод хорош тем, что не требует никаких дополнительных действий со стороны пользователя. Однако, поскольку проект находится в активной фазе развития, у вас есть риск, что вы скачаете не самую последнюю версию проекта, которая не будет содержать важных исправлений. Так было в моем случае. Скачав архив с сайта проекта, я получил набор файлов, который отлично устанавливался и запускался локально, однако совершенно не хотел работать в облаке.
Поэтому я считаю, что на данный момент лучше сначала пойти более долгим путем, чтобы не иметь проблем в дальнейшем. Долгий путь заключается в самостоятельной сборке готового пакета из исходников Ghost. И это только сначала звучит слишком сложно, а на деле вам нужно будет потратить лишних 10-15 минут на все.
Итак, что нам в итоге нужно сделать:
1. Установить Node.js. Дистрибутив берется на официальном сайте [Node.js](http://nodejs.org/ "Node.js official site"). Устанавливается как обычная программа Windows. Главное следите за тем, чтобы он прописался в PATH, чтобы потом можно было пользоваться командами node, не указывая их полный путь в системе.
2. Установить клиент для Git. Консольный клиент для Windows можно скачать на [оф. сайте](http://git-scm.com/ "Git official site"). Также посмотрите, чтобы он прописал вне нужные пути в PATH, или же вам придется работать из специальной командной строки Git Bash, как это делаю я.
3. Установить [Grunt](http://gruntjs.com/ "Grunt"). Это утилита для компиляции JavaScript проектов. Она нужна нам для того, чтобы из исходников Ghost сформировать готовый пакет для публикации. Для установки Grunt вам достаточно из командной строки выполнить команду `npm install grunt-cli --g`. Программа npm идет вместе с nodejs и является по сути менеджером пакетов наподобие apt-get в Debian Linux. Удобная штука, с помощью которой можно скачать и установить все необходимые для работы расширения.
4. Для того, чтобы Grunt заработал, нам надо дополнительно установить Ruby. Скачать его можно тоже на [официальном сайте](https://www.ruby-lang.org/ "Ruby").
5. Также для работы Grunt необходимы два расширения для Ruby под названием Bourbon и Sass. Установить их оба можно одной командой `gem install bourbon`.
На этом настройка рабочего окружения завершена.
#### Подготовка Ghost
Подготовка Ghost разбивается на два этапа. Первый — получение файлов из официального репозитория на GitHub и последующая их компиляция. Второй — финишная настройка конфигов и прочих вещей, чтобы запустить блог в Windows Azure. Приступим!
Репозиторий Ghost на GitHub находится по [этому адресу](https://github.com/TryGhost/Ghost.git "Ghost GitHub repo"). Чтобы получить файлы проекта на свой компьютер, откройте Git Bash (его вы установили на предыдцщем этапе в п.2), перейдите в папку, где хотите сохранить этот проект и выполните команду:
```
git clone https://github.com/TryGhost/Ghost.git
```
Через какое-то время на вашей машине появится локальная копия репозитория Ghost со всеми файлами, которые вам будут нужны. Далее наши действия такие (то, что иде после # считается комментарием и выполнению не подлежит):
```
# перейдите в папку, где непосредственно лежат файлы проекта
npm install
# эта команда скачает и установит все пакеты node.js, которые нужны Ghost
grunt init
grunt prod
# эти команды "скомпилируют" проект и сформируют пакет для установки
```
Теперь надо сделать еще один финт. Дело в том, что по умолчанию сайт Node.js, работающий в Azure, считает стартовой страницей файл с названием server.js. В Ghost же стартовой страницей является index.js, поэтому нам надо самостоятельно убрать эти разногласия. Делается это очень просто. Создаем в блокноте файл server.js в корневой директории Ghost и пишем там одну единственную строку:
```
var GhostServer = require('./index');
```
Сохраняем изменения. Все, теперь Windows Azure корректно найдет настроящий стартовый файл Ghost'а.
Итак, мы уже почти готовы опубликовать свой новый блог в Azure. Осталось лишь настроить конфиги. Тут все довольно просто. В корневой директории Ghost есть файл под названием config.example.js. Переименовываем его в config.js и открываем на редактирование.
Далее ищем такой блок:
```
production: {
// must not contain a path suffix after the hostname - "subdirs" are not (yet) supported!
url: 'http://my-ghost-blog.com',
mail: {},
database: {
client: 'sqlite3',
connection: {
filename: path.join(__dirname, '/content/data/ghost.db')
},
debug: false
},
server: {
// Host to be passed to node's `net.Server#listen()`
host: '127.0.0.1',
// Port to be passed to node's `net.Server#listen()`, for iisnode set this to `process.env.PORT`
port: '2368'
}
},
```
Обратите внимание, что мы ищем блок *production*. Это как раз конфигурация, для которой мы задавали значение параметра DEV\_ENV в самом начале поста. Тут нас интересует две вещи, а именно параметр *url* в самом начале блока и параметр *port* в самом конце. Первый надо изменить на тот url, на котором будет жить ваш блог. В случае Windows Azure по умолчанию этот URL выглядит примерно так: .azurewebsites.net. Вы можете изменить его, если вручную пропишете домен для веб-сайта, но это уже тема отдельной истории. Ну а значение port меняем на строку *process.env.PORT* (без кавычек). Итого, должно получиться следующее:
```
production: {
// must not contain a path suffix after the hostname - "subdirs" are not (yet) supported!
url: 'http://.azurewebsites.net',
mail: {},
database: {
client: 'sqlite3',
connection: {
filename: path.join(\_\_dirname, '/content/data/ghost.db')
},
debug: false
},
server: {
// Host to be passed to node's `net.Server#listen()`
host: '127.0.0.1',
// Port to be passed to node's `net.Server#listen()`, for iisnode set this to `process.env.PORT`
port: process.env.PORT
}
},
```
Ну и последний шаг — открываем файл .gitignore в корневой папке проекта, находим там строки ниже и комментируем их:
```
# /core/client/assets/css
# /core/built
# config.js
```
Если бы мы этого не сделали, то при установке блога в Windows Azure Git просто бы не стал их копировать, проигнорировав.
#### Публикация сайта в Windows Azure
Теперь у нас все готово к финальному действию — публикации сайта. Для этого надо выполнить несколько команд в Git Bash:
```
git add .
git commit -m "first ghost publish"
git remote add azure https://glamcoder@ghost-test-glamcoder.scm.azurewebsites.net:443/ghost-test-glamcoder.git
git push azure master
```
Сперва мы сохранили все изменения с репозиторием, которые мы сделали. Затем мы закоммитили их с определенным комментарием. На третьей строке мы создали ссылку на удаленный Git-репозиторий. Адрес этого репозитория создается специально на каждый Web Site в Windows Azure (это мы сделали в самом начале) и его можно узнать на вкладке Deployments. Последняя команда отправит все файлы на сервере Windows Azure. Вы можете увидеть, как в процессе публикации выполняются различные команды на сервере. После того, как все закончится, вы должны будете увидеть свой сайт, работающий уже в облаке, а на вкладке Deployments будет красоваться что-то вроде этого:
Для первичной настройки блога зайдите по ссылке <ВАШ-ПУТЬ-К-БЛОГУ>/ghost, где вам будет предложено ввести имя пользователя и пароль администратора. После чего вы полностью закончите устанавливать и настраивать свой новый блог и сможете приступить к творчеству!
Удачи!
#### Впечатления от Ghost
Я установил себе Ghost как второй блог параллельно с основным (<http://ghost.glamcoder.ru/>) и хочу поделиться своими впечатлениями от работы.
Начну с плюсов. Во-первых, мне очень нравится *markdown* как язык разметки для написания постов. Он очень чистый, легко редактируется и интуитивно понятный. А еще он больше гиковский, что добавляет ему шарма. Это что-то вроде LaTeX по сравнению с MS Word.
Во-вторых, Ghost работает шустро. Гораздо быстрее, чем Wordpress, даже не задушенный плагинами. Понятное дело, что это скорее не столько заслуга Node.js (хотя наверно и его тоже), сколько просто молодость проекта и он еще не успел стать мультикомбайном типа Nero. Но разработчики уверяют, что он таким никогда не станет и всегда останется чистым и простым. Посотрим.
В-третьих, мне нравится его дизайн. Все просто, понятно, ничего лишнего. Минимализм в лучшем его проявлении.
Это, пожалуй, не все плюсы Ghost, но по крайней мере самые заметные.
С минусами не все так просто. Наибольшая претензия у меня к тому, что блог практически не кастомизируется средствами интерфейса. Т.е. из всех настроект доступно только редактирование названия и описания блога, да фонового изображения на главной странице. Все, больше ничего нет. Ни тебе менюшки, ни виджетов, ни публикации в соц. сети. Нет даже коммментарием под постами. Иными словами, блог действительно лишен всего, что не относится к написанию текста. Но тем не менее я не могу назвать это минусом. Это особенность платформы, с которой надо смириться. Любые модификации, которые вам нужны, вы можете написать сами. В прямом смысле — открыть исходный код и дописать туда нужные модули. Например, код для Яндекс.Метрики я вставлял с помощью редактирования стандартного шаблона вьюхи. То же предлагается сделать для подключения комментариев от Disqus. Полная свобода творчества!
Что хочется сказать в итоге. Если вы гик, программист, технарь (нужное подчеркнуть) и вы любите минимализм, то Ghost вам скорее всего придется по душе. Если же вы любите, чтобы все работало сразу и из коробки с минимальными усилиями — то проходите мимо. В скором времени ребята из Ghost обещают запустить свой собственный хостинг с блогами, и тогда, возможно, он покажется вам удобным. Но сейчас Ghost требует много ручной работы.
P.S. Статья была подготовлена с использованием материалов из [блога Скотта Хансельмана](http://www.hanselman.com/blog/HowToInstallTheNodejsGhostBloggingSoftwareOnAzureWebsites.aspx). Там все то же самое, только более технически.
P.P.S. Пост во многом написан для тех, кто не знаком с Git и Windows Azure. Так что прошу прощения за излишние подробности и простоту. Ваши комментарии, пожелания и советы always welcome :)
|
https://habr.com/ru/post/203242/
| null |
ru
| null |
# По существу о C# 10.0: как нам упростили жизнь — Часть 2
Первую часть статьи [читайте здесь.](https://habr.com/ru/company/otus/blog/660743/)
### Структуры записей (#UsedOccasionally)
Поддержка записей была добавлена еще в C# 9.0. На тот момент все записи были ссылочными типами (и были потенциально мутабельными). Преимущество добавления типов-записей (объявляемых ключевым словом record) заключается в том, что они предоставляют компактный синтаксис для определения нового типа, основной целью которого является инкапсуляция данных (с меньшим акцентом на обеспечении обслуживания и поведении). Теперь же мы имеем записи двух типов, которые имеют генерируемые компилятором C# реализации равенства на основе значений, обратимого изменения (non-destructive mutation) и встроенного форматирования отображения.
#### Структуры записей и классы записей
Итак, в C# 10.0, в дополнение к ссылочным типам записей (**классы записей**), были представлены значимые типы записей (**структуры записей**). В качестве примера давайте рассмотрим объявление `Angle`, приведенное ниже:
```
record struct Angle(double Degrees, double Minutes, int Seconds)
{
// По умолчанию параметры первичного конструктора генерируются как свойства чтения/записи:
public double Degrees {get; set;}
// Вы можете переопределить реализацию параметров первичного конструктора, в том числе сделав их доступными только для чтения (без сеттера) или только для инициализации.
// public double Degrees {get; set;}
// Параметры первичного конструктора можно переопределить, чтобы они были просто полями.
public int Seconds = Seconds;
}
```
Для объявления записи в качестве значимого типа нужно просто добавить ключевое слово `struct` между контекстным ключевым словом `record` и именем типа данных. Как и в классах записей, вы также можете объявить **первичный конструктор** сразу после имени типа данных. Это объявление указывает компилятору сгенерировать публичный конструктор (т. е. `Angle [double Degrees, double Minutes, int Seconds]`), который присваивает полям и свойствам (т. е. членам `degrees`, `minutes`, и `seconds`) соответствующие значения параметров конструктора. Если это не было объявлено явно, компилятор C# сгенерирует свойства в соответствии с параметрами первичного конструктора (т.е. Degrees). Конечно, вы можете добавить дополнительные элементы в структуру записей и переопределить сгенерированные свойства кастомными реализациями, даже если модификатор доступа не является публичным или свойство доступно только для чтения, только для инициализации или и для чтения, и для записи.
Структуры записей обладают теми же преимуществами, что и классы записей, за исключением поддержки иерархий наследования. Например, методы равенства (`Equals(), !=, == и GetHashCode()`) автоматически генерируются во время компиляции. В конце концов, вероятно, именно эти методы являются ключевой фичей, подкупающей в этой языковой конструкции. Кроме того, как и классы записей, структуры записей включают реализацию по умолчанию для `ToString()`, которая обеспечивает форматированный вывод значений свойств. (`ToString()` для инстанса `Angle` возвращает `Angle { Degrees = 30, Minutes = 18, Seconds = 0 }`). В дополнение к предыдущему, структуры записей включают в себя метод деконструкции, который позволяет преобразовать инстанс этого типа в набор переменных, в соответствии с первичным конструктором: т. е. `(int degrees, int minutes, int seconds) = new Angle(30, 18, 42)`. Последняя фича, общая для обоих типов записей, — это оператор with, который позволяет клонировать запись в новый инстанс, при необходимости с изменением выбранных свойств. Вот пример:
```
public static Angle operator +(Angle first, Angle second)
{
(int degrees, int minutes, int seconds) = (
(first.Degrees + second.Degrees),
(first.Minutes + second.Minutes),
(first.Seconds + second.Seconds));
return first with
{
Seconds = seconds % 60,
Minutes = (minutes + (int)(seconds / 60)) % 60,
Degrees = (int)(degrees + (int)((minutes +
(int)(seconds / 60)) / 60)) % 360
};
}
```
И, как бонус, в C# 10.0 поддержка `with` была добавлена и для структур (не только структур записей).
В отличие от классов записей, структуры записей всегда наследуются от `System.ValueType`, поскольку они являются значимыми типами .NET и, следовательно, какое-либо дополнительное наследование для них не поддерживается. Кроме того, структуры записей могут быть объявлены к квалификатором `readonly` `(readonly record struct Angle {})`, что делает их иммутабельными после полного инстанцирования экземпляра. При наличии модификатора `readonly`, компилятор будет проверять, что никакие поля (включая автоматические поля поддержки свойств) не были изменены после завершения инициализации объекта. Как показано на примере параметра `Seconds` в первичном конструкторе, еще одно отличие структур записей заключается в том, что вы можете переопределить поведение первичного конструктора для генерации полей, а не свойств.
Кроме того, теперь вы можете объявлять записи ссылочного типа с применением ключевого слова `class` (использование простой формы `record` по-прежнему допустимо), тем самым обеспечивая симметрию между двумя типами объявления
```
record class FingerPrint(
string CreatedBy, string? ModifiedBy = null) {}
```
Примечание: В классификатор `readonly` не разрешен для классов записей.
#### Мутабельные структуры записей
Я хочу обратить ваше внимание на то, что, в отличие от класса записей, параметры первичного конструктора структуры записей доступны для чтения и записи по умолчанию (по крайней мере на момент написания статьи, в Visual Studio Enterprise 2022 Preview [64-bit] Version 17.0.0 Preview 3.1). Такое поведение по умолчанию меня удивляет по двум причинам:
* Исторически сложилось, что структуры объявляются иммутабельными, чтобы избежать ошибочных попыток модифицировать структуру путем коварного изменения копии. В первую очередь это связано с тем, что передача значимого типа в качестве параметра по определению создает копию. Непреднамеренное изменение копии может не отражается на вызывающем объекте (если не было очевидно или хорошо известно, что тип является значимым). Возможно, более коварным является член, который мутирует инстанс. Представьте себе метод `Rotate()` нашей структуры записей `Angle`, который должен производить поворот своего инстанса `Angle`. Вызов указанного метода из коллекции, т. е. `Angle[0].Rotate(42,42,42)`, непреднамеренно не изменяет значение, хранящееся в `angle[0]`.
* По правде говоря, мутабельные значимые типы были гораздо более проблематичными, когда их изменение внутри коллекции было допустимо. Однако что-то вроде `Angle[0].Degrees = 42` теперь предотвращается компилятором, даже если `Degrees` доступен для записи, что предотвращает неожиданное отсутствие изменения `Degrees`.
* Мутабельные структуры записей по умолчанию были бы непоследовательным решением при наличии классов записей. Последовательное поведение является сильным мотиватором, когда речь идет об обучении, понимании и запоминании.
Несмотря на эти соображения, все-таки есть пару важных доводов в пользу мутабельных структур записей:
* Использование структуры в качестве ключа в словаре не сопряжено с таким же большим риском потеряться в словаре (при условии, что не предоставляется никаких самомодифицирующийся членов).
* Существуют вполне разумные сценарии, в которых мутабельные поля не вызывают проблем (например, с `System.ValueTuple`).
* Поддержка мутабельности и полей в структурах записей позволяет легко “проапгрейдить” кортежи до структур записей.
* Структуры записей и так включают квалификатор `readonly`, который делает их иммутабельными (с помощью всего одного ключевого слова!).
*Примечание:* На момент написания этой статьи в начале сентября 2021 г. решение по мутабельности по умолчанию еще не принято окончательно.
Разработчикам относительно редко требуются кастомные значимые типы, поэтому я дал этой фиче тег `#UsedOccasionaly`. Тем не менее, я очень оценил насколько тщательно была продумана возможность определения значимых типов записей. Что еще более важно, почти все значимые типы требуют реализации равенства. По этой причине я предлагаю вам принять на вооружение новый гайдлайн написания кода: если вам необходимо определить структуру, используйте структуры записей.
### Конструкторы по умолчанию (без параметров) для структур
C# никогда не допускал использования конструкторов по умолчанию (конструктора без параметров) в структурах. Без них также не возможна поддержка инициализаторов полей в структурах, потому что у компилятора нет места для внедрения кода. В C# 10.0 этот разрыв между структурами и классами устранен благодаря возможности определять конструктор по умолчанию для структур (включая структуры записей) и разрешать инициализаторы полей (и свойств) в структурах. В следующем фрагменте кода приведен пример данной возможности:
```
public record struct Thing(string Name)
{
public Thing() : this("")
{
Name = Id.ToString();
}
public Guid Id { get; } = Guid.NewGuid();
}
```
В этом примере мы определяем свойство ID, которому назначается инициализатор свойства. Кроме того, определен конструктор по умолчанию, который инициализирует свойство `Name` значением `Id.ToString()`. Важно отметить, что компилятор C# внедряет инициализатор поля/свойства в начало конструктора по умолчанию. Такое расположение гарантирует, что компилятор C# создаст первичный конструктор для структуры, а также гарантирует, что он вызывается до оценки (evaluation) тела конструктора по умолчанию. Концептуально это очень похоже на то, как ведут себя конструкторы классов. Инициализаторы свойств и полей также выполняются внутри сгенерированного первичного конструктора, чтобы гарантировать, что эти значения будут установлены до выполнения тела конструктора по умолчанию. В результате ID будет уже установлен к моменту выполнения определяемой пользователем части конструктора. Имейте в виду, что компилятор энфорсит вызов конструктора `this()`, когда первичный конструктор указан в структуре записей.
Поскольку конструкторы по умолчанию ранее были недоступны, гайдлайны требовали, чтобы значения по умолчанию (обнуленные) были валидны даже в неинициализированном состоянии. К сожалению, то же самое верно даже при наличии конструкторов по умолчанию, потому что обнуленные блоки памяти по-прежнему используются для инициализации структур. Например, при создании массива из `n` элементов `Thing`, т. е. `var Things = new Thing[42]`, или когда поля/свойства-члены не устанавливаются в содержащем типе до непосредственного доступа к ним.
### Еще несколько улучшений из C# 10.0
C# 10.0 принес еще несколько упрощений. Я отношу их к категории “вы не знали, что это невозможно, пока не попробовали”. Другими словами, если вы сталкивались с такими сценариями раньше, вы, вероятно, сильно разочаровывались, но находили обходной путь и жили дальше. В C# 10.0 некоторые из таких проблем устранены. Ниже приведен список этих фич вместе с примерами кода.
#### Улучшенный анализ явного присваивания
```
string text = null;
if (
text?.TryIntParse(
out int number) == true)
{
number.ToString(); // Undefined error
}
```
Иногда область видимости параметра `out`, объявленного встроенным в метод, не распространялась в блок операторов. Это усовершенствование также повышает качество анализа нулевых ссылок для ссылочных типов.
#UsedRarely
#### Классы записей с sealed ToString()
```
public record class Thing1(string Name)
{
public sealed override string
ToString() => Name;
}
```
Вы можете указать в классах записей метод `ToString()` как `sealed`, чтобы предотвратить переопределение реализации подтипами и потенциальное искажение изначальной цели метода. Это невозможно в структурах записей, поскольку наследование там не поддерживается.
#UsedRarely
#### Расширенная директива #Line
```
#line 42 "8. LineDirectiveTests.cs"
throw new Exception();
// ^
// |
// Column 13
#line default
```
Это идентифицирует начальный символ в директиве `#line` на основе первого символа следующей строки. В этом примере первый символ `t` в `throw` определяет номер столбца.
#UsedRarely
#### Переопределение AsyncMethodBuilder
```
[AsyncMethodBuilder(
typeof(AsyncValueTaskMethodBuilder))]
public readonly struct ValueTask :
lEquatable
{
//…
}
```
Это позволяет каждому асинхронному методу указывать собственный `AsyncMethodBuilder`, а не полагаться только на построитель, указанный в классе.
#UsedRarely
#### Расширенные шаблоны свойств
```
// C# 8.0 syntax:
// if(person is
// { Name: {Length: :0} }) {}
if (person is { (Name.Length: 0 })
{
throw new InvalidOperationException(
@$"Invalid {
nameof(Person.Name)}.");
}
```
Вместо использования фигурных скобок для обхода цепочки свойств C# 10.0 допускает “точечную” нотацию, которую куда легче воспринимать. Забегая вперед, вполне разумным гайдлайном по написанию кода будет: обязательно используйте синтаксис точечной нотации при сопоставлении шаблонов свойств.
#UsedOccasionally
#### Улучшение интерполяции строк
Разрешение ассоциации с константной интерполированной строкой — это значительное улучшение производительности для интерполированных строк в целом. В прошлом интерполированная строка в конечном итоге приводила к вызову `string.Format()`, что является неэффективной реализацией, учитывая чрезмерное упаковывание, вероятную аллокацию массива аргументов, инстанцирование строки и невозможность использовать Span. Многое из этого было исправлено в улучшениях компилятора NET 6.0 и C#. Подробности доступны в отличной статье Стивена Туба (Stephen Toub) “Интерполяция строк в C# 10.0 и NET 6”, которую можно найти по ссылке [devblogs.microsoft.com/dotnet/string-interpolation-in-c-10-and-net-.6/](https://devblogs.microsoft.com/dotnet/string-interpolation-in-c-10-and-net-.6/).
#UsedFrequently
### Что не попало в C# 10.0
Несколько запланированных фич C# 10.0 все-таки не дошли до релиза.
* `nameof(parameter)` внутри конструктора атрибута не будет поддерживаться.
* Не будет оператора проверки параметра на `null`, который декорирует параметр, а затем выдает исключение, если используется значение `null`.
* Общие (generic) атрибуты, которые включают параметр типа при использовании атрибута.\*
* Статические абстрактные члены в интерфейсах, вынуждающие реализующий тип предоставлять такие член.\*
* Обязательные свойства, чтобы гарантировать, что значение будет установлено способом, проверяемым во время компиляции, до завершения построения.
* Ключевое слово поля, которое практически устраняет необходимость в объявлении отдельного поля. \*
Элементы со звездочкой (\*) доступны в предварительной версии C# 10.0, но ожидается, что они будут удалены в финальном релизе.
Из этих фичя больше всего с нетерпением ждал появления оператора проверки на null, но в то же время я надеюсь, что появится более универсальное решение, обеспечивающее проверку параметров не только на `null`. Поддержка `nameof(parameter)` в атрибутах метода также будет полезна как для `CallerArgumentExpression`, так и для ASP.NET и Entity Framework.
### Заключение
C# 10.0 привносит множество относительно небольших “улучшений”; Я не рассматриваю их как новые фичи. Скорее, это те вещи, которые, как я ранее предполагал, уже возможны, но наткнулся бы на ошибку компилятора после написания кода. Теперь, с улучшениями C# 10.0, я, скорее всего, больше не вспомню то время, когда они не работали.
Помимо улучшений, по общему мнению, в C# 10.0 нет ничего революционного, но он, безусловно, включает некоторые фичи, которые изменят способ написания кода: глобальное использование директив и файловых объявлений пространств имен, и это лишь некоторые из них. Хотя это то, что я редко буду писать сам, я очень хочу, чтобы разработчики библиотек логирования, отладки и модульного тестирования обновили свои API с поддержкой атрибутов выражений аргументов вызывающей стороны. Новые API упростят диагностику. И, хотя я думаю, что определение пользовательских значения требуется довольно редко, добавление структур записей, безусловно, упрощает эту задачу благодаря встроенной реализации равенства. По одно только этой причине я подозреваю, что редко будет определяться пользовательский значимый тип без использования структуры записей.
Подытожив, C# 10.0 — долгожданное дополнение со здоровым набором фич и улучшений — на самом деле достаточно улучшений, чтобы я теперь фрустрировал всякий раз, когда мне придется программировать на более ранней версии C#.
---
Приглашаем всех желающих на открытое занятие «Развертывание ASP.NET Core приложений в Azure». На вебинаре мы рассмотрим, что из себя представляет облачная платформа Azure, а также проведем демо по развертыванию ASP.NET Core приложения с помощью Azure App Service. Регистрация доступна [**по ссылке.**](https://otus.pw/XaJ0/)
|
https://habr.com/ru/post/664228/
| null |
ru
| null |
# GitLab 11.7 поставляется с Releases, Multi-level Child Epics и реестром NPM
### Управление релизами стало намного проще
GitLab 11.7 выпускает [Releases](https://about.gitlab.com/2019/01/22/gitlab-11-7-released/#publish-releases-for-your-projects) в GitLab Core. Теперь у пользователей есть снэпшоты релиза, включающие не только исходный код, но и все связанные артефакты. Больше не надо вручную собирать исходный код, выходные данные сборки и прочие метаданные или артефакты, связанные с выпущенной версией вашего кода. Кроме того, Releases — основа для более широкого и надежного взаимодействия релизов в будущем.
### Управление портфелем поддерживает более сложные структуры декомпозиции работ
[Multi-level Child Epics](https://about.gitlab.com/2019/01/22/gitlab-11-7-released/#multi-level-child-epics) — это новейшее дополнение к управлению портфелем GitLab, доступное в Ultimate. Child Epics позволяют создавать многоуровневые рабочие структуры, помогая управлять более сложными проектами и рабочими планами. Теперь эпик содержит как задачи, так и эпики. Такая структура обеспечивает прямую связь между планируемыми и реализуемыми задачами для их внедрения.
### Оптимизация разработки JavaScript с помощью реестров NPM
Gitlab 11.7 Premium поставляет [реестры NPM](https://about.gitlab.com/2019/01/22/gitlab-11-7-released/#npm-registry) непосредственно в GitLab, предоставляя стандартный, более безопасный способ совместного использования и контроля версий пакетов NPM между проектами. Просто поделитесь именем пакета, а NPM и GitLab обработают все остальное в одном интерфейсе!
### И многое другое
Определить, какие функции наших ежемесячных релизов являются главными, — тяжкий выбор, поэтому назовем пару дополнительных интересных функций:
* [Устранить уязвимость с помощью файла коррекции](https://about.gitlab.com/2019/01/22/gitlab-11-7-released/#remediate-vulnerability-with-patch-file): Как вы знаете, функции безопасности GitLab помогают обнаружить уязвимые объекты. С GitLab 11.7 появится возможность исправить эту уязвимость и предложить решение для проектов Node.js, управляемых с помощью Yarn. И хотя это наша первая официальная функция исправления, можете быть уверены: это только начало!
* [Интеграция API с Kubernetes](https://about.gitlab.com/2019/01/22/gitlab-11-7-released/#api-support-for-kubernetes-integration): Если вы создаете много кластеров или считаете себя виртуозом Kubernetes, то вот вам API Kubernetes — он значительно сократит ручные действия и сильно облегчит вам жизнь!
* [Просмотр конвейера между проектами](https://about.gitlab.com/2019/01/22/gitlab-11-7-released/#cross-project-pipeline-browsing): Благодаря возможности просмотра конвейеров между проектами, вы можете легко узнать, какая информация у вас под рукой!
Дальше — полный список возможностей для GitLab 11.7!
Основные функции, добавленные в выпуск GitLab 11.7
--------------------------------------------------
### Публикация релизов для ваших проектов
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Наша новая функция Releases добавляет возможность создавать релизы в GitLab и просматривать их на сводной странице. Релизы представляют собой снэпшот источника, ссылок и других метаданных или артефактов, связанных с выпущенной версией вашего кода, и позволяют пользователям вашего проекта легко находить последнюю выпущенную версию вашего кода.
[Документация](https://docs.gitlab.com/ee/user/project/releases/index.html)
[Задача](https://gitlab.com/gitlab-org/gitlab-ce/issues/41766)
### Многоуровневые дочерние эпики (Multi-level Child Epics)
(Доступно в: ULTIMATE, GOLD)
Эпики и задачи прекрасно работают вместе, обеспечивая гибкость в определении долгосрочных планов работы. Однако они все еще имеют лимит — предоставляют только двухслойную структуру.
В этом выпуске мы представляем дочерние эпики. Теперь у вас может быть эпик, содержащий как задачи, так и эпики. Это позволяет создавать многоуровневые рабочие структуры. Представляйте даже более долгосрочные стратегические инициативы или цели организации как эпики высокого уровня, а под ними будет еще несколько уровней эпиков — разбивайте их на более ощутимые результаты, вплоть до задач.
[Документация](https://docs.gitlab.com/ee/user/group/epics/)
[Задача](https://gitlab.com/gitlab-org/gitlab-ee/issues/8333)
### Просмотр конвейера между проектами
(Доступно в: PREMIUM, ULTIMATE, SILVER, GOLD)
Расширяйте восходящие или нисходящие межпроектные конвейеры прямо из вида конвейера, обеспечивая видимость сквозных конвейеров? — независимо от того, в каком проекте они начинаются или заканчиваются.
[](https://habrastorage.org/webt/ba/rx/kd/barxkd2-oj5zkdixvcapanlccem.png)
[Документация](https://docs.gitlab.com/ee/ci/pipelines.html#pipeline-graphs)
[Задача](https://gitlab.com/gitlab-org/gitlab-ee/issues/2122)
### Устранить уязвимость с помощью файла коррекции
(Доступно в: ULTIMATE, GOLD)
GitLab обнаруживает различные типы уязвимостей в ваших приложениях, а также предлагает возможные способы их устранения.
Начиная с GitLab 11.7, вы можете скачать файл коррекции и применить его к своему репозиторию с помощью команды `git apply`. Потом отправьте изменение обратно в репозиторий, и [панель мониторинга безопасности](https://docs.gitlab.com/ee/user/project/security_dashboard.html) подтвердит, что уязвимость исчезла! Процесс разрешения — проще, а время, необходимое для развертывания решения, — меньше. Сейчас мы поддерживаем уязвимости сканирования зависимостей для менеджера пакетов `yarn`, и для того, чтобы это работало, не нужно ничего менять. Патч будет доступен всегда, когда это возможно, в окне сведений об уязвимости.
[](https://habrastorage.org/webt/sb/tb/ew/sbtbewbo6_mcged1j0mfrfco0ae.png)
[Документация](https://docs.gitlab.com/ee/user/project/merge_requests/#solutions-for-dependency-scanning-ultimate)
[Задача](https://gitlab.com/gitlab-org/gitlab-ee/issues/5656)
### Настройте секреты приложения Kubernetes как переменные
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Операторам и администраторам надо, чтобы настройка секретной информации осуществлялась вне хранилища приложения — чтобы снизить риск и уязвимость конфиденциальных данных. Теперь GitLab предлагает возможность конфигурировать секретные данные как переменные среды, которые становятся доступными для приложения в кластере Kubernetes.
Просто добавьте в свою переменную `K8S_SECRET_`, и соответствующий конвейер CI примет секретную переменную вашего приложения, чтобы заполнить секрет Kubernetes.
[](https://habrastorage.org/webt/dw/8w/gy/dw8wgyjcqr8egpece9g1rp5rmfi.png)
[Документация](https://docs.gitlab.com/ee/topics/autodevops/#application-secret-variables)
[Задача](https://docs.gitlab.com/ee/topics/autodevops/#application-secret-variables)
### Реестр NPM
(Доступно в: PREMIUM, ULTIMATE, SILVER, GOLD)
Разработчики JavaScript нуждаются в безопасном, стандартизированном способе совместного использования и управления версиями пакетов NPM между проектами. Реестр NPM предлагает разработчикам сервисов низкого уровня способ публикации своего кода именно таким способом.
В GitLab 11.7 мы с гордостью предлагаем реестры NPM, встроенные непосредственно в GitLab. Можно совместно использовать простое соглашение об именах пакетов для использования этой библиотеки в любом проекте Node.js, а NPM и GitLab сделают все остальное, используя единый интерфейс. Функция доступна в GitLab Premium.
Вот [пример проекта](https://gitlab.com/gitlab-org/examples/npm-publish), который собирает и передает в реестр GitLab NPM. Как все просто!
[](https://habrastorage.org/webt/xc/cm/cb/xccmcbc59ankcdjdgquzf5vgmay.png)
[Документация](https://docs.gitlab.com/ee/user/project/packages/npm_registry.html)
[Задача](https://gitlab.com/gitlab-org/gitlab-ee/issues/5934)
### Поддержка API для интеграции с Kubernetes
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
В этом выпуске мы добавили в нашу интеграцию с Kubernetes поддержку API. Все действия, доступные сейчас в графическом интерфейсе: такие как перечисление, добавление и удаление кластера Kubernetes, — теперь доступны и через API. Команды используют новый функционал для создания кластера в рамках своего рабочего процесса.
[Документация](https://docs.gitlab.com/ee/api/project_clusters.html)
[Задача](https://gitlab.com/gitlab-org/gitlab-ce/issues/40473)
Другие улучшения в GitLab 11.7
------------------------------
### Поле фильтра поиска для навигации по доске задач
(Доступно в: STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD)
Команды часто используют много досок задач для конкретного проекта или панели. Это затрудняет навигацию по выпадающему списку — если список очень длинный. В этом выпуске мы представляем фильтр поиска. Просто введите несколько символов в поле фильтра, чтобы быстро сузить список задач, которые вас интересуют.
[Документация](https://docs.gitlab.com/ee/user/project/issue_board.html#multiple-issue-boards-starter)
[Задача](https://gitlab.com/gitlab-org/gitlab-ee/issues/7715)
### Редизайн списка проектов
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Проекты — полноправные резиденты GitLab, и мы хотим сделать списки проектов визуально приятными и удобными для анализа.
В GitLab 11.7 мы представили редизайн пользовательского интерфейса для списка проектов: особый упор — на удобочитаемость и краткое описание деятельности проекта. Мы предоставили каждой строке проекта дополнительную информацию о проекте и пробелы, и [продолжим итерацию](https://gitlab.com/gitlab-org/gitlab-ce/issues/55669) дизайна на основе обратной связи.
[](https://habrastorage.org/webt/st/k_/xt/stk_xtafgnk7leam0nq_mm88wia.png)
[Документация](https://docs.gitlab.com/ee/user/project/)
[Задача](https://gitlab.com/gitlab-org/gitlab-ce/issues/51944)
### Поддержка универсальных почтовых ящиков, включая Microsoft Exchange и Google Groups, для функций входящей электронной почты
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
GitLab обладает некоторыми замечательными фичами, которые используют входящую электронную почту. Например, [ответ по электронной почте](https://docs.gitlab.com/ee/administration/reply_by_email.html), [новая задача по электронной почте](https://docs.gitlab.com/ee/user/project/issues/create_new_issue.html#new-issue-via-email), [новый мерж-реквест по электронной почте](https://docs.gitlab.com/ee/user/project/merge_requests/index.html#create-new-merge-requests-by-email) и [служба поддержки](https://docs.gitlab.com/ee/user/project/service_desk.html). Ранее эти функции можно было использовать, только используя сервер электронной почты, настроенный на субадресацию.
GitLab теперь поддерживает почтовые ящики электронной почты с субадресацией и перехватом, используя новый формат электронной почты, что позволяет использовать больше почтовых серверов с GitLab, включая Microsoft Exchange и Google Groups (которые не поддерживают субадресацию).
[Документация](https://docs.gitlab.com/ee/administration/incoming_email.html)
[Задача](https://gitlab.com/gitlab-org/gitlab-ce/issues/29951)
### Импорт задач CSV
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Зачастую команды, начиная пользоваться GitLab, используют разные инструменты и устаревшие данные. Возможно, вы сейчас используете Jira, но хотели бы перейти к задачам GitLab.
Теперь переход стал проще. Многие системы отслеживания проблем допускают экспорт CSV, так что импортируйте такой экспорт задач в GitLab — это позволит продолжать управлять существующей работой, импортируя устаревшие данные в GitLab, и, по мере необходимости, осуществлять поиск и извлечение. Это будет работать с Jira или любой системой отслеживания задач, которая генерирует экспорт CSV.
GitLab также имеет [функцию экспорта в CSV](https://docs.gitlab.com/ee/user/project/issues/csv_export.html).
[Документация](https://docs.gitlab.com/ee/user/project/issues/csv_import.html)
[Задача](https://gitlab.com/gitlab-org/gitlab-ce/issues/49231)
### SHA короткой фиксации доступен в качестве переменной среды
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Git SHA — это 40-символьные указатели на конкретные объекты (т.е. коммиты) в репозитории Git. Зачастую отображать полную строку — громоздко, и хочется показать первые восемь символов в качестве быстрой (хотя и не гарантированно уникальной) ссылки. Для этой цели мы добавили переменную среды `CI_COMMIT_SHORT_SHA` в конвейер CI, что даст вам первую часть создаваемого SHA коммита.
[Документация](https://docs.gitlab.com/ee/ci/variables/#predefined-variables-environment-variables)
[Задача](https://gitlab.com/gitlab-org/gitlab-ce/issues/48061)
### Более строгие ограничения на самоутверждение
(Доступно в: STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD)
Проверка кода — это неотъемлемая практика каждого успешного проекта, и проводить ее должен не автор изменения. По умолчанию самоутверждение мерж-реквестов не разрешено, но критерием для запрета служит не коммит в мерж-реквесте, а авторство запроса.
Начиная с GitLab 11.7, эти ограничения также не дают авторам утверждать собственные изменения в мерж-реквестах. Так что изменения, созданные несколькими инженерами, получают полностью независимые ревью кода и одобрения.
[Документация](https://docs.gitlab.com/ee/user/project/merge_requests/merge_request_approvals.html#eligible-approvers)
[Задача](https://gitlab.com/gitlab-org/gitlab-ee/issues/3845)
### Поддержка авторизации для выборки инклудов
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Когда включаете в определение конвейера внешние файлы с использованием ключевого слова `include`, они выбираются с использованием запросов HTTP / HTTPS. Теперь вы сможете получить доступ к yamls в другом проекте без открытого доступа (например, частный проект на GitLab.com), используя учетные данные, с которыми работает конвейер.
[Документация](https://docs.gitlab.com/ee/ci/yaml/#include)
[Задача](https://gitlab.com/gitlab-org/gitlab-ce/issues/53903)
### Фильтр уязвимостей в панели безопасности группы
(Доступно в: ULTIMATE, GOLD)
Панель безопасности группы позволяет командам безопасности держать все под контролем, показывая уязвимости, которые влияют на их группы.
С помощью GitLab 11.7 фильтруйте отображаемые уязвимости по серьезности, типу отчета и имени проекта. Благодаря этой способности можно сосредоточиться на том, что нужно, и быстрее получать доступ к своим данным, что особенно полезно, когда в списке много записей.
[](https://habrastorage.org/webt/2n/n8/wx/2nn8wxcumnjh_t_6jxx8fdowtl4.png)
[Документация](https://docs.gitlab.com/ee/user/group/security_dashboard/#viewing-the-vulnerabilities)
[Задача](https://gitlab.com/gitlab-org/gitlab-ee/issues/6240)
### Показать результаты сканирования зависимостей на панели безопасности группы
(Доступно в: ULTIMATE, GOLD)
Панель безопасности группы была первоначально выпущена только с результатами [SAST](https://docs.gitlab.com/ee/user/project/merge_requests/sast.html), поэтому пользователи не могли управлять другими типами уязвимостей с помощью этой функции.
С GitLab 11.7 к набору доступных данных добавляются результаты [сканирования зависимостей](https://docs.gitlab.com/ee/user/project/merge_requests/dependency_scanning.html). Если вы уже используете [новый синтаксис отчета](https://docs.gitlab.com/ee/ci/yaml/#artifactsreportsdependency_scanning-ultimate), то автоматически увидите результаты на информационной панели. Шаблон [Auto DevOps](https://docs.gitlab.com/ee/topics/autodevops/) также обновлен, и теперь для правильного выполнения задания сканирования зависимостей требуется [GitLab Runner](https://docs.gitlab.com/runner/) 11.5 или выше.
[](https://habrastorage.org/webt/ob/ms/jn/obmsjn3qrhjp8ny2shlhkx_njhk.png)
[Документация](https://docs.gitlab.com/ee/user/group/security_dashboard/#supported-features)
[Задача](https://gitlab.com/gitlab-org/gitlab-ee/issues/8481)
### Включить файлы CI / CD из других проектов и шаблонов
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Ключевое слово `include` позволяет пользователям динамически создавать конвейеры CI/CD, включая в конфигурацию внешние файлы. Ранее это было возможно только для файлов в репозитории проекта или для удаленных файлов, загружаемых по HTTP.
С GitLab 11.7 включайте свои фрагменты конфигурации также из других проектов и из предопределенных шаблонов. GitLab будет включать фрагменты для определенных заданий (jobs), таких как `sast` или `dependency_scanning`, так что пользователи могут ссылаться на них, а не копипастить текущее определение. Задания будут автоматически обновлены до последней версии вместе с GitLab, поэтому вручную ничего изменять не надо.
[](https://habrastorage.org/webt/rx/cy/a_/rxcya_t1v7j0xhnujhyw_pika9q.png)
[Документация](https://docs.gitlab.com/ee/ci/yaml/#include)
[Задача](https://gitlab.com/gitlab-org/gitlab-ce/issues/53445)
### Режим RBAC по умолчанию для создания кластера Kubernetes
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Без защиты кластера Kubernetes, нельзя контролировать и ограничивать доступ к кластеру, а также определять, кому какие действия в нем разрешены.
Начиная с GitLab 11.7, все кластеры на момент создания по умолчанию будут поддерживать RBAC, обеспечивая более безопасную и защищенную инфраструктуру.
[Документация](https://docs.gitlab.com/ee/user/project/clusters/#role-based-access-control-rbac)
[Задача](https://gitlab.com/gitlab-org/gitlab-ce/issues/53696)
### Поддержка частных пакетов Go в подгруппах
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Пакеты Go, размещенные в GitLab, можно установить с помощью `go get`, однако эта функция не поддерживалась частными проектами в подгруппах. Начиная с GitLab 11.7, любой проект можно использовать в качестве пакета Go, включая частные проекты в подгруппах.
Частные пакеты поддерживаются командой `go get` с использованием файла `.netrc` и с использованием токена личного доступа в поле пароля.
Благодарим [МортиЧои](https://gitlab.com/mortyccp) за внесенный вклад!
[Документация](https://docs.gitlab.com/ee/user/group/subgroups/)
[Задача](https://gitlab.com/gitlab-org/gitlab-ce/issues/45055)
### Поддержка метрик NGINX Ingress 0.16.0+
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
С выпуском [NGINX Ingress 0.16.0](https://github.com/kubernetes/ingress-nginx/blob/master/Changelog.md#0160) метрики Prometheus теперь [встроены изначально](https://github.com/kubernetes/ingress-nginx/pull/2608), а не зависят от внешнего экспортера.
GitLab 11.7 теперь включает [поддержку метрик](https://docs.gitlab.com/ee/user/project/integrations/prometheus_library/nginx_ingress.html), экспортируемых NGINX Ingress 0.16.0+, и автоматически обнаруживает и отображает пропускную способность, задержку и частоту ошибок развертываний.
[Документация](https://docs.gitlab.com/ee/user/project/integrations/prometheus_library/nginx_ingress.html)
[Задача](https://gitlab.com/gitlab-org/gitlab-ce/issues/50431)
### GitLab Runner 11.7
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Сегодня мы также выпустили GitLab Runner 11.7! GitLab Runner — это проект с открытым исходным кодом для запуска заданий CI/CD и отправки результатов обратно в GitLab.
**Самые интересные изменения**:
* [Аннулировать сеанс веб-терминала при отмене сборки](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1058)
* [Исправить разделитель пути для CI\_PROJECT\_DIR в Windows](https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1128)
Список всех изменений можно найти в журнале изменений GitLab Runner: [CHANGELOG](https://gitlab.com/gitlab-org/gitlab-runner/blob/v11.7.0/CHANGELOG.md).
[Документация](https://docs.gitlab.com/runner)
### Пропустить сборку CI во время git push
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Если не надо запускать конвейер CI/CD, в коммитах можно было добавить примечание к сообщению фиксации с помощью `[ci skip]` или `[skip ci]`. Однако многие пользователи не хотят или не могут изменить свои сообщения о фиксации таким образом, чтобы они содержали дополнительную информацию.
Начиная с GitLab 11.7, пользователи могут использовать [параметры Git push](https://git-scm.com/docs/git-push#git-push--oltoptiongt) в Git 2.10 или новее при отправке в GitLab, чтобы предотвратить запуск конвейера для их пуш-уведомления. Использование `git push -o ci.skip` теперь позволит достичь той же цели без каких-либо изменений в сообщении фиксации.
Благодарим [Джонатона Рейнхарта](https://gitlab.com/JonathonReinhart) за внесенный вклад!
[Документация](https://docs.gitlab.com/ee/ci/yaml/#skipping-jobs)
[Задача](https://gitlab.com/gitlab-org/gitlab-ce/issues/18667)
### Улучшение производительности
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Мы продолжаем улучшать производительность GitLab с каждым выпуском для экземпляров GitLab любого размера.
В GitLab 11.7 мы значительно улучшили производительность ревью мерж-реквестов путем [кэширования синтаксиса выделенных дискуссионных различий](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/23857).
Другие заслуживающие внимания улучшения производительности включают в себя:
* [Повышение производительности пуш-уведомлений путем пропуска предварительных проверок, которые были переданы в другие ветви](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/23984)
* [Удаление лишних счетчиков в поиске фрагментов](https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/23952)
* [Ускорение открытия списка форумов при наличии списков правопреемников](https://gitlab.com/gitlab-org/gitlab-ee/merge_requests/9090)
[Улучшения производительности](https://gitlab.com/groups/gitlab-org/merge_requests?scope=all&utf8=%E2%9C%93&state=merged&label_name%5B%5D=performance&milestone_title=11.7)
### Улучшения Omnibus
(Доступно в: CORE, STARTER, PREMIUM, ULTIMATE)
GitLab 11.7 включает в себя [Mattermost 5.6](https://mattermost.com/blog/mattermost-5-6-interactive-message-dialogs-new-admin-tools-ukrainian-language-support-and-more/), [альтернативу Slack с открытым исходным кодом](https://mattermost.com/), новейшая версия которой содержит интерактивные диалоги сообщений, новые инструменты администратора, поддержку украинского языка и многое другое.
[Теперь для официальных GitLab AMI images](https://docs.gitlab.com/ee/install/aws/#choose-the-ami) доступна [расширенная поддержка сети](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/enhanced-networking.html), что позволяет использовать дополнительные типы экземпляров и увеличить пропускную способность.
[Документация](https://docs.gitlab.com/omnibus/)
### Поддержка Debian 7 Wheezy
GitLab 11.7 станет последним релизом с поддержкой Debian 7 Wheezy.
Debian Wheezy больше не поддерживается проектом Debian с [мая 2018 года](https://www.debian.org/releases/wheezy/).
Дата удаления: **22 января 2019 г**.
### Поддержка Raspbian Jessie
GitLab [11.8](https://gitlab.com/groups/gitlab-org/-/milestones/23) станет последним релизом с поддержкой Raspbian Jessie.
Jessie [перешла на LTS](https://www.debian.org/News/2018/20180601), и [последнему Raspbian Jessie image](https://downloads.raspberrypi.org/raspbian/images/raspbian-2017-07-05/) уже больше года. Мы рекомендуем пользователям обновиться до [Raspbian Stretch](https://www.raspberrypi.org/downloads/raspbian/).
Дата удаления: **22 февраля 2019 г.**
### Поддержка CentOS 6 для GitLab Runner
GitLab [11.9](https://gitlab.com/groups/gitlab-org/-/milestones/18) станет последним релизом с поддержкой раннеров для CentOS 6, потому что мы планируем обновиться до более актуальной библиотеки Docker, которая их более не поддерживает. Подробнее смотрите [в данной задаче](https://gitlab.com/gitlab-org/gitlab-runner/issues/3905).
Дата удаления: **22 марта 2019 г.**
### Поддержка Prometheus 1.x в Omnibus GitLab
Начиная с GitLab [11.4](https://gitlab.com/groups/gitlab-org/-/milestones/19), встроенная версия Prometheus 1.0 не включена в Omnibus GitLab. С этого момента [используется Prometheus 2.0](https://about.gitlab.com/2019/01/22/gitlab-11-7-released/#prometheus-20-upgrade-for-omnibus-gitlab), формат метрик которого несовместим с версией 1.0. Существующие версии можно обновить до 2.0 и, при необходимости, перенести данные с [помощью встроенного инструмента](https://docs.gitlab.com/omnibus/update/gitlab_11_changes.html#11-4).
В GitLab версии 12.0 будет автоматически устанавливаться Prometheus 2.0, если обновление еще не было произведено. Данные из Prometheus 1.0 не переносятся и будут утеряны.
Дата удаления: **22 июня 2019 г.**
### TLS v1.1 будет отключен по умолчанию в версии 12.0
Начиная с GitLab [12.0](https://gitlab.com/groups/gitlab-org/-/milestones/33), [TLS v1.1 будет отключен по умолчанию](https://docs.gitlab.com/omnibus/update/gitlab_11_changes.html#tls-v11-deprecation) для повышения безопасности. Это устраняет многочисленные проблемы, включая Heartbleed, и делает GitLab совместимым в исходном состоянии со стандартом PCI DSS 3.1.
Чтобы немедленно отключить TLS v1.1, установите `nginx ['ssl_protocols'] = "TLSv1.2"` в `gitlab.rband` и запустите `gitlab-ctlconfigure`.
Дата удаления: **22 июня 2019 г.**
### Шаблон OpenShift для установки GitLab
Официальная диаграмма [`gitlab` helm](https://docs.gitlab.com/ee/install/kubernetes/gitlab_chart.html) — рекомендуемый метод работы GitLab на Kubernetes, включая [развертывание на OpenShift](https://gitlab.com/charts/gitlab/blob/master/doc/cloud/openshift.md).
[Шаблон OpenShift](https://docs.gitlab.com/ee/install/openshift_and_gitlab/index.html) для установки GitLab устарел и больше не будет поддерживаться в GitLab 12.0.
Дата удаления: **22 июня 2019 г.**
### GitLab Geo обеспечит хэшированное хранение в GitLab 12.0
GitLab Geo требуется [хэшированное хранилище](https://docs.gitlab.com/ee/administration/repository_storage_types.html#hashed-storage) для смягчения гонка фронтов на подчиненных узлах. Это было отмечено в [gitlab-ce#40970](https://gitlab.com/gitlab-org/gitlab-ce/issues/40970).
В версии [11.5](https://gitlab.com/groups/gitlab-org/-/milestones/20) мы добавили это требование в документацию Geo: [gitlab-ee # 8053](https://gitlab.com/gitlab-org/gitlab-ee/issues/8053).
В версии [11.6](https://gitlab.com/groups/gitlab-org/-/milestones/21) `sudo gitlab-rake gitlab: geo: check` проверяет, включено ли хешированное хранилище и все ли проекты переносятся: [gitlab-ee # 8289](https://gitlab.com/gitlab-org/gitlab-ee/issues/8289). Если вы используете Geo, пожалуйста, запустите эту проверку и мигрируйте как можно скорее.
В [11.8](https://gitlab.com/groups/gitlab-org/-/milestones/23) постоянно отключаемое предупреждение [gitlab-ee! 8433](https://gitlab.com/gitlab-org/gitlab-ee/merge_requests/8433) будет отображаться на странице “Admin Area › Geo › Nodes”, если вышеупомянутые проверки не разрешены.
В [12.0](https://gitlab.com/groups/gitlab-org/-/milestones/33) Geo будет применять требование к хэш-хранилищу: [gitlab-ee # 8690](https://gitlab.com/gitlab-org/gitlab-ee/issues/8690).
Дата удаления: **22 июня 2019 г.**
### Google OAuth2 SSO поддерживается только в GitLab 11.7+
7 марта 2019 года Google закрывает все API Google+. Подробнее об анонсе от Google читайте [здесь](https://developers.google.com/+/api-shutdown).
Поскольку версии GitLab до [11.7](https://gitlab.com/groups/gitlab-org/-/milestones/22) используют эти API для Google OAuth2, единый вход Google в этих версиях больше работать не будет. GitLab [11.7](https://gitlab.com/groups/gitlab-org/-/milestones/22) и выше [будет поддерживать Google SSO](https://gitlab.com/gitlab-org/gitlab-ce/issues/55668).
Если для проверки подлинности ваш экземпляр использует Google OAuth2, рекомендуем обновить его до [11.7](https://gitlab.com/groups/gitlab-org/-/milestones/22).
Дата удаления: **7 марта 2019 г.**
### Разработчики могут удалить теги Git в GitLab 11.9
Редактирование / удаление тегов Git в незащищенных ветвях исторически ограничивалось только [сопровождающими и владельцами](https://docs.gitlab.com/ee/user/permissions.html#project-members-permissions).
Поскольку разработчики могут добавлять теги, а также изменять и удалять незащищенные ветви, разработчики должны иметь возможность изменять и удалять теги Git. В GitLab [11.9](https://gitlab.com/groups/gitlab-org/-/milestones/18) [мы вносим это изменение](https://gitlab.com/gitlab-org/gitlab-ce/issues/52954) в нашу модель разрешений — чтобы улучшить рабочий процесс и помочь разработчикам лучше и эффективнее использовать теги.
Дата удаления: **22 марта 2019 г.**
### Интеграция Hipchat
Hipchat [будет прекращен](https://www.atlassian.com/partnerships/slack/faq#faq-2013ca70-3170-4a82-9886-03234e7084c0). Поэтому мы [удаляем существующую функцию интеграции GitLab Hipchat](https://gitlab.com/gitlab-org/gitlab-ce/issues/52424) как часть релиза [11.9](https://gitlab.com/groups/gitlab-org/-/milestones/18).
Дата удаления: **22 марта 2019 г.**
### Барометр обновлений
Чтобы перейти на GitLab версии 11.7 с последней версии 11.6, остановка работы не требуется. Обратитесь к [документации по обновлениям без простоев](https://docs.gitlab.com/ee/update/README.html#upgrading-without-downtime).
Миграция базы данных в этом выпуске может занять от 30 до 60 минут для экземпляров, по размеру аналогичных GitLab.com. Для меньших экземпляров общее время не должно превышать примерно 15 минут.
Мы рекомендуем пользователям GitLab Geo обратиться к документации по [обновлению Geo](https://docs.gitlab.com/ee/administration/geo/replication/updating_the_geo_nodes.html).
### Список изменений
Обратитесь к списку изменений, чтобы просмотреть все изменения:
* [GitLab Community Edition](https://gitlab.com/gitlab-org/gitlab-ce/blob/master/CHANGELOG.md)
* [GitLab Enterprise Edition](https://gitlab.com/gitlab-org/gitlab-ee/blob/master/CHANGELOG-EE.md)
* [GitLab Runner](https://gitlab.com/gitlab-org/gitlab-runner/blob/master/CHANGELOG.md)
### Установка
Если вы настраиваете новую установку GitLab, см. [страницу загрузки GitLab](https://about.gitlab.com/install/).
### Обновление
Ознакомьтесь с нашей [страницей обновлений](https://about.gitlab.com/update/).
### Планы подписок GitLab
GitLab доступен в двух вариантах: [самоуправляемом](https://about.gitlab.com/pricing/#self-managed) и в качестве [облачного сервиса (SaaS)](https://about.gitlab.com/pricing/#gitlab-com).
[Самоуправляемый](https://about.gitlab.com/pricing/#self-managed): Выполните развертывание локально или на вашей любимой облачной платформе.
* **Core**: Для небольших команд, личных проектов или тестирования GitLab с неограниченным временем.
* **Starter**: Для команд, участники которых находятся в одном и том же месте, и занятых небольшим количеством проектов, нуждающихся в профессиональной поддержке.
* **Premium**: Для распределенных команд, которым требуются расширенные функции, высокая доступность и поддержка в режиме 24/7.
* **Ultimate**: Для предприятий, которые хотят согласовать свою стратегию и выполнение проектов с требованиями повышенной безопасности и совместимости.
[Облачный сервис SaaS](https://about.gitlab.com/pricing/#gitlab-com) — **GitLab.com**: поддерживается, управляется и администрируется командой GitLab; возможны [бесплатные и платные подписки](https://about.gitlab.com/pricing/#gitlab-com) для отдельных лиц и команд.
* **Free**: Неограниченные частные репозитории и неограниченное число сотрудников в проекте. Частные проекты получают доступ к функциям **Free**, [открытые проекты](https://gitlab.com/explore) получают доступ к функциям **Gold**.
* **Bronze**: Для команд, которым требуется доступ к более расширенным функциям рабочего процесса.
* **Silver**: Для команд, которым нужны более надежные возможности DevOps, совместимость и более быстрая поддержка.
* **Gold**: Лучше всего подходит при наличии большого количества заданий конвейера CI/CD. Члены команды каждого публичного проекта могут пользоваться функциями **Gold** бесплатно, независимо от их плана подписки.
|
https://habr.com/ru/post/437432/
| null |
ru
| null |
# Фетиш LaTeX (или Не пишите в LaTeX! Он только для вёрстки)
Сейчас то время года, когда студенты выбирают себе классы для обучающих навыков. Один из навыков, который будет поощряться, — обучение LaTeX. Другие могут придти к использованию LaTeX по другим причинам: кто-то хочет сверстать книгу; кто-то слышал, что LaTeX может иметь отношение к журналу Digital Humanities; ну и так далее. Я написал это эссе в качестве предварительного введения в LaTeX. Оно не научит вас использовать редактор (я не имею квалификации для этого!), но я попытаюсь популярно объяснить тем, кто ещё не использует LaTeX, для чего именно он нужен. Это поможет им понять, стоит ли LaTeX усилий на его изучение (не говоря уже о том, чтобы просто *заставить* его работать). Почему такое большое эссе? Потому что многие из евангелистов превратили LaTeX в фетиш и распространяют дезинформацию о его истинных достоинствах. Хочу прояснить ситуацию.
1. Что такое LaTeX?
-------------------
По [словам официального сайта](https://www.latex-project.org/about/), LaTeX — это «высококачественная система набора и вёрстки» и «стандарт де-факто для обмена и публикации научных документов». С этим никто не спорит.
Коммерческая вёрстка книг, журналов и т. д. обычно осуществляется в настольных [WYSIWYG](https://en.wikipedia.org/wiki/WYSIWYG)-приложениях для [подготовки публикаций](https://en.wikipedia.org/wiki/Desktop_publishing), таких как [InDesign](http://www.adobe.com/InDesign), [Scribus](https://www.scribus.net/) или [PageMaker](https://en.wikipedia.org/wiki/Adobe_PageMaker), разработка которого уже прекращена. LaTeX работает иначе: вы даёте ему файл, содержащий текст с кодом (т.е. с [разметкой](https://en.wikipedia.org/wiki/Markup_language)), а он выдаёт файл Postscript, который другая программа может конвертировать в PDF (некоторые варианты напрямую генерируют PDF). Если вы уделили некоторое время чтению (a) статей с конференций по информатике, (b) препринтов научных статей в свободном доступе на [arXiv.org](http://arxiv.org/) или (с) документации [пакетов R](http://cran.r-project.org/), то вам знаком внешний вид этих PDF: названия отцентрированы (но не заголовки), отступ в первой строке каждого абзаца, выровненные строки, обычно широкие поля, если не используется разметка в две колонки, элегантные междусловные пробелы и всё обычно набрано этим странным, старомодным шрифтом, который называется [Computer Modern](https://en.wikipedia.org/wiki/Computer_Modern).
Технически, LaTeX создан на базе TeX: «языка программирования специального назначения, центрального элемента системы набора и вёрстки, которая выдаёт математику (и сопровождающий текст) издательского качества» ([TeX Users Group](https://www.tug.org/whatis.html)). TeX создал в конце 1970-х легендарный учёный в области информатики [Дональд Кнут](http://www-cs-faculty.stanford.edu/~uno/), разочарованный стандартами набора и вёрстки у своего издателя. Первыми пользователями стали математики, по достоинству оценившие математические символы, недоступные на печатной машинке, и красоту математических формул в новой системе. В начале 1980-х другой выдающийся учёный в области информатики [Лесли Лэмпорт](http://www.lamport.org/) расширил TeX и создал LaTeX (добавив к названию первые две буквы своей фамилии). Лэмпорт добавил [макросы](https://en.wikipedia.org/wiki/Macro_(computer_science)) TeX: программы, которые генерируют код TeX вместо вас, в фоне. Очень немногие пытаются писать документы напрямую в TeX. Это слишком трудно. Писать в LaTeX легче. Но это не значит, что писать в LaTeX — хорошая мысль.
2. Фетиш LaTeX
--------------
Многие учёные и математики пишут статьи в формате LaTeX: слова и знаки пунктуации они сопровождают фрагментами кода, компьютерными инструкциями для набора и вёрстки текста вроде «стилизовать этот фрагмент текста как заголовок главы» или «вставить здесь многоточие». Результатом (в идеале) становится приятно выглядящий PDF, который можно отправлять на рецензию в научный журнал. Если журнал примет статью, то автор или авторы могут загрузить более-менее такой же PDF в репозиторий с открытым доступом, а журналу выслать исходный код LaTeX, который будет заново набран и свёрстан. Пользователи LaTeX часто набирают в нём и другие документы: например, диссертации, раздаточные материалы для конференций и резюме. Наверное, так происходит только потому, что хорошо освоив конкретную технологию для некоей конкретной цели, они стремятся применить её для всех остальных задач, где возможно. Но могут быть и более позитивные причины. Набранные в LaTeX документы, как отмечено выше, легко узнаваемы. Отформатированное в LaTeX резюме — это резюме пользователя LaTeX, а пользователя LaTeX воспринимают серьёзно в научных областях, где принято использовать LaTeX. И т.д.
Хотя LaTeX не так неудобен для пользователя, как TeX, написание в нём обычного текста можно считать аномалией. LaTeX — система набора и вёрстки и язык разметки. Системы набора и вёрстки обычно не используются для редактирования текста, и хотя языки разметки вроде [XML](http://www.w3.org/XML/) и [HTML](http://www.w3.org/html/) часто используются таким образом, обычно это считается плохой идеей. Довольно логично утверждается, что «заставлять людей редактировать XML — это садизм» ([Django Project](https://docs.djangoproject.com/ja/1.9/ref/templates/language/)), и хотя на протяжении какого-то времени онлайновый журнал [Digital Humanities Quarterly](http://digitalhumanities.org/dhq/) требовал, чтобы все работы присылали в формате XML (и уникальное разнообразие XML-документов создавалось специально для этой цели), сейчас он [принимает статьи и в форматах популярных текстовых редакторов](http://digitalhumanities.org:8081/dhq/submissions/index.html). Организация Wikimedia Foundation признала требование использовать разметку [wikitext](https://en.wikipedia.org/wiki/Wiki_markup) при создании или редактировании статей одним из барьеров для новых пользователей. Впрочем, попытка реформы была сорвана постоянно уменьшающимся сообществом преданных волонтёров Википедии, среди которых «[не выходит за рамки общепринятого мнение, что облегчение редактирования документов — это потеря времени](https://www.technologyreview.com/s/520446/the-decline-of-wikipedia/)». Я пишу этот блог в слегка упрощённой версии HTML, которая используется в текстовом редакторе WordPress, хотя каждый раз, когда эссе превышает некий размер, я думаю, что лучше бы я этого не делал. Разметка хороша для машин, для чтения и записи, но не настолько хороша для людей. Это хорошо понимали создатели текстовых редакторов вроде Microsoft [Word](https://products.office.com/en-us/word) и LibreOffice [Writer](https://www.libreoffice.org/discover/writer/), которые оба хранят текст в форме XML, но никогда не заставляют пользователя разбираться с реальным XML.
Несмотря на всё это, много текстов пишется именно в LaTeX. Я называю «фетишем LaTeX» убеждение, что в LaTeX есть что-то особенное, что помогает писать в нём тексты. Как мы увидим, аргументы в пользу LaTeX неубедительны на рациональном уровне: в LaTeX на самом деле довольно неудобно писать (хотя могло быть и хуже, например, это мог быть TeX). Это не значит, что от использования LaTeX следует вообще отказаться, но людям хотя бы стоит прекратить рекомендовать его в качестве текстового редактора.
3. Аргумент для написания текста в LaTeX
----------------------------------------
LaTeX лучше подходит для написания текстов, чем TeX, но это немного говорит. Некоторые энтузиасты делают гораздо более громкие заявления, намекая — или прямо заявляя — что написание текстов в LaTeX лучше не только TeX, но даже чем-то лучше, чем набор текста в обычном текстовом редакторе. Например, блог онлайнового редактора [ShareLaTeX](https://www.sharelatex.com/) [даёт такой совет студентам](https://www.sharelatex.com/blog/2013/08/02/thesis-series-pt1.html), которые пишут диссертацию: «Ваша диссертация может стать самым большим и сложным документом, который вы когда-либо напишете, вот почему хорошей идеей будет использовать LaTeX вместо обычного текстового процессора». Более [полный аргумент](https://www.latex-project.org/about/) даёт сам [LaTeX Project](http://latex-project.org/):
> LaTeX — не текстовый процессор! Вместо этого LaTeX поощряет авторов не слишком беспокоиться о внешнем виде своих документов, а сконцентрироваться на правильном содержании. Например, возьмём следующий документ:
>
> *> Декартово замкнутые траектории и стоимость яиц
> >
> > Джейн Доу
> >
> > Сентбярь 1994
> >
> >
> >
> > Hello world!* Для набора такого текста в большинстве систем вёрстки или текстовых процессорах автору нужно разметить текст, например, выбрать шрифт Times Roman величиной 18 пунктов для заголовка, шрифт Times Italic 12 пунктов для имени и так далее. Это приводит к двум результатам: авторы тратят время на оформление и появляется много плохо оформленных документов!
>
>
>
> LaTeX основан на идее, что оформление документа лучше оставить дизайнерам, а авторы пусть сконцентрируются на написании текста. Так что в LaTeX вы введёте такой документ следующим образом:
>
>
>
>
> ```
> \documentclass{article}
> \title{Cartesian closed categories and the price of eggs}
> \author{Jane Doe}
> \date{September 1994}
> \begin{document}
> \maketitle
> Hello world!
> \end{document}
> ```
>
Это вполне стандартное объяснение, почему люди предпочитают использовать LaTeX вместо текстового процессора. Мне много раз встречались различные варианты такого объяснения. Например, на момент написания этой статьи страница Википедии, посвящённая LaTeX, [утверждает следующее](https://en.wikipedia.org/w/index.php?title=LaTeX&oldid=736123000): «LaTeX следует философии отделения представления от содержания, так что авторы могут сконцентрироваться на содержании своих текстов, не отвлекаясь одновременно на визуальное оформление». В презентации с подзаголовком «[Правильный способ создания документов](http://web.mit.edu/rsi/www/pdfs/new-latex.pdf)» сотрудник MIT Research Science Institute однозначно отвечает на вопрос, почему следует использовать LaTeX: «Представление не должно мешать контенту», а затем объясняет этот тезис, сравнивая текстовые процессоры и LaTeX — причём в этих сравнениях неизменно побеждает LaTeX:
> * В текстовом процессоре вы тратите драгоценное время в муках, какой размер шрифта выбрать для заголовков разделов.
>
> В LaTeX вы просто сообщаете о начале нового раздела.
> * В текстовом процессоре изменение форматирования означает, что вам придётся менять каждый элемент по отдельности.
>
> В LaTeX вы просто переопределяете соответствующие команды.
> * В текстовом процессоре вам следует аккуратно следовать всем шаблонам.
>
> В LaTeX вы всегда уверены, что соответствуете всем шаблонам, и легко переключаетесь между ними.
>
Эти текстовые процессоры выглядят ужасно, правда? А LaTeX выглядит замечательно, разве нет? Теперь я буду с вами честным. Некоторое время я принимал такие аргументы за чистую монету и более-менее часто сам повторял их как часть [опубликованных обсуждений академической грамотности](http://www.danielallington.net/communicating-in-english-talk-text-technology/):
> В то время как на старинных механических печатных машинках трудно изменить внешний вид символов, популярные компьютерные операционные системы поставляются с большим набором цифровых шрифтов, предоставляя миллионам пользователей доступ к современным шрифтам, таким как Helvetica, Gill Sans и Calibri, а также к старинным шрифтам вроде семейства Garamond. Подобные возможности можно считать отвлекающим фактором, вот почему многие учёные отказываются от текстовых редакторов в пользу LaTeX: язык разметки документов, который помогает забыть о том, как будет выглядеть текст, и сконцентрироваться на его концептуальной структуре.
Так что это официальная причина, почему LaTeX считается хорошим редактором. Текстовые процессоры заставляют вас «слишком сильно беспокоиться о внешнем виде [ваших] документов», что является «отвлекающим фактором», а работа в LaTeX позволяет «сфокусироваться на содержании того, что [вы] пишете, не обращая внимания одновременно на визуальное оформление документа». Это полезно, чтобы «забыть, как выглядит текст и вместо этого сконцентрироваться на его концептуальной структуре». Все так говорят. Даже я. (Кстати, мой соавтор ни при чём: я сам написал тот абзац).
4. Критика аргумента
--------------------
Я был так убеждён в аргументах в пользу того, почему учёные пишут тексты в LaTeX, что и сам начал создавать собственный документ в LaTeX (так никогда и не закончил его, это стало уроком). В конце концов я понял, что хотя этот аргумент (как отмечалось выше) широко распространён и часто повторяется, он неверный. Посмотрим ещё раз на тот пример. Серьёзно, любой, кто думает, что заставлять людей набрать такое…
>
> ```
> \documentclass{article}
> \title{Cartesian closed categories and the price of eggs}
> \author{Jane Doe}
> \date{September 1994}
> \begin{document}
> \maketitle
> Hello world!
> \end{document}
> ```
>
…вместо этого…
> Декартово замкнутые траектории и стоимость яиц
>
> Джейн Доу
>
> Сентбярь 1994
>
>
>
> Hello world!
…означает «позволить авторам преуспеть в написании документов», обладает (в лучшем случае) слегка нетрадиционным пониманием слов «позволить» или «написание», или, возможно, «преуспеть». Неужели кто-то из пользователей LaTeX действительно верит, что это истинная причина его использования LaTeX? Возможно, здесь можно провести параллели с тем, что [Мэтт Хиллз называет «дискурсивными мантрами»](https://www.amazon.co.uk/Cultures-Sussex-Studies-Culture-Communication/dp/0415240255) у фанатов культовых сериалов, таких как «Доктор Кто». Эти мантры — стандартные аргументы, которые выдвигаются фанатами снова и снова — согласно анализу Хиллза представляют собой «защитные механизмы, созданные для придания фанатской эмоциональной связи некоего рационального смысла, то есть для… узаконивания любви фанатов к „своей” программе». Попробуйте перечитать это, заменив «фанаты» на «преданных пользователей», а «сериалы» на «компьютерные программы». И это ещё не всё. «Преданные пользователи» используют этот аргумент для убеждения новых поколений авторов научных статей — особенно студентов — осваивать LaTeX.
Так что давайте более внимательно разберём полный аргумент LaTeX Project, процитированный выше:
1. *Для набора такого текста в большинстве систем вёрстки или текстовых процессорах автору нужно разметить текст, например, выбрать шрифт Times Roman величиной 18 пунктов для заголовка, шрифт Times Italic 12 пунктов для имени и так далее.*
В большинстве систем *набора и вёрстки* — да, бесспорно. В этом их смысл. Но большинство людей не используют на компьютере системы набора и вёрстки. Они используют текстовые редакторы, такие как Word, Writer или [Pages](https://itunes.apple.com/gb/app/pages/id409201541?mt=12). И у них есть установки по умолчанию, которые (в большинстве случаев) можно оставить для использования. Вот почему так много документов набрано шрифтом [Times New Roman](https://en.wikipedia.org/wiki/Times_New_Roman) 12 пунктов (бывший шрифт по умолчанию в Word, мировом лидере на рынке текстовых редакторов) и шрифтом [Calibri](https://en.wikipedia.org/wiki/Calibri) 12 пунктов (нынешний шрифт по умолчанию там же). Если хотите повозиться со шрифтами и полями в текстовом реакторе — пожалуйста. Но вас никто не заставляет. И определённо нет необходимости принимать осознанное решение о шрифтах перед тем, как начать писать. Поэтому совершенно ложным является утверждение, что «необходимо выбрать шрифт, его размер и прочее», чтобы создать в текстовом процессоре документ из примера. Достаточно просто набрать «Декартово замкнутые траектории и стоимость яиц» и так далее — что гораздо интуитивнее, чем набор `\title{Декартово замкнутые траектории и стоимость яиц}` (не говоря уже о `\documentclass{article}`), как должен сделать пользователь LaTeX. Конечно, набор слов «Декартово замкнутые траектории и стоимость яиц» не даст такой же красиво оформленный заголовок, как `\title{Декартово замкнутые траектории и стоимость яиц}` (когда сработает магия LaTeX) — но решить эту проблему можно так же эффективно, как она решается в LaTeX, и гораздо менее навязчивым способом (об этом мы вскоре поговорим).
2. *Это приводит к двум результатам: авторы тратят время на оформление...*
У авторов есть много способов увильнуть от написания текста, в том числе через возню с оформлением. Нет причин предполагать, что авторы будут меньше уклоняться от работы, если перестанут использовать текстовые процессоры. Они могут уклониться, совершенствуя свои настройки LaTeX. Я знаю много академических авторов, которые тратят на это немалое время. Я не говорю, что это хуже, но разве это лучше на самом деле? Пока не существует эмпирических доказательств, что авторы в LaTeX меньше отвлекаются от работы, чем другие авторы, вышеприведённая цитата остаётся безосновательным утверждением, которое предполагается принять на веру.
3. *…и появляется много плохо оформленных документов!*
Ну, может быть. Но существуют другие способы решить проблему. Например, во всех трёх университетах, где я преподавал, были формальные спецификации для оформления студенческих работ — формальные спецификации, которые близки к настройкам по умолчанию в популярных текстовых редакторах. Если речь идёт о том, чтобы не разрешить студентам набирать документы фиолетовым шрифтом Comic Sans в 28 пунктов, то обучать их всех использовать LaTeX — гораздо менее эффективный способ, чем просто заявить, что вы не принимаете работы, которые не соответствуют установленному стилю оформления. (Также может помочь обучение их правильному использованию текстовых редакторов).
4. *LaTeX основан на идее, что оформление документа лучше оставить дизайнерам, а авторы пусть сконцентрируются на написании текста.*
Задумайтесь об этом на секунду. Если вопрос в том, как авторам преуспеть в написании документов, то разве ответом действительно будет LaTeX? Да, LaTeX в этом отношении лучше, чем TeX. Но если бы их обоих не существовало, вы бы действительно сейчас, в 2016 году, предложили использовать язык разметки?
Аргумент MIT Research Science Institute немногим лучше. Если внимательно посмотреть на три сравнения, то на самом деле в них противопоставляются не LaTeX и текстовые процессоры, а эффективное использование LaTeX и наивное злоупотребление текстовыми процессорами: все три примера, которые, по мнению сотрудника Research Science Institute, великолепно выполняются в LaTeX, на самом деле так же идеально можно подготовить в текстовом редакторе. Мы подробнее рассмотрим их в следующей главе. Сейчас достаточно наблюдения, что людям, которые неумело пользуются определённым инструментом, говорят изучить совершенно другой инструмент на том основании, что это позволит им хорошо делать вещи, которые они могли так же хорошо сделать и с помощью старого инструмента — что (если подумать) представляет собой довольно необычную методику, если вы действительно хотите помочь людям в написании текстов, а не (боже упаси!) просто пропагандируете принятый в сообществе способ написания текстов. Что действительно важно — так это обучить студентов важности написания структурированного текста и использованию функций того инструмента, который они используют, для облегчения работы. А вместо этого мы наблюдаем евангелизм LaTeX с ложным выводом, что текстовые процессоры вообще не поддерживают структурированный текст. Если кто-то размечает заголовки разделов в текстовом редакторе, выбирая жирный шрифт или увеличивая размер шрифта, то он неправильно использует функции текстового редактора. Человеку следует показать [режим структуры документа](https://support.office.com/en-gb/article/Create-a-document-outline-in-Outline-View-cfdd43c9-021f-4d5d-a678-34a182f4433c) в Microsoft Word и [Навигатор](https://help.libreoffice.org/Writer/Navigator) в LibreOffice Writer, научить автоматически генерировать содержание, что оба редактора делают одним нажатием кнопки. Сравнение хорошего использования LaTeX с плохим использованием текстовых редакторов несправедливо. Максимум, что можно сказать — это что знакомить с LaTeX вас с большей вероятностью будет человек, который действительно хорошо в нём разбирается, а вот знакомство с текстовыми редакторами с большей вероятностью будет поверхностным под неформальным инструктажем человека, который не очень хорошо в них разбирается. Поэтому число пользователей LaTeX, которые не используют функции структуризации документа, близко к нулю, а среди пользователей текстовых процессоров таких огромное количество.
В итоге, аргумент в пользу использования LaTeX при написании текстов более чем слабый. TeX решил изначальную проблему для учёных и математиков, но усложнял написание сопровождающих текстов рядом с математическими формулами; LaTeX частично смягчил эту проблему в те времена, когда существовало мало других надёжных систем набора и вёрстки и никакие из них не были предназначены для академического использования. Создателем TeX был, пожалуй, самый великий человек в компьютерных науках со времён фон Неймана. TeX и LaTeX стали реальными, работающими примерами свободного программного обеспечения как раз в то время, когда [движение за свободное ПО](https://www.gnu.org/gnu/thegnuproject.html) начало набирать силу и появились евангелисты; всё началось с этого. Это хорошие причины для принятия в академических кругах TeX и LaTeX в конце 1980-х. Но никакая из этих причин не имеет ничего общего с предположением, что LaTeX подходит для написания текстов — и тот факт, что большинство людей не умеют правильно использовать текстовые редакторы, тоже не имеет ничего общего с предположением о превосходстве LaTeX.
5. Аргумент против написания текстов в LaTeX
--------------------------------------------
Если вкратце, то документы LaTeX очень сложно читать до вёрстки, что делает неэффективным как написание текстов, так и редактирование. Это тезис, который должен быть понятен программистам: если важна [читаемость кода](https://www.software.ac.uk/resources/guides/writing-readable-source-code), то не менее важна и читаемость текста. Документы LaTeX могут превращаться в в прекрасные читаемые PDF после набора и вёрстки, но метод их редактирования, мягко говоря, не оптимальный.
LaTeX, как уже отмечалось — это язык разметки. Разметка состоит из текста, перемежаемого кодом. Код встревает в содержание документа. Чтение размеченного текста требует интерпретации или фильтрации разметки, чтобы восстановить в своей голове изначальный текст. Это не является преимуществом при написании или редактировании прозы. Я покажу, что имею в виду.
Вот скриншот некоторого текста, размеченного в LaTeX. Текст взят с небольшой адаптацией из [статьи, которую я опубликовал в июне](http://www.danielallington.net/linguistic-capital-development-capital-network-cultural-producers-interactive-fiction-retrogaming-scene/). На скриншоте я редактирую этот текст в версии [Emacs](https://www.gnu.org/software/emacs/), которая поставляется с OS X, это мой привычный текстовый редактор на «маке»:
[](http://www.danielallington.net/wp-content/uploads/2016/09/editing_latex_with_error.png)
*Редактирование LaTeX в Emacs 22 (с преднамеренной ошибкой)*
Как можно заметить (нажмите на картинку для просмотра полноразмерной версии), заголовок внутри фигурных скобок определён как содержащий заголовок (`\title{The IF community}`), в то время как название раздела внутри пары фигурных скобок определено как содержащее название раздела (`\section{A past that it could not transcend}`). Это суть разметки. С чем она хорошо справляется — так это с однозначным определением заголовков разделов как таковых, что будет полезно на последующих этапах (например, когда потребуется применить конкретный стиль ко всем заголовкам разделов). Но использование для этого именно разметки (в отличие от альтернативных способов) разрушает восприятие текста человеком (включая редактора и самого автора): глядя на скриншот, мы видим текст, перемешанный с большим количеством служебных символов, которые не являются частью этого текста, и мы должны определить, какие слова и знаки пунктуации увидит конечный читатель. Это мешает понять, действительно ли мы используем правильные слова и знаки пунктуации. Неважно, насколько вы привыкли к этому языку разметки, он представляет собой ненужное когнитивное обременение. Эта специфическая проблема относится к разметке [BibLaTeX](https://www.ctan.org/pkg/biblatex?lang=en) для автоматической генерации цитат и библиографии, потому что разметка вообще не похожа на текст, который она сгенерирует в итоговом документе.
Кстати, одно из слов на скриншоте написано с ошибкой. Это опечатка, которую я вставил специально. Я знаю, где она находится, потому что сам вставил её туда, но попытка найти её вызывает боль в глазах.
Далее скриншот того же текста в редакторе LibreOffice Writer. Там присутствует та же самая опечатка, но на этот раз её гораздо легче заметить (нужно добавить, что проверка правописания её не заметила; и опять нажмите на картинку для увеличения):
[](http://www.danielallington.net/wp-content/uploads/2016/09/editing_libreoffice_with_error.png)
*Редактирование текста в LibreOffice Writer (с преднамеренной ошибкой)*
Спойлер: опечатка в слове “devotes” (for “devotees”). Может быть, вы заметили её здесь, может и нет, может вы заметили её в разметке — но я думаю, вы согласитесь, что рассматривать документ с визуальной вёрсткой и шрифтом Sans было проще. Должен заметить, что цитаты и библиография сгенерированы автоматически (с помощью [Zotero](https://www.zotero.org/)), но именно в таком виде, в каком они появятся в финальном документе (легко читаемом виде): там, где в варианте LaTeX используются `\parencite[see][]{bennett_2002}` и `\printbibliography`, в версии LibreOffice указано “(see Bennett 2002)” и реальная библиография.
Также хочу обратить внимание, что заголовки статьи и раздела указаны так же однозначно, как и в документе LaTeX. Когда я делал скриншот, курсор находился в заголовке статьи, хотя его не видно на скриншоте. Если посмотреть в левый верхний угол экрана (прямо под кнопками Zotero), вы увидите слово “Title” в выпадающем меню. Используя это выпадающее меню я указываю LibreOffice, что строка, где находится курсор, содержит заголовок статьи, и точно так же я указал, что строка “A past that it could not transcend” является заголовком раздела первого уровня (“Heading 1”, эквивалент тега HTML `H1`). Как и LaTeX, LibreOffice делает вывод, что текст за заголовком, который не помечен каким-либо стилем, — это основной текст, который принадлежит этому заголовку (хотя вы можете и явно указать, что это основной текст через то же выпадающее меню, упомянутое выше). Переместите курсор из одной строчки в другую — и значение в выпадающем меню само изменится в соответствии с тем, какой стиль выбран для текущего абзаца. Если хотите изменить стиль заголовков или основного текста по всему документу, то редактируете свойства стиля — а текстовый процессор применяет изменения ко всему документу. Также можно сохранять стили как шаблоны, а затем загружать их в любой документ на своё усмотрение, изменяя его внешний вид в соответствии с шаблоном. И конечно вы можете обмениваться шаблонами с другими пользователями, так что у всех документы будут оформлены в одном стиле.
Так что *вопреки* заявлениям LaTeX Project, мне не «приходится выбирать, какой шаблон использовать». Я не выбираю ни шрифт, ни его размер, ни стиль. LibreOffice сам делает это, поскольку он знает, как оформлять заголовки, подзаголовки и прочее. И *вопреки* заявлениям сотрудника MIT Research Science Institute, мне не приходится «тратить драгоценное время в муках, какой размер шрифта выбрать для заголовков разделов» — я просто указываю, что определённые фрагменты текста являются заголовками разделов, а LibreOffice подбирает размер шрифта. И в чём бы сотрудник Research Science Institute не пытался убедить студентов, «изменение форматирования [не означает], что вам придётся изменять отдельно оформление каждого фрагмента» — как вы можете «переопределить соответствующие команды» в LaTeX, так же вы можете переопределить соответствующие стили в LibreOffice (хотя на этом скриншоте я сохранил стили по умолчанию, как обычно делаю). Более того вы не «должны аккуратно следовать предложенным шаблонам», потому что вы можете менять шаблоны LibreOffice так же легко, как и в LaTeX. Всё это поддерживается и в Word. На самом деле сейчас хорошо снова взглянуть на вышеприведённые сравнения текстовых процессоров с LaTeX, потому что теперь понятно, что все они лживые: по сути, это пропаганда LaTeX.
Но вернёмся к процессу редактирования. Ладно, есть не такой вырвиглазный способ вычитывания документов LaTeX, как прочёсывание документа с разметкой. Можно сверстать итоговый документ, открыть и прочитать итоговый PDF, найти все необходимые места для правок и соответствующим образом отредактировать размеченный файл, заново его сверстать, снова вычитать и повторить процесс.
Если вы программист, то для вас может быть понятной аналогия с циклом кодирования-компиляции-отладки. Но не так большинство людей хочет писать тексты. Большинству из нас удобнее видеть на экране лист бумаги со словами и знаками пунктуации, которые в точности так и будут выглядеть в итоговом документе, а не смотреть на команды разметки вроде `\parencite[see][]{bennett_2002}`. Неважно, начинается шаблонный код с команд вроде `\documentclass{article}` или `\begin{document}` в начале документа. Просто наткнувшись посреди абзаца на нечто вроде `\parencite[706]{lena_peterson_2008}` нужно в уме преобразовать это в “(Lena and Peterson 2008, p. 706)”, и такая остановка прерывает ваш поток мыслей и затрудняет то, что вы в реальности должны делать: читать самому себе слова со знаками препинания и проверять, что они «звучат» как нужно и там нет ошибок.
Возможность редактировать документ, на который вы смотрите (в отличие от просмотра того, что на самом деле является исходным кодом документа), следует принимать как должное. Очевидно, для написания свободной прозы без ошибок лучше редактировать документ, в котором есть ‘…’ на месте многоточия, а не команды `\ldots` в соответствующих местах.
6. Так для чего подходит LaTeX?
-------------------------------
Главными пользователями LaTeX являются учёные. Есть даже *некоторые* исследователи в области гуманитарных наук, которые тоже используют LaTeX (или какой-то его вариант). Эти люди используют LaTeX не потому что так делают все, наоборот, они идут против толпы. В результате они, вероятно, больше задумываются о реальных преимуществах LaTeX — а не о тех воображаемых преимуществах, перечисленных выше, о которых вещают евангелисты LaTeX.
Насколько я могу сказать, они выбирают LaTeX по причине, которая противположна стереотипному мнению, что нужно концентрироваться на содержимом, а не оформлении. Например, один из пользователь так [объясняет](https://andrewgoldstone.com/tex/) свой выбор: «Компьютер должен позволить обычному пользователю создавать элегантно свёрстанную страницу, но в Word этого очень сложно достичь». Это переворачивает с ног на голову вышеуказанные аргументы в пользу написания текстов в LaTeX: такие авторы используют LaTeX (или его варианты), потому что они не верят в то, что «лучше оставить оформление документа дизайнерам»: на самом деле они используют его именно потому что хотят сами стать дизайнерами (в свою очередь, причиной этого является то, что они «беспокоятся… о внешнем виде документов»).
Вот для чего хорош LaTeX: не помогать людям писать тексты, а помогать красиво оформить их. Если для вас важно, то идите и посмотрите на него.
7. LaTeX: инструмент для набора и вёрстки, а не для написания текстов
---------------------------------------------------------------------
Как автор я хочу «преуспеть в написании документов», но иногда у меня есть причины поиграть в дизайнера, и в этих случаях я хочу подумать об оформлении.
LaTeX предоставляет один набор функций для таких ситуаций. Настольные издательские пакеты вроде InDesign предоставляют другой набор. На самом деле там даже более богатый набор. Возможно, многие из этих функций не нужны, если речь об обычных научных типах документов, таких как раздаточные материалы для конференций и лекций. Забудьте всю эту чушь, что LaTeX чем-то лучше текстового процессора в написании текстов: это не так. Но он лучше для набора и вёрстки. И он не требует такого внимательного эстетического выбора и опыта дизайна, как настольный издательский пакет, так что в этом смысле LaTeX может сэкономить вам время (и он не даёт так много возможностей облажаться), при условии, что верстаемый документ принадлежит к типу документов, которые люди обычно верстают в LaTeX. Преимущества LaTeX для академического использования состоят в том, что он производит разумно свёрстанные документы, которые хорошо выглядят именно в таком виде, в каком представители научных кругов обычно любят публиковать документы. За пределами этой комфортной зоны у него немного вариантов использования: TeX подходит практически для всего, но макросы, расширяющие TeX в LaTeX, в основном созданы чисто для научного использования. Например, я не запускал его для вёрстки [публичного доклада](https://valuingelectronicmusic.files.wordpress.com/2015/12/music_value_social_networks_2015.pdf) от проекта [Valuing Electronic Music](https://valuingelectronicmusic.org/), потому что это публичный доклад и я не хотел, чтобы он выглядел как научная статья.
Вот документы PDF, сгенерированные из файла LaTeX (слева) и с помощью функции «Экспортировать как PDF» в редакторе LibreOffice (справа). В обоих случаях я не менял никакие настройки по умолчанию (кроме активации умных цитат в LibreOffice). Версия LaTeX автоматически содержит дату, номера разделов и номера страниц, поскольку это стандартное форматирование документов LaTeX; вы легко можете продублировать эти функции в большинстве текстовых редакторов, но по умолчанию они не включены, так что я решил здесь их тоже не включать.
[](http://www.danielallington.net/wp-content/uploads/2016/09/The_IF_community_LaTeX.pdf)[](http://www.danielallington.net/wp-content/uploads/2016/09/The_IF_community_LibreOffice.pdf)
Думаю, вы согласитесь, что свёрстанная в LaTeX версия выглядит лучше, чем полученная экспортом из текстового процессора. Достаточно ли значительны эти изменения, чтобы оправдать дополнительные усилия при подготовке документа — решать вам.
8. Если мы не пишем в LaTeX, как нам использовать преимущества вёрстки в TeX?
-----------------------------------------------------------------------------
Очевидным решением было бы писать документ в другом формате, а после окончания пройтись по нему и добавить разметку. Например, так я сделал LaTeX-версию параграфа, показанного выше: опубликованная статья не писалась в LaTeX, но я подумал, что следует стилизовать его под LaTeX для задач этого эссе. Но языки разметки лучше подходят для машин, чем для людей, и в наше время вы можете сэкономить время, если отдать разметку LaTeX на откуп компьютеру. Так что одно то, что документ должен быть свёрстан в LaTeX, не означает, что вам нужно писать его в этой программе.
Вот варианты для автоматической разметки текста:
1. Писать в [AbiWord](http://www.abisource.com/), [Scrivener](https://www.literatureandlatte.com/scrivener.php), Emacs [Org-mode](http://orgmode.org/) или [Texts](http://www.texts.io/). AbiWord (доступен под Windows и Linux), Scrivener (доступен под Windows и Mac) и Org-mode (доступен везде, где вы можете запустить Emacs) экспортируют вашу работу в файл LaTeX; Org-mode и Texts (доступен под Windows и Mac) могут дополнительно сверстать его в LaTeX, если у вас установлен пакет LaTeX. С помощью AbiWord можно также открыть файл, написанный в другом текстовом процессоре, а затем экспортировать его в LaTeX. Я давно не использовал AbiWord и ещё не протестировал Texts, но могу поручиться за Org-mode. Обратите внимание, что версия Org-mode, которая идёт с Emacs в комплекте с Mac OS X такого не делает: вам понадобится более новая версия.
2. Писать в Word или LibreOffice, затем с помощью [Pandoc](http://pandoc.org/) конвертировать результат в файлы LaTeX [[1]](#1)
3. Писать в [Markdown](https://daringfireball.net/projects/markdown/) вообще в любом текстовом редакторе и с помощью Pandoc конвертировать файлы Markdown в файлы LaTeX (да, Markdown — это язык разметки, но он изначально разработан как простой и читаемый человеком язык; также обратите внимание, что хотя Texts является текстовым процессором, он всё сохраняет в Markdown). Также: расширение [citeproc](http://pandoc.org/demo/example19/Extension-citations.html) для Pandoc даёт Markdown более интуитивный синтаксис разметки цитат, чем у BibLaTeX, и поскольку [knitr](http://yihui.name/knitr/) работает с Markdown, этот вариант позволяет вам автоматически внедрять сгенерированные таблицы и прочее, если вы используете [R](https://www.r-project.org/). Может быть, стоит почитать детальное руководство [Кирана Хили](http://kieranhealy.org/) к [этому общему подходу](http://plain-text.co/index.html).
Не все перечисленные варианты равноценны, и все они предусматривают, что вы корректно структурировали текст, и по-прежнему не помешает некоторое знание LaTeX (особенно если вы хотите сделать нечто вроде внедрения математических формул). Но факт в том, что эти варианты существуют, потому что написание текстов в LaTeX — не то, для чего создавалась эта программа. LaTeX был изобретён, чтобы никому не пришлось писать прозу в TeX, который слишком сложен для простых смертных. Вышеперечисленные варианты придуманы, чтобы никому не пришлось писать прозу в LaTeX, который не так сложен для простых смертных, но всё равно писать в нём — плохая идея.
9. Вёрстка собственной книги
============================
Вы можете рассмотреть LaTeX как вариант самостоятельной вёрстки книги для издательства. Академические издатели ожидают подобного от учёных и также могут примириться с таким вариантом от исследователей в сфере гуманитарных наук. Это то, для чего Кнут изначально изобрёл TeX. Но следует учесть три вещи, прежде чем убеждать своего издателя позволить вам самому верстать свою книгу:
1. Там уже есть человек, который занимается этой работой.
2. Если вам так хочется сделать чужую работу, может, вам понравится также собрать физические копии, распечатанные на принтере, отвезти их на склад издателя (эй, они даже могут разрешить вам самому управлять погрузчиком!), провести маркетинговая кампанию со своего телефона и доставить копии покупателям и ритейлерам на своей машине. Погодите — зачем останавливаться на этом? Почему не настоять на личном управлении печатным прессом и машиной для переплёта? На самом деле, почему бы не купить механический ручной пресс, тогда можно напечатать и сделать переплёт дома, как Вирджиния и Леонард Вулфы?
3. Даже если вы сверстаете свою книгу и вам нет дела до всего остального, [теория сравнительных преимуществ Рикардо](https://en.wikipedia.org/wiki/Comparative_advantage#Ricardo.27s_example) по-прежнему утверждает, что вы впустую тратите время.
Всё ещё не отказались от плана? Ладно, может быть, вёрстка собственной книги даёт вам личное удовлетворение, или типографика книги должна иметь определённый уникальный вид, который никто кроме вас не способен обеспечить. Хорошо; это в любом случае никому не причинит вреда. (Если бы такая практика распространилась не только на научные монографии и *стала стандартной*, тогда другое дело. Все дизайнеры книг остались бы без работы, а большинство книг или выглядели бы ужасно или были бы похожи друг на друга. Ничего хорошего).
10. Небольшое предупреждение о бесконечном неудобстве всего, что связано с LaTeX
--------------------------------------------------------------------------------
Как мы убедились, есть мало стоящих причин писать тексты в LaTeX, но больше причин вёрстки в LaTeX. Я ещё не затрагивал сопутствующих технических проблем. Если вы сейчас не пользуетесь LaTeX, но рассматриваете такую возможность для типографских целей, то вам действительно нужно знать, на что вы себя обрекаете. Прежде чем закончить это эссе, я обязан сделать несколько замечаний ради людей, которые находятся в таком положении.
У свободного и бесплатного программного обеспечения есть большая склонность к трудностям в установке и работе. TeX и LaTeX не исключение. Кроме того, если вы решитесь на действительно дикий и сумасшедший поступок — вроде замены шрифта на что-нибудь иное, кроме Computer Modern — то простые базовые TeX и LaTeX не позволят вам это сделать. (Вам действительно захочется использовать *другие шрифты*, кроме Computer Modern. Это не какой-то универсальный шрифт на все случаи жизни. Это просто цифровая версия шрифта, который по случайности использовался в первой редакции книги, для которой ко второй редакции Кнут создал TeX для вёрстки, и он действительно не подходит для некоторых вариантов использования, которые мне приходилось встречать, особенно для презентаций со слайдами). И всё кроме чистого TeX и LaTeX действительно очень, очень сложно установить. Настолько сложно, что большинство людей не справляются с установкой отдельных пакетов, а вместо этого устанавливают целиком нечто под названием [TeX Live](https://www.tug.org/texlive/). Пакет Tex Live содержит практически всё, что может когда-нибудь понадобиться пользователю TeX или LaTeX, в одном удобном дистрибутиве. Единый удобный дистрибутив после установки занимает более двух гигабайт на диске: если быть точным, 2,4 гигабайта в версии для Mac — [MacTeX](http://tug.org/mactex/). Для сравнения, LibreOffice требует примерно полтора гигабайта на диске под Windows или Linux и менее одного гигабайта на Mac. И в состав LibreOffice входят текстовый процессор, электронные таблицы, программа для презентаций, пакет для рисования, база данных, всё в одном. LaTeX — это просто программа для набора и вёрстки. Это безумие — особенно если у вас работает старое или дешёвое железо. И даже если вы решите отяготить свой винчестер установкой TeX Live, придётся приложить ещё немало усилий, чтобы заставить всё работать, и почти никакой вопрос там не объясняется ясно и чётко. Иногда возникает впечатление, что установка и настройка LaTeX превратилась в некий испытательный ритуал, участники которого дали обет страдать в одиночестве.
Вот [абсолютно типичный вопль отчаяния](http://tex.stackexchange.com/questions/153647/biblatex-biber-and-latex-citations-undefined) какого-то пользователя, который пытается заставить LaTeX нормально работать с BibLaTeX и [Biber](http://biblatex-biber.sourceforge.net/) (две программы из комплекта TeX Live, которые дополняют LaTeX в качестве альтернативы [BibTeX](http://www.bibtex.org/), тоже включенной в комплект TeX Live, или для работы BibLaTeX вместе с BibTeX — уже запутались? Это только начало!):
> «У меня выскакивают ошибки «Неопределённые ссылки» (There were undefined references) и [я] уже два дня не могу их исправить. Я попытался перейти с редактора Sublime Text 3 на TeXStudio на «маке», потом попробовал оба на PC. Готов попробовать что угодно в данный момент…
>
>
>
> Я прочитал о хитрости при компиляции, но не уверен, как это сделать в SublimeText или TexStudio… Я столкнулся со многими проблемами и предпринял много обходных манёвров, которые привели к другим проблемам. Я в растерянности. Может кто-нибудь дать пару советов или ключевых слов, чтобы я поискал решение этих проблем, или полное решение? Не могу запустить даже минимальную рабочую конфигурацию. Готов установить что угодно.
Каждый раз, когда какой-нибудь новичок пытается запустить LaTeX, человек обрекает себя на несколько часов или несколько дней подобных проблем — плюс на всю жизнь возни с причудами TeX и LaTeX, даже если (как этот пользователь) человек использует относительно «дружественные» графические приложения вроде [TeXstudio](http://www.texstudio.org/), а не пытаетесь совладать с Emacs или [vi](http://www.viemu.com/a-why-vi-vim.html) и [командной строкой](https://en.wikipedia.org/wiki/Command-line_interface). Этот пользователь дошёл до такого отчаяния, что не только поменял программы-редакторы LaTeX, но поменял компьютеры в надежде, что всё заработает. А теперь ответ. Принятый в качестве подходящего ответ тщательно очерчивает решение, а затем [объясняет причину проблемы следующим образом](http://www.danielallington.net/2016/09/the-latex-fetish/#Wright_2014):
> Существует возможность установить TeXstudio альтернативными способами для достижения такого же эффекта. Суть в том, что вам следует убедиться, что программы идут в следующей последовательности:
>
>
>
> * LaTeX
> * Biber
> * LaTeX
>
>
>
> Это делается или вручную (как я это делаю), или можно автоматизировать разными способами. Обратите внимание, что та же основная идея действует с любым редактором: это особенность LaTeX, а не редактора.
Мда, насколько глупым был пользователь, который не догадался, что единственный способ заставить LaTeX правильно работать с Biber — это запустить его дважды, один раз до, а второй раз после! А теперь оцените отзыв на этот (необычно ясный) ответ с решением проблемы: «Подробности вашего ответа будут очень полезны для других неофитов вроде меня. Другие ответы предполагают высокий уровень компьютерной/LaTeX-грамотности, какой не у всех есть».
Это типичная история. Пойдёте по пути LaTeX — и рано или поздно придётся рвать на себе волосы. Вас предупреждали.
Примечания
==========
1. Преобразование файла .odt со сгенерированной в Zotero библиографией в LaTeX при помощи Pandoc слегка сложнее, чем кажется. По моему опыту, лучше всего открыть файл .odt в LibreOffice и сохранить его как .docx (что превращает все ссылки Zotero и библиографию в обычный текст), затем с помощью Pandoc сначала конвертировать файл .docx в файл Markdown, а потом конвертировать файл Markdown в файл LaTeX. [↑](#1_1)
|
https://habr.com/ru/post/339340/
| null |
ru
| null |
# Doodle Jump на pygame
Добрый…
Хочу рассказать и показать вам свой опыт знакомства с библиотекой pygame — предположительно отличной библиотекой для реализации графичиских приложений (в большей степени игр-аркад) на языке python. Для примера была реализована (частично) игра Doodle Jump.
#### Дисклеймер
* Да, я использовал чужие картинки — мне стыдно и я скоро это исправлю.
* Персонаж сейчас может только прыгать, но я планирую дописать игру до конца.
* Да, идея не нова, но прикольно ведь получилось.
* Да, скорее всего бред — использовать интерпретируемый язык для написания игр.
* Я не профессиональный программист и это моя не основная деятельность.
#### Вместо введения
Python. Python великолепен в плане документации. Она есть, она понятна, она не лишена отличных примеров. Pygame — не исключение, поэтому предлагаю пока не останавливаться на подробностях реализации этой библиотеки, но необходимо заметить, что ее средства позволяют подгрузить изображение, и просто перемещать его по x и y. Ничего лишнего.
#### Архитектура
Постараемся разработатать архитектуру приложения в лучших традициях [ООП](http://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5). Имеем следующую диаграмму классов:
Сторонники [MVC](http://ru.wikipedia.org/wiki/Model-View-Controller) модели уже плачут, т.к. и логика и представление засунуты в тело класса.
Имеем 3 локации:
* StartLocation — здесь крутится меню и приглашение к игре.
* GameLocation — собственно сабж.
* ExitLocation — выход, результаты, фанфары-овации.
Базовый объект Sprite, от которого наследуются все игровые объекты — платформы, кнопки, главный герой и т.д. По схеме все ясно.
#### Ключевые моменты
##### Events
```
def event(self, event):
if event.type == QUIT:
sys.exit()
elif event.type == KEYUP:
if event.key == K_ESCAPE:
# do something
if event.type == MOUSEMOTION:
for btn in self.buttons:
if btn.rect.collidepoint(pygame.mouse.get_pos()):
#pass
btn.changeState(1)
```
С помощью механизма эвентов прозрачно перехватываются нажатия клавиш и манипуляции с мышью.
##### Изображения
```
self.img_l = pygame.image.load('img/doodle_l.png').convert()
self.image = self.img_l
self.image.set_colorkey(self.image.get_at((0,0)), RLEACCEL)
self.rect = self.image.get_rect()
self.rect.center = (self.x,self.y)
```
Подгружаем картинки для спрайтов.
##### Столкновения
```
self.doodle.getLegsRect().colliderect(spr.getSurfaceRect())
```
Метода coliderect возвращает true, если прямоугольники, ограничивающие спрайты пересекаются.
#### Пара скриншотов
#### ToDo
* Проработать гемплей
* Нарисовать новые спрайты
* Добавить звуки
* Добавить статистику
* Поправить алгоритмы расположения платформ
* Добавить управление стрелками
* ~~Что еще?~~
#### Вместо послесловия
Знакомство с pygame можно считать законченым, дудлер прыгает и радуется жизни, но нагрузка процессора при этом стремится к 50-70%, что не есть гуд. Что это, ~~говнокод~~ плохая архитектура приложения или особенности языка — решать вам. Спасибо за внимание.
[Исходники на github.](https://github.com/thefrolov/Doodle-Jump)
|
https://habr.com/ru/post/130726/
| null |
ru
| null |
# "Честное" убийство рекламы в ЖЖ.
Сообразил, как относительно честно, удобно и без лишних телодвижений прибить суповскую рекламу в ЖЖ. Сразу оговорюсь — способ для Opera.
«Честно» потому что стили журнала править не нужно, а значит у СУПа не будет никаких оснований суспендить ЖЖ.
Удобно — потому что работает, даже если ходим в ЖЖ незалогиненными.
Без лишних телодвижений — потому что делается сугубо встроенными средствами Оперы за 30 секунд.
Основной и популярный способ блочить рекламу — задать в пользовательском стиле журнала display:none; для рекламного дива.
А в Опере есть возможность подключения пользовательских стилей. Вот и делаем то же самое, но на стороне браузера. Ну, собственно, и подключаем: идём в Preferences->Advanced->Content->Style options, в поле My style sheet выбираем какой-нибудь css-файл (обычно по умолчанию стоит %operadir%\styles\user.css). Пишем в файл (если он уже есть — дописываем):
`.adv { display: none;}
#ad-leaderboard {display: none;}
#ad-5linkunit {display: none;}`
Всё. Рекламы больше нет.
Можно задать стиль только для \*.livejournal.com — F12->Edit site preferences и дальше по аналогии.
Способ, в принципе, равнозначен использованию любой рекламорезки, просто опероводам напрягаться почти не придётся.
|
https://habr.com/ru/post/38503/
| null |
ru
| null |
# Поиск проблемных промисов в JavaScript
JavaScript — это фантастический язык для серверного программирования, так как он поддерживает асинхронное выполнение кода. Но это ещё и усложняет его использование.
[Асинхронность](https://www.youtube.com/watch?v=8aGhZQkoFbQ) означает возможность написания кода, который не подвержен обычным проблемам, связанным с потокобезопасностью, и поддерживает выполнение множества задач в «параллельном» режиме. Например — ожидание считывания файла не блокирует другие вычисления.
Но небольшие ошибки в асинхронном коде могут приводить к появлению неразрешённых промисов. То есть — к участкам кода, выполнение которых, однажды начавшись, никогда не завершается.
[](https://habr.com/ru/company/ruvds/blog/589371/)
Мы столкнулись с этой проблемой, когда в пуле соединений нашей базы данных [knex](https://knexjs.org/) постоянно заканчивались доступные соединения, после чего происходил сбой сервиса. Обычно в рамках соединения выполняется запрос, после чего оно возвращается в пул и может быть использовано для выполнения другого запроса.
Эти соединения что-то захватывало.
Речь идёт о кодовой базе в миллионы строк кода, которой в течение нескольких лет занимались десятки программистов. Может — проблема заключается в неразрешённых промисах? Я решил [исследовать](https://twitter.com/Swizec/status/1450624141070008321) этот вопрос.
Проблема останова поднимает голову
----------------------------------
Поиск неразрешённых промисов — это пример попытки решения [проблемы останова](https://swizec.com/blog/week-1-turings-on-computable-numbers/), а известно, что не существует общего алгоритма решения этой проблемы.
Нет такого алгоритма, реализация которого может проанализировать фрагмент кода и ответить на вопрос о том, всегда ли, при любых входных данных, этот участок кода завершает работу. Провести такой анализ не получится и вручную.
Google выдал мне несколько страниц, где обсуждают неразрешённые промисы. Эти обсуждения всегда сводятся к тому, что не надо писать изначально некачественный код.
Типичное решение проблемы останова заключается в том, чтобы добавить в систему временные ограничения. Если функция не завершает работу в пределах N секунд — мы считаем, что она где-то застопорилась. Может, это и не так, но мы решаем, что это так, и «убиваем» программу.
Именно поэтому и существуют тайм-ауты соединений. Если сервер остановился — мы не собираемся ждать его вечно. Это важно при [разработке распределённых систем](https://serverlesshandbook.dev/serverless-architecture-principles).
Но «убийство» процесса сервера при каждом недоразумении — это решение не идеальное. И, кроме того, оснащение каждого промиса в кодовой базе тайм-аутом — это, в лучшем случае, очень сложно.
Но не так всё плохо! Проблему останова можно решить для подмножества распространённых паттернов.
Паттерны проблемных промисов
----------------------------
В [прочитанной](https://twitter.com/Swizec/status/1450931644995489795) мной [публикации](https://dl.acm.org/doi/10.1145/3276532) «Нахождение проблемных промисов в асинхронных JavaScript-программах» Алимадади с соавторами выделили распространённые паттерны, которые приводят к появлению неразрешённых промисов, и представили программу [PromiseKeeper](https://github.com/nuprl/PromiseKeeper). Эта программа находит потенциально неразрешаемые промисы с использованием графа промисов.
### ▍Краткий рассказ о JavaScript-промисах
Та публикация начинается с обзора JavaScript-промисов.
Промисы представляют асинхронные вычисления и могут пребывать в трёх состояниях: `pending` (ожидание), `fulfilled` (успешное разрешение) и `rejected` (отклонение). Вначале они оказываются в состоянии `pending`.
Код, реагирующий на результат работы промиса (обработчик определённого события), регистрируют с помощью метода `.then()`.
```
// Немедленно разрешается со значением 17
const promise = Promise.resolve(17)
promise.then(
function fulfilledReaction(value) {
console.log({ value })
},
function rejectedReaction(error) {
console.log({ error })
throw error
}
)
```
В коде, на практике, опускают второй параметр для того чтобы сосредоточиться на коде, который выполняется при успешном разрешении промиса (`fulfilledReaction`). Обычно так поступают при построении цепочек промисов:
```
// Немедленно разрешается со значением 17
const promise = Promise.resolve(17)
promise.then(value => value + 1)
.then(value => value + 1)
.then(function (value) => { console.log(value) })
```
Каждый вызов `.then()` приводит к созданию нового промиса, который разрешается возвращаемым значением кода, реагирующего на завершение работы предыдущего промиса. Обратите внимание на то, что последний вызов неявно разрешается со значением `undefined`. Дело в том, что в JavaScript функция, которая не возвращает что-либо, неявным образом возвращает `undefined`.
Важная деталь.
В цепочку промисов можно добавить механизм обработки ошибок с использованием `.catch()`:
```
// Немедленно разрешается со значением 17
const promise = Promise.resolve(17)
promise.then( ... )
.then( ... )
.then( ... )
.catch(err => ...)
```
Каждый промис, созданный `.then()`, неявно определяет код, реагирующий на отклонение промиса, аналогичный конструкции `err => throw err`. Это значит, что `.catch()` в конце цепочки промисов может отреагировать на ошибки, возникшие в любом из предыдущих промисов.
На практике редко полагаются на стандартный механизм обработки успешно разрешённых промисов, но следующий код корректен:
```
// Немедленно разрешается со значением 17
const promise = Promise.resolve(17)
promise
.then(undefined) // используется стандартный механизм value => value
.then((value) => console.log(value))
```
Полагаю, подобное чаще происходит случайно, чем намеренно.
Промисы можно связывать, используя один промис для разрешения другого промиса:
```
const p0 = Promise.resolve(17) // Немедленно разрешается
const p1 = Promise.reject("foo") // Немедленно отклоняется
p0.then(function (v) {
return p1
})
```
Здесь состояние промиса `p0` связано с `p1`. То есть — неименованный промис, созданный в строке 3, отклоняется со значением `foo`.
В реальном коде можно видеть много подобных конструкций. Часто они устроены не так понятно, как эти.
### ▍Паттерн №1: необработанное отклонение промиса
Обычным источником ошибок при работе с промисами являются необработанные отклонения промисов.
Это происходит, когда неявно отклоняют промис, выдавая ошибку в коде, реагирующем на успешное завершение промиса:
```
promise.then(function (val) {
if (val > 5) {
console.log(val)
} else {
throw new Error("Small val")
}
})
```
Так как код, реагирующий на успешное завершение промиса, выполняется в отдельном асинхронном контексте, JavaScript не передаёт эту ошибку в главный поток. Ошибка «проглатывается» и разработчик никогда не узнает о том, что она произошла.
Исправить это можно, использовав метод `.catch()`:
```
promise
.then(function (val) {
if (val > 5) {
console.log(val)
} else {
throw new Error("Small val")
}
})
.catch((err) => console.log(err))
```
Теперь у нас появляется возможность обработать ошибку.
Но мы не перевыбросили эту ошибку! Если другой промис, связанный с этим, или объединённый с ним в цепочку, полагается на этот код, ошибка будет оставаться «проглоченной». Код продолжит выполняться.
Попробуйте следующее в консоли браузера:
```
const p = Promise.resolve(17)
p.then(function (val) {
throw new Error("Oops")
return val + 1
})
.catch(function (err) {
console.log(err)
})
.then(function (val) {
console.log(val + 1) // prints NaN
})
```
Можно ожидать, что в этом коде выполняются вычисления `17 + 1 = 18`, но, из-за неожиданной ошибки, мы получаем `NaN`. Промис, неявно созданный `.catch()`, неявно разрешается (а не отклоняется) со значением `undefined`.
Это, конечно, примитивный пример, но представьте, как часто встречается этот паттерн в постоянно увеличивающейся кодовой базе, где каждая функция может, по какой угодно причине, выбросить ошибку.
### ▍Паттерн №2: незавершённые промисы
Новые промисы пребывают в состоянии `pending` до тех пор, пока не будут успешно разрешены или отклонены (то есть — завершены). Но если промис не завершается, его можно назвать остановившимся промисом. Он навсегда останется в состоянии `pending`, не давая выполняться коду, полагающемуся на его завершение.
Речь идёт о незавершённых промисах, которые крайне сложно обнаружить. Извне нельзя узнать о том, остановился ли промис, или он просто медленно работает.
Авторы вышеупомянутой [публикации](https://dl.acm.org/doi/10.1145/3276532) показывают пример [проблемы из node-promise-mysql](https://github.com/CodeFoodPixels/node-promise-mysql/issues/77), где `connection.release()` возвращает промис, который никогда не разрешается.
Этот пример сложно свести к нескольким строкам кода, поэтому вот — кое-что попроще:
```
const p0 = new Promise((resolve, reject) => null)
const p1 = Promise.resolve(17)
p0.then((result) => p1)
.then((value) => value + 1)
.then((value) => console.log(value)) // ожидается 18
```
Последний промис соединён цепочкой из `.then()` с промисом `p0`, который никогда не разрешается и не отклоняется. Этот код может выполняться вечно, но он никогда не выведет никакого значения.
Это, опять же, простейший пример, но представьте себе огромную кодовую базу, над которой работают десятки программистов. Совсем неочевидным может быть то, что функция в некоторых случаях бесконечно долго держит некий промис в состоянии `pending`.
### ▍Паттерн №3: неявные возвраты и код, реагирующий на результаты работы промиса
Цепочка из промисов прерывается без выдачи каких-либо ошибок в том случае, если разработчик забывает о включении в код выражения `return`.
Эта проблема похожа на ту, связанную с «проглатыванием» ошибок, о которой я уже рассказывал. Вот фрагмент кода из Google Assistant, который приводят Алимадади с соавторами:
```
handleRequest (handler) {
if (typeof handler === 'function') {
const promise = handler(this)
if (promise instanceof Promise) {
promise.then(result => {
debug(result)
return result
}).catch(reason => {
this.handleError('function failed')
this.tell(!reason.message ? ERROR_MESSAGE : reason.message)
return reason
})
}
}
}
```
Метод `handleRequest()` использует объект `Map` с обработчиками, предоставленными разработчиком, для организации асинхронной работы с запросами Assistant. Объект `handler` (обработчик) может быть либо коллбэком, либо промисом.
Если промис разрешается и вызывает предоставленный ему программистом анонимный обработчик, код возвращает результат. Если промис оказывается отклонённым — код возвращает причину этого.
Но все эти возвраты выполняются внутри кода, реагирующего на разрешение или отклонение промиса. Промис не осуществляет возврата значения. Результат реакции на промис `handler` теряется.
Пользователь этой библиотеки не может обработать результат разрешения или отклонения промисов, возвращённых его собственными обработчиками.
Поиск антипаттернов с помощью графа промисов
--------------------------------------------
Алимадади с соавторами создали программу [PromiseKeeper](https://github.com/nuprl/PromiseKeeper), которая динамически анализирует кодовую базу на JavaScript и рисует графы промисов.
*Граф промисов*
Мне не удалось запустить эту программу, поэтому передам то, о чём рассказали авторы публикации.
### ▍Графы промисов
Асинхронный код можно представить в виде графа, вершины которого (промисы, функции, значения, механизмы синхронизации) соединены рёбрами (разрешение промиса, регистрация обработчиков, связь, `return` или `throw`).
* **Вершины-промисы** (p) представляют собой случаи запуска промисов.
* **Вершины-значения** (v) представляют значения, с которыми разрешаются или отклоняются промисы. Это могут быть функции.
* **Вершины-функции** (f) — это функции, зарегистрированные для обработки разрешения или отклонения промиса.
* **Вершины-механизмы синхронизации** (s) представляют собой все использованные в коде вызовы `Promise.all()` или `Promise.race()`.
* **Рёбра разрешения или отклонения промиса** (v)->(p) указывают на связи вершин-значений с вершинами-промисами. Они помечены как `resolve` или `reject`.
* **Рёбра регистрации обработчиков** (p)->(f) указывают на связи между промисом и функцией. Они помечены как `onResolve` или `onReject`.
* **Рёбра связей** (p1)->(p2) показывают взаимоотношения между связанными промисами.
* **Рёбра return или throw** (f)->(v) показывают связи функций и значений. Они помечены как `return` или `throw`.
* **Рёбра механизмов синхронизации** указывают на связи, идущие от множества промисов к одному механизму синхронизации промисов. Они помечаются как `resolved`, `rejected` или `pending` на основании того, как ведёт себя новый промис.
Вот аннотированная версия вышеприведённого графа.
*Аннотированный граф промисов*
### ▍Использование PromiseKeeper для поиска анти-паттернов
Программа PromiseKeeper направлена на конструирование и визуализацию графа промисов кода. Она анализирует код динамически, по мере выполнения тестов. Динамический контекст выполнения кода позволяет находить анти-паттерны, которые не видны при анализе самого кода.
Вот на какие анти-паттерны обращает внимание программа:
* **Пропущенные обработчики отклонения промисов** — это ведёт к «проглатыванию» ошибок.
* **Попытки многократного завершения работы промисов** — это происходит, когда пытаются разрешить или отклонить промис, работа которого уже была завершена.
* **Незавершённые промисы**, то есть такие, которые не разрешены, но и не отклонены в то время, когда PromiseKeeper строит граф.
* **Недостижимые обработчики** — то есть код, зарегистрированный для обработки разрешения или отклонения промисов, который не выполняется во время динамического анализа кода, выполняемого PromiseKeeper.
* **Неявные возвраты и стандартные обработчики** — это может привести к неожиданному поведению промисов, расположенных ниже в цепочке промисов.
* **Ненужные промисы** — когда намеренно создают новый промис в функции, которая уже обёрнута в промис.
Так как PromiseKeeper полагается на динамическое выполнение кода — качество анализа напрямую зависит от того, насколько хорошо код покрыт тестами. В ходе этого анализа нельзя исследовать невыполненный код, что может вести к ложноположительным результатам.
Реализация PromiseKeeper основана на фреймворке для динамического анализа JavaScript-кода [Jalangi](https://github.com/Samsung/jalangi2). В нём имеются коллбэки, которые реагируют на события жизненного цикла промисов.
Мне не удалось заставить работать PromiseKeeper на моём компьютере, но Алимадади с соавторами сообщают о том, что не вполне благополучные промисы встречаются почти во всех кодовых базах, в которых используется JavaScript.
*Отчёт по выявленным анти-паттернам*
Интересно то, что 1012 экземпляров незавершённых промисов встречаются всего в 17 местах кода Node Fetch.
Авторы сообщили, что в ходе их эксперимента 43% промисов оказались неразрешёнными. Это, вероятнее всего, указывает на неполноту тестов, а не на то, что популярные программные продукты, которые они исследовали, безнадёжно «поломаны».
Что делать?
-----------
Для того чтобы улучшить работу с промисами в своих проектах, стоит помнить об анти-паттернах и постараться не писать код, который изначально является некачественным. Применение async/await снижает вероятность появления в коде рассмотренных здесь анти-паттернов.
Мы, решая проблемы промисов, добились серьёзных успехов, логируя сведения о необработанных отклонениях промисов, снабжённые полной трассировкой стека. Делается это с помощью такого кода:
```
// Выводит полезное сообщение об ошибке когда
// отклонение промиса оказывается необработанным
process.on("unhandledRejection", (err, promise) => {
const stack = err instanceof Error ? err.stack : ""
const message = err instanceof Error ? err.message : err
Logger.error("Unhandled promise rejection", {
message,
stack,
promise,
})
})
```
Ещё можно попробовать Node.js-модуль [async\_hooks](https://nodejs.org/api/async_hooks.html), который позволяет наблюдать за жизненным циклом промисов, и попытаться выявлять промисы, которые выполняются слишком долго. Можно, например, сравнивать время работы промиса с заданным тайм-аутом и выводить в консоль предупреждение.
У меня была интересная [попытка](https://gist.github.com/Swizec/30df527907e3488a546075b3ec691dd9) использования `async_hooks` для выявления промисов, выполняющихся слишком долго, но особого толку из этого не вышло. Нельзя получить ссылку на контекст выполнения (только — C-указатель). То есть — можно увидеть, что что-то работает медленно, но о том, что это такое, узнать нельзя.
Меня привлекает идея превращения PromiseKeeper в нечто вроде плагина для Jest. Представьте себе, что после каждого запуска тестов формируется граф промисов, вроде того, который вы здесь видели.
Сталкивались ли вы с проблемами, вызванными неправильной работой промисов?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=poisk_problemnyx_promisov_v_javascript)
|
https://habr.com/ru/post/589373/
| null |
ru
| null |
# Управление микроконтроллером через telegram-бот с обратной связью
Задача
------
Нужно управлять различными устройствами: свет, вентиляция, полив, а также получать нужные данные от микроконтроллера.
При этом для учебно-тренировочных или DIY-задач совершенно не хочется задействовать дополнительные устройства, на которых будет размещаться сервер и уж тем более не оплачивать внешний статический IP-адрес.
Идея
----
Обеспечить выход в интернет с микроконтроллера, запустить два скрипта: веб-сервер для приема информации от микроконтроллера и телеграм-бот для связи с пользователем.
Веб-сервер на Flask и бота будем размещать на ReplIt. Как это сделать бесплатно с работой 24/7 описано в статье [Как хостить телеграм-бота](https://habr.com/ru/post/709314/).
Первая попытка была использовать Arduino + Ethernet-модуль W5500, эта связка заработала только внутри локальной сети и провалилась при переносе на ReplIt, т.к. ссылка веб-сервера оказалась доступна только по протоколу https, который Arduino не поддерживает.
Решение нашлось в виде платы NodeMCU v3 с модулем Wi-Fi:
NodeMCU v3 с WiFi-модулем Эта плата, основанная на микроконтроллере ESP8266, программируется через среду Arduino IDE с небольшой настройкой.
Реализация - шаг 0 - настраиваем IDE
------------------------------------
Пример будет для версии Arduino IDE 2.0.3, которая легко доступна на [официальном сайте.](https://www.arduino.cc/en/software)
После установки IDE необходимо добавить в нее библиотеки для работы с ESP8266.
Нужно зайти в настройки File→Preference:
и добавить ссылки для скачивания информации о дополнительных платах:
`http://arduino.esp8266.com/stable/package_esp8266com_index.json
https://dl.espressif.com/dl/package_esp32_index.json`
Далее открываем в левом меню BOARDS MANAGER и устанавливаем пакет для работы с ESP8266:
После этого IDE готова к работе. Но прежде, чем загрузить код в ESP, нужно создать два скрипта на Python и получить ссылку, по которой будет осуществляться обмен данными.
Реализация - шаг 1 - Пишем код телеграм-бота и веб-сервера на Flask
-------------------------------------------------------------------
В данной статье будет описан принцип обмена данными, поэтому от ESP будет передаваться только "условная температура" (условная, потому что всегда статичная из переменной) и состояния встроенного в микроконтроллер светодиода.
Обмен данными между веб-сервером и телеграм-ботом будет происходить через текстовые файлы, чтобы не усложнять понимание кода.
Создаем проект на ReplIt, в нем делаем два файла main.py (в нем будет телеграм-бот) и background.py (в нем будет веб-сервер). Более подробно процесс описан в статье [Как хостить телеграм-бота](https://habr.com/ru/post/709314/).
### Telegram-бот
Размещаем в файле main.py.
Моменты, на которые стоит обратить внимание:
* `import pip pip.main(['install', 'pytelegrambotapi'])` - установит необходимую нам библиотеку.
* `f.write(str(call.from_user.id))` - записываем id пользователя, с которым общаемся. В данной реализации предполагаем, что с ботом не будет одновременно работать несколько человек.
* `bot.send_message(call.from_user.id,"Свет скоро включится")` - отправляем сообщение пользователю, что "команда принята". Чуть позже, когда от ESP придет информация, что свет включен, мы отправим еще одно подтверждение. Именно для этого и нужно запоминать **user\_id.**
* Токен от бота прячем в SECRETS, т.к. проект в бесплатном режиме открыт в режиме просмотра для всех. Подробнее об этом в [документации](https://docs.replit.com/programming-ide/storing-sensitive-information-environment-variables).
```
import os
from background import keep_alive
import pip
pip.main(['install', 'pytelegrambotapi'])
import telebot
import time
#очищаем все файлы или создаем пустые
with open('messages.txt','w') as f:
f.write("")
with open('user_id.txt','w') as f:
f.write("")
with open('from_esp.txt','w') as f:
f.write("")
with open('from_tg.txt','w') as f:
f.write("")
def get_last_update(now,last):
# функция для определения времени получения данных от микроконтроллера
diff = now-last
if diff<60:
return f"{int(diff)} сек назад"
elif diff<60*60:
return f"{int(diff/60)} мин назад"
elif diff<60*60*24:
return f"{int(diff/60/24)} ч назад"
else:
return "Более дня назад"
bot = telebot.TeleBot(os.environ['TOKEN'])# Создаем бот
# Создание клавиатур, для удобной коммуникации с пользователем
start_keyboard = telebot.types.InlineKeyboardMarkup()
start_keyboard.add(
telebot.types.InlineKeyboardButton('Получить информацию', callback_data='info'),
telebot.types.InlineKeyboardButton('Управлять устройством', callback_data='control')
)
control_keyboard = telebot.types.InlineKeyboardMarkup()
control_keyboard.add(
telebot.types.InlineKeyboardButton('Включить', callback_data='on'),
telebot.types.InlineKeyboardButton('Выключить', callback_data='off')
)
# Клавиатуры будут прикреплены к сообщениям бота
# На любое сообщение пользователя присылаем варианты действий
# Как вариант, обрабатывать команду /start от пользователя
@bot.message_handler(content_types=['text'])
def get_text_message(message):
bot.send_message(message.from_user.id,"Что вы хотите сделать?",reply_markup=start_keyboard)
#Обработка нажатий на кнопки
@bot.callback_query_handler(func=lambda call: True)
def func(call):
bot.answer_callback_query(call.id) # подтверждаем боту, что действие по кнопке выполнено
with open('user_id.txt','w') as f:
f.write(str(call.from_user.id)) # записываем в файл user_id. Он понадобится для отправки сообщений
if call.data=='info':#нажата кнопка с callback_data='info', получаем информацию из файла
with open("from_esp.txt","r") as f:# читаем файл
temp,light,time_last = f.readlines()[0].split(';')#получаем значения переменных
last_update = get_last_update(time.time(),float(time_last))# и время получения данных
#отправляем сообщение пользователю
bot.send_message(call.from_user.id,f"Все хорошо, \nТемпература: {temp} \nОсвещение: {'включено' if light=='1' else 'выключено'}\nОбновлено: {last_update}", reply_markup=start_keyboard)
if call.data=='control':#нажата кнопка с callback_data='control'
bot.send_message(call.from_user.id,"Вот что можно сделать:",reply_markup=control_keyboard)
if call.data=='on':#нажата кнопка с callback_data='on'
bot.send_message(call.from_user.id,"Свет скоро включится")#отправляем сообщение пользователю
with open('from_tg.txt','w') as f:#записываем в файл действие, которое хотим сделать
f.write('1')#включить свет
if call.data=='off':
bot.send_message(call.from_user.id,"Свет скоро выключится")
with open('from_tg.txt','w') as f:
f.write('0')#выключить свет
keep_alive()# запуск веб-сервера из файла background.py
bot.polling(non_stop=True, interval=0)# запуск телеграм-бота
```
### Веб-сервер на Flask
В этой статье не приводится полное описание, что такое Flask и как им пользоваться. Есть огромное количество статей на русском или английском об этом фреймворке. В качестве примера, можно почитать [вот эту](https://docs-python.ru/packages/veb-frejmvork-flask-python/).
Размещаем код в файле background.py
Этот сервер выполняет сразу 2 задачи:
* Обеспечивает обмен данными с микроконтроллером через GET-запросы.
* Используется для поддержки работоспособности скрипта через [UpTimeRobot](https://uptimerobot.com/index). Подробности все в той же [статье](https://habr.com/ru/post/709314/).
```
from flask import Flask
from flask import request
from threading import Thread
import time
import requests
app = Flask('')
@app.route('/')#Создаем "главную страницу" которую будет пинговать UpTimeRobot
def home():
return "I'm alive"
@app.route('/iot', methods=['GET'])#создает ссылку /iot на которую будут приходить запросы
def iot():
temp = request.args.get('temp') #получаем параметры из GET-запроса
light = request.args.get('light')
with open('from_esp.txt', 'r') as f:#читаем данные, полученные из ESP в прошлый раз
old_temp,old_light,time_last = f.readlines()[0].split(';')
if old_light=="0" and light=="1":# и если старое состояние выкл, а новое вкл
with open('messages.txt', 'w') as f_m:# записываем в файл messages текст сообщения
f_m.write("Свет включился")
if old_light=="1" and light=="0":
with open('messages.txt', 'w') as f_m:
f_m.write("Свет выключился")
with open('from_esp.txt', 'w') as f:#записываем в файл новые значения
f.write(f"{temp};{light};{time.time()}")
with open('from_tg.txt', 'r') as f:# читаем из файла действие, сделанное командой в телеграм боте
new_state = f.read(1) #т.к. у нас только 1 параметр Включить/выключить свет, читаем 1 символ
return new_state #возвращаем значение
#Для Flask-сервера это означает, что прочитанный символ будет показан на веб-странице https://сайт/iot
def run(): #функция запуска flask-сервера
app.run(host='0.0.0.0', port=80)
def reminder():
while True:
with open('user_id.txt','r') as f:#пытаемся прочитать user_id. Номер чата с пользователем
lines = f.readlines()
if len(lines)>0:
chat_id = lines[0]
else:
chat_id = None
with open('messages.txt','r') as f:# читаем файл с сообщением
lines = f.readlines()
if len(lines)>0 and chat_id is not None:#если есть user_id и сообщение
text = lines[0]
token = os.environ['TOKEN']
requests.get(r"https://api.telegram.org/bot"
+token
+r"/sendMessage?chat_id="+chat_id
+r"&text="+text)
#отправляем сообщение по специальной ссылке с использованием токена
with open('messages.txt','w') as f:
f.write("")#очищаем файл с сообщениями
time.sleep(0.3)
def keep_alive():# запускаем flask и reminder в отдельных потоках
t = Thread(target=run)
t.start()
tr = Thread(target=reminder)
tr.start()
```
Прекрасно! Теперь, когда все запустилось, нужно записать ссылку доступа к серверу и ключ шифрования для доступа по протоколу https.
### Реализация - шаг 2 - код для ESP8266
После запуска сервера в правом верхнем углу экрана будет ссылка. Копируем ее и вставляем в браузер:
Нажимаем на иконку замка рядом с адресом сайта:
и просматриваем сертификат. Текст меню может немного отличаться в разных браузерах, но принцип остается тот же.
Копируем и сохраняем "отпечаток SHA-1":
Копируем код в Arduino IDE. Меняем параметры доступа к Wi-Fi, адрес сервера *(указывается без https)* и отпечаток SHA-1:
```
#include
#include
#include
#include
#define LED 2
const char \*ssid = "ИМЯ\_WiFi\_сети";
const char \*password = "ППАРОЛЬ\_WiFi\_сети";
const char \*host = "test.username.repl.co";//адрес сервера без https://
const int httpsPort = 443;
//отпечаток SHA-1, который скопировали раньше
const char fingerprint[] PROGMEM = "AA BB CC DD EE FF 00 11 22 33 44 55 66";
void setup() {
pinMode(LED, OUTPUT);
digitalWrite(LED, HIGH);
delay(1000);
Serial.begin(115200);
WiFi.mode(WIFI\_OFF);
delay(1000);
WiFi.mode(WIFI\_STA);
WiFi.begin(ssid, password);//подключаемся к сети
Serial.println("");
Serial.print("Connecting");
while (WiFi.status() != WL\_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Connected to ");
Serial.println(ssid);
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
}
void loop() {
WiFiClientSecure httpsClient;
Serial.println(host);
Serial.printf("Using fingerprint '%s'\n", fingerprint);
httpsClient.setFingerprint(fingerprint);
httpsClient.setTimeout(500);
delay(1000);
//подключение к серверу
Serial.print("HTTPS Connecting");
int r=0;
while((!httpsClient.connect(host, httpsPort)) && (r < 30)){
delay(100);
Serial.print(".");
r++;
}
if(r==30) {
Serial.println("Connection failed");
}
else {
Serial.println("Connected to web");
}
String ADCData, getData, Link;
//создаем переменные, значения которых будут передаваться на сервер
int temp = 15;//условная температура, которую в дальнейшем можно получать с датчика
int light = !digitalRead(LED);//состояние встроенного светодиода, которы и есть СВЕТ в данном проекте
Link = "/iot?temp="+String(temp)+"&light="+String(light);//собираем ссылку из параметров
Serial.print("requesting URL: ");
Serial.println(host+Link);
// выполняем переход по этой ссылке
httpsClient.print(String("GET ") + Link + " HTTP/1.1\r\n" +
"Host: " + host + "\r\n" +
"Connection: close\r\n\r\n");
Serial.println("request sent");
while (httpsClient.connected()) {
String line = httpsClient.readStringUntil('\n');
if (line == "\r") {
Serial.println("headers received");
break;
}
}
Serial.print("reply:");
//в переменную line записываем ответ сервера. В данном случае 0 или 1, команда от телеграм-бота
String line;
while(httpsClient.available()){
line = httpsClient.readStringUntil('\n');
Serial.println(line);
if (line=="0") {//включаем или выключаем свет
digitalWrite(LED, HIGH);
}
if (line=="1") {
digitalWrite(LED, LOW);
}
}
Serial.println("closing connection");
delay(500);//ждем 0.5с и повторяем
}
```
Загружаем код в ESP и наслаждаемся первым шагом к умному дому, сделанному своими руками.
Дальше полет фантазии в реализации не ограничен!
Такие дела! Успехов!
|
https://habr.com/ru/post/710173/
| null |
ru
| null |
# Адекватны ли пользователи вашей системы?
Наверняка многие использовали для записи сессий командной строки программу script.
А кто-нибудь задавался вопросом, а можно ли использовать её в рамках повышения безопасности/мониторинга/проверки адекватности пользователей системы?
Любопытства ради решил прикрутить script ко всем пользователям системы и посмотреть, что из этого выйдет…
``> #!/bin/sh
>
> if [ "$TERM" != "" ]; then
>
> DATE=`date +%F.%H.%M`
>
> FOLDER="/tmp/"
>
> exec script -q -t $FOLDER$USER.$DATE 2> $FOLDER$USER.$DATE.time
>
> else
>
> /bin/sh $\*
>
> fi
>
>
>
>`
Добавляем такой скрипт в /etc/profile (в gentoo сохранил это в файл bash.sh и поместил его в директорию /etc/profile.d/).
Можно проверять работоспособность, заходя по SSH или любым другим способом.
В /tmp должны появиться файлы вида test.2010-03-25.20.01 и test.2010-03-25.20.01.time.
Файл c .time содержит в себе всю информацию по таймингу сессии.
Если файлы создались, дабы проверить плоды, запускаем:
`scriptreplay test.2010-03-25.20.01.time test.2010-03-25.20.01`
и наслаждаемся просмотром.
Хочу сразу сказать недоработки:
1 Если подключаться ssh user@host /bin/bash -i — то ничего не логируется =(
Основной интерес к этому способу появился от желания последить за работой новых админов, посмотреть их способы (не стоять же за спиной у бедняги).
Так же можно создать отдельный каталог вместо /tmp, например /opt/sessions и задать права:
`chmod 733 /opt/sessions`
Дабы все сессии могли писать, но юзеры не могли сделать листинг этой дирекории.
UPD: спасибо [unera](http://unera.habrahabr.ru/) за подсказку с exec`
|
https://habr.com/ru/post/88940/
| null |
ru
| null |
# Книга «Машинное обучение: алгоритмы для бизнеса»
[](https://habr.com/ru/company/piter/blog/454778/) Привет, Хаброжители! Маркос Лопез де Прадо делится тем, что обычно скрывают, — самыми прибыльными алгоритмами машинного обучения, которые он использовал на протяжении двух десятилетий, чтобы управлять большими пулами средств самых требовательных инвесторов.
Машинное обучение меняет практически каждый аспект нашей жизни, алгоритмы МО выполняют задачи, которые до недавнего времени доверяли только проверенным экспертам. В ближайшем будущем машинное обучение будет доминировать в финансах, гадание на кофейной гуще уйдет в прошлое, а инвестиции перестанут быть синонимом азартных игр.
Воспользуйтесь шансом поучаствовать в «машинной революции», для этого достаточно познакомиться с первой книгой, в которой приведен полный и систематический анализ методов машинного обучения применительно к финансам: начиная со структур финансовых данных, маркировки финансового ряда, взвешиванию выборки, дифференцированию временного ряда… и заканчивая целой частью, посвященной правильному бэктестированию инвестиционных стратегий.
### Отрывок. Понимание риска стратегии
### 15.1. Актуальность
Инвестиционные стратегии часто реализуются с точки зрения позиций, которыми владеют до тех пор, пока не будет выполнено одно из двух условий: 1) условие выхода из позиции с прибылями (взятие прибыли) или 2) условие выхода из позиции с убытками (остановка убытка). Даже когда стратегия явно не объявляет остановку убытка, всегда существует неявный предел остановки убытка, при котором инвестор больше не может финансировать свою позицию (маржин колл) или несет ущерб, вызванный увеличением нереализованного убытка. Поскольку большинство стратегий имеют (явно или неявно) эти два условия выхода, имеет смысл моделировать распределение исходов посредством биномиального процесса. Это, в свою очередь, поможет нам понять, какие сочетания частоты ставок, рисков и выплат являются неэкономичными. Цель этой главы — помочь вам оценить, когда стратегия уязвима к небольшим изменениям в любой из этих величин.
Рассмотрим стратегию, которая производит n одинаково распределенных взаимно независимых ставок в год, где исход Xi ставки i ∈ [1, n] представляет собой прибыль π > 0 с вероятностью P [Xi = π] = p и убыток –π с вероятностью P [Xi = –π] = 1 – p. Вы можете представить p как точность бинарного классификатора, в котором утвердительный исход означает заключение ставки на возможность, а отрицательный исход означает пропуск возможности: истинные утверждения вознаграждаются, ложные утверждения наказываются, и отрицательные исходы (будь то истинные или ложные) выплат не имеют. Поскольку исходы ставок {Xi}i=1,...,n независимы, мы будем вычислять ожидаемые моменты в расчете на ставку. Ожидаемая прибыль от одной ставки составляет E[Xi] = πp + (–π)(1 – p) = π(2p – 1). Дисперсия составляет , где  = π2p + (–π)2(1 – p) = π2, следовательно, V [Xi] = π2 – π2 (2p – 1)2 = π2[1–(2p – 1)2] = 4π2p(1 – p). Для n одинаково распределенных взаимно независимых ставок в год среднегодовой коэффициент Шарпа (θ) равен
Обратите внимание, как π уравновешивает приведенное выше уравнение, потому что выплаты симметричны. Так же как и в гауссовом случае, θ [p, n] можно понимать как решкалированное t-значение1. Этим иллюстрируется тот факт, что даже для малого  коэффициент Шарпа может быть сделан высоким для достаточно большого n. Это служит экономической основой для высокочастотного трейдинга, где p может быть чуть выше .5, а залогом успешной биржевой деятельности является увеличение n. Коэффициент Шарпа является функцией от точности, а не от правильности, потому что пропуск возможности (отрицательное утверждение) не вознаграждается или наказывается напрямую (хотя слишком много отрицательных утверждений может привести к малому n, что будет сводить коэффициент Шарпа к нулю).
Например, для  и для достижения среднегодового коэффициента Шарпа, равного 2, требуется 396 ставок в год. Листинг 15.1 проверяет этот результат экспериментально. Рисунок 15.1 показывает коэффициент Шарпа как функцию от точности для разных частот ставок.
Листинг 15.1. Коэффициент Шарпа как функция от числа ставок
```
out,p=[],.55
for i in xrange(1000000):
rnd=np.random.binomial(n=1,p=p)
x=(1 if rnd==1 else -1)
out.append(x)
print np.mean(out),np.std(out),np.mean(out)/np.std(out)
```
Это уравнение совершенно ясно выражает компромисс между точностью (p) и частотой (n) для заданного коэффициента Шарпа (θ). Например, для того чтобы давать среднегодовой коэффициент Шарпа, равный 2, стратегии, которая производит только еженедельные ставки (n = 52), потребуется довольно высокая точность p = 0.6336.
### 15.3. Асимметричные выплаты
Рассмотрим стратегию, которая производит n одинаково распределенных взаимно независимых ставок в год, где исход Xi ставки i ∈ [1, n] равен π+ с вероятностью P [Xi = π+] = p, а исход π– (π– < π+) случается с вероятностью P[Xi = π\_] = 1 – p. Ожидаемая прибыль от одной ставки составляет E[Xi] = pπ+ + (1 – p)π– = (π+ – π–)p + π–. Дисперсия составляет V[Xi] =, где
Наконец, мы можем решить предыдущее уравнение для 0 ≤ p ≤ 1 и получить
где:
a = (n + θ2)(π+ – π–)2;
b = [2nπ – θ2(π+ – π–)](π+ – π–);
Примечание: листинг 15.2 проверяет эти символические операции с помощью Python-овской оболочки SymPy Live, работающей на облачной службе Google App Engine: [live.sympy.org](http://live.sympy.org/).
Листинг 15.2. Использование библиотеки SymPy для символических операций
```
>>> from sympy import *
>>> init_printing(use_unicode=False,wrap_line=False,no_global=True)
>>> p,u,d=symbols('p u d')
>>> m2=p*u**2+(1-p)*d**2
>>> m1=p*u+(1-p)*d
>>> v=m2-m1**2
>>> factor(v)
```
Приведенное выше уравнение отвечает на следующий вопрос: при заданном торговом правиле, характеризуемом параметрами {π–, π+, n}, какова степень точности p, необходимая для достижения коэффициента Шарпа, равного θ\*? Например, для того чтобы получить θ = 2 для n = 260, π– = –.01, π+ = .005, нам потребуется p = .72. Благодаря большому числу ставок очень малое изменение в p (с p = .7 до p = .72) продвинуло коэффициент Шарпа с θ = 1.173 до θ = 2. С другой стороны, это также говорит нам о том, что данная стратегия уязвима для малых изменений в p. Листинг 15.3 реализует выведение предполагаемой точности. На рис. 15.2 показана предполагаемая точность как функция от n и π–, где π+ = 0.1, а θ\* = 1.5. По мере того как для заданного n порог π– становится отрицательнее, требуется более высокая степень р, необходимая для достижения θ\* для заданного порога π+. По мере того как для заданного порога π– число n становится меньше, требуется более высокая степень р, необходимая для достижения θ\* для заданного π+.
Листинг 15.3. Вычисление предполагаемой точности
```
def binHR(sl,pt,freq,tSR):
´´´
```
При заданном торговом правиле, характеризующемся параметрами {sl,pt,freq}, какова минимальная точность, требуемая для достижения коэффициента Шарпа, равного tSR?
1) Входы
sl: порог остановки убытка
pt: порог взятия прибыли
freq: число ставок в год
tSR: целевой среднегодовой коэффициент Шарпа
2) Выход
p: минимальная степень точности p, требуемая для достижения tSR
´´´
a=(freq+tSR\*\*2)\*(pt-sl)\*\*2
b=(2\*freq\*sl-tSR\*\*2\*(pt-sl))\*(pt-sl)
c=freq\*sl\*\*2
p=(-b+(b\*\*2–4\*a\*c)\*\*.5)/(2.\*a)
return p
Листинг 15.4 решает θ[p, n, π–, π+] для предполагаемой частоты заключения ставок n. На рис. 15.3 показана предполагаемая частота в зависимости от p и π–, где π+ = 0.1, а θ\* = 1.5. По мере того как для заданной степени p порог π– становится отрицательнее, требуется более высокое число n, необходимое для достижения θ\* для данного порога π+. По мере того как для заданного порога π– степень p становится меньше, требуется более высокое число n, необходимое для достижения θ\* для заданного порога π+.
Листинг 15.4. Вычисление предполагаемой частоты заключения ставок
```
def binFreq(sl,pt,p,tSR):
´´´
```
При заданном торговом правиле, характеризующемся параметрами {sl, pt, freq}, какое число ставок в год необходимо для достижения коэффициента Шарпа tSR со степенью точности p?
Примечание: уравнение с радикалами, проверьте наличие постороннего решения.
1) Входы
sl: порог остановки убытка
pt: порог взятия прибыли
p: степень точности p
tSR: целевой среднегодовой коэффициент Шарпа
2) Выход
freq: число необходимых ставок в год
´´´
freq=(tSR\*(pt-sl))\*\*2\*p\*(1-p)/((pt-sl)\*p+sl)\*\*2 # возможно постороннее
if not np.isclose(binSR(sl,pt,freq,p),tSR): return
return freq
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/best/product/mashinnoe-obuchenie-algoritmy-dlya-biznesa)
» [Оглавление](https://storage.piter.com/upload/contents/978544611154/978544611154_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544611154/978544611154_p.pdf)
Для Хаброжителей скидка 25% по купону — **Машинное обучение**
По факту оплаты бумажной версии книги на e-mail высылается электронная версия книги.
|
https://habr.com/ru/post/454778/
| null |
ru
| null |
# The Code of the Command & Conquer Game: Bugs From the 90's. Volume one
The American company Electronic Arts Inc (EA) has made the source code of the games Command & Conquer: Tibetan Dawn and Command & Conquer: Red Alert publicly available. This code should help the game community to develop mods and maps, create custom units, and customize the gameplay logic. We all now have a unique opportunity to plunge into the history of development, which is very different from the modern one. Back then, there was no StackOverflow site, convenient code editors, or powerful compilers. Moreover, at that time, there were no static analyzers, and the first thing the community will face is hundreds of errors in the code. This is what the PVS-Studio team will help you with by pointing out the erroneous places.
Introduction
------------
Command & Conquer is a series of computer games in the real-time strategy genre. The first game in the series was released in 1995. The Electronic Arts company acquired this game's development studio only in 1998.
Since then, several games and many mods have been released. The source code of the games was [posted](https://github.com/electronicarts/CnC_Remastered_Collection) together with the release of the [Command & Conquer Remastered](https://www.ea.com/games/command-and-conquer/command-and-conquer-remastered) collection.
The [PVS-Studio](https://www.viva64.com/en/pvs-studio/) analyzer was used to find errors in the code. The tool is designed to detect errors and potential vulnerabilities in the source code of programs, written in C, C++, C#, and Java.
Due to the large amount of problems found in the code, all error examples will be given in a series of two articles.
Typos and copy-paste
--------------------
V501 There are identical sub-expressions to the left and to the right of the '||' operator: dest == 0 || dest == 0 CONQUER.CPP 5576
```
void List_Copy(short const * source, int len, short * dest)
{
if (dest == NULL || dest == NULL) {
return;
}
....
}
```
I'd like to start the review with the never ending copy-paste. The author hasn't checked the pointer for the source and checked the destination pointer twice, because they had copied the *dest == NULL*check and had forgotten to change the variable name.
V584 The 'Current' value is present on both sides of the '!=' operator. The expression is incorrect or it can be simplified. CREDITS.CPP 173
```
void CreditClass::AI(bool forced, HouseClass *player_ptr, bool logic_only)
{
....
long adder = Credits - Current;
adder = ABS(adder);
adder >>= 5;
adder = Bound(adder, 1L, 71+72);
if (Current > Credits) adder = -adder;
Current += adder;
Countdown = 1;
if (Current-adder != Current) { // <=
IsAudible = true;
IsUp = (adder > 0);
}
....
}
```
The analyzer found a meaningless comparison. I suppose there must have been something as follows:
```
if (Current-adder != Credits)
```
but inattention has won.
The exact same code fragment was copied to another function:
* V584 The 'Current' value is present on both sides of the '!=' operator. The expression is incorrect or it can be simplified. CREDITS.CPP 246
V524 It is odd that the body of 'Mono\_Y' function is fully equivalent to the body of 'Mono\_X' function. MONOC.CPP 753
```
class MonoClass {
....
int Get_X(void) const {return X;};
int Get_Y(void) const {return Y;};
....
}
int Mono_X(void)
{
if (MonoClass::Is_Enabled()) {
MonoClass *mono = MonoClass::Get_Current();
if (!mono) {
mono = new MonoClass();
mono->View();
}
return(short)mono->Get_X(); // <=
}
return(0);
}
int Mono_Y(void)
{
if (MonoClass::Is_Enabled()) {
MonoClass *mono = MonoClass::Get_Current();
if (!mono) {
mono = new MonoClass();
mono->View();
}
return(short)mono->Get_X(); // <= Get_Y() ?
}
return(0);
}
```
A larger piece of code that was copied with the consequences. You have to admit, that except using the analyzer, you won't be able notice that the *Get\_X* function instead of *Get\_Y*was called from the *Mono\_Y* function. The *MonoClass* class does have 2 functions that differ by one symbol. Most likely, we found a real error.
I found the identical piece of code below:
* V524 It is odd that the body of 'Mono\_Y' function is equivalent to the body of 'Mono\_X' function. MONOC.CPP 1083
Errors with arrays
------------------
V557 Array overrun is possible. The '9' index is pointing beyond array bound. FOOT.CPP 232
```
#define CONQUER_PATH_MAX 9 // Number of cells to look ahead for movement.
FacingType Path[CONQUER_PATH_MAX];
void FootClass::Debug_Dump(MonoClass *mono) const
{
....
if (What_Am_I() != RTTI_AIRCRAFT) {
mono->Set_Cursor(50, 3);
mono->Printf("%s%s%s%s%s%s%s%s%s%s%s%s",
Path_To_String(Path[0]),
Path_To_String(Path[1]),
Path_To_String(Path[2]),
Path_To_String(Path[3]),
Path_To_String(Path[4]),
Path_To_String(Path[5]),
Path_To_String(Path[6]),
Path_To_String(Path[7]),
Path_To_String(Path[8]),
Path_To_String(Path[9]),
Path_To_String(Path[10]),
Path_To_String(Path[11]),
Path_To_String(Path[12]));
....
}
....
}
```
It seems that this is a debugging method, but the history doesn't record to what extent it could be detrimental for the developer's mental health. Here, the *Path* array consists of **9** elements, and all **13** of them are printed.
In total, 4 memory accesses outside the array boundary:
* V557 Array overrun is possible. The '9' index is pointing beyond array bound. FOOT.CPP 232
* V557 Array overrun is possible. The '10' index is pointing beyond array bound. FOOT.CPP 233
* V557 Array overrun is possible. The '11' index is pointing beyond array bound. FOOT.CPP 234
* V557 Array overrun is possible. The '12' index is pointing beyond array bound. FOOT.CPP 235
V557 Array underrun is possible. The value of '\_SpillTable[index]' index could reach -1. COORD.CPP 149
```
typedef enum FacingType : char {
....
FACING_COUNT, // 8
FACING_FIRST=0
} FacingType;
short const * Coord_Spillage_List(COORDINATE coord, int maxsize)
{
static short const _MoveSpillage[(int)FACING_COUNT+1][5] = {
....
};
static char const _SpillTable[16] = {8,6,2,-1,0,7,1,-1,4,5,3,-1,-1,-1,-1,-1};
....
return(&_MoveSpillage[_SpillTable[index]][0]);
....
}
```
At first glance, the example is complex, but it is easy to puzzle it out after a brief analysis.
The two-dimensional *\_MoveSpillage* array is accessed by an index that is taken from the *\_SpillTable* array. The array happens to contain negative values. Perhaps, access to data is organized according to a special formula and this is what the developer intended. Nonetheless, I'm not sure about that.
V512 A call of the 'sprintf' function will lead to overflow of the buffer '(char \*) ptr'. SOUNDDLG.CPP 250
```
void SoundControlsClass::Process(void)
{
....
void * ptr = new char [sizeof(100)]; // <=
if (ptr) {
sprintf((char *)ptr, "%cTrack %d\t%d:%02d\t%s", // <=
index, listbox.Count()+1, length / 60, length % 60, fullname);
listbox.Add_Item((char const *)ptr);
}
....
}
```
An attentive reader will wonder — why such a long string is saved in a buffer of 4 bytes? This is because the programmer thought that *sizeof(100)* would return something more (at least *100*). However, the *sizeof* operator returns the size of the type and even never evaluates any expressions. The author should have just written the constant *100*, or better yet, used named constants, or a different type for strings or a pointer.
V512 A call of the 'memset' function will lead to underflow of the buffer 'Buffer'. KEYBOARD.CPP 96
```
unsigned short Buffer[256];
WWKeyboardClass::WWKeyboardClass(void)
{
....
memset(Buffer, 0, 256);
....
}
```
A buffer is cleared by 256 bytes, although the full size of the original buffer is *256\*sizeof(unsigned short)*. Oops… goofed this one.
It can be also fixed as follows:
```
memset(Buffer, 0, sizeof(Buffer));
```
V557 Array overrun is possible. The 'QuantityB' function processes value '[0..86]'. Inspect the first argument. Check lines: 'HOUSE.H:928', 'CELL.CPP:2337'. HOUSE.H 928
```
typedef enum StructType : char {
STRUCT_NONE=-1,
....
STRUCT_COUNT, // <= 87
STRUCT_FIRST=0
} StructType;
int BQuantity[STRUCT_COUNT-3]; // <= [0..83]
int QuantityB(int index) {return(BQuantity[index]);} // <= [0..86]
bool CellClass::Goodie_Check(FootClass * object)
{
....
int bcount = 0;
for( j=0; j < STRUCT_COUNT; j++) {
bcount += hptr->QuantityB(j); // <= [0..86]
}
....
}
```
There are a lot of global variables in the code and it is obvious that they are easy to get confused. The analyzer's warning about an array index out of bounds is issued at the point of accessing the *BQuantity* array by index. The array size is 84 elements. Algorithms for analyzing the data flow in the analyzer helped to find out that the index value comes from another function – *Goodie\_Check*. There, a loop is executed with a final value of *86*. Therefore, 12 bytes of "someone's" memory (3 *int* elements) are constantly being read in this place.
V575 The 'memset' function processes '0' elements. Inspect the third argument. DLLInterface.cpp 1103
```
void* __cdecl memset(
_Out_writes_bytes_all_(_Size) void* _Dst,
_In_ int _Val,
_In_ size_t _Size
);
extern "C" __declspec(dllexport) bool __cdecl CNC_Read_INI(....)
{
....
memset(ini_buffer, _ini_buffer_size, 0);
....
}
```
In my opinion, I have repeatedly seen this error in modern projects. Programmers still confuse the 2nd and 3rd arguments of the *memset* function.
One more similar fragment:
* V575 The 'memset' function processes '0' elements. Inspect the third argument. DLLInterface.cpp 1404
About null pointers
-------------------
V522 Dereferencing of the null pointer 'list' might take place. DISPLAY.CPP 1062
```
void DisplayClass::Get_Occupy_Dimensions(int & w, int & h, short const *list)
{
....
if (!list) {
/*
** Loop through all cell offsets, accumulating max & min x- & y-coords
*/
while (*list != REFRESH_EOL) {
....
}
....
}
....
}
```
An explicit access to a null pointer looks very strange. This place looks like the one with a typo and there are a few other places worth checking out:
* V522 Dereferencing of the null pointer 'list' might take place. DISPLAY.CPP 951
* V522 Dereferencing of the null pointer 'unitsptr' might take place. QUEUE.CPP 2362
* V522 Dereferencing of the null pointer 'unitsptr' might take place. QUEUE.CPP 2699
V595 The 'enemy' pointer was utilized before it was verified against nullptr. Check lines: 3689, 3695. TECHNO.CPP 3689
```
void TechnoClass::Base_Is_Attacked(TechnoClass const *enemy)
{
FootClass *defender[6];
int value[6];
int count = 0;
int weakest = 0;
int desired = enemy->Risk() * 2;
int risktotal = 0;
/*
** Humans have to deal with their own base is attacked problems.
*/
if (!enemy || House->Is_Ally(enemy) || House->IsHuman) {
return;
}
....
}
```
The *enemy* pointer is dereferenced, and then checked to make sure that it is nonnull. It is still a vital problem, dare I say it, for every open source project. I'm sure that in projects with closed code the situation is about the same, unless, of course, PVS-Studio is used ;-)
Incorrect casts
---------------
V551 The code under this 'case' label is unreachable. The '4109' value of the 'char' type is not in the range [-128; 127]. WINDOWS.CPP 547
```
#define VK_RETURN 0x0D
typedef enum {
....
WWKEY_VK_BIT = 0x1000,
....
}
enum {
....
KA_RETURN = VK_RETURN | WWKEY_VK_BIT,
....
}
void Window_Print(char const string[], ...)
{
char c; // Current character.
....
switch(c) {
....
case KA_FORMFEED: // <= 12
New_Window();
break;
case KA_RETURN: // <= 4109
Flush_Line();
ScrollCounter++;
WinCx = 0;
WinCy++;
break;
....
}
....
}
```
This function handles the characters you enter. As you know, a 1-byte value is placed in the *char* type, and the number *4109* will never be there. So, this *switch* statement just contains an unreachable code branch.
Several such places were found:
* V551 The code under this 'case' label is unreachable. The '4105' value of the 'char' type is not in the range [-128; 127]. WINDOWS.CPP 584
* V551 The code under this 'case' label is unreachable. The '4123' value of the 'char' type is not in the range [-128; 127]. WINDOWS.CPP 628
V552 A bool type variable is being incremented: printedtext ++. Perhaps another variable should be incremented instead. ENDING.CPP 170
```
void Nod_Ending(void)
{
....
bool printedtext = false;
while (!done) {
if (!printedtext && !Is_Sample_Playing(kanefinl)) {
printedtext++;
Alloc_Object(....);
mouseshown = true;
Show_Mouse();
}
....
}
....
}
```
In this code fragment, the analyzer found the application of the increment operation to a variable of the *bool* type. This is correct code from the point of view of the language, but it looks very strange now. This operation is also marked as deprecated, starting from the C++17 standard.
In total, 2 such places were detected:
* V552 A bool type variable is being incremented: done ++. Perhaps another variable should be incremented instead. ENDING.CPP 187
V556 The values of different enum types are compared. Types: ImpactType, ResultType. AIRCRAFT.CPP 742
```
ImpactType FlyClass::Physics(COORDINATE & coord, DirType facing);
typedef enum ImpactType : unsigned char { // <=
IMPACT_NONE,
IMPACT_NORMAL,
IMPACT_EDGE
} ImpactType;
typedef enum ResultType : unsigned char { // <=
RESULT_NONE,
....
} ResultType;
void AircraftClass::AI(void)
{
....
if (Physics(Coord, PrimaryFacing) != RESULT_NONE) { // <=
Mark();
}
....
}
```
The programmer tied some logic to comparing the values of different enumerations. Technically, this works because numerical representations are compared. But such code often leads to logical errors. It is worth tweaking the code (of course, if this project is to be supported).
The entire list of warnings for this diagnostic looks like this:
* V556 The values of different enum types are compared: SoundEffectName[voc].Where == IN\_JUV. DLLInterface.cpp 402
* V556 The values of different enum types are compared: SoundEffectName[voc].Where == IN\_VAR. DLLInterface.cpp 405
* V556 The values of different enum types are compared: Map.Theater == CNC\_THEATER\_DESERT. Types: TheaterType, CnCTheaterType. DLLInterface.cpp 2805
* V556 The values of different enum types are compared. Types: ImpactType, ResultType. AIRCRAFT.CPP 4269
* V556 The values of different enum types are compared: SoundEffectName[voc].Where == IN\_VAR. DLLInterface.cpp 429
V716 Suspicious type conversion in assign expression: 'HRESULT = BOOL'. GBUFFER.H 780
```
BOOL __cdecl Linear_Blit_To_Linear(...);
inline HRESULT GraphicViewPortClass::Blit(....)
{
HRESULT return_code=0;
....
return_code=(Linear_Blit_To_Linear(this, &dest, x_pixel, y_pixel
, dx_pixel, dy_pixel
, pixel_width, pixel_height, trans));
....
return ( return_code );
}
```
This is a very old problem that is still relevant today. There are special macros for working with the HRESULT type. Casting to BOOL and visa versa isn't used for this type. These two data types are extremely similar to each other from the point of view of the language, but logically they are still incompatible. The implicit type casting operation that exists in the code doesn't make sense.
This and a few other places would be worth refactoring:
* V716 Suspicious type conversion in assign expression: 'HRESULT = BOOL'. GBUFFER.H 817
* V716 Suspicious type conversion in assign expression: 'HRESULT = BOOL'. GBUFFER.H 857
* V716 Suspicious type conversion in assign expression: 'HRESULT = BOOL'. GBUFFER.H 773
* V716 Suspicious type conversion in assign expression: 'HRESULT = BOOL'. GBUFFER.H 810
* V716 Suspicious type conversion in assign expression: 'HRESULT = BOOL'. GBUFFER.H 850
V610 Undefined behavior. Check the shift operator '<<'. The left operand '(~0)' is negative. MP.CPP 2410
```
void XMP_Randomize(digit * result, Straw & rng, int total_bits, int precision)
{
....
((unsigned char *)result)[nbytes-1] &=
(unsigned char)(~((~0) << (total_bits % 8)));
....
}
```
Here, the negative number is shifted to the left, which is undefined behavior. A negative number is obtained from zero when using the inversion operator. Since the result of the operation is placed in the *int* type, the compiler uses it to store the value, whereas it is of the signed type.
In 2020, the compiler already finds this error as well:
*Warning C26453: Arithmetic overflow: Left shift of a negative signed number is undefined behavior.*
But compilers are not full-fledged static analyzers, because they solve other problems. So here is another example of undefined behavior that is only detected by PVS-Studio:
V610 Undefined behavior. Check the shift operator '<<'. The right operand ('(32 — bits\_to\_shift)' = [1..32]) is greater than or equal to the length in bits of the promoted left operand. MP.CPP 659
```
#define UNITSIZE 32
void XMP_Shift_Right_Bits(digit * number, int bits, int precision)
{
....
int digits_to_shift = bits / UNITSIZE;
int bits_to_shift = bits % UNITSIZE;
int index;
for (index = digits_to_shift; index < (precision-1); index++) {
*number = (*(number + digits_to_shift) >> bits_to_shift) |
(*(number + (digits_to_shift + 1)) << (UNITSIZE - bits_to_shift));
number++;
}
....
}
```
The analyzer has found an unusual situation. The 32-bit number can be potentially shifted to the right for the number of bits, exceeding the available number. Here's how it works:
```
int bits_to_shift = bits % UNITSIZE;
```
The *UNITIZE* constant has the value *32*:
```
int bits_to_shift = bits % 32;
```
Thus, the value of the *bits\_to\_shift* variable will be zero for all *bits* values that are multiples of *32*.
Therefore, in this code fragment:
```
.... << (UNITSIZE - bits_to_shift) ....
```
32 digits will be shifted if *0* is subtracted from the constant *32*.
List of all PVS-Studio warnings about shifts with undefined behavior:
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(~0)' is negative. TARGET.H 66
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 24) \* 256) / 24)' is negative. ANIM.CPP 160
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 12) \* 256) / 24)' is negative. BUILDING.CPP 4037
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 21) \* 256) / 24)' is negative. DRIVE.CPP 2160
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 21) \* 256) / 24)' is negative. DRIVE.CPP 2161
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 20) \* 256) / 24)' is negative. DRIVE.CPP 2162
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 20) \* 256) / 24)' is negative. DRIVE.CPP 2163
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 18) \* 256) / 24)' is negative. DRIVE.CPP 2164
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 18) \* 256) / 24)' is negative. DRIVE.CPP 2165
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 17) \* 256) / 24)' is negative. DRIVE.CPP 2166
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 16) \* 256) / 24)' is negative. DRIVE.CPP 2167
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 15) \* 256) / 24)' is negative. DRIVE.CPP 2168
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 14) \* 256) / 24)' is negative. DRIVE.CPP 2169
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 13) \* 256) / 24)' is negative. DRIVE.CPP 2170
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 12) \* 256) / 24)' is negative. DRIVE.CPP 2171
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 11) \* 256) / 24)' is negative. DRIVE.CPP 2172
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 10) \* 256) / 24)' is negative. DRIVE.CPP 2173
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 9) \* 256) / 24)' is negative. DRIVE.CPP 2174
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 8) \* 256) / 24)' is negative. DRIVE.CPP 2175
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 7) \* 256) / 24)' is negative. DRIVE.CPP 2176
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 6) \* 256) / 24)' is negative. DRIVE.CPP 2177
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 5) \* 256) / 24)' is negative. DRIVE.CPP 2178
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 4) \* 256) / 24)' is negative. DRIVE.CPP 2179
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 3) \* 256) / 24)' is negative. DRIVE.CPP 2180
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 2) \* 256) / 24)' is negative. DRIVE.CPP 2181
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 1) \* 256) / 24)' is negative. DRIVE.CPP 2182
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(((- 5) \* 256) / 24)' is negative. INFANTRY.CPP 2730
* V610 Undefined behavior. Check the shift operator '>>'. The right operand ('(32 — bits\_to\_shift)' = [1..32]) is greater than or equal to the length in bits of the promoted left operand. MP.CPP 743
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(~0)' is negative. RANDOM.CPP 102
* V610 Undefined behavior. Check the shift operator '<<'. The left operand '(~0L)' is negative. RANDOM.CPP 164
Conclusion
----------
Let's hope that modern projects of Electronic Arts are of better quality. If not, we invite you to our site to [download](https://www.viva64.com/en/pvs-studio-download/) and try PVS-Studio on all projects.
Someone may object that cool successful games used to be made with this quality, and we can partially agree with this. On the other hand, we mustn't forget that competition in the development of programs and games has grown many times over the years. Expenses on development, support, and advertising have also increased. Consequently, fixing errors at later stages of development can lead to significant financial and reputational losses.
Follow our blog and don't miss the 2nd part of the review of this games series.
|
https://habr.com/ru/post/507164/
| null |
en
| null |
# VVVVVV??? VVVVVV!!! :)
Если вы читаете этот текст – значит, вы либо подумали, что с заголовком статьи что-то не то, либо увидели в нём название знакомой компьютерной игры. VVVVVV – это инди-игра в жанре «платформер», завоевавшая сердца многих игроков своей приятной внешней простотой и не менее приятной внутренней сложностью. Несколько дней назад VVVVVV исполнилось 10 лет, и автор игры – Terry Cavanagh – отметил этот праздник публикацией её исходного кода. Что же «вкусненького» можно в нём найти? Ответ читайте в данной статье.
Введение
--------
Ох, VVVVVV… Помню, как наткнулся на неё вскоре после релиза, и, будучи большим любителем пиксельных ретро-игр, с радостью установил её себе на компьютер. Помню свои первые впечатления: «И что, это всё? Просто бегать по квадратным комнатам?» – подумал я после нескольких минут игры. Я тогда еще не знал, что меня ждёт. Стоило мне выйти из стартовой локации, как я оказался в небольшом, но запутанном и витиеватом двумерном мире, полном необычных ландшафтов и неизвестных мне пиксельных артефактов.
Эта игра меня затянула. Несмотря на высокую сложность, умело обыгранную необычным на тот момент управлением (главный герой не умеет прыгать, но способен инвертировать для себя направление вектора гравитации), я полностью её прошел. Понятия не имею, сколько раз тогда погиб мой персонаж, но я уверен, что количество смертей измеряется десятками сотен. Всё-таки есть в этой игре какой-то неповторимый шарм :)
Вернемся к исходному коду, [выложенному в честь юбилея игры](https://habr.com/ru/post/483518/).
На данный момент я являюсь C++-разработчиком в команде PVS-Studio – статического анализатора кода для C, C++, C# и Java. Помимо непосредственно разработки, мы также занимаемся и продвижением нашего продукта. Для нас одним из лучших способов делать это является написание статей о проверке проектов с открытым исходным кодом. Наши читатели получают интересные статьи на тематику программирования, а мы получаем возможность наглядно продемонстрировать возможности PVS-Studio. Поэтому, узнав об открытии исходного кода VVVVVV, я просто не смог пройти мимо.
В данной статье мы рассмотрим некоторые интересные ошибки, найденные анализатором PVS-Studio в коде VVVVVV, а также проведём детальный разбор этих ошибок. Возвращайте вектор гравитации в положение «вниз» и усаживайтесь поудобнее: мы начинаем!
Обзор предупреждений, выданных анализатором
-------------------------------------------
### Предупреждение 1
[V512](https://www.viva64.com/ru/w/v512/) A call of the 'sprintf' function will lead to overflow of the buffer 'fileSearch'. FileSystemUtils.cpp 307
```
#define MAX_PATH 260
....
void PLATFORM_migrateSaveData(char *output)
{
char oldLocation[MAX_PATH];
char newLocation[MAX_PATH];
char oldDirectory[MAX_PATH];
char fileSearch[MAX_PATH];
....
/* Same place, different layout. */
strcpy(oldDirectory, output);
sprintf(fileSearch, "%s\\*.vvvvvv", oldDirectory);
....
}
```
Как можно заметить, строки *fileSearch* и *oldDirectory* имеют одинаковый размер: 260 символов. Строка форматирования (третий аргумент *sprintf*) после подстановки в нее содержимого строки *oldDirectory* будет иметь вид:
```
*содержимое\_oldDirectory\\*.vvvvvv*
```
Эта строка на 9 символов длиннее, чем исходное значение *oldDirectory*. Именно эта последовательность символов и будет далее записана в *fileSearch*. Что же случится, если длина строки *oldDirectory* будет больше 251? Результирующая строка окажется длиннее, чем сможет вместить в себя *fileSearch*, что приведет к записи за пределы массива. Какие данные в оперативной памяти могут быть повреждены и к какому результату это приведет – это вопрос риторический :)
### Предупреждение 2
[V519](https://www.viva64.com/ru/w/v519/) The 'background' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1367, 1373. Map.cpp 1373
```
void mapclass::loadlevel(....)
{
....
case 4: //The Warpzone
tmap = warplevel.loadlevel(rx, ry, game, obj);
fillcontent(tmap);
roomname = warplevel.roomname;
tileset = 1;
background = 3; // <=
dwgfx.rcol = warplevel.rcol;
dwgfx.backgrounddrawn = false;
warpx = warplevel.warpx;
warpy = warplevel.warpy;
background = 5; // <=
if (warpy) background = 4;
if (warpx) background = 3;
if (warpx && warpy) background = 5;
break;
....
}
```
Одной и той же переменной два раза подряд присваивается какое-то значение. При этом между присвоениями эта переменная нигде не используется. Странно… Возможно, такая последовательность не нарушает логику работы программы, но такие присвоения сами по себе говорят о некоторой путанице при написании кода. Является ли это ошибкой на самом деле – сможет сказать только автор. Хотя в коде есть и более яркие примеры этой ошибки:
```
void Game::loadquick(....)
{
....
else if (pKey == "frames")
{
frames = atoi(pText);
frames = 0;
}
....
}
```
Здесь уже точно понятно, что где-то здесь кроется либо ошибка в логике, либо, как минимум, лишнее присвоение. Возможно вторая строчка была написана временно для отладки, а затем её забыли удалить. Всего PVS-Studio выдал 8 предупреждений о подобных ситуациях.
### Предупреждение 3
[V808](https://www.viva64.com/ru/w/v808/) 'pKey' object of 'basic\_string' type was created but was not utilized. editor.cpp 1866
```
void editorclass::load(std::string &_path)
{
....
std::string pKey(pElem->Value());
....
if (pKey == "edEntities")
{
int i = 0;
for (TiXmlElement *edEntityEl = pElem->FirstChildElement();
edEntityEl;
edEntityEl = edEntityEl->NextSiblingElement())
{
std::string pKey(edEntityEl->Value()); // <=
//const char* pText = edEntityEl->GetText() ;
if (edEntityEl->GetText() != NULL)
{
edentity[i].scriptname = std::string(edEntityEl->GetText());
}
edEntityEl->QueryIntAttribute("x", &edentity[i].x);
edEntityEl->QueryIntAttribute("y", &edentity[i].y);
edEntityEl->QueryIntAttribute("t", &edentity[i].t);
edEntityEl->QueryIntAttribute("p1", &edentity[i].p1);
edEntityEl->QueryIntAttribute("p2", &edentity[i].p2);
edEntityEl->QueryIntAttribute("p3", &edentity[i].p3);
edEntityEl->QueryIntAttribute("p4", &edentity[i].p4);
edEntityEl->QueryIntAttribute("p5", &edentity[i].p5);
edEntityEl->QueryIntAttribute("p6", &edentity[i].p6);
i++;
}
EditorData::GetInstance().numedentities = i;
}
....
}
```
Очень странный код. Анализатор предупреждает о созданной, но не использованной переменной *pKey*, но на деле проблема оказалась интереснее. Я специально отметил стрелкой строку, на которую было выдано предупреждение, потому что данная функция содержит более одного определения строки с именем *pKey*. Да-да, внутри цикла *for* объявляется еще одна такая переменная, и своим именем она перекрывает ту, что объявлена вне цикла.
Таким образом, если вы обратитесь к значению строки *pKey* вне цикла *for*, вы получите значение, равное *pElem->Value()*, но если сделать то же самое уже внутри цикла, то вы получите значение, равное *edEntityEl->Value()*. Перекрытие имён – это достаточно грубая ошибка, которую бывает весьма тяжело отыскать самостоятельно в ходе обзора кода.
### Предупреждение 4
[V805](https://www.viva64.com/ru/w/v805/) Decreased performance. It is inefficient to identify an empty string by using 'strlen(str) > 0' construct. A more efficient way is to check: str[0] != '\0'. physfs.c 1604
```
static char *prefDir = NULL;
....
const char *PHYSFS_getPrefDir(const char *org, const char *app)
{
....
assert(strlen(prefDir) > 0);
...
return prefDir;
} /* PHYSFS_getPrefDir */
```
Анализатор обнаружил место для потенциальной микрооптимизации. В нем для проверки C-style строки на пустоту используется функция *strlen*. Эта функция «пробегает» все элементы строки и проверяет каждый из них на равенство терминальному нулю ('\0'). Если на вход подается большая строка, то каждый её символ всё равно будет сравнён со строковым нулём.
Но ведь нам нужно только проверить, что строка непустая! Для этого достаточно только узнать, является ли первый символ строки терминальным нулём. Поэтому для оптимизации данной проверки внутри assert стоит написать:
```
str[0] != '\0'
```
Именно такую рекомендацию и даёт нам анализатор. Конечно, вызов функции strlen находится в условии макроса *assert*, поэтому он будет выполняться только в отладочной версии, где скорость не столь важна. В релизной версии вызов функции исчезнет и код будет работать быстро. Тем не менее, мне хотелось продемонстрировать возможности анализатора по предложению микрооптимизаций.
### Предупреждение 5
Чтобы показать следующую ошибку, мне необходимо прикрепить сюда два участка кода: объявление класса *entclass* и его конструктор. Начнем с объявления:
```
class entclass
{
public:
entclass();
void clear();
bool outside();
public:
//Fundamentals
bool active, invis;
int type, size, tile, rule;
int state, statedelay;
int behave, animate;
float para;
int life, colour;
//Position and velocity
int oldxp, oldyp;
float ax, ay, vx, vy;
int cx, cy, w, h;
float newxp, newyp;
bool isplatform;
int x1, y1, x2, y2;
//Collision Rules
int onentity;
bool harmful;
int onwall, onxwall, onywall;
//Platforming specific
bool jumping;
bool gravity;
int onground, onroof;
int jumpframe;
//Animation
int framedelay, drawframe, walkingframe, dir, actionframe;
int yp; int xp;
};
```
Конструктор этого класса выглядит вот так:
```
entclass::entclass()
{
clear();
}
void entclass::clear()
{
// Set all values to a default,
// required for creating a new entity
active = false;
invis = false;
type = 0;
size = 0;
tile = 0;
rule = 0;
state = 0;
statedelay = 0;
life = 0;
colour = 0;
para = 0;
behave = 0;
animate = 0;
xp = 0;
yp = 0;
ax = 0;
ay = 0;
vx = 0;
vy = 0;
w = 16;
h = 16;
cx = 0;
cy = 0;
newxp = 0;
newyp = 0;
x1 = 0;
y1 = 0;
x2 = 320;
y2 = 240;
jumping = false;
gravity = false;
onground = 0;
onroof = 0;
jumpframe = 0;
onentity = 0;
harmful = false;
onwall = 0;
onxwall = 0;
onywall = 0;
isplatform = false;
framedelay = 0;
drawframe = 0;
walkingframe = 0;
dir = 0;
actionframe = 0;
}
```
Достаточно много полей, не правда ли? Неудивительно, что здесь затаилась ошибка, на которую PVS-Studio выдал предупреждение:
[V730](https://www.viva64.com/ru/w/v730/) It is possible that not all members of a class are initialized inside the constructor. Consider inspecting: oldxp, oldyp. Ent.cpp 3
Как видите, в таком большом списке потерялись инициализации двух полей класса. Тем самым, их значения остались неопределенны, из-за чего где-то в другом месте программы из них может быть прочитано и использовано неизвестное значение. Обнаружить такую ошибку глазами очень сложно.
### Предупреждение 6
Рассмотрим код:
```
void mapclass::loadlevel(....)
{
....
std::vector tmap;
....
tmap = otherlevel.loadlevel(rx, ry, game, obj);
fillcontent(tmap);
.... // Вектор tmap изменяется еще много раз.
}
```
Предупреждение PVS-studio: [V688](https://www.viva64.com/ru/w/v688/) The 'tmap' local variable possesses the same name as one of the class members, which can result in a confusion. Map.cpp 1192
Действительно, если заглянуть внутрь класса *mapclass*, то можно обнаружить там такой же вектор с таким же именем:
```
class mapclass
{
public:
....
std::vector roomdeaths;
std::vector roomdeathsfinal;
std::vector areamap;
std::vector contents;
std::vector explored;
std::vector vmult;
std::vector tmap; // <=
....
};
```
К сожалению, объявление вектора с таким же именем внутри функции делает невидимым вектор, объявленный в классе. Получается, что на протяжении всей функции *loadlevel* вектор *tmap* изменяется только внутри функции. Вектор, объявленный в классе, остается неизменным!
Занимательно, что PVS-Studio обнаружил аж целых 20 таких фрагментов кода! По большей части они связаны со временными переменными, которые «для удобства» были объявлены, как члены класса. Автор игры (и единственный её разработчик) сам писал, что раньше имел эту плохую привычку. Вы можете прочитать об этом в посте, ссылку на который я прикрепил в начале этой статьи.
Также он отмечает, что подобные именования приводили к вредным и сложно отлавливаемым багам. Что ж, такие баги действительно могут быть вредными, а вот с помощью статического анализа отловить их не составит большого труда :)
### Предупреждение 7
[V601](https://www.viva64.com/ru/w/v601/) The integer type is implicitly cast to the char type. Game.cpp 4997
```
void Game::loadquick(....)
{
....
else if (pKey == "totalflips")
{
totalflips = atoi(pText);
}
else if (pKey == "hardestroom")
{
hardestroom = atoi(pText); // <=
}
else if (pKey == "hardestroomdeaths")
{
hardestroomdeaths = atoi(pText);
}
....
}
```
Чтобы понять, в чем дело, давайте взглянем на определения переменных из приведенного участка кода:
```
//Some stats:
int totalflips;
std::string hardestroom;
int hardestroomdeaths;
```
Переменные *totalflips* и *hardestroomdeaths* имеют целочисленный тип, и поэтому присвоить в них результат функции *atoi* – совершенно нормально. Но что будет, если присвоить целочисленное значение в *std::string*? Оказывается, с точки зрения языка такое присвоение совершенно валидно. В итоге в переменную *hardestroom* будет записано какое-то непонятное значение!
### Предупреждение 8
[V1004](https://www.viva64.com/ru/w/v1004/) The 'pElem' pointer was used unsafely after it was verified against nullptr. Check lines: 1739, 1744. editor.cpp 1744
```
void editorclass::load(std::string &_path)
{
....
TiXmlHandle hDoc(&doc);
TiXmlElement *pElem;
TiXmlHandle hRoot(0);
version = 0;
{
pElem = hDoc.FirstChildElement().Element();
// should always have a valid root
// but handle gracefully if it does
if (!pElem)
{
printf("No valid root! Corrupt level file?\n");
}
pElem->QueryIntAttribute("version", &version); // <=
// save this for later
hRoot = TiXmlHandle(pElem);
}
....
}
```
Анализатор предупреждает, что указатель *pElem* небезопасно используется сразу после того, как он был проверен на *nullptr*. Чтобы убедиться, что анализатор прав, заглянем в определение функции *Element()*, возвращаемым значением которой инициализируется указатель *pElem*:
```
/** @deprecated use ToElement.
Return the handle as a TiXmlElement. This may return null.
*/
TiXmlElement *Element() const
{
return ToElement();
}
```
Как видно по комментарию, эта функция может вернуть *null*.
Теперь представим, что это действительно произошло. Что случится в этом случае? Дело в том, что такая ситуация никак не будет обработана. Да, будет выведено сообщение о том, что что-то пошло не так, но буквально строчкой ниже некорректный указатель будет разыменован. Такое разыменование, в свою очередь, приведет либо к падению программы, либо к неопределенному поведению. Это довольно серьезная ошибка.
### Предупреждение 9
На следующий участок кода PVS-Studio выдал четыре предупреждения:* [V560](https://www.viva64.com/ru/w/v560/) A part of conditional expression is always true: x >= 0. editor.cpp 1137
* [V560](https://www.viva64.com/ru/w/v560/) A part of conditional expression is always true: y >= 0. editor.cpp 1137
* [V560](https://www.viva64.com/ru/w/v560/) A part of conditional expression is always true: x < 40. editor.cpp 1137
* [V560](https://www.viva64.com/ru/w/v560/) A part of conditional expression is always true: y < 30. editor.cpp 1137
```
int editorclass::at( int x, int y )
{
if(x<0) return at(0,y);
if(y<0) return at(x,0);
if(x>=40) return at(39,y);
if(y>=30) return at(x,29);
if(x>=0 && y>=0 && x<40 && y<30)
{
return contents[x+(levx*40)+vmult[y+(levy*30)]];
}
return 0;
}
```
Все предупреждения относятся к последнему *if*-выражению. Проблема в том, что все четыре проверки, которые в нём выполняются, всегда будут возвращать *true*. Не сказал бы, что это серьезная ошибка, но получилось довольно забавно. Автор решил отнестись к этой функции серьезно и на всякий случай проверил каждую переменную еще раз :)
Данную проверку можно убрать, т.к. поток выполнения всё равно никогда не дойдет до выражения "*return 0;*". Хоть это и не изменит логики программы, но освободит её от лишних проверок и мертвого кода.
### Предупреждение 10
В своей статье про юбилей игры Терри с иронией рассказывает, что одним из элементов, управляющих логикой игры, был огромный switch из функции *Game::updatestate()*, отвечающий сразу за большое количество различных состояний игры. И было довольно ожидаемо, что я обнаружу следующее предупреждение:
[V2008](https://www.viva64.com/ru/w/v2008/) Cyclomatic complexity: 548. Consider refactoring the 'Game::updatestate' function. Game.cpp 612
Да, вы все правильно поняли: PVS-Studio оценил цикломатическую сложность функции в 548 единиц. Пятьсот сорок восемь!!! Вот это я понимаю – «опрятный код». И это при том, что, по сути, кроме switch-выражения в функции ничего больше нет. В самом switch я насчитал более 300 case-выражений.
У нас в офисе идет небольшое соревнование между авторами за самую длинную статью. Я бы с радостью привел сюда весь код функции (3450 строк), но такая победа была бы нечестной, поэтому я ограничусь просто [ссылкой](https://github.com/TerryCavanagh/VVVVVV/blob/f7c0321b715ceed8e87eba2ca507ad2dc28a428d/desktop_version/src/Game.cpp#L622) на громадный switch. Рекомендую перейти по ней и оценить весь масштаб самостоятельно! Кстати, помимо *Game::updatestate()*, PVS-Studio нашел еще целых 44 функции с завышенной цикломатической сложностью, 10 из которых имеют сложность более 200.
Заключение
----------
Думаю, выписанных ошибок достаточно для статьи. Да, ошибок в проекте оказалось немало, но в этом как раз и фишка: выложив свой код, Terry Cavanagh показал, что не обязательно быть хорошим программистом, чтобы сделать хорошую игру. Сейчас, спустя 10 лет, Терри вспоминает те времена с иронией. Важно уметь учиться на своих ошибках, и практика – лучший способ делать это. А если ваша практика еще может породить такую игру, как VVVVVV, то это вообще шикарно! Эхх… пойду-ка я, наверное, еще в неё поиграю :)
Это были не все ошибки, найденные в коде игры. Если вы хотите самостоятельно посмотреть, что еще можно найти – предлагаю [скачать и попробовать PVS-Studio](https://www.viva64.com/ru/pvs-studio-download/)! Также не забывайте, что для открытых проектов мы [предоставляем](https://www.viva64.com/ru/b/0614/) бесплатную лицензию.
[](https://habr.com/en/company/pvs-studio/blog/484388/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: George Gribkov. [VVVVVV??? VVVVVV!!! :)](https://habr.com/en/company/pvs-studio/blog/484388/).
|
https://habr.com/ru/post/484166/
| null |
ru
| null |
# Паяем «умный» автомобильный БП на 5v с USB-зарядкой и автоматическим включением/выключением
 Я человек ленивый и люблю комфорт, поэтому люблю всяческого рода автоматизацию. В машине у меня есть видеорегистратор, иногда использую навигатор, часто нужно зарядить телефон или планшет себе или семье/знакомым. Как результат указанных потребностей — вся машина окутана проводами и зарядками, при этом всегда надо думать, что выдернуть из тройника прикуривателя и не потеряла ли контакт в прикуривателе очередная зарядка. Конечно, потихоньку в машине образовался клубок проводов и зарядок, а это мало того, что не эстетично, так еще и может привлечь наркоманов.
В один прекрасный момент это всё достало и было принято решение сделать что-то универсальное.
###### Задача:
* Выходное напряжение 5.1V
* Ток не менее 3A (телефон, 0.6А, видеорегистратор — 0.3А, iPad — 2A)
* Автоматическое включение БП при запуске двигателя
* Ручное включение БП
* Автоматическое отключение БП через 15-30 минут после выключения двигателя (с возможностью продлить это время). Чтобы можно было оставить регистратор в машине без необходимости каждый раз его выключать/включать.
* Автоматическое отключение БП при сильном разряде аккумулятора
* Ручное выключение БП
* ~~Свистелки и перделки~~Световая и звуковая сигнализация
* Достаточное количество USB-разъемов (хотя бы 4 шт.) в легкодоступном месте но без извращения над салоном
* Нормальный (как родной зарядкой) заряд устройств Samsung и Apple
* Без занимания прикуривателя.
###### Решение:
Решение вполне очевидное. Микроконтроллер для автоматизации и какой-нибудь преобразователь напряжения, но у преобразователя должна быть возможность включения/выключения работы логическими уровнями.
С размещением в машине было немного сложнее, сначала хотел вставить USB в подстаканник, но потом откинул эту идею, т.к. не эстетично плюс стакан будет не поставить да и очередные мотки проводов не радовали. Потом я обратил внимание на подлокотник и ящичек находящий в нём. Это было то, что нужно! Сам ящичек вытаскивается — значит можно легко обслуживать, в самом подлокотнике много места — значит спокойно влезет электроника. USB разъемы легко врезать в боковину ящичка и не нужные провода зарядок можно не вытаскивая из разъемов прятать в ящик.
Помимо USB разъемов для зарядок, требовалось питание для видеорегистратора. Для этого был протянут провод от подлокотника до зеркала заднего вида, на зеркале был наклеен еще один [USB-разъем](http://www.everbuying.com/product147773.html?lkid=9508) и выведен разъем для видеорегистратора.
Если с размещением разъемов, всё было довольно понятно, то с электроникой возникли небольшие проблемы.
#### Сначала была LM2596.
Чуть ранее я заказал на eBay несколько платок регулируемых блоков питания, собранных на микросхеме LM2596. Мне нужно было сделать зарядку для iPad, чтобы заряжала большим током (как родная — 10W). Зарядку я сделал, всё прекрасно работало, зарядка выдавала что-то около 2.1A на 5.1V (при входном напряжении около 12-13V — аккумулятор ИБП), но был один минус — она жутко грелась! Вся плата грелась так, что расплавила пластиковую коробочку, в которой была и сама плата потемнела (несмотря на то, что туда был [приколхожен радиатор](http://habrastorage.org/storage2/7f9/70e/24a/7f970e24ae89b3185b89e5deb6b46b62.jpg)). После замеров КПД выяснилось, что при большом токе КПД около 60%, что нам совершенно не подходило.
Дополнительным нехорошим моментом было то, что у таких китайских платок не выведена отдельно ножка управления и пришлось бы отпаивать одну ножку микросхемы от платы и подпаивать к ней проводки.
**Что делать с модулями на LM2596 не ясно.**
#### KIS-3R33S — чудо китайских «конверсионных» технологий.
Шерстя eBay, я часто встречал некие модули KIS-3R33S, в описании которых указывалось, что они выдают 3A. Стоимость модулей тоже внушала — при покупке 10 штук, каждый модуль обходится около 50-90 центов с бесплатной доставкой. Почитав [Яндекс](http://yandex.ru/yandsearch?text=kis-3r33s&lr=2) стало ясно, что это довольно хороший модуль на микросхеме MP2307, который можно переделать в регулируемый преобразователь, а из навесных элементов нужно только два конденсатора — на вход и на выход.
И что важно — **даже при нагрузке 2A он совершенно не греется!**
Все продающиеся модули — паянные. Откуда они их берут в таком количестве совершенно непонятно ;)
**Тех. параметры микросхемы MP2307**Входное напряжение — 4,75-23V
Выходное напряжение — 0,925-20V
Максимальный продолжительный выходной ток (кратковременный) — 3A (4A)
Частота преобразования — 340kHz
КПД — до 95%
Встроенная защита от короткого замыкания и перегрева
Вход управления
Вообщем за какие-то пять копеек кучка модулей была приобретена и работа закипела.
#### Подготовка БП.
По умолчанию модуль KIS-3R33S настрое на 3.3V, поэтому надо модуль немного адаптировать. Есть разные варианты переделки этого модуля ([например](http://we.easyelectronics.ru/part/preobrazovatel-napryazheniya-kis-3r33s-mp2307.html)), но я решил обойтись минимальными переделками. Вооружившись [даташитом](http://www.monolithicpower.com/Page/DownLoad.aspx?ListID=1a4312a6-2709-4b7d-af52-9f1cedbfd415&&ItemID=35) и [схемой KIS-3R33S](http://habrastorage.org/storage2/7b1/574/358/7b1574358be1c4e4a66b5cce3c83e1e7.jpg) я составил такой список переделок:
1. Вскрываем модуль
2. Удаляем резистор и стабилитрон отмеченные красным. (некоторые удаляют конденсатор, отмеченный жёлтым — я не стал)
3. Припаиваем (прямо внутри, чтобы потом корпус можно было закрыть) «выводный» резистор (0,125 ваттный) R между минусом и входом ADJ модуля. Резистор фиолетовый. Резистор номиналом от 9.1ком до 10 ком, в зависимости от резистора будет и разное напряжение (от 5.28V до 5.15V соответственно). Этот резистор включается последовательно с уже установленным резистором на 3.3ком (т.е. общее сопротивление резисторов будет 3.3+9.1=12.4) и параллельно резистору R1, за счёт чего их общее сопротивление падает и напряжение на выходе микросхемы растёт.
4. Собираем модуль обратно
5. На вход и выход модуля подпаиваем электролитические конденсаторы примерно указанных ёмкостей. Напряжение конденсаторов меньше брать нельзя, а больше можно.
Я не хотел, чтобы преобразователь работал на полную нагрузку, поэтому решил использовать 2 преобразователя, на одном будет 2 USB + USB и питание видеорегистратора, а на втором только 2 USB.
В принципе, уже всё работает и может заряжать, если не нужна автоматика, то можно закончить читать :)
#### Микроконтроллер.
Блок питания это самое простое, дальше нужно реализовать логику работы. Как мне показалось, контролировать заведен ли двигатель проще всего по напряжению в бортовой сети авто. Посидев с тестером в машине, получил такие данные:
* > 13.8V — машина заведена.
* < 13.3V — машина заглушена.
* < 11.8V — дальше аккумулятор лучше поберечь.
Можно было контроль напряжения сделать на дискретных элементах, но мне хотелось ~~хардкора~~ легкости изготовления, малых размеров и функционала. Так же и ~~свистелки-перделки~~ свето-звуковые эффекты были в списке задач, поэтому решил использовать МК Attiny13A.
##### Схема управления.
Схема вроде простая. Резистор RV2, обычный подстроечный, чтобы легче было задать нужное напряжение на входе МК. Биппер LS1 обычный компьютерный, светодиод и кнопка тоже компьютерные. Вся схема питается от КРЕНки (78L05). Выход МК подключается к управлению модулями KIS-3R33S — высокий уровень включает, а низкий выключает модули.
##### Программа
Программа оказалась самой трудной задачей. В ассемблере я не силён, да и Си знаю в основном по примерам. Программу несколько раз переписывал, чтобы добиться нужного функционала и влезть в доступную память, в итоге память МК занята на 100%.
Логика работы такая:
* **Режим 1.** Если напряжение выше или равно 13.8V и БП должен включится. Так же должен гореть светодиод и при включении должен пикнуть биппер.
* **Режим 2.** Если напряжение упало до 13.3V значит двигатель заглушен, пикнем биппером три раза и начнём отсчет времени (по умолчанию — около 30 минут). Если во время этого режима нажать на кнопку, то к времени ожидания прибавится 1 час, еще одно нажатие — еще час и т.д. Светодиодом начинаем мигать.
* Если напряжение упало до 11.8V или истекло время предыдущего режима, то пикнем долго и выключим БП. Светодиод погасим.
* Когда БП выключен, то можно нажать на кнопку и БП включится на 30 мин (во второй режим).
* При включенном БП и заведенном двигателе можно выключить БП нажав кнопку и удерживая её (около 3-х секунд) до короткого сигнала. БП выключится. Обратного его включить можно коротким нажатием на кнопку либо он включится сам, если двигатель заглушить и снова завестись.
**Адов код и фьюзы для PonyProg**
```
/*****************************************************
This program was produced by the
CodeWizardAVR V2.05.0 Professional
Automatic Program Generator
Chip type : ATtiny13a
AVR Core Clock frequency: 4,800000 MHz
Memory model : Tiny
External RAM size : 0
Data Stack size : 16
*****************************************************/
#include
#include
#define ADC\_VREF\_TYPE 0x00
unsigned char iter3=10;
unsigned char i,POFF, sec, nobeep;
//POFF - запрещает включать БП при заведенном двигателе;
// Read the AD conversion result
unsigned int read\_adc(unsigned char adc\_input)
{
ADMUX=adc\_input | (ADC\_VREF\_TYPE & 0xff);
// Delay needed for the stabilization of the ADC input voltage
delay\_us(10);
// Start the AD conversion
ADCSRA|=0x40;
// Wait for the AD conversion to complete
while ((ADCSRA & 0x10)==0);
ADCSRA|=0x10;
return ADCW;
}
//пищалка
void beep(unsigned char on)
{
//включим светодиод
PORTB.2=1;
//включим пищалку, если не запрещено
if(!nobeep)DDRB.0=1;
//пищим on\*100 милисекунд
while(on){on--; delay\_ms(100);}
//выключим светодиод и пищалку
PORTB.2=0;
DDRB.0=0;
}
//процедура включения БП
void on()
{
if(POFF!=0)return;
//включаем БП
PORTB.4=1;
iter3=10;
beep(5);
POFF=1;
}
//процедуры выключения БП
void off()
{
//выключение не из-за времени, а из-за напряжения
if(iter3 > 1)
{
//подождем пол минуты и если напряжение всё еще низкое будет, то выключится
delay\_ms(30000);
iter3=1;
return;
}
//пикнем о выключении
if(PORTB.4)beep(30);
//отключаем БП
PORTB.4=0;
if(POFF)
POFF--;
iter3=1;
}
// External Interrupt 0 service routine
//Отрабатываем нажатие на кнопки
interrupt [EXT\_INT0] void ext\_int0\_isr(void)
{
// Place your code here
//нажатие кнопки сопровождается пиканьем
beep(1);
//если БП был выключен, то включим на час
if(!PINB.4)
{
on();
POFF=0;
}
//а если БП включен, то с каждым нажатием будем прибавлять +1 час к ожиданию до выключения
//длинное нажатие (больше 2-х сек, выключит БП)
else
{
//прибавляем +1 час к ожиданию
iter3=iter3+20;
//считаем сколько времени нажата кнопка
i=8;
while(!PINB.1){
i--;
delay\_ms(250);
//кнопка нажата больше 2-х сек.? Вырубаем!
if(i==0)
{
//пикнем, чтобы было понятно, что дальше нажимать на кнопку смысла нет и всё готово к выключению
beep(1);
iter3=0;
//здесь стоит 2, чтобы даже при высоком напряжении БП заново не включился.
//включится он после того, как двигатель будет заглушен и заново заведен.
POFF=2;
}
}
}
}
// Declare your global variables here
void main(void)
{
// Declare your local variables here
// Crystal Oscillator division factor: 1
#pragma optsize-
CLKPR=0x80;
CLKPR=0x00;
#ifdef \_OPTIMIZE\_SIZE\_
#pragma optsize+
#endif
// Input/Output Ports initialization
// Port B initialization
// Func5=In Func4=Out Func3=In Func2=Out Func1=In Func0=Out
// State5=T State4=1 State3=T State2=0 State1=T State0=0
PORTB=0x10;
DDRB=0x15;
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 1,172 kHz
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
//TCCR0A=0x40;
//TCCR0B=0x02;//x05; выключаем таймер
TCNT0=0x00;
OCR0A=0x00;
OCR0B=0x00;
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 4,688 kHz
// Mode: CTC top=OCR0A
// OC0A output: Toggle on compare match
// OC0B output: Disconnected
TCCR0A=0x42;
TCCR0B=0x05;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=0x00;
// External Interrupt(s) initialization
// INT0: On
// INT0 Mode: Low level
// Interrupt on any change on pins PCINT0-5: Off
GIMSK=0x40;
MCUCR=0x00;
GIFR=0x40;
// Timer/Counter 0 Interrupt(s) initialization
TIMSK0=0x00;
// Analog Comparator initialization
// Analog Comparator: Off
ACSR=0x80;
ADCSRB=0x00;
DIDR0=0x00;
// ADC initialization
// ADC Clock frequency: 600,000 kHz
// ADC Bandgap Voltage Reference: Off
// ADC Auto Trigger Source: ADC Stopped
// Digital input buffers on ADC0: On, ADC1: On, ADC2: On, ADC3: Off
DIDR0&=0x03;
DIDR0|=0x08;
ADMUX=ADC\_VREF\_TYPE & 0xff;
ADCSRA=0x83;
#asm("sei")
//выключим пищалку
DDRB.0=0;
while (1){
delay\_ms(1000);
//напряжение больше 13.8 - завелись
if( (0.0048828125\*read\_adc(3)) >=3.42)
on();
//напряжение меньше 11.8 или время работы с заглушенным двигателем истекло
if ( (0.0048828125\*read\_adc(3)) <3.23 || !iter3 )
off();
//напряжение ниже 13.3 - выключили двигатель
else if( (0.0048828125\*read\_adc(3)) < 3.38)
{
//БП включен? включим таймер
if(PINB.4)
{
nobeep=1;
beep(1);
nobeep--;
//осталось полчаса
if(iter3 == 10)
{
if(sec==1)
//пикнем 3 раза коротко
for(; sec<4; sec++)
{
beep(2);
delay\_ms(200);
}
}
if(sec>=180)
{
iter3--;
sec=0;
}
sec++;
}
//если выключили с заведенным двигателем, чтобы после повторной заводки БП включился
POFF=0;
}
//при заведенном двигателе светодиод постоянно горит
else if(iter3 > 1)
PORTB.2=1;
}//end while
}
```
Для программатора PonyProg фьюзы ставить так
##### «Правильные» зарядки.
USB используются двойные, при том у каждой пары у одного USB-выхода средние контакты закорочены (чтобы большинство устройств понимали, что они воткнуты не в USB, а в зарядку), а у второго поставлены резисторы подтяжки, чтобы Apple-устройства считали, что подключены к родной зарядке и заряжались быстро.
**Как Apple-устройство узнает «родную» зарядку.**Способов масса. Как вариант:
Чтобы получить «родную» зарядку из неродной необходимо на data-контакты подать потенциалы в 2.00В и 2.70В
Простейший делитель на эти номиналы:
если таких номиналов нет, то можно рассчитать делители и по другим номиналам резисторов, [калькулятор в помощь](http://allcalc.ru/node/440).
Для Samsung-устройств тоже существует "[своя схема](http://drusakov.ru/index.php/about-joomla/34--sgt/46-samsung-galaxy-tab-2-usb-charge)" зарядки, но даже с закороченными средними контактами, мой телефон SGS2 кушал 600mA, что считаю вполне достаточным для заряда.
##### Конструкция и размещение в машине.
Схематично всё выглядит так:
Плату я делал под имеющуюся коробочку, делал ЛУТом.
**Кровь, кишки**
4 USB хорошо разместились в ящике, рядом был выведен светодиод и проделана дырочка (1мм), чтобы лучше слышать биппер.
И обратная сторона «медали». В алюминиевой коробочке находится плата управления и 2 преобразователя. Коробочка приклеивается скотчем к днищу ящика, который вставляется в подлокотник.
А в машине всё выглядит культурно (кнопку ещё нормально не приделал :).
На зеркале чуть хуже.
Питание брал от прикуривателя, размещенного в подлокотнике. Все подключения на разъемах, чтобы можно было всю систему легко вытащить и унести домой на апгрейд.
Сейчас понимаю, что можно было всё сделать красивее, взяв провода потоньше. Наверно весной переделаю.
Архив со схемой, исходник программы, прошивка, поделки платы [можно скачать в ZIP](https://www.dropbox.com/s/ow450w0mtj6y2u4/habra-avtoBP.zip).
ПС. Уже две недели собирался написать этот пост и только [появившиеся аналогичная статья](http://habrahabr.ru/post/155125/) мотивировала начать :)
|
https://habr.com/ru/post/159121/
| null |
ru
| null |
# Как я хакнул Ethereum кошелек друга за 26 минут на MacBook M1 Pro
Я отправил сообщение на новый адрес Алекса с его взломанного кошелька.В сентябре 2022 года я решил создать себе новый hot wallet для ежедневного использования. Хотелось сгенерировать себе что-то легко узнаваемое, например `0x0000...aced`. Мой друг [Алекс](https://twitter.com/jackqack) сказал мне, что он использовал для таких целей [Profanity](https://github.com/johguse/profanity), инструмент для создания Ethereum кошельков с красивыми адресами. Когда я открыл их [GitHub репозиторий](https://github.com/johguse/profanity), то я увидел в README файле, что была найдена критическая ошибка. Кроме того, в тот же день была опубликована [статья в блоге 1inch](https://blog.1inch.io/a-vulnerability-disclosed-in-profanity-an-ethereum-vanity-address-tool-68ed7455fc8c) с некоторыми идеями по её использованию.
У меня было свободное время, поэтому я решил погрузиться в тему и самостоятельно реализовать взлом. В этой статье я объясню, как можно взломать адреса, сгенерированные с помощью Profanity, и как **я смог подобрать приватный ключ к кошельку моего друга на MacBook M1 Pro (16 Гб) за 26 минут.** Погнали!
Как получить публичный ключ?
----------------------------
Если у вас есть закрытый ключ `k` (случайное число длиной 256 бит), то вам нужно немного "пошаманить" с [криптографией на эллиптической кривой](https://en.wikipedia.org/wiki/Elliptic-curve_cryptography), чтобы получить ваш открытый ключ. Более конкретно, ваш открытый ключ `K = k * G` , где `G` - точка генератор на эллиптической кривой. Затем вы берете 5 младших байт хеша `keccak256` от открытого ключа, чтобы получить адрес, на который вам обычно и кидают эфиры. Как можно догадаться, вы не можете обратить этот процесс. Таким образом, единственный способ получить адрес с множеством ведущих нулей - это перебрать много различных приватных ключей.
Как работает Profanity?
-----------------------
Profanity использует OpenCL ядра для параллельного запуска большого количества GPU потоков, которые генерируют миллионы адресов в секунду с помощью простого алгоритма:
1. Profanity генерирует случайный сид `S`, который используется при генерации закрытого ключа `k`.
2. Затем он создает примерно 4 миллиона воркеров, где i-й воркер принимает `K[i, 0] = (k + i * 2^192) * G` в качестве начального открытого ключа.
3. После этого каждый воркер увеличивает свой открытый ключ на `G`, пока адрес, полученный из него, не будет соответствовать требованиям пользователя. Когда он будет найден, вы можете легко вычислить закрытый ключ, зная номер воркера, который его нашел, и сколько итераций он совершил.
Процесс генерации адреса в Profanity.Что здесь не так?
-----------------
Описанный метод прост и эффективен, но в его реализации есть небольшая проблема, которая имеет значительные последствия. Случайный сид `S`, который используется для генерации закрытого ключа `k`, является 32-разрядным числом вместо 64-разрядного. Обратите внимание, что если вы знаете `S`, который Profanity использовал в процессе генерации, вы знаете все закрытые ключи, которые он генерировал.
Мы собираемся использовать тот факт, что количество всех сидов всего `2^32`.
Вот и ошибочка.И как хакнуть-то?
-----------------
### Идея алгоритма
Если у вас есть адрес, который был сгенерирован с помощью Profanity, вы можете найти соответствующий закрытый ключ, выполнив обратный процесс генерации:
1. Сначала вам нужно восстановить открытый ключ `K_t`соответствующий адресу. Вы можете это сделать, если есть любая транзакция подписанная жертвой. Например, вы можете попробовать найти её на [Etherscan](https://etherscan.io/).
2. Если открытый ключ `K_t` был сгенерирован из начального открытого ключа `K` при помощи добавления необходимого количества `G` (`+2^192 * G` для каждой строки и `+G` для каждого столбца), то можно инициализировать воркеров таким образом, чтобы i-й воркер начинал с открытого ключа `K_t - i * 2^192 * G`, а затем уменьшал его на `G` на каждой итерации, пока `K` не будет найден кем-либо из них.
3. Если вы знаете, какой закрытый ключ соответствует `K`, вы можете вычислить и закрытый ключ жертвы (опять же, потому что вы знаете строку и столбец, где его нашли).
Обратный процесс.Вроде бы все просто! Но есть один нюанс! Мы не знаем начальный открытый ключ `K`.
### Уязвимость
Да, мы не знаем, какой начальный открытый ключ `K` был использован при генерации кошелька жертвы. Но мы знаем, что он был получен из одного из `2^32` сидов (примерно 4 миллиарда). Таким образом, мы можем проитерироваться через все и предварительно вычислить все соответствующие закрытые и открытые ключи.
Теперь, когда мы запускаем обратный процесс, на каждой итерации мы должны проверять, принадлежит ли новый открытый ключ нашему предварительно вычисленному набору. Если мы находим ключ, который находится в множестве, то кошелек взломан!
Если бы сид имел 64 бит, то мы были бы должны предварительно вычислить `2^64` открытых ключей. Это очень много! В 4 миллиарда раз больше!
### Задача поиска
Эта часть алгоритма самая нетривиальная.
Еще разок. Мы должны уметь проверять элемент на принадлежность множеству из `2^32` открытых ключей. В идеале бы, чтобы каждый воркер выполнял эту проверку на GPU, чтобы CPU не был бы узким горлышком.
У нас есть `2^32` открытых ключей. На самом деле это не выглядит огромным количеством для современных компьютеров. Но каждый открытый ключ занимает 32 байта в сжатом виде. Поэтому, если вы решите хранить их все на диске, то потребуется 128Gb памяти. Более того, скорее всего ваш компьютер не имеет 128Gb RAM для загрузки их в память.
Проще говоря, 128Gb это слишком много. Если мы используем только 12 байт для каждого открытого ключа, то потребуется 48GB памяти для их хранения, и вероятность коллизий будет низкой. Так и поступим. Когда я использовал только 8 байт, то коллизии происходили.
#### Разделение
Если у вас есть видеокарта с 48Gb и более, то вы можете загрузить все ключи в память, чтобы каждый воркер мог искать их с помощью двоичного поиска или используя какую-то другую структуры данных.
Я хотел взломать Алекса с помощью моего MacBook Pro M1 с 16Gb памяти, поэтому я выбрал 8Gb в качестве ограничения и попробовал несколько разных подходов.
#### Бинарный поиск
Я поделил множество всех открытых ключей на 4 части по `2^30` ключей в каждой. Затем взял только 8 байт от каждого открытого ключа, отсортировал их и загрузил в память. Это ровно 8Gb памяти видеокарты.
Теперь каждый воркер может выполнять бинарный поиск, чтобы проверить, принадлежит ли его открытый ключ множеству.
Как вы помните, я уже упомянул, что коллизии случаются, если использовались только 8 байт. Но это не большая проблема, потому что они случаются редко, и когда это происходит, я сравниваю эти открытые ключи на CPU используя 12 байт.
#### Хеш-таблица
Двоичный поиск - отличный алгоритм, но есть ли способ найти элемент еще быстрее? Конечно. Мы можем использовать хеш-таблицу. Однако есть одно ограничение. Все слоты использовать нельзя. Как правило, большинство реализаций [хеш-таблиц с открытой адресацией](https://en.wikipedia.org/wiki/Open_addressing) имеют коэффициенты загрузки 50%. Таким образом, если у нас выделено 8Gb для хеш-таблицы, то мы можем хранить только `2^29` открытых ключей (8 байт каждый). Поэтому нам нужно разбить наш набор на 8 частей, а не на 4.
Стоит ли это того? С одной стороны, чем больше у нас частей, тем больше мы тратим вычислительных ресурсов на повторное прохождение по одним и тем же ключам. С другой стороны, проверка элемента на принадлежность в хеш-таблице работает за `O(1)` вместо `O(log N)` для двоичного поиска.
#### Сравнение
Реализации с хеш-таблицей потребовалось 64 минуты для выполнения 10 000 итераций, а двоичному поиску - почти 4 часа. Даже несмотря на повторные вычисления для 8 частей, вместо 4, первый подход работает гораздо быстрее.
Хак
---
Вот и самая вкусная часть! Я потратил 7,5 часов на предподсчет открытых ключей на своем Macbook Pro, а также 26 минут на сам взлом закрытого ключа Алекса. Это просто безумие!
Profanity уже почти 5 лет, а эта уязвимость всегда была там, ожидая пока её кто-нибудь найдет. Интересно, сколько еще мелких ошибок и опечаток скрыто в мире крипты, которые могут иметь существенные последствия.
Что тут сказать? Будьте осторожны, всегда проверяйте свой код и подписывайтесь на мой аккаунт в [Twitter](https://twitter.com/yrebryk) и [блог в Telegram](https://t.me/rebrykblog) 😉
Disclaimer
----------
*Этот пост был подготовлен исключительно в образовательных и развлекательных целях.*
|
https://habr.com/ru/post/693816/
| null |
ru
| null |
# 10 советов по оптимизации приложения NodeJS
Давайте рассмотрим список основных советов по оптимизации приложений NodeJS, статья больше служит полезным справочником чем полноценным практическим пособием.
Node.js — это мощная и универсальная платформа, которая широко используется для создания высокопроизводительных приложений, интенсивно использующих данные. Однако, как и в случае с любой другой технологией, существуют способы оптимизации приложений Node.js для повышения производительности и масштабируемости. В этой статье мы рассмотрим 10 советов по оптимизации приложений Node.js.
1. Используйте последнюю версию Node.js
---------------------------------------
Node.js постоянно развивается, и новые версии часто содержат улучшения производительности и исправления ошибок.
**Использование последней версии Node.js** может принести ряд преимуществ, например:
- Улучшенная производительность и стабильность
- Доступ к новейшим функциям и обновлениям безопасности
- Лучшая совместимость с новейшими функциями JavaScript и другими библиотеками.
- Улучшена безопасность и исправлены ошибки
- Потенциально лучшая производительность и использование памяти
Так же не забывайте оставаться и переключаться на LTS версии, LTS означает долгосрочную поддержку. Node.js выпускает версии LTS каждые 18 месяцев, которые активно поддерживаются в течение 30 месяцев. Эти версии получают исправления ошибок и обновления безопасности, но не получают каких-либо новых функций. Это делает их более стабильными и подходящими для производственных сред, поскольку они с меньшей вероятностью вносят критические изменения. Таким образом, использование последней версии Node.js может предоставить вам доступ к новейшим функциям и улучшениям производительности.
2. Поддерживайте актуальность своих зависимостей
------------------------------------------------
Обязательно обновляйте свои зависимости, так как новые версии часто включают улучшения производительности и исправления ошибок. Это может помочь улучшить производительность вашего приложения и обеспечить его стабильность.
Есть несколько способов проверить наличие обновлений для библиотек в Node.js с помощью npm (диспетчер пакетов Node):
* `npm outdated` эта команда покажет вам список всех установленных пакетов, для которых доступны обновления.
* `npm update` эта команда обновит все пакеты в вашем проекте до их последних версий. Вы также можете обновить конкретный пакет, указав его имя после команды (например, npm update express)
Перед запуском команды `npm update` для обновления пакетов рекомендуется использовать `npm outdated` для проверки наличия обновлений. Это даст вам возможность просмотреть обновления и убедиться, что они совместимы с вашим приложением перед их установкой.
* `npm-check-updates` это пакет npm, который может проверить ваш файл package.json и вывести список пакетов, для которых доступны обновления. Затем вы можете запустить команду ncu -u, чтобы обновить файл package.json, указав последние номера версий.
* Вы также можете использовать менеджер пакетов, такой как `yarn`, который также имеет аналогичные команды, такие как `yarn outdated` или `yarn upgrade-interactive` для проверки и обновления ваших библиотек.
3. Используйте диспетчер процессов
----------------------------------
Приложения Node.js являются однопоточными, что может затруднить обработку нескольких подключений. Использование диспетчера процессов, такого как **PM2** или **Forever**, может помочь повысить производительность вашего приложения за счет создания нескольких процессов.
4. Оптимизируйте запросы к базе данных
--------------------------------------
Базы данных часто являются узким местом в приложениях Node.js, поэтому важно оптимизировать запросы для повышения производительности. Этого можно добиться, используя индексы, ограничивая количество возвращаемых столбцов и используя разбиение на страницы.
5. Используйте кэширование
--------------------------
Кэширование может значительно повысить производительность вашего приложения за счет уменьшения количества запросов к базе данных и вызовов API. Рассмотрите возможность использования библиотеки кэширования, такой как Redis или Memcached, для кэширования данных и повышения производительности вашего приложения.
6. Используйте обратный прокси-сервер
-------------------------------------
Обратный [прокси-сервер](https://habr.com/ru/post/713420/) может помочь повысить производительность вашего приложения за счет маршрутизации запросов и балансировки нагрузки. Рассмотрите возможность использования обратного прокси-сервера, такого как HAProxy или Nginx, чтобы повысить производительность и масштабируемость вашего приложения
7. Используйте потоки
---------------------
Потоки — это мощная функция Node.js, которую можно использовать для обработки больших объемов данных, не блокируя цикл обработки событий. Использование потоков может помочь повысить производительность вашего приложения за счет сокращения использования памяти и повышения скорости передачи данных.
8. Используйте async/await
--------------------------
Использование async/await может помочь повысить производительность вашего приложения, упростив обработку асинхронных операций. Это может помочь уменьшить ад обратных вызовов (callback hell) и улучшить читаемость вашего кода.
9. Мониторинг и оптимизация вашего приложения
---------------------------------------------
Используйте инструмент мониторинга, например New Relic или Application Insights, для мониторинга производительности вашего приложения и выявления узких мест. Используйте эту информацию для оптимизации кода и повышения производительности приложения.
10. Используйте профилировщик
-----------------------------
Профилирование вашего приложения может помочь вам определить, где находятся узкие места в производительности, и отследить утечки памяти. Некоторыми из популярных инструментов профилировщика являются node-spector, v8-profiler и strong-cluster-control.
Следуя этим простым советам, вы сможете оптимизировать приложение Node.js и повысить его производительность. Не забывайте всегда следить за своим приложением и использовать инструменты для выявления узких мест и областей для улучшения. Кроме того, рассмотрите возможность использования этих методов в процессе разработки, чтобы поддерживать производительность вашего приложения с течением времени.
|
https://habr.com/ru/post/713428/
| null |
ru
| null |
# Хранение иерархических структур. Симбиоз «Closure Table» и «Adjacency List»
Когда перед нами встаёт задача хранения и управления иерархическими структурами данных всегда приходится выбирать из довольно ограниченного набора паттернов. Для того чтобы найти наиболее подходящий шаблон необходимо проанализировать особенности каждого способа хранения и обработки данных и оценить их с учётом задачи и специфики используемой СУБД.
Предположим, существует задача, предоставить возможность пользователям сайта оставлять комментарии к публикациям. Комментарии должны иметь древовидную структуру, пользователи должны иметь возможность оставить один или более комментариев к посту, а также отвечать на любые комментарии других пользователей. То есть, нужна система комментариев аналогичная той, что мы можем видеть на Habrahabr. По каким-то причинам, нам не подходят готовые решения, допустим из-за того, что предполагается дополнительная очень сложная бизнес-логика, которая должна быть интегрирована в систему комментариев.
Наша цель – разработать свою реализацию, учитывающую требования нашего приложения.
Что для нас важно?
------------------
1. Минимизировать количество запросов к базе данных. В частности, для извлечения ветки комментариев должно быть достаточно одного запроса.
2. Получить высокую производительность, поэтому запросы к базе данных, особенно на чтение, должны быть простыми и выполняться быстро даже при большом объёме данных.
3. Хранить текст комментариев и иерархическую структуру дерева в разных таблицах.
4. Иметь возможность отсортировать извлечённые из базы данных комментарии, чтобы в результате отобразить их в естественном виде, как древовидную иерархическую структуру или, что ещё лучше, сразу извлечь из базы данных отсортированное дерево.
5. Контролировать глубину вложенности комментариев.
6. Гарантировать целостность данных.
7. Учесть специфику MySQL. Как известно, эта СУБД не поддерживает рекурсивные запросы. Рекурсия в этой СУБД возможна только в хранимых процедурах с ограничением вложенности — не более 255 уровней.
8. Требования вполне обоснованные и актуальные для многих проектов.
Итак, рассмотрим известные способы хранения и работы с деревьями. Их не так уж и много:
Детали реализации этих паттернов отлично рассмотрены в [презентации Билла Карвина (Bill Karwin)](http://www.slideshare.net/billkarwin/models-for-hierarchical-data).
Особенность метода «Adjacency List», заключается в том, что без поддержки рекурсивных запросов СУБД, извлечь одним простым запросом произвольную часть иерархии невозможно. Поэтому, в контексте использования MySQL этот вариант нас совершенно не устраивает.
Метод «Path Enumeration» (или как его ещё называют «Materialized Path»), очевидно, нам тоже не подходит, ввиду низкой производительности SQL-запросов SELECT, так как предполагается использование оператора LIKE и поиск по шаблонам вида: ‘1/2/3/4%’. Хранение некого множества в виде строки с разделителями, едва ли уместно в мире реляционных баз данных.
Пожалуй, самый интересный паттерн для работы с древовидными структурами – Nested Sets. Он вполне может быть использован для нашей задачи, но его реализация довольно сложная и он не обеспечивает целостность данных. Ошибка при вставке нового элемента в иерархию или при переносе поддерева из одного места в другое может создать большие проблемы. Необходимость пересчёта и изменения значений части левых и правых индексов элементов поддерева при добавлении нового элемента, вне всяких сомнений, является существенным недостатком Nested Sets.
Последний метод «Closure Table», исходя из наших требований, мог бы стать лучшим выбором, если бы не одно «но» — отсутствие простого способа построить отсортированное дерево из получаемого запросом плоского списка связей.
Давайте рассмотрим этот шаблон работы с древовидными структурами данных подробнее.
Схема связей элементов дерева «Closure Table» выглядит следующим образом:
Предположим, у нас есть иерархия комментариев, которая соответствует приведённой выше схеме связей:
Таблица comments:
Таблица commentsTree:
Получить список всех элементов нужной нам части дерева можно следующим запросом (извлечём дерево начиная от `commentsTree`.`idAncestor` = 1):
```
SELECT
`tableData`.`idEntry`,
`tableData`.`content`,
`tableTree`.`idAncestor`,
`tableTree`.`idDescendant`,
`tableTree`.`level`,
`tableTree`.`idSubject`
FROM `comments` AS `tableData`
JOIN `commentsTree` AS `tableTree`
ON `tableData`.`idEntry` = `tableTree`.`idDescendant`
WHERE `tableTree`.`idAncestor` = 1
```
В результате получим:
Всё просто! Но извлечённые строки нужно преобразовать в отсортированную древовидную иерархию. Именно она нам нужна. Увы, данных для преобразования этого множества в нужную нам форму недостаточно.
Как же нам решить эту проблему?
Вариант 1. Заставим СУБД сортировать дерево
-------------------------------------------
Существует довольно оригинальный способ, при помощи которого можно получить из базы данных сразу отсортированную древовидную иерархию, причём всего одним запросом. Известный разработчик Билл Карвин (Bill Karwin) предложил весьма изящный вариант решения задачи извлечения отсортированного дерева:
```
SELECT
`tableData`.`idEntry`,
`tableData`.`content`,
`tableTree`.`level`,
`tableTree`.`idAncestor`,
`tableTree`.`idDescendant`,
GROUP_CONCAT(`tableStructure`.`idAncestor`) AS `structure`
FROM
`comments` AS `tableData`
JOIN `commentsTree` AS `tableTree`
ON `tableData`.`idEntry` = `tableTree`.`idDescendant`
JOIN `commentsTree` AS `tableStructure`
ON `tableStructure`.`idDescendant` = `tableTree`.`idDescendant`
WHERE `tableTree`.`idAncestor` = 1
GROUP BY `tableData`.`idEntry`
ORDER BY `structure`
```
В результате мы получим, то что нам нужно:
Но, как не сложно заметить, такой способ будет корректно работать только в случае, когда длина идентификаторов idAncestor у всех строк, отвечающих условию запроса, одинаковая. Обратите внимание на следующий фрагмент SQL-запроса: «GROUP\_CONCAT(tableStructure.idAncestor ORDER BY tableStructure.level DESC) AS structure». Сортировка строк содержащих множества «12,14,28» и «13,119,12» будет некорректной с точки зрения нашей задачи. То есть, если все идентификаторы в запрашиваемой части дерева одинаковой длинны, то сортировка верная, а в случае если это не так, то структура дерева будет нарушена. Уменьшить количество неправильных сортировок можно, задав начало отсчёта идентификаторов с большого целого числа, например 1000000, указав в SQL запросе при создании таблицы AUTO\_INCREMENT=1000000.
Для того чтобы полностью избавится от этой проблемы, можно указать для столбца идентификатора idAncestor параметр ZEROFILL, в этом случае СУБД будет автоматически добавлять атрибут UNSIGNED и идентификаторы буду выглядеть примерно так: 0000000004, 0000000005, 0000000194.
Для некоторых задач, без сомнений, можно использовать этот способ. Но давайте всё-таки постараемся избежать использования двух JOIN’ов при работе с двумя таблицами, функции GROUP\_CONCAT(), да ещё и параметра ZEROFILL.
Вариант 2. Симбиоз двух методов «Closure Table» и «Adjacency List»
------------------------------------------------------------------
Давайте ещё раз посмотрим на метод «Closure Table». В плоском списке связей иерархической структуры, который мы получаем всего одним запросом, нам, очевидно, не хватает информации о связи каждого элемента со своим родителем, для того, чтобы мы смогли построить отсортированное дерево. Поэтому, давайте добавим поле idNearestAncestor в таблицу commentsTree и будем сохранять там ссылку на элемент, который является ближайший предком.
Таким образом, мы получили симбиоз двух методов «Closure Table» и «Adjacency List». Теперь формирование правильно отсортированной иерархической структуры — тривиальная задача. И самое главное, мы нашли решение, которое полностью отвечает требованиям.
Следующим запросом мы получим необходимые для построения дерева данные:
```
SELECT
`tableData`.`idEntry`,
`tableData`.`content`,
`tableTree`.`idAncestor`,
`tableTree`.`idDescendant`,
`tableTree`.`idNearestAncestor`,
`tableTree`.`level`,
`tableTree`.`idSubject`
FROM `comments` AS `tableData`
JOIN `commentsTree` AS `tableTree`
ON `tableData`.`idEntry` = `tableTree`.`idDescendant`
WHERE `tableTree`.`idAncestor` = 1
```
Критика «Closure Table»
-----------------------
Шаблон «Closure Table» часто критикуют за то, что необходимо хранить в базе данных связи каждого элемента дерева со всеми его предками, а так же ссылку каждого элемента на самого себя. Чем глубже в иерархии располагается элемент, тем больше записей в таблице необходимо сделать. Очевидно, что добавление новых элементов в конец глубокой древовидной иерархии будет менее эффективным, чем вставка элементов вблизи корня дерева. Кроме этого, стоит отметить, что для хранения деревьев метод Closure Table требует больше места в базе данных, чем любой другой метод.
Для того чтобы объективно оценить значимость этих замечаний, их следует рассматривать в контексте специфики реального проекта. Например, снижение производительности при добавлении нового элемента на двухвостый или тысячный уровень может быть незначительным или некритичным для работы приложения, или же, что ещё более вероятно, такая ситуация вовсе никогда не произойдёт. Как правило, в реальной жизни нет необходимости в иерархических структурах большой вложенности. Кроме этого, в большинстве случаев, принципиальным параметром является скорость извлечения данных, а не записи. Объём дискового пространства, который может потребовать структура дерева едва ли стоит учитывать, так как другие потребители этого ресурса намного более значимые, например логирование посетителей сайта.
[Пример моей реализации системы древовидных комментариев основанной на методах «Closure Table» и «Adjacency List» на github.](https://github.com/drandin/TreeClosureTable)
**Используемые материалы**
1. Презентация Билла Карвина (Bill Karwin). <http://www.slideshare.net/billkarwin/models-for-hierarchical-data>
2. Обсуждение вопросов сортировки деревьев на stackoverflow. <http://stackoverflow.com/questions/8252323/mysql-closure-table-hierarchical-database-how-to-pull-information-out-in-the-c>, <http://stackoverflow.com/questions/192220/what-is-the-most-efficient-elegant-way-to-parse-a-flat-table-into-a-tree>
3. [Документация MySQL](http://dev.mysql.com/doc/refman/5.6/en/)
|
https://habr.com/ru/post/263629/
| null |
ru
| null |
# Простой способ дополнительной защиты: SSH — ALERT
Администрирование большого количества “чужих” серверов, влечет за собой ответственность за защиту данных наших клиентов. Что бы надежно контролировать список лиц с ssh доступом к серверовам было решено продумать систему авторизации с ограниченого набора хостов.
Что имеем в условии задачи:
* Более 400 физических машин;
* Все клиентские службы хранятся в виртуальных контейнерах openvz ( в основном):
* root доступ на все сервера закрыт по ssh;
* доступ через sudo к привилегиям root есть только у админов на физических серверах;
* несколько серверов, принадлежащих нашей компании, половина из которых территориально распределены. Назовем их: “серверы доступа”.
Что сделано:
* Первым шагом мы через систему управления конфигурациями распространили на все физические сервера ssh ключи, для входа на них с серверов доступа без пароля. Для каждого админа свой ключ.
* Вторым шагом закрываем доступ по ssh на физические сервера, со всех хостов, кроме серверов доступа.
Конечно, в такой схеме будут исключения, но это все индивидуально.
Теперь возникает вопрос о безопасности такого решения: любой кто взламывает учетку на сервере доступа получает не ограниченный доступ ко всем серверам, причем по ключу без пароля.
Не очень хорошо, мягко выражаясь!
Поступило предложение ограничить ssh доступ на серверы доступа через firewall, разрешив доступ только с ip наших сотрудников. Хорошо. Но тут проблема: админов у нас не мало, у многих динамические ip. Да и что если срочно потребуется “поработать” находясь в поездке и т.д.?
Решили остановиться на репортах. То есть каждый раз, когда определенный логин, успешно авторизуется с ip, отсутствующего в списке допустимых, нам в redmine падает задача об этом событии с высоким статусом и далее мы выясняем что произошло, применяя допрос с пристрастием.
Реализация:
Были просмотрены текущие готовые решения для ssh аудита, но ничего подходящего найдено не было, или очень монструозно, или не о том.
И как всегда решили написать свой велосипед, то есть скрипт. Который:
1. анализирует ssh лог на предмет успешной авторизации.
2. берет данные за последние 10 минут.
3. сравнивает пару username/ip из соответствующего списка
4. в случае успешной проверки нич его не делает
5. в случае не совпадения отправляет алерт, который впоследствии становится задачей в redmine.
Скрипт написан на python. Писал я на python второй раз в жизни, так что замечания по коду принимаются в объективном виде. К тому же, оно работает!
Листинг прилагается:
```
#!/usr/bin/env python
import sys, os, time
from datetime import datetime, timedelta, date, time as dt_time
import socket
hostname = socket.gethostname()
fileList = "./List.ip"
date = datetime.now() - timedelta(minutes=10)
date = date.strftime('%H:%M:%S')
from commands import *
import smtplib
def mail(message):
smtp_server = "localhost"
smtp_port = 25
smtp_user= "root@%s" % hostname
subject = 'Ahtung!! Security SSH audit alert'
to = "mail@example.ru"
mail_lib = smtplib.SMTP(smtp_server, smtp_port)
msg = 'From: %s\r\nTo: %s\r\nContent-Type: text/html; charset="utf-8"\r\nSubject: %s\r\n Return-Path: \r\n\r\n' % (smtp\_user, to, subject, hostname)
msg += message
mail\_lib.sendmail(smtp\_user, to, msg)
listLog = getoutput('''cat /var/log/secure |grep "Accepted password for" | awk '{if($3>="'''+date+'''"){print $3 " " $9 " " $11 }}' ''')
if listLog:
for line in listLog.split('\n'):
matchIp = 0
matchName = 0
curIp = line.split()[2]
for lineLs in open(fileList):
if len(lineLs.strip()) == 0 or lineLs[0] == "#" or lineLs[0] == " ":
continue
if line.split()[1] == lineLs.split()[0]:
matchName = 1
listIp = lineLs.split()[1]
i = 0
for c in listIp.strip().split("."):
if c.strip() == "0":
break
i = i + 1
if listIp.strip().split(".")[0:i] == curIp.split(".")[0:i]:
matchIp = 1
if not matchIp:
if not matchName:
print("This user %s not found !!!" % line.split()[1])
message = "This user %s not found !!!" % line.split()[1]
mail(message)
else:
print("Ahtung! User {0} logged from unknown IP {1} in time {2}").format(line.split()[1], line.split()[2], line.split()[0])
message = "Ahtung! User "+line.split()[1]+" logged from unknown IP "+line.split()[2]+" in time "+line.split()[0]
mail(message)
```
Файл List.ip имеет вид:
```
#Vasya
vasya 1.2.3.4
vasya 12.13.14.0
```
Сопутствующие действия:
* поместить скрипт в cron на запуск каждые 10 минут;
* настроить ежедневную ротацию ssh логов на полночь;
* отключить авторизацию по ключам на серверах доступа;
* для большей пароноидальности можно хранить список username/ip в гите и раскидывать на сервера доступа через хуки.
Дополнительный (относительный) плюс этой схемы: если придется увольнять сотрудника ( а такое все же бывает :( ), то нужно будет просто убить сессии на серверах доступа.
|
https://habr.com/ru/post/240425/
| null |
ru
| null |
# Обзор C# библиотек для работы с PDF
На написание данной статьи меня подтолкнул топик [HTML в PDF](http://habrahabr.ru/blogs/php/111979/), правда по причине того, что он посвящен языку php, лично мне он был мало полезен, т.к. весь опыт работы с php у меня сводился в переводе нескольких скриптов на C#, поэтому я решил сделать небольшой обзор того, что доступно для работы с pdf по средствам языка C#.
Ко мне в список попало 7 библиотек, о которых я скажу несколько слов, а для самой популярной (судя по ответам на stackoverflow), я напишу, как с помощью неё сделать простейший документ. Сразу скажу, что это **iTextSharp** и работа с ней будет описана в конце статьи.
#### Обзор библиотек
1. [iTextSharp](http://itextsharp.sourceforge.net/)
Библиотека **iText** позволяет создавать и манипулировать PDF документами. Она позволяет разработчикам совершенствовать веб и прикладные приложения с помощью динамической генерации и/или манипуляции над PDF документами.
Разработчики могут использовать **iText** для:
— Передачи PDF в браузер
— Генерировать динамические документы из XML файлов или базы данных
— Использовать много интерактивных возможностей PDF
— Добавлять закладки, число страниц, водяные знаки и т.д.
— Разделять, объединять и манипулировать PDF страницами
— Автоматизация заполнения PDF форм
— Добавлять цифровую подпись в PDF файл
**iText** доступен для двух языков: Java и C#.
2. [Report.NET](http://report.sourceforge.net/)
**Report.NET** – это мощная библиотека, которая поможет Вам сгенерировать PDF документы в простым и гибким способом. Документ может быть создан с помощью данных, которые были получены из любого ADO.NET data set.
Возможности библиотеки:
— Полностью написана на C# для Microsoft .NET framework
— Очень компактный код (Hello World: 6 строк)
— Поддерживает графические объекты: текст, линии, прямоугольники, изображения jpeg
— Легкость выравнивания и трансформации графических объектов
— ASP.NET может генерировать динамические PDF страницы
— XML Documentation (Comment Web Pages)
3. [PDFsharp](http://www.pdfsharp.com/PDFsharp/)
**PDFsharp** — это библиотека на C#, которая очень просто создаёт PDF документы на лету. Похоже на GDI+ рисование процедур, аналогично можно создавать PDF документы, рисовать на экране или отправлять на печать любого принтера. PDFsharp может изменять, объединять и разделять существующие PDF файлы или перемещать страницы из существующих PDF файлов в новые PDF документы.
PDFsharp – это библиотека с открытым исходным кодом, которая легко создает PDF документы из любого .NET языка.
4. [SharpPDF](http://sharppdf.sourceforge.net/)
**SharpPDF** — это C# библиотека, которая может создавать различные объекты в PDF документах за несколько шагов. Она создана для .NET framework 1.1 и может создавать 100% совместимые PDF файлы (протестировано с Acrobat Reader, Ghostscript, JAWS PDF Editor и другими PDF читалками). Самая важная цель библиотеки – это простое использование.
Возможности библиотеки:
— Можно использовать с Windows Forms для генерации новых pdf файлов или сохранить их в базу данных.
— Можно использовать с Web Applications (ASP.NET) для генерации pdf файлов или сразу отправить результат в браузер.
5. [PDFjet Open Source Edition](http://pdfjet.com/os/edition.html)
**PDFjet** — библиотека с открытым исходным кодом для динамического создания PDF документов из Java и .NET.
Возможности библиотеки:
Рисования: точки, линии, коробки, круги, кривые Безье, многоугольники, звезды, комплекс путей и форм.
Текст: поддержка юникода, кернинг текста при использовании Helvetica и Times-Roman семейств основных шрифтов, вставка гиперссылок, просто использовать табличный класс с гибкостью отчетных возможностей.
Поддерживает вставку следующих типов изображений: PNG, JPEG, BMP
6. [ASP.NET FO PDF](http://sourceforge.net/projects/npdf/)
**FO PDF** похожа на ASP.NET Server Controls, написана на C#. Она получает DataTable и несколько других параметров для генерации XSL FO и рендерит DataGrid как PDF отчёт используя NFOP (Apache FOP Port in J#) PDF Formatter.
7. [PDF Clown](http://sourceforge.net/projects/clown/)
**PDF Clown** – это C# 2.0 библиотека для чтения, обработки и записи файлов PDF с несколькими слоями абстракции, чтобы удовлетворить различные стили программирования: от нижнего уровня (PDF Object Model), до высшего (PDF структуры документа и потокового содержания). Его основная целевая платформа является GNU / Linux, но благодаря проекту Mono она практически платформа-независимая.
#### Быстрый старт с помощью iTextSharp
Как я уже писал ранее, данная библиотека была выбрана не из-за того, что я протестировал все описанные и выбрал её, а по причине того, что на неё чаще всего ссылаются и советуют. Итак, переходим на сайт проекта, видим, что можно купить книжку, а также скачать файлы:
Желания что-то собирать самому, у меня нет, поэтому качаю не исходные коды, а сразу библиотеку [itextsharp-5.0.5-dll.zip](http://switch.dl.sourceforge.net/project/itextsharp/itextsharp/iTextSharp-5.0.5/itextsharp-5.0.5-dll.zip). С одной библиотекой быстрого старта не выйдет, поэтому качаем примеры [iTextSharp.tutorial.01.zip](http://garr.dl.sourceforge.net/project/itextsharp/examples/examples%2001/iTextSharp.tutorial.01.zip). Открыв архив примеров, я понял, что старт будет гораздо быстрее, чем я думал, т.к. там есть целых 13 глав примеров. Сразу подумал, что на этом можно закончить, но всё же решил сделать небольшое приложение.
Распишу по шагам, что нужно для использования библиотеки:
— Я создаю WinForms приложение.
— Добавляю ссылку на **itextsharp.dll**.
— Устанавливаю кнопку на форму и добавляю следующий код в обработчик нажатия:
> `var doc = new Document();
>
> PdfWriter.GetInstance(doc, new FileStream(Application.StartupPath + @"\Document.pdf", FileMode.Create));
>
> doc.Open();
>
> iTextSharp.text.Image jpg = iTextSharp.text.Image.GetInstance(Application.StartupPath + @"/images.jpg");
>
> jpg.Alignment = Element.ALIGN\_CENTER;
>
> doc.Add(jpg);
>
> PdfPTable table = new PdfPTable(3);
>
> PdfPCell cell = new PdfPCell(new Phrase("Simple table",
>
> new iTextSharp.text.Font(iTextSharp.text.Font.FontFamily.TIMES\_ROMAN, 16,
>
> iTextSharp.text.Font.NORMAL, new BaseColor(Color.Orange))));
>
> cell.BackgroundColor = new BaseColor(Color.Wheat);
>
> cell.Padding = 5;
>
> cell.Colspan = 3;
>
> cell.HorizontalAlignment = Element.ALIGN\_CENTER;
>
> table.AddCell(cell);
>
> table.AddCell("Col 1 Row 1");
>
> table.AddCell("Col 2 Row 1");
>
> table.AddCell("Col 3 Row 1");
>
> table.AddCell("Col 1 Row 2");
>
> table.AddCell("Col 2 Row 2");
>
> table.AddCell("Col 3 Row 2");
>
> jpg = iTextSharp.text.Image.GetInstance(Application.StartupPath + @"/left.jpg");
>
> cell = new PdfPCell(jpg);
>
> cell.Padding = 5;
>
> cell.HorizontalAlignment = PdfPCell.ALIGN\_LEFT;
>
> table.AddCell(cell);
>
> cell = new PdfPCell(new Phrase("Col 2 Row 3"));
>
> cell.VerticalAlignment = PdfPCell.ALIGN\_MIDDLE;
>
> cell.HorizontalAlignment = PdfPCell.ALIGN\_CENTER;
>
> table.AddCell(cell);
>
> jpg = iTextSharp.text.Image.GetInstance(Application.StartupPath + @"/right.jpg");
>
> cell = new PdfPCell(jpg);
>
> cell.Padding = 5;
>
> cell.HorizontalAlignment = PdfPCell.ALIGN\_RIGHT;
>
> table.AddCell(cell);
>
> doc.Add(table);
>
> doc.Close();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Результат работы данного кода:
#### Выводы
По каждой из приведенных библиотек в интернете можно найти уйму информации (начинать рекомендую с сайтов разработчиков), готовя данную подборку библиотек, я встречал разные мнения, хоть все библиотеки, казалось бы, предназначены для работы с pdf, но возможности у них разные, всё зависит от Ваших потребностей. Честно скажу, что все из них я не использовал, я лишь попробовал несколько из них и остановился на iTextSharp.
**Пожелание:** Если Вы указываете, что остановились на той или иной библиотеке, то не поленитесь указать, что явилось для Вас решающим при выборе.
|
https://habr.com/ru/post/112707/
| null |
ru
| null |
# Особенности разработки TWA в 2022 году
ДисклеймерРазрабатывать легко, но есть нюансы.
### Вступление
Приветствую. С вами Дени Сергеевич, ведущий разработчик МТС Ticketland. В этой статье я расскажу о своем опыте разработки TWA: какие инструменты выбрать, на какие грабли наступил и костыли пришлось сделать, чтобы все заработало. [В конце статьи](#end) поделюсь своими выводами на что обратить особое внимание.
### Что такое TWA
TWA (Trusted Web Activities) — специальный режим запуска браузера на базе кастомных вкладок [Android Custom Tab](https://developer.chrome.com/docs/android/custom-tabs/). В отличие от WebViews, решение от Google предоставляет больше функций веб-платформы, что делает переход для конечного пользователя между нативным и веб-контентом более плавным.
На практике TWA предоставляет сравнимые возможности [PWAs](https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps) (Progressive web apps) и добавляет дополнительный функционал для операционной системы Android. Это публикация в магазин приложений Google Play, интегрированная монетизация, поддержка веб-нотификаций и другие менее значимые возможности, вроде анимации и кастомизации окна приложения.
### Инструменты создания
Создать TWA можно используя привычные языки веб-программирования и слоя генерации сборки приложения. Я рекомендую использовать TypeScript для создания бизнес-логики и Java для сборки Android App Bundle.
Android App Bundle победил прежде популярный формат сборки APK#### Vue.js
Vue.js стал больше походить на React.JSВ 2022 году [Vue.js](https://vuejs.org) окончательно переехал на третью мажорную версию с новым быстрым и меньшим по размерам ядром. По популярности Vue.js давно наступает на пятки React.JS, предлагая сравнимую функциональность с низкой кривой входа для новичков, благодаря заложенным в фреймворк паттернам проектирования.
При выборе написания кода, рекомендую сразу использовать Composition API как более современное решение. Оно имеет лучшую поддержку TypeScript, проще читается и не раздувает код как это делает Options API.
#### Quasar Framework
Логотип QuasarБазируясь на Vue.js [Quasar Framework](https://quasar.dev) предоставляет удобные повторно используемые компоненты в стиле Material Design, которые можно кастомизировать через CSS и расширять через методы JavaScript. Этот фреймворк покрывает более 90% типовых решений, предлагая командный интерфейс quasar-cli для инициализации, запуска, тестирования и сборки проекта.
Из коробки Quasar генерирует PWA используя два следующих инструмента:
#### Manifest
Здесь задаются данные для приложения: стандартные размеры иконок, описание, цвета. Подробнее про настройку манифеста веб приложений, читайте здесь: <https://developer.mozilla.org/ru/docs/Web/Manifest>.
#### Service Worker
Service Worker (далее SW) - это скрипт, который работает в фоновом режиме предоставляя механизм роутинга и кеширования ресурсов веб-приложения.
Видов SW ровно два:
* GenerateSW - самый простой способ добавить SW на сайт, создает отдельный заранее сгенерированный файл конфигурации.
* InjectManifest - предоставляет дополнительную логику, основанную на Web Worker.
Более подробно про настройку можно прочитать здесь: [https://developer.chrome.com/docs/workbox/modules/workbox-webpack-plugin](https://developer.chrome.com/docs/workbox/modules/workbox-webpack-plugin/).
Документация по конфигурация SW доступна по ссылке: <https://quasar.dev/quasar-cli-webpack/developing-pwa/configuring-pwa>.
#### Android Studio
Эта среда программирования для Android основанная на популярной ныне кроссплатформенной IDEA. Включает дополнительно необходимые отладчики и компиляторы для Java и Kotlin, Device Manager, монитор логов и другой необходимый софт для программирования на Android под ключ.
Скачать Android Studio можно здесь: <https://developer.android.com/studio/>.
#### Bubblewrap CLI
Каким бы ни был крутым Bubblewrap CLI, наличие Android Studio необходимо для тестированияЭтот инструмент позволяет через консоль создавать готовую сборку Gradle и Android Manifest из существующего веб-манифеста, находящегося в конфигурации Quasar Framework. Со своей задачей в принципе справляется, но сам инструмент плохо обновляется и как будет видно в конце статьи, неудобен в работе. Узнать как использовать Bubblewrap CLI вы можете здесь: <https://developer.chrome.com/docs/android/trusted-web-activity/quick-start>.
Скачать Bubblewrap CLI через npm: <https://www.npmjs.com/package/@bubblewrap/cli>.
### Как работает PWA на iOS
Начиная с iOS 15, Apple включили частичный функционал PWA в системный браузер Safari. На главном экране действительно появляется иконка сайта, неотличимая от нативных приложений. При клике на нее запускается сайт без элементов управления браузера.
Сценарий добавления PWA на iOS. Обратите внимание, где теряется пробел между словами.Создавая PWA под iOS нужно быть готовым что не получится в оффлайне использовать функции Touch ID или Face ID. Костылем может стать использование спецификации Web Authentication ([WebAuthn](https://www.w3.org/TR/webauthn-2/)), которая появилась в iOS 16, но данная спецификация требует доступ в онлайн.
Push-уведомления так же не работают в режиме PWA в мобильном Safari.
Еще одной особенностью PWA приложения на iOS становится невозможность переопределения квоты для IndexedDB, ругаясь на "QuotaExceededError: Failed to PutOrAdd in database". При этом такая функция работает если заходить через браузер Safari напрямую.
Увеличение кэша приложения недоступно через PWA Safari. ### Сборка TWA
Создание сборки на выбранных инструментах выполняется двумя следующими командами.
1. Создать сборку PWA используя Quasar Framework:
```
quasar build -m pwa
```
2. Создать сборку Android используя Bubblewrap CLI:
```
bubblewrap build
```
После этого у вас будут созданы файлы приложения, которые можно установить на виртуальное устройство следующей командой:
```
bubblewrap install
```
### Тестирование TWA
Этап тестирования ничем не отличается от тестирования мобильного сайта на физическом устройстве. Запускаем приложение с главного экрана, выбираем Inspect Tools и кликаем на Remote Target. Подробнее как включить тестирование на Android написано здесь: <https://developer.chrome.com/docs/devtools/remote-debugging/>.
Тестировать TWA можно зайдя через chrome://inspect/#devices Замечено, если у пользователя стоит по-умолчанию Firefox, то после установке TWA потребуется запускать отладчик на аналогичный платформе, то есть на Firefox Debugger.
### Публикация в Google Play Market
Особенностью 2022 года стало то, что магазин приложений Google Play недоступен на территории РФ, что пока еще можно исправить используя VPN другой страны. Но так как Android определенным образом открыт, то сборочные файлы App Bundle можно использовать для прочих аналогов Google Play, с соответствующими проблемами веб-нотификаций и установки рекламы от Google Ads.
Без VPN не зайти в консоль разработчика Google Play[Установка и настройка](https://support.google.com/googleplay/android-developer/answer/9859152?hl=ru-RU&skip_cache=true&visit_id=637579122451898339-2540030049&rd=1) TWA в Google Play Market не отличается от обычной установки, но добавляется установка Digital Asset Links в разделе App Integrity. Если вы подписывали приложение через ключ разработчика Google, тогда достаточно просто скопировать предложенные ключи из появляющегося раздела. Иначе установите те ключи, что сгенерировал вам Bubblewrap CLI. Сами ключи должны храниться на контролируемом вами сервере в пути .well-known/assetlinks.json.
Предложенные ключи для assetlinks.json от GoogleЧтобы сгенерировать собственный файл assetlinks.json через Bubblewrap CLI и поместить его в нужную директорию выполните команду:
```
bubblewrap fingerprint generateAssetLinks --output=\"public/.well-known/assetlinks.json\"
```
Проверено, 301 редирект на файл assetlinks.json из корня сайта не работает. Поэтому переносить файл придется вручную следующим образом:
```
cp public/.well-known/assetlinks.json dist/pwa/.well-known/
```
В 2022 году для публикации в магазин Google Play требуется заполнить множество документов, одним из которых является Пользовательское соглашение. Вы можете не заполнять его самостоятельно, а воспользоваться бесплатным сервисом <https://app-privacy-policy-generator.nisrulz.com>.
Модерация у меня заняла почти пять дней. Заранее убедитесь, что у вас все работает и что сервер отвечает за приемлемое время. Для TWA критично чтобы рейтинг производительности был минимум 80/100 в Lighthouse.
### ВЫВОДЫ
Отображение TWA ничем не отличается от нативного в магазине Google PlayTWA - все еще плохая альтернатива нативным приложениям, которая может сгодится только если у вас уже готов хороший мобильный сайт и вы не желаете тратить время и деньги на разработку нативной Android версии.
Спустя время выбор настоящих инструментов показал следующее результаты:
* Vuex - лучше заменить на [Pinia](https://pinia.vuejs.org). Vuex на данный момент имеет четвертую версию с избыточным синтаксисом при работе с Composition API и TypeScript. Pinia видится мне свежей альтернативой, которая к тому же регулярно обновляется.
* Quasar Framework - в продакшене показал множество проблем на выпадающих списках и сложных формах. Часть из них требует самостоятельного исправления, часть являются багами мобильного браузера Safari. Установка шрифтов и иконок Material Design требует соединения с сервером Google из-за чего пропадает возможность открывать сайт вне PWA режима.
* PWA - не годится для программирования больших и сложных приложений. Загрузка новой версии может занимать весомое время, которое на Android можно скрыть картинкой, тогда как пользователи iOS будут видеть черный экран браузера. Создавать что-то связанное с изображениями, камерой или устройствами Bluetooth, в настоящее время так же будет выглядеть плохо, как с точки зрения плавности интерфейса, так и с технической возможностью. Например, тег ![]() в Safari способен отображать PDF документы, а в Chromium браузерах нет; так же замечено, что функционал navigator.share не работает в Firefox на момент написания статьи.
* Bubblewrap CLI - в своем генераторе использует захардкоженные версии Gradle и Java и не имеет гибкой настройки конфигурации. Я решил после первичной инициализации Android Manifest им больше не пользоваться. Теперь вручную исправляю зависимости, обновляю версии Gradle и делаю сборки через Android Studio.
* Веб-манифес - не все так радужно. TWA не поддерживает часть спецификации значений iarc\_rating\_id и categories. Кроме того, theme\_color не поддерживается на iOS.
* HTTP кеширование - не следует создавать кэширование скриптов и документов через сервер, тогда при обновлении билда загрузка ресурсов будет невозможна. Поэтому все кеширование вам предстоит перенести на плечи SW.
* PDF - имейте в виду, что создание русскоязычных документов исключительно в браузере на популярной библиотеке [jsPDF](https://www.npmjs.com/package/jspdf) показывает глюки. Переход на библиотеку [@pdfme/generator](https://www.npmjs.com/package/@pdfme/generator) исправляет проблему.
---
### Ссылки
* [Файл проекта на GitHub](https://github.com/gotois/archive).
* [Приложение в Google Play](https://play.google.com/store/apps/details?id=ru.baskovsky.archive.twa).
|
https://habr.com/ru/post/693090/
| null |
ru
| null |
# Настройка виндового веб-сервера без RDP
Совсем недавно понадобилось настроить очередной веб-сервер. Как раз в это время у меня было весеннее обострение PowerShell. В общем, в качестве небольшой разминки, я решил настроить веб-сервер без RDP.
Итак задача: есть машина с Windows 2008 R2, которая находится где-то в Англии, нужно установить IIS, .NET 4.0 и настроить пару веб-сайтов. Есть несколько вариантов как это сделать удаленно и из командной строки, но сегодня спонсором будет PowerShell Remoting. Для того, чтобы быль стала явью, надо совсем немного, собственно, включить PowerShell Remoting.
#### Настройка PowerShell Remoting на сервере
Вот как раз тут первый фейл. Сложно включать удаленный доступ, когда самого удаленного доступа нет. В общем, тут прийдется воспользоваться RDP. В консоле PowerShell (далее просто консоль), под администратором, надо выполнить:
`Enable-PsRemoting -Confirm`
Если все хорошо, то теперь на машине всегда будет PowerShell Remoting. На этом месте RDP можно выключать. Этот рудимент графических интерфейсов нам больше не понадобится. Следующий шаг — это настройка клиента.
#### Настройка PowerShell Remoting на клиенте
Как по мне, так PowerShell писали параноики. Запрещено все что можно и не можно. Вот и подключаться к серверам тоже запрещено. Это я конечно немного утрирую. Если все находится в одном домене, то все будет прозрачно. Но в моей ситуации машина вне домена и даже не в одной сети. В общем, я решил что буду аккуратным и разрешу любые внебрачные связи.
`set-item wsman:localhost\client\trustedhosts -value * -force
restart-service WinRm`
Вот и подошли к самому интересному. Подключаемся к серверу.
`enter-pssession -ComputerName 192.0.32.10 -Credential "WS0114\Administrator"`
Вы себе представить не можете как я ждал этого момента. Нервничал, ночи не спал. А тут бац, и без барабанного боя я уже в командной строке на машине где-то на другом конце земли. В целом да. Самый нервный этап мы прошли. Мы на удаленной машине. И осталось совсем немного.
#### Инсталляция IIS
Тут все просто:
`Import-Module ServerManager
Add-WindowsFeature Web-Server`
Это правда поставит кучу всякого ненужного, поэтому я бы посоветовал выполнить Get-WindowsFeature, и поставить только нужные фитчи.
#### Инсталляция .NET 4.0
А вот тут фейл номер два. Простой команды чтобы установить .NET 4.0 пока что нет. Зато есть несколько непростых. Свой вариант я опишу чуть ниже, а для отчетности, вкратце расскажу про наверное более правильный. У Microsoft существует с десяток всяких «центральных» репозитариев. Так и для веб-серверов есть [Web Platform Installer](http://www.microsoft.com/web/downloads/platform.aspx). И у этой штуки есть [Command Line](http://blogs.iis.net/satishl/archive/2011/01/26/webpi-command-line.aspx) интерфейс. Если не задаваться вопросом инсталляции WebPi Command Line, то установка .NET 4.0 выглядела бы как:
`WebpiCmdline /Products: NETFX4RTM /AcceptEula`
Но вернемся лучше к моему варианту. Если решать задачу в лоб, то это два простых шага. Скачать инсталлятор и запустить его из командной строки. Основная проблема с первым шагом. В PowerShell нет нормальных средств для скачивания файлов. Поэтому я написал [маленький модуль](https://github.com/chaliy/psurl/) который оборачивает .NET WebClient. Правда, меня поджидала новая проблема. Для того что-бы установить PsUrl, его надо скачать. Круг замкнулся. Но меня было уже не остановить(обострение). Почувствовав в себе силы создать еще один велосипед, я решил что неплохо было бы иметь инсталлятор модулей. Бумс и интернеты пополнились еще одним [проектом](https://github.com/chaliy/psget/).
Теперь вопрос скачивания решается так:
````
# Устанавливаем PsGet
(new-object Net.WebClient).DownloadString("https://github.com/chaliy/psget/raw/master/GetPsGet.ps1") | Invoke-Expression
# Устанавливаем PsUrl
install-module https://github.com/chaliy/psurl/raw/master/PsUrl/PsUrl.psm1
# Скачиваем .NET 4.0
get-url http://download.microsoft.com/download/9/5/A/95A9616B-7A37-4AF6-BC36-D6EA96C8DAAE/dotNetFx40_Full_x86_x64.exe -ToFile dotNetFx40_Full_x86_x64.exe
# Устанавливаем .NET 4.0
start-process .\dotNetFx40_Full_x86_x64.exe -ArgumentList "/q /norestart" -Wait
````
Тут следует заметить, что PsGet и PsUrl теперь у вас в модулях, но при этом они не импортируются при старте профиля.
#### Настраиваем сайты
Импортнем все что надо:
`Import-Module WebAdministration`
На этом сервере все приложения будут под .NET 4.0, поэтому:
`Set-WebConfigurationProperty /system.applicationHost/applicationPools/applicationPoolDefaults -name managedRuntimeVersion -value v4.0`
Поднимем тестовый сайт:
````
New-Item "C:\inetpub\example" -ItemType Directory
New-WebSite Example -Port:8080 -PhysicalPath:"C:\inetpub\example"
Get-Url http://example.com -ToFile "C:\inetpub\example\index.html"
Get-Url http://localhost:8080/
````
Вот собственно и все.
`Exit-PsSession`
Если что, можно все [одним скриптом](https://gist.github.com/938538). В целом меня процес более или менее удовлетворил. Фейлов не так и много. «Подводные камни» удалось обойти. Кстати, о «подводных камнях». Их достаточно много, я не стал их описывать в этом топике, но если возникнут проблемы, спрашивайте.
P.S. Весеннее обострение продолжается.
**[Upadate]**
Оказалось что я немого соврал. Простите. Скачивание файлов в PowerShell есть. Причем с плюшками: докачиванием, асинхронным скачиванием, менджером скачиваний и тп. Собственно использует компонент Винды — BITS. Микрософт традиционно лажанул с названием поэтому модуль называется BitsTransfer.
````
Import-Module BitsTransfer
# Скачиваем .NET 4.0
Start-BitsTransfer http://download.microsoft.com/download/9/5/A/95A9616B-7A37-4AF6-BC36-D6EA96C8DAAE/dotNetFx40_Full_x86_x64.exe
# Устанавливаем .NET 4.0
start-process .\dotNetFx40_Full_x86_x64.exe -ArgumentList "/q /norestart" -Wait
````
|
https://habr.com/ru/post/118020/
| null |
ru
| null |
# «Прозрачный» Squid с разграничением доступа
Как готовить кальмара, думаю что не я один сталкивался с задачей настройки Squid'а для разграничения доступа сотрудникам предприятия, но при этом он должен быть «прозрачным». Другими словами конфигурация показанная далее удовлетворяет трём условиям:
* Имеется список запрещенных интернет-ресурсов, доступ к которым закрыт у всех пользователей (Пример: социальные сети);
* Имеется список разрешенных интернет-ресурсов, доступ к которым открыт у всех пользователей (Пример: портал государственных услуг);
* Имеется список ip-адресов пользователей которые должны иметь доступ ко всем интернет-ресурсам кроме входящих в список запрещенных.
Хотелось бы уточнить по последнему пункту, так как шлюз «прозрачный», то использовать доменную авторизацию пользователей мы не можем, по данной причине выбрано разграничение именно по ip-адресам.
В качестве базовой конфигурации использовались материалы из статьи [«Прозрачный» Squid с фильтрацией HTTPS ресурсов без подмены сертификатов (x86)](https://habrahabr.ru/post/267851/). Так как установка и настройка компонентов в данной статье описаны достаточно подробно, я пропущу данную информацию.
Программное обеспечение использованное мной для тестирование конфигурации:
* Gentoo Linux версии Base System release 2.2;
* Squid 3.5.22;
* OpenSSL 1.0.2j
Итак, файл **/etc/squid/squid.conf:**
```
acl localnet src 192.168.0.0/16 # RFC1918 possible internal network
acl SSL_ports port 443
acl Safe_ports port 80 # http
acl Safe_ports port 21 # ftp
acl Safe_ports port 443 # https
acl Safe_ports port 70 # gopher
acl Safe_ports port 210 # wais
acl Safe_ports port 1025-65535 # unregistered ports
acl Safe_ports port 280 # http-mgmt
acl Safe_ports port 488 # gss-http
acl Safe_ports port 591 # filemaker
acl Safe_ports port 777 # multiling http
acl Safe_ports port 901 # SWAT
acl CONNECT method CONNECT
#Добавление в acl трёх списков: запрещенные, разрешенные и группа расширенного доступа
acl denied_urls url_regex "/etc/squid/denied_urls"
acl allowed_urls url_regex "/etc/squid/allowed_urls"
acl extended_access_group src "/etc/squid/extended_access_group"
http_access deny !Safe_ports
http_access deny CONNECT !SSL_ports
http_access allow localhost manager
http_access deny manager
#Ключевая строчка из-за которой долго ломали голову, так как без нее запрос сертификатов к сайтам
# на https не осуществляется.
#Разрешаем осуществлять коннект к ресурсу, если https
http_access allow localnet CONNECT
#Запрещаем всем доступ на запрещенные сайты
http_access deny denied_urls
#Этим правилом разрешаем всем кто не в группе расширенного доступа ходить только на
#разрешенные сайты
http_access deny !extended_access_group !allowed_urls
http_access allow localnet
http_access allow localhost
http_access deny all
#Обязательно один из портов должен быть в таком виде и являться заглушкой
http_port 3130
http_port 3128 intercept
https_port 3129 intercept ssl-bump options=ALL:NO_SSLv3:NO_SSLv2 connection-auth=off cert=/etc/squid/squidCA.pem
always_direct allow all
sslproxy_cert_error allow all
sslproxy_flags DONT_VERIFY_PEER
#Правила доступа для ssl
acl allowed_urls_ssl ssl::server_name_regex "/etc/squid/allowed_urls"
acl denied_urls_ssl ssl::server_name_regex "/etc/squid/denied_urls"
acl step1 at_step SslBump1
ssl_bump peek step1
ssl_bump terminate denied_urls_ssl
ssl_bump splice extended_access_group
ssl_bump terminate !allowed_urls_ssl
ssl_bump splice all
sslcrtd_program /usr/lib/squid/ssl_crtd -s /var/lib/ssl_db -M 4MB
#cache_dir ufs /var/cache/squid 100 16 256
coredump_dir /var/cache/squid
refresh_pattern ^ftp: 1440 20% 10080
refresh_pattern ^gopher: 1440 0% 1440
refresh_pattern -i (/cgi-bin/|\?) 0 0% 0
refresh_pattern . 0 20% 4320
```
Перед запуском Squid'а не забываем создать три файла в */etc/squid/*. *denied\_urls* и *allowed\_urls* вида:
```
geektimes.ru
habrahabr.ru
toster.ru
windowsupdate.microsoft.com
```
И *extended\_access\_group* вида:
```
192.168.1.5 #Иванов И.И.
192.168.1.87 #Петров П.П.
192.168.1.108 #Сидоров С.С.
```
При обращении по http на запрещенный сайт выдаст стандартную заглушку Squid'а, а по https — «ERR\_SSL\_PROTOCOL\_ERROR».
Спасибо за прочтение статьи.
|
https://habr.com/ru/post/314718/
| null |
ru
| null |
# Перехват системных вызовов с помощью ptrace
**ptrace** (от process trace) — системный вызов в некоторых unix-подобных системах (в том числе в Linux, FreeBSD, Max OS X), который позволяет трассировать или отлаживать выбранный процесс. Можно сказать, что ptrace дает полный контроль над процессом: можно изменять ход выполнения программы, смотреть и изменять значения в памяти или состояния регистров. Стоит оговориться, что никаких дополнительных прав при этом мы не получаем — возможные действия ограничены правами запущенного процесса. К тому же, при трассировке программы с setuid битом, этот самый бит не работает — привилегии не повышаются.
В статье будет показано, как перехватывать системные вызовы на примере ОС Linux.
#### 1. Немного о ptrace
Вот как выглядит прототип функции ptrace:
> `#include
>
> long ptrace(enum \_\_ptrace\_request request, pid\_t pid, void \*addr, void \*data);`
* **request** — это действие, которое необходимо осуществить, например PTRACE\_CONT, PTRACE\_PEEKTEXT
* **pid** — индентификатор трассируемого процесса
* **addr** и **data** зависят от **request**'а
Начать трассировку можно двумя способами: приаттачиться к уже запущенному процессу (PTRACE\_ATTACH), либо запустить его самому с помощью PTRACE\_TRACEME. Мы рассмотрим второй случай, он немножко попроще, но суть та же. Для управления трассировкой можно использовать следующие аргументы:
* PTRACE\_SINGLESTEP — пошаговое выполнение программы, управление будет передаваться после выполнения каждой инструкции; такая трассировка достаточна медленна
* PTRACE\_SYSCALL — продолжить выполнение программы до входа или выхода из системного вызова
* PTRACE\_CONT — просто продолжить выполнение программы
Для более подробной информации — *man ptrace*.
#### 2. Просмотр системных вызовов
Напишем программу для вывода списка системных вызовов, используемых программой (простенький аналог утилиты strace).
Итак, для начала необходимо сделать **fork** — родительский процесс будет отлаживать дочерний:
> `int main(int argc, char \*argv[]) {
>
> pid\_t pid = fork();
>
> if (pid)
>
> parent(pid);
>
> else
>
> child();
>
> return 0;
>
> }`
В дочернем процессе все просто — начинаем трассировку с PTRACE\_TRACEME и запускаем нужную программу:
> `void child() {
>
> ptrace(PTRACE\_TRACEME, 0, 0, 0);
>
> execl("/bin/echo", "/bin/echo", "Hello, world!", NULL);
>
> perror("execl");
>
> }`
При выполнении **execl** трассируемый процесс остановится, передав свое новое состояние родительскому. Поэтому родительский процесс сначала должен подождать запуска программы с помощью **waitpid** (можно просто **wait**, так как дочерний процесс всего один):
> `int status;
>
> waitpid(pid, &status, 0);`
Чтобы как-то различать системные вызовы и другие остановки (например SIGTRAP), предусмотрен специальный параметр PTRACE\_O\_TRACESYSGOOD — при остановке на системном вызове родительский процесс получит в статусе **SIGTRAP | 0x80**:
> `ptrace(PTRACE\_SETOPTIONS, pid, 0, PTRACE\_O\_TRACESYSGOOD);`
Теперь можно в цикле выполнять PTRACE\_SYSCALL до выхода из программы, и смотреть значение регистра **eax** для определения номера системного вызова. Для этого используем PTRACE\_GETREGS. Следует отметить, что регистр **eax** в момент остановки заменен, и поэтому необходимо использовать сохраненный **state.orig\_eax**:
> `while (!WIFEXITED(status)) {
>
>
>
> struct user\_regs\_struct state;
>
>
>
> ptrace(PTRACE\_SYSCALL, pid, 0, 0);
>
> waitpid(pid, &status, 0);
>
>
>
> // at syscall
>
> if (WIFSTOPPED(status) && WSTOPSIG(status) & 0x80) {
>
> ptrace(PTRACE\_GETREGS, pid, 0, &state);
>
> printf("SYSCALL %d at %08lx\n", state.orig\_eax, state.eip);
>
>
>
> // skip after syscall
>
> ptrace(PTRACE\_SYSCALL, pid, 0, 0);
>
> waitpid(pid, &status, 0);
>
> }
>
>
>
> }`
Запустив программу, увидим нечто подобное:
> `...
>
> SYSCALL 6 at b783a430
>
> SYSCALL 197 at b783a430
>
> SYSCALL 192 at b783a430
>
> SYSCALL 4 at b783a430
>
> Hello, world!
>
> SYSCALL 6 at b783a430
>
> SYSCALL 91 at b783a430
>
> SYSCALL 6 at b783a430
>
> SYSCALL 252 at b783a430`
Как видно, после системного вызова №4 (а это **sys\_write**) выводится наш текст.
#### 3. Перехват системного вызова
Попробуем теперь перехватить вызов, и сделать что-нибудь хорошее. Системный вызов **write** выглядит так:
> `write(fd, buf, n);`
* ebx: fd — файловый дескриптор (номер)
* ecx: buf — указатель на текст для вывода
* edx: n — количество байт
Для подмены текста используем PTRACE\_POKETEXT:
> `// sys\_write
>
> if (state.orig\_eax == 4) {
>
> char \* text = (char \*)state.ecx;
>
> ptrace(PTRACE\_POKETEXT, pid, (void\*)(text+7), 0x72626168); //habr
>
> ptrace(PTRACE\_POKETEXT, pid, (void\*)(text+11), 0x00000a21); //!\n
>
> }`
Запускаем, и…
> `...
>
> SYSCALL 6 at 00556416
>
> SYSCALL 197 at 00556416
>
> SYSCALL 192 at 00556416
>
> SYSCALL 4 at 00556416
>
> Hello, habr!
>
> SYSCALL 6 at 00556416
>
> SYSCALL 91 at 00556416
>
> SYSCALL 6 at 00556416
>
> SYSCALL 252 at 00556416`
Таким образом, мы перехватили системный вызов **sys\_write** в программе **/bin/echo** для вывода своего текста. Это всего лишь простой пример использования ptrace. С его помощью также можно легко делать дампы памяти (это, кстати, очень помогает при решении линуксовых крэкмисов), устанавливать breakpoint'ы (с помощью PTRACE\_SINGLESTEP или заменой интсрукции на 0xCC), анализировать регистры/переменные и многое другое. **ptrace** очень полезен, например, когда до проблемного участка кода быстро не добраться — если в отладчике приходится многократно прыгать, подменять данные, а потом программа умирает и приходится все делать заново; если же написать программу для отладки ptrace'ом — все эти действия необходимо описать только один раз, и они будут выполняться автоматически. Конечно, в некоторых отладчиках можно писать скрипты — но по возможностям они навернякак уступают.
**UPD:** забыл выложить полный [исходник](http://dl.dropbox.com/u/8748250/ptrace_example.c)
#### 4. Что почитать
[man ptrace](http://linux.die.net/man/2/ptrace)
[man wait](http://linux.die.net/man/2/wait)
[Playing with ptrace, part I](http://www.linuxjournal.com/node/6100)
[Playing with ptrace, part II](http://www.linuxjournal.com/node/6210)
[syscalls table](http://bluemaster.iu.hio.no/edu/dark/lin-asm/syscalls.html)
|
https://habr.com/ru/post/111266/
| null |
ru
| null |
# Хватит использовать [a-zа-яё]: правильная работа с символами и категориями Unicode в регулярных выражениях
Unicode – это набор символов, целью которого является определение всех символов и глифов всех человеческих языков, живых и мертвых. Поскольку всё больше и больше программ должны поддерживать несколько языков или просто любой язык, юникод в последние годы приобретает всё большую популярность. Использование различных наборов символов для разных языков может быть слишком обременительным для программистов и пользователей.
К сожалению, юникод привносит свои требования и подводные камни, когда речь заходит о регулярных выражениях.
Поддержка юникод-совместимых регулярных выраженийИз всех движков регулярных выражений, обсуждаемых здесь, Java, XML и .NET используют движки поддерживающие юникод. Perl поддерживает юникод, начиная с версии 5.6. PCRE может быть опционально скомпилирован с поддержкой юникод. Обратите внимание, что PCRE гораздо менее гибок в том, что он позволяет делать для `\p`, несмотря на своё название "Perl-совместимый". Функции PHP `preg`, основанные на PCRE, поддерживают юникод, если к регулярному выражению добавлена опция `/u`. Ruby поддерживает категории юникода в регулярных выражениях начиная с версии 1.9. XRegExp привносит поддержку категорий юникода в JavaScript.
Regex-движок RegexBuddy полностью совместим с юникодом, начиная с версии 2.0.0. RegexBuddy 1.x.x не поддерживал юникод вообще. PowerGREP использует regex-движок с поддержкой юникода, начиная с версии 3.0.0. Более ранние версии конвертировали Unicode файлы в ANSI перед выполнением поиска с помощью 8-битного (т.е. не-Unicode) regex движка. EditPad Pro поддерживает юникод, начиная с версии 6.0.0.
Символы, коды и графемы, или как юникод вносит беспорядок
---------------------------------------------------------
Большинство людей считают `à` одним символом. К сожалению, это не так, в зависимости от значения слова "символ".
Все regex-движки с поддержкой юникода, обсуждаемые здесь, рассматривают любой отдельный Unicode код как отдельный символ. Когда говорится, что `.` соответствует любому отдельному символу, это переводится на язык Unicode как "`.` соответствует любому отдельному коду Unicode". В юникоде символ `à` может быть представлен через два кода: `U+0061` (a), за которым следует `U+0300` (гравис). В этой ситуации `.`, примененная к `à`, будет соответствовать `a` без грависа.
`^.$` не будет соответствовать данной строке, так как она состоит из двух кодов, в то время как `^..$` соответствует.
Код `U+0300` (гравис) является комбинируемым символом. За любым кодом, который не является комбинируемым символом, может следовать любое количество комбинируемых. Эта последовательность, как и `U+0061 U+0300` выше, отображается на экране как одна графема.
`à` также может быть представлен единственным кодом `U+00E0` (a с грависом). Причина такой двойственности в том, что многие исторические наборы символов кодируют "a с грависом" как один символ. Разработчики юникода решили, что будет полезно иметь сопоставление один к одному с популярными историческими наборами символов, в дополнение к способу юникода разделять знаки и базовые буквы (что делает возможными произвольные комбинации, не поддерживаемые историческими наборами символов).
Как сопоставить одну графему Юникода
------------------------------------
В Perl, PCRE, PHP, Boost, Ruby 2.0, Java 9 и приложениях Just Great Software сопоставление одной графемы, будь она закодирована как одним кодом или несколькими с помощью комбинируемых знаков, очень просто: просто используйте `\X`. Вы можете считать `\X` юникод-версией `.`. Но есть одно отличие: `\X` всегда соответствует символам перевода строки, в то время как `.` не соответствует им, если только вы не включите режим соответствия `.` новой строке.
В .NET, Java 8 и ниже, а также Ruby 1.9 вы можете использовать `\P{M}\p{M}*+`или`(?>\P{M}\p{M}*)` в качестве достаточно близкой замены. Чтобы подобрать любое количество графем, используйте `(?>\P{M}\p{M}*)+` как замену `\X+`.
Как сопоставить конкретный код Юникода
--------------------------------------
Чтобы сопоставить конкретный код, используйте `\uFFFF`, где `FFFF` – шестнадцатеричный код, который вы хотите сопоставить. Вы всегда должны указывать все 4 шестнадцатеричных разряда. Например, `\u00E0` соответствует `à`, при представлении одним кодом `U+00E0`.
Особенности в разных движкахPerl, PCRE, Boost и std::regex не поддерживают синтаксис `\uFFFF`. Вместо него они используют `\x{FFFF}`. Вы можете опустить ведущие нули в фигурных скобках. Поскольку `\x` сам по себе не является допустимым символом регулярного выражения, `\x{1234}` никогда не может быть перепутано с `\x` 1234 раза. Это всегда соответствует коду `U+1234`. `\x{1234}{5678}` будет сопоставляться с кодом `U+1234` ровно 5678 раз.
В Java `\uFFFF` соответствует только указанному коду, даже если вы включили каноническую эквивалентность. Однако тот же синтаксис `\uFFFF` также используется для вставки символов юникода в литеральные строки в исходном коде Java. `Pattern.compile("\u00E0")` будет соответствовать как однокодовому, так и двухкодовому варианту `à`, в то время как `Pattern.compile("\\u00E0")` соответствует только однокодовой версии. Помните, что при записи regex как строкового литерала Java, обратные слэши должны быть экранированы. Первый код Java компилирует regex `à`, а второй компилирует \u00E0. В зависимости от того, что вы делаете, разница может быть существенной.
JavaScript, который не предлагает никакой поддержки Unicode через свой класс RegExp, поддерживает `\uFFFF` для соответствия одному коду.
XML Schema и XPath не имеют regex токенов для сопоставления кодов Unicode. Однако вы можете легко использовать такие XML-сущности, как `` для вставки явных кодов в ваше регулярное выражение.
Категории в Юникоде
-------------------
В дополнение к сложностям, Unicode также приносит и новые возможности. Одна из них заключается в том, что каждый символ юникода принадлежит к определенной категории. Вы можете сопоставить один символ, принадлежащий к категории "буква", с `\p{L}`, или не принадлежащий к ней, с `\P{L}`.
Опять же, "символ" на самом деле означает "код юникод-символа". `\p{L}` соответствует одному коду в категории "буква". Если входная строка `à` закодирована как `U+0061 U+0300`, она соответствует `a` без грависа. Если входная строка `à` закодирована как `U+00E0`, она соответствует `à` с грависом. Причина в том, что коды `U+0061` (a) и `U+00E0` (à) относятся к категории "буква", а `U+0300` – к категории "знак".
Теперь вы должны понять, почему `\P{M}\p{M}*+`эквивалентно `\X`. `\P{M}`соответствует коду, который не является комбинируемым знаком, в то время как `\p{M}*+` соответствует нулю или более кодов, которые являются комбинируемыми. Чтобы найти букву, включая все диакритические знаки, используйте `\p{L}\p{M}*+`. Последний regex всегда будет соответствовать `à`, независимо от того, как это закодировано. Possessive квантификатор гарантирует, что поиск с возвратом не приведет к тому, что `\P{M}\p{M}*+` будет соответствовать не-знаку без комбинируемых символов, которые следуют за ним, чего `\X` никогда не сделает.
PCRE, PHP и .NET чувствительны к регистру при проверке части между фигурными скобками лексемы `\p`. `\p{Zs}` будет соответствовать любому символу пробела, в то время как `\p{zs}` выдаст ошибку. Все другие regex-движки, описанные здесь, будут соответствовать пробелу в обоих случаях, игнорируя регистр категории между фигурными скобками. Тем не менее, рекомендуется взять за привычку использовать ту же комбинацию прописных и строчных букв, как в списке категорий ниже. Это позволит вашим регулярным выражениям работать со всеми regex-движками поддерживающими Unicode.
В дополнение к стандартной нотации `\p{L}`, Java, Perl, PCRE, движок JGsoft и XRegExp 3 позволяют использовать сокращение `\pL`. Это сокращение работает только с однобуквенными категориями Unicode. `\pLl` не является эквивалентом `\p{Ll}`. Это эквивалент `\p{L}l`, который соответствует `Al` или `àl` или любой букве юникода, за которой следует буква `l`.
Perl, XRegExp и движок JGsoft также поддерживают длиннобуквенный `\p{Letter}`. Полный список всех категорий Unicode приведен ниже. Вы можете опустить подчёркивания или использовать вместо них дефисы или пробелы.
*[прим.: \* – ссылки на сторонний ресурс, с указанием кодов, принадлежащих к конкретной подкатегории, для наглядности]*
* `\p{L}` или `\p{Letter}` – любой вид любой буквы на любом языке.
+ `\p{Ll}` или `\p{Lowercase_Letter}` – буква в нижнем регистре, которая имеет вариант в верхнем. [\*](https://compart.com/en/unicode/category/Ll)
+ `\p{Lu}` или `\p{Uppercase_Letter}` – буква в верхнем регистре, которая имеет вариант в нижнем. [\*](https://compart.com/en/unicode/category/Lu)
+ `\p{Lt}` или `\p{Titlecase_Letter}` – диграф единым символом (кодом) в начале слова, когда заглавной является только его первая часть. [\*](https://compart.com/en/unicode/category/Lt)
+ `\p{L&}` или `\p{Cased_Letter}` – буква, которая существует в строчном и прописном вариантах (сочетание `Ll`, `Lu` и `Lt`).
+ `\p{Lm}` или `\p{Modifier_Letter}` – специальный символ, который используется как буква. [\*](https://compart.com/en/unicode/category/Lm)
+ `\p{Lo}` или `\p{Other_Letter}` – буква или идеограмма, не имеющая строчных и прописных вариантов. [\*](https://compart.com/en/unicode/category/Lo)
* `\p{M}` или `\p{Mark}` – символ, предназначенный для сочетания с другим символом.
+ `\p{Mn}` или `\p{Non_Spacing_Mark}` – символ, предназначенный для сочетания с другим символом, не занимая дополнительного места (например, ударения, умляуты и т.д.). [\*](https://compart.com/en/unicode/category/Mn)
+ `\p{Mc}` или `\p{Spacing_Combining_Mark}` – символ, предназначенный для сочетания с другим символом, занимающий дополнительное место (как знаки гласных во многих восточных языках). [\*](https://compart.com/en/unicode/category/Mc)
+ `\p{Me}` или `\p{Enclosing_Mark}` – символ, который окружает символ, с которым он сочетается (круг, квадрат и т.д.). [\*](https://compart.com/en/unicode/category/Me)
* `\p{Z}` или `\p{Separator}` – любые пробельные символы или невидимые разделители.
+ `\p{Zs}` или `\p{Space_Separator}` – символ пробела, который невидим, но занимает место. [\*](https://compart.com/en/unicode/category/Zs)
+ `\p{Zl}` или `\p{Line_Separator}` – разделитель строк `U+2028`.
+ `\p{Zp}` или `\p{Paragraph_Separator}` – разделитель параграфов `U+2029`.
* `\p{S}` или `\p{Symbol}` – математические символы, знаки валют, дингбаты, символы для рисования и т.д.
+ `\p{Sm}` или `\p{Math_Symbol}` – любой математический символ. [\*](https://compart.com/en/unicode/category/Sm)
+ `\p{Sc}` или `\p{Currency_Symbol}` – любой символ валюты. [\*](https://compart.com/en/unicode/category/Sc)
+ `\p{Sk}` или `\p{Modifier_Symbol}` – объединяющий символ (знак) как самостоятельный полный символ. [\*](https://compart.com/en/unicode/category/Sk)
+ `\p{So}` или `\p{Other_Symbol}` – различные символы, не относящиеся к прошлым подкатегориям. [\*](https://compart.com/en/unicode/category/So)
* `\p{N}` или `\p{Number}` – любой числовой символ любой письменности.
+ `\p{Nd}` или `\p{Decimal_Digit_Number}` – цифра от нуля до девяти в любой письменности, кроме идеографической. [\*](https://compart.com/en/unicode/category/Nd)
+ `\p{Nl}` или `\p{Letter_Number}` – число, которое выглядит как буква, например, римская цифра. [\*](https://compart.com/en/unicode/category/Nl)
+ `\p{No}` или `\p{Other_Number}` – надстрочная или подстрочная цифра, или число, не являющееся цифрой 0-9 (исключая числа из идеографических письменностей). [\*](https://compart.com/en/unicode/category/No)
* `\p{P}` or `\p{Punctuation}` – любой символ пунктуации.
+ `\p{Pd}` или `\p{Dash_Punctuation}` – любой вид дефиса или тире. [\*](https://compart.com/en/unicode/category/Pd)
+ `\p{Ps}` или `\p{Open_Punctuation}` – любой вид открывающей скобки. [\*](https://compart.com/en/unicode/category/Ps)
+ `\p{Pe}` или `\p{Close_Punctuation}` – любой вид закрывающей скобки. [\*](https://compart.com/en/unicode/category/Pe)
+ `\p{Pi}` или `\p{Initial_Punctuation}` – любой вид открывающей кавычки. [\*](https://compart.com/en/unicode/category/Pi)
+ `\p{Pf}` или `\p{Final_Punctuation}` – любой вид закрывающей кавычки. [\*](https://compart.com/en/unicode/category/Pf)
+ `\p{Pc}` или `\p{Connector_Punctuation}` – символ пунктуации, такой как подчёркивание, который соединяет слова. [\*](https://compart.com/en/unicode/category/Pc)
+ `\p{Po}` или `\p{Other_Punctuation}` – любой знак препинания, не относящийся к прошлым подкатегориям. [\*](https://compart.com/en/unicode/category/Po)
* `\p{C}` или `\p{Other}` – невидимые управляющие символы и неиспользуемые коды.
+ `\p{Cc}` или `\p{Control}` – управляющие ASCII или Latin-1 символы: `0x00–0x1F` и `0x7F–0x9F`. [\*](https://compart.com/en/unicode/category/Cc)
+ `\p{Cf}` или `\p{Format}` – невидимый индикатор форматирования. [\*](https://compart.com/en/unicode/category/Cf)
+ `\p{Co}` или `\p{Private_Use}` – любой код, зарезервированный для частного использования.
+ `\p{Cs}` или `\p{Surrogate}` – одна половина суррогатной пары в кодировке UTF-16.
+ `\p{Cn}` или `\p{Unassigned}` – любой код, которому не присвоен ни один символ.
Письменности в Юникоде
----------------------
Стандарт Unicode помещает каждый назначенный код (символ) в одну категорию письменности. Некоторые категории, например `Thai`, соответствуют одному человеческому языку. Другие категории, например `Latin`, относятся к нескольким языкам.
Некоторые языки состоят из нескольких письменностей. Японской письменности в юникоде не существует. Вместо этого юникод предлагает хира́гану, ката́кану, китайское письмо и латиницу, из которых обычно состоят японские документы.
Особой категорией является `Common script`. Здесь содержатся всевозможные символы, которые являются общими для широкого числа письменностей. Категория включает в себя всевозможные знаки препинания, пробелы и различные прочие символы.
Все назначенные коды являются частью ровно одной категории письменности. Все неназначенные коды (те, которые соответствуют `\p{Cn}`) не являются частью какой-либо категории письменности вообще.
Движки JGsoft, Perl, PCRE, PHP, Ruby 1.9, Delphi и XRegExp могут сопоставлять категории письменности юникода.
Список письменностей1. `\p{Common}`
2. `\p{Arabic}`
3. `\p{Armenian}`
4. `\p{Bengali}`
5. `\p{Bopomofo}`
6. `\p{Braille}`
7. `\p{Buhid}`
8. `\p{Canadian_Aboriginal}`
9. `\p{Cherokee}`
10. `\p{Cyrillic}`
11. `\p{Devanagari}`
12. `\p{Ethiopic}`
13. `\p{Georgian}`
14. `\p{Greek}`
15. `\p{Gujarati}`
16. `\p{Gurmukhi}`
17. `\p{Han}`
18. `\p{Hangul}`
19. `\p{Hanunoo}`
20. `\p{Hebrew}`
21. `\p{Hiragana}`
22. `\p{Inherited}`
23. `\p{Kannada}`
24. `\p{Katakana}`
25. `\p{Khmer}`
26. `\p{Lao}`
27. `\p{Latin}`
28. `\p{Limbu}`
29. `\p{Malayalam}`
30. `\p{Mongolian}`
31. `\p{Myanmar}`
32. `\p{Ogham}`
33. `\p{Oriya}`
34. `\p{Runic}`
35. `\p{Sinhala}`
36. `\p{Syriac}`
37. `\p{Tagalog}`
38. `\p{Tagbanwa}`
39. `\p{TaiLe}`
40. `\p{Tamil}`
41. `\p{Telugu}`
42. `\p{Thaana}`
43. `\p{Thai}`
44. `\p{Tibetan}`
45. `\p{Yi}`
Perl и JGsoft позволяют использовать `\p{IsLatin}` вместо `\p{Latin}`. Синтаксис `Is` полезен для различения письменностей и блоков, как объясняется в следующем разделе. PCRE, PHP и XRegExp не поддерживают префикс `Is`.
Java 7 добавляет поддержку категорий письменностей. В отличие от прочих, Java 7 требует префикс `Is`.
Блоки Юникода
-------------
Стандарт Unicode делит карту символов на различные блоки или диапазоны кодов. Каждый блок используется для определения символов конкретной письменности, например, "тибетское письмо" или относящихся к определенной группе, например, "шрифт Брайля". Большинство блоков включают нераспределённые коды, зарезервированные для будущего расширения стандарта.
Обратите внимание, что блоки юникода не совпадают на 100% с категориями письменностей. Существенное различие между блоками и данными категориями заключается в том, что блок – это один непрерывный диапазон кодов, как указано ниже. Категории письменностей состоят из символов, взятых со всей карты символов юникода. Блоки могут включать неназначенные коды (т.е. коды, соответствующие `\p{Cn}`). Категории письменностей никогда не включают неназначенные коды. Обычно, если вы не уверены, использовать ли категорию письменности или блок юникода, используйте категорию письменности.
Например, блок `Currency` не включает символы доллара и йены. Вместо этого они находятся в блоках `Basic_Latin` и `Latin-1_Supplement`, несмотря на то, что оба символа являются валютными, а символ йены не является латинским символом. Это объясняется историческими причинами, поскольку стандарт ASCII включает знак доллара, а стандарт ISO-8859 – знак йены. Не следует слепо использовать любой из перечисленных ниже блоков, основываясь на их названиях. Вместо этого посмотрите на диапазоны символов, которым они фактически соответствуют. В этом может помочь такой инструмент, как RegexBuddy. Категория `\p{Sc}` или `\p{Currency_Symbol}` будет лучшим выбором, чем блок `\p{InCurrency_Symbols}`, когда вы пытаетесь найти все символы валюты.
Блоки юникода1. `\p{InBasic_Latin}: U+0000–U+007F`
2. `\p{InLatin-1_Supplement}: U+0080–U+00FF`
3. `\p{InLatin_Extended-A}: U+0100–U+017F`
4. `\p{InLatin_Extended-B}: U+0180–U+024F`
5. `\p{InIPA_Extensions}: U+0250–U+02AF`
6. `\p{InSpacing_Modifier_Letters}: U+02B0–U+02FF`
7. `\p{InCombining_Diacritical_Marks}: U+0300–U+036F`
8. `\p{InGreek_and_Coptic}: U+0370–U+03FF`
9. `\p{InCyrillic}: U+0400–U+04FF`
10. `\p{InCyrillic_Supplementary}: U+0500–U+052F`
11. `\p{InArmenian}: U+0530–U+058F`
12. `\p{InHebrew}: U+0590–U+05FF`
13. `\p{InArabic}: U+0600–U+06FF`
14. `\p{InSyriac}: U+0700–U+074F`
15. `\p{InThaana}: U+0780–U+07BF`
16. `\p{InDevanagari}: U+0900–U+097F`
17. `\p{InBengali}: U+0980–U+09FF`
18. `\p{InGurmukhi}: U+0A00–U+0A7F`
19. `\p{InGujarati}: U+0A80–U+0AFF`
20. `\p{InOriya}: U+0B00–U+0B7F`
21. `\p{InTamil}: U+0B80–U+0BFF`
22. `\p{InTelugu}: U+0C00–U+0C7F`
23. `\p{InKannada}: U+0C80–U+0CFF`
24. `\p{InMalayalam}: U+0D00–U+0D7F`
25. `\p{InSinhala}: U+0D80–U+0DFF`
26. `\p{InThai}: U+0E00–U+0E7F`
27. `\p{InLao}: U+0E80–U+0EFF`
28. `\p{InTibetan}: U+0F00–U+0FFF`
29. `\p{InMyanmar}: U+1000–U+109F`
30. `\p{InGeorgian}: U+10A0–U+10FF`
31. `\p{InHangul_Jamo}: U+1100–U+11FF`
32. `\p{InEthiopic}: U+1200–U+137F`
33. `\p{InCherokee}: U+13A0–U+13FF`
34. `\p{InUnified_Canadian_Aboriginal_Syllabics}: U+1400–U+167F`
35. `\p{InOgham}: U+1680–U+169F`
36. `\p{InRunic}: U+16A0–U+16FF`
37. `\p{InTagalog}: U+1700–U+171F`
38. `\p{InHanunoo}: U+1720–U+173F`
39. `\p{InBuhid}: U+1740–U+175F`
40. `\p{InTagbanwa}: U+1760–U+177F`
41. `\p{InKhmer}: U+1780–U+17FF`
42. `\p{InMongolian}: U+1800–U+18AF`
43. `\p{InLimbu}: U+1900–U+194F`
44. `\p{InTai_Le}: U+1950–U+197F`
45. `\p{InKhmer_Symbols}: U+19E0–U+19FF`
46. `\p{InPhonetic_Extensions}: U+1D00–U+1D7F`
47. `\p{InLatin_Extended_Additional}: U+1E00–U+1EFF`
48. `\p{InGreek_Extended}: U+1F00–U+1FFF`
49. `\p{InGeneral_Punctuation}: U+2000–U+206F`
50. `\p{InSuperscripts_and_Subscripts}: U+2070–U+209F`
51. `\p{InCurrency_Symbols}: U+20A0–U+20CF`
52. `\p{InCombining_Diacritical_Marks_for_Symbols}: U+20D0–U+20FF`
53. `\p{InLetterlike_Symbols}: U+2100–U+214F`
54. `\p{InNumber_Forms}: U+2150–U+218F`
55. `\p{InArrows}: U+2190–U+21FF`
56. `\p{InMathematical_Operators}: U+2200–U+22FF`
57. `\p{InMiscellaneous_Technical}: U+2300–U+23FF`
58. `\p{InControl_Pictures}: U+2400–U+243F`
59. `\p{InOptical_Character_Recognition}: U+2440–U+245F`
60. `\p{InEnclosed_Alphanumerics}: U+2460–U+24FF`
61. `\p{InBox_Drawing}: U+2500–U+257F`
62. `\p{InBlock_Elements}: U+2580–U+259F`
63. `\p{InGeometric_Shapes}: U+25A0–U+25FF`
64. `\p{InMiscellaneous_Symbols}: U+2600–U+26FF`
65. `\p{InDingbats}: U+2700–U+27BF`
66. `\p{InMiscellaneous_Mathematical_Symbols-A}: U+27C0–U+27EF`
67. `\p{InSupplemental_Arrows-A}: U+27F0–U+27FF`
68. `\p{InBraille_Patterns}: U+2800–U+28FF`
69. `\p{InSupplemental_Arrows-B}: U+2900–U+297F`
70. `\p{InMiscellaneous_Mathematical_Symbols-B}: U+2980–U+29FF`
71. `\p{InSupplemental_Mathematical_Operators}: U+2A00–U+2AFF`
72. `\p{InMiscellaneous_Symbols_and_Arrows}: U+2B00–U+2BFF`
73. `\p{InCJK_Radicals_Supplement}: U+2E80–U+2EFF`
74. `\p{InKangxi_Radicals}: U+2F00–U+2FDF`
75. `\p{InIdeographic_Description_Characters}: U+2FF0–U+2FFF`
76. `\p{InCJK_Symbols_and_Punctuation}: U+3000–U+303F`
77. `\p{InHiragana}: U+3040–U+309F`
78. `\p{InKatakana}: U+30A0–U+30FF`
79. `\p{InBopomofo}: U+3100–U+312F`
80. `\p{InHangul_Compatibility_Jamo}: U+3130–U+318F`
81. `\p{InKanbun}: U+3190–U+319F`
82. `\p{InBopomofo_Extended}: U+31A0–U+31BF`
83. `\p{InKatakana_Phonetic_Extensions}: U+31F0–U+31FF`
84. `\p{InEnclosed_CJK_Letters_and_Months}: U+3200–U+32FF`
85. `\p{InCJK_Compatibility}: U+3300–U+33FF`
86. `\p{InCJK_Unified_Ideographs_Extension_A}: U+3400–U+4DBF`
87. `\p{InYijing_Hexagram_Symbols}: U+4DC0–U+4DFF`
88. `\p{InCJK_Unified_Ideographs}: U+4E00–U+9FFF`
89. `\p{InYi_Syllables}: U+A000–U+A48F`
90. `\p{InYi_Radicals}: U+A490–U+A4CF`
91. `\p{InHangul_Syllables}: U+AC00–U+D7AF`
92. `\p{InHigh_Surrogates}: U+D800–U+DB7F`
93. `\p{InHigh_Private_Use_Surrogates}: U+DB80–U+DBFF`
94. `\p{InLow_Surrogates}: U+DC00–U+DFFF`
95. `\p{InPrivate_Use_Area}: U+E000–U+F8FF`
96. `\p{InCJK_Compatibility_Ideographs}: U+F900–U+FAFF`
97. `\p{InAlphabetic_Presentation_Forms}: U+FB00–U+FB4F`
98. `\p{InArabic_Presentation_Forms-A}: U+FB50–U+FDFF`
99. `\p{InVariation_Selectors}: U+FE00–U+FE0F`
100. `\p{InCombining_Half_Marks}: U+FE20–U+FE2F`
101. `\p{InCJK_Compatibility_Forms}: U+FE30–U+FE4F`
102. `\p{InSmall_Form_Variants}: U+FE50–U+FE6F`
103. `\p{InArabic_Presentation_Forms-B}: U+FE70–U+FEFF`
104. `\p{InHalfwidth_and_Fullwidth_Forms}: U+FF00–U+FFEF`
105. `\p{InSpecials}: U+FFF0–U+FFFF`
Не все regex-движки с поддержкой юникода используют одинаковый синтаксис для сопоставления блоков. Java, Ruby 2.0 и XRegExp используют синтаксис `\p{InBlock}`, как указано выше. В .NET и XML вместо этого используется `\p{IsBlock}`. Perl и JGsoft поддерживают обе нотации. Рекомендуется использовать нотацию `In`, если ваш regex-движок поддерживает её. `In` можно использовать только для блоков Unicode, в то время как `Is` можно использовать для общих категорий и категорий письменностей, в зависимости от используемого вами шаблона регулярных выражений. При использовании `In` очевидно, что вы сопоставляете блок, а не общую категорию или письменность с аналогичным названием.
В .NET и XML вы должны опустить подчёркивание, но сохранить дефисы в именах блоков. Например, используйте `\p{IsLatinExtended-A}` вместо `\p{InLatin_Extended-A}`. В Java вы должны опустить дефисы. .NET и XML также сравнивают имена с учетом регистра, в то время как Perl, Ruby и JGsoft сравнивают их без учета регистра. Java 4 чувствительна к регистру. Java 5 и более поздние версии учитывают регистр для префикса `Is`, но не для самих имен блоков.
Фактические имена блоков одинаковы во всех движках регулярных выражений. Имена блоков определены в стандарте Unicode. PCRE и PHP не поддерживают блоки, хотя они поддерживают категории письменностей.
Нужно ли вам беспокоиться о различных кодировках?
-------------------------------------------------
Хотя вы всегда должны помнить о подводных камнях, создаваемых различными способами кодирования комбинированных символов, вам не всегда нужно беспокоиться об этом. Если вы знаете, что ваша входная строка и ваше регулярное выражение используют один и тот же подход, то вам вообще не нужно беспокоиться об этом. Этот процесс называется нормализацией Unicode. Все языки программирования со встроенной поддержкой Unicode, такие как Java, C# и VB.NET, имеют функции библиотек для нормализации строк. Если вы нормализуете и объект, и регулярное выражение перед попыткой сопоставления, никаких несоответствий не возникнет.
Если вы используете Java, вы можете передать флаг `CANON_EQ` в качестве второго параметра в `Pattern.compile()`. Это указывает движку регулярных выражений Java считать канонически эквивалентные символы идентичными. Символ `à`, закодированный как `U+00E0`, соответствует `à`, закодированному как `U+0061 U+0300`, и наоборот. Ни один из других regex-движков в настоящее время не поддерживает каноническую эквивалентность при сопоставлении.
Если набрать на клавиатуре клавишу `à`, все известные нам текстовые процессоры вставят в файл код `U+00E0`. Таким образом, если вы работаете с текстом, который вы набрали сами, любое регулярное выражение, который вы набрали сами, будет соответствовать таким же образом.
Наконец, если вы используете PowerGREP для поиска в текстовых файлах, закодированных с помощью традиционной кодовой страницы Windows (часто называемой "ANSI") или ISO-8859, PowerGREP всегда использует подстановку один к одному. Поскольку все кодовые страницы Windows или ISO-8859 представляют комбинированные символы одним кодом, почти все программы используют один код для каждого символа при преобразовании файла в юникод.
> Нашли опечатку или неточность в переводе? Выделите и нажмите `CTRL/⌘+Enter`
>
>
|
https://habr.com/ru/post/713256/
| null |
ru
| null |
# Смешав Twitter + Movie мы получем TwiMov
Хотелось бы в этом небольшом тексте рассказать о том как зародилась идея, как рождался код и что имеем на данный момент на моём проекте [TwiMov](http://www.twimov.ru).
Я с детства любил кино, этот сказочный и фантастический мир, где полно совершенно нереальных вещей. Мир не ограниченный ничем, только фантазией автора. Мир который заставляет сопереживать, сочувствовать, понимать. Кино это не настоящая жизнь, это и есть виртуальная реальность.
Так как иногда мне просто хочется, что-то сказать о фильме который я посмотрел, например нападает на меня какое графоманство, что аж не могу в себе это держать и нужно обязательно вылить это на клавиатуре, это как памятка для себя на будущее и еще раз возможность проанализировать фильм, я сажусь за компьютер и пишу рецензию. Удачная она получится или не очень мне не известно и мало волнительно, правило 80/20 всегда в уме. Но хорошие, четкие рецензии с большим количеством мыслей, идей и анализа это удел профессиональных авторов и журналистов, к радости или сожалению я ни один из них. Потому в какой-то момент по одному из топиков на нашем [уфимском рок-форуме](http://rockufa.ru/forum/index.php/topic,1626.0.html) я понял, что люди не всегда готовы писать крупные рецензии, зато с охотностью вставляют свои «пять копеек». Ну а благо я стараюсь следить за всяческими тендециями в сети, хотя с первого раза и не понял к чему мне Twitter, то в этот раз он с точностью подходил к моим задачам!
**Идея.**
Идею я увидел сразу, прозрачно и запросто.
Есть к примеру некий сайт на нём публикуются краткие заметки от разных пользователей по разным фильмам. Заметки группируются по названию фильма. Короткие и лаконичные как перышки воробья. Так как всё хотелось завязать на независимые клиенты, очереди и доставку, то выбрал сразу Twitter, день прочтения [документации по API](http://apiwiki.twitter.com/Twitter-API-Documentation) позволил сказать, что всё это возможно и без особых проблем.
Был зарегистрирован некий бот @twimov, который пока молчун, но уже скоро тоже заговорит :) Так же ряд доменов, среди которых основной это [www.TwiMov.ru](http://www.twimov.ru). И работа закипела.
**Кодирование.**
Задача кода была разделена на 3 составляющих:
1. Бот, забирающий в определенный промежуток времени ленту обращений к нему в Твиттере, проверяющий и обрабатывающий сообщения
2. Фронтэнд, вывод рецензий, фильмов, информации о пользователях
3. Администрирование и контроль
1. *Бот*. Казалось бы четко и логично. Но с чего это я решил делать его на Perl, до сих пор не пойму, взял LWP, DBI::MYSQL, IMAGE::MAGICK и пошёл делать… Да вот как-то всё туго и туго, то авторизация отваливается на LWP, ставить модули специально для Twitter'а не было желания, так как я уже представлял, сколько это кода например на PHP. Странно, но эта задача для меня перелилась в полный уход в PHP.
Сказано, сделано. За день переписан код в «чистый» PHP, то всё своё, ну может кроме PDO. Написан удобный класс для запросов к Twitter'у, работает через стандартные функции запроса файлов, если allow\_url\_open включен, если нет через CURL.
Написан класс для парсинга Твиттер ленты, то, что сразу был намек на универсальность класса помог мне быстро создать второй объект, который парсит еще и приватную ленту сообщений на наличие рецензий.
Именно БОТ как таковой и есть сердце и ядро заполнения, он развивался всеми идеями которые я считал приемлемы в нашем случае, например:
— кэширование аватар пользователей, чтобы в какой-то момент не потерять их и связь с Твиттером.
— поиск обложки фильма с помощью Google и так же кэширование её на свой сервер с коррекцией размеров (за это спасибо [PHPThumb](http://phpthumb.gxdlabs.com))
— поиск так же в Google трейлера фильма
Все эти пункты были выполнены в целом на 5, циклично и не всё сразу, а в процессе работы, но я остался доволен и даже сейчас есть еще идеи, чтобы и как помочь себе в автоматизации.
2. *Фронтэнд*. Вывод это было самое простое. Я не стал тянуть за собой какой-либо старый багаж библиотек или модулей. Взял чистый фреймворк [CodeIgniter](http://www.codeigniter.com) (извините, на «лапше» писать уже жалко времени), расширил его рядом своих классов на Модель, на Фронт контроллер и Административный контроллер, чтобы было удобнее и проще.
Макет дизайна я даже не рисовал, просто взял свои любимые мрачно-готически-эмо цвета и в css набросал, то как я примерно хочу видеть сайт. Дизайн пока оставлен на потом, благо архитектура MVС позволит мне изменить его моментально на всём сайте. Есть ряд «фишек» и моих личных правил по поводу расширения и написания кода под CodeIgniter, которые я взял для себя из Ruby on Rails, в целом это как именование таблиц, функций, расширение модели, автозагрузка и инициализация оных. Если кому-то будет интересно готов поделиться и описать их в очередной статье, я не жадный, авось кому и пригодится.
3. *Администрирование*. Всё опять же на базе CodeIgniter, маленькая авторизация:
Ну тут тоже без особых прикрас, UI дизайнер из меня никакой, потому я всегда делаю как удобно мне любимому и на сколько быстро я буду управляться с контентом сам, так как единственный пока администратор сайта. Но уже ряд фишек для себя наметил.
Сразу же определил, что и как я хочу администрировать.
Это рецензии по отдельности всех пользователей, с листалкой по странице и в будущем будет внутренний поиск.
Это управление фильмами, рядом с каждым фильмом мы наблюдаем его информацию и состояние заполненности обложки, видео-ролика, текстового описания с помощью иконок.
И редактор фильмов. На нём бы я хотел чуток остановиться.
Технически всё просто, бот иногда может ошибиться, как и Google не редкость, потому у Администратора должна быть возможность самостоятельно исправить название ленты, так же «перезалить» новую обложку фильма и возможно выбрать новый видео файл трейлера для ленты. Разумеется есть возможность самостоятельно указывать адрес изобращения и ролика, но в основном я пытаюсь по ряду ключевых слов, опять же спросить Google о их наличии, опять же если кому интересно как работать с поиском в Google, спрашивайте, поставлю себе заметку на новый материал. А дальше дело человека, посмотрел, выбрал, указал. Кстати, указывается через AJAX, чтобы не перегружать столь большие массивы данных. Чтобы не писать свою обертку вокруг этого всего я обычным делом взял JQuery, немного не привычно с ним работать после Prototype, но богатство плагинов и расширений всё же вынудило перейти на эту JS библиотеку. Ответы сервер как обычно отдаёт в JSON, мне так удобнее.
И разумеется список пользователей так же с листалкой и в будущем с поиском
на данный момент, чтобы не вторгаться в приватность пользователей их невозможно редактировать, они всегда остаются вместе с их аватарами на сайте, но есть возможность БАНИТЬ, возможно на столько суровые меры могут пригодиться в борьбе со спамерами и флудерастами.
Ну вот в целом и всё, а теперь просто присоединяйтесь к [www.twitter.com/twimov](http://www.twitter.com/twimov) и пишите ему в таком формате
`@twimov Название фильма+Ваше описание этого супер фильма!`
P.S. Спасибо за инвайт и надеюсь модераторы перенесут в блог «Стартап».
P.P.S. Спасибо за карму, перенес в «Я пиарюсь»
|
https://habr.com/ru/post/80836/
| null |
ru
| null |
# Расчет календаря периодических событий с учетом праздничных дней
[](http://getcalendar.ru)
На пиар вряд ли тянет, но кроме как в «Я пиарюсь» не придумал, куда разместить.
Все началось с того, что знакомые в банке из отдела отчетности обратились ко мне с просьбой, не знаю ли я ресурса, где можно автоматически рассчитать даты сдачи отчетности. На тот момент использовался большой лист формата А3, который висел на стене и содержал в себе список отчетных форм и срок сдачи в соответствии с нормативными требованиями Банка России.
Вся соль в том, что сроки ЦБ обычно устанавливает, например, как «7 рабочий день месяца, следующего за отчетным». В то время, как формы могут быть как месячные, так и квартальные, годовые, декадные, пятидневки. А тот факт, что на каждый календарный год в России Правительством устанавливается производственный календарь, где закрепляются праздничные дни и все необходимые переносы, только усугубляет положение, так как нужно подстраиваться под все эти изменения.
Собственно, на том листе стояли примерные дни сдачи, как-то: для 7 рабочего дня отчет отображался к сдаче в графе «7 число месяца», что заведомо было раньше срока. И получалось, всегда это нужно держать в голове и не забыть сдать тот или иной отчет. Все это было не сильно удобно. А главная задача была — контроль сроков сдачи, так как за нарушение от ЦБ полагаются соответствующие меры воздействия. А если допустить просрочку свыше 15 дней, то могут и лицензию по закону отозвать.
В общем, потыкав Outlook и еще ряд календарных менеджеров, понял, что периодические события, со сроком исчисляемым в рабочих днях, настроить нельзя. Подумал сделать костыль, так как календарь отчетности можно за раз рассчитать на год вперед и на время забыть про это.
Самая простая идея, которая пришла в голову — получить CSV в нужном формате, который можно подгрузить в Outlook. Для того, чтобы сгенерировать CSV, первое о чем подумал, — SQL, благо какое-то время назад разбирался с Oracle и стандарт SQL там расширен множеством полезного функционала.
Для этого завел список событий в Excel, на выходе получал список insert'ов для вставки в таблицу настройки.
А базовых таблиц понадобилось 3:
* таблицы праздничных дней, которые нужно добавить (add\_red\_days)
* таблицы дней, которые являются субботой или воскресенье, но в связи с переносом становятся рабочими (remove\_red\_days)
* собственно, список самих форм отчетности с необходимыми параметрами (cb\_reports\_settings)
> `SQL> desc remove\_red\_days
>
> Name Type Nullable Default Comments
>
> ---- ---- -------- ------- --------
>
> DT DATE Y
>
>
>
> SQL> select \* from remove\_red\_days
>
> 2 /
>
>
>
> DT
>
> -----------
>
> 27.02.2010
>
> 13.11.2010
>
>
>
> SQL> desc add\_red\_days
>
> Name Type Nullable Default Comments
>
> ---- ---- -------- ------- --------
>
> DT DATE Y
>
>
>
> SQL> select \* from add\_red\_days
>
> 2 /
>
>
>
> DT
>
> -----------
>
> 01.01.2010
>
> 04.01.2010
>
> 05.01.2010
>
> 06.01.2010
>
> 07.01.2010
>
> 08.01.2010
>
> 22.02.2010
>
> 23.02.2010
>
> 08.03.2010
>
> 03.05.2010
>
> 10.05.2010
>
> 14.06.2010
>
> 04.11.2010
>
> 05.11.2010
>
>
>
> 14 rows selected
>
>
>
> SQL> desc cb\_reports\_settings
>
> Name Type Nullable Default Comments
>
> --------------- ------------- -------- ------- --------
>
> FORM\_NAME VARCHAR2(100) Y
>
> CALENDAR\_DAY NUMBER(2) Y
>
> WORKING\_DAY NUMBER(2) Y
>
> TIME\_TO\_BE\_SENT NUMBER(2) Y
>
> IS\_QUARTERLY NUMBER(1) Y
>
>
>
> SQL> select \* from cb\_reports\_settings
>
> 2 /
>
>
>
> FORM\_NAME CALENDAR\_DAY WORKING\_DAY TIME\_TO\_BE\_SENT IS\_QUARTERLY
>
> --------------------- ------------ ----------- --------------- ------------
>
> 350 1 2 0
>
> 301 1 2 13 0
>
> 634\_декада 1 4 0
>
> 101 1 4 0
>
> 134 1 4 0
>
> 135 1 6 0
>
> 153 1 6 0
>
> 711 1 5 0
>
> 301 5 2 13 0
>
> 115 1 7 0
>
> 116 1 7 0
>
> 117 1 7 0
>
> 118 1 7 0
>
> 155 1 7 0
>
> 125 1 8 0
>
> 157 1 8 0
>
> 501 1 8 0
>
> 603 1 8 0
>
> 102 1 8 1
>
> 110 1 8 0
>
> 128 1 7 0
>
> 129 1 7 0
>
> 302 1 10 0
>
> 316 1 10 0
>
> 251 1 10 1
>
> 401 1 10 0
>
> 301 10 2 13 0
>
> 350 11 2 0
>
> 634\_декада 11 4 0
>
> 345 1 11 1
>
> 405 1 17 0
>
> 301 15 2 13 0
>
> 301 20 2 13 0
>
> 350 21 2 0
>
> 634\_декада 21 4 0
>
> 301 25 2 13 0
>
> 342-П (ФОР) 1 10 0
>
>
>
> 37 rows selected
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Генерацию CSV для загрузки в MS Outlook сделал таким вот запросом:
> `/\*сгенерируем все даты года\*/
>
> with t1 as (select trunc(sysdate,'y')+rownum-1 dt from dual connect by level<=365),
>
> --
>
> /\*найдем из них все рабочие дни и пронумеруем их внутри месяцев\*/
>
> t2 as (select dt, row\_number() over (partition by trunc(dt,'mm') order by dt) working\_day,
>
> row\_number() over (order by dt) wd2 from t1
>
> where (mod(to\_char(dt, 'j'),7) +1 not in (6,7)--выкинуть выходные
>
> or dt in (select dt from remove\_red\_days)) --добавим выходные, которые стали рабочими
>
> and dt not in (select dt from add\_red\_days)), --выкинем новые перенесенные праздники
>
> --
>
> /\*соберем в один запрос все дни с номером календарного дня в месяце и рабочего дня\*/
>
> t3 as (select t1.dt, to\_number(to\_char(t1.dt,'dd')) calendar\_day, working\_day, wd2 from t1, t2
>
> where t1.dt = t2.dt(+)
>
> order by t1.dt),
>
> --
>
> /\*добавим колонки с первой ближайшей рабочей датой после данной даты, если она выходной, иначе текущая дата\*/
>
> t4 as (
>
> select t3.\*,
>
> first\_value(decode(working\_day, null, null, t3.wd2) ignore nulls) over (order by t3.dt rows between current row and unbounded following) wd3,
>
> first\_value(decode(working\_day, null, null, t3.dt) ignore nulls) over(order by t3.dt rows between current row and unbounded following) dt2,
>
> nvl2(working\_day, dt, null) dt3
>
> from t3
>
> ) /\*select \* from t4\*/,
>
> --
>
> t5 as (select (select dt
>
> from t4 t4\_inner
>
> where t4\_inner.wd3 - t4\_outer.wd3 + 1 = cbrs.working\_day
>
> and t4\_inner.wd2 is not null
>
> and rownum = 1) needed\_date,
>
> t4\_outer.\*,
>
> cbrs.\*
>
> from t4 t4\_outer,
>
> cb\_reports\_settings cbrs
>
> where t4\_outer.calendar\_day = cbrs.calendar\_day
>
> and (cbrs.is\_quarterly = 0 or cbrs.is\_quarterly = 1 and trunc(t4\_outer.dt,'mm') = trunc(t4\_outer.dt,'Q'))
>
> order by 1)
>
> --
>
> select '"'||form\_name||'","'||to\_char(needed\_date,'dd.mm.yyyy')||'","'||nvl(time\_to\_be\_sent,'17')||':00:00","'||to\_char(needed\_date, 'dd.mm.yyyy')||'","'||nvl(time\_to\_be\_sent,'17')||':00:00","Ложь","Истина","'||to\_char(needed\_date, 'dd.mm.yyyy')||'","09:00:00","Обычная"' col
>
> from t5
>
> order by form\_name, needed\_date
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
На выходе получаем:
`COL
--------
"101","14.01.2010","17:00:00","14.01.2010","17:00:00","Ложь","Истина","14.01.2010","09:00:00","Обычная"
"101","04.02.2010","17:00:00","04.02.2010","17:00:00","Ложь","Истина","04.02.2010","09:00:00","Обычная"
"101","04.03.2010","17:00:00","04.03.2010","17:00:00","Ложь","Истина","04.03.2010","09:00:00","Обычная"
"101","06.04.2010","17:00:00","06.04.2010","17:00:00","Ложь","Истина","06.04.2010","09:00:00","Обычная"
"101","07.05.2010","17:00:00","07.05.2010","17:00:00","Ложь","Истина","07.05.2010","09:00:00","Обычная"
"101","04.06.2010","17:00:00","04.06.2010","17:00:00","Ложь","Истина","04.06.2010","09:00:00","Обычная"
"101","06.07.2010","17:00:00","06.07.2010","17:00:00","Ложь","Истина","06.07.2010","09:00:00","Обычная"
"101","05.08.2010","17:00:00","05.08.2010","17:00:00","Ложь","Истина","05.08.2010","09:00:00","Обычная"
"101","06.09.2010","17:00:00","06.09.2010","17:00:00","Ложь","Истина","06.09.2010","09:00:00","Обычная"
"101","06.10.2010","17:00:00","06.10.2010","17:00:00","Ложь","Истина","06.10.2010","09:00:00","Обычная"
...`
Все это успешно импортируется в Outlook.
И все вроде ничего, вот только так как Oracle на работе отсутствовал, пришлось все выгрузки делать дома. Не совсем удобно.
Пришел новый год, обновились сроки сдачи и список отчетных форм в связи с новым указанием ЦБ, установлен новый производственный календарь. Пришлось собрать данные по новому списку отчетов на работе, дома обновлять данные в таблицах, заново генерить CSV.
Не понравилось мне это и решил я сделать небольшой веб-сервис, который будет полезен в первую очередь мне самому, а также другим людям, кто столкнулся с аналогичной задачей.
Процесс разбил на 3 шага:
1. Нужно отметить какие даты являются праздничными на очередной год. Это можно сделать после того, как примут официальный производственный календарь. Также можно поменять признак выходного дня на рабочий, в случае, если осуществляется перенос.
2. Создание календаря событий и добавление отдельных событий с параметрами.
Параметры:
— периодичность: месяц, квартал или год
— сдвиг в месяцах
— сдвиг в календарных днях
— сдвиг в рабочих днях
Последние три параметра нужны для установки сдвига срока сдачи отчетности. Например, если выбрана периодичность «месяц» в выгрузке будет 12 событий для каждого месяца. По умолчанию дата события 01 число каждого месяца. Вот от нее и считаем сдвиг.
— исключить первый
Этот параметр, позволяет задать особые сроки для первого события в году.
3. Когда мы настроили календарь и список событий, то нужно выгрузить файл для его последующей загрузки в свой менеджер событий.
Сейчас поддерживаются стандартный \*.iCal и \*.csv для MS Outlook.
Собственно, адрес [getcalendar.ru](http://getcalendar.ru). Так как, скорее всего, сервис будет полезен очень редко (раз в год), никакой регистрации локальной не стал делать, а сделал авторизацию только через OpenID.
На работе помимо отчетников ЦБ, стали пользоваться и налоговики, и кадровики. В нужный день в Outlook автоматически с утра всплывает напоминание, если нужно какой-то отчет предоставить или совершить платеж.
Надеюсь, кому-нибудь пригодится.
|
https://habr.com/ru/post/96496/
| null |
ru
| null |
# OverScript — язык программирования, написанный на C#
Привет! Меня зовут Дмитрий, я написал на C# свой интерпретируемый язык программирования, который назвал — [OverScript](https://overscript.org/). Это си-подобный язык со статической типизацией. Сразу скажу, что это не прототип, а готовый проект. Весь код на 100% мой. Я подробно не интересовался, как написаны другие языки, поэтому вся реализация интерпретатора это моя чистая импровизация. Мой подход неконвенциональный, поэтому к техническим аспектам стоит относиться без ассоциаций с тем, что вы могли ранее видеть в других языках, несмотря на то, что некоторые вещи могут казаться знакомыми.
Самое важное:
1. Интерпретатор является полностью независимым, т.е. не использует имеющихся в .NET средств компиляции кода. Он также не использует никаких сторонних библиотек. Это не транслятор, а хардкорный интерпретатор.
2. OverScript — си-подобный язык с классическими принципами ООП. Он имеет **статическую типизацию**, поддерживает наследование, виртуальные методы, перегрузку операторов и многое другое. Моя задача была не придумывать новый синтаксис, а сделать язык, привычный для C#-программистов.
3. Скорость работы сопоставима с Python и ClearScript (проверял на VBScript). OverScript пока чуть уступает, но ещё есть что оптимизировать. При этом он в разы быстрее других интерпретаторов, написанных на C#. Например, в 5 раз быстрее, чем MoonSharp (Lua). C IronPython не сравнивал, т.к. это транслятор компилирующего типа.
4. OverScript, на мой взгляд, является идеальным языком для встраивания в .NET-программы. Он относительно быстрый и привычный. Да, это не V8, но более удобный язык, чем JS, за счёт, например, той же статической типизации, которая позволяет на стадии загрузки кода выявлять ошибки, связанные с несовместимостью типов.
5. В OverScript нет проблемы с отсутствием библиотек. Он может использовать типы стандартных .NET-библиотек. Можно импортировать функции из самописных библиотек.
Для работы интерпретатора нужен .NET 6. Можно и под .NET Framework перекомпилировать с небольшими изменениями (не пробовал). Я использовал классический C# без таких нововведений как, например, индексы и диапазоны, которые появились только в версии 8.0.
Пример кода:
```
string s="Hello, world!"; //это переменная типа System.String
WriteLine(ToUpper(Substring(s, 0, 5))); //HELLO //вызывается базовые функции Substring и ToUpper
WriteLine(s.Substring(0, 5).ToUpper()); //HELLO //то же самое
s.Substring(0, 5).ToUpper().WriteLine(); //а можно и так
WriteLine(s->Substring(0, 5)->ToUpper()); //HELLO //через рефлекшн вызываются стандартные методы типа System.String
//WriteLine - это базовая функция-обёртка для Console.WriteLine(str)
//В OverScript почти все базовые функции имеют имена .NET-методов, которые они используют
```
Из простого примера выше видно, что OverScript представляет собой слой абстракции над стандартными .NET-типами. Говоря по-простому, OverScript это программа, которая анализирует код, выстраивает из него определённую структуру из последовательностей отдельных операций, после чего рекурсивно выполняет их.
Ещё пример:
```
Point[] arr = new Point[]{new Point(25, 77), new Point(122, 219)}; //создание массива из двух экземпляров класса Point
int n; // имеет значение 0 по умолчанию
foreach(Point p in arr){ // перебор всех элементов массива
n++;
WriteLine($"{n}) {p.X}; {p.Y}"); // вывод значений с помощью интерполяции строк
}
//1) 25; 77
//2) 122; 219
ReadKey();
class Point{
public int X, Y;
New(int x, int y){ // конструктор
X=x;
Y=y;
}
}
```
Ещё:
```
const string label = " O v e r S c r i p t ";
const int a = '0', z = '9';
const int labelX = 9, labelY = 8, labelX2 = labelX+Length(label);
const object Console = typeof("System.Console, System.Console");
const object DarkGreen = "DarkGreen".ToEnum("System.ConsoleColor, System.Console");
const object Cyan = "Cyan".ToEnum("System.ConsoleColor, System.Console");
bool w, p;
int x, y;
char c;
ReadKey("Press any key to continue");
ClearConsole();
Console->ForegroundColor = Cyan;
string welcome="Welcome to OverScript!";
foreach(c in welcome){Write(c); Sleep(Rand(0, 200));}
Sleep(500);
SetCursorVisible(false);
Console->ForegroundColor = DarkGreen;
foreach(int i in Range(10000)){
x = Rand(0, 50);
y = Rand(0, 16);
p = w;
w = y == labelY && x >= labelX && x < labelX2;
c = w ? label[x - labelX] : char\Rand(a, z);
if(w != p)
Console->ForegroundColor = w ? Cyan : DarkGreen;
SetCursorLeft(x);
SetCursorTop(y);
Write(c);
}
Sleep(5000);
```
Результат выполнения — [GIF](https://overscript.org/images/welcome-sample.gif).
#### Примеры полезных приложений
1. [Парсер урлов изображений](https://github.com/overscript-lang/ImageParser) с сайта;
2. [Переводчик текстов](https://github.com/overscript-lang/Translator) через Yandex Translate;
3. [Игра Змейка](https://github.com/overscript-lang/Snake) с использованием GTK#.
### Есть много разных языков...
Я написал большой текст о *инди-языках* и их создании, но решил не вставлять его (слишком занудный), а просто обозначить основные моменты. Когда я начал свой проект, стал искать, что пишут другие, и обнаружил, что любительских проектов просто туча.
1. Обычно пишут трансляторы в Си, JS, или под LLVM-компиляторы. Чаще всего это JS-подобные языки (функции — объекты, отсутствие полноценного ООП и т.п.).
2. Используют готовые лексеры, парсеры и прочие инструменты.
3. Дальше прототипов дело редко идёт. Скорее всего, причина в том, что пишут по шаблону и упираются в фундаментальные ограничения, которые не знают как обойти.
4. Пишут обычно на C/C++, а C# считается непригодным для таких задач, и проектов почти нет.
5. Сами языки довольно минималистичны и не про ООП. Дело тут, скорее, не в моде, а в "и так пойдёт".
Тема создания языков с одной стороны популярная, но с другой — маргинальная. Есть известные языки с большими комьюнити, и в новых языках особой необходимости нет. Поэтому новыми проектами, как правило, занимаются любители со специфическим пониманием практической стороны вопроса и стремлением уйти от самостоятельной разработки ядра. Не то чтобы это было плохо, просто толку от этого мало. Почти весь материал (обсуждения, проекты), что я нашёл, по сути — переливание из пустого в порожнее. И как следствие, отношение людей к теме создания новых языков довольно скептическое. Я противник хейта, респект всем, кто пытается сделать что-то новое, но просто констатирую факт.
С новыми языками есть ещё такая проблема: одни ожидают от них привычных возможностей, а другие чего-то революционного. И, задавая вопрос "а зачем он нужен?", сразу готовы ответить "ничего не понятно" или "ничего нового". Это такая почти философская проблема прогресса вообще.
Если трезво смотреть на ситуацию с языками, то единственное, что может дать преимущество новому языку — это лучшая производительность, которая сейчас, на сколько я понимаю, упирается в фундаментальные факторы, связанные с ОС и процессорами. Интерпретаторы же про удобство, доступность и скорость разработки. Ruby, Python или Lua — дело вкуса и привычки. Для меня они непривычны из-за ярко выраженной скриптовости, которая, с одной стороны, сделала их популярными у начинающих, а с другой — обособила не в пользу широкого применения в программах со сложной логикой. OverScript — интерпретируемый язык, но, скажем так, более мейнстримный. Я не противопоставляю его другим, ведь главное в нём даже не статическая типизация, а платформа .NET.
У меня были большие сомнения, что с OverScript получится что-то более-менее приемлемое из-за мифа, что управляемый код не годится для создания интерпретаторов. Но я сразу решил, что цель-минимум — разобраться самому, как устроено программирование со стороны разработчика языка, ведь когда пишешь тривиальные программы на высокоуровневых языках, то кажется, что знаешь всё, но это как с айсбергом — видишь только верхушку. Поэтому я даже не думал о том, чтобы пойти по накатанной дорожке с использованием готовых инструментов. Сейчас уже я уверен, что всё сделал правильно, а C# показал себя отличным языком даже для такой нестандартной задачи, как написание интерпретатора.
Отдельно скажу про вообще все языки. Языков много, но большинство из них либо узкоспециализированные, либо давно устарели. Есть новые языки общего назначения вроде Go и Julia, но я пока не вижу, чтобы они пользовались большой популярностью (в рейтингах цифры весьма скромные). Могу отметить только набирающий обороты Rust, который рассматривается как альтернатива C++, и объединяет сейчас вокруг самых дотошных кодеров, которые за *абстракции с нулевой стоимостью* и прочие штуки, до которых большинству программистов дела нет. Но Rust сложный, поэтому популярным у широких масс не будет. Так что, думаю, основными языками для любительских и промышленных целей ещё долго будут C# и Java. Можно, конечно, и Python ещё назвать, но мнения о его практическом использовании в сложных проектах слишком полярные (собственной оценки давать не буду, т.к. не писал ничего серьёзного на нём).
Я это всё пишу, чтобы у читателя было какое-то представление о том, как я вижу ситуацию, понимаю сложности, и почему решился написать свой язык. Если подытожить, то кажется, что языков много, но на деле выбор небольшой, особенно, если говорить о языках для встраивания в .NET-программы. Конечно, можно обходиться ClearScript, но JScript/VBScript не те языки, которые можно назвать удобными, если вы привыкли к C#. То же самое касается IronRuby и IronPython. Есть много вариантов скриптинга, но все со своими подводными камнями. Это целая отдельная тема, в которой ключевое значение имеет степень интеграции, и конструктивно обсуждать её здесь из-за принципиальных различий подходов, наверное, не имеет смысла. Это также тесно связано с темой "интерпретаторы vs компиляторы", которая для меня — всё равно что сравнивать устройство электромобилей и бензиновых машин.
### Под капотом OverScript
Довольно сложно простыми словами объяснить, как работает интерпретатор OverScript, но я попробую:
1. Код подготавливается (удаляются комментарии, отступы и лишние пробелы, находятся литералы и т.п.), после чего разбивается на классы и функции.
2. Код функций разбивается на отдельные логические строки, определяется вид инструкций (if, goto, return и т.д.).
3. Для управляющих конструкций высчитываются переходы. Например, для if ищется, куда переходить в случае выполнения условия и куда в противном случае.
4. Из каждой строки рекурсивно выстраивается дерево операций. В итоге имеем набор отдельных элементов: присваивание, переменная, элемент массива, литерал, функция и т.д.
5. Далее запускается цепочка рекурсивных вычислений. Начинается она от создания главного класса приложения (в других языках обычно вызывается main). Самым первым вызывается метод Instance(), потом конструктор New().
Итого имеем следующие **ключевые элементы**: класс, функция, логические строки, единицы вычисления (*эвал-юниты*).
У тех, кто уже изучал устройство других интерпретаторов, наверняка возникнет много вопросов, почему я сделал что-то именно так, а не иначе. Но я не смотрел, как сделаны другие языки, поэтому ожидать какого-то соответствия принятым в них нормам не стоит. Я писал, придумывая на ходу. Возможно, это не лучший подход, но копирование других проектов мне не интересно. К тому же, даже частичное копирование не имеет смысла, если вы не хотите ограничиваться функционалом источника. Как показывает опыт, в какой-то момент придётся всё переписывать с нуля, чтобы иметь возможность добавлять свои нестандартные фичи, которые выходят за рамки заложенного потенциала. И я уж не говорю про то, что разобраться в чужом коде, обвешенном всевозможными молдингами, бывает сложнее, чем написать свой.
Подробно расписывать здесь технические детали не вижу смысла. Скажу только про то, что у каждой операции есть свой тип результата, и все вычисления происходят в обобщённых методах и классах с этим типом. Это про внутренние алгоритмы интерпретатора, а не про сам язык. Каждый раз на точках входа в обобщённые части приходится делать switch по типам, либо вызывать делегаты, что значительно снижает быстродействие. Но пока я не придумал, как обойтись без этого. Я перепробовал много решений (абстрактные классы, интерфейсы), но по сути всегда получаются непрямые вызовы методов, которые снижают быстродействие. Та архитектура, на которой я остановился, на первый взгляд, может показаться неоптимальной, но я пришёл к ней по результатам многих тестов.
И ещё важный момент: в интерпретаторе не используется unsafe-код.
### О типах
С простыми типами (int, string, bool и т.д.) всё как в C#. Но, чтобы не было путаницы, в OverScript тип Single называется float (есть функция ToFloat(), а не ToSingle()). Ещё DateTime я назвал date. Нет sbyte, ushort, uint, ulong.
Теперь давайте посмотрим на оператор typeof:
```
WriteLine(typeof(float)); //System.Single //тут всё понятно
WriteLine(typeof("System.Drawing.Point, System.Drawing")); //System.Drawing.Point //а это, наверное, выглядит странно
```
OverScript ничего не знает о .NET-типе System.Drawing.Point. Если написать typeof(System.Drawing.Point), то интерпретатор будет искать ваш собственный класс, а не тип в библиотеке .NET.
Работа с типами, которых нет в OverScript, возможна через рефлекшн:
```
object Point = typeof("System.Drawing.Point, System.Drawing");
object point = Create(Point, 150, 225); //можно так: Point.Create(150, 225)
WriteLine(point->X + "; " + point->Y); //150; 225
```
В этом примере, для создания объекта типа Point, используется базовая функция Create, которой передаются тип и аргументы для конструктора (150 и 225). Стрелка (->) в данном случае — это вызов базовой функции GetMemberValue, которая через рефлекшн получает значение свойства/поля. При загрузке кода последняя строка превращается в:
```
WriteLine(@GetMemberValue(point,"X")+"; "+@GetMemberValue(point,"Y"));
```
Символ @ перед именем функций указывает, что нужно вызывать именно базовую функцию без поиска пользовательской.
Сразу нужно запомнить, что typeof срабатывает на этапе загрузки кода, и заменяется в коде на литерал (ссылку на объект). Получить тип во время выполнения можно функцией GetTypeByName. В большинстве случаев можно писать как typeof(int), так и просто int (по сути, это как константа).
#### Получаем курсы валют
Теперь разберём более сложный пример, в котором с сайта www.cbr-xml-daily.ru загружаются курсы валют в формате JSON, данные десериализируются и выводятся построчно:
```
object JsonDocument=typeof("System.Text.Json.JsonDocument, System.Text.Json"); //получаем тип JsonDocument, который будем использовать для парсинга JSON данных
WriteLine("Загрузка курсов валют..."); //выводим строку, что начинается загрузка данных с сайта
string json=Fetch("https://www.cbr-xml-daily.ru/daily_json.js"); //get-запросом получаем ответ сервера с курсами валют в JSON формате
int i=json.IndexOf("\r\n\r\n"); //ищем два переноса строки, чтобы удалить http-заголовки. json.IndexOf("\r\n\r\n") - это вызов базовой функции IndexOf(json, "\r\n\r\n")
if(i<0 || json.IndexOf(" 200 OK")<0){ //если переносы не найдены, либо в http-ответе нет кода 200 OK
WriteLine("Не удалось загрузить данные!"); //выводим сообщение об ошибке
ReadKey("Нажмите любую клавишу для выхода"); //выводим текст, и начитается ожидание нажатия (а ReadKey() в C# не умеет выводить сообщение)
return; //после нажатия любой клавиши произойдёт завершение работы программы
}
json=json.Substring(i+4); //из http-ответа берём только тело, без заголовка. json.Substring(i+4) - это Substring(json, i+4).
//далее нужно прочитать данные из JSON
object defaultJsonDocumentOptions=Create("System.Text.Json.JsonDocumentOptions, System.Text.Json"); //создаём объект JsonDocumentOptions, который дальше нужно будет передать методу Parse
object docRoot=JsonDocument->Parse(json, defaultJsonDocumentOptions)->RootElement; //сначала статическим методом Parse класса JsonDocument получаем из JSON-строки объект со структурированными данными, а потом из этого объекта получаем корневой элемент
WriteLine("Курсы валют на: "+docRoot->GetProperty("Date")); //из корневого элемента получаем дату обновления данных. GetProperty - это метод структуры System.Text.Json.JsonElement.
/*
теперь взглянем на то, как в JSON хранятся курсы валют:
"AUD": {
"ID": "R01010",
...
},
"AZN": {
"ID": "R01020A",
...
},
"GBP": {
"ID": "R01035",
...
}...
Это перечисление объектов. Далее нужно перебирать и десериализовывать их по одному.
*/
object rates=docRoot->GetProperty("Valute")->EnumerateObject(); //получаем перечислитель объектов c данными по каждой валюте. EnumerateObject - это метод структуры System.Text.Json.JsonElement.
foreach(object item in rates){ //перебираем объекты так же, как в C#.
object val=item->Value; //получаем объект System.Text.Json.JsonElement. Это данные о конкретной валюте. Например:
/*
"ID": "R01010",
"NumCode": "036",
"CharCode": "AUD",
"Nominal": 1,
"Name": "Австралийский доллар",
"Value": 54.0507,
"Previous": 54.137
*/
Valute v=FromJson(val.ToString(), Valute); //десериализуем в объект типа Valute, класс которого прописан в конце программы. FromJson - встроенная функция, которой передаётся json-текст и тип, в экземпляр которого нужно его превратить. val.ToString() - это базовая ToString(val).
//теперь у нас есть экземпляр нашего класса Valute, в котором каждой переменной присвоено соответствующее значение из JSON-структуры, и мы можем просто вывести нужные нам данные
WriteLine($"{v.Nominal} {v.Name.ToLowerFirst()} ({v.CharCode}): {v.Value}"); // выводим через интерполяцию строк номанал валюты, её название и сколько рублей она стоит. v.Name.ToLowerFirst() - это ToLowerFirst(v.Name).
}
/*Результат:
Курсы валют на: 2021-08-07T11:30:00+03:00
1 австралийский доллар (AUD): 54,0507
1 азербайджанский манат (AZN): 43,0432
1 фунт стерлингов Соединенного королевства (GBP): 101,7683
100 армянских драмов (AMD): 14,8383
...
*/
ReadKey(); //ожидает нажатия любой клавиши, после чего программа закрывается
class Valute{ //этот класс повторяет тип данных валюты в JSON-е
public string ID;
public string NumCode;
public string CharCode;
public int Nominal;
public string Name;
public decimal Value;
public decimal Previous;
}
```
Как видим, структурно код такой же, как в C#. Понимаю, что object-переменные выглядят непривычно, но в целом, думаю, код понятен. Можно использовать **подсказки типа**, которые делаются из констант типа при помощи машинописного обратного апострофа:
```
const object Point=typeof("System.Drawing.Point, System.Drawing");
`Point p=Point.Create(10, 20); //интерпретатор знает, что в p должен находиться объект типа Point
WriteLine(p->X); //p->X - это @TGetValue(#Int32 X#,int,p), где #Int32 X# - объект MemberInfo
```
В этом примере p — это object-переменная с подсказкой, что в ней находится экземпляр System.Drawing.Point. Это позволяет ускорить обращение к членам объекта, т.к. интерпретатор будет искать члены (не значения, а MemberInfo) не во время выполнения, а один раз при загрузке кода. Также вы не сможете обычным способом присвоить такой переменной значение неподходящего типа (по ошибке).
Покажу **пару фич**:
1) Кроме привычного try/catch есть очень простой способ перехвата ошибок при вызове функций:
```
string s="test";
WriteLine(s.Substring(9)("error message")); //error message
if(exception!=null) WriteLine("Error: "+exName+" ("+exMessage+")"); //Error: ArgumentOutOfRangeException (startIndex cannot be larger than length of string. (Parameter 'startIndex'))
//exception, exName и exMessage - специальные переменные, в которые записывается информация об исключении
```
Значение во вторых скобках возвращается в случае, если функция выбросила исключение.
Операторы — это функции, поэтому с ними тоже так можно:
```
WriteLine((5/0)(123)); //123
```
2) Выражения можно передавать и выполнять как объекты.
```
Go();
Go(){
int x, y;
object e=Expr(x+y);
Test(e);
}
Test(object e){
int x=2, y=3;
WriteLine(e.Eval(int)); //5
}
```
### Ремонт невозможно закончить — его можно только прекратить
Начал я этот проект в середине декабря 2020-го. Более-менее рабочий прототип был готов, как мне казалось, уже через месяц. Дальше я доделывал и переделывал, и по мере добавления функционала, становилось понятно, что нужно усложнять общую архитектуру. Правка старого кода приводила к его полному переписыванию. У меня было желание выложить всё уже через 2-3 месяца, но постоянно находилось что-то, что требует обязательной доработки.
Надо сказать, что психологически довольно непросто работать долго без фидбэка, особенно если ты пишешь что-то необычное, и непонятно, будет ли это вообще кому-то интересно. Несмотря на то, что ещё много чего нужно доделывать, я решил, что пора уже выложить то, что есть, чтобы понять по отзывам, что нужно сделать/переделать в первую очередь. Я отложил некоторые решения потому, что не уверен в их уместности. Например, нужны мнения о том, какие нестандартные перегрузки операторов добавить. В Python можно "abc"\*3 и получить "abcabcabc". Удобно, но вдруг программист по ошибке пытается умножить строку на число?.. Где грань между допустимыми поблажками и фичами, от которых больше вреда, чем пользы?.. Чтобы избежать холивара, предлагаю обсуждать это исключительно в контексте интерпретаторов, для производительности которых важна лаконичность кода (максимальная автоматизация).
Сейчас в OverScript есть только самое основное. Нет многомерных массивов, интерфейсов, дженериков, лямбд, struct-ов, checked/unchecked и много чего ещё. Что-то добавить легко, что-то сложно, а что-то просто не нужно, ведь OverScript простой интерпретируемый язык, и нецелесообразно добавлять в него всё, что есть в C#.
OverScript ещё тестировать и тестировать. Я постоянно нахожу новые ошибки и код, который можно улучшить. И я практически не оптимизировал загрузку кода, только выполнение. В будущем я планирую сделать кэширование загрузки скрипта, чтобы ускорить повторные запуски.
### Итог
В целом, я доволен результатом, но чувства неоднозначные. Во-первых, получилось лучше, чем ожидал, но многие задуманные фичи пока не реализованы. А во-вторых, у меня сейчас что-то вроде *синдрома самозванца*. Мой код, мягко говоря, неидеален, местами сумбурный, есть временные решения. И кто-то может возмутиться, что вот с этим я чуть ли не на лавры великого Питона покусился. Но, как я уже писал, ниша OverScript — это .NET. Есть Iron-языки, но это вторичные решения со своими легаси-особенностями. OverScript же свободен и лёгок на подъём! И как гласит китайская поговорка (тут представляем известный мем с китайским мудрецом): *Увидеть лучше, чем услышать, познать лучше, чем увидеть, сделать лучше, чем познать.*
Если вам интересен мой проект, то вы можете [поддержать](https://overscript.org/donate) его донатом. Разработка заняла немало времени, и на доработку, скорее всего, уйдёт не меньше. Свои некоммерческие проекты — это здорово, но нужно и деньги как-то зарабатывать. Сейчас **развитие проекта под угрозой**, т.к. из-за сами знаете какой ситуации в России, где я нахожусь, я лишился всех источников дохода, и ваши донаты для меня сейчас единственная возможность продолжить активную работу над проектом.
Если у вас есть вопросы, интересные идеи или даже коммерческие предложения — пишите на support@overscript.org.
Спасибо за внимание, и с нетерпением жду ваших комментариев. Фух… *Хей, хоу, летс гоу!*
|
https://habr.com/ru/post/656035/
| null |
ru
| null |
# Книга «Глубокое обучение в картинках. Визуальный гид по искусственному интеллекту»
[](https://habr.com/ru/company/piter/blog/508938/)Привет, Хаброжители! Глубокое обучение стало мощным двигателем для работы с искусственным интеллектом. Яркие иллюстрации и простые примеры кода избавят вас от необходимости вникать в сложные аспекты конструирования моделей глубокого обучения, делая сложные задачи доступными и увлекательными.
Джон Крон, Грант Бейлевельд и замечательный иллюстратор Аглаэ Бассенс используют яркие примеры и аналогии, которые позволяют объяснить, что такое глубокое обучение, почему оно пользуется такой популярностью и как эта концепция связана с другими подходами к машинному обучению. Книга идеально подойдет разработчикам, специалистам по обработке данных, исследователям, аналитикам и начинающим программистам, которые хотят применять глубокое обучение в своей работе. Теоретические выкладки прекрасно дополняются прикладным кодом на Python в блокнотах Jupyter. Вы узнаете приемы создания эффективных моделей в TensorFlow и Keras, а также познакомитесь с PyTorch.
Базовые знания о глубоком обучении позволят создавать реальные приложения — от компьютерного зрения и обработки естественного языка до генерации изображений и игровых алгоритмов.
### Сеть промежуточной глубины на основе Keras
В завершение этой главы воплотим новые теоретические познания в нейронную сеть и посмотрим, сможем ли мы превзойти предыдущую модель shallow\_net\_in\_keras.ipynb в классификации рукописных цифр.
Первые несколько этапов создания сети промежуточной глубины в блокноте Jupyter intermediate\_net\_in\_keras.ipynb идентичны этапам создания ее предшественницы — неглубокой сети. Сначала загружаются те же самые зависимости Keras, точно так же вносится и обрабатывается набор данных MNIST. Как можно увидеть в листинге 8.1, самое интересное начинается там, где определяется архитектура нейронной сети.
Листинг 8.1. Код, определяющий архитектуру нейронной сети с промежуточной глубиной
```
model = Sequential()
model.add(Dense(64, activation='relu', input_shape=(784,)))
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))
```
Первая строка в этом фрагменте кода, model = Sequential(), та же, что и в предыдущей сети (листинг 5.6); это экземпляр объекта модели нейронной сети. В следующей строке начинаются расхождения. В ней мы заменили функцию активации sigmoid в первом скрытом слое функцией relu, как было рекомендовано в главе 6. Все остальные параметры первого слоя, кроме функции активации, остались прежними: он все так же состоит из 64 нейронов, и прежней осталась размерность входного слоя — 784 нейрона.
Другое существенное изменение в листинге 8.1 по сравнению с неглубокой архитектурой в листинге 5.6 заключается в наличии второго скрытого слоя искусственных нейронов. Вызовом метода model.add() мы без всяких усилий добавляем второй слой Dense с 64 нейронами relu, оправдывая слово intermediate (промежуточная) в имени блокнота. Вызвав model.summary(), можно увидеть, как показано на рис. 8.9, что этот дополнительный слой добавляет 4160 дополнительных обучаемых параметров, по сравнению с неглубокой архитектурой (см. рис. 7.5). Параметры можно разбить на:
* 4096 весов, соответствующих связям каждого из 64 нейронов во втором скрытом слое с каждым из 64 нейронов в первом скрытом слое (64 × 64 = 4096);
* плюс 64 смещения, по одному для каждого нейрона во втором скрытом слое;
* в результате получается 4160 параметров: nпараметров = nw + nb = 4096 + 64 =
= 4160.
Помимо изменений в архитектуре модели мы также изменили параметры компиляции модели, как показано в листинге 8.2.
Листинг 8.2. Код компиляции нейронной сети с промежуточной глубиной
```
model.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=0.1),
metrics=['accuracy'])
```
Эти строки из листинга 8.2:
* задают функцию стоимости на основе перекрестной энтропии: loss='categorical\_crossentropy' (в неглубокой сети использовалась квадратичная стоимость loss='mean\_squared\_error');
* задают метод стохастического градиентного спуска для минимизации стоимости: optimizer=SGD;
* определяют гиперпараметр скорости обучения: lr=0.1**(1)**;
* указывают, что в дополнение к обратной связи о потерях, которая предлагается библиотекой Keras по умолчанию, мы также хотим получить обратную связь о точности модели: metrics=['accuracy']**(2)**.
> **(1)** Вы можете попробовать увеличить скорость обучения на несколько порядков, а затем уменьшить ее на несколько порядков и понаблюдать, как это повлияет на обучение.
>
>
>
> **(2)** Потеря является наиболее важным показателем, позволяющим увидеть, как изменяется качество модели с течением эпох, но конкретное значение потери зависит от характеристик данной модели и, как правило, не поддается интерпретации и не может сравниваться у разных моделей. Поэтому даже зная, что потери должны быть как можно ближе к нулю, часто очень сложно понять, насколько близка к нулю потеря для конкретной модели. Точность, напротив, легко интерпретируется и легко обобщается: мы точно знаем, что это значит (например, «неглубокая нейронная сеть правильно классифицировала 86 процентов рукописных цифр в проверочном наборе данных»), и можем сравнить с точностью любой другой модели («точность 86 процентов хуже, чем точность нашей глубокой нейронной сети»).
Наконец, мы обучаем промежуточную сеть, выполняя код в листинге 8.3.
Листинг 8.3. Код обучения нейронной сети с промежуточной глубиной
```
model.fit(X_train, y_train,
batch_size=128, epochs=20,
verbose=1,
validation_data=(X_valid, y_valid))
```
Единственное, что изменилось в обучении промежуточной сети по сравнению с неглубокой сетью (см. листинг 5.7), — это уменьшение на порядок гиперпараметра epochs с 200 до 20. Как вы увидите далее, более эффективная промежуточная архитектура требует намного меньше эпох для обучения.
На рис. 8.10 представлены результаты первых четырех эпох обучения сети. Как вы наверняка помните, наша неглубокая архитектура достигла плато на уровне 86%-й точности на проверочных данных после 200 эпох. Сеть промежуточной глубины значительно превзошла ее: как показывает поле val\_acc, сеть достигла 92.34%-й точности уже после первой эпохи обучения. После третьей эпохи точность превысила 95%, а к 20-й эпохе, похоже, достигла плато на уровне около 97.6%. Мы серьезно продвинулись вперед!
Разберем подробнее вывод model.fit(), показанный на рис. 8.10:
* Индикатор процесса, показанный ниже, заполняется в течение 469 «циклов обучения» (см. рис. 8.5):
60000/60000 [==============================]
* 1s 15us/step означает, что на все 469 циклов обучения в первую эпоху потребовалась 1 секунда, в среднем по 15 микросекунд на цикл.
* loss показывает среднюю стоимость на обучающих данных для эпохи. Для первой эпохи она равна 0.4744 и от эпохи к эпохе уверенно уменьшается методами стохастического градиентного спуска (SGD) и обратного распространения, а в конечном итоге уменьшается до 0.0332 к двадцатой эпохе.
* acc — точность классификации на обучающих данных в данную эпоху. Модель правильно классифицировала 86.37% после первой эпохи и достигла уровня выше 99% к двадцатой. Поскольку модель может переобучиться, не следует особо удивляться высокой точности в этом параметре.
* К счастью, стоимость на проверочном наборе данных (val\_loss), как правило, тоже уменьшается и в конечном итоге достигает плато на уровне 0.08 в ходе последних пяти эпох обучения.
* Одновременно с уменьшением стоимости на проверочных данных растет точность (val\_acc). Как уже упоминалось, точность на проверочных данных составила 97.6%, что значительно выше 86% у нашей неглубокой сети.
### Итоги
В этой главе мы проделали большую работу. Сначала мы узнали, как нейронная сеть с фиксированными параметрами обрабатывает информацию. Затем разобрались с взаимодействующими методами — функциями стоимости, стохастическим градиентным спуском и обратным распространением, которые позволяют корректировать параметры сети для аппроксимации любого истинного значения y, имеющего непрерывное отношение с некоторым входом х. Попутно мы познакомились с несколькими гиперпараметрами, включая скорость обучения, размер пакета и количество эпох обучения, а также с практическими правилами настройки каждого из них. В завершение главы мы применили новые знания для создания нейронной сети промежуточной глубины, которая значительно превзошла предыдущую неглубокую сеть на той же задаче классификации рукописных цифр. Далее мы познакомимся с методами улучшения стабильности искусственных нейронных сетей по мере их углубления, что позволит нам разработать и обучить полновесную модель глубокого обучения.
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/glubokoe-obuchenie-v-kartinkah-vizualnyy-gid-po-iskusstvennomu-intellektu?_gs_cttl=120&gs_direct_link=1&gsaid=42817&gsmid=29789&gstid=c)
» [Оглавление](https://storage.piter.com/upload/contents/978544611574/978544611574_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544611574/978544611574_p.pdf)
Для Хаброжителей скидка 25% по купону — **Глубокое обучение**
По факту оплаты бумажной версии книги на e-mail высылается электронная книга.
|
https://habr.com/ru/post/508938/
| null |
ru
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.