text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Мощность статистических тестов на единичный корень
Цель данной статьи — поделиться результатами сравнительного исследования мощности статистических тестов на единичные корни [Дики-Фуллера (ADF)](https://habr.com/ru/post/314330/) и [Квятковского, Филлипса, Шмидта и Шина (KPSS)](https://habr.com/ru/post/457794/): в случае около-нестационарных временных рядов тест ADF часто не способен отклонить нулевую гипотезу нестационарности. Это означает, что у теста ADF высокий риск ошибки второго рода, то есть вероятность не отклонить ложную нулевую гипотезу.
В данной статье мы посмотрим, насколько «мощны» тесты ADF и KPSS. Сгенерируем случайный процесс , у которого нет единичного корня (то есть процесс является стационарным), :
и посмотрим, насколько различные статистические тесты распознают данный процесс как стационарный, а также на каких именно  будет фейлиться тест ADF.
План эксперимента
-----------------
Для различных значений  мы сгенерируем 1000 процессов , , где , и посчитаем количество отвергнутых гипотез.
**Тест ADF**: Истинной моделью является , где  с нулевым средним и конечной дисперсией . Мы оцениваем модель . Критические значения для тестовой статистики , где , представлены в таблице ниже.
| | | |
| --- | --- | --- |
| 1% | 5% | 10% |
| -2.57 | -1.94 | -1.62 |
**Тест KPSS**: Истинной моделью является , где ,  с нулевым средним и конечной дисперсией . Мы оцениваем ту же модель с . Критические значения для тестовой статистики множителей Лагранжа, где , представлены в таблице ниже.
| | | |
| --- | --- | --- |
| 1% | 5% | 10% |
| 0.74 | 0.46 | 0.35 |
Начальное значение  влияет на конечное выборочное распределение и в тесте ADF, и в тесте KPSS. На реальном фондовом рынке начальное значение  может варьироваться достаточно широко, например, от 0.00215 до 204 100 (в абсолютных величинах). В данной статье мы проанализируем мощность тестов ADF и KPSS для малых значений .
Генерация случайных процессов
-----------------------------
Начнем с генерации нестационарных случайных процессов при . Во всех последующих таблицах , , а количество генерируемых случайных процессов равно 1000. Генерировать случайные процессы будем в матлабе.
```
T = 500;
count = 1000;
epsilon = zeros(T,count);
for set = 1 : count
epsilon(:,set) = randn(T,1);
end
y = zeros(T,count);
y(1,:) = 0;
for t = 2 : T
y(t,:) = y(t - 1,:) + epsilon(t,:);
end
figure
plot(y(:,1))
title('Simulated RW Process')
```
На рисунке ниже представлен 1 из 1000 сгенерированных нестационарных случайных процессов, который следует модели случайного блуждания ().
Тестирование на разных уровнях значимости
-----------------------------------------
Затем протестируем каждый из сгенерированных случайных процессов тестами ADF и KPSS на различных уровнях значимости (1%, 5% и 10%).
```
h = zeros(count,1);
for set = 1 : count
h(set,1) = adftest(y(:,set),'alpha',0.01);
h(set,2) = adftest(y(:,set));
h(set,3) = adftest(y(:,set),'alpha',0.1);
h(set,4) = kpsstest(y(:,set),'trend',false,'alpha',0.01);
h(set,5) = kpsstest(y(:,set),'trend',false);
h(set,6) = kpsstest(y(:,set),'trend',false,'alpha',0.1);
end
```
Напомню, что методологический подход теста KPSS полностью отличается от подхода теста ADF, главное различие которого следует понимать в перестановке нулевой и альтернативной гипотезой.
В тесте KPSS нулевая гипотеза утверждает, что временной ряд является стационарным, альтернативная гипотеза утверждает наличие нестационарности. Простыми словами, если тест ADF отвечает 1 (true), значит, процесс стационарный. Если тест KPSS отвечает 1 (true), значит, процесс нестационарный.
Соответственно, для того, чтобы посчитать количество рядов, которые выявлены как стационарные тем или иным тестом, нужно воспользоваться следующим кодом.
```
nnz(h(:,1))
nnz(h(:,2))
nnz(h(:,3))
nnz(~h(:,4))
nnz(~h(:,5))
nnz(~h(:,6))
```
Эксперимент для стационарных процессов
--------------------------------------
Теперь сгенерируем и протестируем стационарные случайные процессы с теми же начальными условиями, что и нестационарные процессы, сгенерированные и протестированные выше. Начнём с .
```
phi = 0.1;
z = zeros(T,count);
z(1,:) = 0;
for t = 2 : T
z(t,:) = phi * z(t - 1,:) + epsilon(t,:);
end
figure
plot(z(:,1))
title('Simulated AR(1) Process')
```
На рисунке ниже представлен 1 из 1000 сгенерированных стационарных случайных процессов, который следует авторегрессионной модели первого порядка ().
Протестируем каждый из сгенерированных случайных процессов тестами ADF и KPSS на различных уровнях значимости (1%, 5% и 10%).
```
zh = zeros(count,1);
for set = 1 : count
zh(set,1) = adftest(z(:,set),'alpha',0.01);
zh(set,2) = adftest(z(:,set));
zh(set,3) = adftest(z(:,set),'alpha',0.1);
zh(set,4) = kpsstest(z(:,set),'trend',false,'alpha',0.01);
zh(set,5) = kpsstest(z(:,set),'trend',false);
zh(set,6) = kpsstest(z(:,set),'trend',false,'alpha',0.1);
end
```
Затем посчитаем количество рядов, которые были выявлены как стационарные тем или иным тестом.
```
nnz(zh(:,1))
nnz(zh(:,2))
nnz(zh(:,3))
nnz(~zh(:,4))
nnz(~zh(:,5))
nnz(~zh(:,6))
```
Продолжим тестирование для других значений .
Результаты эксперимента
-----------------------
В таблице ниже показано, сколько раз процесс был выявлен как стационарный для различных тестов и различных значений . Для  количество найденных стационарных процессов соответствует тому, что мы ожидали. Для около-нестационарных процессов  мы получаем много ложно-положительных ответов от теста ADF. Для  мы можем получить ложно-отрицательный ответ от теста KPSS.
| | | |
| --- | --- | --- |
| | Тест ADF | Тест KPSS |
| $\phi$ | 1% | 5% | 10% | 1% | 5% | 10% |
| 0.1 | 1000 | 1000 | 1000 | 981 | 924 | 868 |
| 0.2 | 1000 | 1000 | 1000 | 961 | 885 | 812 |
| 0.3 | 1000 | 1000 | 1000 | 938 | 834 | 731 |
| 0.4 | 1000 | 1000 | 1000 | 893 | 758 | 642 |
| 0.5 | 1000 | 1000 | 1000 | 831 | 665 | 512 |
| 0.6 | 1000 | 1000 | 1000 | 733 | 516 | 353 |
| 0.7 | 1000 | 1000 | 1000 | 586 | 339 | 186 |
| 0.8 | 1000 | 1000 | 1000 | 349 | 145 | 66 |
| 0.9 | 1000 | 1000 | 1000 | 68 | 17 | 4 |
| 0.95 | 988 | 1000 | 1000 | 2 | 0 | 0 |
| 0.975 | 501 | 886 | 981 | 1 | 0 | 0 |
| 0.99 | 79 | 330 | 536 | 1 | 0 | 0 |
| 0.995 | 34 | 155 | 288 | 0 | 0 | 0 |
| 1 | 8 | 46 | 95 | 0 | 0 | 0 |
| 1.01 | 1 | 4 | 5 | 0 | 0 | 0 |
Выводы
------
Как мы видели, тест Дики-Фуллера не способен различить нестационарные и около-нестационарные временные ряды. Это объясняет, почему не выполняется [свойство симметричности отношения коинтеграции](https://habr.com/ru/post/457794/) примерно для 3% пар.
Мной были проанализированы остатки 8 несимметричных пар на Московской бирже за 2019 год:  колебалась от 0.9593 до 0.9716, то есть временной ряд остатков был около-нестационарным.
На практике полезно классифицировать переменные с высокой степенью постоянства во времени (незначительный возврат к среднему) как нестационарные, а переменные со значительной склонностью возврата к среднему — как стационарные.
Однако важно подчеркнуть, что стационарность/нестационарность или, в качестве альтернативы, порядок интегрирования переменной не является в целом свойством экономической переменной, а представляет собой удобную статистическую аппроксимацию, позволяющую различать краткосрочные, среднесрочные и долгосрочные колебания данных.
Если временной ряд пересекает свой средний уровень, скажем, 10 раз, то эконометрический анализ обнаружит значительный возврат к среднему и, следовательно, сделает вывод о том, что временной ряд является стационарным.
Однако если мы расширим горизонт выборки, то можем получить противоречивые результаты. На более широком временном диапазоне эконометрический анализ может сделать вывод о нестационарности временного ряда.
Существует множество аргументов в пользу рассмотрения единичного корня (стохастического тренда) как удобной эконометрической аппроксимации, а не как глубокого структурного параметра.
Например, если временным аспектом нашего исследования является макроэкономическое поведение в среднесрочной перспективе, то большинство макроэкономических переменных проявляют значительную инерционность, согласующуюся с нестационарным, а не стационарным поведением.
Такой временной ряд не будет статистически отличаться от нестационарного процесса, и его рассмотрение в качестве стационарной переменной (на небольшой выборке), скорее всего, сделает статистический анализ невалидным и, следовательно, приведет к неверным экономическим выводам.
В связи с этим не вижу большого смысла перед исследованием на коинтеграцию проверять временной ряд на стационарность. Во-первых, мы можем получить невалидный результат. Во-вторых, даже если процесс действительно будет стационарным на некотором промежутке времени, скорее всего, выборкой мы просто поймали движение в боковике. Однако если мы расширим горизонт анализа, мы увидим в целом нестационарное поведение временного ряда. | https://habr.com/ru/post/530688/ | null | ru | null |
# We need to go deeper: диплинки и кодогенерация
Привет! Мы написали свою систему диплинков на основе кодогенерации. В этой статье поговорим, как мы упростили работу с диплинками и смогли отловить устаревшие, добавили мониторинг и как собрали все диплинки в одной статье в конфлюенсе.
Диплинк — это uri на конкретный ресурс в приложении. Они нужны бизнесу, чтобы упрощать пользовательский опыт. Так вместо нескольких переходов внутри приложения диплинки позволяют направить пользователя на определённый экран в один клик (польза для пользователя) и снимать статистику (польза для бизнеса). Например: на внешней площадке компания разместила баннер, в котором предлагается заказать виртуальную карту, пользователь может кликнуть по баннеру и сразу попасть на экран заказа карты, а бизнес сможет оценить, какая из площадок более эффективна.
Самая большая проблема — это проблема безопасности. Объясню на примере активити, которая открывает веб-страницы. Активити открывается по диплинку, в нём указывается URL в качестве параметра. Один из вариантов атаки — когда злоумышленник может заставить пользователя пройти по диплинку с URL на вредоносный сайт и таким образом провести атаку. Ещё одна из возможных проблем — на некоторых экранах нам нужно валидировать параметры, а это иногда занимает значительную часть активити. Было бы хорошо вынести валидацию в отдельное место.
Ещё у нас бывали случаи, когда маркетинг запускал промо-кампании либо с диплинками, в которых содержались ошибки, либо с устаревшими диплинками, которые уже не поддерживались, и мы могли об этом даже и не узнать. А при заведении новой кампании маркетинг обращался к разработчиками за диплинками и поиск занимал некоторое время. Если разработчик помнил название экрана и диплинк без параметров, то его можно было быстро найти, а если название экрана сразу не вспомнилось, то алгоритм поиска примерно такой: сбилдить проект -> пройти на нужный экран -> посмотреть в логах, какая активити открылась -> пойти в манифест для получения диплинка -> открыть исходных код активити для сбора входных параметров.
Посмотрев на это, мы поняли, что нам нужна единая точка обработки, анализа, мониторинга, и решили выбрать инструмент аннотаций и кодогенерации. Сейчас объявление диплинка у нас выглядит следующим образом.
Пример объявления диплинка для экрана бонуса.
```
@DeepLink(
Uri("qiwi", "bonus"),
description = Description("открыть раздел бонус(кэшбек)")
)
class BonusHandler : ProxyDeepLinkHandler() {
override val activityClass: Class<*> = BonusShowcaseActivity::class.java
}
```
С помощью аннотации `@Deeplink` помечаем обработчик и задаем диплинк, в данном примере диплинк `qiwi://bonus` откроет `BonusShowcaseActivity`.
Во втором примере показано, как производим проверки перед открытием диплинка.
```
@DeepLink(
Uri("qiwi", "bonus"),
description = Description("открыть раздел бонус(кэшбек)")
)
class BonusHandler : DeepLinkHandler() {
@Inject
lateinit var bonusShowcaseFeature: BonusShowcaseFeature
override fun deeplinkData(context: Context, intent: Intent): DeepLinkData {
QiwiApplication.get(context)
.appComponent.inject(this)
val clazz = BonusShowcaseActivity::class.java
val startIntent = Intent(context, claszz).copyIntent(intent)
return bonusShowcaseFeature.deepLinkData(DeepLinkData(startIntent, claszz))
}
}
```
В обработчике проверяем фича флаг `BonusShowcaseFeature` и открываем экран, если флаг включен. Про наши фича флаги можно почитать [в этом посте](https://habr.com/ru/company/qiwi/blog/664152).
Аннотации
---------
```
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.SOURCE)
annotation class DeepLink(
vararg val deepLinks: Uri,
val description: Description = Description(),
val commonParams: Array = [],
val addToDoc: Boolean = true
)
@Retention(AnnotationRetention.SOURCE)
annotation class Uri(
val scheme: String,
val hostPath: String,
val description: Description = Description(),
val parameters: Array = [],
val examples: Array = [],
val addToDoc: Boolean = true
)
@Retention(AnnotationRetention.SOURCE)
annotation class Description(
val description: String = "",
val group: String = Groups.OTHER
)
@Retention(AnnotationRetention.SOURCE)
annotation class Parameter(
val key: String = "",
val value: String = "",
val description: String = ""
)
@Retention(AnnotationRetention.SOURCE)
annotation class Example(
val description: String,
val parameters: Array = []
)
```
Сейчас в системе у нас пять аннотаций.
1. **Deeplink** — используется для описания одно или нескольких uri, также есть возможность добавить описание, общие параметры для всех uri и можно указать, попадёт ли данный диплинк в документацию.
2. **Uri** — позволяет установить диплинк(scheme://hostPath), дополнительно можно оставить описание, параметры, с которыми используется диплинк, и, если необходимо, добавить примеры.
3. **Description**— используется для описания. Можно указать группу, в которой содержится диплинк, это необходимо для сортировки в итоговой документации.
4. **Parameter**— аннотация задаёт query-параметры в формате key-value, в value описываем возможные значения.
5. **Example** — используется для примеров.
Аннотация `Deeplink` указывает, какой обработчик будет обрабатывать диплинк из аннотации Uri. Все обработчики являются наследниками класса `DeepLinkHandler`.
```
class DeepLinkData(
val startIntent: Intent?,
val activityClazz: Class<*>?
)
abstract class DeepLinkHandler {
var analytics: DeepLinkHandlerAnalytics? = null
abstract fun deeplinkData(context: Context, intent: Intent): DeepLinkData
fun process(context: Context, intent: Intent) {
val deepLinkData = deeplinkData(context, intent)
deepLinkData.startIntent?.let { startIntent ->
context.startActivity(startIntent)
}
}
}
```
Абстрактный класс, который умеет открывать активити по интенту и отправлять аналитику. При наследовании от этого класса нужно реализовать метод `deeplinkData` и в нём можно проводить обработку диплинка.
В случае, когда не нужно проводить проверку диплинка, мы используем `ProxyDeeplinkHandler`.
```
abstract class ProxyDeepLinkHandler : DeepLinkHandler() {
protected abstract val activityClass: Class<*>
override fun deeplinkData(context: Context, intent: Intent): DeepLinkData {
val startIntent = Intent(context, activityClass).copyIntent(intent)
return DeepLinkData(startIntent, activityClass)
}
}
```
При наследовании от этого класса в дочернем классе достаточно определить поле `activityClass`, который должен возвращать ту активити, которую нужно открыть.
Архитектура диплинков
---------------------
Под капотом всё работает немного сложнее. Точкой входа у нас является `SplashActivity`. Она с помощью `DeepLinkDelegate`и остальных компонентов достаёт из реестра нужный обработчик для того диплинка, который пришёл в систему.
Манифест для `SplashActivity` выглядит следующим образом.
```
...
```
В манифесте есть два интент-фильтра для диплинков. Первый для диплинков — со схемой `qiwi`, что позволяет открывать любые диплинки с этой схемой. Во втором интент-фильтр используется для url-диплинков. Мы редко добавляем url-диплинки, поэтому манифест практически не редактируем.
Кодогенерация
-------------
Во время кодогенерации происходит поиск всех классов, помеченных аннотацией `Deeplink`, потом с помощью Kotlin Poet создаются несколько `DeeplinkRegistry` и json-файл с описанием диплинков для документации.
`DeeplinkRegistry` — это интерфейс с методом `registry()`, возвращающий мапу, где ключ - диплинк, а значение — класс обработчика.
Пример сгенерированного `DeeplinkRegistry` для диплинков uri:
```
public class OuterDeepLinkRegistryGenerated : DeepLinkRegistry {
public override fun registry(): Map> {
val map = mutableMapOf>()
map["qiwi://bonus"] = BonusHandler::class.java
map["qiwi://main.action"] = MainHandler::class.java
map["qiwi://cards/detail"] = CardDetailActivityHandler::class.java
...
map["qiwi://help"] = ProfileActivityHandler::class.java
return map
}
}
```
Json-файл с описанием диплинков выглядит так:
```
{
"qiwi://bonus": {
"description": "открыть раздел бонус(кэшбек)"
},
"qiwi://qvc/order": {
"group": "QIWI-карты",
"description": "заказ qvc или qvc_mir карты",
"parameters": [
{
"name": "alias",
"value": "qvc | qvc-mir"
}
]
},
"qiwi://cards/detail": {
"group": "QIWI-карты",
"description": "детали карты",
"parameters": [
{
"name": "id",
"value": "*",
"description": "id карты"
}
]
}
}
```
Из этого файла создается документация.
Документация — это большая таблица, в которой перечислены все диплинки с описанием и параметрами из json-файла.
Таблица всегда актуальная, так как выгрузка json-файла встроена в релизный пайплайн. С помощью таски файл загружается на статик-сервер. А в конфлюенсе настроена таблица, которая подгружает и парсит json-файл.
Таблица в первую очередь полезна отделу маркетинга, так как позволяет быстро получить инфу по диплинкам.
В системе диплинков мы добавили мониторинг и аналитику. И получаем события о необработанных диплинках. Алерты настроены на почту и в телеграм-канал, что позволяет быстро реагировать на инциденты.
Проблему с безопасностью в WebView, о которой писал выше, мы решили следующим образом: в обработчике для активити с WebView проверяем по белому списку урл, который приходит с диплинком, если урл содержится в списке, то открываем веб-страницу.
Итоги
-----
1. Упростили работу с диплинками, например, в обработчике проверяем фича флаг, проводим валидацию параметров.
2. Повысили безопасность активити с WebView, завели whitelist, по которому определяется, будет ли открыта веб-страничка или нет, если приходит диплинк с урлом не из белого списка, то кидаем событие в мониторинг.
3. Добавили мониторинг в систему диплинков.
4. Улучшили жизнь специалистам из маркетинга, они получили всегда актуальную таблицу с диплинками.
5. Отловили все устаревшие и кривые диплинки, которые использовались в промо-материалах. | https://habr.com/ru/post/673850/ | null | ru | null |
# Определение кодировки текста в PHP, часть 2 — биграммы
[В прошлой статье](http://habrahabr.ru/blogs/php/107945/) был реализован алгоритм автоматического определения кодировки текста на основе частот распределения символов. [В комментариях отметили](http://habrahabr.ru/blogs/php/107945/#comment_3411483): если использовать биграммы (триграммы), результат будет более точный. Тогда я отмахнулся, мол, и на одиночных символах неплохой результат получается. Но сейчас подумал, что неплохо было бы добавить надежности и точности в алгоритм, тем более использование биграмм вместо одиночных символов сильно кушать не просит.
Под катом — пример реализации алгоритма на биграммах, исходники и результаты его работы.
#### Описание алгоритма
Как всегда — будем работать только с однобайтовыми русскими кодировками. Для определения UTF-8 смысла писать такой алгоритм нету: она определяется очень просто:
```
$str_utf8 = 'Русский текст';
$str_cp1251 = iconv('UTF-8', 'Windows-1251', $str_utf8);
var_dump(preg_match('#.#u', $str_utf8));
var_dump(preg_match('#.#u', $str_cp1251));
```
```
m00t@m00t:~/workspace/test$ php detect_encoding.php
int(1)
int(0)
```
Итак, берем достаточно большой русский текст и замеряем вместо частот букв частоты пар букв (я традиционно взял Войну и Мир). Получаем что-то в этом роде (тут показаны не частоты, а кол-во упоминаний в тексте, что фактически одно и то же):
```
php
return array (
'аа' = 3,
'аб' => 1127,
'ав' => 5595,
'аг' => 1373,
'ад' => 3572,
'ае' => 1483,
'аё' => 0,
'аж' => 1931,
....
'яс' => 1325,
'ят' => 2439,
'яу' => 1,
'яф' => 1,
'ях' => 284,
'яц' => 70,
'яч' => 254,
'яь' => 0,
'яы' => 0,
'яъ' => 0,
'яэ' => 0,
'яю' => 185,
'яя' => 283,
);
```
Далее конвертируем это дело во все нужные кодировки, при этом добавляем еще варианты с разным регистром символов (заодно сконвертируем кол-во упоминаний в частоту):
```
php return array (
'аа' = 2.5816978277594E-6,
'Аа' => 2.5816978277594E-6,
'аА' => 2.5816978277594E-6,
'АА' => 2.5816978277594E-6,
'аб' => 0.00096985781729497,
'Аб' => 0.00096985781729497,
'аБ' => 0.00096985781729497,
'АБ' => 0.00096985781729497,
'ав' => 0.0048148664487714,
'Ав' => 0.0048148664487714,
'аВ' => 0.0048148664487714,
'АВ' => 0.0048148664487714,
...
'яы' => 0,
'Яы' => 0,
'яЫ' => 0,
'ЯЫ' => 0,
'яъ' => 0,
'Яъ' => 0,
'яЪ' => 0,
'ЯЪ' => 0,
'яэ' => 0,
'Яэ' => 0,
'яЭ' => 0,
'ЯЭ' => 0,
'яю' => 0.0001592046993785,
'Яю' => 0.0001592046993785,
'яЮ' => 0.0001592046993785,
'ЯЮ' => 0.0001592046993785,
'яя' => 0.00024354016175197,
'Яя' => 0.00024354016175197,
'яЯ' => 0.00024354016175197,
'ЯЯ' => 0.00024354016175197,
);
```
Таких файликов у меня получилось три — по одному на каждую кодировку: cp1251, koi8-r, iso8859-5.
Теперь, когда нам нужно узнать кодировку неизвестного текста, мы проходимся по нему, вычленяем все пары символов и прибавляем к «весу» каждой кодировки частоту этой пары символов по уже сгенерированным спектрам.
#### Результаты работы
Закомментированные массивы — суммарные весы пар символов в тексте для соответствующей кодировки, поделенные на сумму для всех подировок ([см. test\_detect\_encoding.php:21](https://github.com/m00t/detect_encoding/blob/master/test_detect_encoding.php#L21)). Т.е. можно сказать, что это вероятности того, что текст именно в этой кодировке.
```
$data = iconv('UTF-8', 'iso8859-5', 'Короткая русская строка');
/*
array(3) {
["windows-1251"]=>
float(0.071131587263965)
["koi8-r"]=>
float(0.19145038318717)
["iso8859-5"]=>
float(0.73741802954887)
}
*/
$data = iconv('UTF-8', 'windows-1251', 'Короткая русская строка');
/*
array(3) {
["windows-1251"]=>
float(0.95440659551352)
["koi8-r"]=>
float(0.044353550201316)
["iso8859-5"]=>
float(0.0012398542851665)
}
*/
$data = file_get_contents('test/cp1251_1.html'); // это какая-то сохраненная страничка в cp1251
/*
array(3) {
["windows-1251"]=>
float(0.78542385878465)
["koi8-r"]=>
float(0.18514302234077)
["iso8859-5"]=>
float(0.029433118874583)
}
*/
```
Как видим, получается очень даже неплохой результат — даже на маленьких строках верная кодировка лидирует почти на порядок.
Все исходники со сгенерированными спектрами для трех однобайтовых кодировок (конечно, для русского языка) можно [скачать на гитхабе](https://github.com/m00t/detect_encoding/). Я намеренно не оформлял все это дело в виде реюзабельной либы, потому что там кода-то всего на сотню строк. Если кому будет необходимо, он сможет сам для себя оформить как ему нравится и как навязывает тот или иной используемый фреймворк. | https://habr.com/ru/post/127658/ | null | ru | null |
# RAML-роутинг в Play Framework
[Play framework](https://www.playframework.com/documentation/2.5.x/Home) — очень гибкий инструмент, но информации о том, как изменить [формат route-файла](https://www.playframework.com/documentation/2.5.x/ScalaRouting#The-routes-file-syntax), на просторах интернета мало. Я расскажу о том, как можно заменить стандартный язык описания маршрутов на основе route-файла на описание в формате [RAML](http://raml.org/). А для этого нам придется создать [свой SBT-плагин](https://github.com/bavadim/raml2play).
В двух словах о RAML (RESTful API Modeling Language). Как совершенно справедливо сказано на главной странице проекта, этот язык существенно упрощает работу с API приложения на протяжении всего его жизненного цикла. Он лаконичен, легко переиспользуется, и что самое ценное — в равной степени легко читается машиной и человеком. То есть можно воплотить подход documentation as a code, когда один артефакт (RAML-скрипт) становится точкой входа для всех участников процесса разработки — аналитиков, тестировщиков и программистов.
Постановка задачи
-----------------
Наша команда работает над большой и сложной [системой онлайн-банкинга](https://rbo.raiffeisen.ru/). Особое внимание уделяется документированию интерфейсов и тестам. Однажды я задался вопросом, можно ли объединить тесты, документацию и кодогенерацию. Оказалось, что до определенной степени это возможно. Но для начала пара слов о том, зачем нам это понадобилось.
В большом проекте особое значение имеет документирование интерфейсов. Аналитики, разработчики сервисов и клиентских приложений должны иметь описание API системы, над которой они работают. Аналитикам важна документация в удобном для чтения виде, программисты в конечном счете описывают интерфейс в коде, причем разные команды пишут код на разных языках. Информация многократно дублируется, что затрудняет её синхронизацию. Когда команд много, почти невозможно вручную гарантировать соответствие друг другу различных форматов API. Поэтому к решению этой проблемы мы подошли основательно.
Для начала мы выбрали единый для всех команд формат описания API. Им стал RAML. Далее нам нужно было бы гарантировать (насколько это возможно), что наши сервисы соответствуют описанию, а клиентские приложения работают с описанными сервисами. Для этого мы используем инструменты тестирования, о которых я расскажу в другой статье. И последним шагом стало внедрение кодогенерации, которая создает за нас код на основе данных из RAML. Сегодня речь пойдет об инструментах кодогенерации, используемых в проекте сервера.
Обычно в документации содержится информация о конечных точках REST, описание параметров и тела запроса, HTTP-коды и описание ответов. При этом для всех вышеперечисленных элементов часто указываются примеры. Этой информации вполне достаточно для тестирования работоспособности конечной точки — просто нужно взять пример запроса для неё и отослать на сервер. Если у конечной точки есть параметры, то их значения нужно также взять из примеров. Пришедший ответ сравнить с примером ответа или провалидировать его JSON-схему на основании документации. Чтобы примеры ответов соответствовали ответам сервера, тот должен работать с правильными данными в БД. Таким образом, при наличии БД с тестовыми данными и документации API сервиса с описанием ответов и примерами запросов, мы можем обеспечить простое тестирование работоспособности нашего сервиса. О нашей документации, системе тестирования и БД сейчас я упомянул для полноты картины, и мы о них обязательно поговорим в другой раз. Здесь же я расскажу о том, как на основании такой документации генерировать как можно больше полезного серверного кода.
Наш сервер написан на Play 2.5 и предоставляет REST API своим клиентам. Формат обмена данными — JSON. Стандартное описание API в Play framework находится в файле conf/route. Синтаксис этого описания прост и ограничивается описанием имен конечных точек и их параметров, а также привязкой конечных точек к методам контроллера в файле routes. Нашей целью будет замена стандартного синтаксиса на описание в формате RAML. Для этого нам нужно:
1. Разобраться, как в Play устроена маршрутизация и как обрабатываются route-файлы.
2. Заменить стандартный механизм маршрутизации на наш механизм, использующий RAML.
3. Посмотреть на результат и сделать выводы :)
Итак, давайте по порядку.
**Роутинг в Play framework
------------------------**
Play framework рассчитан на использование с двумя языками — Scala и Java. Поэтому для описания маршрутов авторы фреймворка не стали использовать DSL на базе какого-то конкретного языка, а написали свой язык и компилятор к нему. Далее я буду говорить про Scala, но всё сказанное справедливо и для Java. Play-приложение собирается с помощью [SBT](http://www.scala-sbt.org/). Во время сборки проекта route-файлы компилируются в файлы на Scala или Java, и далее результат компиляции используется при сборке. За обработку route-файла отвечает SBT-плагин com.typesafe.play.sbt-plugin. Давайте посмотрим, как он работает. Но для начала пару слов об SBT.
Основным понятием SBT является ключ. Ключи бывают двух типов: TaskKey и SettingsKey. Первый тип используется для хранения функций. Каждое обращение к этому ключу приводит к вызову этой функции. Второй тип ключа хранит константу и вычисляется один раз. Compile — это TaskKey, в процессе выполнения он вызывает другой TaskKey, sourceGenerators, для кодогенерации и создания исходных файлов. Собственно SBT-plugin добавляет функцию обработки route-файла к sourceGenerators.
Обычно на основе route создается два основных артефакта — файл target/scala-2.11/routes/main/router/Routes.scala и target/scala-2.11/routes/main/controllers/ReverseRoutes.scala. Класс Routes используется для маршрутизации входящих запросов. ReverseRoutes используется для вызова конечных точек из кода контроллеров и view по имени конечной точки. Давайте проиллюстрируем вышесказанное примером.
**conf/routes**
```
GET /test/:strParam @controllers.HomeController.index(strParam)
```
Тут мы объявляем параметризованную конечную точку и мапим её на метод HomeController.index. В результате компиляции этого файла получается следующий код на Scala:
**target/scala-2.11/routes/main/router/Routes.scala**
```
class Routes(
override val errorHandler: play.api.http.HttpErrorHandler,
HomeController_0: javax.inject.Provider[controllers.HomeController],
val prefix: String
) extends GeneratedRouter {
...
private[this] lazy val controllers_HomeController_index0_route = Route("GET",
PathPattern(List(
StaticPart(this.prefix),
StaticPart(this.defaultPrefix),
StaticPart("test/"),
DynamicPart("strParam", """[^/]+""",true)
))
)
private[this] lazy val controllers_HomeController_index0_invoker = createInvoker(
HomeController_0.get.index(fakeValue[String]),HandlerDef(
this.getClass.getClassLoader,
"router","controllers.HomeController","index",
Seq(classOf[String]),"GET","""""",this.prefix + """test/""" + "$" + """strParam<[^/]+>""")
)
def routes: PartialFunction[RequestHeader, Handler] = {
case controllers_HomeController_index0_route(params) =>
call(params.fromPath[String]("strParam", None)) { (strParam) =>
controllers_HomeController_index0_invoker.call(HomeController_0.get.index(strParam))
}
}
}
```
Этот класс занимается маршрутизацией входящих запросов. В качестве аргументов ему передаются ссылка на контроллер (точнее, инжектор, но это не существенно) и префикс URL пути, который настраивается в конфигурационном файле. Далее в классе объявлена «маска» маршрутизации **controllers\_HomeController\_index0\_route**. Маска состоит из HTTP-глагола и паттерна маршрута. Последний состоит из частей, каждая соответствует элементу URL пути. StaticPart определяет маску для неизменной части пути, DynamicPart задает шаблон для URL параметра. Каждый входящий запрос попадает в функцию routes, где сопоставляется с доступными масками (в нашем случае она одна). Если совпадений не найдено — клиент получит 404 ошибку, в противном случае будет вызван соответствующий обработчик. В нашем примере обработчик один — это **controllers\_HomeController\_index0\_invoker**. В обязанности обработчика входит вызов метода контроллера с нужным набором параметров и трансформация результатов этого вызова.
**target/scala-2.11/routes/main/controllers/ReverseRoutes.scala**
```
package controllers {
class ReverseHomeController(_prefix: => String) {
...
def index(strParam:String): Call = {
import ReverseRouteContext.empty
Call("GET", _prefix + { _defaultPrefix } +
"test/" +
implicitly[PathBindable[String]].unbind("strParam", dynamicString(strParam)))
}
}
}
```
Этот код позволяет нам обращаться к конечной точке через соответствующую функцию, например, во view.
Итак, чтобы сменить формат описания маршрутов нам достаточно написать свой генератор файла Routes. ReverseRoutes нам не нужен, так как наш сервис отдает JSON и view у него нет. Чтобы наш генератор сработал, нужно включить его. Можно копировать исходники генератора в каждый проект, где он нужен, а далее подключать его в build.sbt. Но правильнее будет оформить генератор в виде плагина к SBT.
**Плагин SBT
----------**
О плагинах SBT исчерпывающе [написано](http://www.scala-sbt.org/0.13/docs/Using-Plugins.html) в документации. Тут я упомяну об основных, на мой взгляд, моментах. Плагин — это набор дополнительной функциональности. Обычно плагины добавляют в проект новые ключи и расширяют существующие. Нам, например, нужно будет расширить ключ sourceGenerators. Одни плагины могут зависеть от других, например, мы могли бы использовать в качестве основы плагин com.typesafe.play.sbt-plugin и изменить в нем только то, что нам нужно. Другими словами наш плагин зависит от com.typesafe.play.sbt-plugin. Чтобы SBT автоматически подключал все зависимости для нашего плагина, тот должен быть [AutoPlugin'ом](http://www.scala-sbt.org/0.13/docs/Using-Plugins.html#Enabling+and+disabling+auto+plugins). Ну и последнее: из-за вопросов совместимости плагины пишутся на Scala 2.10.
Итак, нам нужно генерировать Routes.scala на основе файла RAML. Пусть этот файл называется conf/api.raml. Чтобы документацию в RAML-формате можно было использовать для маршрутизации, необходимо каким-то способом указать в нем для каждой конечной точки метод контроллера, который необходимо вызвать при получении запроса. RAML 0.8, который мы будем использовать, не имеет средств для указания такой информации, поэтому придется делать грязный хак (RAML 1.0 решает эту проблему с помощью аннотаций, но на момент написания статьи эта версия стандарта еще сыра). Добавим информацию о вызываемом методе контроллера в первую строку description для каждой конечной точки. Наш пример в RAML-формате из предыдущей главы будет выглядеть так:
```
/test/{strParam}:
uriParameters:
strParam:
description: simple parameter
type: string
required: true
example: "some value"
get:
description: |
@controllers.HomeController.index(strParam)
responses:
200:
body:
application/json:
schema: !include ./schemas/statements/operations.json
example: !include ./examples/statements/operations.json
```
На деталях парсинга RAML останавливаться не буду, скажу лишь, что можно использовать [парсер от raml.org.](https://github.com/raml-org/raml-java-parser) В результате парсинга мы получаем список правил — по одному на каждую конечную точку. Правило задается следующим классом:
```
case class Rule(verb: HttpVerb, path: PathPattern, call: HandlerCall, comments: List[Comment] = List())
```
Названия и типы полей говорят сами за себя. Теперь для каждого правила мы можем в файле Routes.scala создать свою маску, обработчик и элемент case в функции route. Для решения этой задачи можно вручную генерировать строку с кодом Routes.scala на основе списка правил, или применить макросы. Но лучше выбрать промежуточный вариант, который предпочли и разработчики Play — использовать шаблонизатор. PВ Play применяется шаблонизатор [twirl](https://github.com/playframework/twirl), и мы тоже его используем. Вот шаблон из нашего плагина, генерирующий функцию route:
```
def routes: PartialFunction[RequestHeader, Handler] = @ob
@if(rules.isEmpty) {
Map.empty
} else {@for((dep, index) <- rules.zipWithIndex){@dep.rule match {
case route @ Rule(_, _, _, _) => {
case @(routeIdentifier(route, index))(params) =>
call@(routeBinding(route)) @ob @tupleNames(route)
@paramsChecker(route) @(invokerIdentifier(route, index))
.call(@injectedControllerMethodCall(route, dep.ident, x => safeKeyword(x.name)))@cb
}
}}}@cb
```
Выглядит несколько запутанно, но если присмотреться, то всё становится ясно. Выражения, начинающиеся с @ — это директивы и переменные шаблонизатора. Переменные @ob и @cb будут раскрыты в { и } соответственно. А, например, **@(routeIdentifier(route, index))** развернется по следующему правилу:
```
def routeIdentifier(route: Rule, index: Int): String = route.call.packageName.replace(".", "_") +
"_" + route.call.controller.replace(".", "_") +
"_" + route.call.method + index + "_route"
```
Теперь ясно, как написать код, создающий Routes.scala на основе RAML, и понятно, как подключить его к сборке. Исходники готового плагина лежат на [Github](https://github.com/bavadim/raml2play).
**Планы на будущее
----------------**
Плагин позволил нам использовать документацию в качестве исходного кода для сервера. Но кодогенерация не использует всей доступной информации из RAML-файла. А именно, мы никак не используем информацию о типе запроса и ответа. В Play парсинг запроса и генерация ответа происходит в методах контроллера, но мы хотим генерировать этот код автоматически. Кроме того, у нас в планах использовать версию RAML 1.0.
На сегодня всё, спасибо за внимание! | https://habr.com/ru/post/332638/ | null | ru | null |
# Жжем и зажигаем! Логически
История про то как добавить терминалу (Uni-Ubi) то, чего у него не было от рождения с помощью M5Stack на ESP32?
Uni-Ubi и M5StackВ наши ковидные времена стало прилетать все больше вопросов про термометрию и бесконтактную биометрию. Не смотря, на то, что до недавнего времени мы, как и многие ИТ-компании с удовольствием не касались этой темы, считая её больше СБ-шной, волею обстоятельств вопрос-таки пришел и к нам. Не прямым путем, но пришлось вникнуть.
Являясь подрядчиком одной из выставочной компании по сетевым делам, нас периодически привлекают к совершенно непрофильным, на первый взгляд, задачам. Видимо, руководствуясь мнением, что все, включаемое в локальную сеть – это к айтишному подрядчику.
Итак, перед очередной выставкой «умных технологий и IoT» от наших выставочников поступило ТЗ, которые мы сразу даже рассматривать не стали. Однако клиент настаивал и пришлось взяться.
**Задача формулировалась так:** необходимо было усовершенствовать, имеющуюся у них, систему контроля температуры на базе терминалов биометрического распознавания лиц, добавив явную визуальную индикацию в виде светодиодной ленты. При этом индикация на ленте должна зависеть от температуры распознаваемого объекта.
**Как это должно работать:** при распознавании лица терминал измеряет температуру лба, в зависимости от неё светодиодная лента загорается либо зеленым, в случае если температура ниже порогового значения, либо красным, если температура выше. Так же лента должна иметь промежуточную нейтральную индикацию (например, белую) пока терминал находится в режиме ожидания.
На первый взгляд задача показалась более чем простой – замкнуть в терминале реле №1, если температура нормальная и замкнуть реле №2, если температура повышенная. Белую LED линейку можно просто разрывать при подаче питания на реле 1 или реле 2.
Но, как водится, если вы обрадовались простоте задачи, — ждите подвоха. Так и вышло.
Когда к нам привезли на пробы терминал доступа по лицу (им оказался Uni-Ubi Uface 8T-Temp) мы поняли, что рано радовались.
…у него оказался ровно ОДИН! релейный выход. И вот это было фиаско, рубившее на корню всю идею быстро что-то прикрутить, быстро сдать и при этом чего-то заработать.
К самому терминалу 8t-Temp по итогам первичных ознакомительных тестов у нас вопросов не было. Это достаточно популярная штука c болометром «во лбу». По субъективным впечатлениям очень быстрый, интерактивный, лицо ловит метров с двух – достаточно мимо проходя чуть попасть его поле зрения. Температуру измеряет тоже достаточно точно, контроль наличия маски имеет. Сценарии на реле также отрабатывает четко. Но нашей задачи это не решает. Следовательно, надо лезть внутрь и разбираться как можно развязаться логически с помощью внешних устройств.
**Изучаем пациента и ищем варианты!**
Пришедшая к нам выставочная конструкция представляла из себя следующий набор:
- Блок автономного питания терминала с аккумуляторами на много часов работы
- Металлическая трубостойка, прикрученная к блоку автономного питания
- Собственно сам терминал Uface 8T-Temp.
Вдоль трубостойки по всей высоте была нехитрым образом приклеена зеленая LED- подсветка с принципом работы, простым как палка – она загоралась по замыканию реле терминала, только если температура нормальная, а если нет – не загоралась. В принципе это вполне рабочая схема, минусом является только то, что когда на входе в зал стоит таких стоек не одна, а 20, то издали не понятно почему терминал не дает прохода посетителю: то ли он сам «залип», то ли температура неправильная, то ли индикация отвалилась.
Иначе говоря, вы подходите к терминалу, он вас измеряет, обнаруживает, что у вас повышенная температура и на экране выдается не очень приметная надпись о том, что «у вас повышенная температура». При этом с индикацией ничего не происходит. То есть, если вы идете быстро, а контролер на входе отвернулся в этот момент, то вы спокойно проходите мимо, и никто этого не заметит. Вероятно, наши заказчики это вполне осознали и стали срочно искать варианты более понятной визуализации события.
Первое что, что пришло в голову как-то повлиять на сам терминал и получить желаемый логический вариант ресурсами его процессора. Под капотом терминала Uni-Ubi стоит проц ARM Cortex-A7. Принципиально его бы хватило на что угодно, но ввиду самозамкнутости и защищенности изделия никакого доступа к его логике извне нет. Терминал работает на базе Linux, поверх которого крутится их собственное Юни-Юбишное проприетарное ядро распознавания лиц, GUI и контроль обвеса, включая интерфейсы. Все закрыто и забито гвоздями от любопытствующих, поэтому исполнить свой код внутри терминала не представлялось возможным от слова совсем.
К счастью, у Юни-Юби оказался крайне обширный API (есть и SDK). Он полностью открытый и в нем есть описания примерно на 99% процедур и событий, обрабатываемых на терминале.
Таким образом задача сводилась к тому, чтобы изучить API, получить описания требуемых переменных, получаемых по call-back ответам на запросы и далее и далее введя параметры оценки, полученных значений отработать их по оговоренному сценарию.
Принципиально это достаточно простая задача, даже для начинающего программера. И мы решились попробовать.
Оставалось выбрать то, на чем будем генерировать запросы, собственно запрашивать и обрабатывать полученное в ответ от терминала. Первое, что пришло в голову, — это конечно платка на базе Arduino, но мы пока не понимали, где должно крепиться готовое устройство, поэтому выбор склонялся в сторону чего-то в культурном собственном корпусе. Времени и желания на конструирование корпуса у нас не было.
Посмотрев на разные варианты было решено использовать продукт на базе микроконтроллера ESP32 как достаточный с запасом и гибко программируемый. Ввиду, того, что нужно было сделать всё быстро и аккуратно, без торчащих проводов, мы применили модули на ESP-32 от M5Stack. Аргументом в их пользу стала цена ниже Raspberry PI, очень простая соединяемость без пайки и наличие собственного корпуса у большинства девайсов этого «конструктора для взрослых».
**Компоненты системы:**
* Контроллер M5Stack BASIC на ESP32-D0WDQ6 <https://clck.ru/ZLhDo>
* Основание M5Stack Bottom с сигнальными выводами <https://clck.ru/ZLhMm>
* Светодиодная лента M5Stack LED Bar на 288 светодиодов <https://clck.ru/ZLi4q>
* Ну и сам пациент — Терминал Uni-Ubi UFACE 8T-TEMP вместе со стойкой <https://clck.ru/ZLhSU>
Компоненты проекта**Обмен данными между терминалом и контроллером:**
Терминал Uni-Ubi имеет несколько проводных интерфейсов для отправки данных, среди них был выбран, на мой взгляд, самый простой – Wiegand. С него в обычном случае мы получаем коды лица (карты) и пр., но получим ли мы с него переменные по температуре -- это вопрос. Идея первоначально была в том, чтобы либо сразу после измерения температуры получать значения температуры на Wiegand вместе с FaceID автоматом, либо инициировать это действие по Json запросу от M5Stack по некой синхронизации с событием измерения температуры.
Чтобы, понять, что мы получаем на Wiegand терминала по запросу необходимо посмотреть на посылку данных при распознавании лица и найти там сведения о температуре. Для это я написал простенькую программы вывода в serial получаемой информации:
Подключение M5Stack к Uni-Ubi по Wiegand
```
#include
#include
WIEGAND wg;
void setup() {
Serial.begin(115200); //Инициализируем сериал порт
wg.begin(2, 5); //подключенные Wiegand D0 и D1 к пинам 2, 5
M5.begin();
}
void loop() {
if (wg.available()) //Если по Wiegand пришла посылка
{
Serial.print(wg.getCode()); //выводим ее в Serial
}
}
```
Тут я столкнулся с проблемой, в посылке присутствовал только идентификационный номер клиента. В настойках терминала нельзя добавить дополнительную информацию для передачи по Wiegand. Однако у Uni-Ubi есть встроенный модуль реле, настроив его на срабатывание при отрицательном результате распознавания, система будет скомплексирована. Таким образом при получении данных по Wiegand и по срабатывании реле можно однозначно определить какая индикация будет на светодиодной ленте. Правда это выглядит не как оптимальное решение, а как «колхоз», да и реле может в дальнейшем понадобиться для других задач, например, если терминалы будут врезаны в выставочные турникеты.
**Web-server на M5Stack и получение POST-запросов:**
От идеи с Wiegand пришлось отказаться и отдать предпочтения сильным сторонам ESP32, а именного встроенному модулю Wi-Fi, благо в терминале Uni-Ubi WIFI модуль тоже есть. Осталось лишь настроить их взаимодействие.
Отметим, что в дальнейшем, при массовом внедрении, мы все же перешли на проводное подключение, добавив в конструкцию сетевое основание [M5Stack LAN-W5500](https://m5stack.pro/modulnye-osnovaniya/lan-w5500). Так безусловно надежнее и секурнее, но на этапе отладки идеи взаимодействие по Wi-Fi не потребовало никаких добавок и поэтому было выбрано «здесь и сейчас».
На M5Stack с помощью дополнительных библиотек достаточно просто настроить веб сервер.
```
#include
#include
const char \*ssid = "\*\*\*\*\*\*";
const char \*password = "\*\*\*\*\*\*\*";
boolean flagEmptyLine = true; // признак строка пустая
WiFiServer server(80);
String header;
char clientAlreadyConnected = false;
void setup(void) {
Serial.begin(115200);
M5.begin();
WiFi.begin(ssid, password);
Serial.println("");
while (WiFi.status() != WL\_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Connected to ");
Serial.println(ssid);
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
Serial.println("HTTP server started");
}
void loop(void) {
WiFiClient client = server.available(); // начинаем прослушивать входящих клиентов:
if (client) { // если подключился новый клиент
Serial.println("New Client.");
flagEmptyLine = true;
String currentLine = ""; // создаем строку для хранения входящих данных от клиента
while (client.connected()) { // цикл while() пока клиент подключен к серверу
if (client.available()) { // если у клиента есть данные
char c = client.read(); // считываем байт
Serial.write(c);
header += c;
if (c == '\n') { //если байт это символ новой строки – отправляем ответ
if (currentLine.length() == 0) { // + информация о типе контента
client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println("Connection: close"); // "Соединение: отключено"
client.println(); // конец HTTP-ответа – пустая строка
break; // выходим из цикла while:
} else { // если получили новую строку, то очищаем currentLine
currentLine = "";
}
} else if (c != '\r') { // если получили что-то, кроме символа возврата каретки,
currentLine += c; // добавляем эти данные в конец строки «currentLine»
}
}
}
header = ""; // очищаем переменную «header»
client.stop(); // отключаем соединение:
Serial.println("Client disconnected.");
Serial.println("");
}
}
```
Далее с помощью программы «Postman» настраиваем по API терминал на отправку данных об объекте POST запросом. Необходимо указать локальные адреса и пароль терминала, а также адрес M5Stack веб сервера. Возможность данной настройки прописана в документации на Uni-Ubi.
Настройка термила по API через приложение «Postman»Смотрим запрос через Serial и пишем парсер.
Нам необходимо получить данные о температуре (1 – нормальная температура, 2 – ненормальная температура, 3 – термометрия отключена). Для этого применим методы очень мощного класса String.
POST запрос на вебсервер M5StackС помощью метода `indexOf(x)` (где x = String "temperatureState=") ищем в строке другую строку, при этом метод вернет позицию (номер) первого совпадающего элемента. Далее `substring()` вернет кусок строки, содержащейся в исходном post запросе , с позиции первого элемента строки "temperatureState=" до позиции "temperatureState="+17. Таким образом функция парсера вернет нужное нам значение температуры.
```
int parser(String post){
String temp = "temperatureState=";
int info = post.substring(post.indexOf(temp), post.indexOf(temp)+17).toInt();
return info
}
```
Теперь необходимо, на основе данных из функции `parser`, выводить анимацию на светодиодную ленту, воспользуемся предлагаем M5Stack библиотекой `Adafruit_NeoPixel`.
```
#include
#include
#include
#define PIN 21 //управляющий пин ленты
#define NUMPIXELS 288 //кол-во светодиодов в ленте
//установивем количество светодиодов, номер контакта, тип светодиода
Adafruit\_NeoPixel pixels = Adafruit\_NeoPixel(NUMPIXELS, PIN, NEO\_GRB + NEO\_KHZ800);
const char \*ssid = "\*\*\*\*\*\*\*";
const char \*password = "\*\*\*\*\*\*\*";
boolean flagEmptyLine = true;
WiFiServer server(80);
String header;
char clientAlreadyConnected = false;
int iterator = 0, jterator = 0; // переменные для анимации ленты
void setup(void) {
Serial.begin(115200);
M5.begin();
WiFi.begin(ssid, password);
Serial.println("");
while (WiFi.status() != WL\_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Connected to ");
Serial.println(ssid);
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
Serial.println("HTTP server started");
pixels.begin();
pixels.setBrightness(10);
}
void loop(void) {
WiFiClient client = server.available();
if (client) {
Serial.println("New Client.");
flagEmptyLine = true;
String currentLine = "";
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
header += c;
if (c == '\n') {
if (currentLine.length() == 0) {
client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println("Connection: close");
client.println();
break;
} else {
currentLine = "";
}
} else if (c != '\r') {
currentLine += c;
}
}
}
int info = parser(header);
Serial.println(info);
if ( info == 1 ) {
pixelState(100, 0, 128, 0);
pixels.clear();
}
else if (info == 2) {
pixelState(100, 100, 0, 0);
pixels.clear();
}
header = "";
client.stop();
Serial.println("Client disconnected.");
Serial.println("");
}
// И небольшая анимация для пассивного состояния ленты
pixels.setBrightness(10);
pixels.setPixelColor(iterator++, pixels.Color(127, 199, 255));
pixels.show();
if (iterator > 10) {
pixels.setPixelColor(jterator++, pixels.Color(0, 0, 0));
pixels.show();
}
if (iterator == 288) iterator = 0;
if (jterator == 288) jterator = 0;
}
void pixelState(int brightness, int R, int G, int B) {
pixels.clear();
pixels.setBrightness(brightness);
for (int n = 0; n < NUMPIXELS; n++) {
pixels.setPixelColor(n, pixels.Color(R, G, B));
pixels.show();
}
}
int parser(String post) {
String temp = "temperatureState=";
int info = post.substring(post.indexOf(temp), post.indexOf(temp) + 17).toInt();
return info;
}
```
Наконец-то с кодом покончено и можно проверить систему в действии.
Индикация при нормальной температуреРазумеется, этот проект — достаточно простой для ESP32 и здесь можно многое доработать. Тем не менее, здесь я описал интересный и реальный кейс добавления нового функционала к биометрическому терминалу.
Хочется сказать несколько слов относительно использованного M5Stack. Свет клином на нем, конечно, не сошелся, более того, для нас это была лотерея, где мы купились на внешний вид и законченность изделий. В принципе, для решения нашей задачи подошел бы любой менее производительный контроллер. Однако, М5-й оставил самые позитивные впечатления. Если вам нужно «соорудить» что-то быстрое как бутерброд — за 5 минут и с гарантированным результатом, то M5Stack – это очень неплохой выбор (как минимум по сравнению с другими аппаратными платформами по типу Arduino и NodeMCU). Ничего не надо паять, никаких макетных плат — воткнул/стэкировал и оно работает. Поэтому, в будущих проектах и кастомных решениях, мы будем использовать возможно именно его.
Дополнительным аргументом «ЗА» можно считать наличие сотен совместимых модулей — датчики, исполнительные устройства, моторы, реле и всё, что только можно представить и внедрить в проекты.
Осталось только всё собрать. | https://habr.com/ru/post/592545/ | null | ru | null |
# Работа с моделями данных в javascript
Здравствуйте, Хабралюди.
Мал по-малу из моего опыта и наших проектов родилась небольшая библиотека для работы с моделями в джаваскрипте. Она так и называется — [Model.js](http://mcmlxxxiii.github.io/Model.js).
Я расскажу вам вкратце об этой библиотеке и этим постом запрашиваю обратную связь у тех, кто создавая сложные джаваскрипт-приложения, уже решает эту проблему каким-то определенным образом без фреймворков. Интересно также и мнение тех, кто только подыскивает подходящий инструмент для своих нужд: какой инструмент вам нужен и насколько вам подходит **Model.js**?
#### Зачем?
Чтобы упростить работу со слоем данных, не используя фреймворков. Текущая первая версия библиотеки — v0.1 весом около 12К — призвана помочь в первую очередь с валидацией данных и управлением событиями, в частности c событиями при изменении данных.
#### Что особенного?
Сахар. Обыкновенный приятный глазу синтаксический сахар.
Модель описыватся проще некуда.
```
var Note = new Model('Note', function () {
this.attr('id!', 'number');
this.attr('title', 'string', 'nonempty');
this.attr('text', 'string');
});
```
Затем создаем сущности, как обычные объекты.
```
var note = new Note({ id: 123, title: "Hello World" });
```
#### Публичные свойства сущности
Геттеры значений атрибутов. В нашем примере это:
```
note.data.id
note.data.title
note.data.text
```
Сеттеры. Кроме изменения значений также «выстреливают» событие **change**.
```
note.data.id =
note.data.title =
note.data.text =
note.data = {…}
```
Геттер `note.get(attrName[, attrName, …])` возвратит объект со значениями запрашиваемых атрибутов.
`note.get()` возвратит копию всех данных.
`note.data()` — то же самое, что и `note.get()`.
Сеттеры `note.set(attrName, value)` и `note.set({…})` не “выстреливают” событие change.
`note.hasChanged` говорит, изменены ли данные сущности с момента их последнего сохранения.
`note.isNew` говорит, сохранены ли данные сущности вообще хоть раз.
`note.isPersisted` говорит, сохранены ли последние изменения.
`note.bind(eventName, handler)` «вешает» обработчик. Кстати говоря, повесить обработчик любого события можно не только на отдельную сущность, но и на все сущности класса (`Note.bind`).
`note.isValid` говорит, валидны ли текущие данные модели.
`note.errors` собственно, возвращает ошибки данных, если они есть.
`note.revert()` откатывает несохраненные изменения и «выстреливает» событие `revert`.
Это все.
Вы спросите, где же методы сохранения и прочее-прочее? — Отвечу: использование библиотеки подразумевает, что разработчик должен реализовать эти методы самостоятельно как того требует логика его приложения.
Нужно отметить, что с сохранением есть один нюанс: если данные сохранились успешно, нужно об этом сообщить сущности при помощи приватного метода `note._persist()`, который также «выстреливает» событие `persist`.
*Объяснение примером хорошо. Допустим, наше приложение работает в браузерном окружении и метод `note.save()` должен сохранить данные при помощи аджакса.*
```
Note.prototype.save = function () {
var note = this;
return $.ajax({
type: 'PUT',
url: '/notes/'+note.data.id,
data: note.data(),
dataType: 'json'
}).done(function (json) {
note._persist();
});
}
note.bind('persist', function () {
$('h1', 'div#note'+this.data.id).html(this.data.title);
});
note.data = { id: 123, title: "abc", text: "" }
if (note.hasChanged && note.isValid) { // оппа Django-style
note.save();
}
```
#### Проверка данных
При создании модели обязательно описывается каждый ее атрибут.
```
this.attr('title', 'string', 'nonempty')
```
Сперва указываем название атрибута, затем его валидаторы. Валидаторы, когда придет время, в объявленном порядке будут проверять значение атрибута.
Вообще, валидаторы — это обычные функции, которые принимают значения и возвращают ошибки, когда эти значения невалидны.
```
function validateMinLength(value, minLength) {
if (value.length < minLength) return 'tooshort';
}
```
Если у вас есть необходимость использовать валидатор несколько раз — резонно его зарегистрировать, чтобы подключать по имени.
```
Model.registerValidator('array', function (value) {
if (Object.prototype.toString.call(v) === '[object Array]') return 'wrongtype';
});
Model.registerValidator('minLength', validateMinLength);
```
**Model.js** имеет несколько базовых (уже зарегистрированных) валидаторов: `number`, `string`, `boolean`, `nonnull`, `nonempty` и `in`. Их, совсем как в нашем примере, можно подключать к атрибутам по названию.
Чтобы передать параметр валидатору при описании атрибута, нужно записать его, как в примере ниже, в виде массива:
```
this.attr('title', 'string', 'nonempty', [ 'minLength', 6 ]);
```
Валидаторы можно подключать и обычным дедовским методом, не регистрируя их.
```
this.attr('title', 'string', 'nonempty', [ 'minLength', 6 ], function (title) {
if (title[0] !== title[0].toUpperCase()) return 'downcase';
});
```
Все это нужно, чтобы `note.isValid` мог сказать `true` или `false`, а `note.errors` мог вернуть объект с ошибками, если они есть.
```
note.data = { id: 'abc', title: '', text: 3 }; // полностью неверные данные
note.isValid // false
note.errors // { id: 'wrongtype', title: 'empty', text: 'wrongtype' }
```
#### События
Есть четыре события: `initialize`, `change`, `persist` и `revert`. Как говорилось выше, можно повесить обработчик на конкретную сущность (`note.bind`), а можно и на класс (`Note.bind`), так что обработчик станет общим для всех сущностей.
`initialize` «выстреливается» единожды при создании сущности: `var note = new Note({…})`. Так что вешать обработчик `initialize` имеет смысл только на класс.
`change` срабатывает каждый раз, когда меняется значение атрибута. Есть, правда, сеттеры, которые не дергают change (об этом было рассказано выше).
`perist` — когда сущность получает сигнал о том, что изменения успешно сохранены.
`revert` — когда логика приложения приказала откатить еще несохраненные изменения (при помощи метода `note.revert()`).
```
var ALLOWED_LANGUAGES = ['en', 'ua', 'ru'];
var Note = new Model('Note', function () {
this.attr('id!', 'number');
this.attr('title', 'string', 'nonempty');
this.attr('lang', 'string', 'nonempty', [ 'in', ALLOWED_LANGUAGES]);
this.attr('text', 'string');
});
Note.bind('initialize', function () {
if (!this.data.lang) {
this.set('lang', 'en'); // change не выстрелит — специальный такой сеттер!
}
});
note.bind('change', function (changes) {
if (changes.title) $('h1', 'div#note'+this.data.id).html(changes.title);
});
```
#### В завершение
Сейчас **Model.js** — это чистый *state of the art*, это промежуточный, но уверенно работающий результат. Если вы заинтересовались библиотекой, если у вас возникло желание попробовать ее применить, я буду рад ответить на ваши вопросы. Больше информации о том, как что работает можно найти в документации на [гитхабе](http://mcmlxxxiii.github.io/Model.js) и в тестах.
Ну а пока пожелайте малютке доброго пути, ведь чтобы ей стать «взрослой» библиотекой, нужно проделать еще немало работы. | https://habr.com/ru/post/178811/ | null | ru | null |
# Безопасный Android для ребёнка
Подозреваю, что многие из читателей этой публикации в детстве не носили с собой мобильный телефон, или начали носить его только в старших классах — как ни странно, обыденные на сегодняшний момент мобильники появились не так давно. И даже после их появления в течение долгого времени мобильные телефоны были огромными и дорогими, и позволить их себе могли только серьёзные дядьки. Но на дворе 2018 год, и младшеклассники вовсю пользуются смартфонами.
Конечно, дети разные, и проблемы у всех в связи с этим возникают разные. У кого-то проблем вообще не возникает, и я могу только порадоваться за этих людей. Лучше всего, если получается договориться с ребёнком о разумном использовании телефона — но этот случай мы рассматривать не будем как довольно очевидный (договорились — молодцы). Будем рассматривать тот случай, когда нужно выдавать ребёнку смартфон, но при этом технически ограничивать его применение.
Почему именно так?
------------------
Наверняка, сразу у многих возникнет логичное предложение: “Дайте ребёнку старый кнопочный телефон,” или “Просто не включайте ему интернет”. Опять же, для кого-то это может быть отличным решением, но для меня это не работает по следующим причинам:
* Общение с ребёнком идёт через телеграм. Потому что у меня на работе не ловит сотовая связь, а ещё через телеграм можно присылать фоточки учебника с вопросами по домашней работе;
* Хочется включить геолокацию. Не для того, чтобы постоянно следить за ребёнком, а чтобы иметь возможность отпустить его одного недалеко от дома и чуть меньше волноваться. Мало ли что. Конечно, кнопочный телефон можно отследить через различные не совсем легальные сервисы или предложения операторов — но точность геолокации по вышкам оставляет желать лучшего. Кроме того, в случае, если телефон внезапно сел, был выключен, или, не дай бог, выброшен кем-то — нужна возможность быстро найти его последнюю локацию. Увы, не знаю, как решить эту задачу без смартфона.
Постановка задачи
-----------------
Дальше буду исходить из указанных выше предпосылок: что ребёнку нужен стандартный недорогой смартфон, где будет работать телеграм и геолокационный сервис. Теперь перечислим, что ребёнку не нужно:
* Устанавливать игрушки и другие приложения;
* Смотреть мультики;
* Пользоваться браузером или любым другим встроенным поиском;
* Использовать встроенный калькулятор (казалось бы, смешная проблема, но попробуйте убрать калькулятор в своём Android).
Небольшое отступление
---------------------
Если вас интересует только техническая часть, то смело перематывайте к следующему заголовку. Здесь рассуждения о корректности поставленной задачи.
Может сложиться впечатление, что я какой-то зверь с манией контроля, поэтому уточню — дома у ребёнка есть свой планшет и компьютер. И после того, как уроки сделаны, можно смотреть мультики, читать википедию, играть в игрушки, или писать свои игрушки. До того, как они сделаны, тоже можно отдыхать — но без использования девайсов.
Вообще, признаем честно: необходимость решения какого-то организационного вопроса техническими средствами — это уже фейл. К примеру, если в компании ставится система пропусков, мониторится трафик сотрудников, открытые приложения и активность кликов мышкой — то это значит, что что-то пошло сильно не так. Вряд ли производительность сотрудников вырастет от того, что им будут вставлять палки в колёса. Взрослые и сознательные люди хотя бы из чувства противоречия начнут обходить запреты.
С ребёнком то же самое — основная проблема в том, что ребёнку абсолютно неинтересно делать уроки. И, глядя на задания, я понимаю, почему. И, даже если забрать телефон, то ребёнок всегда найдёт, чем ещё себя развлечь: играть в машинки, куклы, или просто сидеть и фантазировать. Так что настоящее решение проблемы — это, скорее, смена школы, или домашнее обучение. Но это уже тема для другой публикации и других ресурсов.
С другой стороны, у меня есть подозрение, что все эти новые технологии “на кончиках пальцев” слишком привлекательны для ребёнка, и он просто физически не может противостоять искушению (сразу вспоминается логотип Apple, да?). Так что, возможно, лучшим решением будет просто не искушать. По крайней мере, какое-то время. Дальше всё равно нужно будет потихоньку вводить во взрослую информационную сферу. Иначе всё может закончиться плохо, когда ребенок внезапно получит доступ ко всему на свете, и из вашего парникового мира розовых поней окунётся с головой в интернет с игрушками, ММОРПГ, приложениями, социальными сетями, голыми людьми, странной лексикой и так далее. Без шуток — я знаю довольно много ребят, которые вылетали из университетов, потому что дома над ними был установлен тотальный контроль. И, попав в общежитие, они полностью уходили в игрушки или общение, которого им так не хватало. Этого хотелось бы избежать.
С третьей стороны, может быть, я просто старею и начинаю брюзжать против естественного технического прогресса? Хотя, так ли сильно смартфон под столом отличается от книжки и фонарика под одеялом?
С четвёртой — я сам являюсь разработчиком во втором поколении, и помню, как мне ограничивали пользование компьютером. И помню, что если я мог как-то обойти запреты (о, сколькому я научился в процессе), то после этого мне было очень сложно себя контролировать. Может быть, это был эффект “запретного плода”. Или нет… Если ты можешь поиграть по модему с другом в DOOM, то какого чёрта заниматься чем-либо ещё? Так что, не думаю, что отсутствие ограничений пользования компьютером в детстве дало бы мне что-то хорошее. Например, я бы точно не начал делать первые веб проекты за деньги лет в 14, чтобы купить свой собственный компьютер…
Однозначных выводов я сделать не могу, поэтому выбираю старый надёжный метод — метод проб и ошибок. Пробую ограничить ребёнку телефон и посмотреть, что из этого выйдет. Наверное, через год верну на него всё в первоначальное состояние, и посмотрю, сможет ли ребенок с этим справиться.
Платформа и железка
-------------------
Сначала нужно выбрать платформу и железку, на которой мы будем делать детский телефон. Мой выбор пал на Android — по той простой причине, что я с ним работал, и могу его прошить, написать софтину на Java или что-нибудь нативное на уровне Linux. Железка не так принципиальна, и у меня уже был купленный ранее недорогой телефон (чтобы не было жалко, если что, и чтобы дети не мерялись “у кого круче”). Не принципиально, что именно брать, но, если бы я делал это сейчас с нуля, то требования были бы такие:
* Точно можно получить root права;
* Есть альтернативные прошивки;
* Есть сообщество хоть какого-то размера;
* Забегая вперёд, замечу, что совсем хорошо, если есть возможность поставить Lineage OS или хотя бы Cyanogen. И смотрите, чтобы в описании прошивки не было замечательных комментариев вроде “всё работает, кроме звонков и камеры”.
Варианты, которые не работают
-----------------------------
Для начала расскажу, что я смотрел и пробовал:
* Альтернативный ланчер, в котором на самом рабочем столе только нужные приложения. Провальный вариант — ребенок мгновенно уходит в полный список;
* Отключить все лишние приложения. Увы, ребёнок быстро разбирается, как их включать обратно;
* Ограничить установку программ и просмотр контента стандартными средствами. Увы, тут гугл подвёл меня — можно ограничить приложения и мультики по возрасту, но нельзя полностью запретить их установку и просмотр. Вроде как у iOS всё в этом плане лучше, но это не точно;
* Всякие детские программы контроля и шеллы для андроида. Их оказалось удивительно мало, и по большей части на них были отрицательные отзывы со словами “защиту обошёл трёхлетний ребёнок”. Будучи сам немного Android разработчиком, охотно в это верю. Так же у многих решений были совершенно другие взгляды на проблему — например, в “детском режиме” они блокировали входящие и исходящие звонки, что меня не устраивало (например, так работает Kid's Shell). Единственное, что привлекло моё внимание — это решение от Лаборатории Касперского. Там обещали защиту от запуска приложений, геолокацию, мониторинг использования и кучу всего другого. И этим ребятам я верю (кстати, они честно написали, что на iOS ограничения не работают). Но не то чтобы мне было жалко 500 рублей — просто задача выглядела тривиальной, и я захотел решить её своими силами.
В любой непонятной ситуации — DIY
---------------------------------
После того, как стало ясно, что малой кровью я не отделаюсь, я начал думать, что проще — резать родную прошивку, или поставить альтернативную. С тоской я посмотрел на безумное количество шумелок, свистелок и прочего bloatware на родной. Затем посмотрел, что на альтернативной, якобы, всё работает. Версия Android на обеих прошивках была одинаковая. И решил, что мне быстрее будет допилить альтернативную, чем резать родную.
В качестве альтернативной я поставил Cyanogen. Понятно, что он больше не поддерживается, но альтернатив не было, кроме заведомо неработающих. Да и меня не очень волновали обновления — по замыслу телефон должен спокойно жить ещё несколько лет на том комплекте софта, который я сейчас поставлю.
Сам процесс прошивки описывать не буду — для этого есть километровые топики на известном ресурсе. Скажу только, что в первый раз это у меня заняло часов 5 — но скорее по причине невнимательности. Повторить это я могу теперь за полчаса. Проблем не возникло — прошивка встала, всё работает, быстро снёс встроенный браузер и калькулятор. А вот дальше оказалось интересно — ни один сервис семейной геолокации не захотел работать без Google Play на телефоне. Уж не знаю, какими удивительными причинами это обусловлено, но факт. Я подавил в себе порыв быстренько написать свой сервис геолокации (задача несложная, уже делал такие, но это был явный “фатальный недостаток”), и смирился с тем, что нужно поставить Google Apps, и как-то потом с ними бороться. Поставил в результате Open GApps в варианте pico — только в нём не было Google Now, который по сути открывает поисковое окно куда угодно. После этого у меня заработали сервисы геолокации. Над проблемой доступности Google Play я бился довольно долго, не понимая, почему нигде не описано казалось бы простой вещи — полного запрета установки приложений. Собственно, на это я потратил ещё часов 5 и вторую ночь.
Здесь должно было быть описание решения, продиктованного мне ночным отчаянием и недосыпом — как я настроил крон, чтобы он постоянно убивал процесс google play. Но я выспался и понял, что достаточно прописать в /etc/init.d простой скрипт
```
chmod 0551 /data/app
sleep 20
chmod 0551 /data/app
```
Пояснение — при установки нового приложения под него создаётся отдельная директория. Убираем права на запись — после скачивания приложение не может установиться. Заодно так решается проблема с установкой сторонних apk.
Один раз этого сделать недостаточно — андроид сам исправляет права на папку, поэтому скрипт помещён в автозагрузку в init.d. Два раза это делаю для надёжности — мало ли когда там исправление прав происходит.
Что вышло
---------
### Плюсы
* Можно поставить любую программу через консоль adb;
* Нет никакого лишнего софта;
* Время жизни телефона увеличилось как минимум вдвое, несмотря на геолокацию;
* Можно использовать приложения, которые требуют Google Apps;
* Нельзя поставить приложения из Google Play;
* У ребёнка появилось куча места на телефоне для фоточек;
* Можно ставить приложения в системный раздел — например, ту же геолокацию;
* Нельзя поставить apk из сторонних источников;
* Решение получилось условно бесплатное. Условно — потому что на него было убито много времени, которое напрямую конвертируется в деньги. И я во многих случаях плачу деньги за экономию времени. И здесь я закопал несколько тысяч рублей и время здорового сна. Стоило ли оно того? Не уверен;
* Я абсолютно уверен в том, что если что-то пойдёт не так, то я смогу это допилить сам. В случае стороннего решения можно только смириться.
### Минусы
* Сам телеграм уже превратился чуть ли не в отдельный marketplace, и в нём есть игрушки, поиск картинок и анимаций, стикеры, боты-калькуляторы, и так далее. С этим тоже можно бороться — как-то я уже собирал свой телеграм, и, если будет нужно, то повторю. К сожалению, это не очень быстро — потребуется ещё одна ночь;
* У кастомной прошивки может не быть обновления, а кастомизированную сложно обновлять. Но это не очень критично — для телефонов интересующей нас ценовой категории обновления системы выпускают примерно раз в никогда, так что альтернативные прошивки могут оказаться более свежими, чем родная. Опять же — телефон без браузера и маркетплейса не сильно подвержен уязвимостям;
* Ребёнок, конечно, огорчился. Но это была крайняя мера, о которой я неоднократно предупреждал.
Не думаю, что моё решение идеально, и с интересом жду способов обхода ребёнком ограничений. Помню, как я в детстве начал интуитивно понимать комбинаторику, прикидывая количество возможных комбинаций пароля из 4 символов. Как учился сбрасывать пароль в BIOS. Как использовал софт, который мог этот пароль мне выдать. Как учился минимальному тайм менеджменту, чтобы тёплый ламповый монитор успел остыть к приходу родителей. Как в конце концов понял, что выгоднее всего быстро и хорошо сделать уроки, а потом втихую играть…
Выводы
------
Честно говоря, не понимаю, почему на рынке нет такого востребованного продукта, как полноценно управляемая детская мобильная ОС, или надстройка, которая позволяет её сделать (ну, кроме упомянутого варианта от ЛК). Если вдруг и есть, то странно, что я оказался не в силах его найти. Было бы это лет пять назад — я сразу загорелся бы идеей самому написать такую прошивку. Но уже не сейчас. Хотя инициативу я бы на досуге поддержал.
А вообще, я очень сильно надеюсь, что упустил какое-то известное решение, которое вы мне подскажете в комментариях.
**UPD.** В комментариях подсказали огромное количество всего интересного — как по техническим решениям, так и по организационным. Тот самый случай, когда получил много пользы от комментариев к статье. Вам тоже рекомендую к прочтению. | https://habr.com/ru/post/410213/ | null | ru | null |
# Доступный, но неприступный мобильный интернет
*— Кросс-пост из моего [блога](http://absolvo.ru/2008-06-28/dostupnyj-no-nepristupnyj-mobilnyj-internet/)*
Сегодня мобильный интернет уже не редкость, а удобный инструмент. Его можно повстречать практически везде. В пробке можно заметить у соседа ноутбук на переднем сидении, в метро студента, который читает bash.org.ru, а в сквере на лавочке девушку, которая сидит в аське.
Со всей уверенностью можно сказать – сегодня мобильный интернет доступен, как никогда. Доступен по многим параметрам, в частности – интернет есть там, где есть покрытие провайдера (другой вопрос качество, но об этом позже) и недорого.
Если брать в пример меня, то я два часа в день, ни в чём себе не отказываю – форумы, блоги, ленты новостей, баш и IM, вплоть до скайпа. Кроме скайпа всеми этими благами я пользуюсь в метро. И плачу за это удовольствие максимум 250 рублей в месяц.
Однако если вы считаете, что вам доступна вся сеть, то вы неслабо заблуждаетесь. Давайте пройдёмся по примерам, даже покажу скриншоты. Задача простая, выяснить у некоторых организаций телефон, или адрес.
Какие минусы могут нам встретиться? Их, на мой взгляд, несколько. Опишу те, которые реально мешают получить информацию. Это телефон или почта, которые указаны на картинке. Как правило, я выключаю картинки, дабы ускорить загрузку и сэкономить на трафике. Всё бы ничего, скажете вы, есть alt, который и создан специально для этого. Однако не все веб-мастера выставляют размеры картинкам, и альтернативный текст. А если вписывают альтернативный текст, то совсем неочевидный, к примеру: «Телефон». Для примера, сайт довольно известного банка, банкоматы которого вы видели наверняка. Не буду давать активную ссылку, а то посчитаете рекламой – просто скриншот:
Дальше идёт известная контора, которая «поможет» нам заказать билет, к примеру, на концерт:
Таких примеров в рунете полным полно. В следующий раз, когда зайдёте на какой-нибудь сайт с мобильника – обратите внимание.
Теперь давайте посмотрим, как можно организовать версию сайта, которую будет комфортно просматривать на экране мобильного телефона.
Я вижу всего два варианта, которые заслуживают рассмотрения. Однако и среди двух вариантов есть абсолютный лидер. Но расскажу об обоих.
Вариант номер один – стили:
В CSS введено понятие типа носителя, когда стиль применяется только для определенного – для мобильников это handheld. К примеру код для подключения стилей для мобильника будет выглядеть примерно так:
`<br/>
@import "/style/palm.css" handheld;<br/>`
Такие стили особым образом оптимизируют. Заменяют оформление графикой на оформление в связке html+css, скрывают ненужное, к примеру, блоки второстепенной важности и несколько правят размеры блоков. К сожалению я сейчас не готов написать универсального пособия по оптимизации стилей для мобильников. Хотя вопрос интересен, и возможно я его освещу, когда-нибудь. Этот способ хорош тем, что затратив минимум усилий можно приспособить перегруженную графикой и информацией страницу в более или менее пригодный вид, для просмотра её с помощью мобильного устройства (в конце концов есть PSP, Палмы и т.д.). Однако я предпочитаю другой метод.
Вариант номер два:
Вам наверняка знакомы следующие страницы:
Как видите – это полнофункциональные (за некоторым исключением) версии сайтов, но в специальном, минимизированном формате. Оптимизированная графика, которая весит копейки и кешируется, мало стилей, которые хоть и кешируются, но всё-таки тоже генерят трафик и минимальное количество Java Script – вот залог успешности мобильных версий сайтов. Этот способ хорош всем, на самом деле, стоит признаться, некоторое время назад я был вынужден сидеть на диалапе, и мобильные версии яндекса и mail.ru меня неслабо спасали (да, да – у меня была необходимость в mail.ru – просьба не кидаться помидорами)
Как вы видите, при копеечной стоимости мобильного интернета мы не можем насладиться всеми прелестями Сети. И до тех пор, пока наши мобильники не научатся разворачивать экраны до 13 дюймов – нам придётся встречаться с большим количеством сайтов, которые откровенно враждебно к нам, обычным пользователям, настроены.
Вот история из жизни моего знакомого, курьера. Ему дали задание доставить пакет с документами, сроки поджимали (экспресс-доставка), и он галопом по Европам помчался куда-то на окраину города, в район который по своей сути находился в самом разгаре строительства. Естественно парень потерялся, но решил выйти из ситуации и позвонить по телефону. Указанному в накладной. Выяснилось, что номер неверен. В диспетчерской помочь не смогли, да и наверное не хотели. Узнав сайт компании через Яндекс, он заходит туда и натыкается на сайт. Который полностью соткан из картинок. Текст, меню, боковые блоки – пришлось грузить картинки. Даже не в деньгах дело, а во времени – он еле-еле успел к назначенному сроку доставить пакет с документами. А ведь ничего не стоило добавить альтернативный текст картинке с телефоном.
Самое обидное, что завтра может понадобиться узнать не номер телефона по работе, а адрес ближайшей аптеки или телефон ближайшей больницы. Естественно есть альтернативные источники этой информации, однако это не избавляет от неприятного осадка, когда натыкаешься на сайт, скриншот которого я разместил первым в этой заметке. | https://habr.com/ru/post/28079/ | null | ru | null |
# Music on the Commodore PET and the Faulty Robots
After completion of the [System Beeps](https://shiru8bit.bandcamp.com/album/system-beeps), I wasn’t planning to make another stand alone album release with the pseudo polyphonic music, as I felt the topic had been explored enough. This, however, wouldn’t mean I couldn’t apply the experience and skills gained to make more utilitarian stuff, like an actual retro game OST or an old school demoscene project. Such an opportunity arose in Autumn 2020, as David Murray of [The 8-bit Guy Youtube channel](https://www.youtube.com/c/The8BitGuy) fame announced his new game to be in development, the *Attack of The PETSCII Robots* for Commodore PET and some other Commodore 8-bitters. As I previously worked with David on his previous big release, [Planet X3](https://www.the8bitguy.com/product/planet-x3-for-ms-dos-computers/) game for MS-DOS, and this was a perfect opportunity to satisfy my interest towards the pre-graphics era PCs as well as apply my vast experience both in the minimalistic computer music and 6502 assembly programming, I offered my services that had been accepted. Besides the sound code I also had hopes to participate as a music composer this time.
Unfortunately, this time the project didn’t went well on my side, and lots of issues of all kinds eventually turned it into a small scale development hell (you can learn more from a [series of posts](https://www.patreon.com/shiru8bit/posts?filters%5Btag%5D=pet%20robots) at my Patreon blog) The end result was that my code and sound effects were only used in the VIC-20 port, and music for other versions has been created by other people. However, I was left with the full working code of the sound system for PET, and a number of music sketches. It would be a pity to file it into the archive, PET projects aren’t a frequent thing these days, so another chance to use the stuff wouldn’t come any time soon. So I got the idea to develop my music sketches into full songs, and release it as an alternative OST, and having David’s approval it has been done and released in the Winter 2021 as [Faulty Robots](https://shiru8bit.bandcamp.com/album/faulty-robots), a small music album for PET that is available as a digital audio release and a runnable program for the actual PET computer.
You can hear and see the whole thing in the action in the video below. The following article tells the story full of epic wins over numerous difficulties on the thorny path to this weird music release.
### The Music
This time I decided that good things should come in a small package, thus I limited the ear torture session with just eight short songs. In fact, their length had been severely limited by the technical constraints described below. This resulted in a total play time of 13 minutes.
The core album concept is a deconstruction, an alternative perspective on the game’s contents, the hardship of the robots from the game story, as well as the development difficulties of the project itself. A word to describe it is minimalism. Highbrow aside, something is making beeps to some to love, and some to hate.
A few words about the creative process behind each of the songs, and how the entangled creative mess straightens up into the well ordered structure of the final release.
*Faulty Robots* — has been envisioned as the title screen song, the melody there is based on chanting the title. It was one of the first sketches, developed up to the second verse. It has got a bridge and the second verse in the finished version.
*Rusty Gears* — the first fully finished track that has been composed to test out and show up the sound system capabilities. David and I considered it to be difficult to follow and not really match the game stylistically, so we didn’t plan to include it into the game. Has been altered a bit for the album release.
*Conveyor Belt* — was planned to be a short loop on the level stats screen, when you beat or lose a level. For the album version I added the second verse with the arpeggio starting from the bridge and then running as a counterpoint to the main melody.
*Old Model* — has been created just about before it became clear that I won’t be making music for the game. So it was changed from an uneventful background music for the gameplay into a song with more melodic content.
*Crosswired* — the first proposal for the in-game music. It had to be arranged with lots of air, the pauses between the notes, so sound effects would cut through it easily, and it had to be as lengthy as possible considering the memory limitations, to not be much annoying after numerous repeated plays. I was afraid that it lacks melodic content too much, so it won’t be enough for a stand-alone music release, but in fact some album listeners highlighted this one as theirs favorite.
*Scraplord* — started its life as a riff to serve as a base for one of the in-game songs. It was pretty difficult to figure out how to turn it into a full blown song. Unlike most of the other songs that have been directly written down from the head into the tracker, I had to do this one by improvising on the keyboard, recording it in Reaper, then cutting the best parts together into a single melody.
*Bosstown Dynamics* — the very last track that has been composed specifically for the album, to make the eight songs total. The work on the melodic part wasn’t going smoothly again, so it also has been cut together from the best parts of improvised pieces. The title is a nod to the Corridor viral videos.
*Not Obsolete* — interestingly it started as the very first test of the sound engine, just a mere pattern with a few random notes. When I got the track counts up to six, I wanted to add two more to make it (binary) even. So I just added some waveform changes, and as it happens sometimes, it kinda developed its true shape hidden within, so I just had to carve it out, and it made a bit of a sad but affirmative finale. The title is a quote of the world’s most famous cyborg from an unnecessary follow-up.
As the songs were initially intended to be used in a game, they were all seamlessly looped. Once all tracks were done and the player shell programmed, I felt it needed a more definitive conclusion, so I added an extremely basic coda to each of the songs, basically just a couple notes here and there.
In conclusion, I personally like the end result more than the previous one, *System Beeps*. In both cases I was trying to move away from a much limited but kinda typical chiptune music into the aesthetics of old computers that make their beeping randomly, and that somehow develops into a defined melody. I think I was able to get closer to that feeling this time.
### History Reference
While the artsy creative portion of the album mostly appeals to the relatively small community of chiptune fans, the technical portion may have an interest for a wider group of the retro computing enthusiasts.
It should be noted that Commodore computers were mostly absent here, in Russia. Back in late 1980s when home computers started to be more affordable, they were mostly presented with obscure i8080-based Soviet stuff and ZX Spectrum clones, and US or Japanese made computers were a major rarity - if anything, that would be presented with Atari 8-bit and MSX families at best. Unlike the rest of the world, C64 and especially everything prior to it was virtually unknown, besides maybe brief mentions in the books. The situation only changed a bit in the late 90s when second hand Amigas became available, they got their following, but of course it lost the market to much more affordable IBM PC compatibles. So Commodore PET is a total obscurity here.
I don’t have to get into the PET history for the readers from the rest of the world, as it is more or less known there. I’ll just say that it is one of the earliest (1977) fully featured personal computers, complete with its own CPU, display, keyboard, and everything else, as well as one of the first successful mass market computers of this kind. It can barely be defined as a home computer, and it is certainly not designed for video games. It lacks any graphics capabilities, just 40x25 or 80x25 monochrome text mode with a fixed character set that features some pseudographic symbols. First models came without any sound capabilities at all, later ones got a simple speaker added to make system beeps. You likely won’t find a less suitable platform for a computer musician, yet it makes it the more appealing challenge to overcome.
Personal computers of such an early era, when the whole format of such devices has been just getting established, often have lots of personality, and PET is one of the most peculiar. It has a bright retro futuristic appearance, it features a very distinct pseudographic character set called PETSCII, it has an all rectangular keyboard that lacks the now obligatory top row with the numbers, and that offers only two keys to control the cursor movements. It hides even more funny quirks under the hood. Like, when BASIC’s PEEK can only read the RAM under 49152, because the BASIC ROM is located above, and presumably this limitation has been put to prevent users from reading the ROM contents. One of such special quirks of the system was the unusual approach to the sound hardware as well.
There are three common approaches to the sound hardware in the computers of the past.
The sound hardware of the most budget computers is often presented with just a single bit I/O line that is connected directly to the sound speaker. The CPU has to toggle this output bit on and off using carefully timed code to produce a tone of the desired frequency. This normally takes a major chunk of the CPU performance, if not the whole time, to produce the sound, and does not allow running anything else in the background while the sound is playing. In other words, if a game or a program needs to play a music or a sound effect, any screen activity should stop.
Home computers designed to run video games were using the opposite approach, employing relatively complex custom hardware such as sound chips that are specifically aimed to generate multichannel sound in the background. Having a dedicated sound chip allows it to play sounds without stopping the action, the CPU only needs to pass the sound parameters to the sound chip from time to time.
The business targeted machines, and PET can be seen as one of these, were using something in between of these two extremes. They often had a solution similar to the famous PC Speaker of the IBM PC/XT fame - a sound speaker driven by a programmable timer chip, such as the i8255. It can produce simple beeps without stopping the other activity, but the sound capabilities are normally limited to just a single channel of basic square wave.
### The Sound Customs
The early PET 30xx models lacked any sound capabilities, neither they had a dedicated sound hardware, nor a built-in speaker. The platform enthusiasts weren’t happy with this, so they came up with a very simple modification that allowed them to produce some sound. This modification has been adopted by Commodore, and implemented in the following, more widespread PET models 40xx and 80xx.
PET uses a MOS 6522 chip, also known as VIA (Versatile Interface Adapter) to communicate with the peripherals. It is a multi-function chip that provides a couple of parallel I/O ports and a very rudimentary serial I/O port. The serial port support is presented with a 8-bit shift register and two programmable timers. It was the software duty to utilize these resources to implement an actual serial interface protocol.
When the PET enthusiasts were adding the sound speaker to the early PET models, they went with quite an original route. One would expect they would use a PIO line, which is a common and simple solution. However, they used the CB2 line, that is the output of the shift register of the serial interface. One of the 6522 timers defines the shift frequency, so if you load the alternating bit pattern such as %11110000 there, you’ll get the square wave, leaving the CPU to do other things. This design kinda looks like the PC Speaker, however, it has more limitations, and an advantage in a way.
The main limitation is the frequency range. The counter of the timer that clocks the shift register is only 8-bit wide. The 6522 clock frequency of 500 kHz gets divided by the programmed 8-bit value (1..255), then by the number of the bits in the shift register, i.e. 8. With %11110000 loaded to the shift register the lowest available frequency would be 500000/8/255, which is about 245 Hz. The shift register could be loaded with %11001100 or %10101010 bit patterns even, however, that would only multiply the resulting frequency by 2 or 4. This means the lowest possible note you can get with the 6522 generated sound is somewhere near the B-3. That omits the whole bass range that is the staple of nearly all modern music, and the pitch of the higher notes gets far from the perfect tuning. This makes it very difficult to make any music that is pleasant for the ear.
The advantage of the MOS 6522 in sound generation is that the shift register can be loaded with any other bit pattern as well, which allows it to have a richer sound variety, not limited to just the classic 50% square wave. In addition, it can generate IRQs using the second, 16-bit timer, as well as at the end of a full shift cycle. The latter allows us to overcome the hardware limitations with software tricks.
During the commercial life of the PET, programming books weren’t going into deep details, mostly providing a table of the three octave range for the two 6522 registers that controls the shift register contents and the 8-bit timer divider. The insufficiency of the information on the serial interface part even has been explicitly acknowledged in one of editions of the original 6522 datasheet. There were a few exceptions, some books did mention the possibilities of improving the sound by using the IRQ to reload the shift register ever so often, or by c[onnecting an external DAC](https://archive.org/details/COMPUTEs_Programming_the_PET-CBM_1982_Small_Systems_Services/page/n301/mode/2up?view=theater) to the parallel port (much like the Covox). However, as the home computer market was progressing rapidly, and PET wasn’t a gaming or home machine to begin with, so there was not much support from the big software development companies, PET became an obsolete artifact way before these ideas were properly explored and used by the not so large community of the PET enthusiasts.
As the result, the better PET games and other software was sounding mostly like this:
Decades later, in the modern time the proposed techniques were explored and employed in the demoscene productions, and pretty amazing results have been achieved. Some are certainly much more impressive than my work that I’m describing here, however, they require nearly the whole CPU time and lots of RAM, which makes them not much applicable to the games. Here is an example:
### A Brief History of Failure
Getting started with the project I had a vague idea of the PET architecture, distorted with the previous experience with similar machines, such as Robotron 1715 (a i8080 based text only business machine) - I expected it to have the basic speaker controlled with one I/O line, and sound to be produced with a well timed code. So I envisioned the sound for the game much along the lines of ZX Spectrum 48K or Apple II games - software synthesized sound effects and music pieces that stops the action.
I have a vast background with lots of prior work of this kind that has been used in literally hundreds of retro games created in the past decade. So I expected that I could just adapt it to the PET, and the job would be done quickly and easily. However, soon it turned out that David’s vision is much different, he would like to have a solution much similar to the PC Speaker sound in MS-DOS games - a single channel sound produced by the 6522’s CB2 and played simultaneously with the gameplay, without interrupting it and without taking much CPU time.
The original plan was supposed to have versions of the sound code for Commodore VIC-20, Commodore 64, and eventually Commodore Plus/4. All of these have much more advanced and sound capabilities, full of pretty unique limitations that are only specific for a particular platform. The sound system had to be developed with all of this specific consideration and even it out somehow. The original plan also considered that the exact same sound data would be shared between all the platforms. The PET was considered the primary platform, setting the main limitations, while other versions for the rest of the platforms just had to recreate a similar sound, just with polyphony and minor improvements added on the top.
Another key requirement that affected the system design a lot was the need to save as much memory as possible, because it was severely limited in the VIC-20 version. Both the sound code, and the sound and music data had to be as compact as possible. This automatically would put the limitation on the code and music format complexity, further limiting its capabilities, and ultimately the complexity of the music arrangements. There was just 2.5K or RAM for the whole sound code, all sound effects, and a single reloadable music track. That’s about 2.5 times less than usual. This was the reason that support of the most advanced features of more capable platforms, such as SID waveforms and the filter, was not considered from the beginning - it would take a much more complex format and sound code that would take more RAM.
Yet another specific requirement was the black box style code integration. This means that the sound code wouldn’t be included as the assembly code source into the main program. It rather had to be a loadable separately compiled binary that would communicate with the game code through commands passed via assigned RAM location, rather than the usual jump table approach. This idea was kinda weird to be used in a single CPU architecture (it is a commonplace in multi CPU architectures such as Genesis and SNES), so it didn’t work well in the end.
In the middle of the development process a major priorities shift happened. It has been decided to exclude the music from the PET version altogether, because of the technical difficulties that arose during the development and slowed it down considerably, and because the built-in speaker is just too quiet. The VIC-20 version has been promoted as the primary one, which now would take a much different sound system design. The C64 version got the improved graphics and a totally different sound content with the SID music, up to the common C64 standards, being composed by Noelle using the player from goattracker.
This grand plan with many specific goals and changing priorities ultimately turned into a major failure on my end. Eventually the code that was meeting the requirements has been finished and debugged, a way to produce sound content has been created, all sound effects made, and some of the music has been sketched out, too. It all was working fine in separate test programs that were running in VICE and MAME emulators. However, these tests failed to run properly on David's side, both in the very same emulators and on the real hardware, for an unknown reason. It didn’t work being integrated into the actual game as well. All the deadlines were missed, so there was no time to figure out this mystery, and being put into an awkward position, David had to take a decision to release the first batch of the PET version copies without the sound at all, then implement his own sound code for the PET. As a result, the only version of the game that still featured some of my sound code, sound effects, and a test song, was the VIC-20 one.
### Pushing The Limits
The first issue to be solved was the issue with generating the low frequency sounds on the PET. David wouldn’t consider this a problem, but I was sure it is important. I just couldn’t imagine how it is possible to compose the high pitched in-game music without a bass section that wouldn’t get extremely annoying after a few seconds.
As 245 Hz is pretty low, I leaned towards this solution: sounds above 245 Hz would be generated via the regular 6522 means, and for sounds below I would run a software emulation of the 6522 shift register on the IRQ from the second, 16-bit timer. The worst case scenario would be 5 IRQs per TV frame, so it shouldn’t hit the CPU performance too much.
David didn’t like the idea much, as he was worrying it may hurt the performance and be a potential source of trouble in the debug - it turned out to be not too far from the truth. Nevertheless, I implemented a simple test to the idea, and it worked for the most part, although one major issue had been exposed.
Just like any other 6502-based platform, PET has its IRQ vector located in the ROM. To allow the user to set up his own IRQ handler, a technique known as trampoline is employed - the default IRQ handler optionally calls a custom one whose address is placed to a location in the RAM. It seems, though, that PET firmware developers didn’t take this possibility seriously, as not many were programming the system at the low level. So the trampoline implementation there is quite inefficient - it does not pass the control to the custom handler right away, it rather puts all the CPU registers to the stack first. The code in question looks like this:
```
; Main IRQ Entry Point
E442 PHA
E443 TXA
E444 PHA
E445 TYA
E446 PHA
E447 TSX
E448 LDA $0104,X
E44B AND #$10
E44D BEQ $E452
E44F JMP ($0092) ; Vector: BRK Instr. Interrupt
E452 JMP ($0090) ; Vector: Hardware Interrupt
```
$0090 is the user IRQ vector that is stored in the Zero Page. This location is different between the BASIC ROM versions, so a program must detect the ROM version first, then use the corresponding location. The vector is set to the standard BASIC interrupt handler by default, it polls the keyboard and updates the system clock. So I had to call it back at the original rate in my custom IRQ handler too, to keep the keyboard and time count working properly. To make this work, I had to first detect what device fired the IRQ request, display controller or the 6522 timer.
Besides the increased CPU load (about 15% for 245 Hz sound) such an inefficient interrupt handler also caused a background hum at ~50 Hz, which interfered with the generated sound, altering the bass notes timbre and frequency to be way out of tune, rendering the whole thing kinda pointless. That’s because the default handler takes quite a long while to finish, and sometimes another IRQ could be fired just before the previous interrupt handler call would get finished. It would help to re-enable IRQs just before passing the control into the default handler, but it failed to work (the program would just freeze) by a reason then unknown to me.
It took a long while to figure out, the attempts to solve this issue were continued simultaneously with the development in all other areas. It kinda stalled, and a solution was nowhere to be seen, but utz came to the rescue, he just mentioned a thing about PET interrupt handling, and helped to configure the MAME emulator properly to run my tests. It turned out that vertical blanking IRQ gets fired by one of the PIA lines, and it would remain set unless the PIA status gets acknowledged manually, by just reading the corresponding PIA register. Re-enabling the IRQ without the acknowledgement to the PIA would just re-fire it right away, so the IRQ handler will immediately get invoked again, putting the program into an infinite loop.
Once the music player code has been finished, a test song prepared, and it has been tested on the real PET computer, another major problem has been found. Some notes of a certain pitch had been missing, presumably those were just on the borderline between the 6522 sound generation and the software one, yet it worked just fine in the VICE. With help from utz and mr287cc I was able to use MAME for testing the code, it turned out to be more precise and reproduced this issue too. utz also pointed out to a text that explained the reason for the issue, the 6522 shift register had to be reloaded in a specific way to make it run right after loading, otherwise it would start to shift the bit pattern after a delay.
Besides the PET challenges, the VIC-20’s limits have been pushed a bit. Its sound chip is normally only capable of generating 50% square wave and white noise. However, it features a pretty unusual inner design, worthy of a whole different article on itself. In short, using a few of precisely timed register writes it is possible to make it generate 15 more waveforms, each of those is basically a 1-bit sequence, each with its own specific sound. This trick has been first discovered by viznut in the early 2000s, however it barely has been employed in the newest development, even though it is supported in the modern emulators.
When I learned about this trick, I attempted to implement it in my sound code, and it kinda worked. However, it turned out that the extra waveforms only added higher harmonics to the signal, and it isn’t very useful for the music, considering the very limited VIC-20’s pitch range. Besides, with the not so perfect precision of the existing emulators I wasn't able to debug it well enough, so it worked a bit unstable, occasionally selecting the wrong waveform. As a result, the VIC-20 music sounds a bit weird in my sound code, and it wasn’t ever fixed properly.
### Squeezing It In
Going according to the original plan, I was designing the sound system towards the PET’s limitations, as it has been set as the main target platform. The plan was to make a pseudo polyphonic engine, much like what I did for PC Speaker and Planet X3 before. The idea behind this is that there are a few virtual sound channels playing their parts, but in each particular moment of the time, which is something about 1/50 seconds long, only one of those gets routed towards the sole sound output, according to the part priority. That’s the drums, the melody, and the bass line in the order of the most to least importance. This creates an illusion of a multi channel arrangement, even though the sound always remains monophonic. For the platforms with more capable sound chips the player code logic remains the same, but a different channel manager is used that routes the virtual channels to the available hardware channels, so if a sound chip is capable for polyphony, the music gets polyphonic, while using the same exact music data as the input.
The compact data requirement, which allowed about 1K per one music track, made it impossible to take the easy way with pre-rendered register dumps that *System Beeps* was relying on. A new super size-efficient format had to be designed, which also would require composing the music and preparing the music data in a very specific way.
To reduce the music data size, a few decisions have been made, which in general meant less of everything on the input: shorter play time for songs, as less notes produces less data; less variable parameters per each note, as less parameters produces less data as well. High degree of reusable repetitive parts such as bass lines and drum patterns has been also considered to be used in order to reduce the data size.
My previous experience with compacting the music data, for example, in the Huby engine (a 100-byte engine for ZX Spectrum 48K) showed that a per-channel order list with 8-16 step patterns will give the best compacting results. Per-channel order has an overhead of the size of the list itself, but allows to reuse parts of the song such as bassline and drum patterns. This provides more compact data compared to the general order list that is used in music formats like MOD, XM, or IT.
To reduce the number of bits required to encode a single note, I employed the idea of different note ranges for channels, suggested by the VIC-20 sound chip design. The chip features three channels, each of those is tuned one octave apart from each other, which was needed to improve the pitch resolution having low resolution (7-bit) frequency dividers.
I did a similar thing: one channel is mostly used for bassline, second one for melodic parts, and third one is for the drums. So the second channel range is shifted one octave up. The lowest possible note is picked to match the VIC-20 capabilities too: it can play as low as 50 Hz, which makes the A-1 note. The pitch range of a channel is 2.5 octaves, roughly 32 semitones. Matching the lowest note to the chip capabilities allowed to not use the software synthesis for the VIC-20 and C64.
Besides the note range, each channel in my sound system also features a set of 7 customizable instruments, unique for each of the channels. I.e., 7 instruments for the bass part, 7 instruments for melodic parts, and 7 drum sounds. The note pitch is encoded with 5 bits, the instrument number is encoded with 3 bits, and the instrument with number 0 encodes the empty position, rest note, and repeating fields using the RLE. Considering the short patterns, it is just enough to encode any number of repeating fields in a pattern. This way any note field or series of repeating notes is encoded with just a single byte, and the smallest order position (all empty fields in each channel) can be encoded with a mere three bytes.
As the same music data was supposed to be used for all versions of the game, it had to be loaded into different RAM locations. So I had to use relative offsets everywhere. It made the player code a bit more complex and increased its size, but improved the versatility.
As the instrument data was extremely simple, it was encoded in the simplest possible way: two envelopes, one byte per update frame, no RLE. First envelope defines the wave shape, duty cycle, or volume changes over the time (depending on the target platform). Second envelope defines semitone offsets or pitch steps from the current note; the pitch/semitone mode gets switched with a special byte in this envelope.
In the initial version of the sound code all the variables were located in the Zero Page. This reduces code size considerably, as the variables get accessed very frequently, and ZP location allows to address them with just a single byte instead of a couple. However, as the firmware (BIOS and such) of all 8-bit Commodore machines prior to C64 put their system variables into ZP as well, filling the majority of its space, and there is no clear documentation on which variables can be used for machine code programs without any side effects, I had to omit this optimization and put the variables into regular RAM.
### Debugging Misadventures
The biggest issue in the development of the sound code was the age of the target platforms. While Commodore 64 retains a huge popularity among the retro computing enthusiasts, its ancestors and less successful relatives such as PET, VIC-20, Plus/4, and others, never had a major popularity to begin with, and lost most of its remnants at the present day.
The unfortunate consequence of this is the very scarce amount of reasonably good information on programming for these platforms that can be found today in the webs. It is mostly present with scans of the old books in the unsearchable PDF and DJVU, and the books were mostly dedicated to BASIC programming. So I couldn’t really find a memory map that would explain which ZP locations are safe to be used in my code to not interfere with the BASIC/BIOS routines, and that became a major issue to integrate the sound code with the actual game that also needed some ZP memory to function.
Another unfortunate consequence of the low popularity of said platforms is the lack of software of all kinds. This results in the pretty low emulation quality, and the choice of emulators is very limited. For one, VICE does not emulate all 6522 modes, and MAME implements them with some mistakes - just because the old software wasn’t really using these features, so there is nothing to test out the implementations and improve the emulation precision.
Things get even worse at my end of the pond. Commodore computers were never popular in my country back in the 80s and 90s - up to the point of the total absence - so today the least popular models can only be found in the computer museums. So the first time I’ve seen a PET 8032 in person was in the private MTUCI (a communication technologies university) museum some time after the release of both the game and my album. Even if a real PET was accessible to me during the development process, it would be a major trouble to put my test code to it, as Commodore machines tend to use proprietary incompatible storage media and communication interfaces, which is even harder to find here.
Due to the reasons above, I had to debug my code using the pretty incomplete and imprecise emulators with rudimentary debug functionality. David was running my code from time to time on the actual hardware he owns, but as he’s busy with many other things, the back and forth couldn’t be done quick and frequently enough. This became yet another reason for the project failure, as we ended up with issues that were not possible to iron out using the available emulators, and that were difficult to figure out on the actual hardware, especially without having it within a direct reach.
In order to be able to debug the sound code at least somehow, I implemented support for yet another 6502 powered platform - the NES game console. Unlike the older Commodore series, this platform was and remains hugely popular, so it has dozens of emulators of very high quality, and some of them has the advanced debug functionality. This helped a lot, so I was able to use the much convenient FCEUX debugger for a good chunk of the work. The sound code is designed in a way to have its primary logic a platform independent, so only the part that accesses the sound chip gets changed depending on a platform. Once I got the primary logic working properly on the NES, I added the platform dependent parts for the actual target platforms, which had to be debugged in the respective platform emulators, of course.
### Creating The Music And Sound
Having the music data format designed and sound code working, I had to solve the issue of the content authoring pipeline. In other words, how a music can be programmed within the specific constraints set, and the binary music data produced out of it. The less limited format, the easier the problem to solve - one can just adapt an existing music editor via making a format converter (from MIDI or XM, for example), and just compose the music with the constraints in mind. The more limited and quirky the format is, the more difficult a converter from a generic format to create, up to infeasibility due to the major inconvenience. This was the case.
In this situation the usual solution is just to program the music manually - compose the music in any format with all the limitations considered, then convert it into the hex all by hand. This is the common method that the video game music has been created up to the early 90s. Totally legit, but extremely tedious way to do it, that takes a lot of time and leaves too much room for a mistake. We didn’t have much time left for the project, so an editor tool of sorts had to be created in order to speed up the process.
At first, I has been considering to create an editor that would run on the actual PET, which could be programmed reasonably fast using a C compiler. The speed likely wouldn’t be an issue, however, the usability would be pretty bad, especially in the regards to the input (PET keyboard has much less keys than a regular PC keyboard), and file transfer into and from a floppy disk image. The support for other target platforms would have to be also provided somehow, but porting the editor to each of the targets would be pretty inefficient. So I dropped this idea. However, it has been eventually implemented by David himself, as he created a music editor that runs on the PET to create the music for the PET version when it has been decided to not use my code there.
David’s music editor running on the actual Commodore PET.Other possible solution was to create a music cross editor for a modern PC, similar to the FamiTracker and alike. It would solve all the issues reliably, however, it would be way too time consuming - the sound chips of the target platforms aren’t well emulated, so I couldn’t just utilize someone’s else code for this project, and making my own sound emulation code for an obscure and poorly documented chip, not even having it at hand, is an R&D task that would take an undefined amount of time with uncertain results. So this idea has been dropped as well.
There was another option, an odd one. A decade back I developed my own experimental cross platform cross target music editor called 1tracker. The whole reason to create it was to simplify creation of chiptune music for the most obscure platforms, which has been ZX Spectrum beeper music back then. The editor gets fully re-configured with external AngelScript based plugins, without recompiling the main code. It has been the best opportunity to utilize it for this project, but there was a catch. 1tracker back end is based on the Game\_Music\_Emu library that had no support for Commodore’s sound chips, not even SID, let alone VIC-20 and PET. And it couldn’t be added by the reasons given above.
To work around this problem, I got an idea, much similar to the code debugging: use another platform as an intermediate solution, namely utilize some of the supported music formats for a 6502 powered platform, such as NSF (NES music), SAP (POKEY music), or HES (PC Engine music), and just emulate the sound of a Commodore platform inside it via a crude software implementation in the 6502 assembly code that would just provide a somewhat similar sound. Another catch there, however, was that it was the first case of the need to support a 6502 platform inside the 1tracker, and it just was missing the infrastructure required, such as a built-in 6502 cross assembler. Sure it could have been added, but again, it would take a while to go that extra mile, the time that could match with making a custom tracker from scratch.
The ultimate solution to this can of worms has been a quirky compromise that worked, nevertheless: use 1tracker’s existing Z80 infrastructure to re-implement the PET sound code in Z80 assembly code, including a crude CB2 sound imitation written in Z80 code as well. This would allow one to hear a somewhat similar sound during composing the music, and an authentic sound could be then heard in a PET, VIC-20, or C64 emulator one the music data gets exported from the 1tracker.
The weak point of this solution was that ZX Spectrum’s Z80 that is emulated inside the AY file format container, runs at mere 3.5 MHz, and does not feature any timer interrupts besides the standard 50 Hz one. It may be just enough to run a CB2 sound counterpart, but the music player code had to be executed every 1/50 seconds, interrupting the sound,m and introducing a loud hum into the sound. This has been fixed by implementing an unlimited Z80 overclocking inside the Game\_Music\_Emu that can be enabled from Z80 code by using a dummy opcode such as LD H,H. When the overclocking is enabled, all opcodes take 0 t-states to execute, until the overclocking mode gets disabled. This mode has been enabled before running the music player logic and disabled just before the sound generation loop, so all the unwanted hum was removed.
One of the songs loaded into 1tracker under Windows.This way I ended up writing a full equivalent of the 6502 sound code in Z80 assembly code, complete with a CB2-alike software sound synthesis written in Z80 assembly as well, and implemented the music and SFX authoring system as an external script-based plugin for 1tracker. I also added a few minor improvements to the 1tracker front end, to make the process more convenient. A binary music data export has been added, to be included into a 6502 program later. This was just sufficient for the project. I didn’t have to implement VIC-20 and C64 audition in the tracker, as at this point its support has been excluded from the project goals.
### Recording The Audio
Having everything ready, the technical challenges solved, the player shell programmed, and music all composed, it may seem the album is almost ready to release. Only one more step has to be done: prepare the audio files for streaming/digital platforms. As I didn’t have access to a real PET, I could only record the audio from an emulator, which seem like a breeze. However, it turned out to be yet another challenge.
The sound emulation of the PET in the actual version of the WinVICE emulator at the time has been applying a really weird filtering to its audio output. It affected the timbre a lot, and the worst part was that it affected the volume depending on the pitch, reducing it up to almost silence at certain frequencies. Besides that, the latest build of the xpet of the latest WinVICE was simply not working, this particular executable just wasn’t starting at all (all others worked), so I had to stick to the previous release.
MAME’s PET sound emulation quality was much better. However, it was seriously messed up: the CB2 shift register clock was twice higher than it should be, even though the T1 timer was running at proper speed. Besides that, the sound emulation was disabled for all 40xx models for no apparent reason, and I needed a 40xx model to run the player shell that was not designed for 80xx series, and just wouldn’t run there.
To break the circle of trouble, I decided that I have to modify one of the emulators to fix its issues, and get a proper sound output. It turned out that fixing MAME imprecision was easier than removing the filter from VICE. mr287cc helped me to set up the MAME compilation pipeline, and I applied a dirty fix that simply divides the shift register clock by two, and enables sound for all 40xx models. After this I was able to make proper audio and video recording. I added a simple CRT-alike filter to the video using VirtualDub, and applied an impulse response of a small speaker to the audio, to give it a more authentic feel, compared to the clean and harsh idealized sound coming from the emulator
After releasing the album and confirming everything works correctly on different models of the actual hardware, bug reports have been sent to the authors of the respective emulators, supplied with the video proofs. I don’t know if the issues were fixed in the latest versions of the emulators.
### The Legacy
It has been a whole year since the past Winter when the game and music album has been released. This article was on the back burner, and took a long while to get finished and translated to English. In the meantime, a number of unexpected things happened to the game and the album, and they both got a legacy of a kind that is worth mentioning.
*Attack of the PETSCII Robots* has been first released on the three Commodore home computer platforms, as it was planned from the beginning. Even though it looks very simplistic, and has a steep learning curve (without understanding its rules it seems to be lacking any depth), this simplicity combined with the popularity of the author played to its merit: some of David subscribers started to make ports to many other 6502 powered platforms and beyond. At the moment it actually seems to be one of the most ported homebrew games ever, even though it is not an open source or free software project - all the rights reserved to the original author and the source code is only available by a personal request.
At the time there are ten versions of the game available to purchase from David’s web page: PET, VIC-20, C64, Plus/4, C128, Apple II, Atari 8-bit, Amiga, PlayStation Portable, and even ZX Spectrum (more on this below). Each of the ports has its own specific features, different graphics and music, sharing the same general concept and level maps. A dozen more ports are in development, including versions for Sega Genesis, NES, SNES, MS-DOS, Commander X16, and other platforms. The versions and the development process has been covered by David in a video series on his YouTube channel.
In the Autumn 2021, an [ensemble game OST](https://eoxstudios.bandcamp.com/album/attack-of-the-petscii-robots-the-alternate-soundtrack) was released on a compact cassette. It included the original music from the Commodore 64 version, composed by Noelle Aman, and not one, but two alternative soundtracks: one by Anders Enger Jensen (his music is frequent in David’s videos), composed using modern synthesizers, and another one is my Faulty Robots album in full. This is the first time my music has been published on physical media, so it is an honor to share the release with these respectable composers.
 The alternative sound track on a compact cassette.About the same time, I made a port of the Faulty Robots album to the [ESPboy](https://community.espboy.com/), by the platform maintainer request. No special reason behind this, it has been done just for fun, and because it is just another unusual media to share the album.
Faulty Robots running on the ESPboy.Unexpectedly, my involvement with the game did not end with the release of the album. In the late 2021 my retro game development fellow [mr287cc](https://www.patreon.com/8bitbay) and I were evaluating the idea of a static assembly source code translation between different classic CPU architectures - it would be a kind of holy grail for some of our projects. As PETSCII Robots was missing a Z80 port, an idea arose to try to make a translator using this game code as a test suite, like do two good things at once. Our idea kinda failed, as it turned out to be pretty tricky to get efficient enough code without bloating it 10 times (yes, 6502 and Z80 are that different), but we’re decided to translate the game code manually, to gain better experience of porting between these architectures. We did the port extremely close to the original code design, including keeping original 6502-optimal data structures, which aren’t really fit to Z80 architecture, so it was pretty inefficient, however, it kept the original gameplay and even original quirks very authentic.
We used our Z80 code port to create a version for ZX Spectrum 48K. mr287cc did the main chunk of the work, I just translated the AI routines, helped to debug some things, created some extra graphics for the ‘mini’ version of the game, and of course I handled all the sound code, including a couple dozens of brand new pretty complex, gameplay-interrupting sound effects (created using my old tool called BeepFX), and three songs from Faulty Robots for the title, lose and win screens. So the sound part of this port is now strictly matched to my vision that I had at the very beginning of the project. Besides the game itself, I also ported the whole album, with all songs included, as a separate program.
Color Mini Bots version of Attack of the PETSCII Robots for ZX Spectrum 48K.ZX Spectrum 48K version of the game is [available for purchase](https://www.the8bitguy.com/product/petscii-robots-for-zx/) at David’s web page as well, digital release only at the moment. Hopefully eventually it’ll get a limited physical media release, too.
Near completion of writing of this article, I finally cleaned up and [published the full source code](http://shiru.untergrund.net/files/src/peskytone_src.zip) of my sound system, now called PeskyTone, that supports PET, VIC-20, C64, and the NES. I don’t think it has any importance outside of the PET realm, but it may serve as a kind of a Hello World example for the said platforms, as it is kinda difficult to find one for these. | https://habr.com/ru/post/650905/ | null | en | null |
# Топ ошибок со стороны разработки при работе с PostgreSQL
[HighLoad++](https://www.highload.ru/) существует давно, и про работу с PostgreSQL мы говорим регулярно. Но у разработчиков все равно из месяца в месяц, из года в год возникают одни и те же проблемы. Когда в маленьких компаниях без DBA в штате случаются ошибки в работе с базами данных, в этом нет ничего удивительного. В крупных компаниях тоже нужны БД, и даже при отлаженных процессах все равно случаются ошибки, и базы падают. Неважно, какого размера компания — ошибки все равно бывают, БД периодически обваливаются, рушатся.
С вами такого, конечно, никогда не случится, но проверить чек-лист не трудно, а сэкономить будущих нервов он может очень прилично. Под катом перечислим топ типичных ошибок, которые совершают разработчики при работе с PostgreSQL, разберемся, почему так делать не надо, и выясним, как надо.
**О спикере: Алексей Лесовский** ([lesovsky](https://habr.com/ru/users/lesovsky/)) начинал системным администратором Linux. От задач виртуализации и систем мониторинга постепенно пришел к PostgreSQL. Сейчас PostgreSQL DBA в [Data Egret](https://blog.dataegret.com/) — консалтинговой компании, которая работает с большим количеством разных проектов и видит много примеров повторяющихся проблем. Это [ссылка](http://www.highload.ru/moscow/2018/abstracts/4018) на презентацию доклада на HighLoad++ 2018.
Откуда берутся проблемы
-----------------------
Для разминки, несколько историй о том, как возникают ошибки.
### История 1. Фичи
Одна из проблем — это то, какими фичами пользуется компания при работе с PostgreSQL. Начинается все просто: PostgreSQL, наборы данных, простые запросы с JOIN. Берем данные, делаем SELECT — все просто.
Потом начинаем использовать дополнительную функциональность PostgreSQL, добавляем новые функции, расширения. Фич становится больше. Подключаем потоковую репликацию, шардирование. Вокруг появляются разные утилиты и обвесы — pgbouncer, pgpool, patroni. Примерно так.
> Каждое ключевое слово — повод появиться ошибке.
### История 2. Хранение данных
То, как мы храним данные, тоже источник ошибок.
Когда проект только появился, в нем довольно мало данных и таблиц. Достаточно простых запросов, чтобы получать и записывать данные. Но потом таблиц становится все больше. Данные выбираются из разных мест, появляются JOIN. Запросы усложняются и включают в себя CTE-конструкции, SUBQUERY, IN-списки, LATERAL. Допустить ошибку и написать кривой запрос становится гораздо легче.
И это только верхушка айсберга — где-то сбоку могут быть еще 400 таблиц, партиций, из которых тоже изредка читаются данные.
### История 3. Жизненный цикл
История о том, как продукт сопровождается. Данные всегда нужно где-то хранить, поэтому всегда есть базы данных. Как развивается БД, когда развивается продукт?
С одной стороны, есть **разработчики**, которые заняты языками программирования. Они пишут свои приложения и развивают навыки в области разработки ПО, не обращая внимания на сервисы. Часто им неинтересно, как работает Kafka или PostgreSQL — они разрабатывают новые фичи в своем приложении, и до остального им дела нет.
С другой стороны — **админы**. Они поднимают новые инстансы в Amazon на Bare-metal и заняты автоматизацией: настраивают деплой, чтобы хорошо работала выкладка, и конфиги, чтобы сервисы хорошо взаимодействовали между собой.
Складывается ситуация, когда на тонкий тюнинг компонентов, и БД в том числе, не остается времени или желания. Базы работают с дефолтными конфигами, а потом про них и вовсе забывают — «работает, не трогай».
В итоге в самых разных местах разбросаны грабли, которые то и дело прилетают в лоб разработчикам. В этой статье постараемся все эти грабли собрать в один сарайчик, чтобы вы про них знали и при работе с PostgreSQL на них не наступали.
Планирование и мониторинг
-------------------------
Сначала представим, что у нас есть новый проект — это всегда активная разработка, проверка гипотез и реализация новых фич. В момент, когда приложение только-только появилось и развивается, у него мало трафика, пользователей и клиентов, и все они генерируют небольшие объемы данных. В БД работают простые запросы, которые быстро отрабатываются. Не нужно тягать большие объемы данных, нет никаких проблем.
Но вот пользователей больше, приходит трафик: появляются новые данные, базы растут и старые запросы перестают работать. Нужно достраивать индексы, переписывать и оптимизировать запросы. Появляются проблемы производительности. Все это приводит к алертам в 4 утра, стрессу для админов и недовольству руководства.
### Что не так?
> По моему опыту, чаще всего не хватает дисков.
**Первый пример**. Открываем график мониторинга утилизации диска, и видим, что **заканчивается свободное пространство на диске**.
Смотрим сколько места и чем съедено — оказывается, есть каталог pg\_xlog:
```
$ du -csh -t 100M /pgdb/9.6/main/*
15G /pgdb/9.6/main/base
58G /pgdb/9.6/main/pg_xlog
72G итого
```
Админы баз данных обычно знают, что это за каталог, и его не трогают — существует и существует. Но разработчик, особенно если он смотрит на staging, чешет голову и думает:
*— Какие-то логи… Давайте удалим pg\_xlog!*
**Удаляет каталог, база перестает работать**. Тут же приходится гуглить, как поднять базу после того, как удалил журналы транзакций.
**Второй пример**. Опять открываем мониторинг и видим, что места не хватает. На сей раз место занято какой-то базой.
```
$ du -csh -t 100M /pgdb/9.6/main/*
70G /pgdb/9.6/main/base
2G /pgdb/9.6/main/pg_xlog
72G итого
```
Ищем, какая база занимает больше всего места, какие таблицы и индексы.
Выясняется, что это таблица с историческими логами. Исторические логи нам никогда были не нужны. Они пишутся на всякий случай, и, если бы не проблема с местом, в них бы никто не смотрел до второго пришествия:
*— Давайте, зачистим всё, что мм… старше октября!*
Составим update-запрос, запустим его, он отработает и удалит часть строк.
```
=# DELETE FROM history_log
-# WHERE created_at < «2018-10-01»;
DELETE 165517399
Time: 585478.451 ms
```
Запрос работает 10 минут, но таблица по-прежнему занимает столько же места.
PostgreSQL удаляет строки из таблицы — все верно, но он не возвращает место операционной системе. Такое поведение PostgreSQL неизвестно большинству разработчиков и может сильно удивить.
**Третий пример**. Например, ОРМ составил интересный запрос. Обычно все винят ОРМ в том, что они составляют «плохие» запросы, которые вычитывают несколько таблиц.
Допустим, там несколько операций JOIN, которые читают таблицы параллельно в несколько потоков. PostgreSQL умеет параллелить операции работы с данными и может читать таблицы в несколько потоков. Но, учитывая, что у нас несколько серверов приложений, этот запрос вычитывает все таблицы несколько тысяч раз в секунду. Получается, что сервер баз данных перегружается, диски не справляются, и все это приводит к ошибке **502 Bad Gateway** c бэкенда — база недоступна.
Но это еще не все. Можно вспомнить про другие особенности PostgerSQL.
* **Тормоза фоновых процессов СУБД** — в PostgreSQL есть всякие checkpoint’ы, vacuum’ы, репликация.
* **Накладные расходы от виртуализации**. Когда база запущена на виртуальной машине, на этой же железке сбоку есть еще виртуальные машины, и они могут конфликтовать за ресурсы.
* **Хранилище от китайского производителя NoName**, производительность которого зависит от Луны в Козероге или положения Сатурна, и разобраться, почему оно работает именно так, нет возможности. База страдает.
* **Дефолтные конфигурации**. Это моя любимая тема: заказчик говорит, что у него тормозит база — смотришь, а у него дефолтный конфиг. Дело в том, что дефолтный конфиг PostgreSQL предназначен для того, чтобы **запускаться на самом слабом чайнике**. База запускается, работает, но когда она работает уже на железе среднего уровня, то этого конфига недостаточно, его нужно тюнить.
> Чаще всего PostgreSQL не хватает либо дискового пространства, либо дисковой производительности. К счастью, с процессорами, памятью, сетью, как правило, все более-менее в порядке.
Как быть? Нужен мониторинг и планирование! Казалось бы — очевидно, но почему-то в большинстве случаев никто не планирует базу, а мониторинг не покрывает всего того, что нужно отслеживать при эксплуатации PostgreSQL. Есть набор четких правил, при соблюдении которых все будет работать хорошо, а не «на авось».
### Планирование
**Размещайте базу данных на SSD не раздумывая**. SSD давно стали надежными, стабильными и производительными. Энтерпрайзные модели SSD работают годами.
**Всегда планируйте схему данных**. Не пишите в БД то, что вы сомневаетесь, что понадобится — гарантированно не понадобится. Простой пример — немного измененная таблица одного из наших клиентов.
Это таблица логов, в которой есть колонка data с типом json. Условно говоря, в эту колонку можно записать что угодно. Из последней записи этой таблицы видно, что логи занимают 8 Мб. В PostgreSQL нет проблем с хранением записей такой длины. У PostgreSQL очень хороший storage, который прожёвывает такие записи.
Но проблема в том, что когда серверы приложений будут вычитывать данные из этой таблицы, они запросто забьют всю пропускную способность сети, и другие запросы будут страдать. В этом заключается проблема планирования схемы данных.
**Используйте партиционирование при любых намеках на историю, которую необходимо хранить больше двух лет**. Партиционирование иногда кажется сложным — нужно заморачиваться с триггерами, с функциями, которые будут создавать партиции. В новых версиях PostgreSQL ситуация лучше и сейчас настройка партиционирования сильно проще — один раз сделал, и работает.
В рассмотренном пример удаления данных за 10 минут, `DELETE` можно заменить на `DROP TABLE` — такая операция в аналогичных обстоятельствах займет всего несколько миллисекунд.
Когда данные рассортированы по партициям, партиция удаляется буквально за несколько миллисекунд, и место ОС отдается сразу. Управлять историческими данными так легче, проще и безопаснее.
### Мониторинг
Мониторинг — отдельная большая тема, но с точки зрения БД есть рекомендации, которые можно уместить в один раздел статьи.
По умолчанию многие системы мониторинга предоставляют мониторинг процессоров, памяти, сети, дискового пространства, но, как правило, **нет утилизации дисковых устройств**. Информацию о том, насколько загружены диски, какая пропускная способность в данный момент на дисках и значение latency, нужно всегда добавлять в мониторинг. Это поможет быстро оценить, как загружены диски.
Вариантов мониторинга PostgreSQL очень много, есть на любой вкус. Вот некоторые моменты, которые обязательно должны присутствовать.
* **Подключенные клиенты**. Нужно отслеживать, с какими статусами они работают, быстро находить «вредных» клиентов, которые вредят базе, и отключать их.
* **Ошибки**. Нужно мониторить ошибки, чтобы отслеживать, насколько хорошо работает база: нет ошибок — замечательно, появились ошибки — повод заглянуть в логи и начать разбираться, что идет не так.
* **Запросы (statements)**. Мониторим количественные и качественные характеристики запросов, чтобы примерно оценивать, нет ли у нас медленных, долгих или ресурсоемких запросов.
За более детальной информацией обратитесь к докладу [«Основы мониторинга PostgreSQL»](https://youtu.be/Hbi2AFhd4nY) с HighLoad++ Siberia и страницу [Monitoring](https://wiki.postgresql.org/wiki/Monitoring) в PostgreSQL Wiki.
Когда мы все спланировали и «обмазались» мониторингом, мы все равно можем столкнуться с некоторыми проблемами.
### Масштабирование
Обычно разработчик видит БД строчкой в конфиге. Ему не особо интересно, как она устроена внутри — как работает checkpoint, репликация, планировщик. Разработчику и так есть, чем заняться — в todo стоит много интересных вещей, которые ему хочется попробовать.
> «Дайте мне адрес базы, дальше я сам». © Anonymous developer.
Незнание предмета приводит к довольно интересным последствиям, когда разработчик начинает писать запросы, которые работают в этой базе. Фантазии при написании запросов порой дают ошеломляющие эффекты.
Есть два типа транзакций. **OLTP транзакции** — быстрые, короткие, легкие, которые выполняются доли миллисекунд. Они отрабатывают очень быстро, и их очень много. **OLAP — аналитические запросы** — медленные, долгие, тяжелые, читают большие массивы таблиц и считают статистику.
Последние 2-3 года часто звучит аббревиатура **HTAP** — Hybrid Transaction / Analytical Processing или **гибридный транзакционно-аналитический процессинг**. Если вам некогда думать над масштабированием и разнесением OLAP и OLTP запросов, можно говорить: «У нас HTAP!» Но опыт и боль ошибок показывают, что все-таки разные типы запросов должны жить отдельно друг от друга, потому что долгие запросы OLAP блокируют легкие OLTP-запросы.
Так мы подходим к вопросу, как масштабировать PostgreSQL так, чтобы разнести нагрузку, и все остались довольны.
**Streaming replication**. Самый простой вариант — **потоковая репликация**. Когда приложение работает с базой, подключаем к этой базе несколько реплик и распределяем нагрузку. Запись по-прежнему идет в мастер-базу, а чтение на реплики. Такой способ позволяет масштабироваться очень широко.
Плюс к отдельным репликам можно подключить еще реплики и получить **каскадную репликацию**. Отдельные группы пользователей или приложения, которое, например, читает аналитику, можно вынести на отдельную реплику.
**Logical publications, subscriptions** — механизм логических публикаций и подписок предполагает наличие нескольких независимых PostgreSQL-серверов с отдельными базами и наборами таблиц. Эти наборы таблиц можно подключать в соседние базы, они будут видны приложениям, которые смогут ими нормально пользоваться. То есть все изменения, которые происходят в источнике, реплицируются на базу назначения и там видны. Прекрасно работает с PostgreSQL 10.
**Foreign tables, Declarative Partitioning — декларативное партиционирование и внешние таблицы**. Можно взять несколько PostgreSQL и создать там несколько наборов таблиц, которые будут хранить нужные диапазоны данных. Это могут быть данные за конкретный год или данные, собранные по любому range.
С помощью механизма внешних таблиц можно объединить все эти базы в виде партиционированной таблицы в отдельной PostgreSQL. Приложение может работать уже с этой партиционированной таблицей, но на самом деле оно будет читать данные с удаленных партиций. Когда объемы данных больше возможностей одного сервера, то это шардинг.
Это все можно объединять в развесистые конфигурации, придумывать разные топологии репликации PostgreSQL, но как все это будет работать и как этим управлять — тема отдельного доклада.
### С чего начать?
Самый простой вариант — **с репликации**. Первый шаг — разнести нагрузку на чтение и на запись. То есть писать в мастер, а читать с реплик. Так мы масштабируем нагрузку и выносим чтение с мастера. Кроме того, не забываем про аналитиков. Аналитические запросы работают долго, для них нужна отдельная реплика с отдельными настройками, чтобы долгие аналитические запросы могли не мешать остальным.
Следующий шаг — **балансировка**. У нас по-прежнему остается та самая строчка в конфиге, которой оперирует разработчик. Ему нужно место, куда он будет писать и читать. Здесь есть несколько вариантов.
Идеальный — реализовывать балансировку **на уровне приложения**, когда приложение само знает, откуда ему читать данные, и умеет выбирать реплику. Допустим, баланс счета всегда нужен актуальный и его нужно прочитать с мастера, а картинку товара или информацию о нем можно прочитать с некоторой задержкой и сделать это с реплики.
* **DNS Round Robin**, на мой взгляд, не очень удобная реализация, поскольку иногда работает долго и не дает необходимого времени при переключении ролей мастера между серверами в случаях failover.
* Более интересный вариант — использование **Keepalived и HAProxy**. Виртуальные адреса для мастера и набора реплик перекидываются между серверами HAProxy, а HAProxy уже осуществляет балансировку трафика.
* **Patroni, DCS** в связке с чем-то типа ZooKeeper, etcd, Consul — самый интересный вариант, на мой взгляд. То есть service discovery отвечает за информацию, кто сейчас мастер, а кто реплики. Patroni управляет кластером PostgreSQL’ов, осуществляет переключение — если топология изменилась, эта информация появится в service discovery, и приложения смогут оперативно узнать текущую топологию.
И с репликацией бывают нюансы, самый частый из них — **лаг репликации**. Можно сделать, как GitLab, и когда накопится лаг, просто дропнуть базу. Но у нас же есть всесторонний мониторинг — смотрим его и видим долгие транзакции.
### Приложения и СУБД-транзакции
В общем случае медленные и ничего не делающие транзакции приводят к:
* **снижению производительности** — не к резкому скачкообразному, а плавному;
* **блокировкам и дедлокам**, потому что долгие транзакции удерживают блокировки на строки и мешают другим транзакциям работать;
* **ошибкам HTTP 50\* на бэкенде**, к ошибкам в интерфейсе или где-то еще.
Рассмотрим немного теории о том, как же возникают эти проблемы, и почему механизм долгих и ничего не делающих транзакций (idle transactions) вреден.
В PostgreSQL есть MVCC — условно говоря, движок БД. Он позволяет клиентам конкурентно работать с данными, не мешая при этом друг другу: читатели не мешают читателям, а писатели не мешают писателям. Конечно, есть некоторые исключения, но в данном случае они не важны.
Получается, что в базе для одной строки может существовать несколько версий для разных транзакций. Клиенты подключаются, база выдает им снимки данных, и в рамках этих снимков могут существовать разные версии одной и той же строки. Соответственно, в жизненном цикле базы транзакции сдвигаются, заменяют друг друга, и появляются версии строк, которые уже никому не нужны.
Так возникает **необходимость в сборщике мусора — auto vacuum**. Долгие транзакции существуют и мешают auto vacuum вычистить ненужные версии строк. Эти мусорные данные начинают кочевать из памяти на диск, из диска в память. На то, чтобы хранить этот мусор, тратятся ресурсы CPU и памяти.
> Чем дольше транзакции — тем больше мусора и ниже производительность.
С точки зрения «Кто виноват?», в появлении долгих транзакций виновато именно приложение. Если база будет существовать сама по себе, долгие, ничего не делающие транзакции ниоткуда не возьмутся. На практике же есть следующие варианты появления idle транзакций.
**«Давайте сходим во внешний источник»**. Приложение открывает транзакцию, что-то делает в базе, потом решает обратиться к внешнему источнику, например, Memcached или Redis, в надежде, что потом вернется в базу, продолжит работу и закроет транзакцию. Но если во внешнем источнике происходит ошибка, приложение падает, и транзакция остается незакрытой, пока ее кто-нибудь не заметит и не убьет.
**Нет обработки ошибок**. С другой стороны, может быть проблема обработки ошибок. Когда опять же приложение открыло транзакцию, решило какую-то задачу в базе, вернулось к исполнению кода, выполнило какие-то функции и вычисления, чтобы дальше продолжить работу в транзакции и закрыть ее. Когда на этих вычисления работа приложения прервалась с ошибкой, код вернулся в начало цикла, а транзакция опять осталась незакрытой.
**Человеческий фактор**. Например, админ, разработчик, аналитик, работает в каком-нибудь pgAdmin или в DBeaver — открыл транзакцию, что-то в ней делает. Потом человека отвлекли, он переключился на другую задачу, потом на третью, забыл про транзакцию, ушел на выходные, а транзакция продолжает висеть. Производительность базы страдает.
Давайте разберем, что делать в этих случаях.
* У нас есть мониторинг, соответственно, нужны **алерты в мониторинге**. Любая транзакция, которая висит больше часа и ничего не делает — повод посмотреть, откуда она взялась, и разбираться, что не так.
* Следующий шаг — **отстрел таких транзакций через задачу в кроне** (pg\_terminate\_backend(pid)) или настройку в конфиге PostgreSQL. Нужны пороговые значения в 10-30 минут, после которых транзакции автоматически завершаются.
* **Рефакторинг приложения**. Конечно же, нужно выяснить, откуда берутся idle транзакции, почему они происходят и устранять такие места.
> Избегайте долгих транзакций любой ценой, потому что они очень сильно влияют на производительность базы данных.
Все становится еще интересней, когда появляются отложенные задачи, например, нужно аккуратно посчитать агрегаты. И мы подходим к вопросу велосипедостроения.
### Велосипедостроение
Больная тема. Бизнесу со стороны приложения нужно производить фоновую обработку событий. Например, рассчитывать агрегаты: минимальное, максимальное, среднее значение, рассылать уведомления пользователям, выставлять счета клиентам, настраивать кабинет пользователя после регистрации или регистрировать в соседних сервисах — делать отложенную обработку.
Суть у таких задач одна — они откладываются на потом. В базе появляются таблицы, которые как раз осуществляют очереди.
Здесь есть идентификатор задачи, время, когда задача была создана, когда обновлена, хэндлер, который её взял, количество попыток выполнения. Если у вас есть таблица, которая хотя бы отдаленно напоминает эту, значит, у вас есть **самописные очереди**.
Все это работает прекрасно, пока не появляются долгие транзакции. После этого **таблицы, которые работают с очередями, распухают в размерах**. Новые jobs все время добавляются, старые удаляются, происходят апдейты — получается таблица с интенсивной записью. Её нужно регулярно чистить от устаревших версий строк, чтобы не страдала производительность.
**Растет время обработки** — долгая транзакция удерживает блокировку на устаревшие версии строк или мешает vacuum ее почистить. Когда таблица увеличивается в размерах, время обработки тоже увеличивается, так как нужно прочитать много страниц с мусором. Время увеличивается, и **очередь в какой-то момент перестает работать вообще**.
Ниже пример топа одного нашего заказчика, у которого была самописная очередь. Все запросы как раз связаны с очередью.
Обратите внимание на время выполнения этих запросов — все, кроме одного, работают по двадцать с лишним секунд.
Чтобы решить эти проблемы давно изобретен **Skytools PgQ** — менеджер очередей для PostgreSQL. Не изобретайте свой велосипед — возьмите PgQ, один раз настройте и забудьте про очереди.
Правда, и у него есть особенности. У Skytools PgQ **мало документации**. После чтения официальной страницы, складывается ощущение, что ничего не понял. Ощущение растет, когда что-то пробуешь сделать. Все работает, но **как работает — не понятно**. Какая-то джедайская магия. Но многую информацию можно получить в **Mailing-lists**. Это не очень удобный формат, но много интересного находится именно там, и эти листы придется читать.
Несмотря на минусы, Skytools PgQ работает по принципу «настроил и забыл». Создается триггерная функция, которая вешается на таблицу, с которой хотим получать изменения, и все работает надежно. Практически про PgQ вспоминают, когда нужно добавить еще одну таблицу в очередь. Использовать PgQ дешевле, чем поддержка и настройка отдельных брокеров.
> Если столкнулись с задачей, с которой кто-то уже скорее всего сталкивался — поищите инструменты, которые уже изобретены. Это особенно относится к очередям.
В своей практике мы выпилили очень много самописных очередей и заменили их на PgQ. Конечно, бывают большие инсталляции PostgreSQL, например, в Авито, где возможностей PgQ не хватает. Но это единичные кейсы, которые решаются отдельно.
### Автоматизация
Админы хотят от автоматизации получить возможность раскатывать инстансы, чтобы деплой работал без их вмешательства и конфиги раскатывались мгновенно. А разработчики хотят, чтобы деплой работал так, чтобы, как только они закомитили какие-то изменения, они дальше подтянулись, оттестировались, разлились и все бы было хорошо. Конечно, они хотят катить миграции без ручного вмешательства, чтобы не надо было логиниться на сервер, руками выполнять alter.
Все вместе они хотят **auto-failover** — если вдруг во время работы кластера PostgreSQL произойдет какой-нибудь сбой, роль мастера автоматически перекинется на другой сервер, а мы об этом даже ничего не знали. Но есть несколько очень серьёзных проблем, которые мешают использованию auto-failover.
**Split-brain**. В нормальном кластере PostgreSQL с мастером и несколькими репликами, запись идет в один сервер, чтение — с реплик. Если происходит сбой, то сервер выключается. Но в PostgreSQL из коробки нет механизма fencing, и часто даже в Kubernets его приходится настраивать отдельно. При сбое приложение может по-прежнему писать в старый мастер, а новое переключившееся приложение начинает писать в новый мастер. Возникает ситуация Split-brain.
Попытка восстановить консистентность может быть очень тяжелой и потребует много нервов. Когда GitHub столкнулся со Split-brain, им пришлось восстанавливать свою базу из бэкапа.
**Cascade failover**. Допустим, есть мастер и несколько реплик. Мастер падает, и нагрузка переключается на новый мастер и оставшиеся реплики.
Старый мастер не успел переинициализироваться и стать репликой, а в этот момент падает другой мастер. На это уходят секунды, и вся нагрузка приходится на единственный сервер.
Он не справляется с нагрузкой и тоже отказывает — получается каскадный failover.
Если все же браться за auto-failover, то есть следующие пути.
**Bash скрипты** — хрупкое решение, которое нужно постоянно тестировать и отлаживать. Один админ ушел, другой пришел и не знает, как этим пользоваться. Если вдруг что-то сломалось, очень тяжело найти, где что произошло. Такое решение требует постоянной доработки.
**Ansible playbooks** — bash-скрипты на стероидах. Тоже нужно постоянно проверять, что все работает, прогонять на тестовых кластерах.
[**Patroni**](https://github.com/zalando/patroni) — на мой взгляд, один из лучших продуктов, потому что у него есть auto-failover, мониторинг состояния кластера, плюс функция отдачи топологии кластера в service discovery.
[**PAF**](https://github.com/clusterlabs/PAF) — **основан на Pacemaker**. Тоже интересный инструмент для auto-failover в PostgreSQL, но он уже сложнее и требует знания Pacemaker.
[**Stolon**](https://github.com/sorintlab/stolon) больше предназначен для облачных задач. Для Kubernetes, например. Stolon сложнее Patroni, но они взаимозаменяемы и можно выбирать между ними.
### Контейнеры и оркестрация
В последние годы Docker и Kubernetes растут. Это динамично развивающиеся технологии, в которых появляется много нового.
В каждой новой версии добавляется много интересной функциональности, правда при этом старая может перестать работать. *С «А что если развернуть базу в Kubernetes...»* начинаются разные удивительные истории.
**База — это всегда stateful**, ее нужно где-то хранить. Где? На ум приходит отказоустойчивое сетевое хранилище. Решения из Open Source: CEPH, GlusterFS, LinStor DRBD. Фундаментальная проблема в том, что все это работает очень медленно и, наверное, никогда не станет работать быстро.
Бонусом вы получаете дополнительную головную боль — **необходимость поддерживать кластерную файловую систему**. Например, если вы знакомы только с Kubernetes, вам придется глубоко изучить CEPH. Это сложная система с большим багажом своих проблем — придется наращивать свою экспертизу. Если говорить в целом про сетевые хранилища и базы в них, то это работает пока выполняется три требования.
* **Размер базы небольшой**, и не нужно передавать Гб и десятки Гб данных между узлами.
* **Нет требований к производительности и latency**. Если latency увеличивается до десятков или даже сотен миллисекунд — это совершенно нерабочее решение.
* **Не страшно потерять данные**. Kubernetes развивается, в нем находят какие-то баги. Движки, которые позволяют делать shared storage для Kubernetes, тоже развиваются и там тоже находят баги. В какой-то момент можно просто напороться на баг и все потерять.
Этот подводит нас к тому, что хорошо использовать Kubernetes и Docker для БД на staging или dev-серверах либо на этапе проверки гипотез. Но для высоких нагрузок, на мой взгляд, Kubernetes и шаредные хранилища не очень хороши.
Но если сильно хочется, то оптимальным вариантом будут **local volumes — локальные хранилища** без использования шаредных файловых систем, **streaming replication — нативная потоковая репликация**, через которую идет синхронизация данных и **PostgreSQL-операторы**, которые предоставляют нам нечто вроде кнопки — нажал, и все заработало. На данный момент есть два таких оператора: [Zalando](https://github.com/zalando-incubator/postgres-operator) и [Crunchy](https://github.com/CrunchyData/postgres-operator).
Конечно же стоит помнить, что это все динамично развивается. Посмотрите на количество issues и pull requests. Появляются новые фичи, в них могут скрываться ошибки, поэтому внедряйте контейнеризацию без фанатизма.
Итоги
-----
**Когда вы занимаетесь планированием и мониторингом не экономьте на SSD** — они относительно дешевы и оттянут проблемы с производительностью на год, а то и больше.
**Не пишите в базу все подряд**. Практика писать JSON на 8 Мб — это плохо, так делать нельзя.
**Мониторинг нужен**, причем не оставляйте его в дефолтно настроенном состоянии. Мониторьте PostgreSQL, расширяйте ваш мониторинг.
**Разносите нагрузку — Postgres is ready**. Старайтесь не читать и не писать данные из одного места. PostgreSQL очень хорошо масштабируется, и есть варианты его масштабирования на любой вкус. Для масштабирования нагрузки используйте: **streaming replication; publications, subscriptions; foreign Tables; declarative partitioning**.
**Избегайте ничего не делающих транзакций**. Они снижают производительность и очень медленно, но верно убивают базу.
Если вы делаете что-то, что уже могло понадобиться другим людям, посмотрите вокруг — **возможно все уже есть**. Это напрямую касается очередей. Не изобретайте самописные очереди, используйте Skytools PgQ!
**Если очень хочется базу в Kubernetes, используйте local volumes, streaming replication и PostgreSQL операторы**. С этим можно хоть как-то работать, но без фанатизма, потому что все очень быстро меняется.
> Не пропустите новую возможность обсудить высокие нагрузки и услышать среди прочего об администрировании баз данных. На этот раз в Новосибирске, где уже 24 и 25 июня на [HighLoad++ Siberia](https://www.highload.ru/siberia/2019/) коллега Алексея Андрей Сальников [расскажет](https://www.highload.ru/siberia/2019/abstracts/5425) о том, как построить рабочий процесс, когда у тебя несколько сотен баз данных с абсолютно разной нагрузкой. И еще 38 классных докладов в [расписании](https://www.highload.ru/siberia/2019/schedule) — отличный повод приехать на конференцию! | https://habr.com/ru/post/455248/ | null | ru | null |
# HMVC в пространстве имен
В последнее время очень много говорится о схеме проектирования [MVC](http://ru.wikipedia.org/wiki/MVC), почти все популярные PHP-фреймворки уже давно перешли на эту схему. Что же касается [Kohana](http://kohanaframework.org/), то начиная с версии 3, реализована иерархическая схема MVC – [HMVC](http://ru.wikipedia.org/wiki/HMVC). Преимущества HMVC, всем понятны и мы не будем их здесь обсуждать.
Я, как желающий сменить статус «программиста-любителя» на «программиста-профессионала» решил, что уже достаточно изучил PHP и пора начинать работать с фреймворками, выбор моего самого первого фреймворка пал на именно Kohana, т.к. в нем реализуется HMVC, ну и вообще, его много хвалят за простоту.
В реальности все оказалось не просто, но особенно напрягало отсутствие изолированности триад MVC, триады разбивались на части и помещались в разные папки. В моем понимании, триада *Model-View-Controller*, должны быть изолированны от других триад, и находиться в одной папке, конечно, это можно было реализовать в Kohana, но все будет выглядеть очень «коряво» и запутанно. Еще было не понятно, почему не используется такая замечательная возможность **PHP** как пространство имен? Просмотрел еще несколько HMVC-фреймворков, но не к одному «душа не легла». Тогда я решил самостоятельно реализовать HMVC.
Сразу установил несколько директив:
* Должно использоваться пространство имен
* Автозагрузка классов работает на пространстве имен
* В автозагрузку можно добавлять несколько папок
* Каждое приложение имеет свою папку, на которую устанавливается автозагрузка
* Каждая триада, в том числе и шаблоны, помещается в отдельную папку, соответственно, находятся в своем пространстве имен
* По умолчанию, части MVC называются своими именами, *Controller*, *Model* и *View*, в каждой папке триады должна быть папка *templates* для шаблонов
* Очень простой роутинг, URI просто разбивается в массив
* *Controller* похож на *Kohana\_Controller*
* *Controller* получает информацию о том, что от него хотят в конструкторе, разбирает информацию URI-массива, после чего запускает метод *action()*
* Метод *action()* проверяет методы объекта и запускает соответственно *action\_действие()*
* Генерация HTML, осуществляется методом контроллера *render()*
Потом добавил еще несколько:
* Роутинг осуществляет расширенный контроллер, он разбивает URI в массив, сначала проверяет свои *actions*, если не находит, то ищет зарегистрированный контроллер
* Результат работы модели сохраняется в контроллере, передается в *View*, при создании в методе контроллера *render()*
* Метод *action()* публичный, созданный контроллер можно еще раз запустить и сгенерировать HTML
* *View* похож на *Kohana\_View*, для приложения, *View* необходимо «вытащить» в глобальное пространство имен при помощи наследования, заодно немного настроив, все остальные *View* должны быть наследниками глобального *View*
* *Контроллеры* и *View* должны знать в какой папке и в каком пространстве имен они находятся, для этого они наследуются от специального класса *NameSpaceAdapter*, это нужно для правильного поиска *View* из контроллера, а так же папки *templates* из родительского *View*
* Главный шаблон для каждой триады — *template.php*
* Контроллеры автоматически передают в *View* свой *action*, на основании этой информации *View* из главного шаблона *template.php* самостоятельно ищет нужный шаблон *action.php*, поэтому не должно быть *action\_template()*, это приведет к зацикливанию шаблонов
* Для администрирования можно создать шаблоны с префиксом *admin\_action.php*, которые можно вызвать только если установлена константа ADMIN
В итоге получилась небольшая HMVC структура, *Model* не играет роли, поэтому код не привожу, скажу только, что склоняюсь к статическому классу.
Итак, самый первый класс **Autoload**:
**Раскрыть**
```
class Autoload {
static $dirs=array();
// необходимо добавлять папку с последнем слэшем!
static function add( $dir ){
if( !in_array($dir,self::$dirs) ){
self::$dirs[]=$dir;
}
}
static function findClass( $className ){
$path=str_replace('\\','/',$className).'.php';
foreach( self::$dirs as $dir ){
$file=$dir.$path;
if( is_file($file) ){
return $file;
}
}
return false;
}
static function loadClass( $className ){
if( $file=self::findClass( $className ) ){
require $file;
}
}
}
spl_autoload_register( '\\Autoload::loadClass' );
Autoload::add( __DIR__.'/');
```
Класс **NameSpaceAdapter**:
**Раскрыть**
```
namespace lib;
class NameSpaceAdapter {
public function getDirectory(){
return dirname( \Autoload::findClass( get_class($this) ) ).'/';
}
public function getNameSpace(){
$c=trim(str_replace('\\',' ',get_class($this)));
$path=explode(' ',$c);
if( count($path) ){
array_pop($path);
return ('\\'.implode('\\',$path));
}
return null;
}
}
```
Класс **Controller**:
**Раскрыть**
```
namespace lib;
class Controller extends NameSpaceAdapter {
protected $view_data=array();
protected $params=array();
protected $action=null;
protected $uri=null;
public function __construct( $a_uri=null , $controller_uri=null ){
$this->uri=$controller_uri;
if( is_array($a_uri) && count($a_uri) ){
$action=$a_uri[0];
if( is_numeric($action) ){
$this->action='show';
$this->params=$a_uri;
}else{
$this->action=array_shift($a_uri);
$this->params=$a_uri;
}
}else{
$this->action='index';
}
$this->action();
}
public function action( $action=null, array $params=null){
if( $action ) $this->action=$action;
if( $params ) $this->params=$params;
$method='action_'.$this->action;
if( !\method_exists($this,$method) ){
$this->action=null; // стираем на всякий случай
$method='action404';
}
if( $this->before_action() ){
$this->$method();
}else{
$this->setError('Мeтод не доступен');
}
return $this;
}
protected function before_action(){ return true; } // в наследуемых классах здесь можно что-нибудь проверить
protected function before_view(){ } // в наследуемых классах можно что-нибудь сделать
protected function action404(){
$this->setError('Страница не найдена');
}
protected function action_index(){ throw new \Exception('
```
Метод index не реализован'); }
protected function action_show(){ throw new \Exception('
```
Метод show не реализован'); }
protected function setError( $message ){
$this->action='error'; // нужен будет подшаблон error.php
$this->view_data['title']='Ошибка';
$this->view_data['message']=$message;
}
public function render(){
$this->before_view();
// Создание View, берется пространство имен самого последнего потомка, используется NameSpaceAdapter
$viewClass=$this->getNameSpace().'\\View';
$view=new $viewClass();
if( is_array($this->view_data) && count($this->view_data) ){
foreach( $this->view_data as $key=>$value ){
$view->set($key,$value);
}
}
if( $this->action ) $view->set('action',$this->action);
$view->set('uri',('/'.$this->uri));
if( defined('ADMIN') ){ // admin_action.php
if( $this->action ) $view->set('admin_action','admin_'.$this->action);
}
return $view->render();
}
public function __toString(){ return $this->render(); }
}
```
```
```
Класс **Main** — расширение Controller:
**Раскрыть**
```
namespace lib\Controller;
class Main extends \lib\Controller {
protected $controllers=array(); //array( 'uri'=>array( 'title'=>'','class'=>''),...
protected $content_controller; // вызванный контроллер
protected $auth_class='\\lib\\auth\\BasicAdmin'; // класс, проверяющий администратора
function __construct(){
$this->checkAdmin();
$this->init();
$a_uri=$this->read_URI();
$this->call_controller($a_uri);
}
protected function read_URI(){
$arr=explode('?',$_SERVER["REQUEST_URI"]);
$uri=$arr[0];
$dirt_uri=explode('/',$uri);
$a_uri=array();
foreach( $dirt_uri as $i){
if( !empty($i) ) $a_uri[]=$i;
}
return $a_uri;
}
protected function call_controller($a_uri){
/*
метод роутера
сначала ведется поиск собственных action, если action присутствует,
то объект запускается как обычный контроллер
далее ищем контроллеры из списка, если найден, то запускается,
а ссылка на него присваивается $this->content_controller
если путь так и не найден, то запускаем собственный action404
если параметр $a_uri пустой,
то запускаем собственный конструктор с пустыми параметрами, будет вызван index
*/
// обнуление внутренних свойств, т.к. метод может быть запущен из собственных action
$this->action=null;
$this->params=null;
if( is_array($a_uri) && count($a_uri) ){
$method='action_'.$a_uri[0];
// если имеется собственный метод, или передается номер для action_show
if( method_exists($this,$method) || is_numeric($a_uri[0]) ){
parent::__construct($a_uri);
}else{ // метода нет, поиск контроллера
$controller_uri=array_shift( $a_uri );
if( isset($this->controllers[ $controller_uri ]) ){
$this->content_controller=new $this->controllers[ $controller_uri ]['class']( $a_uri , $controller_uri );
}else{
$this->action404();
}
}
}else{
parent::__construct(); // будет вызван action_index
}
}
protected function checkAdmin(){
$auth=new $this->auth_class();
if( $auth->login() ){
define('ADMIN',true);
$this->prepareForAdmin(); // подготовить контроллер для администратора
}
}
public function render(){
/*
проверяется необходимость отображения собственного View,
если определена констанкта AJAX, то выводим отображение только найденного контроллера
для работы AJAX обязательно должен быть content-контроллер
*/
if( defined('AJAX') ){
if( $this->content_controller ){
return $this->content_controller->render();
}else{
return 'Ошибка - контроллер не найден';
}
}else{
if( $this->content_controller ) $this->view_data['content']=$this->content_controller->render();
//$this->view_data['controllers']=$this->controllers;
return parent::render();
}
}
public function action_ajax(){
/*
был запрос uri /ajax/...
устанавливаем констанкту AJAX
*/
define('AJAX',true);
$this->call_controller( $this->params); // снова роутинг
}
public function action_login(){/* ничего не надо делать будет загружен подшаблон login.php */}
public function action_logout(){
$auth=new $this->auth_class();
$auth->logout();
$this->action('index');
}
public function init(){ /* для потомков */}
protected function prepareForAdmin(){/* подготовка контроллера для администратора */}
}
```
Класс **View**:
**Раскрыть**
```
namespace lib;
class View extends NameSpaceAdapter {
static $public_uri; // папка картинок, силей и скриптов, присваивается с последним слешем
static $scripts=array(); // можно подгрузить скрипты, использовать ассоциативный массив
static $styles=array(); // можно подгрузить стили, использовать ассоциативный массив
static $global_data=array(); // глобальные данные
protected $data=array(); // собственные данные, имеют приоритет относительно глобальных
protected $templates_dir='templates'; // папка шаблонов по умолчанию, без последнего слеша
protected $template='template.php'; // главный файл шаблона по умолчанию, поэтому НЕЛЬЗЯ иметь action='template'
static function render_styles(){
/*
генерирует дополнительные скрипты, можно устанавливать из вызываемых контроллеров
вызывать внутри шаблона \View::render_styles()
*/
$html='';
if( is_array(static::$styles) && count(static::$styles) ){
foreach( static::$styles as $style ){
$html.=''."\n";
}
}
return $html;
}
static function render_scripts(){
$html='';
if( is_array(static::$scripts) && count(static::$scripts) ){
foreach( static::$scripts as $script ){
$html.=''."\n";
}
}
return $html;
}
protected function getActionFile(){
$dir=$this->getDirectory().$this->templates_dir.'/';
if( defined('ADMIN') && isset($this->data['admin_action']) ){ // поиск admin_action.php
$file=$dir.$this->data['admin_action'].'.php';
if( !file_exists($file) ) $file=$dir.$this->data['action'].'.php';
}elseif( isset($this->data['action']) ){
$file=$dir.$this->data['action'].'.php';
}
if( $file && file_exists($file)){
return $file;
}else{
return null;
}
}
public function set( $name, $value=null ){
if( is_array($name) ){
foreach( $name as $key=>$value ){
$this->data[$key]=$value;
}
}else{
$this->data[$name]=$value;
}
return $this;
}
public function render(){
/*
функция запускает шаблоны для отображения данных
берется папка по умолчанию (templates), относительно класса
первый файл для отображения template.php, или admin_template.php
извлекаются переменные из View::$global_data - это глобальные переменные
*/
$dir=$this->getDirectory().$this->templates_dir.'/';
if( defined('ADMIN') ){
$template=$dir.'admin_'.$this->template; // вдруг есть admin_template.php
if( !file_exists($template) ) $template=$dir.$this->template;
}else{
$template=$dir.$this->template;
}
extract( static::$global_data );
extract( $this->data, EXTR_OVERWRITE );
$public_uri=static::$public_uri;
ob_start();
require ($template);
return ob_get_clean();
}
static function microRender( $template, $data ){
/*
важно использовать эту функцию в нужном пространстве имен,
шаблон запускается "напрямую" без template.php
*/
$dir=dirname( \Autoload::findClass(get_called_class()) );
$file=$dir.'/templates/'.$template.'.php';
if( file_exists($file) ){
if( is_array($data) ) extract($data);
ob_start();
require ($file);
return ob_get_clean();
}else{
return "не удалось найти файл шаблона $file
";
}
}
public function __toString(){
return $this->view->render();
}
}
```
Далее очень краткий пример реализации
Реализация главного контроллера:**Раскрыть**
```
namespace main;
class Controller extends \lib\Controller\Main {
protected $controllers=array(
'pages'=>array(
'title'=>'Страницы',
'class'=>'\\pages\\Controller'
)
);
protected function action_index(){
$static_page=new \static_pages\Controller(array('get_page','index'));
$this->view_data['content']=$static_page->render();
}
protected function action_about(){
$static_page=new \static_pages\Controller(array('get_page','about'));
$this->view_data['content']=$static_page->render();
}
protected function action_contacts(){
$static_page=new \static_pages\Controller(array('get_page','contacts'));
$this->view_data['content']=$static_page->render();
}
protected function prepareForAdmin(){
if( defined('ADMIN') ){
// добавление в список контроллеров, доступных для вызова по uri только администратору
$this->controllers['banners']=array(
'title'=>'Баннеры',
'class'=>'\\banners\\Controller'
);
$this->controllers['static_pages']=array(
'title'=>'Статические страницы',
'class'=>'\\static_pages\\Controller'
);
}
return true;
}
protected function before_view(){
if( !defined('AJAX') ){
/*
небольшая экономия ресурсов
без необходимости не трогаем модель и View
*/
}
}
}
```
View главного контроллера, примерно так же выглядят View остальных триад
**Раскрыть**
```
namespace main;
class View extends \View {
function __construct(){
static::$scripts['jquery']='jquery-1.9.0.js';
static::$styles['main']='main.css';
}
}
```
Пример главного шаблона *template.php* вызываемого контроллера
**Раскрыть**
```
php
if( $file=$this-getActionFile() ){
require $file;
}else{
echo "Ошибка шаблона";
}
?>
```
Приведенный код является частью моего проекта «по вечерам», немного обрезано в хабра-редакторе, поэтому что-то может не работать, выкладывать demo не готов — его пока нет.
Таким образом я получил то, что хотел:
* ЧПУ
* легкость
* пространства имен
* триады расположены изолированно, в том числе и шаблоны
* администрирование можно встроить прямо в триаду при помощи префиксов *admin\_* для шаблонов
* низкая связанность классов контроллер -> View и главный\_контроллер -> контроллер, а также View -> шаблон
* автоматический роутинг, его можно сделать более гибким перекрыв *action404()*
* легко реализовать AJAX запросы
* можно очень легко подключать свой набор скриптов и стилей для каждого контроллера
Правда, здесь нет модели и кэширования, а также, нужно очень хорошо подумать о безопасности.
Хотелось бы услышать мнение профессионалов о недостатках, а может быть и вообще не стоит изобретать велосипед. | https://habr.com/ru/post/170739/ | null | ru | null |
# QQuickRenderControl, или как подружить QML с чужим OpenGL контекстом. Часть I
Недавний [релиз Qt 5.4](http://habrahabr.ru/post/245521/), помимо прочего, предоставил в распоряжение разработчиков один, на мой взгляд, очень любопытный инструмент. А именно, разработчики Qt сделали [QQuickRenderControl](http://doc-snapshot.qt-project.org/qt5-5.4/qquickrendercontrol.html) частью публичного API. Занятность данного класса заключается в том, что теперь появилась возможность использовать Qml в связке с любым другим фреймворком, если он предоставляет возможность получить (или задать) указатель на используемый OpenGL контекст.
С другой стороны, в процессе работы над одним из своих проектов, я столкнулся с необходимостью отрисовывать QML сцену на [CALayer (Mac OS X)](https://developer.apple.com/library/mac/documentation/GraphicsImaging/Reference/CALayer_class/index.html), без малейшей возможности получить доступ к родительскому окну. Недельный поиск возможных вариантов решения проблемы показал, что самым адекватным решением будет как раз использование QQuickRenderControl из Qt 5.4, благодаря удачному совпадению, получившего статус релиза одновременно с возникновением вышеупомянутой задачи.
Изначально я предположил что задача плевая, и будет решена в течении пары вечеров, но как же я сильно заблуждался — задача заняла порядка полумесяца на исследования, и еще пол месяца на реализацию (которая все еще далека от идеала).
#### **Несколько тезисов**
* QQuickRenderControl это всего навсего дополнительный интерфейс к реализации [QQuickWindow](http://doc.qt.io/qt-5/qquickwindow.html) для получения нотификаций об изменении QML сцены, а так же передачи команд в обратном направлении (т.е. фактически «костыль»);
* Результат рендеринга будет получен в виде [QOpenGLFramebufferObject (далее FBO)](http://doc.qt.io/qt-5/qopenglframebufferobject.html), который в дальнейшем может быть использован в качестве текстуры;
* Работать придется непосредственно с QuickWindow, соответственно сервис по загрузке QML предоставляемый QQuickView будет недоступен, и придется его реализовывать самостоятельно;
* Поскольку никакого окна на самом деле не создается, возникает необходимость искуственно передавать события мыши и клавиатуры в QQuickWindow. Так же необходимо вручную управлять размером окна;
* Пример использования QQuickRenderControl я сумел найти только один, в Qt 5.4 (Examples\Qt-5.4\quick\rendercontrol) — собственно по нему и проходили все разбирательства;
#### **Что же нужно сделать для решения исходной задачи?**
1) Реализовать настройку QQuickWindow для рендеринга в FBO и управления этим процессом через QQuickRenderControl;
2) Реализовать загрузку Qml и присоединение результата к QQuickWindow;
3) Реализовать передачу событий мыши и клавиатуры;
4) Отрисовать FBO (ради чего все и затевалось);
В данной статье я позволю себе остановится только на пункте 1), остальные пункты в последющих частях (если вы сочтете это интересным).
#### **Настраиваем QQuickWindow**
##### ***Внешний QOpenGLContext***
Отправной точкой является OpenGL контекст в котором в конечном итоге и будет отрисовываться FBO. Но поскольку, с большой долей вероятности, работать необходимо с контекстом изначально не имеющим никакого отношения к Qt, то необходимо провести конвертацию контекста из формата операционной системы в экземпляр QOpenGLContext. Для этого необходимо использовать метод [QOpenGLContext::setNativeHandle](http://doc.qt.io/qt-5/qopenglcontext.html#setNativeHandle).
Пример использования на основе NSOpenGLContext:
```
NSOpenGLContext* nativeContext = [super openGLContextForPixelFormat: pixelFormat];
QOpenGLContext* extContext = new QOpenGLContext;
extContext->setNativeHandle( QVariant::fromValue( QCocoaNativeContext( nativeContext ) ) );
extContext->create();
```
*Список доступных Native Context лучше смотреть непосредственно в заголовочных файлах Qt ( include\QtPlatformHeaders ), т.к. документация в этой части сильно не полна.*
Далее можно использовать этот контекст (но при этом необходимо внимательно следить чтоб изменения состояния этого контекста не входили в конфликт с манипуляциями владельца), а можно сделать shared контекст:
```
QSurfaceFormat format;
format.setDepthBufferSize( 16 );
format.setStencilBufferSize( 8 );
context = new QOpenGLContext;
context->setFormat( format );
context->setShareContext( extContext );
context->create();
```
Важным ньюансом для использования OpenGL контекста с QML является наличие в нем настроенных Depth Buffer и Stencil Buffer, поэтому если у вас нет возможности влиять на параметры исходного контекста, нужно использовать shared контекст с установленными «Depth Buffer Size» и «Stencil Buffer Size».
##### ***Создание QQuickWindow***
При создании QQuickWindow предварительно создается QQuickRenderControl и передается в конструктор:
```
QQuickRenderControl* renderControl = new QQuickRenderControl();
QQuickWindow* quickWindow = new QQuickWindow( renderControl );
quickWindow->setGeometry( 0, 0, 640, 480 );
```
Кроме того важно задать размер окна, для дальнейшего успешного создания FBO.
##### ***Инициализация QQuickRenderControl и QOpenGLFramebufferObject***
Перед вызовом QQuickRenderControl::initialize важно сделать контекст текущим, т.к. в процессе вызова будет сгенерирован сигнал sceneGraphInitialized, а это хорошая точка для создания FBO (который, в свою очередь, требует выставленного текущего контекста).
```
QOpenGLFramebufferObject* fbo = nullptr;
connect( quickWindow, &QQuickWindow::sceneGraphInitialized,
[&] () {
fbo = new QOpenGLFramebufferObject( quickWindow->size(), QOpenGLFramebufferObject::CombinedDepthStencil );
quickWindow->setRenderTarget( fbo );
}
);
offscreenSurface = new QOffscreenSurface();
offscreenSurface->setFormat( context->format() );
offscreenSurface->create();
context->makeCurrent( offscreenSurface );
renderControl->initialize( context );
context->doneCurrent();
```
##### ***Рендеринг***
Рендеринг необходимо осуществлять как реакцию на сигналы QQuickRenderControl::renderRequested и QQuickRenderControl::sceneChanged. Разница в этих двух случаях заключается в том что во втором случае необходимо дополнительно вызывать QQuickRenderControl::polishItems и QQuickRenderControl::sync. Второй важной особенностью является то что [настойчиво не рекомендуется](http://doc-snapshot.qt-project.org/qt5-5.4/qquickrendercontrol.html#renderRequested) отсуществлять рендеринг непосредственно в обработчиках упомянутых выше сигналов. Поэтому используется таймер с небольшим интервалом. Ну и последней тонкостью является то, что, в случае использования shared OpenGL контекста, после рендеринга, требуется вызывать glFlush — в противном случае первичный контекст не видит изменений в FBO.
```
bool* needSyncAndPolish = new bool;
*needSyncAndPolish = true;
QTimer* renderTimer = new QTimer;
renderTimer->setSingleShot( true );
renderTimer->setInterval( 5 );
connect( renderTimer, &QTimer::timeout,
[&] () {
if( context->makeCurrent( offscreenSurface ) ) {
if( *needPolishAndSync ) {
*needPolishAndSync = false;
renderControl->polishItems();
renderControl->sync();
}
renderControl->render();
quickWindow->resetOpenGLState();
context->functions()->glFlush();
context->doneCurrent();
}
);
connect( renderControl, &QQuickRenderControl::renderRequested,
[&] () {
if( !renderTimer->isActive() )
renderTimer->start();
}
);
connect( renderControl, &QQuickRenderControl::sceneChanged,
[&] () {
*needPolishAndSync = true;
if( !renderTimer->isActive() )
renderTimer->start();
}
);
```
Ну вот в общем то и все, первая часть задачи выполнена.
Класс реализующий вышеприведенную концепцию доступен на GitHub: [FboQuickWindow.h](https://github.com/RSATom/QuickLayer/blob/master/FboQuickWindow.h), [FboQuickWindow.cpp](https://github.com/RSATom/QuickLayer/blob/master/FboQuickWindow.h)
Коментарии, вопросы, здоровая критика в комментариях — приветствуются.
Продолжение: [Часть II: Загружаем QML](http://habrahabr.ru/post/248103/), [Часть III: Обработка пользовательского ввода](http://habrahabr.ru/post/249383/) | https://habr.com/ru/post/247477/ | null | ru | null |
# Устанавка pyload в качестве standalone качалки для ReadyNAS DUO v2
Для закачки торрентов ReadyNAS-ом на родном сайте в addons есть transmission, и поставить его не проблема.
Но, в тоже время простой ftp/http качалки, к моему сожалению и удивлению я там не нашел. Это недоразумение я предлагаю исправить.
Для начала нужно установить из addons EnableROOT для последующего комфортного конфигурирования по ssh.
Выкачиваем [EnableRootSSH\_1.0-arm.bin](http://www.readynas.com/download/addons/arm/5.3/EnableRootSSH_1.0-arm.bin) и устанавливаем через админ-панель ReadyNAS.
Нас попросят перезагрузиться, после чего ssh будет доступен на стандартном порту с логином root и вашим текущим паролем от админ-панели.
Для подключения можно воспользоваться kitty. В последнее время я предпочитаю использовать ее вместо putty — т.к. у нее кодировка utf8 по умолчанию для новых подключений.
Вот то, что из себя представляет начинка ReadyNAS DUO v2 (версия FW 5.3.8):
**cat /etc/debian\_version**6.0.3
**uname -a**Linux nas 2.6.31.8.duov2 #1 Thu Apr 18 18:24:47 HKT 2013 armv5tel GNU/Linux
**cat /proc/cpuinfo**Processor: Feroceon 88FR131 rev 1 (v5l)
BogoMIPS: 1599.07
Features: swp half thumb fastmult edsp
CPU implementer: 0x56
CPU architecture: 5TE
CPU variant: 0x2
CPU part: 0x131
CPU revision: 1
Hardware: Feroceon-KW
Revision: 0000
Serial: 0000000000000000
**cat /proc/meminfo**MemTotal: 246820 kB
MemFree: 24188 kB
Buffers: 6056 kB
Cached: 104700 kB
SwapCached: 12 kB
Active: 96728 kB
Inactive: 101508 kB
Active(anon): 36812 kB
Inactive(anon): 51176 kB
Active(file): 59916 kB
Inactive(file): 50332 kB
Unevictable: 16 kB
Mlocked: 4 kB
SwapTotal: 524268 kB
SwapFree: 524256 kB
Dirty: 92 kB
Writeback: 0 kB
AnonPages: 87504 kB
Mapped: 28332 kB
Slab: 15456 kB
SReclaimable: 3764 kB
SUnreclaim: 11692 kB
PageTables: 2052 kB
NFS\_Unstable: 0 kB
Bounce: 0 kB
WritebackTmp: 0 kB
CommitLimit: 647676 kB
Committed\_AS: 610212 kB
VmallocTotal: 385024 kB
VmallocUsed: 940 kB
VmallocChunk: 382812 kB
> **На заметку**
>
>
>
> ReadyNAS-овские маркетологи толкают под названием FLEX-RAID & X-RAID2… mdadm. Только тсс!
Обновим доступные из базового репозитория пакеты и установим необходимые зависимости:
```
#apt-get update
#apt-get install python python-beaker python-crypto python-imaging python-jinja2 python-openssl python-pycurl tesseract-ocr-eng unzip nano
```
Так как для доступа к скачанным файлам используется в основном samba — нам необходимо закачивать наши файлы с правами того же пользователя/группы, что и samba — nobody:nogroup. Есть также альтернативный (менее геморройный) вариант оставить все как есть, и запускать pyload из-под root, но менять пользователя/группу средствами самого pyload. Для себя я выбрал первый вариант (да, гентушник).
Выкачиваем исходники pyload:
```
#cd /opt
#wget https://github.com/pyload/pyload/archive/stable.zip
#unzip stable.zip && mv pyload-stable pyload
#touch /opt/pyload/pyload.pid && chown –R nobody:nogroup /opt/pyload
#usermod –s /bin/bash nobody
```
Теперь приступаем непосредственно к настройке pyload.
Запустим в режиме конфигурации – заботливый pyload сам проверит доступные ему фичи и отрапортует об этом.
`#cd /opt/pyload && su nobody -c "python pyLoadCore.py –s"`
**Выхлоп должен быть схожим (простынка):**Choose your Language / Wähle deine Sprache ([en], de, fr, it, es, nl, sv, ru, pl, cs, sr, pt\_BR): *Enter*
*// Можно сменить язык установки.*
Welcome to the pyLoad Configuration Assistent.
It will check your system and make a basic setup in order to run pyLoad.
The value in brackets [] always is the default value,
in case you don't want to change it or you are unsure what to choose, just hit enter.
Don't forget: You can always rerun this assistent with --setup or -s parameter, when you start pyLoadCore.
If you have any problems with this assistent hit STRG-C,
to abort and don't let him start with pyLoadCore automatically anymore.
When you are ready for system check, hit enter. *Enter*
## System Check ##
Python Version: OK
pycurl: OK
sqlite3: OK
pycrypto: OK
py-OpenSSL: OK
py-imaging: OK
tesseract: OK
PyQt4: missing
jinja2: OK
beaker: OK
JS engine: missing
System check finished, hit enter to see your status report.*Enter*
## Status ##
Features available: container decrypting, ssl connection, automatic captcha decryption, Webinterface
Featues missing:
Gui not available
The Graphical User Interface.
no JavaScript engine found
You will need this for some Click'N'Load links. Install Spidermonkey, ossp-js, pyv8 or rhino
You can abort the setup now and fix some dependicies if you want.
Continue with setup? ([y]/n):*Enter*
*// Я зажал ресурсы и незахотел перегружать систему. Можно попробовать поставить rhino или spidermonkey.*
Do you want to change the config path? Current is /root/pyload/.pyload
If you use pyLoad on a server or the home partition lives on an iternal flash it may be a good idea to change it.
Change config path? (y/[n]):*Enter*
*// В моем случае подтянулся сохраненный путь. Указываем свой — /root/pyload/.pyload*
Do you want to configure login data and basic settings?
This is recommend for first run.
Make basic setup? ([y]/n):*Enter*
## Basic Setup ##
The following logindata is valid for CLI, GUI and webinterface.
Username [User]: *pyload*
Password:
Password (again):
*// Вбиваем свои данные. Обратите внимание, что пользователь admin в системе есть перманентно, и его не удалить.*
External clients (GUI, CLI or other) need remote access to work over the network.
However, if you only want to use the webinterface you may disable it to save ram.
Enable remote access ([y]/n): *n*
*// Если решили попробовать rpc-клиент с ПК, то видимо нужно включать (об этом далее).*
Language ([en], de, fr, it, es, nl, sv, ru, pl, cs, sr, pt\_BR):*Enter*
Downloadfolder [Downloads]: */d/media2/pyload*
*// У меня диск разбит на 2 тома по 2 Тб. Жадный я, что ж поделать.*
Max parallel downloads [3]:*Enter*
Use Reconnect? (y/[n]):*Enter*
Do you want to configure ssl?
Configure ssl? (y/[n]):*Enter*
*// В случае с выбором threaded сервера — нужно включить, и не забыть сгенерировать ключи командами, которые выплюнет конфигуратор (об этом далее).*
Do you want to configure webinterface?
Configure webinterface? ([y]/n):*Enter*
## Webinterface Setup ##
Activate webinterface? ([y]/n):*Enter*
Listen address, if you use 127.0.0.1 or localhost, the webinterface will only accessible locally.
Address [0.0.0.0]:*Enter*
Port [8000]:*Enter*
*// Порт по вкусу, лишь бы не пересекался с уже запущенными сервисами.*
pyLoad offers several server backends, now following a short explanation.
builtin: Default server, best choice if you dont know which one to choose.
threaded: This server offers SSL and is a good alternative to builtin.
fastcgi: Can be used by apache, lighttpd, requires you to configure them, which is not too easy job.
lightweight: Very fast alternative written in C, requires libev and linux knowlegde.
Get it from here: [github.com/jonashaag/bjoern](https://github.com/jonashaag/bjoern), compile it
and copy bjoern.so to module/lib
Attention: In some rare cases the builtin server is not working, if you notice problems with the webinterface
come back here and change the builtin server to the threaded one here.
Server ([builtin], threaded, fastcgi, lightweight):Enter
*// Мною были испробованы разные варианты веб-серверов:
* builtin: Пробовал. Работает. Остановился на нем, как на самом непритязательном варианте.
* threaded: Пробовал. Работает.
* fastcgi: Не пробовал. На официальном форуме наткнулся о проблемах с настройкой wcgi. Геморрой-way. Skip
* lightweight: Попробовать не удалось. Установил необходимые инструменты для сборки и libev. При сборке уткнулся в ошибку, отчего плюнул на это дело. Может у кого-то получится (я подглядывал [сюда](http://pyload.org/install_bjoern)).*
Setup finished successfully.
Hit enter to exit and restart pyLoad
Поздравляю, мы почти все настроили. Теперь нам осталось сделать удобный запуск того, что мы наворотили.
Сперва я решил пойти в лоб и сделать кустарный авторан — засунул в crontab следующую запись:
`@reboot sh /root/pyload-start.sh`
```
root@nas:~# cat pyload-start.sh
#!/bin/sh
sleep 30
su nobody -c "/usr/bin/python /opt/pyload/pyLoadCore.py --daemon"
```
Потом, все же, поступил более цивилизованно. Создаем стартовый скрипт следующего содержания:
**/etc/init.d/pyload**#!/bin/sh
### BEGIN INIT INFO
# Provides: pyload
# Required-Start: $syslog $local\_fs $network $remote\_fs
# Required-Stop: $syslog $local\_fs $network $remote\_fs
# Should-Start: $remote\_fs $named
# Should-Stop: $remote\_fs $named
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Starts pyload daemon
# Description: This script runs the pyload service
### END INIT INFO
# Starts and stops the pyload daemon.
PATH=/bin:/usr/bin:/sbin:/usr/sbin
DAEMON="/usr/bin/python /opt/pyload/pyLoadCore.py"
PIDFILE="/opt/pyload/pyload.pid"
. /lib/lsb/init-functions
start() {
log\_daemon\_msg «Starting pyLoad server»
su nobody -c "$DAEMON --daemon"
if [ $? != 0 ]; then
log\_end\_msg 1
exit 1
else
log\_end\_msg 0
fi
}
stop() {
log\_daemon\_msg «Stoping pyLoad server»
su nobody -c "$DAEMON --quit"
if [ $? != 0 ]; then
log\_end\_msg 1
# exit 1
else
log\_end\_msg 0
fi
}
case "$1" in
start)
start
;;
stop)
stop
;;
force-reload)
stop
sleep 5
start
;;
restart)
stop
sleep 2
start
;;
\*)
echo «Usage: $0 {start|stop|restart|force-reload}»
exit 1
;;
esac
exit 0
Делаем исполняемым:
```
#chmod +x /etc/init.d/pyload
```
И заставляем стартовать службой при старте:
```
#update-rc.d pyload start 20 2 3 4 5 . stop 10 0 1 6 .
```
Пробуем стартовать и тушить службу через init-скрипт:
```
/etc/init.d/pyload start
/etc/init.d/pyload stop
```
Я настроил openvpn тунель до домашнего роутера, поэтому веб-морда pyload доступна по своему домашнему адресу. Если неохота заморачиваться с openvpn — банально пробросываем порт на роутере.
Также есть возможность управлять закачками через отдельную программку, которая по RPC (с SSL, если вы это настроили) взаимодействует с сервером pyload. Выкачиваем бинарники для винды [pyload-v0.4.9-win.zip](http://get.pyload.org/get/win) Нас убедительно предупреждают, что PyQT GUI сей нестабильный, и лучше использовать webGUI. У меня вроде не падал и не вис — возможно я мало эксплуатировал.
> Чтобы появилась поддержка ssl необходимо ответить утвердительно в конфигураторе, а также сгенерировать самоподписанный сертификат:
>
>
> ```
> openssl genrsa -out ssl.key 1024
> openssl req -new -key ssl.key -out ssl.csr
> openssl req -days 36500 -x509 -key ssl.key -in ssl.csr > ssl.crt
>
> ```
>
При настройке были использованы:
[Pyload site](http://pyload.org)
[Pyload site: Install bjoern](http://pyload.org/install_bjoern)
[Pyload forum: Script modification for booting Debian](http://forum.pyload.org/viewtopic.php?f=7&t=916)
[Pyload forum: Running pyload on startup as a specified user](http://forum.pyload.org/viewtopic.php?f=7&t=1957)
Всем позитива и удачи! | https://habr.com/ru/post/198110/ | null | ru | null |
# Исследование CSS-свойства flex
Вам когда-нибудь было интересно узнать о том, как работает сокращённое CSS-свойство `flex`? Оно позволяет задавать значения свойств `flex-grow`, `flex-shrink` и `flex-basis`. Я обратил внимание на то, что данное свойство чаще всего используют в виде `flex: 1`, что позволяет flex-элементу растягиваться, занимая доступное пространство.
[](https://habr.com/ru/company/ruvds/blog/515298/)
В этом материале я хочу поговорить о сокращённом свойстве `flex` и о тех свойствах, значения которых устанавливают с его помощью. Я собираюсь рассказать о том, когда и почему можно пользоваться этими свойствами, приведу практические примеры.
Свойство flex-grow
------------------
CSS-свойство `flex-grow` используется для настройки так называемого «коэффициента роста» элементов (flex grow factor), что позволяет этим элементам растягиваться, занимая доступное пространство. В качестве значений этого свойства можно использовать только целые числа. Рассмотрим пример.
Вот HTML-разметка:
```
```
Вот стили:
```
.wrapper {
display: flex;
flex-wrap: wrap;
}
.item {
flex-grow: 1;
}
```
Свойство `flex-grow` может воздействовать на ширину или на высоту элемента, что зависит от значения свойства `flex-direction`. Рассматривая следующие примеры, учитывайте то, что используемое в них свойство `flex-direction` установлено в значение, задаваемое по умолчанию (`row`). Если это будет не так — я об этом скажу.
Обратите внимание на то, что без использования `flex-grow` ширина flex-элементов будет установлена в значение, применяемое по умолчанию, то есть — она будет равна их исходной ширине. А если используется `flex-grow: 1`, то доступное свободное пространство распределяется между элементами.
*Вверху свойство flex-grow не применяется. Внизу применяется flex-grow: 1*
Возможно, тут у вас возникнет вопрос о том, как именно между flex-элементами распределяется свободное пространство. Это — хороший вопрос. Скоро я на него отвечу.
На следующем рисунке показано то, как элементы выглядят без использования свойства `flex-grow`. Другими словами, здесь показаны элементы, имеющие свой обычный размер.
*Свойство flex-grow не используется*
Для того чтобы понять то, как вычисляется ширина flex-элементов, взгляните на формулы, показанные ниже. Я нашёл эти формулы в [материале](https://www.samanthaming.com/flexbox30/22-flex-grow-calculation/) Саманты Минг (за что её благодарю!).
Давайте посчитаем ширину первого элемента — того, в котором находится текст `CSS`.
*Нахождение ширины элемента*
Итак, тут используется такая формула:
```
Ширина элемента = ((flex-grow элемента / сумма значений flex-grow) * доступное пространство) + исходная ширина элемента
```
Разберём эту формулу:
* `flex-grow элемента` — это коэффициент роста, заданный для элемента.
* `сумма значений flex-grow` — это сумма значений коэффициентов роста всех элементов.
* `доступное пространство` — это свободное пространство контейнера, которое имеется в нём до применения механизмов `flex-grow`.
* `исходная ширина элемента` — это, как несложно догадаться, ширина элемента до её изменения с помощью `flex-grow`.
В результате подстановки в эту формулу реальных значений получается следующее:
```
Ширина элемента = ( (1 / 3) * 498) + 77 = 241
```
Разные значения flex-grow, задаваемые для разных элементов
----------------------------------------------------------
В предыдущем примере для всех flex-элементов использовалось одно и то же значение `flex-grow`. Попробуем теперь назначить первому элементу свойство `flex-grow: 2`. Как будет вычисляться ширина элементов теперь? Рассматривая следующую формулу, помните о том, что ширина свободного пространства в нашем примере равняется `498px`.
*Нахождение ширины элемента в ситуации, когда разным элементам заданы разные значения flex-grow*
Как видите, тут используется тот же механизм расчёта ширины элементов, который был рассмотрен выше. Главное отличие заключается в том, что значение `flex-grow` для первого элемента задано как `2`, что находит отражение в формуле расчёта ширины элементов.
Можно ли использовать 0 в качестве значения flex-grow?
------------------------------------------------------
Конечно можно! Так как свойство `flex-grow` принимает целочисленные значения, в него можно записать и `0`. Это будет означать, что мы не хотим, чтобы flex-элемент менял бы размеры, занимая некоторую часть свободного пространства контейнера.
*Последствия установки свойства flex-grow в значение 0*
Как видите, элемент, которому назначено свойство `flex-grow: 0`, не меняет ширину. Этот приём может быть полезен в тех случаях, когда нужно, чтобы некий flex-элемент сохранял бы свою исходную ширину.
Использование flex-grow не приводит к тому, что элементы становятся одинаковыми
-------------------------------------------------------------------------------
Существует распространённое заблуждение, в соответствии с которым использование `flex-grow` позволяет сделать так, чтобы соответствующие элементы имели бы одинаковую ширину. Это — ошибка. Смысл использования `flex-grow` заключается в распределении доступного пространства между элементами. Как вы могли видеть, анализируя вышеприведённые формулы, итоговая ширина flex-элементов вычисляется на основе их исходной ширины (то есть той, которую они имели до применения `flex-grow`).
Если вам нужно сделать так, чтобы все элементы из некоего набора имели бы одинаковую ширину, то знайте, что сделать это можно, воспользовавшись свойством `flex-basis`. Мы поговорим об этом ниже.
Свойство flex-shrink
--------------------
Свойство `flex-shrink` позволяет задать так называемый «коэффициент сжатия» элемента (flex shrink factor). Если размер всех flex-элементов больше, чем размер их контейнера, размер элементов будет уменьшен в соответствии с назначенными им значениями свойства `flex-shrink`.
*Центральному элементу назначено свойство flex-shrink: 1*
Вот стили к этому примеру:
```
.item-2 {
width: 300px;
flex-shrink: 1;
}
```
Браузер сделает ширину элемента `item-2` равной `300px` при выполнении следующих условий:
* Общая ширина всех элементов меньше ширины контейнера.
* Ширина области просмотра страницы равна или больше ширины элемента.
Вот как элементы из предыдущего примера ведут себя при их выводе в областях просмотра разной ширины.
*Ширина элемента с текстом Is не уменьшается до тех пор, пока на экране достаточно места для его вывода*
Как видите, элемент не сжимается, сохраняя ширину в `300px` до тех пор, пока ему хватает места.
Свойство flex-basis
-------------------
Свойство `flex-basis` задаёт базовый размер flex-элемента, который он имеет до распределения свободного пространства в соответствии с коэффициентами гибкости, задаваемыми свойствами `flex-grow` и `flex-shrink`. По умолчанию, для всех значений, кроме `auto` и `content`, значение `flex-basis` равняется ширине элемента, а при использовании свойства `flex-direction: column` — его высоте.
Свойство `flex-basis` принимает те же значения, которые могут принимать свойства `width` и `height`. Значением, задаваемым по умолчанию, является `auto`, которое устанавливается на основе значения `content`. Значение `content` задаётся автоматически, на основе размера содержимого flex-элемента.
Применим к элементу `item-1` из нашего примера следующие стили:
```
.item-1 {
flex-grow: 0;
flex-shrink: 0;
flex-basis: 50%;
}
```
*Использование свойства flex-basis: 50%*
Здесь первому элементу назначено свойство `flex-basis: 50%`. При этом тут важно сбросить в `0` свойство `flex-grow`, что позволит сделать так, чтобы размер элемента не превысил бы `50%`.
Что произойдёт, если вместо этого записать в свойство `flex-basis` значение `100%`? Это приведёт к тому, что элемент займёт 100% ширины родительского элемента, а другие элементы будут перенесены на новую строку.
Вот соответствующие стили:
```
.item-1 {
flex-grow: 0;
flex-shrink: 0;
flex-basis: 100%;
}
```
*Результат использования свойства flex-basis: 100%;*
Сокращённое свойство flex
-------------------------
Свойство `flex` позволяет, в сокращённом формате, задавать значения свойств `flex-grow`, `flex-shrink` и `flex-basis`. Значением по умолчанию, которое принимает это свойство, является `auto`. Оно соответствует `flex: 0 1 auto`. Это означает, что оно позволяет flex-элементам увеличиваться в размерах, основываясь на размерах их содержимого.
В данном контексте мне хотелось бы обратить ваше внимание на одну важную деталь. Речь идёт о flex-элементах с абсолютными и относительными размерами. И, кстати, это не имеет отношения к [CSS-позиционированию](https://ishadeed.com/article/learn-css-positioning/). Это относится к модели flexbox.
Flex-элементы с относительными размерами
----------------------------------------
Вот CSS-код:
```
.item {
/* Значение, используемое по умолчанию, эквивалентно flex: 1 1 auto */
flex: auto;
}
```
Здесь размер flex-элементов основан на их содержимом. В результате элементы, в которых больше содержимого, будут больше.
*Элемент, в котором больше содержимого, будет больше*
Flex-элементы с абсолютными размерами
-------------------------------------
Если же, в отличие от предыдущего примера, свойство `flex-basis` будет установлено в значение `0`, это приведёт к тому, что все flex-элементы увеличатся до одного и того же размера.
Вот стиль:
```
.item {
/* Аналогично flex: 1 1 0% */
flex: 1;
}
```
*Элементы имеют одинаковый размер*
Особенности свойства flex, которые мне нравятся
-----------------------------------------------
Само название свойства `flex` намекает на то, что оно умеет гибко работать с передаваемыми ему значениями. Это наделяет его некоторыми особенностями, которые кажутся мне привлекательными. Рассмотрим несколько примеров.
### ▍Одно значение без единиц измерения
Вот CSS-код:
```
.item {
flex: 1;
}
```
Здесь в свойство `flex` записывается единственное значение без единиц измерения. Это значение будет воспринято системой как значение свойства `flex-grow`. Его эквивалент будет выглядеть как `flex: 1 1 0`.
### ▍Два значения без единиц измерения
Взглянем на следующий стиль:
```
.item {
flex: 1 1;
}
```
Тут мы в явном виде задаём, соответственно, значения `flex-grow` и `flex-shrink`. При этом `flex-basis` будет сброшено в значение, применяемое по умолчанию.
### ▍Одно значение, представляющее собой некий размер
Поговорим о том, как будет «расшифрован» следующий стиль:
```
.item {
flex: 100px;
/* flex: 1 1 100px */
}
```
Значение `100px` будет рассматриваться системой как значение `flex-basis`. А во `flex-grow` и `flex-shrink` будет, по умолчанию, записано `1`.
### ▍Использование значения 0 без указания единиц измерения
Предположим, нужно установить `flex-basis` в значение `0`, воспользовавшись свойством `flex`. Мы, для решения этой задачи, решим поступить так:
```
.item {
flex: 0;
}
```
Делать так не рекомендуется, так как это способно запутать и тех, кто будет читать подобный код, и браузер. Как понять — к чему именно относится этот `0`? К свойству `flex-grow`, `flex-shrink` или `flex-basis`? В общем — путаница получается. Вот что говорится об этом в [спецификации CSS](https://drafts.csswg.org/css-flexbox-1/#flex-property):
*Ноль без указания единиц измерения, перед которым нет двух значений коэффициентов гибкости, должен интерпретироваться как значение коэффициента гибкости. Для того чтобы избежать неправильной интерпретации или ошибочного объявления свойства, авторы должны, задавая нулевое значение flex-basis, использовать единицы измерения, или ставить перед этим значением два значения, относящиеся к коэффициентам гибкости.*
То есть, чтобы избежать неоднозначностей, вышеприведённый код стоит переписать так:
```
.item {
flex: 0%;
/* flex: 1 1 0% */
}
```
Здесь используется конструкция `0%`, но можно, например, воспользоваться и конструкцией `0px`.
Пользуйтесь сокращённым свойством flex
--------------------------------------
Когда вам надо задать свойства `flex-grow`, `flex-shrink` и `flex-basis`, лучше всего использовать для этого сокращённое свойство `flex`.
Заглянем в [спецификацию CSS](https://drafts.csswg.org/css-flexbox-1/#flex-components):
*Авторам рекомендуется управлять гибкими элементами, используя сокращённое свойство flex, а не применяя напрямую полные имена свойств, так как при применении сокращённого свойства производится корректный сброс неуказанных значений к состоянию, соответствующему распространённым способам их использования.*
Сценарии использования и практические примеры
---------------------------------------------
### ▍Аватары пользователей
*Аватар, при настройке которого использовано свойство flex*
Модель flexbox часто используется для оформления компонентов страниц, имеющих отношение к пользователям. Например, это касается аватара пользователя и соответствующей подписи, которые должны находиться на одной строке.
Вот разметка:
```
### Ahmad Shadeed
Author of Debugging CSS
```
Вот стиль:
```
.user {
display: flex;
flex-wrap: wrap;
align-items: center;
}
.user__avatar {
flex: 0 0 70px;
width: 70px;
height: 70px;
}
```
Обратите внимание на то, что, настраивая элемент `user__avatar`, я применил свойство `flex: 0 0 70px`. Это важно, так как без этой настройки в некоторых устаревших браузерах изображение может вывестись неправильно. Более того, приоритет свойства `flex` выше приоритета свойства `width` (если речь идёт о ситуации, в которой применяется `flex-direction: row`) и свойства `height` (в ситуации, когда применяется `flex-direction: column`).
Если изменить размер аватара, воздействуя только на свойство `flex`, браузер проигнорирует то, что задано в свойстве `width`. Вот соответствующий стиль:
```
.user__avatar {
/* Ширина будет 100px, а не 70px */
flex: 0 0 100px;
width: 70px;
height: 70px;
}
```
### ▍Заголовок элемента
*Заголовок элемента*
Предположим, нам надо оформить заголовок некоего элемента. Этот заголовок должен занять всё доступное ему пространство. Решить эту задачу можно с помощью свойства `flex: 1`:
```
.page-header {
display: flex;
flex-wrap: wrap;
}
.page-header__title {
flex: 1;
}
```
### ▍Поле ввода для подготовки сообщения
*Поле ввода*
Подобные поля часто встречаются в приложениях для обмена сообщениями, вроде тех, что есть в Facebook и Twitter. Такое поле должно занимать всё доступное ему пространство. При этом кнопка для отправки сообщения должна иметь фиксированную ширину. Вот как это выглядит в CSS:
```
form {
display: flex;
flex-wrap: wrap;
}
input {
flex: 1;
/* Другие стили */
}
```
Этот пример являет собой удачную демонстрацию использования свойства `flex-grow`.
Надо отметить, что некоторым способам использования свойства `flex` не уделяется достаточно внимания в публикациях, посвящённых этому свойству. Давайте это исправим.
### ▍Выравнивание нижних элементов, находящихся на разных карточках
*Цель — выровнять обе даты по красной линии*
Предположим, что перед нами — макет, сформированный средствами CSS Grid, в котором имеются две колонки. Проблема тут в том, что даты, выводимые в конце текстового содержимого карточек, не выровнены. А нам нужно, чтобы они находились бы на одной линии, показанной на предыдущем рисунке.
Для решения этой задачи можно воспользоваться моделью flexbox.
Вот разметка:
```
### Title short
```
Достичь нашей цели можно, воспользовавшись свойством `flex-direction: column`. Элемент `card__title`, заголовок, можно стилизовать, применив свойство `flex-grow` и сделав так, чтобы он занимал бы всё доступное ему пространство. В результате окажется, что строка с датой попадёт в нижнюю часть карточки. Так произойдёт даже в том случае, если сам заголовок окажется достаточно коротким.
Вот стили:
```
.card {
display: flex;
flex-direction: column;
}
/* Первое решение */
.card__title {
flex-grow: 1;
}
```
Решить эту задачу можно и не прибегая к свойству `flex-grow`. А именно, речь идёт о применении модели flexbox и механизма автоматической настройки внешних отступов с использованием ключевого слова `auto`. Я, кстати, написал об этом [подробную статью](https://habr.com/ru/company/ruvds/blog/494716/).
```
/* Второе решение */
.card__date {
margin-top: auto;
}
```
Использование разных значений для коэффициентов гибкости
--------------------------------------------------------
В этом разделе я хочу рассказать об использовании свойств `flex-grow` и `flex-shrink`, которым назначают значения, отличные от `1`. Сейчас я приведу несколько практических примеров использования подобной схемы настройки этих свойств.
### ▍Панели управления
*Набор элементов управления*
На подготовку этого примера меня вдохновил дизайн Facebook (значки я тоже взял оттуда). На панели управления (элемент `actions` в следующем коде) имеется четыре элемента. Последний (элемент `actions__item.user`) имеет ширину, которая меньше, чем ширина других элементов. Сформировать подобную панель управления можно так:
```
.actions {
display: flex;
flex-wrap: wrap;
}
.actions__item {
flex: 2;
}
.actions__item.user {
flex: 1;
}
```
### ▍Анимация, в ходе которой элемент растягивается
*Элемент растягивается при наведении на него указателя мыши*
Flex-элементы можно анимировать при наведении на них указателя мыши. Этот приём может оказаться крайне полезным. Вот соответствующий CSS-код:
```
.palette {
display: flex;
flex-wrap: wrap;
}
.palette__item {
flex: 1;
transition: flex 0.3s ease-out;
}
.palette__item:hover {
flex: 4;
}
```
[Здесь](https://ishadeed.com/assets/flex-css/expand-animation.mp4) можно найти видео, демонстрирующее всё это в действии.
### ▍Увеличение размера активной карточки
Мне очень нравится [этот](https://codepen.io/shshaw/pen/EbjvbQ) проект на CodePen, в котором реализован механизм увеличения размеров карточки с описанием тарифного плана, по которой щёлкнул пользователь. Размер карточки меняется благодаря установке её свойства `flex-grow` в значение `4`.
*Увеличение размера активной карточки*
### ▍Что делать, если содержимое контейнера больше самого контейнера?
*Элементы не помещаются в контейнер*
Некоторое время тому назад мне пришло письмо от одного из моих читателей, который рассказал мне о возникшей у него проблеме и попросил помочь с её решением. Суть этой проблемы представлена на предыдущем рисунке. Здесь есть пара изображений, которые должны находиться в пределах элемента-контейнера, но размер этих изображений больше размеров контейнера.
Попробуем такой стиль:
```
.wrapper {
display: flex;
}
.wrapper img {
flex: 1;
}
```
Но даже при использовании свойства `flex: 1` изображения в контейнер не помещаются. Обратимся к [спецификации CSS](https://www.w3.org/TR/css-flexbox-1/):
*Flex-элементы, по умолчанию, не уменьшаются в размерах до величин, меньших, чем размеры их содержимого (длина самого длинного слова или элемента с фиксированным размером). Для того чтобы это изменить, нужно воспользоваться свойствами min-width или min-height.*
В нашем случае проблема заключается в том, что изображения слишком велики и модель flexbox не уменьшает их до таких размеров, чтобы они поместились бы в контейнер. Исправить это можно так:
```
.wrapper img {
flex: 1;
min-width: 0;
}
```
Подробности смотрите в [этой](https://ishadeed.com/article/min-max-css/#setting-min-width-to-zero-with-flexbox) моей статье.
Итоги
-----
Здесь я рассказал вам о свойстве `flex` и о том, как им пользоваться. Надеюсь, вы узнали из этого материала что-то новое и полезное.
**Пользуетесь ли вы CSS-свойством flex в своих проектах?**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=css-flex-propert) | https://habr.com/ru/post/515298/ | null | ru | null |
# Генератор энтропии Seeder 1.1 существенно уменьшает лаги на Android-устройствах
В старых версиях Android некоторые системные компоненты и JVM активно считывали большие объёмы случайных чисел из псевдоустройства `/dev/random`. Это устройство предоставляет интерфейс к системному генератору случайных чисел (ГСЧ), который выводит шумы из драйверов устройств и других источников в «хаотичный» пул. На старых версиях Android иногда возникали проблемы с наполнением пула случайных чисел. В случае опустошения пула возникали лаги UI, пока пул не наполнялся. В новых версиях Android проблему с лагами UI решили, но не до конца: всё-таки иногда возникают характерные задержки.
Многие пользователи считали, что лаги интерфейса объясняются недостаточной производительностью CPU, на самом деле это не так. Проблема [именно в истощении пула случайных чисел](https://code.google.com/p/android/issues/detail?id=42265#c114).
Один из разработчиков с форума XDA-Developers перекомпилировал `rngd`, так что пул случайных чисел каждую 1 секунду пополняется из пула псевдослучайных чисел `/dev/urandom`. Результат — [потрясающее ускорение интерфейса Android](http://forum.xda-developers.com/showthread.php?t=1987032&nocache=0) с почти полным исчезновением лагов! Chrome, карты и другие тяжеловесные приложения теперь мгновенно переключаются между задачами.
Рендеринг новых фрагментов карт в Google Maps осуществляется мгновенно, по мере прокрутки карты. Отображение рабочего стола тоже стало мгновенным. Если у вас в таких ситуациях случались лаги в 5-10 секунд, то обязательно попробуйте установить эту программку. Один из мейнтейнеров CyanogenMod [говорит](https://code.google.com/p/android/issues/detail?id=42265#c114), что разница в производительности действительно налицо, хотя причины этого непонятны: тесты не показывали истощения пула случайных чисел. «Что происходит? Или мы все тут сумасшедшие, или мы случайно наткнулись на какой-то неуловимый баг в ядре. Нужно дополнительное изучение этой темы», — пишет Стив Кондрик (Steve Kondik), мейнтейнер CyanogenMod.
[Seeder-1.1.apk](http://forum.xda-developers.com/showthread.php?t=1987032&nocache=0) ([зеркало](https://docs.google.com/open?id=0B68LH1VzpjxNMzljZS1ITVU4SlU))
Копирование псевдослучайных данных из `/dev/urandom`, теоретически, представляет некоторую угрозу для безопасности, потому что качество случайных чисел там не такое высокое, как в нормальном `/dev/random`. Но на практике, шансы того, что кто-то применит для атаки эксплойт ГСЧ гораздо меньше, чем вероятность использования уязвимости в ОС.
Автор говорит, что программа практически не расходует заряд батарей, но если у кого-то будут с этим проблемы — напишите, он поставит блокировку на чтение файла только при включенном дисплее. С другой стороны, благодаря устранению лагов в интерфейсе вы теперь можете снизить частоту CPU и сэкономить заряд.
P.S. Кроме бесплатной программы для читателей форума XDA-Developers, автор опубликовал в каталоге Google Play и [платную версию программы](https://play.google.com/store/apps/details?id=com.lcis.seeder) для «непосвящённых». | https://habr.com/ru/post/164881/ | null | ru | null |
# Методы проверки гипотез. Результаты беседы с продактом из ВТБ. Разговор с продактом из ВТБ
Есть ощущение, что у всех разное представление о том, какие бывают инструменты проверки гипотез и для чего они используются. Информация из статей в медиа разнится между собой. И мне захотелось создать некую универсальную “памятку”, которая разложила бы по полочкам все по этой теме. В рамках статьи я подчеркнул базовые мысли и выводы, к которым мы пришли в рамках стрима с автором канала <https://t.me/productgames>.
> Кому не подходит вариант статьи, то есть стрим <https://youtu.be/-Bnzohta2ng>
>
>
### Пару слов про гостя
Всем привет, меня зовут Кристина. Мое основное место работы - ВТБ. Там я работаю над мобильным приложением для малого и среднего бизнеса и являюсь одним из его PO. В качестве дополнительных увлечений веду блог (product games), консультирую стартапы по тестированию и запуску идей, а также веду проекты по типу кейс клубов и продуктовые интенсивы.
`— Как ты попала в продакт-менеджмент? Пришла туда изначально или занималась чем-то смежным?`
— В продакт-менеджмент я пришла не сразу. Начинала с консалтинга, работала консультантом PWC. Сначала занималась налогами, а потом поняла, что все наши проекты бесполезны. Как раз тогда я познакомилась с девочкой, которая работала в Яндекс Такси. Мне показалось интересным то, чем она занимается, и я начала искать возможность устроиться на продакта. Так получилось, что в стартапе моих знакомых как раз была вакансия. Они искали человека, который настроит процессы и поведет дальше их продукт. Я присоединилась и с тех пор больше не уходила из технологий.
`— Что ты думаешь по этому поводу и какой разрез было бы лучше использовать, чтобы расположить все инструменты для проверки гипотез?`
— Интересный вопрос. В целом, я бы исходила из стадии развития продукта и располагала бы инструменты в зависимости от неё.
### Этапы жизненного цикла продукта
Давай подробнее поговорим о том, какие этапы жизненного цикла продукта можно выделить:
- Preseed - этап перед привлечением инвестиций
- Product market fit
- Вывод на рынок
- Рост
- Зрелость
- Упадок
При этом методы, используемые в больших организациях и стартапах, будут отличаться. Не все, что дозволено стартапам с большим уровнем гибкости, может делать enterprise, так как риск гораздо выше и все решения должны согласовываться. Конечно, те методы, о которых мы сегодня поговорим, подойдут и для enterprise, но не все.
### Инновации в ВТБ
`— Кстати, давай поговорим о корпоративных инновациях в больших компаниях. В 2018 я побывал в корпоративном стартапе, и это было отвратительно. Сейчас ты работаешь в ВТБ, в большой организации. Как там с этим обстоят дела?`
— В целом, мы сотрудничаем со стартапами: у нас есть внутренний акселератор, который подбирает стартап проекты и предлагает им программы для создания пилотов вместе с банком. Это происходит примерно так:
1. Приходит стартап, рассказывает про свой продукт, и акселератор оценивает его.
2. Далее акселератор собирает все одобренные продукты и рассылает их по подразделениям. Те из них, к которым выразили интерес подразделения банка, могут начать пилотирование внутри банка.
Всё это реализуется не без затруднений. Возникает множество бюрократических моментов, так как заключение контрактов с внешним контрагентом - это всегда непросто.
### Ходим от рисков
Я люблю ходить от рисков. На этапе preseed у нас есть только идея и мы выделяем самые рискованные гипотезы. Я выписываю все свои рискованные предположения и вижу, что самое рискованное предположение, например, связано не со спросом, а с рынком. Например, объемы рынка недостаточно велики. Первое, что я пойду делать - изучать рынок. Но если я, например, понимаю, что у меня есть сомнения о востребованности продукта среди юзеров, то один из самых дешевых методов тестирования моей идеи - кастдевы. Можно провести Jobs to be Done интервью, чтобы узнать, есть ли у пользователя задачи, которые мой продукт сможет закрыть, и если есть, то перейти далее к проблемным интервью. Если на этапе preseed мы выявили возможные проблемы со спросом на продукт, то cusdev - один из самых дешевых методов проверки на начальном этапе.
`— Я бы добавил, что когда мы только пытаемся найти проблему/боль/пользовательский инсайт, нам как раз-таки нужен инструмент, с помощью которого мы будем исследовать пользователя. На этом этапе это актуально как никогда: у тебя нет никакой информации, а проблему найти нужно.Давай рассмотрим другие стадии. Для зрелых продуктов и вообще для тех, кто уже вышел на рынок, насколько этот инструмент применим и нужен?`
— У меня был интенсив с основателем Мартех-стартапа, и он сказал, что хороший продакт знает своих юзеров. И, соответственно, даже при зрелых продуктах надо периодически общаться с пользователями, чтобы вы не теряли с ними связь, знали их боли и жили их проблемами и задачами.
И второй момент - кастдевы, как и пользовательские интервью, бывают разные. Особенно, когда компания большая и обладает нужными материальными ресурсами, на регулярной основе точно нужно проводить решенческие интервью. Когда мы делаем интерфейс в больших компаниях, мы тестируем их на пользователях, проверяя, чтобы им было удобно. Также, если у нас уже есть продукт, который мы совершенствуем и предлагаем новые решения, нужно проводить Jobs to be Done интервью, чтобы понять, есть ли смысл вводить какую-то новую фичу в наше приложение, насколько часто пользователи сталкиваются с этой задачей. И если есть какие-то проблемные места, с помощью интервью мы смотрим, как их можно закрыть. Поэтому в зрелом продукте кастдев - это тоже актуальная вещь.
`— Можешь пару слов сказать о Jobs to be Done? В принципе, все так или иначе слышали об этом. Но что именно вы вкладываете в этот инструмент?`
— Jobs to be Done фактически формулируется следующим образом: когда я хочу что-то сделать, чтобы что-то получить, мы исходим не из персоны пользователя, а из задачи, которая перед ним стоит. Используем его для того, чтобы сформулировать, зачем мы делаем ту или иную фичу, как она поможет нашему пользователю. Перед JTBD интервью мы выделяем направления, про которые будем спрашивать, и формулируем вопросы. Например, если нам интересно, как человек проверяет своих контрагентов, мы спрашиваем его про весь процесс проверки. Потенциальный пользователь рассказывает, через какие шаги он проходит, а мы пытаемся понять, что ему нравится и как часто он этим занимается. На основе этой информации мы понимаем контекст ситуации, его мотивацию и конкретные желания. Если человек делает проверку контрагентов перед заключением договоров с мелкими фирмами и когда делает платеж, мы понимаем, где конкретно нам лучше встроить эту фичу. Его мотивация состоит в том, что его не обманут и налоговая не заберет положенные ему выплаты за связь с недобросовестным контрагентом. Мы собираем всю эту информацию и исходя из этого можем более точечно спроектировать фичу под запросы пользователя, чтобы она логично ложилась в его привычный распорядок.
`— То есть, если говорить про акторов, userstory - это фокус на эмпатию? А здесь я - это как таковая система? Или же здесь есть обязательная привязка к человеку/лицу/роли?`
— В Userstory есть привязка к именно профилю юзера, что, как мне кажется, дает не очень много информации с точки зрения продукта, как именно Jobs to be Done. Здесь происходит замен профиля юзера на конкретную ситуацию. Сравнение JTBD и Userstory - классический случай. Это как батончик сникерса. Вне зависимости от того, каким юзером ты являешься, у тебя есть задача. Причем задача одна и та же и ученика, и у учителя, и у банкира - быстро насытиться. Для нас неважно, что за профиль у юзера, мы должны просто решить задачу.
### Посадочная страница
`— Давай двигаться дальше: ты создала lending page с каким-то трафиком и value proposition. Скажи, пожалуйста, где это использовать?`
— Его можно использовать для того, чтобы протестировать спрос на продукт. Получается, что у нас есть идея продукта, в котором мы уверены. Уверенность может рождаться из нашей экспертности. Например, я учитель и вижу проблему Х, ощущаю ее на себе и хочу потестить. Считаем, что нам незатратно сделать лендинг: за 2 часа собрать его на Тильде. Если я не уверен, есть вероятность, что мне придется несколько раз на лендинге ее переделывать, и, возможно, с точки зрения времени, есть более дешевый способ проверки гипотез. Например, кастдевы. Соответственно, лендинг пишется, когда у меня есть сформированная идея, понимание ЦА и того, что я могу предложить с точки зрения ценности для клиента. Я описываю это на лендинге и оставляю на нем форму для записи с лид-магнитом. Если пользователь оставляет контакты, то мы можем считать, что он хоть как-то заинтересован в нашем продукте.
`— Это такой элемент фиксации намерений, да? В решенческих интервью это письмо, гарантия о будущем сотрудничестве.`
— Да. Самый топ - это когда пользователь платит. Недавно приходил стартап и мы с ними обсуждали. Они говорят: “Мы год не хотим брать платежи”. Понятно, что у стартапа на начальных этапах нету цели выйти на огромную прибыль, но когда ты получаешь оплату - это гарантия интереса. Можно говорить, все, что угодно - насколько человеку нравится фича и т.п., но когда он платит - это значит, что продукт действительно интересен.
Это большая боль и проблема, когда ты бредишь: создал себе мир, в котором твой продукт необходим, и в нем находишься.
Есть еще очень важный момент. Бизнес, стартап - это про масштабирование воронки. Чтобы это масштабировать, желательно, чтобы это число было положительное и было в принципе: ноль масштабировать смысла нет. Хотя нет - легко масштабировать, умножаешь на что угодно и получаешь ноль🙂. Отличный способ слить деньги.
### Коридорные тесты
Окей, сделали УТП, лендинг, все собрали. Какие есть еще инструменты для проверки гипотез? Я тут себе написал про коридорный тест. Расскажу про свой опыт в ВК. Мы обновляли интерфейс у вебинарной площадки, которую используют там как сервис. Мы пилили достаточно много гипотез. Делали это в рамках HADI (Гипотеза, Действия, Данные, Инсайты) - инструмента для приоритизации веры, команды и затрат в какую-то гипотезу. Мы используем этот фреймворк для того, чтобы понять, что нам делать.
Понятно, что вкусовщины много: дизайнер хочет одно, мы - другое. А гипотезу нужно проверять и ты идешь, проводишь 30 коридорных тестов, люди смотрят, сравнивают с текущей версией, между версиями и дальше ты считаешь и смотришь, что получается. Это очень сильный инструмент, который помогает не бредить, а взять релевантную аудиторию и с ней поговорить.
— Да, коридорки - отличный вариант для решенческого интервью для проверки гипотезы. Можно быстро в Figm’е сделать прототипчик. Figm’a - очень классный инструмент. Можно даже сразу на телефоне посмотреть приложение.
### Fake button
— Применяется, когда мы хотим внедрить фичу в существующий продукт и хотим посмотреть, какой будет спрос на него. Мы внедряем кнопочку, под которой ничего нет. Соответственно, клиенты кликают туда, если им интересно и мы трекаем их интересы. Это считается серым способом, потому что не очень хорошо, когда мы клиенту ничего не даем. В больших компаниях может быть репутационный момент, поэтому нужно рассматривать, насколько мы готовы в него идти. Однако это даст дешевое и точное понимание, какой у нас будет охват, если мы не будем лить трафик в эту историю.
`— Это такой dark pattern своего рода, когда мы немного обманываем, но получаем информацию. Это мне напомнило паттерны в Амазоне, когда для того, чтобы удалить там аккаунт нужно пройти 20 экранов и несколько дать согласие, что это точно произойдет. В конце же нужно отправить запрос в форме заявки в support Амазона. По-другому ты не можешь сделать это. Просто невероятно.`
— Не очень люблю dark pattern истории, я люблю крутой сервис. Где бы я не находилась, если там плохой сервис, это меня очень раздражает. Поэтому я стараюсь смотреть на вещи, как пользователь: чтобы ему было максимально комфортно и все нравилось.
`— Согласен, но иногда бывает так, что, просто поменяв в основном окне подтверждения местами кнопки, ты можешь увеличить конверсию за счет того, что пользователь запутается. Это часто делают для того, чтобы привлечь внимание. Например, в бесплатных играх это часто делается, чтобы вы потратили 1000 рублей. Но может быть и обратный эффект, когда меняют местами кнопки для того, чтобы вы отвлеклись и подумали: “надо почитать, изучить, здесь что-то другое” и тогда только согласиться на условия.`
### Ухудшающие тесты
`— Ты часто приводишь пример из корпорации, а можешь рассказать, насколько часто вы там используете ухудшающие тесты.`
— В ВТБ мы такое не использовали. Я знаю, что такое делает Райффайзен. Недавно читала их [статью](https://sense23.com/post/produktovye-eksperimenty-v-krupnom-banke-kak-sohranit-loyalnost-komand-i-soznatelno-ronyat-metriki) про то, что ухудшающие тесты очень сильно недооценены. Они помогают сконцентрироваться на самом важном. Например, мы спроектировали процесс обслуживания наших пользователей. Если мы с помощью ухудшающего теста понимаем, что пользователь готов подождать время дозвона с 5 на 7 минут и это не снижает конверсию, то мы можем снизить нагрузку на наш коллцентр и сфокусировать наши ресурсы на более важной вещи для пользователя.
— Большинство тестов помогают понять, что мы получим, если добавим какую-то фичу. Этот тест говорит: “а вдруг ты ошибаешься, и на самом деле это фича вообще не влияет на результат”. Например, скорость загрузки страницы. Когда я работал с IT сервисами, они очень много драли за то, чтобы увеличить скорость загрузки страницы. Это сложная технологическая задача - изменить стек технологии. IT команде пришлось бы очень много переделывать. Мы провели тестирование, которое разумеется показало, что скорость загрузки вообще не влияет на конверсию. Влияет другое: текст и понятность интерфейса.
### Прототипы
Для тестировании ценности продукта можно использовать разные прототипы, не только в Figm’е. Сейчас достаточно популярны No Code инструменты. Есть на любой вкус и цвет: можно сделать и веб приложение, и адаптив для мобильного, и интегрировать с Google таблицами. У этого есть плюсы, и минусы.
Плюсы. Можно обойти создание продукта своим ресурсами, если на приличном уровне шаришь в UX/UI дизайне, а можно и без него. если используешь шаблоны.
Минусы. Во-первых, No code - это отстающая история. Например, когда на рынке появляются популярные маркетплейсы, No cоd’ы постепенно перенимают эту историю и тоже предлагают им легкую возможность создать такой маркетплейс. Но вы не в первых рядах. Вряд ли получится создать инновации с помощью них. Во-вторых, есть зависимость от платформы. Если платформа легла, то это будет влиять и на продукт. В краткосроке, это дешевле и выгоднее, но в долгосроке на No Cod’е не посидишь, потому что если оставаться на нем, накопится legacy, нужно будет переводить клиентов, вставлять ключи… В принципе, для тестирования прототипа ок, но дальше - нет.
Есть еще такой вопрос: “Кому принадлежит кодовая база?”. Например, когда ты сделал сайт на no code, можешь ли ты зарегистрировать его и свой продукт на себя или она пренадлежит условному bubbl’у.
> Значит, возникает юридический момент: ты собрал сайт на Тильде - а кому принадлежит эта собственность. Это хороший вопрос. Вот, например, у меня школа на 1.5 тысяч платящих пользователей, но мы не используем ни одного программного продукта, который бы написали сами. Мы используем Тильду, Формы, SaaS решения и все прочее. Я не очень хочу платить за разработку - сейчас все дорого и хочется пока есть возможность, справляться так. Сейчас наш оборот меньше 100 миллионов рублей в год. Когда мы перейдем определенный порог, нам точно нужно будет все эти элементы модифицировать
>
>
### Итог
— Мы говорим про лендинг как про инструмент, хотя правильно исходить из цели. Цель - это протестить спрос. Как я могу это сделать?
Я могу это сделать разными нативными способами там, где обитает моя ЦА. Один из вариантов - условный телеграм канал или создание группы в соцсетях.
Есть такая фишка, которую делала знакомая SMM. Она искала треды, где что-то обсуждалось, и нативно вставляла свои услуги. Рассказывала свой кейс и приглашала поговорить об их ситуации, а дальше продавала. Лендинг - не единственное, на чем нужно зацикливаться. Нужно смотреть на цель.
— Согласен с тем, что важно задавать вопрос: “Для чего и как мы это делаем”. Каждое из перечисленного можно рассматривать и как инструмент, и как метод. Вещи могут давать нам гипотезы, а может быть инструментом для их проверки. Поэтому при их использовании нужно думать и осознавать, что мы используем и как. Второе - большое количественно инструментов - это большая ответственность, как говорил дядя П.
— Да, а еще все эти инструменты можно использовать в комбинации. Например, запустить лендинг, собрать список заинтересованных идей, а дальше для того, чтобы сформировать продукт, можно попробовать связаться с этими людьми и провести с ними кастдевы и JBTD. | https://habr.com/ru/post/668042/ | null | ru | null |
# Недокументированные возможности Windows: точки остановки для ключей реестра
Иногда в процессе обратной разработки какой-либо программы (в том числе драйвера) может потребоваться прервать ее исполнение в момент совершения некоторого действия с определенным ключом реестра, в такой ситуации можно воспользоваться недокументированной функциональностью точек остановки для ключей реестра.
Впервые точки остановки для ключей реестра появились в Windows XP, где была реализована возможность исполнения ядром инструкции int 3 при открытии ключа реестра с пометкой (отладочным флагом) `BREAK_ON_OPEN` или при создании подключа в составе такого ключа.
*Рис. 1: Фрагмент функции CmpDoOpen*
Данная функциональность появилась в ядре еще до выпуска каких-либо пакетов обновления, причем устанавливать отладочную («checked») версию ядра не требовалось. Вместе с тем API-функций для установки флага `BREAK_ON_OPEN` не было, а потому этот флаг можно было выставить у ключа только через редактирование файла с кустом реестра в HEX-редакторе.
Начиная с Windows Vista, список доступных отладочных флагов был расширен, появилась возможность установки этих флагов через API-функцию NtSetInformationKey, однако сама функциональность осталась только в отладочных версиях ядра (которые можно взять из Windows Driver Kit).
*Табл. 1: Возможные значения отладочного флага*
| **Флаг** | **Значение** | **Примечание** |
| --- | --- | --- |
| BREAK\_ON\_OPEN | 0x01 | Открытие ключа |
| BREAK\_ON\_DELETE | 0x02 | Удаление ключа |
| BREAK\_ON\_SECURITY\_CHANGE | 0x04 | Изменение дескриптора безопасности |
| BREAK\_ON\_CREATE\_SUBKEY | 0x08 | Создание подключа |
| BREAK\_ON\_DELETE\_SUBKEY | 0x10 | Удаление подключа |
| BREAK\_ON\_SET\_VALUE | 0x20 | Установка значения |
| BREAK\_ON\_DELETE\_VALUE | 0x40 | Удаление значения |
| BREAK\_ON\_KEY\_VIRTUALIZE | 0x80 | Виртуализация ключа |
Для установки отладочного флага необходимо вызвать функцию NtSetInformationKey, передав ей в качестве первого аргумента дескриптор ключа реестра, для которого нужно установить отладочный флаг. В качестве второго аргумента — KeySetDebugInformation, а последние два аргумента должны описывать буфер, содержащий двойное слово (DWORD), в котором размещено значение отладочного флага (или комбинация из двух и более флагов).
Для активации обсуждаемых точек остановки необходимо выставить значение переменной ядра CmpRegDebugBreakEnabled в единицу.
#### Пример
В качестве примера попытаемся поймать момент записи значения в ключ реестра «`HKEY_LOCAL_MACHINE\SYSTEM\MountedDevices`», где сохраняются сведения о смонтированных томах, и определить компонент Windows, который записывает туда данные. Для этого отметим указанный ключ отладочным флагом `BREAK_ON_SET_VALUE`, включим точки остановки, изменив значение переменной CmpRegDebugBreakEnabled на единицу, и отформатируем тестовый диск, который затем смонтируем.
В результате происходит срабатывание точки остановки, виден следующий стек вызовов:
```
# Child-SP RetAddr Call Site
00 ffffd000`79b851a0 fffff803`7ccf88fa nt!CmSetValueKey+0x158
01 ffffd000`79b852b0 fffff803`7c69eac3 nt!NtSetValueKey+0x73e
02 ffffd000`79b85470 fffff803`7c697e40 nt!KiSystemServiceCopyEnd+0x13
03 ffffd000`79b85678 fffff803`7d08f11e nt!KiServiceLinkage
04 ffffd000`79b85680 fffff801`46d6fcaa nt!RtlWriteRegistryValue+0x9e
05 ffffd000`79b856f0 fffff801`46d6b58c mountmgr+0xecaa
06 ffffd000`79b85820 fffff803`7cd9cd78 mountmgr+0xa58c
07 ffffd000`79b85850 fffff803`7cd9bdd5 nt!PnpNotifyDriverCallback+0x1b8
08 ffffd000`79b85900 fffff803`7cdd6755 nt!PnpNotifyDeviceClassChange+0x2f9
09 ffffd000`79b859d0 fffff803`7c66dcb7 nt!PnpDeviceEventWorker+0x4c1
0a ffffd000`79b85b50 fffff803`7c5e7071 nt!ExpWorkerThread+0x177
0b ffffd000`79b85be0 fffff803`7c699836 nt!PspSystemThreadStartup+0x23d
0c ffffd000`79b85c60 00000000`00000000 nt!KiStartSystemThread+0x16
```
По стеку вызовов ясно видно, что запись инициирует компонент «mountmgr», в его коде можно обнаружить искомый вызов nt!RtlWriteRegistryValue:
```
fffff801`46d6fca4 ff15fe44ffff call qword ptr [mountmgr+0x31a8 (fffff801`46d641a8)] // вызов nt!RtlWriteRegistryValue
fffff801`46d6fcaa 488d55b7 lea rdx,[rbp-49h]
```
#### Выводы
Описанная функциональность может быть использована как для решения задач, связанных непосредственно с отладкой ядра и драйверов, так и для решения сторонних задач — например, поиска программ в исследуемом образе системы, которые используют заданный ключ реестра. | https://habr.com/ru/post/321288/ | null | ru | null |
# CSS3. Работа с тенями. Часть 1
*Так получилось (и прошу считать это удачным совпадением), именно сегодня на Хабре опубликован топик про [практическое применение теней из CSS3 для создания интересных эффектов](http://habrahabr.ru/blogs/css/133258/), а мы в свою очередь подготовили топик про основы для этого творчества.*
Мы попробуем разобраться в том, как работают тени в новых модулях CSS3. С практической точки зрения, мы рассмотрим два правила: *box-shadow* и *text-shadow*, определенные соответственно в модулях [CSS3 Backgrounds and Borders](http://www.w3.org/TR/css3-background/#the-box-shadow) и [CSS3 Text](http://www.w3.org/TR/css3-text/#text-shadow).
Оба правила работают схожим образом (вплоть до соответствующей отсылки в спецификации), поэтому имеет смысл рассматривать их вместе. Вместе с этим есть некоторые различия, о которых тоже нельзя не сказать.
Первая часть посвещена работе с box-shadow, во второй мы пройдемся по теням для текста.
box-shadow
----------
### Сдвиги и цвет
В самом простом варианте для задания тени достаточно указать два параметра, задающие соответственно горизонтальный и вертикальный сдвиги тени (1.1):
```
box-shadow: 3px 3px;
```
Положительные значения сдвига смещают тень вправо и вниз, отрицательные — влево и вверх.
По умолчанию, если цвет тени не задан, в большинстве браузеров (все, кроме webkit-based) он берется из цвета текста (color) в текущем контексте (1.2), впрочем, похоже, этот момент спецификацией не обговаривается:
```
box-shadow: 3px 3px; color:blue;
```
Чтобы задать цвет тени, достаточно указать его дополнительным параметром (1.3):
```
box-shadow: 3px 3px darkgreen;
```
Очевидно, цвет можно указывать любым из доступных способов: от прямого указания названия и шестнадцатеричного кода, до rgb или rgba и hsla с прозрачностью (мы рассмотрим такие примеры чуть позже).
### Размытие
Третий «линейный» параметр, который можно задать при описании тени — это радиус размытия (blur), положительная величина, указывающая насколько сильно нужно размывать тень по пространству (2.1–2.3):
```
box-shadow:3px 3px 3px darkgrey;
```
По умолчанию радиус размытия равен 0 и в этом случае тень получается четкой.
В сочетании с разными сдвигами тени, можно получить разные эффекты, например, на (2.3) оба сдвига тени равны нулю, но за счет размытия тень выступает с разных сторон:
```
box-shadow:0 0 9px black;
```
Сам алгоритм размытия спецификацией не описывается, кроме указания того, что это должен быть эффект, аналогичный размытию по Гауссу (Gaussian blur) с половинным радиусом в обе стороны от границы тени (2.4):
### Растяжение
Еще один интересный параметр — это растяжение или распространие тени (spray), позволяющее увеличить или уменьшить ее размеры (по умолчанию размеры тени соответствуют размеру исходного объекта). Надо отметить, что этот параметр не сразу появился в спецификации, поэтому во множестве примеров в интернете он просто не рассматривается.
Для увеличения тени нужно указать положительный spray-параметр (3.1, 3.2):
```
box-shadow:6px 6px 0px 4px darkred;
```
Для уменьшения — отрицательный (3.3):
```
box-shadow:12px 12px 8px -4px darkred;
```
Растяжение или сжатие тени можно расценивать как операцию масштабирования, но спецификация описывает это несколько более хитро (через аналогию с размытием и удаление прозрачных или непрозрачных пикселей), что, впрочем, не меняет сути дела:
На примере выше (3.4) тень смещена на 6px вниз и влево и увеличена на 8px с каждой стороны:
```
box-shadow:6px 6px 0 8px grey;
```
Если в вашем блоке используются скругленные уголки, будьте готовы к тому, что в расширенной тени радиус скругления также будет пропорционально смаштабирован (3.5):
### Внутренняя тень
Наконец, еще один хитрый параметр — это возможность применения тени внутри блока. Для этого используется специальное ключевое слово *inset* (4.1-4.4):
```
box-shadow:inset 4px 4px rgba(66,66,66,0.5); /* (4.1) */
box-shadow:inset 4px 4px 0 8px rgba(198,198,198,1); /* (4.2) */
box-shadow:inset -2px -2px 8px 0px black; /* (4.3) */
box-shadow:inset 0 0 4px 0px black; /* (4.4) */
```
Обратите внимание, что внутренняя тень отрисовывается только внутри блока, к которому применено соответствующее правило, причем применение spray-параметра для внутренней тени (4.2) в отличие от внешней приводит к уменьшению внутреннего перимерта тени.
### Множественные тени
Ну и теперь еще один нюанс: на самом деле, к блокам можно применять любое количество теней одновременно, для этого достаточно их перечислить через запятую при описании box-shadow.
Например, чтобы получить радужную тень (5.1) достаточно последовательно указать 7 теней с увеличивающимся растяжением:
```
box-shadow: 0 0 2px 1px red,
0 0 2px 2px orange,
0 0 2px 3px yellow,
0 0 2px 4px green,
0 0 2px 5px lightblue,
0 0 2px 6px blue,
0 0 2px 7px violet;
```
Обратите внимание, что фактически тени выстраиваются в стек в обратном порядке и отрисовываются, начиная с последней, причем каждая из них применяется к исходному объекту так, как будто есть только она.
Так как тени независимы, вы легко можете сочетать тени, выстроенные в разных направлениях (5.2):
```
box-shadow: -6px -6px 8px -4px rgba(255,0,0,0.75),
6px -6px 8px -4px rgba(0,255,0,0.75),
6px 6px 8px -4px rgba(255,255,0,0.75),
-6px 6px 8px -4px rgba(0,0,255,0.75);
```
Аналогично, можно сразу задавать внутренние и внешние тени (5.3):
```
box-shadow: inset 0 0 8px lightgray,
1px 1px 3px darkgray;
```
Или «продвинутое подчеркивание» (5.4):
```
box-shadow: 0 1px red,
0 3px 3px -2px black
```
Или, если проявить еще немного фантазии и дополнительных спецэффектов, сделать slick-box, [описанный, например, у Matt Hamm](http://www.matthamm.com/box-shadow-curl.html) (5.5):
```
.slick-box {
position: relative;
height: 50px;
border: 1px solid #efefef;
background: #fff;
box-shadow: 0 1px 4px rgba(0, 0, 0, 0.27), 0 0 40px rgba(0, 0, 0, 0.06) inset;
}
.slick-box:before, .slick-box:after {
content: '';
z-index: -1;
position: absolute;
left: 10px;
bottom: 10px;
width: 70%;
max-width: 300px; /* avoid rotation causing ugly appearance at large container widths */
height: 55%;
box-shadow: 0 8px 16px rgba(0, 0, 0, 0.3);
transform: skew(-15deg) rotate(-6deg);
}
.slick-box:after {
left: auto;
right: 10px;
transform: skew(15deg) rotate(6deg);
}
```
(Для упрощения, я убрал код с вендорными префиксами, но вам нужно будет добавить -ms-transform, -webkit-transform и т.д.)
### Общий синтаксис
Резюмируя, синтаксис для описания теней выглядит следующим образом:
```
box-shadow: [ , ]\*;
= inset? && [ {2,4} && ? ]
```
Последнее в полном виде разворачивается в следующую схему:
```
box-shadow: inset? h-offset v-offset blur-radius spread-distance color;
```
Радиус размытия и растяжение не являются обязательными. *inset* переключает режим отображения тени с внешней на внутреннюю.
### Интерактив
Если вы хотите просто поиграться с тенями в интерактивном режиме, наши коллеги к прошедшей в сентябре конференции [Build](http://buildwindows.com) подготовили демонстрационную страницу: "[Hands-on: box-shadow](http://ie.microsoft.com/testdrive/Graphics/hands-on-css3/hands-on_box-shadow.htm)".
### Internet Exlorer
Насущный для многих вопрос: **box-shadow поддерживается в IE9 и выше**.
И еще одна важная деталь: стандартные css-правила, начиная с 9й версии Internet Explorer, работают с использованием аппаратного ускорения — в отличие от нестандартных старых фильтров вроде filter:DXImageTransform.Microsoft.Shadow. То есть, использовать стандарты не только правильнее, но и эффективнее.
Мой совет: старайтесь использовать стандартные возможности, исходя из идей progressive enhacenment. | https://habr.com/ru/post/133276/ | null | ru | null |
# Создание USB-гаджета с нуля или еще одна лампа настроения
Как-то на глаза попалась статья про [лампу настроения](http://habrahabr.ru/blogs/DIY/65616/). Будучи очень далеким от электротехники и абсолютно незнакомым с принципом работы микроконтроллеров, полученных из топика данных ну никак не хватало для понимания всех необходимых действий для создания лампы. Со временем на глаза попадались другие интересные проекты на микроконтроллерах, потому в один прекрасный момент появилось желание потратить часть свободного времени на покорение сей стихии.
В этой статье я попытался собрать информацию о первых шагах создания с нуля своего проекта на микроконтроллере.
#### Цель
Изучать работу микроконтроллеров я решил на практике: делать что-то реальное куда интереснее, чем гонять десяток светодиодов в симуляторе.
В первую очередь было необходимо определиться, что хочется сделать. Я остановился на вышеупомянутой лампе настроения. Дабы не создавать полный аналог было решено расширить функционал лампы и добавить управление с ПК.
#### Микроконтроллер
Выбор микроконтроллера был прост.
Работать с ПК через COM порт — несовременно, потому был выбран вариант связи через USB. Дабы не начинать с микропайки, было решено использовать только компоненты в DIP корпусе. Подходящих микроконтроллеров осталось немного: или любой AVR с программной эмуляцией USB, или PIC серии 18F с аппаратной поддержкой USB 2.0.
Кто-то может решить по другому, но мой выбор пал на последний вариант, в данном проекте я использовал МК PIC18F2455.
> 18F2455 можно заменить без последствий на 18F2550, разница лишь в объеме памяти.
>
> С минимальными изменениями можно так же использовать:
>
> 18F4455/4550 — при необходимости большего количества ног (40 вместо 28)
>
> 18F14K50 — 20 ног, немного обрезанный функционал, зато немного дешевле
#### Схема
Самая простая схема для подключения PIC18F2455 выглядит так:
[](http://habrastorage.org/storage/habraeffect/60/83/6083a368ee9d60953d6ac37ebce40c43.jpg)
*По неизвестной мне причине на схеме переставлены местами 25 и 26 ноги МК.*
Отталкиваясь от нее можно составить схему для лампы. Из изменений потребуется:
Питание 5В и землю взять от USB.
Соединить D+ и D- USB с соответствующими ногами МК.
Подключить к одному цифровому входу кнопку.
К трем цифровым выходам подсоединить транзисторы для управления светодиодом.
[](http://habrastorage.org/storage/habraeffect/12/40/1240cb998091425b954a25a24c70f65c.jpg)
На схеме не отображены только мощные резисторы к катодам светодиода.
#### Программатор
Перед сборкой микроконтроллер необходимо прошить. Умные люди скажут, что нет ничего лучше PicKit для прошивки пиков. Но кому хочется тратить 1000-2000 руб. для разовой прошивки МК?
Существуют множество схем самодельных программаторов различной сложности исполнения, но не у всех выходит заставить работать их с первого раза.
Мною были опробованы два самых простых программатора: один работает через LPT порт, другой — через COM. Удивительно, но все заработало без особых проблем.
Схема art2003 ([читать подробнее](http://www.foxdelta.com/products/art2003.htm)):
[](http://habrastorage.org/storage/habraeffect/1d/f1/1df1bc5f792e7e8608fadcd48d441683.jpg)
LPT разъем, 8 диодов, конденсатор и резистор. Только список поддерживаемых МК не радует.
Схема универсального программатора (работает как JDM):
Такой простой схемой на трех резисторах с внешним питанием 5В можно прошить почти любой PIC, главное подсоединить провода к нужным ногам МК (а так же не забыть, что Vdd и Vss может быть несколько).
Питание 5В можно взять от USB, БП компьютера или зарядного устройства для телефона.
Оба программатора поддерживаются программой для прошивки пиков — WinPic800.
#### Бутлоадер
Программатор — это хорошо, но что делать, если требуется часто перепрошивать МК, не оставлять же доступ к плате ради такой мелочи? На этот случай удачно подходит использование бутлоадера. Достаточно один раз записать его в МК, после чего все обновления прошивки выполнять напрямую с компьютера через USB.
На начальном этапе не требуется знать подробностей, достаточно использовать готовые решения. После прошивки бутлоадера в МК достаточно подать питание при зажатой кнопке — и в системе определится новое устройство Microchip Custom USB Device. После установки драйверов можно безопасно работать с доступной памятью через распространяемый Microchip'ом софт.
#### Компилятор
Существует много хороших компиляторов, свой выбор я остановил, наверное, на самом малоизвестном — JAL ([Just Another Language](http://www.casadeyork.com/jalv2/)). Возможно, кто-то посчитает использование этого компилятора неразумным, но он полностью покрыл все мои требования для старта. Минимальный размер (архив 11 мб), отсутствие установки (1 минута на распаковку не в счет), никаких излишеств (мне не нужна среда разработки), наличие всех необходимых библиотек, рабочие примеры для каждого МК (мигание светодиодом) и для всех основных функциональностей.
Пример кода мигания светодиодом:
> `include 18f2455 -- библиотека для используемого МК
>
> --
>
> pragma target clock 48\_000\_000 -- частота МК, задается для расчета задержки
>
> --
>
> enable\_digital\_io() -- переключение всех входов на цифровой режим
>
> --
>
> **alias** led **is** pin\_B3 -- привязываем led к пину B3
>
> pin\_B3\_direction = output -- настраиваем пин B3 для работы как выход
>
> --
>
>
>
> **forever loop** -- основной цикл
>
> led = on -- включить светодиод
>
> \_usec\_delay(250000) -- пауза
>
> led = off -- выключить светодиод
>
> \_usec\_delay(250000) -- пауза
>
> **end loop**`
При использовании бутлоадера вся конфигурация МК устанавливается в нем, для адаптации прошивки к бутлоадеру достаточно изменить параметры компилирования добавив флаги **-loader18 2048 -no-fuse**.
#### Прошивка
Описывать все тонкости при написании программы для МК — не хватит не только одной статьи, но и книги. Одна только документация по PIC18F2455/2550/4455/4550 занимает 430 страниц. Узнать все и сразу — почти невозможно.
Самый простой способ написать что-то свое — посмотреть примеры и сделать по аналогии. Данный путь не всегда самый верный, но постоянно проверяя каждую строчку кода на работоспособность выходит вполне рабочая программа.
Функционал, включенный в текущую версию прошивки:
* софтовый 8-битный ШИМ на 200 Гц, 3 канала
* возможность использования таблицы коррекции гаммы (желательно перевести ШИМ на BAM 10-бит, иначе заметны переходы цвета)
* 4 процедуры для работы с цветом:
+ программный таймер с шагом 0.1с (макс. время 1:49:13.5) для пауз и установки времени перехода
+ переход от текущего до заданного цвета по RGB значениям за время таймера
+ переход от текущего до заданного цвета по HSV значениям за время таймера
+ мгновенное изменение цвета
* 6 подпрограмм смены цвета
+ вращение по HSV колесу; дополнительно: колебание по насыщенности и яркости
+ цикл основных цветов; дополнительно: рандомное время перехода на каждый шаг
+ фиксированный цвет; дополнительно: второй фиксированный цвет
+ рандомный цвет по параметрам RGB; дополнительно: рандомный цвет по параметрам HSV
+ предустановленный цикл цветов; дополнительно: — (в будущем — набор команд, загруженный с ПК)
+ (активируется с ПК)прямой вывод полученного с ПК цвета; дополнительно: плавное переход на новый цвет
* трехрежимная кнопка
+ быстрое нажатие — смена подпрограммы (либо сброс паузы);
+ продолжительное нажатие — альтернативный режим;
+ длительное нажатие — переход в сервисный режим(для перепрошивки)
* таймер обратного отсчета (задается с ПК, макс. время 1:49:13.5)
* оповещение о событиях (многократные и одноразовые), 6 каналов (по количеству основных цветов)
* пауза на время различных событий
* связь с ПК:
+ возможность изменить основные параметры каждой подпрограммы при помощи софта
+ прием команд управления таймером обратного отсчета и оповещениями
+ возможность прямого контроля цвета с ПК, что открывает путь к расширению функционала за счет софта.
Казалось бы: вроде ничего особенного. За вечер можно написать. Но, не зная как работают МК, собираешь, наверное, почти все грабли, которые можно встретить. Тем не менее все труды по перечитыванию документации, углубленному гуглению и переписыванию кода с нуля были оправданы: конечный результат оказался вполне работоспособен.
#### Сборка
Основные составляющие лампы — корпус, микроконтроллер и светодиод.
В качестве основы для лампы была взята все та же лампа GRÖNÖ из IKEA.
Светодиод — китайский аналог с DealExtreme ([SKU 4530](http://www.dealextreme.com/details.dx/sku.4530)), почти в 3 раза дешевле оригинала.
Светодиод сильно греется, необходим хоть какой радиатор, иначе ярко гореть он будет не долго.
Мелочевка:
* панелька для МК
* 3 транзистора
* 3 мощных и 5 маломощных резисторов
* 2 конденсатора
* резонатор
* кнопка
* miniUSB разъем (в DIP исполнении — редкость)
Все это разместил на плате, дабы попасть в нишу лампы.
[](http://habrastorage.org/storage/habraeffect/01/95/01954d162da7dd9161b499dd30420e64.jpg)
Разводка платы в Sprint Layout, перевод на текстолит методом [ЛУТ](http://habrahabr.ru/blogs/easyelectronics/45322/), сверление, пайка.
[](http://habrastorage.org/storage/habraeffect/16/ac/16ac14b2c5ea4d936aa2375dc97d296b.jpg) [](http://habrastorage.org/storage/habraeffect/98/fa/98fabf3112e99907f909cbcc56761708.png)
[](http://habrastorage.org/storage/habraeffect/4f/63/4f63401f9f3ef9e0dc5508a11ecb8538.jpg) [](http://habrastorage.org/storage/habraeffect/d0/fc/d0fc83b3c60bb29237448e2c9fcd5648.jpg) [](http://habrastorage.org/storage/habraeffect/09/ed/09edc8642df4a9ecc9ed1fca70a7b0e5.jpg)
Работа не идеальная, да и без ошибок не обошлось: один резистор оказался лишним (на схемах его уже нет).
[](http://habrastorage.org/storage/habraeffect/ed/0a/ed0ab1d290ee0e9007316e0e2089e1e2.jpg) [](http://habrastorage.org/storage/habraeffect/d8/0a/d80abbd0371f1d9b714a01e82e1d2f4f.jpg)
Вся плата размещена под лампой, в выемке для провода размещены кнопка и разъем miniUSB для питания и связи с ПК.
[](http://habrastorage.org/storage/habraeffect/3d/40/3d40f27f20ed266732497abb45f1637c.jpg) [](http://habrastorage.org/storage/habraeffect/75/77/7577a22f8629a33c43d35a300b3596db.jpg)
Питание подается через miniUSB, но не стоит подключать лампу с таким светодиодом к первому подвернувшемуся источнику питания: лампа на полной яркости потребляет чуть меньше 1А. Не все БП рассчитаны на такой ток, в зависимости от типа БП им может стать крайне плохо, что может привести к неприятным последствиям.
Для подключения к компьютеру возможно потребуется кабель с дополнительным разъемом питания (как у переносных HDD) или хороший активный USB хаб.
#### Софт
Найти подходящий софт для индивидуальной задачи — невозможно. Пришлось заняться и этим вопросом самостоятельно.
Программа писалась параллельно с прошивкой и использовалась в основном для отладки лампы. На данный момент не реализованы несколько функций — но возможно вскоре найдется время доделать и их.
#### Итоги
Как оказалось, сделать себе уникальный USB-гаджет с нуля — вполне доступная задача. Для этого не требуется мастерство пайки недешевых ft232, не требуется отвлекаться на совместимость с программной реализацией USB и не требуется никаких полуфабрикатов Arduino. Все что нужно — это немного желания.
#### Полезная информация
[Набор файлов проекта.](http://narod.ru/disk/23522629000/RGBLamp.rar.html)
[Документация по семейству PIC 18F с поддержкой USB 2.0.](http://ww1.microchip.com/downloads/en/DeviceDoc/39632e.pdf)
Русский перевод документации: книга «Микроконтроллеры Microchip с аппаратной поддержкой USB» Автор: В. С. Яценков.
[Набор библиотек](http://code.google.com/p/jallib/) для JAL и IDE — [JALEdit](http://jal.sunish.net/jaledit).
[WinPic800](http://www.winpic800.com/) — программа для прошивки Pic.
[MCHPFSUSB](http://ww1.microchip.com/downloads/en/DeviceDoc/MCHPFSUSB_Setup.EXE) — набор для работы с бутлоадером. | https://habr.com/ru/post/95789/ | null | ru | null |
# Как использовать Python для «выпаса» ваших неструктурированных данных
Здравствуйте, уважаемые читатели.
В последнее время мы прорабатываем самые разные темы, связанные с языком Python, в том числе, проблемы извлечения и анализа данных. Например, нас заинтересовала книга [«Data Wrangling with Python: Tips and Tools to Make Your Life Easier»](http://www.amazon.com/Data-Wrangling-Python-Tools-Easier/dp/1491948817/):
Поэтому если вы еще не знаете, что такое скрепинг, извлечение неструктурированных данных, и как привести хаос в порядок, предлагаем почитать перевод интересной статьи Пита Тамисина (Pete Tamisin), рассказывающего, как это делается на Python. Поскольку статья открывает целую серию постов автора, а мы решили пока ограничиться только ею, текст немного сокращен.
Если кто-то сам мечтает подготовить и издать книгу на эту тему — пишите, обсудим.
Я – продакт-менеджер в компании Rittman Mead, но при этом я еще считаю себя фриком 80 лвл. Я полюбил комиксы, фэнтези, научную фантастику и прочее подобное чтиво в те времена, когда слово «Старк» еще отнюдь не ассоциировалось с Робертом Дауни-младшим или с мемами о надвигающейся зиме. Поэтому мне очень понравилась перспектива объединить приятное с полезным, то есть, хобби с работой. Я решил написать у себя в блоге несколько статей о построении прогностической модели на основании данных, связанных с продажами комиксов. Конечная цель — предложить такую модель, которая позволяла бы достоверно судить, будут ли читатели сметать новый комикс с полок как горячие пирожки, либо он заляжет на складе. В этой публикации я расскажу о некоторых подводных камнях, которые могут подстерегать вас при подготовке данных к анализу. Подготовка данных, также именуемая «выпасом» (wrangling) – это несовершенный процесс, обычно выполняемый в несколько итераций и включающий преобразование, интерпретацию и рефакторинг – после чего данные можно будет анализировать.
Хотя этапы выпаса данных могут отличаться в зависимости от состояния и доступности «сырых» данных, в этой статье я решил сосредоточиться на сборе информации из разрозненных источников, обогащении данных путем слияния их атрибутов и реструктурировании данных для упрощения анализа. Серии книг с комиксами легко найти в Интернете, однако оказалось, что не так просто добыть их в удобоваримом формате. В итоге я решил поступить дешево и сердито – занялся экранным скрепингом информации с [сайта](http://www.comichron.com/), посвященного исследованию комиксов. Для тех счастливчиков, которым пока не довелось иметь дело с экранным скрепингом, объясняю: при скрепинге вы программно скачиваете HTML-данные и удаляете из них всякое форматирование, чтобы эти данные можно было использовать. Как правило, этот прием используется, когда ничего другого не остается, поскольку сайт – штука непостоянная, контент на нем меняется не реже, чем дитя-подросток намыливается сбежать из дома.
Итак, вот первая проблема, с которой можно столкнуться при выпасе данных. У вас есть доступ к массе данных, но они неаккуратные. Надо их причесать. Работа с сырыми данными напоминает работу резчика по дереву. Ваша задача – не изменить структуру данных таким образом, чтобы подогнать их под свои цели, а отсечь все лишнее, чтобы от чурки осталась красивая лошадка… я имею в виду, чтобы вы могли сделать выводы. Извините, увлекся метафорами. Кстати, продолжая эту аналогию: для работы над этим проектом я первым делом извлек из столярного ящика Python. Для программиста Python – реальный мультитул. Он быстр, хорошо сочетается с другими технологиями и, что наиболее важно в данном случае, он повсеместно распространен. Python используется для решения всевозможных задач – от автоматизации процессов и ETL до программирования игр и академических исследований. Python – по-настоящему многоцелевой язык. Таким образом, столкнувшись с конкретной задачей, вы вполне можете найти в Python специально предназначенный для нее нативный модуль, либо кто-то уже мог написать общедоступную библиотеку, обладающую нужным функционалом. Мне были нужны определенные скрипты для «скрепинга» HTML-таблиц с данными о продажах комиксов. Далее мне требовалось скомбинировать эту информацию с другими данными по комиксам, добытыми в ином месте. «Другая» информация представляла собой метаданные о каждом из выпусков. Метаданные – это просто информация, описывающая другие данные. В данном случае к метаданным относилась информация об авторе, о продажах, о времени публикации и т.д…. Подробнее об этом ниже.
К счастью, те данные, которые я скрепил, были в табличном формате, поэтому извлекать их и преобразовывать в объекты Python было относительно просто – требовалось лишь перебрать строки таблицы и связать каждый столбец таблицы со специально предназначенным для этого полем объекта Python. На странице все-таки оставалось достаточно много ненужного контента, который приходилось игнорировать – например, теги title и другие структурные элементы. Но, как только я нашел нужную таблицу с данными, мне удалось ее изолировать. На данном этапе я записал объекты в CSV-файл, чтобы данные было легко передавать, а также чтобы их было проще использовать с применением других языков и/или процессов.
Вся сложная работа в данном случае выполнялась при помощи трех модулей Python: urllib2, bs4 and csv. Urllib2, как понятно из названия, содержит функции для открытия URL. Работая над этим проектом, я нашел сайт, где была такая страница: на ней содержалась информация с примерными продажами выпусков за каждый месяц вплоть до начала 90-х. Чтобы извлечь данные за каждый месяц, не обновляя вручную жестко закодированные URL снова и снова, я написал скрипт, принимавший в качестве аргументов MONTH и YEAR — `month_sales_scraper.py`
Отклик на вызов функции `urlopen(url)` содержал полный HTML-код в таком виде, как он обычно отображается в браузере. Такой формат был для меня практически бесполезен, поэтому пришлось задействовать парсер, чтобы извлечь данные из HTML. Парсер в данном случае – это программа, которая считывает документ в конкретном формате, разбивает его на составляющие, не нарушая при этом тех взаимосвязей, что имелись между этими составляющими; наконец, парсер позволяет избирательно обращаться к вышеупомянутым составляющим. Итак, HTML-парсер открывал мне легкий доступ ко всем тегам столбцов в конкретной таблице внутри HTML-документа. Я воспользовался программой BeautifulSoup, она же bs4.
В BeautifulSoup есть поисковые функции, позволяющие найти конкретную HTML-таблицу с данными о продажах и циклически перебрать все ее строки, заполняя при этом объект Python значениями из столбцов таблицы.
Этот объект Python под названием data содержит поля, заполненные данными из различных источников. Информация о годе и месяце заполняется на основе аргументов, переданных модулю. Поле формата устанавливается динамически, исходя из логики, по которой строятся рейтинги, а остальные поля заполняются в зависимости от того, где именно их источники расположены в HTML-таблице. Как видите, здесь много жестко закодированной логики, которую пришлось бы обновлять вручную, если бы изменился формат того сайта, с которого мы извлекаем данные. Однако, пока мы справляемся с задачей, пользуясь описанной здесь логикой.
Последний этап решения задачи – записать эти объекты Python в CSV-файл. В модуле Python CSV есть функция `writerow()`, принимающая в качестве параметра массив и записывающая все элементы массива как столбцы в формате CSV.
При первом прогоне программа выдала исключение, поскольку в поле title содержались символы unicode, которые не мог обработать механизм записи в CSV.
Чтобы справиться с этим, пришлось добавить проверку на unicode и закодировать все содержимое как UTF-8. Unicode и UTF-8 – это символьные кодировки, то есть, они служат словарями, при помощи которых компьютеры идентифицируют символы. В кодировках содержатся алфавитные и логографические символы из различных языков, а также другие распространенные символы, например,.
Кроме того, требовалось переформатировать значения в некоторых числовых полях (в частности, удалить оттуда символы $ и запятые), чтобы позже над этими значениями можно было производить математические действия. В остальном загрузка данных прошла вполне гладко. Для каждого месяца был сгенерирован файл под названием (MONTH)\_(YEAR).CSV. Каждый из этих файлов выглядел так:
Хотя в результате были сгенерированы десятки тысяч строк с данными о продажах комиксов, мне этого было недостаточно. То есть, у меня имелся нужный объем информации, но она получилась недостаточно широкой. Чтобы делать точные прогнозы, мне нужно было заполнить в модели и другие переменные, а не только название комикса, номер выпуска и цену. Издательство не имело значения, так как я решил поупражняться лишь с комиксами Marvel, а передача примерных данных по продажам была бы жульничеством, поскольку рейтинг зависит от продаж. Итак, чтобы улучшить мое множество данных, я извлек метаданные о каждом выпуске из «облака», воспользовавшись Marvel’s Developer API. К счастью, поскольку этот API является веб-сервисом, удалось обойтись без скрепинга экрана.
Извлекать и объединять эти данные было не так просто как может показаться. Основная проблема заключалась в том, что названия выпусков, полученные путем скрепинга, не полностью совпадали с названиями, сохраненными в базе данных Marvel. Например, в массиве данных, полученных путем скрепинга, фигурирует название ‘All New All Different Avengers”. Воспользовавшись API для поиска по базе данных Marvel я ничего такого не нашел. В итоге удалось вручную отыскать у них в базе данных запись “All-New All-Different Avengers”. В других случаях попадались лишние слова, сравните: “The Superior Foes of Spider-Man” и “Superior Foes of Spider-Man”. Итак, чтобы выполнить поиск по названию, я должен был знать, в каком виде название может упоминаться в базе данных Marvel. Для этого я решил сделать список названий всех тех серий, чьи метаданные были изменены в течение промежутков времени, по которым у меня были данные о продажах. И вновь я столкнулся с препятствием. API Marvel позволял извлекать не более 100 результатов по одному запросу, а Marvel опубликовали тысячи комиксов. Чтобы обойти эту проблему, пришлось извлекать данные инкрементно, сегментируя их по алфавиту.
Даже здесь возникли небольшие проблемы, поскольку на некоторые буквы, например, ‘S’, попадалось более 100 названий. Чтобы решить их, мне пришлось извлекать все названия на ‘S’ сначала в алфавитном, а потом в обратном алфавитном порядке, затем комбинировать эти результаты и избавляться от всех дублей. Поэтому советую внимательно разбираться со всеми ограничениями того API, который вы собираетесь использовать. Возможно, какие-то ограничения окажутся неустранимыми, но, может быть, их и удастся обойти, изобретательно формулируя запросы.
На данном этапе у меня уже был список названий серий Marvel, сохраненных в нескольких CSV-файлах, которые я в итоге сложил в один файл MarvelSeriesList.csv, чтобы было проще работать. Но у меня было и еще кое-что. Извлекая названия серий, я также сохранял ID каждой серии и рейтинг ее репрезентативности. Поиск по ID гораздо более точен, чем по имени, а рейтинг репрезентативности может пригодиться при построении прогностической модели. Далее требовалось перебрать все строки CSV-файлов, созданных на основе данных о продажах, найти соответствия с ID из файла MarvelSeriesList.csv и использовать этот ID для извлечения соответствующих метаданных через API.
Как вы помните, последний этап понадобился потому, что заголовки, сохраненные в файлах с данными о продажах, не совпали с заголовками в API, и мне требовалось каким-то образом объединить два этих источника. Я не стал писать кейсы для обработки каждого сценария (например, несовпадение пунктуации, лишние слова), я нашел библиотеку Python для поиска нечетких соответствий. Мне попалась исключительно полезная библиотека [Fuzzy Wuzzy](https://github.com/seatgeek/fuzzywuzzy).Fuzzy Wuzzy, в которой была функция `extractOne()`. Эта функция позволяет передать термин и сравнить его с массивом значений. Затем функция `extractOne()` возвращает найденный в массиве термин, максимально соответствующий запросу. Кроме того, можно задать нижний предел приемлемости соответствия (т.е. возвращать лишь те результаты, степень соответствия которых >= 90%).
Опять же, пришлось немного повозиться, чтобы такая конфигурация работала эффективно. На первый раз всего для 65% названий в списках продаж удалось найти соответствия. На мой взгляд, скрипт отсеивал слишком много данных, поэтому пришлось присмотреться к исключениям и выяснить, какие соответствия от меня ускользают. Так, обнаружилась следующая проблема: заголовки, привязанные в базе данных Marvel к конкретному году, например, “All-New X-Men (2012)”, имели рейтинг соответствия более 80 при сравнении с такими заголовками как “All New X-Men”. Эта проблема встречалась постоянно, поэтому я решил не занижать процент соответствия (в таком случае, скрипт мог не заметить некоторых реальных несовпадений), а при несовпадении отсекать год и проверять соответствие снова. Почти получилось. Была еще такая проблема: библиотека This was a pretty consistent issue, so rather than lowering the match percentage, which Fuzzy Wuzzy плохо сравнивала акронимы и акростихи. Так, при сравнении ‘S.H.E.I.L.D.’ и ‘SHIELD’ получалась степень соответствия около 50. Дело в том, что во втором варианте не хватало половины символов (точек). Поскольку в этом случае затрагивалось всего два названия, я написал поисковый словарь со специальными случаями, которые требовалось «переводить». В описываемом упражнении можно было пропустить этот шаг, поскольку у меня и так получалось приличное соответствие, но для стопроцентно точного поиска совпадений он необходим. Как только функция поиска соответствий заработала, я подключил urllib2 и извлек все метаданные по выпускам, которые смог достать.
В готовых файлах содержались не только данные о продажах (название, номер выпуска, месячный рейтинг, примерные продажи), но и информация об авторах, самих выпусках, персонажах, датах выхода и соответствующих сюжетных линиях. | https://habr.com/ru/post/302520/ | null | ru | null |
# v3.14.1592-beta2: все, что вы хотели знать о семантическом версионировании
Усилия и деньги, вкладываемые в продвижение языка Go, часто приносят пользу и другим разработчикам. В конце прошлого года на сайте [gopheracademy](https://www.gopheracademy.com/) была опубликована очень удачная статья о семантическом версионировании. Том самом, которое используется в npm, начинается с домика **^** и все ломает. Под катом спрятан перевод, который поможет вам быстро осмотреть сад граблей версионирования и как сейчас принято им пользоваться. И немного примеров на Go. Передаем слово автору!
[Семантическое версионирование](http://semver.org/) (также известное как SemVer) уже стало популярным подходом к работе с версиями программ и библиотек. Оно не только облегчает работу с последовательными релизами, но позволяет и людям, и автоматике понимать совместимость этих релизов друг с другом и с остальным миром. SemVer можно использовать много где, но больше всего этот подход известен в системах управления зависимостями.
Прежде чем рассказывать о специфичных для Go вещах, давайте посмотрим, что такое семантическое версионирование (примечание переводчика: ради этой части и был затеян перевод).
На иллюстрации показаны семантические части строки версии. Чаще всего вы будете видеть только первые три цифры, разделенные точками **"."**. Полностью же семантическая версия может состоять из следующих частей:
* “Major” номер версии. Увеличивается (и не всегда на 1, вспомните PHP 5 -> 7), когда API библиотеки или приложения меняется обратно несовместимым образом.
* “Minor” номер версии. Увеличивается, когда в API добавляются новые функции без нарушения обратной совместимости (примечание переводчика: вот здесь самое зло. К примеру, npm по умолчанию сохраняет версию с префиксом “^”, что означает “любая версия с такой же major”. Авторы npm резонно полагают, что если при смене minor обратная совместимость не теряется, то можно смело обновлять. Сюрприз: множество разработчиков библиотек просто не знают, что такое семантическое версионирование и ломают обратную совместимость, как получится. Результат – на компьютере автора все работает, а при установке “с чистого листа” на другом компьютере мы получаем новые версии зависимостей с поломанной обратной совместимостью). При увеличении номера “major” принято сбрасывать “minor” в 0, то есть за версией 4.27… последует версия 5.0… а не 5.28
* “Patch” номер версии. Увеличивается при исправлении багов, рефакторинге и прочих изменениях, которые ничего не ломают, но и новых фичей не добавляют. При увеличении “Major” или “Minor” принято сбрасывать “Patch” в 0 (примечание переводчика: очень часто его называют “build number” и просто увеличивают на единицу с каждый билдом continuous integration, никогда не сбрасывая. Это позволяет легко отличать билды друг от друга во время тестирования и анализа сообщений ошибок от пользователей. Минус такого подхода в том, что довольно скоро цифра становится пятизначной. Но многих это не беспокоит).
* Строка “pre-release”: необязательный, разделенный точками список, отделенный от трех номеров версии знаком минус. Например: **“1.2.3-beta.2”**. Используется вместо тегов, чтобы “помечать” определенные вехи в разработке. Обычно это “alpha”, “beta”, “release candidate” (“rc”) и производные от них.
* Завершает строку семантической версии метаданные системы сборки. Так же, как и список “pre-release” тегов, он разделен точками **.**, но отделяет от номеров или тегов его не минус, а плюс. Данную информацию принято игнорировать (примечание переводчика: по феншую номер билда должен идти сюда – но мало кто так делает, очень длинные строки получаются).
Несмотря на то, что в спецификации ничего не говорится о префиксе **“v”**, он часто используется перед строкой семантической версии, например, **“v.12.3”**. Так же, как и метаданные, его принято игнорировать.
Все это и многое другое можно найти в официальной спецификации:<http://semver.org/>
Благодаря продуманной спецификации, строки семантических версий можно легко распарсить, сортировать, и, главное, сравнивать друг с другом и с диапазонами «допустимых» версий. Чем, собственно, и занимаются большинство менеджеров зависимостей, таких как npm.
### **Парсинг семантических версий в Go**
Для Go доступно несколько пакетов для работы с семантическими версиями. В этой статье я рассмотрю вот этот: **github.com/Masterminds/semver**. Он соответствует спецификации, поддерживает необязательный префикс **“v”**, сортировку, работу с диапазонами и ограничениями. При этом с ограничениями этот пакет работает так же, как большинство решений для других языков программирования, таких как JavaScript, Rust и другие.
Пример ниже парсит строку семантической версии и выводит либо “major” версию, либо сообщение об ошибке:
```
v, err := semver.NewVersion("1.2.3-beta.1+build345")
if err != nil {
fmt.Println(err)
} else {
fmt.Println(v.Major())
}
```
Возвращаемое значение является экземпляром **semver.Version**, который содержит некоторое количество полезных методов. Если переданная строка не является семантической версией, то возвращается ошибка **semver.ErrInvalidSemVer**.
Но реальная польза этой библиотеки заключается не в возможности парсить строки, а в возможности проводить сложные действия над семантическими действиями.
### **Сортировка семантических версий**
С помощью библиотеки semver вы можете сортировать семантические версии средствами стандартной библиотеки. Например:
```
raw := []string{"1.2.3", "1.0", "1.0.0-alpha.1" "1.3", "2", "0.4.2",}
vs := make([]*semver.Version, len(raw))
for i, r := range raw {
v, err := semver.NewVersion(r)
if err != nil {
t.Errorf("Error parsing version: %s", err)
}
vs[i] = v
}
sort.Sort(semver.Collection(vs))
```
В этом примере набор семантических версий преобразуется в экземпляры **semver.Version**, которые затем складываются в **semver.Collection**. А у **semver.Collection** есть все необходимое для использования со стандартной библиотекой **sort**. Это очень удобно для правильной сортировки pre-release информации и игнорирования мета-тегов.
### **Диапазоны, Ограничения и Wildcards**
Один из самых популярных вопросов относительно версий заключается в проверке, лежит ли версия в указанном диапазоне. Или удовлетворяет ли она каким-то другим ограничениям. Все эти проверки легко сделать с помощью библиотеки:
```
c, err := semver.NewConstraint(">= 1.2.3, < 2.0.0, != 1.4.5")
if err != nil {
fmt.Println("Error parsing constraint:", err)
return
}
v, err := semver.NewVersion("1.3")
if err != nil {
fmt.Println("Error parsing version:", err)
return
}
a := c.Check(v)
fmt.Println("Version within constraint:", a)
```
Для тех, кто знаком с диапазонами версий по другим языкам и тулзам, библиотека предлагает хорошо знакомую нотацию:
* **^1.2.3** обозначает совместимость на уровне “major” версии. Это синтаксический сахар для записи **“>= 1.2.3, < 2.0.0”**. Используется для указания “самой свежей версии зависимости, все еще совместимой по API”.
* **~1.2.3** обозначает совместимость на уровне “patch” версии. Это синтаксический сахар для **“>= 1.2.3, < 1.3.0”**. Используется для указания нужной версии с последними багфиксами, но без серьезных изменений.
* **“1.2.3 — 3.4.5”** обозначает точный диапазон версий, включая начальную и конечную. Это синтаксический сахар для **“>= 1.2.3, <= 3.4.5”**.
* Также библиотека поддерживает “wildcards” с помощью символов **“x”**, **”X”** или **“\*”**. Вы можете указать версию как **“2.x”**, **“1.2.x”** или даже как **“\*”**. И все эти нотации можно спокойно комбинировать друг с другом.
### **Начните использовать семантические версии прямо сейчас**
~~И ваши волосы станут мягкими и шелковистыми!~~ Если в вашем проекте есть работа с версиями, то предлагаю не терять время и начать пользоваться стандартом семантического версионирования. Для Go есть описанная выше библиотека **github.com/Masterminds/semver**, большинству современных языков и тулчейнов тоже есть, что предложить. Особенно Node.js с npm. | https://habr.com/ru/post/281593/ | null | ru | null |
# Создание подключений VPN на шлюзах Zyxel
VPN шлюзы Zyxel Zywall серий VPN, ATP и USG обладают обширными возможностями создания защищенных виртуальных сетей (VPN) для подключения как конечных пользователей (узел-сеть), так и создания подключения между шлюзами (сеть-сеть). В этой статье мы пройдем по всем моментам создания и настройки VPN подключения удаленных сотрудников.
Выбор подходящего VPN
---------------------
Шлюзы позволяют создать три сценария подключения:
* L2TP over IPSec VPN
* SSL VPN
* IPSec VPN
В зависимости от требований к безопасности и поддержки протоколов на конечных устройствах [выбирается требуемый](https://support.zyxel.eu/hc/ru/articles/360012528960-VPN-Guideline-%D0%92%D1%8B%D0%B1%D0%BE%D1%80-%D0%BF%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D1%8C%D0%BD%D0%BE%D0%B3%D0%BE-%D1%82%D0%B8%D0%BF%D0%B0-VPN-%D0%B4%D0%BB%D1%8F-%D0%B2%D0%B0%D1%88%D0%B5%D0%B3%D0%BE-%D0%B4%D0%BE%D0%BC%D0%B0%D1%88%D0%BD%D0%B5%D0%B3%D0%BE-%D0%BE%D1%84%D0%B8%D1%81%D0%B0-%D0%BF%D0%BE%D0%BB%D0%B5%D0%B7%D0%BD%D1%8B%D0%B5-%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8-%D0%B8-%D1%83%D1%87%D0%B5%D0%B1%D0%BD%D1%8B%D0%B5-%D0%BF%D0%BE%D1%81%D0%BE%D0%B1%D0%B8%D1%8F).
Рассмотрим настройку каждого из них.
Предварительная настройка
-------------------------
Даже при столь обильном функционале шлюзов, создание подключений не составит труда для не сильно подготовленного человека, главное иметь в виду некоторые нюансы:
Для корректной работы L2TP VPN по средствам встроенного клиента на Windows требуется проверить включение службы «IKEEXT» (Модули ключей IPsec для обмена ключами в Интернете и протокола IP с проверкой подлинности)
Остальные советы из интернета о правке реестра стоит воспринимать с осторожностью, так как они могут только навредить.
В связи с таможенными ограничениями по отношению ввоза сетевого оборудования на территорию РФ, реализующее шифровально-криптографические функции, на шлюзах Zyxel «из коробки» доступно только шифрование DES.
На актуальной прошивке версии 4.35 есть возможность работы с CLI прямо из Web интерфейса и не требует отдельного подключения к шлюзу через консольный кабель, что сильно упрощает работу с командной строкой.
Для активации остальных режимов (3DES) — нужно через консоль ввести команды:
```
Router> configure terminal
Router(config)# crypto algorithm-hide disable
Router(config)# write
Router(config)# reboot
```
После ввода команды reboot шлюз перезапустится и позволит выбрать нужные режимы шифрования.
С нюансами разобрались, приступим непосредственно к настройке соединений.
Все примеры будут описаны с применением шлюза VPN50, VPN2S, ПК под управлением Windows, Android смартфона и иногда iPhone смартфона.
VPN50 выступает в роли «головного шлюза» находящегося в офисе/серверной.
Настройка L2TP подключения
--------------------------
### Настройка L2TP на VPN50
Проще всего настроить VPN через Wizard. Он сразу создаст все правила и подключение.
После ввода логина\пароля открывается Easy mode (упрощенный режим управления)
Настоятельно рекомендуем использовать его только в информационном режиме, так как создаваемые через Easy Wizard режимы VPN потом нельзя корректировать в Expert Mode.
Нажимаем верхнюю правую кнопку “Expert Mode” и попадаем в полноценный Web интерфейс управления
Слева сверху иконка «волшебная палочка» — быстрая настройка:
Если настройки интернета отличаются от DHCP, первоначально требуется настроить WAN interface. Для настройки VPN выбираем правую иконку
Для настройки L2TP выбрать последний пункт «VPN Setting for L2TP».
Здесь нам предлагают ввести имя подключения, интерфейс, через который будет проходить трафик (стоит иметь в виду: если подключение к интернету происходит через PPPOE подключение, то и здесь соответственно нужно выбрать wan\_ppp) и предварительный ключ.
На следующей странице вводим диапазон IP адресов, которые будут присваиваться клиентам.
Диапазон не должен пересекаться с другими интерфейсами на шлюзе!
DNS сервер можно не прописывать, если не требуется пускать весь трафик (клиентский интернет) через VPN, что выбирается галочкой ниже.
На этой странице выводится информация о созданном подключении, проверяется правильность всех данных и сохраняется.
Всё! Подключение создано. Осталось создать пользователей для подключения к шлюзу.
На вкладке Configuration -> Object -> User/Group создаются пользователи (требуется ввести имя и пароль.)
На соседней вкладке для удобства можно создать группу и внести в нее список пользователей. Если удаленных пользователей более одного, то группу в любом случае придется создавать.
На вкладке VPN-L2TP VPN в пункте Allowed user выбираем созданную ранее группу или единичного пользователя, которые смогут подключаться по L2TP.
На этом создание подключения по L2TP на шлюзе можно считать настроенным.
Перейдем к настройке клиентов.
### Настройка клиентов L2TPНастройка L2TP на клиентах Windows
На Windows 10 настройка L2TP производится штатными средствами:
```
Пуск -> Параметры -> Сеть и Интернет -> VPN -> Добавить VPN-подключение
```
* Поставщик услуг – Windows (встроенные)
* Имя подключения – на выбор
* Имя или адрес сервера- IP адрес VPN шлюза
* Тип VPN- L2TP с предварительным ключом
* Общий ключ- ток ключ, что создавался на первом пункте Wizard'а
* Логин и пароль пользователя из группы разрешенных
Для подключения этого достаточно. Но иногда требуется немного подправить подключение, либо Подключение создается на более ранних версиях Windows:
```
Панель управления -> Центр управления сетями и общим доступом -> Изменение параметров адаптера -> свойства L2TP подключения
```
Выставляется правильные шифрование и протоколы как на изображении.
Во вкладке Дополнительные параметры меняется предварительный ключ
Так же рекомендуется на вкладке Сеть отключить протокол IPv6
На этом подключение готово.
Настройка L2TP на клиентах Android
Иногда требуется подключать и мобильных сотрудников к корпоративной сети.
На Android смартфонах это делается в меню:
```
Настройки -> Беспроводные сети (Дополнительно) -> VPN -> Создать новое подключение (в зависимости от производителя телефона и оболочки ОС пункты могут называться по-разному)
```
Здесь вводится имя подключения, выбирается тип VPN L2TP/IPSec PSK, вводится общий ключ, имя пользователя и пароль.
После подключения должен появиться значок «Ключ», который информирует о VPN соединении.
Настройка L2TP на клиентах Iphone
Настройка Iphone практически не отличается от клиентов android
По пути
```
Настройки -> Основные -> VPN
```
создается новое подключение, где прописывается Описание (название подключения), Сервер (ip адрес шлюза), имя пользователя с паролем и общий ключ. Готово.
После создания и подключения VPN в верхнем правом углу будет отображаться иконка «VPN», как индикатор поднятого соединения.
Тапнув по конфигурации так же можно увидеть информацию о соединении.
Настройка L2TP на аппаратном клиенте VPN2S
А теперь покажем, как подключить к корпоративной сети удаленного клиента, у которого дома установлен недорогой шлюз Zyxel VPN2S.
Для подключения VPN2S клиентом L2TP настройка так же не составит труда. Тут даже не требуется «Wizard», все правила изначально созданы.
Первым делом в Configuration -> VPN -> IPsec VPN нужно включить стандартные конфигурации.
В Gateway конфигурации ввести Peer Gateway Address (IP адрес шлюза) и ключ.
На вкладке L2TP VPN поставить галочку Enable, на против IPsec (имя дефолтной конфигурации) Enforce, ввести имя и пароль пользователя и, если требуется, включить NAT.
После этого перейти обратно на вкладку IPsec VPN и убедиться, что в Connection Tunnel горит «зеленый глобус», сигнализирующий о поднятом соединении.
Настройка SSL подключения
Настойка SSL на шлюзе VPN50
Для настройки SSL VPN (которых к слову без лицензии меньше, чем L2TP, но имеющие более защищенное подключение) потребуется:
На вкладке VPN -> SSL VPN создается новое правило, в котором указывается имя, список пользователей\групп, пул выдаваемых IP адресов и список сетей, в который будет доступ клиентам.
***Важное замечание! Для работы SSL VPN протокол HTTPS должен быть добавлен в конфигурацию протоколов***
Делается это по пути Object -> Service -> Service Group.
В группе “Default\_Allow\_Wan\_To\_ZyXall” добавить HTTPS. Он так же потребуется и для доступа на Web интерфейс шлюза извне.
Настройка клиентов SSL
Настройка SSL на клиентах Windows
Для подключения клиента Windows используется программа [ZyWALL SecuExtender 4.0.3.0](ftp://ftp.zyxel.com/SecuExtender/software/SecuExtender_SecuExtender_Windows%204.0.3.0.zip).
Настройка заключается лишь в введении IP адреса шлюза и логина\пароля пользователя.
Так же можно поставить галочку «запомнить пользователя», чтобы не вводить каждый раз.
В процессе подключения согласиться со всплывающим предупреждением
После подключения во вкладке Status будет показана информация о соединении.
Настройка VPN IPsec подключения
Настройка VPN IPsec на VPN50
Перейдем к настройке самого безопасного VPN IPsec.
На вкладке VPN -> IPsec VPN -> VPN Gateway создается новое правило
Где указывается имя, версия IPsec, ключ, режим согласования и варианты шифрования.
В соседней вкладке VPN Connection создается новое подключение, настройки по аналогии с созданием L2TP.
Настройка VPN IPsec на клиентах
Настройка VPN IPsec на клиентах Windows
Программа для подключения IPSec VPN на Windows располагается по [ссылке](ftp://ftp.zyxel.com/ZyWALL_IPSec_VPN_Client/software/ZyWALL%20IPSec%20VPN%20Client_SecuExtender%20IPSecVPN_Windows%203.8.204.61.32.zip).
Подключение создается через «мастер создания туннеля IKE V1» (так как на шлюзе был выбран именно он).
На этой вкладке вводится IP адрес шлюза, ключ и подсеть шлюза- далее- готово.
В первой фазе проверяется соответствие параметров шифрования.
Так же и во второй фазе
Если всё сделано правильно, то подключение поднимется, о чем будет сигнализировать зеленый индикатор.
Настройка VPN IPsec на VPN50 с предоставлением конфигурации
Шлюз позволяет упростить настройку у пользователей посредством запроса конфигурации прямо со шлюза. Для этого на вкладке VPN -> IPSec VPN -> Configuration Provisioning
включается функция предоставления конфигурации
Добавляется новая конфигурация, где выбирается созданное VPN подключение и группа пользователей. Активировать и сохранить.
После этого в ZyWALL IPSec VPN Client будет доступна возможность загрузки конфигурации прямо со шлюза.
В меню Конфигурация выбрать пункт «Получить с сервера»
Где нужно ввести только IP адрес шлюза, логин и пароль пользователя.
После успешного соединения будут получены все нужные настройки и создано новое подключение.
Заключение
Были рассмотрены самые популярные варианты подключения VPN с различными клиентскими устройствами. Но самих вариантов еще очень много.
Благодаря обширному функционалу шлюзов Zyxel, есть возможность расширить рабочую сеть далеко за пределами офиса с минимальными затратами на настройку и поддержку.
Больше информации вы можете найти на [странице](https://www.zyxel.com/ru/ru/ci_general_20200319_623235.shtml) технической поддержки Zyxel
Обсудить статью и получить поддержку вы можете в нашем [телеграм-чате](https://t.me/zyxelru). | https://habr.com/ru/post/503094/ | null | ru | null |
# Сервер WhatsApp обслуживает более миллиона TCP-соединений
Разработчики популярной программы WhatsApp Messenger [сообщили в блоге](http://blog.whatsapp.com/index.php/2011/09/one-million/), что провели оптимизацию серверного бэкенда для улучшения производительности, аптайма и масштабируемости. В результате им удалось добиться, что один сервер обслуживает более миллиона tcp-сессий.
`$ netstat -an | grep -c EST
1016313`
Бэкенд WhatsApp работает на FreeBSD + Erlang. Они [не первые](http://www.metabrew.com/article/a-million-user-comet-application-with-mochiweb-part-3), кто добился миллиона одновременных tcp-сессий на одном сервере. | https://habr.com/ru/post/129035/ | null | ru | null |
# The Modal — правильные модальные окна
Очень часто модальные окна и диалоги делаются при помощи плагинов jQuery. Например, [SimpleModal](http://www.ericmmartin.com/projects/simplemodal/) или [jqModal](http://dev.iceburg.net/jquery/jqModal/). К сожалению, все они, в варианте по умолчанию, работают неправильно.
Что же такое «правильно»?
Модальное окно по определению блокирует работу пользователя с родительским окном до тех пор, пока пользователь его не закроет. То есть:
1. Пользователю нельзя позволять прокручивать страницу под ним.
2. При этом, если содержимого в модальном окне очень много, нужно позволить прокручивать содержимое.
По этому принципу работает просмотр фото в Facebook и Вконтакте и, я считаю, что для модальных окон это правильный вариант.
Чтобы не мучать вас заранее деталями реализации, покажу сначала демо [плагина jQuery](https://github.com/samdark/the-modal): <http://rmcreative.ru/playground/modals_plugin/demo.html>.
Ну а теперь немного про реализацию.
Идея достаточно проста. В открытом состоянии разметка получается примерно вот такая:
```
...
...
Hi, I'm the modal demo.
=======================
...
...
```
К ней применяется CSS:
```
/* Данный класс навешивается на контейнер при открытии модального окна. Для нормальных браузеров это body, для стырах IE — html */
.lock {
/* убираем скроллбары с основнового содержимого страницы */
overflow: hidden;
}
/* ширма (полупрозрачное затенение под модальным окном) */
.shim {
/* фиксируем, растягиваем на весь доступный экран */
position: fixed;
bottom: 0; left: 0; top: 0; right: 0;
/* если в модальном окне много содержимого, показываем скроллбар */
overflow: auto;
/* однопальцевый скролл для iPad*/
-webkit-overflow-scrolling: touch;
}
/* фикс для странностей в iPad */
.shim > * {
-webkit-transform: translateZ(0px);
}
/* декоративная часть ширмы: делаем полупрозрачной и чёрной */
.shim {
background: rgba(0,0,0,0.5);
filter: progid:DXImageTransform.Microsoft.gradient(startColorstr=#7F000000,endColorstr=#7F000000); /* IE6–IE8 */
zoom: 1;
}
```
Вот и всё. Остаётся завернуть в удобный для использования плагин jQuery и добавить плюшки вроде закрытия по ESC. У меня получился плагин вот с таким API:
```
$.modal().open({
onOpen: function(el, options){
$.get('http://example.com/', function(data){
el.html(data);
});
}
});
```
[Забрать его можно на github](https://github.com/samdark/the-modal).
На данный момент имеется некоторое количество нехорошестей, которые, надеюсь, поможет исправить сообщество:
* Скролл клавиатурой в FF скроллит страницу вместо модального окна.
* На iPad скролл работает не очень стабильно (иногда скроллит страницу).
* Скролл нажатием средней кнопки мыши работает неверно.
* Открытие модального окна сдвигает страницу в том случае, если появляется или убирается скролл.
Конструктивная критика и советы очень приветствуются. | https://habr.com/ru/post/148515/ | null | ru | null |
# DaData.ru превращает гуиды в адреса и знает всех пацанов на раёне
*[DaData.ru](https://dadata.ru/?utm_source=habr&utm_medium=post&utm_campaign=267997) — сервис автоматической проверки и исправления контактных данных (ФИО, адресов, телефонов, email, паспортов). Плюс javascript-виджет и API подсказок при вводе адреса, ФИО, организации и банковских реквизитов.*
[В предыдущем выпуске](//habrahabr.ru/company/hflabs/blog/258367/) Дадата прошлась по паспортам и банкам, а за лето взялась помочь интернет-магазинам с доставкой:
* определять район города;
* писать районы и города по правилам Почты России;
* откладывать в сторонку абонентские ящики и адреса «до востребования»;
* находить адрес до улицы по коду ФИАС.
Район города по адресу
----------------------
Человек пишет адрес, а Дадата определяет район города. Полезно для интернет-магазинов — посчитать стоимость доставки в зависимости от района или сегментировать базу клиентов по районам.
Работает для Москвы, Санкт-Петербурга и городов с населением больше 500 тысяч. [В подсказках](https://dadata.ru/suggestions/?utm_source=habr&utm_medium=post&utm_campaign=267997#demo), [файлах](https://dadata.ru/?utm_source=habr&utm_medium=post&utm_campaign=267997#process-file) и [через API стандартизации](https://dadata.ru/api/clean/?utm_source=habr&utm_medium=post&utm_campaign=267997).
Адрес по правилам Почты России
------------------------------
По правилам Почты, если город — центр региона, то название региона в адресе на конверте не пишется (*~~Новосибирская обл~~, г Новосибирск, ул Абаканская, д 21*). А если город — центр района, то не пишется название района (*Московская обл, ~~Одинцовский р-н~~, г Одинцово, ул Ракетчиков*).
Дадата умеет формировать адрес одной строкой по этим правилам [в подсказках](https://dadata.ru/suggestions/?utm_source=habr&utm_medium=post&utm_campaign=267997#demo), [файлах](https://dadata.ru/?utm_source=habr&utm_medium=post&utm_campaign=267997#process-file) и [через API стандартизации](https://dadata.ru/api/clean/?utm_source=habr&utm_medium=post&utm_campaign=267997).
Абонентские ящики и адреса до востребования
-------------------------------------------
Если в письме указан адрес до почтового отделения («до востребования» или номер абонентского ящика), то адресат его получит. Но доставку товара по такому адресу делать бессмысленно.
Дадата отличает эти адреса от всех остальных и отмечает биркой «До почтового отделения»:
Поиск адреса по коду ФИАС
-------------------------
Адрес в России состоит из десятка-другого полей. Хранить его в базе отдельными полями неудобно: многие CMS и движки интернет-магазинов не содержат нужных полей.
Хранить адрес одной строкой проще. Но тогда не получится сегментировать клиентскую базу по городам, определить геокоординаты, напечатать адрес на конверте как положено (отдельно город, отдельно улица-дом-квартира).
Привычное для разработчика решение — хранить уникальный идентификатор адреса вместо простыни отдельных полей. Такой идентификатор есть, его назначает налоговая служба в Федеральной информационной адресной системе (ФИАС). Выглядит идентификатор ФИАС увесисто: `5f96fd6b-b3de-451f-b280-8fedf859e683`.
Хранить уникальный идентификатор удобно. Но покупателю и Почте России его не покажешь. Поэтому совсем хорошо хранить в базе идентификатор ФИАС улицы и превращать его в полноценный адрес по запросу. Дом, корпус-строение и квартиру лучше хранить отдельными полями, потому что ~~не все квартиранты платят налоги~~ в базе налоговой нет квартир и многих домов.
Ровно это и делает API Дадаты: возвращает адрес [по коду ФИАС](https://dadata.ru/api/find-by-id/?utm_source=habr&utm_medium=post&utm_campaign=267997). Ищет до улицы включительно:
Бесплатно до 10 тысяч запросов в день.
Надеемся, что вам будет полезно что-то из перечисленного. Подключайтесь, пробуйте, задавайте вопросы в комментариях или [на форуме](//dadata.userecho.com/)! | https://habr.com/ru/post/267997/ | null | ru | null |
# Работа с GeoJSON в среде Node.js: практическое знакомство
[GeoJSON](https://tools.ietf.org/html/rfc7946) — это стандартизованный формат представления географических структур данных, основанный на JSON. Существует множество замечательных [инструментов](http://geojson.io/) для визуализации GeoJSON-данных. При этом данный формат хорош не только в деле хранения координат неких точек. Он, помимо точек, позволяет описывать и другие объекты: линии, полигоны, коллекции объектов.
[](https://habr.com/ru/company/ruvds/blog/489828/)
Точки — объекты Point
---------------------
[GeoJSON-точка](https://docs.mongodb.com/manual/reference/geojson/#point) выглядит так:
```
{
"type": "Point",
"coordinates": [-80.1347334, 25.7663562]
}
```
Эта точка представляет [парк](https://www.miamiandbeaches.com/thing-to-do/parks-recreation/south-pointe-park/2966) в Майами-Бич, штат Флорида, США. Визуализировать эту точку на карте легко можно с помощью проекта [geojson.io](http://geojson.io/).
*Точка на карте*
Важно отметить, что координата в свойстве `coordinates` записывается в формате `[lng, lat]`. [Долгота](https://ru.wikipedia.org/wiki/%D0%94%D0%BE%D0%BB%D0%B3%D0%BE%D1%82%D0%B0) в GeoJSON идёт перед [широтой](https://ru.wikipedia.org/wiki/%D0%A8%D0%B8%D1%80%D0%BE%D1%82%D0%B0). Это так из-за того, что долгота представляет направление «восток-запад» (ось `x` на типичной карте), а широта — направление «север-юг» (ось `y` на типичной карте). Авторы GeoJSON стремились к [сохранению](https://tools.ietf.org/html/rfc7946#appendix-A.1) порядка координат `x, y`.
Типичный пример использования точек GeoJSON — [геокодирование](https://geocode.xyz/api) — преобразование адресов наподобие «429 Lenox Ave, Miami Beach, FL» в координаты, выраженные долготой и широтой. Например, мы пользуемся [API](https://docs.mapbox.com/api/search/) геокодирования Mapbox. Для обращения к этому API нужно выполнить HTTP-запрос к следующей конечной точке:
```
https://api.mapbox.com/geocoding/v5/mapbox.places/429%20lenox%20ave%20miami.json?access_token=pk.eyJ1IjoibWF0dGZpY2tlIiwiYSI6ImNqNnM2YmFoNzAwcTMzM214NTB1NHdwbnoifQ.Or19S7KmYPHW8YjRz82v6g&cachebuster=1581993735895&autocomplete=true
```
В ответ придёт такой код:
```
{"type":"FeatureCollection","query":["429","lenox","ave","miami"],"features":[{"id":"address.8052276751051244","type":"Feature","place_type":["address"],"relevance":1,"properties":{"accuracy":"rooftop"},"text":"Lenox Avenue","place_name":"429 Lenox Avenue, Miami Beach, Florida 33139, United States","center":[-80.139145,25.77409],"geometry":{"type":"Point","coordinates":[-80.139145,25.77409]}, ...}
```
Если присмотреться к ответу, то окажется, что `features[0].geometry` в JSON-коде — это GeoJSON-точка:
```
{"type":"Point","coordinates":[-80.139145,25.77409]}
```
*Визуализация координат*
[API](https://docs.mapbox.com/api/maps/#static-images) статических карт Mapbox — это отличный инструмент для вывода точек на картах. Ниже показан скрипт, который декодирует переданную ему строку и возвращает URL на изображение, которое показывает первый результат поиска.
```
const axios = require('axios');
async function search(str) {
const geocoderUrl = 'https://api.mapbox.com/geocoding/v5/mapbox.places/' +
encodeURIComponent(str) +
'.json?access_token=' +
'pk.eyJ1IjoibWF0dGZpY2tlIiwiYSI6ImNqNnM2YmFoNzAwcTMzM214NTB1NHdwbnoifQ.Or19S7KmYPHW8YjRz82v6g';
const res = await axios.get(geocoderUrl).then(res => res.data);
const point = res.features[0].geometry;
return 'https://api.mapbox.com/styles/v1/mapbox/streets-v11/static/' +
'pin-l-1+333(' + point.coordinates[0] + ',' + point.coordinates[1] + ')/' +
point.coordinates[0] + ',' + point.coordinates[1] +
',14.25,0,0/600x600/' +
'?access_token=pk.eyJ1IjoibWF0dGZpY2tlIiwiYSI6ImNqNnM2YmFoNzAwcTMzM214NTB1NHdwbnoifQ.Or19S7KmYPHW8YjRz82v6g';
}
search('429 Lenox Ave, Miami Beach').then(res => console.log(res));
```
*Пример визуализации точки на карте*
Линии — объекты LineString
--------------------------
В GeoJSON линии, объекты `LineString`, представляют массивы координат, описывающие линию на карте. Ниже показан GeoJSON-объект `LineString`, представляющий приблизительную границу между штатами Калифорния и Орегон в США:
```
{
"type": "LineString",
"coordinates": [[-124.2, 42], [-120, 42]]
}
```
*Визуализация объекта LineString на карте*
Линии, при использовании API навигации наподобие [Mapbox](https://docs.mapbox.com/api/navigation/), применяются для визуализации поэтапного пути между двумя точками. Один из способов представления автомобильного пути из точки `[-80.139145,25.77409]` (офис WeWork в Майами-Бич) до точки `[-80.2752743,25.7938434]` (международный аэропорт Майами) заключается в использовании GeoJSON-объекта `LineString`:
```
{
"type": "LineString",
"coordinates": [
[-80.139153, 25.774281],
[-80.13829, 25.774307],
[-80.142029, 25.774479],
[-80.148438, 25.772148],
[-80.151237, 25.772232],
[-80.172043, 25.78116],
[-80.177322, 25.787195],
[-80.185326, 25.787212],
[-80.189804, 25.785891],
[-80.19268, 25.785954],
[-80.202301, 25.789175],
[-80.207954, 25.788721],
[-80.223, 25.782646],
[-80.231026, 25.78261],
[-80.238007, 25.784889],
[-80.246025, 25.784403],
[-80.249611, 25.785175],
[-80.253166, 25.786049],
[-80.259262, 25.786324],
[-80.264038, 25.786186],
[-80.264221, 25.787256],
[-80.264214, 25.791618],
[-80.264221, 25.792633],
[-80.264069, 25.795443],
[-80.263397, 25.795652],
[-80.263786, 25.794928],
[-80.267723, 25.794926],
[-80.271141, 25.794859],
[-80.273163, 25.795704],
[-80.275009, 25.796482],
[-80.277481, 25.796461],
[-80.278435, 25.795622],
[-80.278061, 25.794088],
[-80.275276, 25.793804]
]
}
```
Объекты `LineString`, представляющие собой некие маршруты, могут быть очень сложными. Вышеприведённый объект, например, описывает короткую 15-минутную поездку. Вот как всё это выглядит на карте.
*Путь из одной точки в другую*
Вот — простой скрипт, который возвращает `LineString`-представление пути между 2 точками с использованием API `directions` Mapbox.
```
const axios = require('axios');
async function directions(fromPt, toPt) {
const fromCoords = fromPt.coordinates.join(',');
const toCoords = toPt.coordinates.join(',');
const directionsUrl = 'https://api.mapbox.com/directions/v5/mapbox/driving/' +
fromCoords + ';' + toCoords + '?' +
'geometries=geojson&' +
'access_token=pk.eyJ1IjoibWF0dGZpY2tlIiwiYSI6ImNqNnM2YmFoNzAwcTMzM214NTB1NHdwbnoifQ.Or19S7KmYPHW8YjRz82v6g';
const res = await axios.get(directionsUrl).then(res => res.data);
return res.routes[0].geometry;
}
const wework = { type: 'Point', coordinates: [-80.139145,25.77409] };
const airport = { type: 'Point', coordinates: [-80.2752743,25.7938434] };
directions(wework, airport).then(res => {
console.log(res);
});
```
Полигоны — объекты Polygon
--------------------------
GeoJSON-полигоны, объекты `Polygon`, используются для описания замкнутых областей на картах. Это могут быть области, имеющие форму треугольника, квадрата, [двенадцатиугольника](https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%B5%D0%BD%D0%B0%D0%B4%D1%86%D0%B0%D1%82%D0%B8%D1%83%D0%B3%D0%BE%D0%BB%D1%8C%D0%BD%D0%B8%D0%BA), или любой другой фигуры с фиксированным количеством сторон. Например, следующий GeoJSON-объект грубо описывает границы штата Колорадо в США:
```
{
"type": "Polygon",
"coordinates": [[
[-109, 41],
[-102, 41],
[-102, 37],
[-109, 37],
[-109, 41]
]]
}
```
*Визуализация полигона на карте*
GeoJSON-полигоны могут использоваться для описания очень сложных форм. Например, некоторое время в Uber использовался единственный GeoJSON-полигон, включающий в себя все 3 основных аэропорта области залива Сан-Франциско.
*Сложный GeoJSON-полигон*
Правда, надо отметить, GeoJSON-полигоны не могут представлять окружности и эллипсы.
Для чего используются полигоны? Обычно — для описания [геозон](https://ru.wikipedia.org/wiki/%D0%93%D0%B5%D0%BE%D0%B7%D0%BE%D0%BD%D1%8B). Например, представьте себе, что работаете в Uber или в Lyft. Вам нужно показать пользователям, заказывающим поездки из аэропорта, особый экран. Для того чтобы это сделать, нужно будет узнать, находится ли точка, из которой заказывают поездку, в пределах полигона, описывающего аэропорт (или несколько аэропортов как на предыдущем рисунке).
Один из способов проверки нахождения GeoJSON-точки в пределах полигона заключается в [использовании](http://thecodebarbarian.com/wrangling-geojson-with-turf.html#which-points-are-within-a-polygon) npm-модуля Turf. [Модуль](https://www.npmjs.com/package/@turf/boolean-point-in-polygon) `@turf/boolean-point-in-polygon` позволяет узнать о том, находится ли точка в пределах полигона.
```
const pointInPolygon = require('@turf/boolean-point-in-polygon').default;
const colorado = {
"type": "Polygon",
"coordinates": [[
[-109, 41],
[-102, 41],
[-102, 37],
[-109, 37],
[-109, 41]
]]
};
const denver = {
"type": "Point",
"coordinates": [-104.9951943, 39.7645187]
};
const sanFrancisco = {
"type": "Point",
"coordinates": [-122.4726194, 37.7577627]
};
// true
console.log(pointInPolygon(denver, colorado));
// false
console.log(pointInPolygon(sanFrancisco, colorado));
```
Пакет Turf позволяет узнать о том, находится ли точка в пределах полигона, пользуясь средой Node.js. Но что если нас интересует получение таких же сведений путём выполнения запросов к базе данных? В таком случае стоит знать о том, что встроенный [оператор](http://thecodebarbarian.com/80-20-guide-to-mongodb-geospatial-queries#which-documents-are-in-a-given-polygon) MongoDB `$geoIntersects` поддерживает GeoJSON. Поэтому, например, можно написать запрос, который позволяет выяснить, какому штату США соответствует некая точка на карте:
```
const mongoose = require('mongoose');
run().catch(err => console.log(err));
async function run() {
await mongoose.connect('mongodb://localhost:27017/geotest', {
useNewUrlParser: true,
useUnifiedTopology: true
});
await mongoose.connection.dropDatabase();
const State = mongoose.model('State', mongoose.Schema({
name: String,
location: mongoose.Schema({
type: String,
coordinates: [[[Number]]]
})
}));
const colorado = await State.create({
name: 'Colorado',
location: {
"type": "Polygon",
"coordinates": [[
[-109, 41],
[-102, 41],
[-102, 37],
[-109, 37],
[-109, 41]
]]
}
});
const denver = {
"type": "Point",
"coordinates": [-104.9951943, 39.7645187]
};
const sanFrancisco = {
"type": "Point",
"coordinates": [-122.4726194, 37.7577627]
};
// В каком штате находится Денвер?
let res = await State.findOne({
location: {
$geoIntersects: { $geometry: denver }
}
});
res.name; // Колорадо
// В каком штате находится Сан-Франциско?
res = await State.findOne({
location: {
$geoIntersects: { $geometry: sanFrancisco }
}
});
res; // null
}
```
Итоги
-----
GeoJSON — это не только хранение координат точек. В этом формате можно хранить пути. С использованием GeoJSON-данных можно выяснить момент попадания пользователя в геозону. А если нужно, то GeoJSON даже позволяет создавать [изохроны](https://docs.mapbox.com/help/tutorials/get-started-isochrone-api/). Вокруг формата GeoJSON сформировался набор отличных инструментов. Так, ресурс [geojson.io](http://geojson.io/) позволяет выполнять простые визуализации координат на карте. Проект [Mapbox](https://www.mapbox.com/) даёт доступ к продвинутым географическим API. Пакет [Turf](https://turfjs.org/) позволяет выполнять геопространственные вычисления в браузерах и в среде Node.js.
MongoDB поддерживает запросы, связанные с географическими данными. И если вы храните географические координаты точек в виде пар значений, не пользуясь форматом GeoJSON, это значит, что вы упускаете возможность воспользоваться некоторыми замечательными инструментами разработки.
**Уважаемые читатели!** Пользуетесь ли вы форматом GeoJSON?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/489828/ | null | ru | null |
# Flutter + Socket.io — Обмен информацией в режиме реального времени
Когда скорость имеет решающее значение, когда необходимо иметь возможность обмениваться информацией мгновенно, есть несколько способы добиться этого, отправка множества сетевых запросов на сервер не всегда решает эту задачу, так как часто нам нужно поддерживать постоянное активное соединение с сервером. Тогда и появляются **WebSocket**.
> Представьте себе трубу, по которой вода (*данные*) может течь в обе стороны.
>
>
### Преимущества WebSocket над HTTPS
WebSocket имеет множество преимуществ над привычным HTTPS, в зависимости от архитектуры вашего проекта, **WebSocket** обычно быстрее в обмене информацией.
В отличии от принципа *запрос-ответ*, как в HTTP, WebSocket предлагает обмен информации в реальном времени с двунаправленной системой передачи данных, в которой нет необходимости отправлять запросы для получения ответов.
> Благодаря такому методу мгновенной коммуникации разработчики могут предоставлять пользователям возможность получения уведомлений, оповещений, а также обмен сообщениями и использование других сервисов.
>
>
### Создание Node сервера
Нам предстоит поработать над двумя приложениями: сервером на **Node.js** и, собственно, **Flutter-приложением**. В сущности, наш сервер будет эхо-сервер, который получает данные и отправляет их всем, кто слушает (другими словами - тем, кто *подписан на получение этих данных*). Условно*, сервер* является мостом между клиентами.
В роли клиента будет выступать **Flutter** приложение, которое будет использовать WebSocket для получения информации. Чтобы установить сервер нужно:
* Создать папку с именем проекта, например `socket_chat_server`
* Создать файл `package.json` в этой папке
* Переключиться в текущую папку, если еще не сделали это
* Запустить команду `npm init` и завершить установку
Измените файл `package.json`, чтобы добавить нужные нам две зависимости:
#### package.json
```
{
"name": "socket_chat_server",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"start": "node ./index.js"
},
"author": "",
"license": "ISC",
"dependencies": {
"http": "0.0.1-security",
"socket.io": "^2.3.0"
},
"engines": {
"node": "10.x"
}
}
```
Затем установим **npm** модули с помощью команды `npm install`.
#### index.js
Последним шагом будет написание логики сервера*,* как в примере:
```
const server = require('http').createServer()
const io = require('socket.io')(server)
io.on('connection', function (client) {
console.log('client connect...', client.id);
client.on('typing', function name(data) {
console.log(data);
io.emit('typing', data)
})
client.on('message', function name(data) {
console.log(data);
io.emit('message', data)
})
client.on('location', function name(data) {
console.log(data);
io.emit('location', data);
})
client.on('connect', function () {
})
client.on('disconnect', function () {
console.log('client disconnect...', client.id)
// handleDisconnect()
})
client.on('error', function (err) {
console.log('received error from client:', client.id)
console.log(err)
})
})
var server_port = process.env.PORT || 3000;
server.listen(server_port, function (err) {
if (err) throw err
console.log('Listening on port %d', server_port);
});
```
Здесь все очень просто, запускается соединение, затем идет прослушивание данных через `client.on`, передача события для прослушивания, к примеру "сообщение", и отправка информации назад всем, кто подключен к серверу. Ваш WebSocket должен быть запущен на `http://localhost:3000`.
С помощью команды `npm start` можно протестировать сервер. Вывод должен быть таким:
### Создание приложения Flutter
**Flutter** приложение будет выступать как клиент, которые получает сообщения от сервера и отправляет их к нему. Создайте новый проект с помощью команды `flutter create socket_chat`. На [pub.dev](https://pub.dev) есть несколько **socket.io** пакетов, но, как мне кажется, [socket\_io\_client](https://pub.dev/packages/socket_io_client) будет проще для понимания, так как является копией *js* библиотеки:
#### Обратите внимание
При подключении к `localhost` на **Android** эмуляторе может потребоваться немного больше настроек. Команда `adb reverse tcp:3000 tcp:3000` разрешает подключаться к `localhost` через `http://127.0.0.1:3000` на Android (а без команды [можно](https://developer.android.com/studio/run/emulator-networking) подключится к `localhost` с Android эмулятора посредством подключения к адресу `http://10.0.2.2:3000`. прим. переводчика) *.* После удаления стандартного *приложения-счетчика* приступим к написанию `home.dart`.
#### home.dart
```
...
Socket socket;
@override
void initState() {
super.initState();
connectToServer();
}
void connectToServer() {
try {
// Configure socket transports must be sepecified
socket = io('http://127.0.0.1:3000', {
'transports': ['websocket'],
'autoConnect': false,
});
// Connect to websocket
socket.connect();
// Handle socket events
socket.on('connect', (\_) => print('connect: ${socket.id}'));
socket.on('location', handleLocationListen);
socket.on('typing', handleTyping);
socket.on('message', handleMessage);
socket.on('disconnect', (\_) => print('disconnect'));
socket.on('fromServer', (\_) => print(\_));
} catch (e) {
print(e.toString());
}
}
// Send Location to Server
sendLocation(Map data) {
socket.emit("location", data);
}
// Listen to Location updates of connected usersfrom server
handleLocationListen(Map data) async {
print(data);
}
// Send update of user's typing status
sendTyping(bool typing) {
socket.emit("typing",
{
"id": socket.id,
"typing": typing,
});
}
// Listen to update of typing status from connected users
void handleTyping(Map data) {
print(data);
}
// Send a Message to the server
sendMessage(String message) {
socket.emit("message",
{
"id": socket.id,
"message": message, // Message to be sent
"timestamp": DateTime.now().millisecondsSinceEpoch,
},
);
}
// Listen to all message events from connected users
void handleMessage(Map data) {
print(data);
}
...
```
Пример выше - простая реализация WebSocket, в которой есть функции прослушивания и отправления событий к серверу.
### Настройка CI/CD для тестирования
Возможно, во время разработки вам потребуется использование различных WebSocket для разных версий приложения(Test, Dev, или Prod). Хорошей практикой считается вынесение секретных участков кода(к примеру, *URL*-адрес хоста) в зашифрованную **CI/CD** **сборку**.
> Кроме того, использование **CI/CD** стало нормой для хороших тестируемых и масштабируемых мобильных приложений, и поэтому важно и рекомендуется всегда поддерживать наличие оного для ваших **Flutter** пактов, **Flutter** приложений и тому подобного.
>
>
Существует множество способов интеграции среды **CI/CD** в Codemagic. Я хотел бы пойти более интересным, но сложным путем и объяснить, как создать среды `dev` и `prod` с помощью простого старого `.yaml` файла и загрузить его на свой [Codemagic.io](https://codemagic.io/start/) проект в кратчайшие сроки.
Да, я знаю, что есть UI, но иногда вам нужно протестировать поток CI/CD, не прерывая существующие, или создать новый поток с графическим интерфейсом. Итак, вот быстрый, но простой способ сделать это:
#### Настройки и Среды
Мы будем создавать нашу структуру **CI/CD** и среды таким образом, чтобы мы могли использовать как динамические значения из Codemagic, так и фиксированные значения среды из наших настроек.
Структура проста, у нас есть наш ненастроенный **JSON** файл `config/appconfig.json`, в нем будут размещены наши *URL*-адреса хостов для разработки и готовой сборки. Вам также нужно будет установить его следующим образом.
```
assets:
- config/app_config.json
```
Код в `lib/config/config_loader.dart` управляет загрузкой данных из нашего **JSON** файла `(config/appconfig.json)`.
`env.dart` и `env_config.dart` управляют созданием наших различных сред для использования в`_dev.dart` и `_prod.dart` .
Для большинства **Flutter** приложений `main.dart` является входной точкой. Но для нас, чтобы наша задумка работала, нужно создать файлы `main_common.dart` , `main_dev.dart` и `main_prod.dart`. Как следует из названия, `main_common.dart` будет мостом, связывающим с предпочитаемой средой. Теперь для запуска кода нужно будет указывать настройки, с которыми мы хотим запустить приложение.
У нас есть `flutter run -t lib/main_dev.dart` для разработки и `flutter run -t lib/main_prod.dart` для готовой сборки.
#### Переменные среды
Теперь нам нужно преобразовать **JSON** конфиг в *base64*, чтобы его можно было добавить как переменные среды в `codemagic.yaml`, [здесь](https://docs.codemagic.io/getting-started/yaml/) можно найти более подробную информацию об этом.
#### Codemagic.yaml
Codemagic дает возможность записывать настройки работы приложения в легко настраиваемом `yaml` [синтаксисе](https://docs.codemagic.io/getting-started/yaml/). Мы создадим и изменим наш файл `codemagic.yaml` следующим образом:
```
# Automatically generated on 2020-11-16 UTC from https://codemagic.io/app/5fb2a25c605096f91720b983/settings
# Note that this configuration is not an exact match to UI settings. Review and adjust as necessary.
workflows:
default-workflow:
name: Default Workflow
max_build_duration: 60
environment:
vars:
APP_CONFIG: ewogICJnQXBpS2V5IjogIkFJemFTeUEzbl95bTlWUUU2NURyRUVpdDZobnNtWDgyR3FGb3Q0QSIKfQo=
flutter: stable
xcode: latest
cocoapods: default
scripts:
- |
# set up debug keystore
rm -f ~/.android/debug.keystore
keytool -genkeypair \
-alias androiddebugkey \
-keypass android \
-keystore ~/.android/debug.keystore \
-storepass android \
-dname 'CN=Android Debug,O=Android,C=US' \
-keyalg 'RSA' \
-keysize 2048 \
-validity 10000
- |
# set up local properties
echo "flutter.sdk=$HOME/programs/flutter" > "$FCI_BUILD_DIR/android/local.properties"
- cd . && flutter packages pub get
- |
# Create directory if it doesn't exist
mkdir -p $FCI_BUILD_DIR/config
# Write out the environment variable as a json file
echo $APP_CONFIG | base64 --decode > $FCI_BUILD_DIR/config/app_config.json
- cd . && flutter build apk --debug -t lib/main_dev.dart
- find . -name "Podfile" -execdir pod install \;
- cd . && flutter build ios --debug --no-codesign lib/main_dev.dart
artifacts:
- build/**/outputs/**/*.apk
- build/**/outputs/**/*.aab
- build/**/outputs/**/mapping.txt
- build/ios/ipa/*.ipa
- /tmp/xcodebuild_logs/*.log
- flutter_drive.log
publishing:
email:
recipients:
- ogbondachiziaruhoma@gmail.com
```
Определив наши переменные среды следующим образом:
```
vars:
APP_CONFIG: ewogICJkZXZIb3N0IjogIkRldmVsb3BtZW50IEhvc3QiLAogICJwcm9kSG9zdCI6ICJQcm9kdWN0aW9uIEhvc3QiCn0K
```
Вставив этот фрагмент кода выше, мы можем удалить файл `/config/app_config.json` и создать его при запуске **CI** сборки.
```
# Write out the environment variable as a json file
echo $APP_CONFIG | base64 --decode > $FCI_BUILD_DIR/config/app_config.json
```
**Примечание:** Наш входной файл `lib/main_dev.dart` в файле `codemagic.yaml` должен быть изменен на `lib/main_prod.dart`для готовой сборки.
### Запуск сборки
После сохранения `codemagic.yaml` файла на предпочитаемой системе контроля версий(GitHub, bitbucket и т.д), нажмите на **“Start your first build”**.
Файл среды определится автоматически:
Нажмите на **“Start new build”**:
Вуаля, сборка запущена.
### The end
Веб-сокеты быстрые, просты в настройке и все еще могут быть **"RESTful"**. Их можно использовать для большого количества приложений. И мы также видим, что очень просто настроить работу приложения и интегрировать различные переменные среды/скрыть части кода в Codemagic CI/CD, и радость в том, что вам нужно сделать это только один раз, после этой настройки вы можете добавить больше конфигураций или изменить существующие.
Если вы хотите познакомиться с более продвинутым использованием веб-сокетов и Codemagic CI/CD, пройдите по ссылки, чтобы [**посмотреть полный код**](https://github.com/Zfinix/socket_chat/). | https://habr.com/ru/post/568356/ | null | ru | null |
# EDuke32 — Open Source движок Duke Nukem 3D
[](http://www.eduke32.com)
[EDuke32](http://www.eduke32.com) — движок культового PC шутера от 1-го лица Duke Nukem 3D для Windows, Linux и OS X, который добавляет кучу интересных вещей и дополнений для игроков, а также включает в себя средства для редактирования как карт, так и самой игры для модмейкеров. Модами я особо не интересуюсь, так что расскажу о самой игре
* Полностью нативна и запускается без всяких эмуляторов
* Поддержка сумасшедших разрешений, как 3072x2304
* Позволяет выбирать между новым, модернизированным рендером с OpenGL ускорением и классическим, софтверным
* Исправлены ошибки, что были в DOS версии
* Единственный активно разрабатываемый и поддерживаемый порт Duke Nukem 3D за последние годы
* Поддержка нового рендера, который имеет название «Polymer», как замена «Polymost»
* Бесконечное количество модов и расширений, которые изменяют игровой процесс. Есть даже мод, добавляющий [гравипушку](http://deeperthought.dukertcm.com/)
* Единственный порт, который может запустить High Resolution Pack со всеми его достоинствами
* Quake-стайл консоль с подсветкой, историей команд итд
* Поддержка Ogg Vorbis для музыки и звуков
* Он разрабатывается людьми, которые стояли у истоков Duke3D-сцены
* Он делает бутерброды
Пользуюсь я Мандривой, и в репозитории бинарного пакета eduke32 не было. Ну чтож, будем собирать из исходников:
1. Для начала возьмем последнюю версию движка с SVN:
`svn co https://eduke32.svn.sourceforge.net/svnroot/eduke32 eduke32`
2. Собираем:
`cd eduke32/polymer/eduke32
make`
3. Лучше скопировать бинарники eduke32 и mapster32 /usr/local/bin, но я этого делать не стал (ну а в идеале — собрать пакет под свой дистрибутив).
4. Запускаем
`./eduke32`
Гуляем по менюшкам и понимаем, что игру начать не можем. Для успешного запуска нам еще необходим файлик duke3d.grp. Его можно скинуть с запылившегося диска оригинального Дюка, ~~[скачать](http://www.google.ru/search?q=duke3d.grp)~~ или [купить](http://www.gog.com/en/gamecard/duke_nukem_3d_atomic_edition/pp/6c1e671f9af5b46d9c1a52067bdf0e53685674f7) всего за $5.99.
Кидаем свой duke3d.grp в `~/.eduke32`
Следите чтобы имя файла было написано в нижнем регистре (обычно оно написано в верхнем), иначе eduke32 его не найдет. В результате во вкладке Games появится стандартный Duke Nukem 3D. Также можно скопировать duke3d.grp с диска Atomic Edition или с еще каких-либо модов и играть в них.
Нажимаем Start и вперед!
##### Polymer
На вкладке Configuration, как вы наверное заметили, можно включить функцию Polymer. Она позволяет нам использовать новый рендер. Зачем нам это? А для полного цветного динамического освещения, shadow mapping'a, поддержки детализированных текстур, динамических теней, шейдерных эффектов, glow-эффектов и еще кучи других фич. Конечно, для этого нужен и более мощный компьютер.
Вот для сравнения 2 скрина с огнем — до и после
##### High Resolution Pack
Для полного счастья необходимо [скачать](http://www.duke4.org/files/nightfright/beta/polymer_hrp.zip) комплект текстур высокого разрешения с поддержкой полимерного рендера. Копируем содержимое архива в ~/.eduke32. Запускаем и на вкладке Configuration в Custom Mod выбираем HiRes
Ждем пока прогрузятся все текстуры (лично у меня занимает около минуты) и наслаждаемся новым нюком! Все текстуры заменены, враги больше не картонные, пламя более человеческое. Только все окружающие предметы потеряли брутальность и стали выглядеть более мультяшно.
[](http://funkyimg.com/viewer.php?img=/2/858/827/3.png)[](http://funkyimg.com/viewer.php?img=/2/243/278/2.png)[](http://funkyimg.com/viewer.php?img=/2/149/667/1.png)
При всех этих украшательствах у меня игра идет вполне сносно, но при появлении большого количества врагов играть, мягко говоря, некомфортно.
PS: хотел попробовать поиграть на джойпаде, он определился, но на нажатия кнопок не реагировал… | https://habr.com/ru/post/89321/ | null | ru | null |
# Go += управление версиями пакетов
*Статья написана в феврале 2018 года*
В Go необходимо добавить версионирование пакетов.
Точнее, нужно добавить концепцию версионирования в рабочий словарь разработчиков Go и в инструменты, чтобы все употребляли одинаковые номера версий при упоминании, какую именно программу собрать, запустить или проанализировать. Команда `go` должна точно говорить, какие версии каких пакетов находятся в конкретной сборке.
Нумерация версий позволяет сделать воспроизводимые сборки: если я выложу последнюю версию своей программы, вы получите не только последнюю версию моего кода, но и точно такие же версии всех пакетов, от которых зависит мой код, так что мы с вами создадим полностью эквивалентные двоичные файлы.
Версионирование также гарантирует, что завтра программа соберётся точно так же, как сегодня. Даже если вышли новые версии зависимостей, `go` не станет их использовать без специальной команды.
Хотя нужно добавить управление версиями, не следует отказываться от главных преимуществ команды `go`: это простота, скорость и понятность. Сегодня многие программисты не обращают внимания на версии, и всё работает нормально. Если сделать правильную модель, то программисты *по-прежнему* не будут обращать внимания на номера версий, просто всё станет лучше работать и станет понятнее. Существующие рабочие процессы практически не изменятся. Выпуск новых версий очень простой. В общем, управление версиями должно уйти на второй план и не отнимать внимание разработчика.
Короче говоря, нужно добавить управление версиями пакета, но не сломать `go get`. В этой статье мы предлагаем, как это сделать, а также демонстрируем прототип, который вы можете попробовать уже сейчас, и который, надеюсь, станет основой для возможной интеграции `go`. Надеюсь, статья станет началом продуктивной дискуссии о том, что работает, а что нет. На основе этого обсуждения я внесу коррективы как в своё предложение, так и в прототип, а затем представлю [официальное предложение](https://golang.org/s/proposal) для добавления опциональной функции в Go 1.11.
Это предложение сохраняет все преимущества `go get`, но добавляет воспроизводимые сборки, поддерживает семантическое управление версиями, устраняет вендоринг, убирает GOPATH в пользу рабочего процесса на основе проекта и обеспечивает плавный уход от `dep` и его предшественников. Тем не менее, это предложение все ещё на ранней стадии. Если детали не верны, мы их исправим, прежде чем работа попадёт в основной дистрибутив Go.
Общая ситуация
==============
Прежде чем изучить предложение, давайте посмотрим на текущее положение и как мы в нём оказались. Может, этот раздел слегка великоват, но история несёт важные уроки и помогает понять, почему мы хотим что-то изменить. Если это вам не интересно, можете сразу перейти к [предложению](https://research.swtch.com/vgo-intro#proposal) или прочитать [сопроводительную статью в блоге с примером](https://research.swtch.com/vgo-tour).
### `Makefile`, `goinstall` и `go get`
В ноябре 2009 года с первоначальной версией Go вышел компилятор, компоновщик и несколько библиотек. Чтобы скомпилировать и связать программы, требовалось запустить `6g` и `6l`, и мы включили в комплект примеры файлов makefile. Минимальная оболочка `gobuild` могла собрать один пакет и написать соответствующий makefile (в большинстве случаев). Не было никакого установленного способа поделиться кодом с другими. Мы знали, что этого мало — но выпустили то, что было, планируя разработать остальное совместно с сообществом.
В феврале 2010 года [мы предложили goinstall](https://groups.google.com/d/msg/golang-nuts/8JFwR3ESjjI/cy7qZzN7Lw4J), простую команду для загрузки пакетов из репозиториев систем управления версиями, таких как Bitbucket и GitHub. `Goinstall` ввёл конвенции по путям импорта, которые сейчас считаются общепринятыми. Но в то время ни один код не следовал этим соглашениям, `goinstall` сначала работал только с пакетами, которые не импортировали ничего, кроме стандартной библиотеки. Но разработчики быстро перешли к единому соглашению, которое мы знаем сегодня, и набор опубликованных пакетов Go вырос в целостную экосистему.
Goinstall также устранил файлы Makefile, а с ними и сложность пользовательских вариантов сборки. Хотя иногда бывает неудобно, что авторы пакетов не могут генерировать код во время каждой сборки, это упрощение невероятно важно для *пользователей* пакета: им не нужно беспокоиться об установке того же набора инструментов, который использовал автор. Такое упрощение также имеет решающее значение для работы инструментов. Makefile — это обязательный пошаговый рецепт компиляции пакета; а применение к тому же пакету другого инструмента вроде `go vet` или автозавершения может оказаться довольно сложным. Даже правильное получение зависимостей, чтобы собирать заново пакеты при необходимости и только при необходимости, намного сложнее с произвольными файлами Makefile. Хотя в то время некоторые возражали, что их лишают гибкости, но оглядываясь назад, становится ясно, что отказ от Makefile стал правильным шагом: выгоды намного перевешивают неудобства.
В декабре 2011 года в рамках подготовки Go 1 [мы представили команду go](https://groups.google.com/d/msg/golang-dev/8DNjlySemwI/-1CDvVX6QVcJ), которая заменила `goinstall` на `go get`.
В целом, `go get` представил значительные изменения: он позволил разработчикам Go обмениваться исходным кодом и использовать работы друг друга. Он также изолировал детали системы сборки внутри команды `go`, так что стала возможной значительная автоматизация с помощью инструментария. Но `go get` не хватает концепции управления версиями. В [самых первых обсуждениях goinstall](https://groups.google.com/d/msg/golang-nuts/8JFwR3ESjjI/cy7qZzN7Lw4J) стало понятно: нужно что-то делать с управлением версиями. К сожалению, не было понятно, что именно делать. По крайней мере, мы в команде Go этого ясно не понимали. Когда `go get` запрашивает пакет, то всегда получает последнюю копию, делегируя операции загрузки и обновления системе управления версиями, такой как Git или Mercurial. Такая «работа вслепую» привела по крайней мере к двум существенным недостаткам.
### Управление версиями и стабильность API
Первый существенный недостаток `go get` заключается в том, что без концепции управления версиями она не может ничего сказать пользователю о том, каких изменений ожидать в данном обновлении.
В ноябре 2013 года в версии Go 1.2 добавлена запись FAQ с таким советом относительно версионирования (текст не изменился к версии Go 1.10):
> Пакеты для общего пользования должны поддерживать обратную совместимость по мере своего развития. Здесь уместны [рекомендации по совместимости Go 1](https://golang.org/doc/go1compat.html): не удаляйте экспортированные имена, поощряйте тегирование составных литералов и так далее. Если требуется новая функциональность, добавьте новое имя, а не меняйте старое. В случае кардинального изменения создайте новый пакет с новым путём импорта.
В марте 2014 года Густаво Нимейер запустил [gopkg.in](https://gopkg.in/) под вывеской «стабильные API для языка Go». Данный домен — GitHub-редирект с учётом версии, позволяющий импортировать пути вроде `gopkg.in/yaml.v1` и `gopkg.in/yaml.v2` для различных коммитов (возможно, в разных ветвях) одного репозитория Git. Согласно семантическому управлению версиями авторы должны при внесении критических изменений выпускать новую основную версию. Таким образом, более поздние версии пути импорта `v1` заменяют предыдущие, а `v2` может отдавать совершенно другие API.
В августе 2015 года Дэйв Чейни [подал предложение о семантическом управлении версиями](https://golang.org/issue/12302). В течение следующих нескольких месяцев это вызвало интересную дискуссию: казалось, все согласились, что семантическая пометка версий — прекрасная идея, но никто не знал, как инструменты должны работать с этими версиями.
Любые аргументы за семантическое версионирование неизбежно встречает критику со ссылкой на [закон Хайрама](http://www.hyrumslaw.com/):
> Контракт вашего API становится не важен при достаточном количестве пользователей. От любого наблюдаемого поведения системы кто-то зависит.
Хотя закон Хайрама эмпирически верен, семантическое управление версиями по-прежнему является полезным способом формирования ожиданий по отношениям между релизами. Обновление с 1.2.3 до 1.2.4 не должно ломать ваш код, а обновление с 1.2.3 до 2.0.0 вполне может. Если код перестаёт работать после обновления на 1.2.4, то автор, скорее всего, примет баг-репорт и исправит ошибку в версии 1.2.5. Если код перестал работать (или даже компилироваться) после обновления на 2.0.0, то это изменение с гораздо большей вероятностью было преднамеренным и, соответственно, вряд ли что-то исправят в 2.0.1.
Я не хочу делать из закона Хайрама вывод, что семантическое версионирование невозможно. Вместо этого я считаю, что сборки следует использовать осторожно, используя точно такие же версии каждой зависимости, что и автор. То есть сборки по умолчанию должны быть максимально воспроизводимыми.
### Вендоринг и воспроизводимые сборки
Второй существенный недостаток `go get` заключается в том, что без концепции управления версиями команда не может обеспечить и даже выразить идею воспроизводимой сборки. Невозможно быть уверенным, что пользователи компилируют те же версии зависимостей кода, что и вы. В ноябре 2013 года в FAQ для Go 1.2 добавили ещё и такой совет:
> Если вы используете внешний пакет и опасаетесь, что он может неожиданно измениться, самое простое решение — скопировать его в локальный репозиторий (такой подход используется в Google). Сохраните копию c новым путём импорта, который идентифицирует её как локальную копию. Например, можно скопировать `original.com/pkg` в `you.com/external/original.com/pkg`. Один из инструментов для этой процедуры — `goven` Кита Рэрика.
Кит Рэрик начал этот проект в марте 2012 года. Утилита `goven` копирует зависимость в локальный репозиторий и обновляет все пути импорта, чтобы отразить новое местоположение. Такие изменения исходного кода необходимы, но неприятны. Они затрудняют сравнение и включение новых копий, а также требуют обновления другого скопированного кода с использованием этой зависимости.
В сентябре 2013 года [Кит представил godep](https://groups.google.com/d/msg/golang-nuts/8NJq6jTIpas/Vpf-KZtVu9MJ), «новый инструмент для фиксации зависимостей пакетов». Основным достижением `godep` стало то, что мы теперь называем вендорингом, то есть копирование зависимостей в проект *без* изменения исходных файлов, без прямой поддержки инструментов, путём определённой настройки GOPATH.
В октябре 2014 года Кит предложил добавить в инструменты Go [поддержку «внешних пакетов»](https://groups.google.com/forum/#!msg/golang-dev/74zjMON9glU/dGhnoi2IMzsJ), чтобы инструменты лучше понимали проекты, использующие эту конвенцию. К тому времени появилось уже несколько утилит в стиле `godep`. Мэтт Фарина опубликовал пост «Путешествие по морю пакетных менеджеров Go», сравнивая `godep` с новичками, особенно `glide`.
В апреле 2015 года Дэйв Чейни [представил gb](https://dave.cheney.net/2015/05/12/introducing-gb), «инструмент сборки на основе проекта… с повторяемой сборкой через вендоринг исходников», опять же без перезаписи путей импорта (другая мотивация для создания gb заключалась в том, чтобы избежать требования хранить код в определённых каталогах в GOPATH, что не всегда удобно).
Той весной Джейсон Буберель изучил ситуацию с системами управления пакетами Go, в том числе многочисленное дублирование усилий и напрасную работу над похожими утилитами. Его опрос дал понять разработчикам, что поддержку вендоринга без перезаписи путей импорта обязательно надо добавить в команду `go`. В то же время, Даниэль Теофанес начал подготовку спецификации для формата файла, который описывает точное происхождение и версию кода в каталоге вендора. В июне 2015 года мы приняли предложение Кита в качестве [эксперимента по вендорингу в Go 1.5](https://golang.org/s/go15vendor), который включили по умолчанию в Go 1.6. Мы призвали авторов всех инструментов для вендоринга поработать с Даниэлем, чтобы принять единый формат файла метаданных.
Внедрение концепции вендоринга в Go позволило инструментам вроде `vet` более грамотно анализировать программы, и сегодня её используют уже с десяток или два пакетных менеджеров или инструментов вендоринга. С другой стороны, поскольку у всех различные форматы метаданных, они не взаимодействуют и не могут легко обмениваться информацией о зависимостях.
Более фундаментально, вендоринг — неполное решение проблемы управления версиями. Он обеспечивает только воспроизводимость сборки, но не помогает разобраться в версиях пакета и решить, какую из них использовать. Пакетные менеджеры вроде `glide` и `dep` неявно добавляют в Go концепцию управления версиями, определённым образом настраивая каталог вендора. В результате многие инструменты в экосистеме Go не могут быть получить корректную информацию о версиях. Понятно, что Go нуждается в прямой поддержке версий пакетов.
### Официальный эксперимент по управлению пакетами
На GopherCon 2016 в Hack Day (теперь Community Day) собралась группа активистов Go для [широкого обсуждения проблемы управления пакетами](https://docs.google.com/document/d/1xMJ0c-YxvcgNglzjbALzncs5_Acr0MST29oMf9TkgQI/edit). Одним из результатов стало формирование [комитета и консультативной группы для ведения комплекса работ с целью создания нового инструмента управления пакетами](https://groups.google.com/d/msg/go-package-management/P8TehVoFLjg/Ni6VRyOjEAAJ). Идея заключалась в том, чтобы унифицированный инструмент заменил существующие, хотя он всё равно будет реализован за рамками прямого инструментария Go, с использованием каталогов вендоров. В комитет вошли Эндрю Джерранд, Эд Мюллер, Джесси Фразель и Сэм Бойер под руководством Питера Бургона. Они подготовили [черновик спецификаций](https://docs.google.com/document/d/1qnmjwfMmvSCDaY4jxPmLAccaaUI5FfySNE90gB0pTKQ/edit), а затем Сэм с помощниками [реализовали dep](https://github.com/golang/dep). Для понимания общей ситуации см. статью Сэма в феврале 2016 года [«Итак, вы хотите написать пакетный менеджер»](https://medium.com/@sdboyer/so-you-want-to-write-a-package-manager-4ae9c17d9527), его пост в декабре 2016 года [«Сага об управлении зависимостями в Go»](https://blog.gopheracademy.com/advent-2016/saga-go-dependency-management/) и выступление в июле 2017 года на GopherCon [«Новая эра управления пакетами в Go»](https://www.youtube.com/watch?v=5LtMb090AZI).
`Dep` выполняет много задач: это важное улучшение по сравнению с текущими практиками. Это и важный шаг к будущему решению, и одновременно эксперимент — мы называем его «официальным экспериментом» — который помогает нам лучше узнать потребности разработчиков. Но `dep` не является прямым прототипом возможной интеграции команд `go` в управление версиями пакетов. Это мощный, гибкий, почти универсальный способ исследовать пространство проектных решений. Он похож на makefiles, с которыми мы боролись в самом начале. Но как только мы лучше поймём пространство проектных решений и сможем сузить его до нескольких ключевых функций, которые должны поддерживаться, это поможет экосистеме Go удалить другие функции, уменьшить выразительность, принять обязательные конвенции, которые делают базы кода Go более единообразными и лёгкими в понимании.
Эта статья является началом слудующего шага после `dep`: первый прототип окончательной интеграции с командой `go`, пакетный эквивалент `goinstall`. Прототип — это отдельная команда, которую мы называем `vgo`: замена `go` с поддержкой управления версиями пакетов. Это новый эксперимент, и мы посмотрим, что из него выйдет. Также как и во время анонса `goinstall`, некоторые проекты и код уже сейчас совместимы с `vgo`, а другие нуждаются в изменениях. Мы уберём некоторый контроль и выразительность, также как в своё время убрали makefiles, в целях упрощения системы и устранения сложности для пользователей. Самое главное, мы ищем первопроходцев, которые помогут экспериментировать с `vgo`, чтобы получить как можно больше отзывов.
Начало эксперимента с `vgo` не означает прекращения поддержки `dep`: он останется доступным до тех пор, пока мы не достигнем полной и общедоступной интеграции с `go`. Мы также постараемся сделать окончательный переход от `dep` к интеграции с `go` как можно более плавным, в какой бы форме не осуществлялась эта интеграция. Проекты, которые ещё не преобразованы в `dep`, по-прежнему могут извлечь реальную выгоду из этого преобразования (обратите внимание, что [`godep`](https://github.com/tools/godep) и [`glide`](https://github.com/Masterminds/glide) прекратили активное развитие и поощряют миграцию на dep). Возможно, какие-то проекты пожелают перейти сразу на `vgo`, если это отвечает их потребностям.
Предложение
===========
Предложение по добавлению управления версиями в команду `go` состоит из четырёх шагов. Во-первых, принять *правило совместимости импорта*, на которое указывают FAQ и gopkg.in: более новые версии пакета с заданным путём импорта должны быть обратно совместимы со старыми версиями. Во-вторых, принять простой новый алгоритм, известный как *выбор минимальной версии* для определения, какие версии пакета используются в данной сборке. В-третьих, ввести понятие *модуля* Go: группы пакетов, версионированных как единое целое и объявляющих минимальные требования, которые должны быть удовлетворены их зависимостями. В-четвёртых, определить, как встроить всё это в существующую команду `go`, чтобы основные рабочие процессы существенно не изменились с сегодняшнего дня. В остальной части статьи мы рассматриваем каждый из этих шагов. Они более подробно рассматриваются в [других статьях блога](https://research.swtch.com/).
### Правило совместимости импорта
Главная проблема систем управления пакетами — попытки решить несовместимости. Например, большинство систем позволяют пакету B объявить, что ему нужен пакет D версии 6 или более поздней, а затем позволяют пакету C объявить, что он требует D версии 2, 3 или 4, но не 5-й или более поздней версии. Таким образом, если в своём пакете вы хотите использовать B и C, то вам не повезло: невозможно выбрать ни одной версии D, которая удовлетворяет обоим условиям, и вы ничего не можете сделать.
Вместо системы, которая неизбежно блокирует сборку больших программ, наше предложение вводит *правило совместимости импорта* для авторов пакетов:
> Если у старого и нового пакетов одинаковый путь импорта, новый пакет должен быть обратно совместим со старым пакетом.
Правило повторяет FAQ, упомянутый ранее. Тот текст завершался словами: «В случае кардинального изменения создайте новый пакет с новым путём импорта». Сегодня для такого кардинального изменения разработчики рассчитывают на семантическое управление версиями, поэтому мы интегрируем его в наше предложение. В частности, номер второй и последующих основных версий можно непосредственно включать в путь:
```
import "github.com/go-yaml/yaml/v2"
```
В семантическом управлении версиями версия 2.0.0 означает кардинальное изменение, поэтому создаётся новый пакет с новым путём импорта. Поскольку у каждой основной версии другой путь импорта, то конкретный исполняемый файл Go может содержать одну из основных версий. Это ожидаемо и желательно. Такая система поддерживает сборку программ и позволяет частям очень большой программы независимо друг от друга обновиться с v1 на v2.
Соблюдение авторами правила совместимости импорта устраняет попытки решить несовместимости, экспоненциально упрощая общую систему и уменьшая фрагментированность экосистемы пакетов. Конечно, на практике, несмотря на все старания авторов, обновления в рамках одной и той же основной версии иногда ломают пакеты пользователей. Поэтому не следует слишком часто обновляться. Это подводит нас к следующему шагу.
### Выбор минимальной версии
Сегодня почти все пакетные менеджеры, включая `dep` и `cargo`, [используют в сборке самую последнюю разрешённую версию пакетов](https://research.swtch.com/cargo-newest.html). Я считаю, что такое поведение по умолчанию неправильно по двум причинам. Во-первых, номер «последней разрешённой версии» может измениться из-за внешних событий, а именно из-за публикации новых версий. Возможно, сегодня вечером кто-то представит новую версию некоторой зависимости, а завтра та же последовательность команд, которую вы выполнили сегодня, даст другой результат. Во-вторых, чтобы переопределить это значение по умолчанию, разработчики тратят своё время, указывая пакетному менеджеру «нет, не нужно использовать X», а затем пакетный менеджер тратит время на [поиск способа не использовать X](https://research.swtch.com/version-sat).
В нашем предложении используется другой подход, который я называю *выбор минимальной версии*. По умолчанию используется *самая старая* разрешённая версия каждого пакета. Это решение не изменится завтра, потому что невозможно опубликовать более старую версию. Ещё лучше, что для пакетного менеджера тривиально определить, какую версию использовать. Я называю это выбором минимальной версии, потому что выбранные номера версии минимальны, а ещё потому что система в целом, возможно, тоже минимальна, избегая почти всей сложности существующих систем.
Выбор минимальной версии позволяет модулям задавать только минимальные требования к зависимостям. Это чётко определённые, уникальные ответы как для обновлений, так и для операций понижения версии, и эти операции действительно эффективны. Такой принцип позволяет автору всего модуля указать версии зависимостей, которые он хочет исключить, или указать замену конкретной зависимости на её форк, который размещается или в локальном хранилище, или опубликован как отдельный модуль. Эти исключения и замены не применяются, когда модуль собирается как зависимость какого-то другого модуля. Это даёт пользователям полный контроль над тем, как собираются их собственные программы, но не над чужими.
Выбор минимальной версии обеспечивает воспроизводимые сборки по умолчанию без файла блокировки.
Совместимость импорта — ключ к простоте выбора минимальной версии. Пользователи больше не могут сказать «нет, это слишком новая версия», они могут только сказать «нет, она слишком старая». В этом случае решение понятно: используйте (минимально) более новую версию. И более новые версии по соглашению являются приемлемыми заменами для более старых.
### Определение модулей Go
*Модуль* Go представляет собой набор пакетов с общим префиксом пути импорта, известным как путь модуля. Модуль является единицей управления версиями, а версии записываются в виде семантических строк. При разработке с помощью Git разработчики определяют новую семантическую версию модуля, добавляя тег в репозиторий Git модуля. Хотя сильно рекомендуется указывать именно семантические версии, поддерживаются и ссылки на конкретные коммиты.
В новом файле `go.mod` модуль определяет минимальные требования к версии других модулей, от которых он зависит. Например, вот простой файл `go.mod`:
```
// My hello, world.
module "rsc.io/hello"
require (
"golang.org/x/text" v0.0.0-20180208041248-4e4a3210bb54
"rsc.io/quote" v1.5.2
)
```
Этот файл определяет модуль, который идентифицируется по пути `rsc.io/hello`, а сам зависит от двух других модулей: `golang.org/x/text` и `rsc.io/quote`. Сборка модуля сама по себе всегда будет использовать определённые версии необходимых зависимостей, перечисленные в файле `go.mod`. Как часть более крупной сборки, он может использовать более новую версию только если какая-то другая часть сборки этого потребует.
Авторы помечают свои релизы семантическими версиями, а `vgo` рекомендует использовать помеченные версии, а не произвольные коммиты. У модуля `rsc.io/quote`, который поставляется с `github.com/rsc/quote`, есть помеченные версии, в том числе 1.5.2. Однако у модуля `golang.org/x/text` помеченных версий ещё нет. Чтобы присвоить название непомеченным коммитам, псевдоверсия *v0.0.0-yyyymmddhhmmss-commit* определяет конкретный коммит в заданную дату. В семантическом управлении версиями эта строка соответствует пререлизу v0.0.0 с идентификатором *yyyymmddhhmmss-commit*. Семантические правила старшинства версий распознают такие пререлизы как более ранние, чем версия v0.0.0, и выполняют сравнение строки. Порядок указания даты в псевдоверсии гарантирует, что сравнение строк соответствует сравнению дат.
В дополнение к этим требованиям, файлы `go.mod` могут указывать исключения и замены, упомянутые в предыдущем разделе, но опять же они применяются только при сборке изолированного модуля, а не при сборке в рамках более крупной программы. Всё это демонстрируется в [примерах](https://research.swtch.com/vgo-tour).
`Goinstall` и старый `go get` для загрузки кода вызывают инструменты управления версиями, такие как `git` и `hg`, что приводит ко многим проблемам, среди которых фрагментация. Например, пользователи без `bzr` не могут загрузить код из репозиториев Bazaar. В отличие от этой системы, модули Go всегда выдаются по HTTP в виде zip-архивов. Раньше в `go get` были особые команды для популярных хостингов кода. Сейчас у `vgo` особые процедуры API для получения архивов с этих сайтов.
Единообразное представление модулей в виде zip-архивов позволяет тривиально реализовать протокол и прокси-сервер для загрузки модулей. У компаний и отдельных пользователей есть разные причины для запуска таких прокси-серверов, в том числе безопасность и желание работать с кэшированными копиями в случае удаления оригиналов. При наличии прокси для обеспечения доступности и `go.mod` для определения, какой код использовать, больше не нужны каталоги вендоров.
### Команда `go`
Для работы с модулями команду `go` нужно обновить. Одним из существенных изменений является то, что обычные команды сборки, такие как `go build`, `go install`, `go run` и `go test`, начнут разрешать по требованию новые зависимости. Чтобы использовать `golang.org/x/text` в совершенно новом модуле достаточно добавить импорт в исходный код Go и выполнить сборку.
Но самое значительное изменение — прощание с GOPATH как местом написания кода. Поскольку файл `go.mod` включает в себя полный путь к модулю, а также определяет версию каждой используемой зависимости, каталог с файлом `go.mod` отмечает корень дерева каталогов, который служит автономным рабочим пространством, отдельно от любых других таких каталогов. Теперь вы просто делаете `git clone`, `cd`, и начинаете писать. Где угодно. Никакого GOPATH.
Что дальше?
===========
Я опубликовал также [«Тур по управлению версиями в Go»](https://research.swtch.com/vgo) с демонстрацией, как использовать `vgo`. В той статье рассказывается, как скачать и прямо сегодня начать использовать `vgo`. Остальная информация в [других статьях](https://research.swtch.com/). Буду рад комментариям.
Пожалуйста, [попробуйте vgo](https://research.swtch.com/vgo-tour). Начните размечать семантическими тегами версии в репозиториях. Создавайте файлы `go.mod`. Обратите внимание, что если в репозитории пустой файл `go.mod`, но есть `dep`, `glide`, `glock`, `godep`, `godeps`, `govend`, `govendor` или конфигурационный файл `gvt`, то `vgo` использует их для заполнения файла `go.mod`.
Я рад, что Go делает этот давно назревший шаг по поддержке версий. Некоторые из наиболее распространённых проблем, с которыми сталкиваются разработчики Go, — отсутствие воспроизводимых сборок, полное игнорирование тегов релиза со стороны `go get`, неспособность GOPATH распознать разные версии пакета и невозможность работать в каталогах за пределами GOPATH. Предлагаемый здесь дизайн устраняет все эти проблемы и многое другое.
Но я наверняка ошибаюсь в каких-то деталях. Надеюсь, читатели помогут улучшить его, испытав прототип `vgo` и участвуя в продуктивных дискуссиях. Я бы хотел, чтобы Go 1.11 поставлялся с предварительной поддержкой модулей Go, как своего рода демо, а затем Go 1.12 вышел с официальной поддержкой. В более поздних версиях мы удалим поддержку старого, неверсионного `go get`. Но это агрессивный план, и если для правильной функциональности потребуется ждать более поздних релизов, так тому и быть.
Меня очень волнует переход от старого `go get` и бесчисленных инструментов вендоринга к новой модульной системе. Этот процесс так же важен для меня, как и правильная функциональность. Если успешный переход означает ожидание более поздних выпусков, опять же, так тому и быть. | https://habr.com/ru/post/442272/ | null | ru | null |
# Behind the scene of TOP-1 supercomputer
Это история о том, как мы c [mildly\_parallel](https://habrahabr.ru/users/mildly_parallel/) ~~замедляли~~ ускоряли расчеты на самом мощном суперкомпьютере [в мире](http://www.top500.org/).
В апреле этого года наша команда приняла участие в финале [Asia supercomputer challenge 2017](http://www.asc-events.org/ASC17/), одним из заданий которого было ускорение программы для моделирования океанских волн Masnum-Wave на китайском суперкомпьютере Sunway TaihuLight.
Все началось с отборочного тура в феврале: мы получили доступ к суперкомпьютеру и познакомились с нашим новым другом на ближайшие пару месяцев.
Вычислительные узлы выставлены в форме двух овалов, между которыми стоит сетевое железо. В узлах используются процессоры Shenwei 26010. Каждый из них состоит из 4 гетерогенных процессорных групп, которые включают одно управляющее и 64 вычислительных ядра с тактовой частотой 1,45 ГГц и размером локального кэша 64 Кб.
Охлаждается все это с помощью водяной системы, расположенной в отдельном здании.
Из ПО в нашем распоряжении были компиляторы фортрана и си с “поддержкой” OpenACC 2 и athreads (аналог POSIX Threads) и планировщик задач, совмещающий в себе одновременно возможности обычного планировщика и mpirun.
Доступ к кластеру осуществлялся через особый VPN, плагины для работы с которым были доступны только для Windows и Mac OS. Все это добавляло особенного шарма при работе.
Заданием было ускорение Masnum-Wave на этом суперкомпьютере. Нам предоставили исходный код Masnum-Wave, несколько крохотных readme файлов с описанием основ работы на кластере и данные для замера ускорения.
Masnum-Wave – это программа для моделирования движения волн по всему земному шару. Она написана на Фортране с использованием MPI. В двух словах, она итеративно выполняет следующее: читает данные функций внешнего воздействия, синхронизирует граничные области между MPI-процессами, вычисляет продвижение волн и сохраняет результаты. Нам дали workload на 8 модельных месяцев с шагом по 7.5 минуты.
В первый же день мы нашли в интернете статью: “The Sunway TaihuLight supercomputer:
system and applications, Haohuan Fu” с описанием ускорения Masnum-Wave на архитектуре Sunway TaihuLight с помощью конвейерной обработки. Авторы статьи использовали всю мощь кластера (10649600 ядер), в нашем же распоряжении было 64 вычислительных группы (4160 ядер).
Masnum-Wave состоит из нескольких модулей:
Мы впервые столкнулись с таким большим количеством кода, порожденного наукой. Так как код представляет собой смесь двух версий фортрана 90 и 77, это порой ломало работу их собственного компилятора. В большом количестве там встречаются чудесные конструкции goto, куски закомментированного кода и, конечно же, комментарии на китайском.
Сокращенный пример кода для наглядности:
```
do 1201 j=1,jl
js=j
j11=jp1(mr,j)
j12=jp2(mr,j)
j21=jm1(mr,j)
j22=jm2(mr,j)
!****************************************************************
! do 1202 ia=ix1,ix2
! do 1202 ic=iy1,iy2
eij=e(ks,js,ia,ic)
!if (eij.lt.1.e-20) goto 1201
if (eij.lt.1.e-20) cycle
ea1=e(kp ,j11,ia,ic)
ea2=e(kp ,j12,ia,ic)
! ...
eij2=eij**2
zua=2.*eij/al31
ead1=sap/al11+sam/al21
ead2=-2.*sap*sam/al31
! fcen=fcnss(k,ia,ic)*enh(ia,ic)
fcen=fconst0(k,ia,ic)*enh(ia,ic)
ad=cwks17*(eij2*ead1+ead2*eij)*fcen
adp=ad/al13
adm=ad/al23
delad =cwks17*(eij*2.*ead1+ead2) *fcen
deladp=cwks17*(eij2/al11-zua*sam)*fcen/al13
deladm=cwks17*(eij2/al21-zua*sap)*fcen/al23
!* nonlinear transfer
se(ks ,js )= se(ks ,js )-2.0*ad
se(kp2,j11)= se(kp2,j11)+adp*wp11
se(kp2,j12)= se(kp2,j12)+adp*wp12
se(kp3,j11)= se(kp3,j11)+adp*wp21
se(kp3,j12)= se(kp3,j12)+adp*wp22
se(im ,j21)= se(im ,j21)+adm*wm11
se(im ,j22)= se(im ,j22)+adm*wm12
se(im1,j21)= se(im1,j21)+adm*wm21
se(im1,j22)= se(im1,j22)+adm*wm22
!...
! 1202 continue
! 1212 continue
1201 continue
```
Прежде всего мы с помощью вывода времени выполнения каждой функции определили узкие места в коде и кандидатов для оптимизации. Наибольший интерес у нас вызвал модуль warcor, отвечающий за численное решение модельного уравнения и функции записи контрольных точек.
Изучив скудную документацию к китайским компиляторам, мы решили использовать OpenACC, так как это стандарт от Nvidia с примерами и спецификацией. К тому же, код из readme к athreads казался нам неоправданно сложным и просто не компилировался. Как же мы ошибались.
Одна из первых идей, которая приходит в голову при оптимизации кода на ускорителях – это использование локальной памяти. В OpenACC это можно сделать несколькими директивами, но результат всегда должны быть один: данные перед началом вычислений должны быть скопированы на локальную память.
Для проверки и выбора нужной директивы мы написали на фортране несколько тестовых программ, на которых убедились, что они работают и что можно таким образом получить ускорение. Далее мы расставили эти директивы в Masnum-Wave, указав им имена наиболее используемых переменных. После компиляции они стали появляться в логах, сопутствующие надписи на китайском не были подсвечены красным, и мы посчитали, что все скопировалось и работает.
Но оказалось, что не все так просто. Компилятор OpenACC не копировал массивы в Masnum-Wave, но работал исправно с тестовыми программами. Проведя пару дней с Google Translate мы поняли, что он не копирует объекты, которые определены в файлах, подключаемых через директивы препроцессора (include)!
Всю следующею неделю мы переносили код Masnum-Wave из подключаемых файлов (а их больше 30) в файлы с исходным кодом, при этом нужно было убедиться, что все определятся и линкуется в правильном порядке. Но, так как ни у кого из нас не было опыта работы с Фортраном, и все сводилось к “давайте жахнем и посмотрим, что получится”, то без замены некоторых основных функций на костыльные версии тут тоже не обошлось.
И вот, когда все модули были перелопачены, и мы, в надежде получить свое мизерное ускорение, запустили свежескомилированный код, то получили очередную порцию разочарования! Директивы, написанные по всем канонам стандарта OpenACC 2.0, выдают ошибки в runtime. В этот момент в наши головы начала закрадываться идея, что этот чудесный суперкомпьютер поддерживает какой-то свой особый стандарт.
Тогда мы попросили у организаторов соревнований документацию, и с третьей попытки они нам ее предоставили.
Пару часов с Google Translate подтвердили наши опасения: стандарт, который они поддерживают, называется OpenACC 0.5, и он кардинально отличается от OpenACC 2.0, поставляемого с pgi компилятором.
Например, основной нашей задумкой было переиспользование данных на ускорителе. Для выполнения этого в стандарте 2.0 необходимо обернуть параллельный код в блок data. Вот как это делается в примерах от Nvidia:
```
!$acc data copy(A, Anew)
do while ( error .gt. tol .and. iter .lt. iter_max )
error=0.0_fp_kind
!$omp parallel do shared(m, n, Anew, A) reduction( max:error )
!$acc kernels
do j=1,m-2
do i=1,n-2
Anew(i,j) = 0.25_fp_kind * ( A(i+1,j ) + A(i-1,j ) + &
A(i ,j-1) + A(i ,j+1) )
error = max( error, abs(Anew(i,j)-A(i,j)) )
end do
end do
!$acc end kernels
!$omp end parallel do
if(mod(iter,100).eq.0 ) write(*,'(i5,f10.6)'), iter, error
iter = iter +1
!$omp parallel do shared(m, n, Anew, A)
!$acc kernels
do j=1,m-2
do i=1,n-2
A(i,j) = Anew(i,j)
end do
end do
!$acc end kernels
!$omp end parallel do
end do
!$acc end data
```
Но на кластере этот код не скомпилируется, потому что в их стандарте эта операция делается через указание индекса для каждого блока данных:
```
#include
#include
#define NN 128
int A[NN],B[NN],C[NN];
int main()
{
int i;
for (i=0;i
```
Коря себя за выбор OpenACC, мы все же продолжили работу, так как времени оставалось всего пару дней. В последний день отборочного тура нам наконец-то удалось запустить наш “ускоренный” код. Мы получили замедление в 3.5 раза. Нам ничего не оставалось, кроме как написать в отчете к заданию все, что мы думаем о их реализации OpenACC в цензурной форме. Не смотря на это, мы получили множество позитивных эмоций. Когда еще придется удаленно отлаживать код на самом мощном компьютере в мире?
P.S.: В результате мы все же прошли в финальную часть конкурса и съездили в Китай.
Последним заданием финала была презентация с описанием решений. Лучшего результата добилась местная команда, которая написала свою библиотеку на Си c использованием athread т.к. OpenACC, по их словам, не работает. | https://habr.com/ru/post/340318/ | null | ru | null |
# Mikrotik Router OS, скрипт для динамического деления скорости (Версия 2)
#### Mikrotik Router OS, скрипт для динамического деления скорости (Версия 2)
Это вторая версия, первая лежит тут: [тут.](http://habrahabr.ru/blogs/sysadm/110745/)
На днях встала следующая проблема: делить скорость поровну между всеми пользователями, причем так, чтобы скорость не выделялась на клиентов, которые на данный момент не пользуются интернетом, а отдавалась всем остальным, еще чтобы при большом количестве клиентов и узком канале получить некоторую «буферность» канала.
Исходя из прошлого опыта, был написан совершенно новый скрипт исключающий недостатки прошлого и доработанный для текущих потребностей.
В новой версии стало все значительно проще в плане расположения пользователей, теперь не имеет значения, как подключился пользователь, главное, что у него есть ip адрес и этого нам достаточно.
Итак, поехали…
##### Пример на трех пользователей.
Адреса пользователей 192.168.5.100-192.168.5.102
Добавляем трех пользователей в списки, причем, только тех, кто реально существует. Не нужно забивать целый диапазон, если вы его не используете, т.к. каждая лишняя запись очень сильно отразится на производительности.
`/ip firewall address-list add list="users" address=192.168.5.100
/ip firewall address-list add list="users" address=192.168.5.101
/ip firewall address-list add list="users" address=192.168.5.102`
Чтобы не добавлять списки вручную был наброшен маленький цикл, который позволит ускорить процесс добавления диапазонов. Однократный запуск такого скрипта сделает аналогичные действия, того что мы делали с вами выше.
`#Settings
######################################################
:local start ("100");
:local stop ("102");
:local net ("192.168.5.");
######################################################
######################################################
:global count ($start);
:for count from=$start to=$stop step=1 do={
/ip firewall address-list add list="users" address=( $net . $count);};
######################################################
######################################################
# (C) Inlarion icq 429-587 mikrotik.axiom-pro.ru Copyright!
######################################################`
Вторым шагом является добавление записей в /queue и /ip firewall mangle, опять же чтобы освободить администратора от рутинной работы с добавлением записей вручную, что чревато ошибками т.к. человеческий фактор не дремлет, был набросан небольшой скрипт. Данный скрипт необходимо запускать каждый раз, когда вы добавляете или удаляете записи в /ip firewall address-list list=«users», его основная задача добавлять новые записи и удалять ненужные старые, очевидно, что у нормального системного администратора не должно быть мусора, который забыли удалить. После окончания работы скрипта в системный лог будет записана информация о количестве добавленных и удаленных записей.
`#Settings
######################################################
:local DownloadParent ("Download");
:local UploadParent ("Upload");
######################################################
#Internal Var
######################################################
:local i;
:local z;
:local userX;
:local enum (" ");
:local mark;
:local qrd;
:local qru;
:local mrd;
:local mru;
:local qrdadd;
:local qruadd;
:local mrdadd;
:local mruadd;
:set qrd (0);
:set qru (0);
:set mrd (0);
:set mru (0);
:set qrdadd (0);
:set qruadd (0);
:set mrdadd (0);
:set mruadd (0);
######################################################
######################################################
:log warning ("Rules Manager Started!");
:if ([/queue type find name="dshaper_down"] = "") do={ /queue type add name="dshaper_down" kind="pcq" pcq-classifier=dst-address pcq-rate=0 pcq-limit=50 pcq-total-limit=2000;};
:if ([/queue type find name="dshaper_up"] = "") do={ /queue type add name="dshaper_up" kind="pcq" pcq-classifier=src-address pcq-rate=0 pcq-limit=50 pcq-total-limit=2000;};
:if ([/queue tree find name=$DownloadParent] = "") do={ /queue tree add name=$DownloadParent parent="global-out" queue="dshaper_down" priority=8;};
:if ([/queue tree find name=$UploadParent] = "") do={ /queue tree add name=$UploadParent parent="global-out" queue="dshaper_up" priority=8;};
:foreach i in=[/ip firewall address-list find list="users"] do={ :set userX [/ip firewall address-list get $i address];
:if ([/queue tree find name=($userX . "_down")] = "") do={ /queue tree add name=($userX . "_down") parent=$DownloadParent queue="dshaper_down" packet-mark=($userX . "_down") priority=8; :set qrdadd ($qrdadd+1); };
:if ([/queue tree find name=($userX . "_up")] = "") do={ /queue tree add name=($userX . "_up") parent=$UploadParent queue="dshaper_up" packet-mark=($userX . "_up") priority=8; :set qruadd ($qruadd+1);};
:set enum (" ");
:set enum ([/ip firewall mangle find comment=($userX . "_up")]);
:if ($enum = "") do={ /ip firewall mangle add chain=forward src-address=$userX dst-address=0.0.0.0/0 action=mark-packet new-packet-mark=($userX . "_up") comment=($userX . "_up") disabled=no passthrough=yes; :set mruadd ($mruadd+1);
};
:set enum (" ");
:set enum ([/ip firewall mangle find comment=($userX . "_down")]);
:if ($enum = "") do={ /ip firewall mangle add chain=forward src-address=0.0.0.0/0 dst-address=$userX action=mark-packet new-packet-mark=($userX . "_down") comment=($userX . "_down") disabled=no passthrough=yes; :set mrdadd ($mrdadd+1);
};
};
:foreach z in=[/queue tree find parent=$DownloadParent] do={
:set mark [/queue tree get $z name];
:if ($mark !="") do={
:set mark ([:tostr $mark]);
:set mark ([:pick $mark 0 ([:len $mark]-5)]);
:if ([/ip firewall address-list find address=$mark] = "") do={/queue tree remove [/queue tree find name=($mark . "_down")]; :set qrd ($qrd+1); };};};
:foreach z in=[/queue tree find parent=$UploadParent] do={
:set mark [/queue tree get $z name];
:if ($mark !="") do={
:set mark ([:tostr $mark]);
:set mark ([:pick $mark 0 ([:len $mark]-3)]);
:if ([/ip firewall address-list find address=$mark] = "") do={/queue tree remove [/queue tree find name=($mark . "_up")]; :set qru ($qru+1); };};};
:foreach z in=[/ip firewall mangle find src-address="0.0.0.0/0" action="mark-packet" chain="forward"] do={
:set mark [/ ip firewall mangle get $z comment];
:if ($mark !="") do={
:set mark ([:tostr $mark]);
:set mark ([:pick $mark 0 ([:len $mark]-5)]);
:if ([/ip firewall address-list find address=$mark] = "") do={
:if ([/ip firewall mangle find comment=($mark . "_down")] != "") do={/ip firewall mangle remove [/ip firewall mangle find comment=($mark . "_down")]; :set mrd ($mrd+1); }}}}
:foreach z in=[/ip firewall mangle find dst-address="0.0.0.0/0" action="mark-packet" chain="forward"] do={
:set mark [/ ip firewall mangle get $z comment];
:if ($mark !="") do={
:set mark ([:tostr $mark]);
:set mark ([:pick $mark 0 ([:len $mark]-3)]);
:if ([/ip firewall address-list find address=$mark] = "") do={
:if ([/ip firewall mangle find comment=($mark . "_up")] != "") do={/ip firewall mangle remove [/ ip firewall mangle find comment=($mark . "_up")]; :set mru ($mru+1); }}}}
######################################################
######################################################
:log info ("------------------------------------------");
:log warning ("Rules Manager:");
:log info ("Queue Tree Download Records Added: " . $qrdadd);
:log info ("Queue Tree Upload Records Added: " . $qruadd);
:log info ("Mangle Download Records Added: " . $mrdadd);
:log info ("Mangle Upload Records Added: " . $mruadd);
:log info ("Queue Tree Download Records Deleted: " . $qrd);
:log info ("Queue Tree Upload Records Deleted: " . $qru);
:log info ("Mangle Download Records Deleted: " . $mrd);
:log info ("Mangle Upload Records Deleted: " . $mru);
:log info ("------------------------------------------");
######################################################
######################################################
# (C) Inlarion icq 429-587 mikrotik.axiom-pro.ru Copyright!
######################################################`
##### Теперь скрипт вычислительной и исполнительной части схемы
###### Принцип работы скрипта.
Скрипт определяет, включена ли поддержка ночного времени и проверяет текущее время, согласно диапазону времени выбирает пропускную способность канала.
Скрипт замеряет, с какой скоростью работает клиент и если она превышает ActiveThresholddown, добавляет его как активного на прием.
так же, увеличивает счетчик активных на прием клиентов.
Далее производит проверку ActiveThresholdup, если пользователь превысил эту отметку, то добавляет его как активного на отдачу.
так же, увеличивает счетчик активных на отдачу клиентов.
Рассчитывает:
MaxRateDownload делит на количество активных пользователей на прием, выводит скорость на пользователя.
MaxRateUpload делит на количество активных пользователей на отдачу, выводит скорость на пользователя.
Далее устанавливает лимит всем пользователям в Queue Tree согласно рассчитанной выше схеме.
Далее рассчитывает значение в килобитах и выводит в лог статистику.
###### Переменные в скрипте в самом начале:
MaxRateDownload -Ширина канала на всех пользователей (прием) Бит/сек.
MaxRateUpload -Ширина канала на всех пользователей (отдача) Бит/сек.
MaxRateDownloadNight -Ширина канала на всех пользователей в ночное время (прием) Бит/сек.
MaxRateUploadNight -Ширина канала на всех пользователей в ночное время (отдача) Бит/сек.
ActiveThresholddown -Порог при превышении, которого пользователь будет считаться активным (прием) Бит/сек.
ActiveThresholdup — Порог при превышении, которого пользователь будет считаться активным (отдача) Бит/сек.
usenighttime -может принимать значения «yes» и «no», разрешает скрипту использовать другую ширину канала. В соответствии с ночным тарифом.
nighttimestart -сообщает скрипту начало действия ночного тарифа.
nighttimestop -сообщает скрипту конец действия ночного тарифа.
`#Settings
######################################################
:local MaxRateDownload ("15000000");
:local MaxRateUpload ("15000000");
:local MaxRateDownloadNight ("20000000");
:local MaxRateUploadNight ("20000000");
:local ActiveThresholddown ("15000");
:local ActiveThresholdup ("15000");
:local usenighttime ("yes");
:local nighttimestart ("02:00");
:local nighttimestop ("08:00");
######################################################
#Internal Var
######################################################
:local z;
:local i;
:local ii;
:local userX;
:local timedelay (0);
:local startmin;
:local startsec;
:local stopmin;
:local stopsec;
:local scripttimedelay (0);
:local scriptstartmin;
:local scriptstartsec;
:local scriptstopmin;
:local scriptstopsec;
:local userscount ("0");
:local userstmp ("");
:local firstdowntmp ("");
:local firstuptmp ("");
:local twodowntmp ("");
:local twouptmp ("");
:local activedownuserstmp ("");
:local activeupuserstmp ("");
:local activedowncount ("0");
:local activeupcount ("0");
######################################################
######################################################
:set scriptstartmin ([: pick [/system clock get time] 3 5]);
:set scriptstartsec ([: pick [/system clock get time] 6 8]);
:if ($usenighttime = "yes") do={
:set nighttimestart ([: pick $nighttimestart 0 2] . [: pick $nighttimestart 3 5]);
:set nighttimestop ([: pick $nighttimestop 0 2] . [: pick $nighttimestop 3 5]);
:local currenthours ([: pick [/system clock get time] 0 2]);
:local currenttime ([: pick [/system clock get time] 0 2] . [: pick [/system clock get time] 3 5] );
:local acttime ("day");
:local starttime ("day");
:if ($currenthours < 10) do={ :set acttime ("night"); };
:if ( [: pick $nighttimestart 0 2] < 10) do={ :set starttime ("night"); };
:local night ("no");
:if ($starttime = "night") do={
:if ( $currenttime > $nighttimestart && $currenttime < $nighttimestop) do={ :set night ("yes"); };
};
:if ($starttime = "day") do={
:if ( $acttime = "day") do={
:if ( $currenttime >= $nighttimestart) do={ :set night ("yes"); };
};
:if ( $acttime = "night") do={
:if ( $currenttime < $nighttimestop ) do={ :set night ("yes"); };
};};
:if ($night = "yes") do={
:set MaxRateDownload ($MaxRateDownloadNight);
:set MaxRateUpload ($MaxRateUploadNight);
};
};
:set ActiveThresholddown ($ActiveThresholddown / 8);
:set ActiveThresholdup ($ActiveThresholdup / 8);
:foreach i in=[/ip firewall address-list find list="users"] do={ :set userX [/ip firewall address-list get $i address];
:set userscount ($userscount+1);
:set userstmp ($userstmp . $userX . ",");
};
:local users [:toarray $userstmp];
:set startmin ([: pick [/system clock get time] 3 5]);
:set startsec ([: pick [/system clock get time] 6 8]);
:global dcount ("1");
:for dcount from=1 to=$userscount step=1 do={
:set firstdowntmp ($firstdowntmp . [/ip firewall mangle get [/ip firewall mangle find comment=[:pick $users ($dcount-1)] . "_down"] bytes] . ",");
:set firstuptmp ($firstuptmp . [/ip firewall mangle get [/ip firewall mangle find comment=[:pick $users ($dcount-1)] . "_up"] bytes] . ",");
};
:set stopmin ([: pick [/system clock get time] 3 5]);
:set stopsec ([: pick [/system clock get time] 6 8]);
:global dcount ("1");
:for dcount from=1 to=$userscount step=1 do={
:set twodowntmp ($twodowntmp . [/ip firewall mangle get [/ip firewall mangle find comment=[:pick $users ($dcount-1)] . "_down"] bytes] . ",");
:set twouptmp ($twouptmp . [/ip firewall mangle get [/ip firewall mangle find comment=[:pick $users ($dcount-1)] . "_up"] bytes] . ",");
};
:if ( $stopmin > $startmin) do={
:set timedelay (($stopmin-$startmin) * 60);
};
:set timedelay (($timedelay+$stopsec)-$startsec);
:local firstdown [:toarray $firstdowntmp];
:local firstup [:toarray $firstuptmp];
:local twodown [:toarray $twodowntmp];
:local twoup [:toarray $twouptmp];
:global dcount ("1");
:for dcount from=1 to=$userscount step=1 do={
:if ( ($ActiveThresholddown * $timedelay) < ([:pick $twodown ($dcount-1)] - [:pick $firstdown ($dcount-1)]) ) do={
:set activedownuserstmp ($activedownuserstmp . [:pick $users ($dcount-1)] . ",");
:set activedowncount ($activedowncount+1);
};
:if ( ($ActiveThresholdup * $timedelay) < ([:pick $twoup ($dcount-1)] - [:pick $firstup ($dcount-1)]) ) do={
:set activeupuserstmp ($activeupuserstmp . [:pick $users ($dcount-1)] . ",");
:set activeupcount ($activeupcount+1);
};
};
:local activedownusers [:toarray $activedownuserstmp];
:local activeupusers [:toarray $activeupuserstmp];
:local maxlimitdown ("0");
:local maxlimitup ("0");
:if ( $activedowncount > 0 ) do={
:set maxlimitdown ($MaxRateDownload/$activedowncount);
:global dcount ("1");
:for dcount from=1 to=$activedowncount step=1 do={
:if ([/queue tree get [find name=[:pick $activedownusers ($dcount-1)] . "_down"] max-limit] != $maxlimitdown) do={
/queue tree set [/queue tree find name=[:pick $activedownusers ($dcount-1)] . "_down"] max-limit=$maxlimitdown; };
};
};
:if ( $activeupcount > 0 ) do={
:set maxlimitup ($MaxRateUpload/$activeupcount);
:global dcount ("1");
:for dcount from=1 to=$activeupcount step=1 do={
:if ([/queue tree get [find name=[:pick $activeupusers ($dcount-1)] . "_up"] max-limit] != $maxlimitup) do={
/queue tree set [/queue tree find name=[:pick $activeupusers ($dcount-1)] . "_up"] max-limit=$maxlimitup; };
};
};
:local kbsmaxdown ($MaxRateDownload/1000);
:local kbsmaxup ($MaxRateUpload /1000);
:if ( $maxlimitdown = 0 ) do={ :set maxlimitdown ($MaxRateDownload); };
:if ( $maxlimitup = 0 ) do={ :set maxlimitup ($MaxRateUpload); };
:local kbsmaxlimitdown ($maxlimitdown/1024);
:local kbsmaxlimitup ($maxlimitup/1024);
:set scriptstopmin ([: pick [/system clock get time] 3 5]);
:set scriptstopsec ([: pick [/system clock get time] 6 8]);
:if ( $scriptstopmin > $scriptstartmin) do={
:set scripttimedelay (($scriptstopmin-$scriptstartmin) * 60);
};
:set scripttimedelay (($scripttimedelay+$scriptstopsec)-$scriptstartsec);
######################################################
######################################################
:log info ("------------------------------------------");
:log warning ("Shaper:");
:log info ("MaxRate Download : " . $MaxRateDownload . " bps /" . $kbsmaxdown . " kbs / Upload : " . $MaxRateUpload . " bps /" . $kbsmaxup . " kbs");
:log info ("Active Users : Download : " . $activedowncount . " / Upload : " . $activeupcount );
:log info ("User Speed Download : " . $maxlimitdown . " bps /" . $kbsmaxlimitdown . " kbs / Upload : " . $maxlimitdown . " bps /" . $kbsmaxlimitup . " kbs" );
:log warning ("Performance Time: " . $scripttimedelay . " seconds.");
:log info ("------------------------------------------");
######################################################
######################################################
# (C) Inlarion icq 429-587 mikrotik.axiom-pro.ru Copyright!
######################################################`
##### Что касается последних пожеланий
В данной версии можно заметить добавление новой строки в системном логе «Performance Time», данная строка позволяет правильно установить интервал выполнения скрипта в планировщике. «Performance Time» отражает время выполнения скрипта в секундах с точностью +-1сек. Данное время резко увеличивается с количеством клиентов добавленных в /ip firewall address-list list=«users», нагрузкой на ваш микротик и неправильно выставленным интервалом выполнения скрипта, так что данный параметр необходимо постоянно контролировать.
Интервал выполнения скрипта устанавливайте исходя из формулы: Performance Time + 10-15 сек. При первом запуске скрипта установите интервал равный 1-2 минутам, в идеальном случае если система будет максимально загружена в этот момент.
###### Параметры скрипта:
`:local MaxRateDownload ("15000000");
:local MaxRateUpload ("15000000");
:local MaxRateDownloadNight ("20000000");
:local MaxRateUploadNight ("20000000");`
Следует устанавливать чуть меньше чем ширина вашего канала, дабы избежать тормозов при активности еще одного пользователя, который до этого не потреблял интернет.
`:local ActiveThresholddown ("15000");
:local ActiveThresholdup ("15000");`
Эти значения устанавливайте согласно своим потребностям, но исходя из расчета: кол-во пользователей умноженное на Thresholddown = не дожно превышать MaxRateDownload иначе ваши пользователи будут всегда не активными! Естественно users\*ActiveThresholdup = не должно превышать MaxRateUpload. Всегда оставляйте некоторый запас.
В дополнение ко всему хочу отметить то, что вопрос нецелесообразности применения скрипта в версиях 5.x закрыт, т.к. после тестирования версии 5.0rc7 я действительно убедился, что /queue в микротик стали работать значительно лучше по сравнению с более ранними версиями, поэтому в версиях 5.х скрипт не нужен. Но вопрос перехода на пятую версию весьма сомнителен, ввиду тех багов, которые допускают разработчики. К примеру, в rc3 коряво работает утилита ping и не возвращает параметры, в rc7 не работает маршрутизация при использовании имен в таблице, хотя в ранних версиях все работает на ура. Но это всего лишь RC, хотя уже седьмая по счету и это очень сильно беспокоит.
Даже если вам не понадобится основная часть, но вы используете /queue tree, можно просто использовать скрипт для создания правил, очень удобная штука при добавлении/удалении пользователей. | https://habr.com/ru/post/111745/ | null | ru | null |
# Визуальный сахар для ActiveRecord
Каждый, кто разрабатывал приложение на RoR знает, что в консоли (./script/console) не слишком удобно просматривать ActiveRecord объекты, они имеют мягко говоря не читабельный вид
Например в моем последнем проекте есть модель Schema
> `# == Schema Information`
>
>
Соответсвенно, когда я в консоли выполняю поиск по объектам, то в ответ получаю «кашу»:
> `>> Schema.find(:all, :limit => 3)
>
> => [#, #, #]`
>
>
Можно конечно сделать
> `>> pp Schema.find(:all, :limit => 3)
>
> [#,
>
> #,
>
> #]`
>
>
или же преобразовать в YAML:
> `>> puts Schema.find(:all, :limit => 3).to_yaml`
признаться — меня и это не особо возбуждает…
Но на днях я подсмотрел у Ryan'а на [Railscasts](http://railscasts.com/), обалденное отображение табличек:
потратив пару часов на поиск, я нашел gem который отображает массивы объектов как таблицы.
Им оказался [Hirb](http://tagaholic.me/hirb/).
устанавливается он стандартно:
> `sudo gem install hirb`
>
>
Активируется через:
> `$ ./script/console
>
> Loading development environment (Rails 2.3.5)
>
> irb>> require 'hirb'
>
> => true
>
> irb>> Hirb.enable
>
> => nil`
>
>
Согласитесь, выглядит гораздо приятней:
[](https://habrastorage.org/getpro/habr/post_images/940/211/b09/940211b09be9a7cef34141fc454c7bb0.png)
а для того, чтобы сделать это отображение по умолчанию, добавляем в ~/.irbrc
> `**if** ENV['RAILS\_ENV']`
>
>
отключить можем в любой момент, набрав
> `>> Hirb.disable`
>
>
при больших объемах данных вывод передается в $PAGER, что согласитесь тоже удобно | https://habr.com/ru/post/78732/ | null | ru | null |
# Xcode 11 и XCFrameworks: новый формат упаковки фреймворков
В жизни многих компаний, которые имеют и развивают свой стек библиотек и компонентов, наступает момент, когда объёмы этого стека становится сложно поддерживать.
В случае разработки под платформу iOS, да и в целом, экосистему Apple, есть два варианта подключать библиотеки в качестве зависимостей:
1. Собирать их каждый раз при сборке приложения.
2. Собирать их заранее, используя уже собранные зависимости.
При выборе второго подхода становится логичным использовать CI/CD системы для сборки библиотек в готовые к употреблению артефакты.
Однако, необходимость собирать библиотеки под несколько платформ или архитектур процессора в экосистеме Apple, зачастую, требует проводить не всегда тривиальные операции, как при сборке библиотеки, так и конечного продукта, который её использует.
На этом фоне, было сложно не заметить и крайне интересно изучить, одно из нововведений от Apple, представленное на WWDC 2019 в рамках презентации [Binary Frameworks in Swift](https://developer.apple.com/videos/play/wwdc2019/416/) — формат упаковки фреймворков — XCFramework.
XCFramework имеет несколько преимуществ, в сравнении с устоявшимися подходами:
1. Упаковка зависимостей под все целевые платформы и архитектуры в единый bundle из коробки.
2. Подключение bundle в формате XCFramework, как единой зависимости для всех целевых платформ и архитектур.
3. Отсутствие необходимости в сборке fat/universal фреймворка.
4. Нет необходимости избавляться от x86\_64 слайсов (slice) перед загрузкой конечных приложений в AppStore.
В этой статье мы расскажем, зачем был внедрён этот новый формат, что он из себя представляет, а также, что он даёт разработчику.
Как появился новый формат
=========================
Ранее компанией Apple был выпущен менеджер зависимостей [Swift Package Manager](https://github.com/apple/swift-package-manager).
Суть в том, что Swift PM позволяет выполнять поставку библиотек в форме открытого исходного кода с описанием зависимостей.
С позиции разработчика, поставляющего библиотеку, хотелось бы выделить два аспекта Swift PM.
* Очевидный минус — по тем или иным причинам, не все поставщики библиотек хотели бы открывать их исходный код потребителям.
* Очевидный плюс — при компиляции зависимостей из исходников мы избавляемся от необходимости соблюдать бинарную совместимость библиотек.
XCFramework Apple предлагает, как новый бинарный формат упаковки библиотек, рассматривая его как альтернативу Swift Packages.
Этот формат, как и возможность подключения собранной в XCFramework библиотеки, доступен, начиная с Xcode 11 и его beta-версий.
Что из себя представляет XCFramework
====================================
По своей сути, XCFramework — новый способ упаковки и поставки библиотек, в их различных вариантах.
Кроме прочего, новый формат также позволяет производить и упаковку статических библиотек вместе с их заголовочными файлами, в том числе и написанных на С/Objective-C.
Рассмотрим формат несколько подробнее.
1. **Упаковка зависимостей под все целевые платформы и архитектуры в единый bundle из коробки**
Все сборки библиотеки под каждую из целевых платформ и архитектур теперь могут быть упакованы в единый bundle с расширением .xcframework.
Однако, для этого, на данный момент времени, приходится использовать скрипты для вызова команды `xcodebuild` с новым для Xcode 11 ключом `-create-xcframework`.
Процесс сборки и упаковки рассмотрим далее.
2. **Подключение bundle в формате XCFramework, как единой зависимости для всех целевых платформ и архитектур**
Поскольку bundle .xcframework содержит все необходимые варианты сборки зависимости, нам не нужно заботиться о его архитектуре и целевой платформе.
В Xcode 11 библиотека, упакованная в .xcframework подключается точно также, как и обычный .framework.
Говоря конкретнее, этого можно добиться следующими способами в настройках target’а:
* добавляя .xcframework в раздел «Frameworks And Libraries» на вкладке «General»
* добавляя .xcframework в «Link Binary With Libraries» на вкладке «Build Phases»
3. **Отсутствие необходимости в сборке fat/universal фреймворка**
Ранее для поддержки в подключаемой библиотеке нескольких платформ и нескольких архитектур приходилось подготавливать так называемые fat или universal фреймворки.
Производилось это с помощью команды `lipo` для сшития всех вариантов собранного фреймворка в единый толстый бинарник.
Подробнее с этим можно ознакомиться, к примеру, в следующих статьях:
* [Как собрать собственный фреймворк для iOS](https://habr.com/ru/company/sebbia/blog/246247/) (habr.ru)
* [Writing Custom Universal Framework in Xcode 10.2 and iOS 12](https://medium.com/allatoneplace/writing-custom-universal-framework-in-xcode-9-and-ios-11-7a63a2ce024a) (medium.com)
4. **Нет необходимости избавляться от x86\_64 слайсов (slice) перед загрузкой конечных приложений в AppStore**
Обычно такой слайс используется для обеспечения работы библиотек в симуляторе iOS.
При попытке загрузить приложение с зависимостями, содержащими x86\_64 слайс в AppStore можно столкнуться с небезызвестной ошибкой [ITMS-90087](http://www.openradar.me/radar?id=6409498411401216).
Создание и упаковка XCFramework: теория
=======================================
В упомянутой ранее [презентации](https://developer.apple.com/videos/play/wwdc2019/416/), описаны несколько шагов, которые требуются для сборки и упаковки библиотеки в формате XCFramework:
1. **Подготовка проекта**
Для начала во всех target’ах проекта, которые отвечают за сборку библиотеки под целевые платформы, нужно включить новую для Xcode 11 настройку — «Build Libraries for Distribution».
2. **Сборка проекта под целевые платформы и архитектуры**
Далее нам предстоит собрать все таргеты под целевые платформы и архитектуры.
Рассмотрим примеры вызова команд на примере определённой конфигурации проекта.
Допустим, что в проекте у нас есть две схемы «XCFrameworkExample-iOS» и «XCFramework-macOS».
Также в проекте есть два target’а, которые собирают библиотеку под iOS и под macOS.
Для сборки всех требуемых конфигураций библиотеки нам потребуется собрать оба target’а, используя соответствующие им схемы.
Однако, для iOS нам потребуется две сборки: одна под конечные устройства (ARM), а другая под симулятор (x86\_64).
Итого нам потребуется собрать 3 фреймворка.
Для этого можно воспользоваться командой `xcodebuild`:
```
# iOS devices
xcodebuild archive \
-scheme XCFrameworkExample-iOS \
-archivePath "./build/ios.xcarchive" \
-sdk iphoneos \
SKIP_INSTALL=NO
# iOS simulator
xcodebuild archive \
-scheme XCFrameworkExample-iOS \
-archivePath "./build/ios_sim.xcarchive" \
-sdk iphonesimulator \
SKIP_INSTALL=NO
# macOS
xcodebuild archive \
-scheme XCFrameworkExample-macOS \
-archivePath "./build/macos.xcarchive" \
SKIP_INSTALL=NO
```
В итоге у нас получилось 3 собранных фреймворка, которые далее мы будем упаковывать в контейнер .xcframework.
3. **Упаковка собранных .framework в .xcframework**
Сделать это можно следующей командой:
```
xcodebuild -create-xcframework \
-framework "./build/ios.xcarchive/Products/Library/Frameworks/XCFrameworkExample.framework" \
-framework "./build/ios_sim.xcarchive/Products/Library/Frameworks/XCFrameworkExample.framework" \
-framework "./build/macos.xcarchive/Products/Library/Frameworks/XCFrameworkExample.framework" \
-output "./build/XCFrameworkExample.xcframework"
```
Здесь может быть множество указаний параметра `-framework`, которые указывают на все сборки .framework, которые требуется вложить в контейнер .xcframework.
Подготовка проекта библиотеки для будущей сборки и упаковки XCFramework
=======================================================================
**TL;DR: готовый проект можно скачать [в репозитории на Github](https://github.com/dreadct/XCFrameworkExample).**
В качестве примера реализуем библиотеку, которая будет доступна под две платформы: iOS и macOS.
Воспользуемся упомянутой в предыдущем разделе статьи конфигурацией проекта: две схемы и два соответствующих им Framework target’а для платформ iOS и macOS.
Сама же библиотека будет предоставлять нам простенький extension для `String?` (`Optional where Wrapped == String`), с единственным свойством.
Назовём это свойство `isNilOrEmpty` и, как следует из названия, оно позволит нам узнать, когда внутри `String?` отсутствует значение или хранимая внутри строка является пустой.
Код можно реализовать следующим образом:
```
public extension Optional where Wrapped == String {
var isNilOrEmpty: Bool {
if case let .some(string) = self {
return string.isEmpty
}
return true
}
}
```
Приступим непосредственно к созданию и конфигурации проекта.
1. **Для начала нам нужно создать проект типа «Framework» под одну из двух целевых платформ на ваш выбор: iOS или macOS.**
Сделать это в Xcode можно через пункт меню «File» => «New» => «Project», либо сочетанием клавиш **⇧ + ⌘ + N** (по умолчанию).
Далее наверху диалога выбираем нужную платформу (iOS или macOS), выбираем тип проекта Framework и переходим далее по кнопке «Next».
На следующем экране нам нужно задать имя проекта в поле «Product Name».
Как вариант можно использовать «базовое» имя проекта, в упомянутой ранее конфигурации это «XCFrameworkExample».
В дальнейшем, при конфигурации проекта к базовому имени, использованному в имени target’ов мы добавим суффиксы, обозначающие платформы.
2. **После этого требуется создать ещё один Target типа «Framework» в проекте под другую из перечисленных платформ (кроме той, под которую проект был создан изначально).**
Для этого можно воспользоваться пунктом меню «File» => «New» => «Target».
Далее выбираем в диалоге другую (относительно выбранной в пункте 1) из двух платформ, после чего снова выбираем тип проекта «Framework».
Для поля «Product Name» мы можем сразу использовать название с суффиксом платформы, для которой мы в данном пункте добавляем target. Так, если платформа — это macOS, то имя может быть «XCFrameworkExample-macOS» (%base\_name%-%platform%).
3. **Настроим таргеты и схемы, чтобы их было проще отличать.**
Для начала переименуем наши схемы и привязанные к ним target’ы таким образом, чтобы их имена отображали платформы, например так:
* «XCFrameworkExample-iOS»
* «XCFrameworkExample-macOS»
4. **Далее добавляем в проект .swift файл с кодом нашего extension’а для `String?`**
Добавим в проект новый .swift файл с именем «Optional.swift».
И в сам файл помещаем ранее упомянутый extension для `Optional`.
Важно не забыть добавить файл с кодом к обеим target’ам.
Теперь у нас есть проект, который мы можем собрать в XCFramework используя команды из предыдущего этапа.
Процесс сборки и упаковки библиотеки в формат .xcframework
==========================================================
Для сборки библиотеки и упаковки её в формат .xcframework на данном этапе можно воспользоваться bash-скриптом в отдельном файле. К тому же, это позволит в будущем использовать эти наработки для интеграции решения в CI/CD системы.
Скрипт выглядит до безобразия просто и, по факту, сводит воедино ранее упомянутые команды для сборки:
```
#!/bin/sh
# ----------------------------------
# BUILD PLATFORM SPECIFIC FRAMEWORKS
# ----------------------------------
# iOS devices
xcodebuild archive \
-scheme XCFrameworkExample-iOS \
-archivePath "./build/ios.xcarchive" \
-sdk iphoneos \
SKIP_INSTALL=NO
# iOS simulator
xcodebuild archive \
-scheme XCFrameworkExample-iOS \
-archivePath "./build/ios_sim.xcarchive" \
-sdk iphonesimulator \
SKIP_INSTALL=NO
# macOS
xcodebuild archive \
-scheme XCFrameworkExample-macOS \
-archivePath "./build/macos.xcarchive" \
SKIP_INSTALL=NO
# -------------------
# PACKAGE XCFRAMEWORK
# -------------------
xcodebuild -create-xcframework \
-framework "./build/ios.xcarchive/Products/Library/Frameworks/XCFrameworkExample.framework" \
-framework "./build/ios_sim.xcarchive/Products/Library/Frameworks/XCFrameworkExample.framework" \
-framework "./build/macos.xcarchive/Products/Library/Frameworks/XCFrameworkExample.framework" \
-output "./build/XCFrameworkExample.xcframework"
```
Содержимое .xcframework
=======================
В результате работы скрипта cборки из предыдущего пункта статьи, мы получаем заветный bundle .xcframework, который можно добавлять в проект.
Если мы заглянем внутрь этого bundle, который, как и .framework, является по сути простой папкой, то увидим следующую структуру:
Здесь мы видим, что внутри .xcframework лежат сборки в формате .framework, разбитые по платформам и архитектурам. Также для описания содержимого bundle .xcframework, внутри имеется файл Info.plist.
**Файл Info.plist имеет следующее содержание**
```
xml version="1.0" encoding="UTF-8"?
AvailableLibraries
LibraryIdentifier
ios-arm64
LibraryPath
XCFrameworkExample.framework
SupportedArchitectures
arm64
SupportedPlatform
ios
LibraryIdentifier
ios-x86\_64-simulator
LibraryPath
XCFrameworkExample.framework
SupportedArchitectures
x86\_64
SupportedPlatform
ios
SupportedPlatformVariant
simulator
LibraryIdentifier
macos-x86\_64
LibraryPath
XCFrameworkExample.framework
SupportedArchitectures
x86\_64
SupportedPlatform
macos
CFBundlePackageType
XFWK
XCFrameworkFormatVersion
1.0
```
Можно заметить, что для ключа «CFBundlePackageType», в отличии от формата .framework используется новое значение «XFWK», а не «FMWK».
Итоги
=====
Итак, формат упаковки библиотек в XCFramework есть ни что иное, как обычный контейнер для библиотек собираемых в формате .framework.
Однако, такой формат позволяет отдельно хранить и независимо использовать каждую из архитектур и платформ, представленных внутри. Это избавляет от ряда проблем, присущих широко распространённому подходу со сборкой fat/universal фреймворков.
Как бы то ни было, на данный момент, есть немаловажный нюанс, касающийся вопроса использования XCFramework в реальных проектах — управление зависимостями, которое в формате XCFramework компанией Apple не реализовано.
Для этих целей привычно используются Swift PM, Carthage, CocoaPods и прочие системы управления зависимостями и их сборки. Поэтому неудивительно, что поддержка нового формата уже находится на стадии реализации именно в проектах [CocoaPods](https://github.com/CocoaPods/CocoaPods/issues/9148) и [Carthage](https://github.com/Carthage/Carthage/issues/2890). | https://habr.com/ru/post/475816/ | null | ru | null |
# Как адаптировать UX/UI под permissions
Во многих проектах существует процессы аутентификации (в той или иной степени). Написано много “бест практис” во всех известных технологиях и т.д. и т.п.
Но вот пользователь сделал логин и? Ведь он далеко не всё может сделать. Как определить что он может видеть, а что нет. На какие кнопки имеет право нажимать, что может менять, что создавать или удалять.
В этой статье я хочу рассмотреть подход к решению этих проблем на веб аппликации.
Начнем с того, что настоящая/действенная авторизация может происходить только на сервере. На Front End мы можем только улучшить пользовательский интерфейс (хм, Русский язык могуч, но не всегда...), он же User Experience дальше UX. Мы можем скрыть кнопки на которые у пользователя нет прав нажимать, или не допустить его до страницы, или показать сообщение о том, что у него нет прав на то или иное действие.
И вот тут возникает вопрос, как сделать это максимально правильно.
Начнем с определения проблемы.
Мы создали Todo App и у нее есть разные виды пользователей:
**USER** — может видеть все таски и изменять их (ставить и убирать V), но не может удалять или создавать и не видит статистику.
**ADMIN** — может видеть все таски и создавать новые, но не видит статистику.
**SUPER\_ADMIN** — может видеть все таски, создавать новые и удалять, также может видеть статистику.
| | view task | Create task | check/uncheck task (update) | delete task | view stats |
| --- | --- | --- | --- | --- | --- |
| USER | V | X | V | X | X |
| ADMIN | V | V | V | X | X |
| SUPER\_ADMIN | V | V | V | V | V |
В такой ситуации мы можем легко обойтись ролями “roles”. Однако, ситуация может сильно измениться. Представим, что есть пользователь, который должен иметь те же права что и **ADMIN** плюс удаление тасков. Или же просто **USER** с возможностью видеть статистику.
Простое решение, это создать новые роли.
Но на больших системах, с относительно большим количеством пользователей мы быстро потеряемся в огромном количестве ролей… И тут мы вспомним о “правах пользователя” *permissions*. Для более упрощенного управления мы можем создавать группы из нескольких permissions и присоединять их к пользователю. Всегда остается возможность добавить специфический permission конкретному пользователю.
Подобные решения можно встретить во многих больших сервисах. AWS, Google Cloud, SalesForce и т.д.
Также подобные решения уже имплементированы во многих фреймворках, например Django (python).
Я хочу привести пример имплементации для Angular аппликаций. (На примере все той же ToDo App).
Для начала необходимо определить все возможные permissions.
Разделим на фичеры
1. У нас есть таски и статистика.
2. Определим возможные действия с каждым из них.
* Таск: create, read, update, delete
* Статистика: read (в нашем примере только просмотр)
3. Создадим карту (MAP) ролей и пермишнс
```
export const permissionsMap = {
todos:{
create:'*',
read:'*',
update:'*',
delete:'*'
},
stats:'*'
}
```
На мой взгляд это оптимальный вариант, однако в большинстве случаев сервер будет возвращать нечто вроде этого:
```
export permissions = [
'todos_create',
'todos_read',
'todos_update',
'todos_delete',
'stas'
]
```
Менее читабельно, но тоже очень неплохо.
Вот так выглядит наша аппликация при наличии у пользователя всех возможных permissions.
Начнем с USER, так выглядит его permissions:
```
export const USERpermissionsMap = {
todos:{
read:'*',
update:'*',
}
}
```
1) USER не может видеть статистику, то есть он в принципе не может перейти страницу статистики.
Для подобных ситуаций в Angular есть Guards, которые прописываются на уровне Routes ([документация](https://angular.io/guide/router)).
В нашем случае это выглядит так:
```
const routes: Routes = [
// {...Other routes},
{
path: 'stats',
component: TodoStatisticsComponent,
canActivate: [
PermissionsGuardService
],
data: {
permission: 'stats'
},
}
];
```
Следует обратить внимание на объект в data.
peremissions = ‘stats’, это именно те permissions которые необходимо иметь пользователю, чтобы иметь доступ к этой странице.
Основываясь на требуемых data.permissions и тех permissions которые нам передал сервер PermissionsGuardService будет решать пускать или нет USER на страницу ‘/stats’.
```
@Injectable({
providedIn: 'root'
})
export class PermissionsGuardService implements CanActivate {
constructor(
private store: Store) {
}
canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable | boolean {
// Required permission to continue navigation
const required = route.data.permission;
// User permissions that we got from server
const userPerms = this.getPermissions();
// verification
const isPermitted = checkPermissions(required, userPerms);
if (!isPermitted) {
alert('ROUTE GUARD SAYS: \n You don\'t have permissions to see this page');
}
return isPermitted;
}
getPermissions() {
return localStorage.get('userPermissions')
}
}
```
Эта функция содержит логику принятия решения, — сущестует ли неободимый permission (required) среди всех permissions находящихся у USER (userPerms).
```
export function checkPermissions(required: string, userPerms) {
// 1) Separate feature and action
const [feature, action] = required.split('_');
// 2) Check if user have any type of access to the feature
if (!userPerms.hasOwnProperty(feature)) {
return false;
}
// 3) Check if user have permission for required action
if (!userPerms[feature].hasOwnProperty(action)) {
return false;
}
return true;
}
```
И так. Наш USER не может попасть на страницу статистики. Однако он все еще может создавать таски и удалять их.
Для того чтобы USER не мог удалить таск, достаточно будет убрать красный (Х) из строки таска.
Для этой цели воспользуемся [Structural Directive](https://angular.io/guide/structural-directives).
```
X
```
```
@Directive({
selector: '[appPermissions]'
})
export class PermissionsDirective {
private _required: string;
private _viewRef: EmbeddedViewRef | null = null;
private \_templateRef: TemplateRef | null = null;
@Input()
set appPermissions(permission: string) {
this.\_required = permission;
this.\_viewRef = null;
this.init();
}
constructor(private templateRef: TemplateRef,
private viewContainerRef: ViewContainerRef) {
this.\_templateRef = templateRef;
}
init() {
const isPermitted = checkPermissions(this.\_required, this.getPermissions());
if (isPermitted) {
this.\_viewRef = this.viewContainerRef.createEmbeddedView(this.templateRef);
} else {
console.log('PERMISSIONS DIRECTIVE says \n You don\'t have permissions to see it');
}
}
getPermissions() {
localStorage.get('userPermissions')
}
}
```
Теперь USER не видит кнопки DELETE но все еще может добавлять новые таски.
Убрать поле ввода — испортит весь вид нашей аппликации. Правильным решением в данной ситуации будет `disable` поля ввода.
Воспользуемся pipe.
```
```
```
@Pipe({
name: 'permissions'
})
export class PermissionsPipe implements PipeTransform {
constructor(private store: Store) {
}
transform(required: any, args?: any): any {
const isPermitted = checkPermissions(required, this.getPermissions());
if (isPermitted) {
return true;
} else {
console.log('[PERMISSIONS PIPE] You don\'t have permissions');
return false;
}
}
getPermissions() {
return localStorage.get('userPermissions')
}
}
```
И вот теперь USER может только видеть таски и изменять их (V/X). Однако у нас осталась еще одна кнопка ‘Clear completed’.
Предположим, что у нас следующие требования Продук Менеджера:
1. Кнопка ‘Clear Completed’ должна быть видна всем и всегда.
2. Oна также должна быть кликабельна.
3. В случае если USER без соответствующих пермишн нажимает на кнопку, должно появится сообщение.
Constructional directive нам не поможет, также как и pipe.
Прописывать в функции компоненты проверку на permissions тоже не очень удобно.
Все что нам необходимо, — это между кликом и выполнением привязанной функции произвести проверку permissions.
На мой взгляд здесь стоит воспользоваться декораторами.
```
export function Permissions(required) {
return (classProto, propertyKey, descriptor) => {
const originalFunction = descriptor.value;
descriptor.value = function (...args: any[]) {
const userPerms = localStorage.get('userPermissions')
const isPermitted = checkPermissions(required, userPerms);
if (isPermitted) {
originalFunction.apply(this, args);
} else {
alert('you have no permissions \n [PERMISSIONS DECORATOR]');
}
};
return descriptor;
};
}
```
```
@Component({
selector: 'app-actions',
templateUrl: './actions.component.html',
styleUrls: ['./actions.component.css']
})
export class ActionsComponent implements OnInit {
@Output() deleteCompleted = new EventEmitter();
constructor() {
}
@Permissions('todos_delete')
public deleteCompleted() {
this.deleteCompleted.emit();
}
}
```
Дикораторы заслуживают отдельной статьи.
Наш финальный результат:
Итог:
Данный подход позволяет легко и динамично адаптировать наш UX в соответствии с permissions которые есть у пользователя.
А главное, нам для этого не надо пихать сервисы во все компоненты или забивать темплейты ‘\*ngIf’.
[Вся аппликация целиком](https://github.com/danduh/ngx-to-do-permissions).
Буду рад комментариям. | https://habr.com/ru/post/439100/ | null | ru | null |
# Распределенный реестр для колесных пар: опыт с Hyperledger Fabric
Привет, я работаю в команде проекта РРД КП (распределенный реестр данных для контроля жизненного цикла колесных пар). Здесь я хочу поделиться опытом нашей команды в разработке корпоративного блокчейна для данного проекта в условиях ограничений, накладываемых технологией. По большей части я буду говорить о Hyperledger Fabric, но описанный здесь подход может быть экстраполирован на любой permissioned блокчейн. Конечная цель наших изысканий — готовить корпоративные блокчейн-решения так, чтобы итоговым продуктом было приятно пользоваться и не слишком тяжело поддерживать.
Здесь не будет никаких открытий, неожиданных решений и здесь не будут освещаться никакие уникальные разработки (потому что их у меня нет). Я просто хочу поделиться своим скромным опытом, показать, что «так можно было» и, возможно, прочитать о чужом опыте принятия хороших и не очень решений в комментариях.
### Проблема: блокчейны пока что не масштабируются
Сегодня усилия многих разработчиков направлены на то, чтобы сделать блокчейн действительно удобной технологией, а не бомбой замедленного действия в красивой обертке. Каналы состояний, optimistic rollup, plasma и шардинг, возможно, станут повседневностью. Когда-нибудь. А возможно, TON снова отложит запуск на полгода, а очередная Plasma Group прекратит своё существование. Мы можем верить в очередной roadmap и читать на ночь блестящие white papers, но здесь и сейчас нужно что-то делать с тем, что мы имеем. Get shit done.
Задача, поставленная перед нашей командой в текущем проекте, выглядит в общем виде так: есть множество субъектов, достигающее нескольких тысяч, не желающее строить отношения на доверии; необходимо построить на DLT такое решение, которое будет работать на обычных ПК без специальных требований к производительности и обеспечивать пользовательский опыт не хуже любых централизованных систем учета. Технология, лежащая в основе решения, должна свести к минимуму возможность злонамеренных манипуляций с данными — именно поэтому здесь блокчейн.
Лозунги из whitepapers и СМИ обещают нам, что очередная разработка позволит совершать миллионы транзакций в секунду. Что же на самом деле?
Mainnet Ethereum сейчас работает со скоростью ~30 tps. Уже только из-за этого его сложно воспринимать как сколько-нибудь пригодный для корпоративных нужд блокчейн. Среди permissioned-решений известны бенчмарки, показывающие 2000 tps ([Quorum](https://www.researchgate.net/publication/327570196_Performance_Evaluation_of_the_Quorum_Blockchain_Platform)) или 3000 tps ([Hyperledger Fabric](https://arxiv.org/pdf/1805.11390.pdf), в публикации чуть меньше, но нужно учитывать, что бенчмарк проводился на старом consensus engine). Была [попытка радикальной переработки Fabric](https://arxiv.org/pdf/1901.00910.pdf), давшая не самые плохие результаты, 20000 tps, но пока это лишь академические изыскания, ждущие своей стабильной имплементации. Вряд ли корпорация, которая может себе позволить содержать отдел блокчейн-разработчиков, будет мириться с такими показателями. Но проблема не только в throughput, есть ещё latency.
### Latency
Задержка от момента инициации транзакции до её окончательного утверждения системой зависит не только от скорости прохождения сообщения через все этапы валидаций и упорядочивания, но и от параметров формирования блока. Даже если наш блокчейн позволяет нам коммитить со скоростью 1000000 tps, но требует при этом 10 минут на формирование блока размером 488 Мб, станет ли нам легче?
Давайте посмотрим поближе на жизненный цикл транзакции в Hyperledger Fabric, чтобы понять, на что уходит время и как это соотносится с параметрами формирования блока.
*взято отсюда*: [hyperledger-fabric.readthedocs.io/en/release-1.4/arch-deep-dive.html#swimlane](https://hyperledger-fabric.readthedocs.io/en/release-1.4/arch-deep-dive.html#swimlane)
(1) Клиент формирует транзакцию, отправляет на endorsing peers, последние симулируют транзакцию (применяют изменения, вносимые чейнкодом, на текущее состояние, но не коммитят в леджер) и получают RWSet — имена ключей, версии и значения, взятые из коллекции в CouchDB, (2) endorsers отправляют обратно клиенту подписанный RWSet, (3) клиент либо проверяет наличие подписей всех необходимых пиров (endorsers), а потом отправляет транзакцию на ordering service, либо отправляет без проверки (проверка все равно состоится позже), ordering service формирует блок и (4) отправляет обратно на все пиры, не только endorsers; пиры проверяют соответствие версий ключей в read set версиям в базе данных, наличие подписей всех endorsers и наконец коммитят блок.
Но это ещё не всё. За словами «ордерер формирует блок» скрывается не только упорядочивание транзакций, но и 3 последовательных сетевых запроса от лидера к фолловерам и обратно: лидер добавляет сообщение в лог, отправляет фолловерам, последние добавляют в свой лог, отправляют подтверждение успешной репликации лидеру, лидер коммитит сообщение, отправляет подтверждение коммита фолловерам, фолловеры коммитят. **Чем меньше размер и время формирования блока, тем чаще придется ordering service устанавливать консенсус**. В Hyperledger Fabric есть два параметра формирования блока: BatchTimeout — время формирования блока и BatchSize — размер блока (количество транзакций и размер самого блока в байтах). Как только один из параметров достигает лимита, выпускается новый блок. Чем больше нод ордереров, тем дольше это будет происходить. Следовательно, нужно увеличивать BatchTimeout и BatchSize. Но поскольку RWSet'ы версионируются, то чем больше мы сделаем блок, тем выше вероятность MVCC-конфликтов. К тому же, с увеличением BatchTimeout катастрофически деградирует UX. Мне кажется разумной и очевидной следующая схема для решения этих проблем.
### Как избежать ожидания финализации блока и не потерять возможности отслеживания статуса транзакции
Чем больше время формирования и размер блока, тем выше пропускная способность блокчейна. Одно из другого прямо не следует, однако следует вспомнить, что установление консенсуса в RAFT требует трех сетевых запросов от лидера к фолловерам и обратно. Чем больше нод ордеров, тем дольше это будет происходить. Чем меньше размер и время формирования блока, тем больше таких интеракций. Как увеличивать время формирования и размер блока, не увеличивая время ожидания ответа системы для конечного пользователя?
Во-первых, нужно как-то решать MVCC-конфликты, вызванные большим размером блока, который может включать разные RWSet'ы с одной и той же версией. Очевидно, на стороне клиента (по отношению к блокчейн-сети, это вполне может быть бекенд, и я имею в виду именно его) нужен **хендлер MVCC-конфликтов**, который может быть как отдельным сервисом, так и обычным декоратором над инициирующем транзакцию вызовом с логикой retry.
Retry можно реализовать с экспоненциальной стратегией, но тогда latency будет деградировать так же экспоненциально. Так что следует использовать либо рандомизированный в определенных небольших пределах retry, либо постоянный. С оглядкой на возможные коллизии в первом варианте.
Следующий этап — сделать взаимодействие клиента с системой асинхронным, чтобы он не ждал 15, 30 или 10000000 секунд, которые мы установим в качестве BatchTimeout. Но при этом нужно сохранить возможность удостовериться в том, что изменения, инициированные транзакцией, записаны/не записаны в блокчейн.
Для хранения статуса транзакций можно использовать базу данных. Самый простой вариант — CouchDB из-за удобства использования: у базы есть UI из коробки, REST API, для неё легко можно настроить репликацию и шардирование. Можно создать просто отдельную коллекцию в том же инстансе CouchDB, который использует Fabric для хранения своего world state. Нам нужно хранить документы такого вида.
```
{
Status string // Статус транзакции: "pending", "done", "failed"
TxID: string // ID транзакции
Error: string // optional, сообщение об ошибке
}
```
Этот документ записывается в базу до передачи транзакции на пиры, пользователю возвращается ID сущности (этот же ID используется в качестве ключа), если это операция создания чего-либо, а затем поля Status, TxID и Error обновляются по мере поступления релевантной информации от пиров.
В этой схеме пользователь не ждет, когда же наконец сформируется блок, наблюдая крутящееся колесико на экране 10 секунд, он получает моментальный отклик системы и продолжает работать.
Мы выбрали BoltDB для хранения статусов транзакций, потому что нам нужно экономить память и не хочется тратить время на сетевое взаимодействие с отдельно стоящим сервером базы данных, тем более когда это взаимодействие происходит по plain text протоколу. Кстати, используете вы CouchDB для реализации описанной выше схемы или просто для хранения world state, в любом случае имеет смысл оптимизировать способ хранения данных в CouchDB. По умолчанию в CouchDB размер b-tree узлов равен 1279 байт, что сильно меньше размера сектора на диске, а значит как чтение, так и перебалансировка дерева будет требовать больше физических обращений к диску. Оптимальный размер соответствует стандарту [Advanced Format](https://en.wikipedia.org/wiki/Advanced_Format) и составляет 4 килобайта. Для оптимизации нам нужно установить параметр **btree\_chunk\_size равным 4096** в файле конфигурации CouchDB. Для BoltDB такое ручное вмешательство [не требуется](https://github.com/boltdb/bolt/blob/master/db.go#L345).
### Backpressure: buffer strategy
Но сообщений может быть очень много. Больше, чем система способна обработать, разделяя ресурсы с десятком других сервисов кроме отраженных на схеме — и все это должно работать безотказно даже на машинах, на которых запуск Intellij Idea будет делом крайне утомительным.
Проблема разной пропускной способности сообщающихся систем, продьюсера и консьюмера, решается разными способами. Посмотрим, что мы могли бы сделать.
**Dropping**: мы можем заявить, что способны обрабатывать не более X транзакций за T секунд. Все запросы, превышающие этот лимит, сбрасываются. Это довольно просто, но про UX тогда можно забыть.
**Controlling**: у консьюмера должен быть некий интерфейс, через который он в зависимости от нагрузки сможет контролировать tps продьюсера. Неплохо, но это накладывает обязательства на разработчиков клиента, создающего нагрузку, реализовывать этот интерфейс. Для нас это неприемлемо, так как блокчейн в перспективе будет интегрирован в большое количество давно существующих систем.
**Buffering**: вместо того, чтобы ухищряться в сопротивлении входному потоку данных, мы можем буферизовать этот поток и обрабатывать его с необходимой скоростью. Очевидно, это лучшее решение, если мы хотим обеспечить хороший пользовательский опыт. Буфер мы реализовывали с помощью очереди в RabbitMQ.
В схему добавилось два новых действия: (1) после поступления запроса на API в очередь кладется сообщение с параметрами, необходимыми для вызова транзакции, и клиент получает сообщение о том, что транзакция принята системой, (2) бекенд с задаваемой в конфиге скоростью читает данные из очереди; инициирует транзакцию и обновляет данные в хранилище статусов.
Теперь можно увеличивать время формирования и вместимость блока настолько, насколько захочется, скрывая задержки от пользователя.
### Другие инструменты
Здесь не было ничего сказано про чейнкод, потому что в нем, как правило, нечего оптимизировать. Чейнкод должен быть максимально простым и безопасным — это всё, что от него требуется. Писать чейнкод просто и безопасно нам сильно помогает фреймворк [ССKit](https://github.com/s7techlab/cckit) от S7 Techlab и статический анализатор [revive^CC](https://github.com/sivachokkapu/revive-cc).
Кроме того, наша команда разрабатывает набор утилит для того, чтобы сделать работу с Fabric простой и приятной: [блокчейн эксплорер](https://github.com/OCRVblockchain/fabex), утилита для [автоматического изменения конфигурации сети](https://github.com/OCRVblockchain/fabchanger) (добавление/удаление организаций, нод RAFT), утилита для [отзыва сертификатов и удаления identity](https://github.com/OCRVblockchain/slasher). Если хотите внести свой вклад — welcome.
### Заключение
Этот подход позволяет легко заменить Hyperledger Fabric на Quorum, другие приватные Ethereum сети (PoA или даже PoW), существенно снизить реальную пропускную способность, но при этом сохранить нормальный UX (как для пользователей в браузере, так и со стороны интегрируемых систем). При замене Fabric на Ethereum в схеме нужно будет изменить только логику retry-сервиса/декоратора c обработки MVCC-конфликтов на атомарный инкремент nonce и повторную отправку. Буферизация и хранилище статусов позволили отвязать время отклика от времени формирования блока. Теперь можно добавлять тысячи нод ордеров и не бояться, что блоки формируются слишком часто и нагружают ordering service.
В общем-то, это всё, чем я хотел поделиться. Буду рад, если это кому-то поможет в работе. | https://habr.com/ru/post/489002/ | null | ru | null |
# Восстановление (импутация) данных с помощью Python
*Автор статьи — Виктория Ляликова.*
На данный момент Python является самым популярным языком программирования, который применяется для анализа данных или в машинном обучении. Сильными сторонами Python являются его модульность и возможность интегрироваться с другими языками программирования.
В науке о данных разведочный анализ данных (exploratory data analysis, EDA) является самым важным этапом в проекте и занимает около 70-80% времени всего проекта. Такой анализ позволяет изучить какие-то свойства данных, найти в них закономерности, аномалии, очистить их, подготовить и построить начальные модели для дальнейшей работы. На этом этапе можно определить вид распределения, оценить основные его параметры, обнаружить выбросы, построить матрицу корреляции признаков и т.д.
И в предварительном анализе достаточно серьезной проблемой является обнаружение недостающих (пропущенных) значений и самым сложным является то, что здесь нет какого-то универсального алгоритма. Для каждой конкретной задачи приходится искать наиболее подходящие методы или их комбинации.
Так как большинство моделей машинного обучения не могут обрабатывать пропущенные значения, значит их нельзя игнорировать в данных и эту проблему необходимо решать во время предобработки. Самым простым решением является удаление каждого наблюдения, содержащего одно или несколько пропущенных значений. Эта задача быстро и легко выполняется с помощью библиотек Numpy или pandas.
Вместе с этим необходимо стараться воздерживаться от удаления наблюдений с отсутствующими значениями. Их удаление является крайним средством, поскольку тогда алгоритм теряет доступ к полезной информации, содержащейся в непропущенных значениях наблюдений.
Можно выделить следующие основные стратегии замены пропущенных данных подстановочными значениями.
1. Заменить пропущенные значения средним/медианой. В данном случае необходимо вычислить среднее/медиану имеющихся значений для каждого столбца и вставить то, что получилось в пропущенные ячейки. Данный метод является простым и быстрым, но не работает с качественными переменными. Также невозможно оценить погрешность импутации.
2. Замена самым часто встречающимся значением или константой. Также является еще одним простым методом импутации. Можно использовать для качественных переменных
3. Замена данных, используя метод k ближайших соседей или kNN. Является самым популярным методом машинного обучения для решения задач классификации. Основан на оценивании сходства объектов. Используется функция расстояния Евклида
где x\_{ik} и x\_{jk} — к-е элементы векторов x\_{i} и x\_{j} соответственно
У какого класса выше значение близости, тот класс и присваивается новому объекту.
Тогда с помощью данного метода можно вычислить значения пропущенных атрибутов на основании дистанций от попавших в область объектов и соответствующих значений этого же атрибута у объектов
где a\_{i} — i-ый объект, попавший в область, k\_{i} — значение атрибута k у заданного объекта a\_{i}, x — новый объект, x\_{k} — ый атрибут нового объекта.
Иным словами, выбирается k-точек, которые больше всего похожи на рассматриваемую, и уже на их основании выбирается значение для пустой ячейки.
Данный метод на некоторых наборах данных может быть точнее среднего/медианы или константы, учитывает корреляцию между параметрами. Главным недостатком данного метода является то, что он является вычислительно дорогим, так как требует держать весь набор данных в памяти, чтобы вычислить расстояние между пропущенным значением и каждым отдельным значением.
4. Множественная импутация данных (MICE). Суть данного метода заключается в том, что импутация каждого значения проводится не один раз, а много. Такой тип замены пропущенных значений позволяет понять насколько надежно или ненадежно предложенное значений. Также, MICE, позволяет работать с переменным разных типов.
5. Импутация данных с помощью глубоко обучения. Библиотека datawig позволяет восстанавливать недостающие значения за счет тренировки нейронной сети на тех точках, для которых есть все параметры.
Теперь попробуем разобрать некоторые возможности библиотек Phyton, которые помогут нам решить проблему недостающих значений. Для исследования необходимо выбрать набор данных (DataSet). Разнообразные наборы данных можно скачать с сайта (kaggle.com). Для демонстрации возможностей исследуем набор данных с информацией о диабете, где пациентами являются женщины не моложе 21 года индейского происхождения Пима.
Загружаем необходимые библиотеки и датасет
```
import pandas as pd
import numpy as np
data_diabetes = pd.read_csv('......../datasets/diabetes.csv')
data_diabetes
```
Данный набор содержит следующие поля: Pregnancies (количество беременностей), Glucose (уровень глюкозы), BloodPressure (давление), SkinThickness (толщина кожной складки трицепса в мм), Insulin (уровень инсулина), BMI (индекс массы тела), DiabetesPedigree (функция наличия диабета у родственников), Age (возраст), Outcome (наличие диабета).
Посмотрим на основные характеристики, каждого признака.
```
data_diabetes.describe()
```
 Можно увидеть, почти в каждом столбце есть нулевые значения. Посчитаем их количество
```
(data diabetes ==0).sum()
```
Можно предположить, что это пропущенные значения, где неизвестное значение было заменено нулем. Преобразуем все нули в значениях 'Glucose','BloodPressure','SkinThickness','Insulin','BMI' на значения NaN и еще раз посчитаем их количество, предварительно сделав копию нашего датасета.
```
new_data = data_diabetes.copy(deep = True)
colsFix = ['Glucose','BloodPressure','SkinThickness','Insulin','BMI']
new_data [colsFix] = new_data[colsFix].replace(0, np.NaN)
new_data.isnull().sum()
```
И еще раз посмотрим на характеристики датасета
```
new_data.describe()
```
Почти в каждом столбце, кроме max произошли какие-то изменения.
Каким же образом можно проводить импутацию данных? Будем работать только со столбцами SkinThickness и Insulin, так как они имеют больше всего пропущенных значений.
1. В библиотеке Pandas (которая была уже загружена ранее) есть метод fillna(), который как раз позволяет заполнить пропущенные значения.
Синтаксис метода следующий
```
DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)
```
Наверное, нет смысла описывать все параметры этого метода. Описание можно посмотреть [здесь](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.fillna.html#pandas.DataFrame.fillna).
Важно, что данный метод возвращает объект, в котором заполняются все пропущенные значения. Можно заменить пропущенные значения, например, средним, медианой, самым часто встречающимся значением, константой.
Вычисли эти значения, а затем заменим пропущенные значения медианой используя метод fillna.
Параметр SkinThickness
| | | |
| --- | --- | --- |
| Медиана | Среднее | Самое часто встречающееся значение |
| median\_Skin = new\_data.Skin.median()median\_Skin29 | mean\_Skin= new\_data.Skin.mean()mean\_Skin29.153419593345657 | mode\_Skin = new\_data.Skin.mode()mode\_Skin32 |
Параметр Isulin
| | | |
| --- | --- | --- |
| median\_Insulin = new\_data.Insulin.median()median\_Insulin125 | mean\_Insulin = new\_data.Insulin.mean()mean\_Insulin155.5482233502538 | mode\_Insulin = new\_data.Insulin.mode()mode\_Insulin105 |
Воспользуемся методом `fillna()` для восстановления значений
```
new_data = new_data.fillna({'SkinThickness':median_SkinThickness})
new_data = new_data.fillna({'Insulin':median_Insulin})
```
В данном случае при использовании метода `fillna` указывается столбец и значение, которые необходимо заполнить.
Если необходимо заполнить значения в нескольких столбцах сразу, тогда можно сделать, например, так
```
new_data = new_data.fillna({'Insulin':median_Insulin, 'SkinThickness':median_SkinThickness})
```
2. Библиотека Sklearn имеет класс `SimpleImputer`, который используется для восстановления пропущенных значений.
Используется следующий синтаксис
```
SimpleImputer(missingValues, strategy, fill_value)
```
`missingValues` – здесь мы можем установить разные кодировки пропущенных значений, например, такие как np.nan или pd.NA.
`strategy`: это данные, которые заменят отсутствующие значения из набора данных, по умолчанию метод значения для этого параметра – среднее. Также можно использовать следующие стратегии: среднее, медиана, наиболее часто встречающееся, константа.
`fill_value` – константное значение, которое заменит пропущенные значения
Для замены пропущенных значений используется метод `fit_transform`.
Подробнее про класс `SimpleImputer` можно посмотреть [здесь](https://scikit-learn.org/stable/modules/generated/sklearn.impute.SimpleImputer.html).
Продемонстрируем работу с данным классом
```
from sklearn.impute import SimpleImputer #импортируем библиотеку
myImputer = SimpleImputer (strategy= 'mean') #определяем импортер для обработки отсутствующих значений, используется стратегия замены средним значением
myImputer = SimpleImputer (strategy= 'median') # используется стратегия замены медианным значением
myImputer = SimpleImputer (strategy= 'most_frequent') используется стратегия замены наиболее часто встречающимся значением
#используем метод fit_transform для замены пропущенных значений
new_data.Insulin = myImputer.fit_transform(new_data['Insulin'].values.reshape(-1,1))
```
Если необходимо заменить категориальные пропущенные значения, тогда можно использовать стратегию «самое частое значение» или «константа». Только одно замечание: все категориальные признаки должны быть переведены в числовые.
```
myImputer = SimpleImputer (strategy= 'constant', fill_value='1')
new_data.Outcome = myImputer.fit_transform (new_data['Outcome'].values.reshape(-1,1))
```
Для замены значений в нескольких столбцах в датасете средним/медианой/конcтантой можно использовать следующую команду
```
new_data[['Insulin','SkinThickness']]=myImputer.fit_transform(new_data[['Insulin','SkinThickness']])
```
3. Класс `IterativeImputer` библиотеки sklearn реализует многомерные алгоритмы восстановления пропущенных значений, оценивая другие значения в наборе. Данный класс моделирует каждый признак пропущенного значения как функцию от других признаков и использует оценку для замены значений. `IterativeImputer` фактически итеративно строит модель регрессии, используя подмножества столбцов для прогнозирования отсутствующих значений.
Подробнее про класс `IterativeImputer` можно посмотреть [здесь](https://scikit-learn.org/stable/modules/generated/sklearn.impute.IterativeImputer.html).
Посмотрим на работу с этим классом
```
X = new_data.copy(deep = True) #создаем копию датасета
# импортируем библиотеку
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer
# определяем импортер
myImputer=IterativeImputer()
# устанавливаем imputer на X
myImputer.fit(X)
#получаем восстановленные данные
myImputer_data = myImputer.transform(X)
# полученные данные преобразовываем в DataFrame
myImputer_data = pd.DataFrame(myImputer_data,columns = new_data.columns)
```
4. Класс KNNImputer библиотеки sklearn обеспечивает восстановление пропущенных значений с использованием метода k – ближайщих соседей.
Подробнее про класс [здесь](https://scikit-learn.org/stable/modules/generated/sklearn.impute.KNNImputer.html).
```
# импортируем библиотеку
from sklearn.impute import KNNImputer
#определяем импортер
imputer=KNNImputer(n_neighbors=5, weigths=’uniform’)
#устанавливаем импортер на Х
imputer.fit(X)
# восстанавливаем данные
X1 = imputer.transform(X)
# полученные данные преобразовываем в DataFrame
myImputer_data = pd.DataFrame(X1,columns = new_data.columns)
```
Каждый отсутствующий объект рассчитывается с использованием значений от n\_neighbors ближайших соседей у которых есть значение для данного объекта. Характеристики соседей усредняются равномерно или взвешиваются по расстоянию до каждого соседа
Для определения параметра n\_neighbors нет какого-то определенного способа, можно определить только экспериментальным путем. Низкое значение параметра может привести к эффекту недообучения модели, а слишком высокое влияет на производительность. Чаще всего наиболее предпочтительным является значение, равное 5.
Посмотрим на сравнительную таблицу методов `SimpleImputer`, `IterativeImputer`, `KNNImputer`
Теперь наши данные готовы к работе.
---
> Приглашаем всех желающих на открытое занятие «**Основы ООП в Python**». На занятии научимся работать с классами, познакомимся с наследованием, узнаем про мутабельность экземпляров класса, передачу аргументов в инициализатор, наследование, переопределение методов, обращение к методам суперкласса. Регистрация доступна [**по ссылке.**](https://otus.pw/pHGK/)
>
> | https://habr.com/ru/post/681410/ | null | ru | null |
# Разработка своей системы биллинга на Django
При разработке большинства сервисов возникает потребность во внутреннем биллинге для аккаунтов сервиса. Так и в [нашем сервисе](http://bitcalm.com/) возникла такая задача. Готовые пакеты для её решения мы так и не смогли найти, в итоге пришлось разрабатывать систему биллинга с нуля.
В статье хочу рассказать о нашем опыте и подводных камнях, с которыми пришлось столкнуться во время разработки.
#### Задачи
Задачи, которые нам предстояло решить были типичны для любой системы денежного учета: прием платежей, лог транзакций, оплата и повторяющиеся платежи (подписка).
#### Транзакции
Основной единицей системы, очевидно, была выбрана транзакция. Для транзакции была написана следующая простая модель:
```
class UserBalanceChange(models.Model):
user = models.ForeignKey('User', related_name='balance_changes')
reason = models.IntegerField(choices=REASON_CHOICES, default=NO_REASON)
amount = models.DecimalField(_('Amount'), default=0, max_digits=18, decimal_places=6)
datetime = models.DateTimeField(_('date'), default=timezone.now)
```
Транзакция состоит из ссылки на пользователя, причины пополнения (или списания), суммы транзакции и времени совершения операции.
#### Баланс
Баланс пользователя очень легко посчитать при помощи функции [annotate](https://docs.djangoproject.com/en/dev/topics/db/aggregation/) из ORM Django (считаем сумму значений одного столбца), но мы столкнулись с тем, что при большом количестве транзакций данная операция сильно нагружает БД. Поэтому было решено денормализовать БД, добавив поле “balance” в модель пользователя. Данное поле обновляется в методе “save” в модели “UserBalanceChange”, а для уверенности в актуальности данных в нем, мы каждую ночь его пересчитываем.
Правильнее, конечно же, хранить информацию о текущем балансе пользователя в кэше (например, в Redis) и инвалидировать при каждом изменении модели.
#### Прием платежей
Для самых популярных систем приема платежей есть готовые пакеты, поэтому проблем с их установкой и настройкой, как правило, не возникает. Достаточно выполнить несколько простых шагов:
* Регистрируемся в платежной системе;
* Получаем API ключи;
* Устанавливаем соответствующий пакет для Django;
* Реализовываем форму оплаты;
* Реализовываем функцию зачисления средств на баланс после оплаты.
Прием платежей реализуется очень гибко, например, для системы Robokassa (используемся приложение [django-robokassa](https://bitbucket.org/kmike/django-robokassa/)) код выглядит так:
```
from robokassa.signals import result_received
def payment_received(sender, **kwargs):
order = OrderForPayment.objects.get(id=kwargs['InvId'])
user = User.objects.get(id=order.user.id)
order.success=True
order.save()
try:
sum = float(order.payment)
except Exception, e:
pass
else:
balance_change = UserBalanceChange(user=user, amount=sum, reason=BALANCE_REASONS.ROBOKASSA)
balance_change.save()
```
По аналогии можно подключить любую систему оплаты, например PayPal, Яндекс.Касса
#### Списание средств
Со списаниями чуть сложнее – перед операцией необходимо проверять, каким будет баланс счета после проведения операции, причем “по-честному” – при помощи annotate. Это необходимо делать для того, чтобы не обслуживать пользователя “в кредит”, что особенно важно, когда транзакции выполняются на большие суммы.
```
payment_sum = 8.32
users = User.objects.filter(id__in=has_clients, balance__gt=payment_sum).select_related('tariff')
```
Здесь мы написали без annotate, так как в данейшем есть дополнительные проверки.
#### Повторяющиеся списания
Разобравшись с основами, переходим к самому интересному — повторяющимся списаниям. У нас есть потребность каждый час (назовет это “биллинг-период”) снимать с пользователя определенную сумму в соответствии с его тарифным планом. Для реализации этого механизма мы используем [celery](http://www.celeryproject.org/) – написан task, который выполняется каждый час. Логика в этом моменте получилась сложная, так как необходимо учитывать много факторов:
* между выполнениями задачи в celery никогда не пройдет ровно час (биллинг-период);
* пользователь пополняет свой баланс (он становится >0) и получает доступ к услугам между биллинг-периодами, снимать за период было бы нечестно;
* пользователь может поменять тариф в любое время;
* celery может по каким-либо причинам перестать выполнять задачи
Мы пытались реализовать данный алгоритм без введения дополнительного поля, но получилось не красиво и не удобно. Поэтому нам пришлось в модель User добавить поле last\_hourly\_billing, где указываем время последней повторяющиеся операции.
Логика работы:
* Каждый биллинг-период мы смотрим время last\_hourly\_billing и списываем сумму согласно тарифному плану, затем обновляем поле last\_hourly\_billing;
* При смене тарифного плана мы списываем сумму по прошлому тарифу и обновляем поле last\_hourly\_billing;
* При активации услуги мы обновляем поле last\_hourly\_billing.
```
def charge_tariff_hour_rate(user):
now = datetime.now
second_rate = user.get_second_rate()
hour_rate = (now - user.last_hourly_billing).total_seconds() * second_rate
balance_change_reason = UserBalanceChange.objects.create(
user=user,
reason=UserBalanceChange.TARIFF_HOUR_CHARGE,
amount=-hour_rate,
)
balance_change_reason.save()
user.last_hourly_billing = now
user.save()
```
Данная система, к сожалению, не является гибкой: если мы добавим еще один тип повторяющихся платежей — придется добавлять новое поле. Скорее всего, в процессе рефакторинга, мы напишем дополнительную модель. Примерно такую:
```
class UserBalanceSubscriptionLast(models.Model):
user = models.ForeignKey('User', related_name='balance_changes')
subscription = models.ForeignKey('Subscription', related_name='subscription_changes')
datetime = models.DateTimeField(_('date'), default=timezone.now)
```
Эта модель позволит очень гибко реализовать повторяющиеся платежи.
#### Dashboard
Мы используем [django-admin-tools](https://bitbucket.org/izi/django-admin-tools/wiki/Home) для удобного dashboard в панели администрирования. Мы решили, что будем следить за следующими двумя важными показателями:
* Последние 5 оплат и график платежей пользователей за последний месяц;
* Пользователи, у которых баланс приближается к 0 (из тех, кто уже платил);
Первый показатель для нас является своего рода показателем роста (traction) нашего стартапа, второй — это возвращаемость (retention) пользователей.
О том, как мы реализовали dashboard и следим за метриками, мы расскажем в одной из следующих статей.
Желаю всем удачной настройки биллинг-системы и получения больших платежей!
P.S. Уже в процессе написания статьи нашел готовый пакет [django-account-balances](https://pypi.python.org/pypi/django-account-balances), думаю, что можно обратить внимание, если вы делаете систему лояльности. | https://habr.com/ru/post/234861/ | null | ru | null |
# Спам-кампания “Love you” перенацелена на Японию
Изучая свежую [волну спама в России](https://habr.com/ru/company/eset/blog/437982/), мы обратили внимание на другую атаку. С середины января 2019 года известная [кампания “Love you”](https://isc.sans.edu/forums/diary/Heartbreaking+Emails+Love+You+Malspam/24512/) доработана и перенацелена на Японию, где используется для распространения шифратора GandCrab 5.1.
По данным телеметрии, последняя версия “Love you” запущена 28 января 2019 года, ее активность примерно вдвое превысила первоначальную (см. график ниже). Как и в середине января, с помощью спама распространяется набор вредоносных полезных нагрузок с некоторыми обновлениями. Так, мы видели попытки загрузки криптомайнера, ПО для изменения системных настроек, вредоносного загрузчика, червя Phorpiex, а также шифратора GandCrab версии 5.1.
*Рисунок 1. Детектирование вредоносных вложений JavaScript, распространяемых в кампании “Love you” и ее последней волн*е
По состоянию на 29 января 2019 года подавляющее большинство обнаружений приходится на Японию (95%), каждый час детектируются десятки тысяч вредоносных писем. В тот же день JS/Danger.ScriptAttachment (по классификации ESET — вредоносный JavaScript, распространяемый через вложения электронной почты) был четвертой по числу обнаружений угрозой в мире и угрозой №1 в Японии (см. ниже).
*Рисунок 2. JS/Danger.ScriptAttachment был угрозой №1 в Японии по состоянию на 29 января*
#### Сценарий атаки
В последней кампании атакующие изменили тексты рассылок, перейдя от «Love You» в теме письма к заголовкам, связанным с Японией. Прежним осталось множество смайлов в теме и теле письма.
Темы писем, которые мы видели в ходе анализа:
— Yui Aragaki ;)
— Kyary Pamyu Pamyu ;)
— Kyoko Fukada ;)
— Yuriko Yoshitaka ;)
— Sheena Ringo ;)
— Misia ;)
(японские звезды шоу-бизнеса)
Изученные вредоносные вложения представляют собой ZIP-архивы, замаскированные под изображения с именами формата PIC0-[9-digit-number]2019-jpg.zip. На рисунке ниже представлены примеры таких писем.
*Рисунок 3. Примеры спам-писем из «японской» кампании*
ZIP-архив содержит JavaScript-файл с именем в том же формате, но заканчивающимся только на .js. После извлечения и запуска JavaScript загружает полезную нагрузку первого этапа с C&C-сервера атакующих – ЕХЕ-файл, детектируемый продуктами ESET как Win32/TrojanDownloader.Agent.EJN. URL-адреса, на которых размещена эта полезная нагрузка, имеют путь, заканчивающийся на bl\*wj\*b.exe (имя файла изменено) и krabler.exe; эта полезная нагрузка загружается в C:\Users\[username]\AppData\Local\Temp[random].exe.
Полезная нагрузка первого этапа скачивает одну из следующих финальных полезных нагрузок с того же C&C-сервера:
— шифратор GandCrab версии 5.1
— криптомайнер
— червь Phorpiex
— загрузчик, работающий в соответствии с языковыми настройками (скачивает полезную нагрузку только в том случае, если языковые настройки зараженного компьютера соответствуют Китаю, Вьетнаму, Южной Корее, Японии, Турции, Германии, Австралии или Великобритании)
— ПО для изменения системных настроек
GandCrab 5.1 шифрует файлы, добавляя случайное расширение из пяти символов к их именам. Требования выкупа, содержащие это расширение в именах файлов и их содержимом, создаются в каждой папке, затронутой шифратором.
*Рисунок 4. Требование выкупа GandCrab v5.1*
Полезная нагрузка данной кампании скачивается с IP-адреса 92.63.197[.]153, геолокация которого соответствует Украине. Адрес использовался в кампании “Love you” с середины января.
### Индикаторы компрометации
**Примеры хешей вредоносных вложений ZIP**
`8551C5F6BCA1B34D8BE6F1D392A41E91EEA9158B
BAAA91F700587BEA6FC469FD68BD8DE08A65D5C7
9CE6131C0313F6DD7E3A56D30C74D9E8E426D831
83A0D471C6425DE421145424E60F9B90B201A3DF
57F94E450E2A504837F70D7B6E8E58CDDFA2B026`
Детектирование ESET: JS/Danger.ScriptAttachment
**Примеры хешей загрузчиков JavaScript**
`cfe6331bdbd150a8cf9808f0b10e0fad4de5cda2
c50f080689d9fb2ff6e731f72e18b8fe605f35e8
750474ff726bdbd34ffc223f430b021e6a356dd7
1445ea29bd624527517bfd34a7b7c0f1cf1787f6
791a9770daaf8454782d01a9308f0709576f75f9`
Детектирование ESET: JS/TrojanDownloader.Agent.SYW или JS/TrojanDownloader.Nemucod.EDK
**Примеры хешей полезной нагрузки первого этапа**
`47C1F1B9DC715D6054772B028AD5C8DF00A73FFC`
Детектирование ESET: Win32/TrojanDownloader.Agent.EJN
**Примеры хешей финальной полезной нагрузки**
Шифратор GandCrab `885159F6F04133157871E1D9AA7D764BFF0F04A3` Win32/Filecoder.GandCrab.E
Криптомайнер `14E8A0B57410B31A8A4195D34BED49829EBD47E9` Win32/CoinMiner.BEX
Червь Phorpiex `D6DC8ED8B551C040869CD830B237320FD2E3434A` Win32/Phorpiex.J
Загрузчик `AEC1D93E25B077896FF4A3001E7B3DA61DA21D7D` Win32/TrojanDownloader.Agent.EEQ
ПО для изменения системных настроек `979CCEC1DF757DCF30576E56287FCAD606C7FD2C` Win32/Agent.VQU
**C&C-сервер, используемый в кампании**
`92.63.197[.]153` | https://habr.com/ru/post/439068/ | null | ru | null |
# Google Drive папка для Linux
Введение
--------
Существуют различные дистрибутивы Linux. В Xubuntu используется среда рабочего стола Xfce с файловым менеджером [thunar](https://ru.wikipedia.org/wiki/Thunar) (фунар). Целью данного туториала является описание способа подключения Google Диска к фунару. Этот же способ [с небольшими доработкими](https://habr.com/ru/post/311890/) может быть использован и для подключения Google Диск папки у серверного дистрибутива вроде Ubuntu server.
А вот для очень популярной Ubuntu используется среда рабочего стола Gnome с файловым менеджером [GNOME Files](https://ru.wikipedia.org/wiki/GNOME_Files), куда еще [в 2015 году](https://linuxthebest.net/eshhe-odin-sposob-podklyucheniya-google-drive-v-linuxmate-xfce/) интегрировали возможность использовать свой Google Диск непосредственно из приложения GNOME Files. Так что кто хочет всё и сразу, ставьте Ubuntu (лично у меня комп не тянет) и не читайте дальше.
Перейдем к созданию Google Drive папки
--------------------------------------
1) Установим
```
sudo add-apt-repository ppa:alessandro-strada/ppa
sudo apt update
sudo apt install google-drive-ocamlfuse
```
2) Создаем директорию, куда будем монтировать. Пусть директория называется gd и лежит в каталоге пользователя (символ тильда ~ означает домашний каталог текущего пользователя).
```
sudo mkdir ~/gd
```
Назначим права доступа на директорию
```
sudo chmod -R 0777 ~/gd
```
3) Теперь необходимо из-под пользователя (не sudo) выполнить команду
```
google-drive-ocamlfuse ~/gd
```
Вы будете перенаправлены в браузер для авторизации (вариант без браузера [тут](https://habr.com/ru/post/311890/)). По ее завершении Google у вас спросит разрешить управлять вашим диском – подтверждаем.
Кажется готово: можно перейти в директорию ~**/gd** и увидеть там свои файлы из облака.
После перезапуска системы ваша папка на компьютере окажется пуста, потому что не настроено автоматическое монтирование.
4) Настроим автоматическое монтирование с помозью systemd. Необходимо создать файл с именем, пусть google-drive.service по адресу /etc/systemd/system/ Сделать это можно разными способами, я предпочитаю через редактор nano. То есть мы открываем в nano файл на редактирование и через ctrl+c ctrl+v наполняем его. Хотя делать то же можно и через cat, тогда содержимое файла возможно передать не через буфер обмена, а прямо указать в терминале, очень удобно для скриптов. Далее я покажу и этото способ, а пока (создадим и) откроем файл через nano.
`sudo nano /etc/systemd/system/google-drive.service`
И пропишем в файле
```
[Unit]
Description=FUSE filesystem over Google Drive
After=network.target
[Service]
User=a
Group=a
ExecStart=google-drive-ocamlfuse -label default ~/gd
ExecStop=fusermount -u ~/gd
Restart=always
Type=forking
[Install]
WantedBy=multi-user.target
```
Шаг 4) можно было сделать через cat вот так:
```
cat < /etc/systemd/system/google-drive.service
[Unit]
Description=FUSE filesystem over Google Drive
After=network.target
[Service]
User=a
Group=a
ExecStart=google-drive-ocamlfuse -label default ~/gd
ExecStop=fusermount -u ~/gd
Restart=always
Type=forking
[Install]
WantedBy=multi-user.target
EOF
```
5) Финальный аккорд - вызываем
```
sudo systemctl daemon-reload
sudo systemctl start google-drive
```
Теперь на компьютере будет папка Google Диска и при включении она будет автомонтироваться. Кстати ocamlfuse [поддерживает](https://github.com/astrada/google-drive-ocamlfuse/wiki) возможность использования нескольких аккаунтов.
Дополнительные материалы
------------------------
Аналогичный туториал другими словами [тут](https://www.xmodulo.com/mount-google-drive-linux.html).
[Еще](https://linuxthebest.net/eshhe-odin-sposob-podklyucheniya-google-drive-v-linuxmate-xfce/) один способ подключения Google Drive в Xubuntu.
Туториал как подключить Google Диск через [fstab](https://habr.com/ru/post/548780/) | https://habr.com/ru/post/685758/ | null | ru | null |
# 12 млрд реквестов в месяц за 120$ на java
Когда Вы запускаете свой продукт — Вы совершенно не знаете, что произойдет после запуска. Вы можете так и остаться абсолютно никому не нужным проектом, можете получить небольшой ручеек клиентов или сразу целое цунами пользователей, если про Вас напишут ведущие СМИ. Не знали и мы.
Этот пост об архитектуре нашей системы, ее эволюционном развитии на протяжении уже почти 3-х лет и компромиссах между скоростью разработки, производительностью, стоимостью и простотой.
Упрощенно задача выглядела так — нужно соединить микроконтроллер с мобильным приложением через интернет. Пример — нажимаем кнопку в приложении зажигается светодиод на микроконтроллере. Тушим светодиод на микроконтроллере и кнопка в приложении соответственно меняет статус.
Так как мы стартовали проект на кикстартере, перед запуском сервера в продакшене у нас уже была довольно большая база первых пользователей — 5000 человек. Наверное многие из Вас слышали про известный хабра эффект, который положил в прошлом многие веб ресурсы. Мы, конечно же, не хотели повторять эту участь. Поэтому это отразилось на подборе технического стека и архитектуре приложения.
Сразу после запуска вся наша архитектура выглядела так:
Это была 1 виртуалка от Digital Ocean за 80$ в мес (4 CPU, 8 GB RAM, 80 GB SSD). Взяли с запасом. Так как “а вдруг лоад пойдет?”. Тогда мы действительно думали, что, вот, запустимся и тысячи пользователей ринут на нас. Как оказалось — привлечь и заманить пользователей та еще задача и нагрузка на сервер — последнее о чем стоит думать. Из технологий на тот момент была лишь Java 8 и Netty с нашим собственным бинарным протоколом на ssl/tcp сокетах (да да, без БД, spring, hibernate, tomcat, websphere и прочих прелестей кровавого энтерпрайза).
Все пользовательские данные хранились просто в памяти и периодически сбрасывались в файлы:
```
try (BufferedWriter writer = Files.newBufferedWriter(fileTo, UTF_8)) {
writer.write(user.toJson());
}
```
Весь процесс поднятия сервера сводился к одной строке:
```
java -jar server.jar &
```
Пиковая нагрузка сразу после запуска составила 40 рек-сек. Настоящего цунами так и не произошло.
Тем не менее мы много и упорно работали, постоянно добавляли новые фичи, слушали отзывы наших пользователей. Пользовательская база хоть и медленно, но стабильно и постоянно росла на 5-10% каждый мес. Так же росла и нагрузка на сервер.
Первой серьезной фичей стал репортинг. В момент когда мы начали его внедрять — нагрузка на систему уже составляла 1 млрд реквестов в месяц. Причем большинство запросов были реальные данные, такие как показания датчиков температуры. Было очевидно, что хранить каждый запрос — очень дорого. Поэтому мы пошли на хитрости. Вместо сохранения каждого реквеста — мы рассчитываем среднее значение в памяти с минутной гранулярностью. То есть, если вы послали в течении минуты числа 10 и 20, то на выходе получите значение 15 для этой минуты.
Сначала я поддался хайпу и реализовал данный подход на apache spark. Но когда дело дошло до деплоймента, понял что овчинка не стоит выделки. Так конечно было “правильно” и по “энтерпрайзному”. Но теперь мне предстояло деплоить и мониторить 2 системы вместо моего уютного монолитика. Кроме того добавлялся оверхед на сериализацию данных и их передачу. В общем я избавился от спарка и просто подсчитываю значения в памяти и раз в минуту сбрасываю на диск. На выходе выглядит это так:
Система с одним сервером монолитом отлично работала. Но были и вполне очевидные минусы:
* Так как сервер был в Нью-Йорке — в удаленных районах, например, Азии были визуально видны лаги при интерактивном использовании приложения. Например, когда вы меняли уровень яркости лампы с помощью слайдера. Ничего критического и ни один из пользователей на это не жаловался, но мы же изменяем мир, черт побери.
* Деплой требовал обрыва всех соединений и сервер был недоступен на ~5 сек при каждом перезапуске. В активную фазу разработки мы делали около 6 деплоев в мес. Что забавно — за все время таких вот рестартов — ни один пользователь не заметил недоступность серверов. То есть рестарты были настолько быстрыми (привет спринг и томкат), что пользователи вообще не замечали их.
* Отказ одного сервера, датацентра ложил всё.
Спустя 8 мес после запуска — поток новых фич немного спал и у меня появилось время, чтобы изменить эту ситуацию. Задача была проста — уменьшить задержку в разных регионах, снизить риск падения всей системы одновременно. Ну и сделать все это быстро, просто, дешево и минимальными усилиями. Стартап, все-таки.
Вторая версия получилась такой:
Как Вы, наверное, заметили — я остановил свой выбор на GeoDNS. Это было очень быстрое решение — вся настройка 30 мин в Amazon Route 53 на почитать и настроить. Довольно дешевое — Geo DNS роутинг у амазона стоит 50$ в мес (я искал альтернативы дешевле, но не нашел). Довольно простое — так как не нужен был лоад балансер. И требовало минимум усилий — пришлось лишь немного подготовить код (заняло меньше дня).
Теперь у нас было 3 монолитных сервера по 20$ (2 CPU, 2 GB RAM, 40 GB SSD) + 50$ за Geo DNS. Вся система стоила 110$ в мес, при этом она имела на 2 ядра больше за цену на 20$ дешевле. В момент перехода на новую архитектуру нагрузка составляла 2000 рек-сек. А прежняя виртуалка была загружена лишь на 6%.
Все проблемы монолита выше — решались, но появлялась новая — при перемещении человека в другую зону — он будет попадать на другой сервер и у него ничего не будет работать. Это был осознанный риск и мы на него пошли. Мотивация очень простая — юзеры не платят (на тот момент система была полностью бесплатной), так пусть терпят. Так же мы воспользовались статистикой, согласно которой — лишь 30% американцев хоть раз в жизни покидали свою страну, а регулярно перемещаются лишь 5%. Поэтому предположили, что данная проблема затронет лишь небольшой % наших пользователей. Предсказание оправдалось. В среднем мы получали около одного письма в 2-3 дня от пользователя у которого “Пропали проекты. Что делать? Спасите!”. Со временем такие письма начали очень сильно раздражать (несмотря на детальную инструкцию как быстро пользователю это пофиксить). Тем более такой подход врядли бы устроил бизнес, на который мы только начали переключатся. Нужно было что-то делать.
Вариантов решения проблемы было много. Я решил, что самым дешевым способом это сделать будет направлять микроконтроллеры и приложения на один сервер (чтобы избежать оверхед при передаче сообщений из одного сервера другому). В общем требования к новой системе вырисовывались такими — разные соединения одного пользователя должны попадать на один сервер и нужен shared state между такими серверами, чтобы знать куда конектить пользователя.
Я слышал очень много хороших отзывов о кассандре, которая отлично подходила под эту задачу. Поэтому решил попробовать ее. Мой план выглядел так:
Да, я нищеброд и наивный чукотский юноша. Я думал что смогу поднять одну ноду кассандры на самой дешевой виртуалке у ДО за 5$ — 512 MB RAM, 1 CPU. И я даже прочитал статью счастливчика, который поднимал кластер на Rasp PI. К сожалению, мне не удалось повторить его подвиг. Хотя я убрал/урезал все буферы, как было описано в статье. Поднять одну ноду кассандры мне удалось лишь на 1Гб инстансе, при этом нода сразу же упала с OOM (OutOfMemory) при нагрузке в 10 рек-сек. Более-менее стабильно кассандра себя вела с 2ГБ. Нарастить нагрузку одной ноды касандры до 1000 рек-сек так и не удалось, опять OOМ. На этом этапе я отказался от касандры, так как даже если бы она показала достойный перформанс, минимальный кластер в одном датацентре обходился бы в 60уе. Для меня это было дорого, учитывая что наш доход тогда составлял 0$. Так как сделать надо было на вчера — я приступил к плану Б.
Старый, добрый постгрес. Он еще никогда меня не подводил (ну ладно, почти никогда, да, full vacuum?). Постгрес отлично запускался на самой дешевой виртуалке, абсолютно не кушал RAM, вставка 5000 строк батчем занимала 300мс и нагружала единственное ядро на 10%. То что надо! Я решил не разворачивать БД в каждом из датацентров, а сделать одно общее хранилище. Так как постгрес скейлить/шардить/мастер-слейвить труднее, чем ту же касандру. Да и запас прочности это позволял.
Теперь предстояло решить другую проблему — направлять клиента и его микроконтроллеры на один и тот же сервер. По сути, сделать sticky session для tcp/ssl соединений и своего бинарного протокола. Так как вносить кардинальные изменения в существующий кластер не хотелось, я решил переиспользовать Geo DNS. Идея была такая — когда мобильное приложение получает IP адрес от Geo DNS, приложение открывает соединение и шлет login по этому IP. Сервер в свою очередь или обрабатывает команду логина и продолжает работать с клиентом в случае если это “правильный” сервер или возвращает ему команду redirect с указанием IP куда он должен конектится. В худшем случае процесс соединения выглядит так:
Но был один маленький ньюанс — нагрузка. Система на момент внедрения обрабатывала уже 4700 рек-сек. К кластеру постоянно были подключены ~3к устройств. Периодически конектилось ~10к. То есть при текущем темпе роста через год это уже будет 10к рек-сек. Теоретически могла возникнуть ситуация, когда много девайсов одновременно подключаются к одному серверу (например при рестарте, ramp up period) и если, вдруг, все они коннектились “не к тому” серверу, то могла возникнуть слишком большая нагрузка на БД, что может привести к ее отказу. Поэтому я решил подстраховаться и информацию о user-serverIP вынес в редис. Итоговая система получилась такой.
При текущей нагрузке в 12 млрд рек в месяц вся система нагружена в среднем на 10%. Сетевой трафик ~5 Mbps (in/out, благодаря нашему простому протоколу). То есть в теории такой кластер за 120$ может выдержать до 40к рек-сек. Из плюсов — не нужен лоад балансер, простой деплой, обслуживание и мониторинг довольно примитивные, есть возможность вертикального роста на 2 порядка (10х за счет утилизации текущего железа и 10х за счет более мощных виртуалок).
Проект опен-сорс. Исходники [можно глянуть тут.](https://github.com/blynkkk/blynk-server)
Вот, собственно, и все. Надеюсь статья Вам понравилась. Любая конструктивная критика, советы и вопросы — приветствуются. | https://habr.com/ru/post/316370/ | null | ru | null |
# Как посчитать количество звёзд на фото?
Всем привет!
Недавно я участвовал в олимпиаде по искусственному интеллекту на Python и там было много интересных задач, но самая интересная это про звезды на небе: *"Дано фото звездного неба с земли. Задача: определить количество звёзд на небе"*
Вроде бы не сложно, если фотка только со звездами, например:
Фото только со звёздамиЛадно, тут все легко! Это можно решить так:
Импортируем библиотеки
```
from scipy.spatial import distance
from skimage import io
from skimage.feature import blob_dog, blob_log, blob_doh
from skimage.color import rgb2gray
import matplotlib.pyplot as plt
```
Я буду использовать библиотеку `skimage` для работы с изображением, `scipy` - для сложных математических вычислений и `matplotlib.pyplot` для отладочного вывода.
```
image = io.imread(input("Путь до изображения: "))
image_gray = rgb2gray(image)
```
Откроем изображение и преобразуем его в черно белое для его простоты его будущей обработки.
Чтобы разобраться как мы упростили представление изображения, возьмем первый пиксель в RGB и GrayScale:
```
print(image[0, 0])
print(image_gray[0, 0])
```
И получим:
```
[24 16 14] #RGB
0.06884627450980392 #GrayScale
```
**работать с float проще чем с кортежем**
Далее нам нужно определиться, как искать звезды. К счастью, в модуле `skimage` есть функция определения капель(blobs). Их три вида:
* Laplacian of Gaussian (LoG)
* Difference of Gaussian (DoG)
* Determinant of Hessian (DoH)
Подробнее о их различиях можно прочитать [тут](https://scikit-image.org/docs/stable/auto_examples/features_detection/plot_blob.html).
На личном опыте и сравнивая результаты я пришел к выводу, что для данной задачи я буду использовать с такими параметрами.
```
blobs_log = blob_log(image_gray, max_sigma=20, num_sigma=10, threshold=.05)
```
Далее я отмечаю точки на картинке и считаю их количество
```
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.set_title('Laplacian of Gaussian')
ax.imshow(image)
c_stars = 0
for blob in blobs_log:
y, x, r = blob
if r > 2:
continue
ax.add_patch(plt.Circle((x, y), r, color='purple', linewidth=2, fill=False))
c_stars += 1
print("Количество звёзд: " + str(c_stars))
ax.set_axis_off()
plt.tight_layout()
plt.show()
```
Запуская, я получаю такой результат:
```
Количество звёзд: 353
```
Вывод программыНо верно ли отработает программа, если ввести ей картинку, которая соответствует условию задачи.
Картинка, соответствующая задачи И мы получим много ложных точек.
Улучшение алгоритма
-------------------
Поэтому нужно улучшить алгоритм поиска точек. Для этого воспользуемся еще одной фишкой библиотеки `skimage` это сегментация изображения.
Вот ссылка на [источник](https://stackoverflow.com/questions/26237580/skimage-slic-getting-neighbouring-segments/26243226), где описывается основы сегментации изображения.
Взяв от туда нужный кусок кода, мы улучшаем нынешний алгоритм.
Импортируем новые модули:
```
from skimage.segmentation import slic, mark_boundaries
import numpy as np
from sklearn.cluster import KMeans
```
Сегментируем изображение с помощью функции `slic`
```
segments = slic(img, start_label=0, n_segments=200, compactness=20)
segments_ids = np.unique(segments)
print(segments_ids)
# centers
centers = np.array([np.mean(np.nonzero(segments == i), axis=1) for i in segments_ids])
print(centers)
vs_right = np.vstack([segments[:, :-1].ravel(), segments[:, 1:].ravel()])
vs_below = np.vstack([segments[:-1, :].ravel(), segments[1:, :].ravel()])
bneighbors = np.unique(np.hstack([vs_right, vs_below]), axis=1)
fig = plt.figure(figsize=(10, 10))
ax = fig.add_subplot(111)
plt.imshow(mark_boundaries(img, segments))
plt.scatter(centers[:, 1], centers[:, 0], c='y')
for i in range(bneighbors.shape[1]):
y0, x0 = centers[bneighbors[0, i]]
y1, x1 = centers[bneighbors[1, i]]
l = Line2D([x0, x1], [y0, y1], alpha=0.5)
ax.add_line(l)
```
Сегментация изображенияСоздаём словарь, для определения к какому сегменту относится каждый пиксель.
```
dict_seg = {}
for i in range(img.shape[0]):
for j in range(img.shape[1]):
seg = segments[i, j]
if seg not in dict_seg.keys():
dict_seg[seg] = [img[i, j]]
continue
dict_seg[seg].append(img[i, j])
```
Высчитываем средний цвет у каждого сегмента
```
def middle(a, b):
color = []
for i, j in zip(a, b):
color.append((i + j) // 2)
return color
for k, v in dict_seg.items():
# вычисляем перцентиль для выброса пересвеченных пикселей в сегменте
p = int(0.9 * len(v))
v = sorted(list(v), key=lambda x: my_distance(x, white))
s = [0, 0, 0]
for c in v:
s[0] += c[0]
s[1] += c[1]
s[2] += c[2]
s[0] //= len(v[:p])
s[1] //= len(v[:p])
s[2] //= len(v[:p])
dict_seg[k] = s
```
На выходе получаем словарь со средними цветами в каждом сегменте
```
>>> {0: [5, 3, 14], 1: [5, 3, 16], 2: [7, 4, 17] ... 190: [23, 19, 37]}
```
Далее кластеризуем словарь `dict_seg`с помощью `KMeans` из библиотеки `sklearn`
```
kmeans = KMeans(n_clusters=3, algorithm="elkan")
kmeans.fit(list(dict_seg.values()))
labels, counts = np.unique(kmeans.labels_, return_counts=True)
```
Создаем новый словарь вида `{segment: claster_num(их всего 3)}`
```
dic_seg_claster = {}
for key, value in dict_seg.items():
dic_seg_claster[key] = kmeans.predict([value])[0]
max_l = max(dic_seg_claster.values(), key=lambda x: list(dic_seg_claster.values()).count(x))
```
Находим максимально частый кластер на картинке
Далее идет наш предыдущий код, но с некоторыми изменениями:
```
blobs_log = blob_log(image_gray, max_sigma=30, num_sigma=10, threshold=.05)
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
...
for blob in blobs_log:
y, x, r = blob
# новый фрагмент
if dic_seg_claster[segments[int(y), int(x)]] == max_l:
c = plt.Circle((x, y), r, color='purple', linewidth=2, fill=False)
count += 1
ax.add_patch(c)
...
```
И уже получаем результат получше.
1418 звездВысчитав статистическую вероятность, пришел к выводу, что погрешности на лишних объектах компенсируют невыделенные звезды.
Этот алгоритм ещё можно долго улучшать, подстраивать количество сегментов и кластеров. Но на данный момент я приостановлюсь.
Все ваши пожелания или негодования оставляйте а комментариях, мне будет очень интересно прочитать их, для того чтобы улучшить мой алгоритм до идеального состояния)
Готовый проект можно найти в [gitHub](https://github.com/LivelyPuer/Astrologer/tree/master)
Спасибо за внимание! | https://habr.com/ru/post/589003/ | null | ru | null |
# JavaScript фреймворки теперь можно хостить на Google
В блоге [AJAX Search API](http://googleajaxsearchapi.blogspot.com/) вчера был проанонсирован [AJAX Libraries API](http://code.google.com/apis/ajaxlibs/). Суть состоит в том, что Google теперь позволяет всем желающим использовать JavaScript фреймворки, размещенные на их серверах. Сам API представляет собой простой в использовании механизм для подключения к НТМL-документам наиболее популярных JS-библиотек, среди которых jQuery, prototype, script.aculo.us, MooTools и dojo. Список, по всей видимости, будет расширяться.
Подключить необходимую библиотеку можно двумя способами. Первый тривиальный, с помощью HTML-элемента script.
Как не сложно догадаться, вместо `prototype/1.6.0.2` можно указать название любого другого фреймворка и его версии.
Второй способ более гибок. С помощью специального JS-метода `google.load()` можно задавать версию библиотеки не точно, а по первым цифрам.
```
google.load("prototype", "1.6");
//
```
Заданное в примере значение «1.6» означает то, что будет автоматически выбрана самая свежая версия prototype в ветке 1.6. Таким образом, AJAX Libraries API может обеспечить автообновление JS-библиотек без каких-либо изменений в вызывающем скрипте (естветсственно, такое обновление ограничивается пределами нужной ветки).
К основным плюсам использования AL API можно отнести следующие:
* Хранение скриптов на Google в некоторой степени снижает нагрузку на собственный веб-сервер.
* Скорость загрузки страниц увеличивается, благодаря [переносу части запросов на другой хост](http://paradigm.ru/2008/05/11/circumventing-browser-connection-limits/) и поддержке gz-сжатия.
* При массовом использовании централизованно-хранимых фреймворков, кэш браузеров используется эффективнее. Файл, загруженный для одного веб-приложения, может быть повторно использован при работе с другим, использующим тот же фреймворк. Пока это лишь потенциальный бенефит сервиса, но, тем не менее, приятный.
* Кроме того, благодаря Google можно облегчать дистрибутивы веб-приложений, использующих JS-фреймворки.
### Ссылки по теме
* [Официальный анонс](http://googleajaxsearchapi.blogspot.com/) AJAX Search API.
* [Подробное описание](http://code.google.com/apis/ajax/documentation/) метода google.load().
* [Developers Guide](http://code.google.com/apis/ajaxlibs/documentation/), содержащий список поддерживаемых фреймворков с номерами версий.
* [Announcing AJAX Libraries API](http://ajaxian.com/archives/announcing-ajax-libraries-api-speed-up-your-ajax-apps-with-googles-infrastructure): Speed up your Ajax apps with Google's infrastructure @ [ajaxian.com](http://ajaxian.com/)
Кросспост с [paradigm.ru](http://paradigm.ru). | https://habr.com/ru/post/26344/ | null | ru | null |
# Как я год строил расширениe для браузера которое читает статьи голосом (с синхронизацией в подкаст)
[Не один раз](https://habr.com/post/275587) я пробовал использовать сторонние API для получения голоса из текста который мне интересно прочитать — можно переключить чтение на уши когда глаза устали, или слушать во время комьюта. Знаю я такой не один, даже люди далекие от айти бывает загружают куда-то текст и скачивают mp3. И подкасты/аудиокниги становятся все популярнее, и голосовые интерфейсы. Очевидно что аудитория есть, топовые экстеншены в маркете Хрома на эту тематику имеют сотни тысяч пользователей. Но голоса от Амазона обычно у них нет (лучший из доступных, лучше [нового от Гугла](https://cloud.google.com/text-to-speech)), а где есть нет чего-то другого, например возможности слушать в экстеншене — а не только добавлять в свой подкаст. Предложил идею проекта внутри компании — был получен апрув — пошла разработка.
Экстеншены для браузера это уникальное явление любимое многими — другие методы распространения ПО не имеют подобного механизма «мокинга» клиентской части. Например, десктопный клиент Evernote — невозможно сделать шрифт больше, невозможно сделать темную тему — только если хакать частично бинарные файлы ну и частично CSS — редактор в клиенте использует веб технологии. Тогда как мой поиск Гугла последние годы выглядит так:
Тут несколько расширений — темная тема, два превью картинкой (главной и страницы) и загрузка-превью в iframe по наведению мыши, без JS — благодаря этому загружается быстрее — и интересно видеть какой сайт без скриптов может работать какой нет — и понимать что все оставшиеся анимации сделаны чистыми стилями. И эти экстеншены были найдены и установлены из сторов — а там скриншоты и какая-то проверка на безопасность — то есть каждый сайт/сервис живет в среде где аддоны существуют имплисивно. Если ваш популярный сервис где-то неудобен — сообщество настрогает свои изменялки, иногда вплодь до мешапов — когда на одной странице могут оказаться данные из нескольких сервисов. Изменение владельцем сервиса DOMа или названий CSS классов может [сломать чье-нибудь воркфлоу](https://xkcd.com/1172/).
Благодаря userscrypt и userstyle мы можем менять внешний вид и функциональность сайтов — многим из нас иногда приятнее иметь свои кастомные заточки для сервисов ежедневного использования. Вот в Маке например Finder темным не сделать если авторы не позаботились, а они позаботились чтобы сторонние хаки для темирования работать перестали. В браузере все opensource — пока мы не дождались WebAssembly где разные языки смогут компилироваться в бинарники.
Несколько лет назад я делал свой первый экстеншен для Firefox — не было на нем переводчика через Яндекс. Я сделал так что перевод отображался в системном всплывающем окне — чтобы не засорять DOM страницы.
Работало шустро. На пике чуть больше 8k пользователей, спад в графике — после Firefox 57 где расширение перестало работать:
Давно не смотрел, думал сегодня вообще сто человек на старом браузере, оказывается еще несколько тысяч. Положительный рейтинг того опыта и добрые отзывы добавляли мотивации.
То расширение было некоммерческим личным pet project, тут же — первый опыт инкубатора внутри компании и расширение должно стать коммерчески успешным. В сердце продукта — лучший из доступных сервисов генерации голоса из текста — [Amazon Polly](https://aws.amazon.com/polly/). Недавно вышел синтез от Гугла: WaveNet который в рекламе звучал как человек, на самом деле оказался [хуже качеством](https://cloud.google.com/text-to-speech/) и в четыре раза дороже.
Первая версия бекэнда, точнее первый прототип для локальной машины, был написан на Питоне на встроенном сервере (интересно знать built in прежде чем переходить к фреймворкам, если они вообще будут нужны). Главная «проблема» была в разбиении текста по чанкам — лимит 1500 символов (у всех text-to-speech APIs приблизительно такой же лимит). Первый прототип был готов за несколько недель:
Казалось уже почти все и готово — ну еще UI, сайт, что-то еще и будет много пользователей.
Главной целевой платформой очевидно стал популярный Google Chrome. Начал изучать как устроен его WebExtensions. Оказалось что я попал в удачное время — как раз появился Firefox 57 где поддерживается этот формат — то есть можно написать один код для Chrome и Firefox, и даже для Edge, ну и для Opera — она вообще на движке Хрома. Здорово, тот мой старый экстеншен работал только в Firefox, ну а теперь и только до версии 57. Если вы в недавнем прошлом разработали расширение для Google Chrome — скорее всего сегодня оно будет работать и в Firefox. А также даже если автор расширения не озаботился этим — вы можете сами скачать архив аддона с Chrome Store и установить в Firefox — думаю только сейчас, с 60 версии Firefox, можно сказать что его имплементация WebExtensions стабилизировалась и избавилась от многих детских проблем.
Сначала я играл звук в так называемом popup UI — это то что вы видите когда нажимаете на кнопку экстеншена и появляется его интерфейс, но оказалось что как только это окно закрывается — эта обычная страница выгружается из памяти и звук перестает играть. Ок, играем из пространства страницы — это называется [Isolated Worlds](https://developer.chrome.com/extensions/content_scripts#isolated_world) где с вашим экстеншеном шарится только DOM, origin остается экстеншеновский (если вы не запрашиваете при установке права на доступ к страницам). Звук играл и с закрытым экстеншеном, но тут я на практике познакомился с Content Security Policy — на Medium не играло — оказалось там явно прописано откуда могут поступать медиа элементы. Осталось третье место откуда можно играть — background/event page. У каждого расширение есть три «страницы» — общаются они сообщениями. Event page значит что экстеншен существует в памяти только когда нужен — например отреагировал на ивент (клик), пожил несколько секунд и выгрузился (похоже на Service Worker). Firefox пока поддерживает только background page — экстеншен всегда в фоне. Проверил все свои установленные расширения — нашел несколько таких которые всегда в памяти, хотя функционально они только на ивенты реагируют, самое известное из них — Evernote Clipper. Отказаться от него я не могу, хотя после установки браузер работает явно медленнее. Они вставляют много своего кода в каждую открывающуюся страницу. Возможно это ускоряет отклик при клике на их кнопку, но думаю глобальное торможение это не оправдывает. Написал им об этом.
Вставляют код в страницу, даже в ваш приватный Google Doc — каждый маркетплейс с расширениями имеет автоматическую и ручную проверку кода на безопасность. В Chrome, насколько я понял, проверка автоматическая — люди смотрят только при варнингах, Firefox — всегда смотрит человек — и иногда вижу у них в блоге объявления что ищутся новые волонтеры на эту позицию. Opera — требует чтобы была приложена девелоперская версия кода с инструкцией как воспроизвести билд. Популярная проблема с Оперой — ревью происходит очень медленно, например наш экстеншен висит в очереди уже несколько месяцев — и еще не вышел в их магазине. Когда однажды все-же кто-то из Оперы начал проверять аддон на безопасность — дал красный свет по причине что хеш собранного архива отличался от хеша архива мною предоставленного.
Chrome Store несколько месяцев **удалял** расширение при каждом обновлении — и высылал стандартное письмо о возможных причинах — где не было описано ничего из нашего продукта. Каждый раз мы слали им письма и даже звонили.
Edge как всегда — там что-то не работало, но *devtools не открывался*, попробовал предрелизную сборку Windows — то же самое, [спросил на StackOverflow](https://stackoverflow.com/questions/48623669/porting-webextension-from-chrome-to-edge-dead-ico-and-empty-devtools) — ответа нет.
Столкнулся с проблемой что играние звука не мешает экстеншену выгрузиться — завел [баг](https://bugs.chromium.org/p/chromium/issues/detail?id=740097), написал забавный workaround:
```
function _doNotSleep() {
if (audioCurrent) {
setTimeout(_ => {
// only some http request, neither console.log() nor creating obj
fetch(chrome.runtime.getURL('manifest.json'));
_doNotSleep();
}, 2000);
}
}
```
Параллельно велась работа на серверной стороне. Ментор, который сам тоже и разработчик (хотя в этом проекте код не писал), убедил использовать DynamoDB для базы данных (NotOnlySQL от Amazon) и [Lambda](https://aws.amazon.com/lambda/) вместо классического сервера. Сегодня я наслаждаюсь лямбдами — это виртуальные машины (Amazon Linux, based on Red Hat) которые запускаются на ивенты, в моем случае — на HTTP запросы которые идут через Amazon API Gateway. Сегодня смешно вспоминать — но сначала когда я не понимал что лямбды это не EC2 — пытался использовать сервер Питона для обработки HTTP — только потом узнал что лямбды с интернетом связываются через API Gateway — то есть получается что отдельный сервис вызывает контейнер, на каждый запрос. Помимо HTTP лямбды могут просыпаться на другие ивенты — например обновление базы или добавление файла в S3. Если нагрузка повышается в сотни раз — запускаются сотни лямбд одновременно — scalability это один из продающих пунктов этой технологии. Лямбда живет максимум пять минут. Контейнер всегда обрабатывает только один запрос, контейнер может быть автоматически переиспользован для следующего запроса а может и нет. Все это заставляет немного изменить [стиль разработки](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html). Stateless — жесткий диск (пол гигабайта) только для временных файлов (у меня уже давно такой образ жизни что жесткий диск лаптопа тоже должен быть stateless — чтобы урон был минимален от потери данных — весь state в облаках, конфиги в git). Удивляюсь, но сейчас для такого маленького продукта уже используется десяток лямбд. Изоляция этих микросервисов делает код проще — вот этот экран листинга это и есть весь микросервис, вот этот экран кода — второй независимый микросервис. Понял почему lose coupling это хорошо.
Лямбды стали популярны, у Google Cloud и Microsoft Azure и Openstack есть свои аналоги. Встроенное ПО обновляется автоматически — security updates и обновления Питона происходят сами. На прочих проектах мы внутри компании для сервера первым делом рассматриваем Лямбды. Для своих личных задачек-микропроектов лямбды хороши еще и тем что стоят они доли цента, и если например вам нужно что-то автоматически запускать раз в месяц — лямбда может быть хорошим решением. При высокой нагрузке EC2 будет стоить меньше денег — но это если у вас не будет проблем с масштабированием и прочим maintenance.
DynamoDB просто работает, пока про него сказать нечего (пока вся база всего несколько мегабайт). Обещают автоматически масштабироваться. База популярна так что есть много готовых инструментов, например для экспорта. Плюс перед например открытым Postgres — можно сделать связь через API Gateway напрямую к API DynamoDB — без промежуточной Лямбды, [полиси доступа](https://aws.amazon.com/blogs/aws/fine-grained-access-control-for-amazon-dynamodb/) можно настраивать на уровне индексов и колонок таблицы. У меня почта пользователя (ключ таблицы) берется из верифицированного токена — API Gateway сам проверяет:
При создании HTTP endpoint без Лямбды можно написать входной запрос на сервис Амазона который имеет API и модифицировать выходную структуру — используя Apache Velocity синтакс, например обновление базы:
```
#set( $unixtime = $context.requestTimeEpoch / 1000 )
{
"TableName": "history",
"UpdateExpression": "SET isNew = :isNew, updated = :updated",
"ExpressionAttributeValues": {
":isNew": {"BOOL": $input.body},
":updated": {"N": "$unixtime"}
},
"Key": {
"email": {"S": "$context.authorizer.claims.email"},
"utc": {"N": "$input.params('id')"}
}
}
```
Плохо что при экспорте гейтвея вот этот код будет сохранен в одну строку, в каше с прочей информацией про эндпоинт, да еще при каждом экспорте может меняться сортировка строк — в Гите образуется месиво, труднее отслеживать изменения в таком коде:
При каждом открытии окна экстеншена идет запрос на «сервер» — для синхронизации истории и статуса (прослушано или нет) — API Gateway напрямую к HTTP API DynamoDB.
Получилось сделать так что при установке экстеншен не требует никаких разрешений — они не нужны если все что нужно это работа с текущим DOM и отправка его на сервер (даже без пермишенов — можно догадаться что ищут секьюрити сканы при публикации). Думал было придется вводить разрешение на коммуникацию с родительским сайтом для аутентификации — но обошлось — придумал что при открытии окна если не найден id\_token от Amazon Cognito — делается запрос на API Gateway -> Lambda где проверяется таблица state\_on\_tokens — есть ли там такой стейт (криптографическая строка), если есть — возвращается токен а эта запись в таблице удаляется.
Пока текст из HTML вынимается только на сервере (на Лямбде) — это позволяет использовать единый микросервис при получении текста/HTML из браузера и из писем. При наборе популярности и повышении нагрузки можно будет вынимать текст на клиенте (есть библиотеки), возможно так и работать будет быстрее.
Тексты и HTML мы у себя не храним, только полученный звук на S3. У каждого пользователя своя папка. При добавлении статьи проверяем — есть ли подпапка с таким же хешем, если есть — звук переиспользуется. Пока можно добавить две одинаковые статьи, возможно в будущем будем предупреждать если хеши совпадают.
Мы согласились что для такого экстеншена который добавляет и читает тексты логично было бы синхронизироваться с личным подкаст фидом — ну разумеется, я же сервис для себя делаю в том числе, мне такая функциональность нужна. Оказалось что кроме не лучшего сегодня mp3 можно использовать более эффективный aac — Андроид воспроизводит его с четвертой версии. Месяц возился с разными методами сшивания ogg чанков в единый файл, пробовал ffmpeg, libav, что-то еще, переписывался с Амазоном и багтрекерами проектов — звук получался с дефектами. Остановился на минимальном решении, как я и люблю — ничего личшего — одна бинарная программа декодирует ogg в wav ([oggdec](https://github.com/xiph/vorbis-tools/tree/master/oggdec)), вторая из пайпа энкодит aac ([fdkaac](https://github.com/nu774/fdkaac)) — Питон выполняет shell комманду:
```
f'''cd /tmp;
curl {urls} |
/var/task/oggdec - -o - |
/var/task/fdkaac -m5 - -o {episode_filename}
--title="{title_escaped}"
--artist='Intelligent Speaker'
--album-artist='Intelligent Speaker'
--album='Intelligent Speaker'
--genre='Podcast'
--date='{date}'
--comment='Voiced text from {url_article or "email"}'
'''
```
Тут в *--comments* может быть линк на оригинальную страницу (если текст не был отправлен почтой) — оказалось что на iOS встроенный подкаст проигрыватель может удобно показать что за линкой.
Когда пользователь получает ответ что статья добавлена — на самом деле мы только выняли текст из HTML и вернули хеш этого текста (который работает как ссылка), пока пользователь двигает мышь к кнопке Play — звук еще только синтезируется. Когда начал слушать статью — звук возможно готов еще не для всего текста, так что при перемотке иногда нужно ждать. После рендера последнего чанка звука — запускается еще одна Лямбда в этой цепочке — которая генерирует m4a для подкаста и модифицирует xml файл фида.
У Лямбд есть [лимит](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) на передачу payload в другую лямбду — всего 128 килобайт. Написал обработчик исключения — использовать отдельный транзитный бакет а передавать в лямбду синтезирования звука хеш файла, в бакете настроено полиси на удаление файла через сутки (минимальное значение).
Для кодирования звука рассматривал [Amazon Elastic Transcoder](https://aws.amazon.com/elastictranscoder/), но удивился что звук там можно получить только со статическим битрейдом — а я хотел динамический для лучшей компрессии. Даже письмо в саппорт писал — как может быть что нет такой базовой опции, может она в другом месте или я не понял чего-то? Ответили что и правда кодирование только в статический:
Если текста много — пяти минут дешевой лямбды может не хватит — поэтому выставил максимальный CPU — хватит скодировать часов шесть за раз.
У каждого пользователя есть inbound email как в Эверноут — вижу в телефоне интересную статью — шарю в почтовую программу и отправляю линк или текст (из любой программы) на личный адрес, переключаюсь на программу с подкастами — новый эпизод уже здесь — запускаю проигрывание и продолжаю крутить педали на снегу. Это значит что можно использовать сторонний сервис который отправляет письмо на каждый новый пост из RSS — это значит что вы можете подписаться на блог в виде подкаста. На телефоне пока экстеншен не работает — хотя Firefox и YandexBrowser для Андроида поддерживают расширения но там я вижу только UI с нерабочими кнопоками; или дождусь Progressive Web Apps для iOS когда в него можно будет шарить как в нативную программу. Хотя входящая почта уже предлагает такую функциональность — еще и в отправленных останутся линки.
При имплементации поиска на клиенте столкнулся с предупреждением Хроме *Violation Long running JavaScript task took xx ms*. Ну, что-то там медленно работало, не критично, ладно, решил покопать, поизучать красивый профайлер Хрома:
Много операций, перерисовки, поэтому подтормаживает.
Нашел что это происходит при фильтрации и изменении класса нужных нод:
```
search.addEventListener('keyup', function() {
for (const node of nodes)
if (node.innerText.toLowerCase().includes(this.value.toLowerCase()))
node.classList.remove('hidden');
else
node.classList.add('hidden');
});
```
Ну что тут поделаешь, но предчувствие продиктовало мне попробовать оптовый подход:
```
search.addEventListener('keyup', function() {
const nodesToHide = [];
const nodesToShow = [];
for (const node of nodes)
if (node.innerText.toLowerCase().includes(this.value.toLowerCase()))
nodesToShow.push(node);
else
nodesToHide.push(node);
nodesToHide.forEach(node => node.classList.add('hidden'));
nodesToShow.forEach(node => node.classList.remove('hidden'));
});
```
Операций больше, кода больше, а работать стало сильно быстрее:
Тут видно что на самом деле браузер делает гораздо меньше операций.
Одно из лучших решений при разработке продукта — после удаления показывать форму обратной связи. Использовал обычный Google Forms:
Заказали сайт/landing — их портфолио было красивым. Но оказалось что наш сайт делали другие люди:
Был у нас на примете один похожий продукт, я и маркетолог посмеивались над его сайтиком с нерабочей главной линкой на стор — тут стало ясно что наш выглядит хуже. Так мы и жили несколько месяцев с таким дизайном. Потом ментор решил заказать другой сайт у другой комманды, с нашими доработками получилось лучше:
Вот так он и [выглядит](https://intelligent-speaker.com/) сейчас. Не идеально, надо дорабатывать, но мне нравится agile подход — сначала сделаем как-нибудь, потом сделаем получше, потом еще чуть лучше. Потому что не знаю что можно улучшить. Одна из причин написания этой статьи — получение обратной связи.
Отзыв от Larry настоящий — ему так понравился продукт (точнее голос Амазона) что он на своей новой книге поместил наш логотип, вот это да. Я был удивлен что люди пользуются Интеллиджент Спикером для пруфридинга (когда писал статью и читаешь ушами чтобы почувствовать под другим углом) и при дислексии. Например пришло благодарственное письмо от американского тренера что как ей здорово теперь слушать тексты.
Для хостинга сайтика изначально был выбрал GitHub — я уже имел опыт работы со статическими сайтами используя его возможность добавить свой домен. Но как тогда оказалось — свой домен невозможно держать на Гитхабе с SSL сертификатом. Сегодня уже [можно](https://blog.github.com/2018-05-01-github-pages-custom-domains-https/) (с этого месяца кстати), но в 2017 по этой причине я смигрировался на GitLab. Пришлось писать первый в моей жизни ci чтобы сайт копировался из одной папки в другую — минимальный процесс работы со static pages. Не всегда этот (бесплатный замечу) ci работает — какие то проблемы GitLab, но в общем я доволен им, недавно узнал что у них был вот такой старый логотип
Ого, эта харизма мне любее шаблонного
LastPass показывает лучшую версию:
Хм а еще нет экстеншена чтобы был старый логотип? Видел [похожие](https://chrome.google.com/webstore/detail/some-rich-asshole/hgcjjgnlnheojgpdiafpdnjjpbkedgfh) [шуточки](https://chrome.google.com/webstore/detail/ncage/hnbmfljfohghaepamnfokgggaejlmfol).
Сегодня ci для сайта в том числе минифицирует HTML/CSS/JS — давно хотел имплементировать эту best practice, обычно этим не заморачиваются — есть задачи приоритетнее. После минификации — создаются gz архивчики для каждого файла — теперь даже на этом бесплатном статическом хостинге мы получили Content-Encoding: gzip, надеюсь Гугл от этого будет ранжировать выше и у пользователей будет быстрее открываться (а кажется отдает Гитлаб не быстро).
Ci написан и для сборки-публикации экстеншена: минификация и HTTP POST. Запускается локально вручную — можно было бы ввернуть на тот сервер где живет Git экстеншена — в нашем случае [VSTS](https://www.visualstudio.com/team-services), но пока незачем. Сайт живет в submodule — возможно стоило иметь один репозиторий, но тогда я думал что незачем гонять в Гитлаб код который не относится к сайту — тем паче еще чтобы ci запускался, хотя да можно настроить чтобы сайт собирался только при пуше в определенный бранч.
Первая версия UI экстеншена выглядела так:
Потом ментор сказал что путь студия сделает нормальный дизайн:
Чувствовали что надо лучше.
Решили попробовать Material — мы не против нераздражающей безликости, пусть чувствуется как часть браузера, и думаю это повышает шансы стать Featured в Chrome Store — ведь визуальный стиль от той же компании. Хотя сегодня нам уже [объяснили](https://material.io/design/material-studies/rally.html) что Материал это не значит когда все одинаковое. Сегодняшний итог:
Фишка продукта в том что он будет не только детектить текст для чтения как readability mode, но и хитро адаптировать текст для озвучивания — например чтобы было удобно слушать дерево комментариев когда ники, даты, цитирования будут читаться другой интонацией. Это еще в планах, начать планируем с Reddit. Но уже на ранней стадии разработки стало понятно что возможностей библиотек для дистилляции HTML не хватает — например в Википедии[0] остаются[1] вот[2] такие[3] штуки[4], Google Doc вообще не подхватывался (а хотелось получить плашку в Chrome Store что мы его поддерживаем). Решение — для Википедии используется их API, для Google Doc — хитрый код для получения выделенного текста и всего документа — чтобы не просить у пользователя разрешения на доступ ко всему Google Drive. Выбрали десяток других популярных сайтов и проверили/адаптировали чтение на них.
Ментор с маркетологом решили что обязательно нужен блог с социальными сетями. Начал искать статический блогогенератор — для скорости, простоты, дешевизны и безопасности. Если я себе когда-нибудь открою блог — то только в виде продукта статического генератора — чтобы в Гите хранились все посты. От моего доброго друга ~~Марселя Пруста~~ [umputun](https://habr.com/ru/users/umputun/) слышал что [Hugo](https://gohugo.io/) хороший. Несколько дней изучения, тестов, выбора темы — блог готов. Сначала мы хранили в Гите сгенерированные асеты, потом я дописал ci на Гитлабе чтобы собирал там же — чище Гит, маркетологу проще добавлять посты (думал вообще не получится научить это прекрасную девушку писать посты в блокноте маркдауном и пушить). Для сборки сайта используется контейнер Ubuntu в который устанавливается все что нужно — в том числе и Hugo — и получается что когда Hugo обновится — при пуше нового поста в Гит — на сайте «движок» блога тоже обновится, красота. Хотя для безопасности лучше не иметь внешних зависимостей — чтобы сайт собрался даже когда GitHub недоступен.
Однажды начитавшись про Go, любимши быстрое выполнение и всякие оптимизации, написал минимальный тест — HTTP GET — оказалось такая Лямбда отрабатывала быстрее, нагугленные бенчмарки показывали высокую скорость. Следующий микросервис писал уже на Go — теперь это мой основной серверный язык вместо Питона. Понравилось наличие встроенного инструмента `go fmt` для форматирования кода, ну вы знаете, это всем нравится, хоть там и табы. Для преобразования JSON строки в объект надо заранее описывать структуру — после Питона и JS это казалось невероятным — зачем? Еще более невероятным оказалось что в массивах (arrays или slices) нет метода contains() — приветствую минимализм, но неужели это корректный дизайн языка когда нужно писать свой цикл для такой базовой вещи? Другие незначительные минусы Go перед Питоном — деплой на Лямбду это скопмилированный исполняемый файл — то есть например 6 мегабайт а не килобайт кода (надо ждать несколько секунд), а также все-же больше кода (уровень абстракции иногда ниже, но мне нравится лучше понимать как оно работает). Приятно что компилируеммый код безопаснее — меньше ошибок в рантайме, а типы в Питоне я и так писал с 3.5 — с типами языки быстрее (но в Питоне типы только для валидации), понятнее и безопаснее. [Golang тоже имеет аналог duck typing](https://medium.com/@matryer/golang-advent-calendar-day-one-duck-typing-a513aaed544d) через имплисивные интерфейсы — если есть нужные методы — значит объект подходит под интерфейс.
Я думал — почему Go а не например Java? Я не тестировал сам, но читал что на Лямбде холодный старт будет дольше. Возможно можно написать лямбду которая будет держать все другие лямбды теплыми и использовать Java, возможно. Не люблю прыгать по технологиям, мне больше нравится углубляться и совершенствоваться в текущем стеке, но тут уж скорость Go плюс его общая положительная оценка индустрией и то что Лямды его теперь поддерживают да так что Амазон все свои SDK написал и на Go тоже — хотя это технология от конкурирующей корпорации — переход того стоил. В нашей небольшой компании на другом проекте тоже переходят с Питона на Go.
Из Go мне понравился один из стейтментов что [A little copying is better than a little dependency](https://go-proverbs.github.io/), это тоже один из моих девизов, то есть я стараюсь не бабахать библиотеку ради экономии пяти строк. Один из моих любимых экстеншенов имеет 639 зависимостей, можете себе представить:
С ранней стадии экстеншена была возможность проигрывать из контекстного меню, а когда играет — ставить на паузу и перематывать на чанк вперед-назад:
Но было принято решение сделать UI удобнее в ущерб функциональности — вместо вложенного меню теперь только один пункт который добавляет страницу или выделенное в список:
Это решение далось трудновато, но я вижу основной историей добавление страниц для прослушивания потом, а слушать сразу ведь все еще можно — только нужно открыть окно экстеншена и play.
Логотип как видите тоже поменялся — во время прототипирования сайта девочка дизайнер поставила загрушку — этот квадрат нам показался лучше попугая.
Тестирование: Селениум не может открыть окно расширения, поэтому использую его в связке с [pyautogui](https://github.com/asweigart/pyautogui) для кликов и [scikit-image](http://scikit-image.org/) для сравнения ожидаемого и текущего изображения. Никогда еще такого не делал, это интересно — таким образом я могу тестировать CSS.
Весь код на протяжении года (и раньше) я писал в [Виме](https://www.youtube.com/watch?v=md9-ftG_-O8). Узнал еще больше об этом великолепном редакторе. Настало то время когда я почувствовал что в Виме действительно продуктивен. Волшебный peace of software. Во всем айти для меня Вим стал особенностью индустрии которая составляет the best parts. В нем есть свой стиль. И предустановлен во многих местах — ssh кудаугодно — рабочая среда остается удобной, он даже у меня в Андроиде из коробки есть. Плагины расширяют функциональность, а с недавнего времени поддерживается их асинхронная работа. У меня есть линтеры-анализаторы, возможность посмотреть предыдущую версию ханка гита, какой-то рефакторинг (переименования функций во всех местах), букмарки в коде, хексы цветов выделены его цветом, и везде темный цвет — помню в Intelligent IDEA на нескольких мониторах во внешних окнах было невозможно избавится от белой рамки маковского окна. Видел и более sophisticated плагины как-то подсказки, документации при написании, интеграции с внешними утилитами, но в Виме и так много всего спрятано — и внешние комманды к выделенному тексту можно легко выполнять — например посчитать количество символов ([wc](https://linux.die.net/man/1/wc)) или перевод выделенного текста ([trans](https://github.com/soimort/translate-shell)). Несколько раз слышал жалобы что в Виме что-то нельзя сделать — а на самом деле можно. Довелось работать и на Salesforce используя соответственный [плагин](https://github.com/neowit/vim-force.com) — прямо из Вима запускал тесты на удаленном сервере. Помню как воспринимал фрикерством когда слышал что кто-то *работает* в Виме или Емаксе, но со мной это тоже произошло. Не призываю попробовать — действительно нужно время чтобы разобраться как делать базовые операции, нужны инвестиции времени и сил чтобы добраться до мякоти.
Сегодняшняя аналитика в Chrome Store:
Изменение темпов роста между декабрем и февралем — добавили локализацию в экстеншен на все языки что читает Polly — так что теперь например для франзузской выдачи мы стали выше. Думаю локализация сайта даст такой же эффект. Статистика сайта:
Рост оказался ниже планируемого, хотя платной рекламы нет — только органический трафик. Шесть человек подписались за $6.99 в месяц. Возможно со временем цифры начнут расти. Что думаете?
Вот такая история моего года. | https://habr.com/ru/post/358374/ | null | ru | null |
# Блокировка нежелательного DNS трафика
У Вас может быть идеально настроено конечное сетевое оборудование, полный порядок в кластерах, могут быть пустыми магистрали и не нагруженное оборудование ядра сети, но если у Вас плохо работает DNS, то Ваши клиенты будут недовольны.
Отсюда следует простой вывод — Ваши рекурсивные DNS сервера должны быть всегда доступны и в состоянии обслужить запросы клиента.
Все статьи о настройке производительного DNS сервера начинаются примерно так: «давайте померяемся различными параметрами различных рекурсивных DNS серверов и выберем из них самый-самый, и будет нам счастье». Могу сказать заранее, счастье таким методом наступит, но не на долго.
Следующим шагом идёт наращивание мощностей самого сервера. Данным методом счастье тоже достигается, но при стабильном росте абонентской базы оно быстро заканчивается.
Вы спросите, какое-же решение задачи существует, точнее, что же делать в данной ситуации?
Ответ прост — необходимо ограничивать количество рекурсивных запросов определённых типов от каждого из наших клиентов. **К огромному сожалению ни в одном из ныне существующих DNS серверов нет средств ограничения количества запросов определённого типа для каждого из рекурсивных клиентов**. Мы возложим данную задачу на пакетный фильтр, в приведённых ниже примерах используется iptables.
В большинстве случаев от завирусованных клиентов идет шквал DNS запросов различных типов, огромное количество MX запросов направленных на поиск ip адресов почтовых серверов, запросы типа A для экзотических доменов типа kljhajlhfqweqwe.com или ioweurtisdvfso.org.
По нашим грубым оценкам 3% клиентских машин генерировали более 90% всех DNS запросов.
Простой обзвон клиента зачастую проблему не решает, ибо клиента может и не быть дома, клиент не обладает квалификацией или же просто клиент не хочет лечиться (у меня и так все работает). Также зачастую при отключении клиентского порта, провайдеры оставляют открытым трафик до DNS сервера чтобы клиент мог войти в свой личный кабинет по его имени и посмотреть причину блокировки, но т. к. клиентский компьютер «валит» именно DNS сервер, то для решения данной проблемы надо искать другой выход.
Итак нам необходимо решить две простые задачи.
1.Определить все допустимые типы DNS запросов которые мы будем обрабатывать.
2.Найти разумные интервалы поступления запросов каждого типа от каждого клиента.
Давайте разберём запросы каких типов могут приходить от наших клиентов и что нам с ними делать.
Запись A (address record) или запись адреса связывает имя хоста с адресом IP. Самый «наиполезнейший» тип запросов. Значения 100 запросов за 10 секунд вполне приемлемы даже для тех клиентов, которые серфят «ну очень быстро» :)
Запись AAAA (IPv6 address record) связывает имя хоста с адресом протокола IPv6. Пока IPv6 распространён не сильно, можно оставить данный тип запросов к нашему DNS серверу, ограничив двумя запросами в 10 секунд от каждого из клиентов, чтобы пустые запросы типа AAAA localhost. не влияли на работу DNS сервера.
Запись CNAME (canonical name record) или каноническая запись имени. Тип запроса полезный, блокировка должна быть мягкая чтобы запросов подобного типа блокировалось как можно меньше. Также как и для запросов типа A 100 запросов за 10 секунд вполне приемлемое значение.
Запись MX (mail exchange) или почтовый обменник указывает сервер(ы) обмена почтой для данного домена. Для домашних клиентов интенсивные запросы к данным типам записей явно свидетельствуют о том, что компьютер клиента заражен заразой которая рассылает спам. 5 запросов за 60 секунд хватит для работы диагностических утилит.
Запись NS (name server) указывает на DNS-сервер для данного домена. Напрямую пользователи услуг домашнего Интернет такие запросы не генерируют, в большинстве случаев такие запросы формируются вручную через диагностические утилиты типа nslookup в целях отладки работоспособности своих доменов и пр. 10 запросов данного типа за 60 секунд вполне приемлемое значение.
Запись PTR (pointer) или запись указателя связывает IP хоста с его каноническим именем. Применительно к пользователям услуг домашнего интернета запросы подобного типа поступают достаточно часто во время работы торрент или p2p клиентов, для разрешения имен хостов с которых вы скачиваете и которым вы раздаете. Например 50 запросов за 10 секунд вполне приемлемое значение, которого в большинстве случаев хватает для любого пользователя.
Запись SOA (Start of Authority) или начальная запись зоны указывает, на каком сервере хранится эталонная информация о данном домене, содержит контактную информацию лица, ответственного за данную зону, тайминги (параметры времени) кеширования зонной информации и взаимодействия DNS-серверов. Данный тип запросов может использоваться пользователями домашнего интернет только в целях отладки, разрешим каждому клиенту делать 5 запросов за 60 секунд.
Запись SRV (server selection) указывает на серверы для сервисов. Данный тип запросов может использоваться пользователями домашнего интернет только в целях отладки, разрешим каждому клиенту делать 5 запросов за 60 секунд.
Полный список типов DNS записей можно просмотреть [здесь](http://en.wikipedia.org/wiki/List_of_DNS_record_types).
Для того чтобы понять по каким сигнатурам нам классифицировать тот или иной DNS запрос необходимо «поймать» tcpdump-ом по одному типу пакета, заглянуть в тело запроса поле Type и убедиться что:
запрос типа MX содержит в поле type — 00 0F
запрос типа AAAA содержит в поле type — 00 1C
запрос типа A содержит в поле type — 00 01
запрос типа PTR содержит в поле type — 00 0C
запрос типа CNAME содержит в поле type — 00 05
запрос типа NS содержит в поле type — 00 02
запрос типа SOA содержит в поле type — 00 06
запрос типа SRV содержит в поле type — 00 21
Заметим также, что в DNS запросе после поля Type идёт поле Class оно всегда равно 00 01 для DNS запроса. Добавим это поле ко всем сигнатурам чтобы уменьшить количество ложных срабатываний.
Итак чтобы заблокировать DNS запросы типа MX нам необходимо на DNS серверах добавить правила iptables:
`-A INPUT -p udp --dport 53 -m string --algo kmp --hex-string "|00 0F 00 01|" -j DROP`
так как нам надо закрыть данные запросы не полностью а просто ограничить их количество в единицу времени чтобы данные запросы не «ложили» нам сервер просто добавим в правила модуль recent.
Например правило которое ограничивает поступления DNS запросов типа MX в 5 запросов за 60 секунд будет выглядеть так:
`-A INPUT -p udp --dport 53 -m state --state NEW -m string --algo kmp --hex-string "|00 0F 00 01|" -m recent --set --name MXFLOOD --rsource
-A INPUT -p udp --dport 53 -m state --state NEW -m string --algo kmp --hex-string "|00 0F 00 01|" -m recent --update --seconds 60 --hitcount 5 --rttl --name MXFLOOD -j DROP
-A INPUT -p udp --dport 53 -m string --algo kmp --hex-string "|00 0F 00 01|" -j ACCEPT`
Аналогичным образом ограничиваются и другие типы DNS запросов.
Так как DNS типов существует превеликое множество и мы разрешили все нужные нам типы DNS запросов, то было бы неплохо запретить все остальные запросы чтобы они не обрабатывались вашим DNS сервером.
`-A INPUT -p udp --dport 53 -j DROP`
Данные простейшие правила позволили нам сократить количество одновременных рекурсивных DNS запросов к нашим DNS серверам более чем в 20 раз (c 10000 до 400), без жалоб на работу DNS со стороны наших пользователей. | https://habr.com/ru/post/110771/ | null | ru | null |
# Crossfilter.js, dc.js и D3.js для визуализации Данных
Приветствую ценителей красивой и функциональной визуализации данных! Предлагаю вашему вниманию небольшой обзор нескольких **JavaScript** библиотек, которые вкупе с [D3.js](http://d3js.org) позволят создать интерактивную визуализацию многомерных данных с возможностью применения фильтрации «на лету».
Заинтересовались, тогда добро пожаловать под кат.
*Примечание: Данная статья является в некоторой степени компиляцией нескольких статей из замечательного блога [www.d3noob.org](http://www.d3noob.org), переработанных и дополненных в соответствии с моим видением задачи визуализации данных.*
***Источник вдохновения:*** [Crossfilter, dc.js and d3.js for Data Discovery](http://www.d3noob.org/2013/07/crossfilter-dcjs-and-d3js-for-data.html)
* [Introduction to dc.js](http://www.d3noob.org/2013/07/introduction-to-dcjs.html)*
#### Визуализация данных и аналитика
У нас в стране инфографика в основном ассоциируется с картинками, созданными дизайнерами (иногда весьма недурно), хотя последнее время стало активнее развиваться ещё и видео. Это лишь вершина айсберга, которую оккупировали маркетологи, истинная же мощь доступна лишь ~~водолазам~~ аналитикам-программистам. Но о сложившейся ситуации как-нибудь в другой раз, а сейчас давайте вернёмся к интерактивной инфографике. Обычно под словом «интерактивная» подразумевается возможность отображать тултипы, менять масштаб, иногда применять фильтры и менять структуру данных, но всё это, как правило, подчиняется заранее продуманной логике (сценарию). А теперь представьте, что вы можете управлять потоком данных сами, с минимальными ограничениями, представьте, что вы можете задавать произвольные простые (без формул) фильтры, не ограничиваясь выбором из списка. А теперь представьте ещё больше, а именно: все изменения практически мгновенно отображаются на всех графиках, представляющих многомерный массив данных. Звучит неплохо, не так ли?
#### Crossfilter.js
[Crossfilter](http://square.github.io/crossfilter/) это JavaScript библиотека для работы с многомерными данными в браузере. Crossfilter обеспечивает экстремально быстрое взаимоизменение (менее 30мс) связанных между собой представлений данных (срезов многомерных данных) даже если входные данные содержат более миллиона строк. Библиотека создана людьми, имеющими непосредственное отношение к [d3.js](http://d3js.org), это [Mike Bostock](http://bost.ocks.org/mike/) и [Jason Davies](http://www.jasondavies.com/).
В основе работы с данными лежат принципы модного нынче [Map-Reduce](https://en.wikipedia.org/wiki/MapReduce). Для человека, который с этим прежде не сталкивался всё это звучит довольно сложно и запутанно, так что давайте разбираться. Итак что обычно делают с многомерными данными (вспоминаем сводные таблицы из Excel)? Их обычно группируют всевозможными способами, суммируют, сортируют, подсчитывают частоту вхождения значений и т. д. За это и отвечает ***Reduce***, а ***Map*** обеспечивает параллельное вычисление всех этих манипуляций. Конечно в реальности всё ~~немного~~ сложней, но, думаю, для первого приближения сойдёт.
#### Так что же может crossfilter
Как говорится, лучше один раз увидеть, а сделать это можно на [Github странице библиотеки](http://square.github.io/crossfilter/).
Перед нами информация о `231,083` полётах в различных разрезах. Здесь мы видим пять представлений данных: четыре столбчатых диаграммы и одна таблица. На графике `Time of Day` отображено распределение полётов в зависимости от часа. `Arrival delay` показывает распределение количества задержек рейсов, сгруппированных в 10-ти минутные интервалы. `Distance` показывает распределение рейсов по дальности полёта (интервал 50 миль). `Date` — количество рейсов в день. И всё это было отрендерено на стороне клиента, то есть у нас в браузере, согласитесь, неплохо для такого количества данных.
В центре графика `Date` вы можете увидеть окно, ограничивающее рабочий диапазон, аналогичные окна вы можете задать мышкой и на остальных графиках, при этом все графики будут скоординировано изменяться в соответствии с наложенными фильтрами. Таким образом, нам открываются широкие возможности для анализа данных «на лету».
И самое главное, всё это великолепие **«Released under the Apache License 2.0»**.
#### DC.js спешит на помощь
Если вы посмотрите [код демо-примера](https://github.com/square/crossfilter/blob/gh-pages/index.html) для [crossfilter](http://square.github.io/crossfilter/), вы увидите, что он занимает более 500 строк. Всё потому, что crossfilter создавался не для визуализации данных, а для манипуляции ими. [D3.js](http://d3js.org) же, в свою очередь, создавался как раз для визуализации данных. Тут нам на выручку приходит библиотека [dc.js](https://github.com/NickQiZhu/dc.js) за авторством [Nick Qi Zhu](https://github.com/NickQiZhu), которая связывает две интересующие нас технологии в один мощный инструмент. К сожалению, все [многообразие графиков D3.js](https://github.com/mbostock/d3/wiki/Gallery) нам доступно не будет, но тех что реализованы в [dc.js](http://nickqizhu.github.io/dc.js/) достаточно для большинства случаев. DC.js поддерживает следующие типы графиков:
* Bar Chart
* Pie Chart
* Row Chart
* Line Chart
* Bubble Chart
* Geo Choropleth Chart
* Data Table
Примеры реализованных графиков можно посмотреть на [Github странице проекта](http://nickqizhu.github.io/dc.js/). Библиотека тоже опубликована под лицензией [«Apache License 2.0»](http://www.apache.org/licenses/LICENSE-2.0.html).
#### Больше инфографики красивой и функциональной
Ну вот, теперь вы знаете ещё несколько инструментов визуализации данных и можете создавать многокомпонентные графики с фильтрацией «на лету». Успехов вам в реализации ваших замыслов.
#### Хаб, посвящённый визуализации данных
Дорогие хабровчане, как вы смотрите на создание хаба **Data visualization** или **Визуализация данных**? Потому что сейчас из близких тематических хабов существует только хаб [Инфографика](http://habrahabr.ru/hub/infographics/), но он посвящён собственно инфографике (результатам), а не процессу её создания. Определения этих двух терминов можно найти в википедии: [Infographic](https://en.wikipedia.org/wiki/Infographic), [Data visualization](http://en.wikipedia.org/wiki/Data_visualization).
Так что всех заинтересованных прошу выразить своё мнение по данному вопросу. | https://habr.com/ru/post/189838/ | null | ru | null |
# Инструмент автоматизации управления версиями
Всем привет!
Всегда было интересно, что такое версии продукта и как ими управлять? Как автоматизировать управление версиями разработки? Прошу под кат.
Меня зовут Роман. Я разработчик в очень интересной компании Softeq, где каждый человек — вдохновитель.
При разработке различных инструментов я впал в размышления о том, всем ли разработчикам известно, что же такое версия, какой смысл она несет и как ей управлять при разработке. Итак, давайте рассмотрим, что же такое версионирование.
### Версионирование
Версионирование — разработка и управление несколькими выпусками продукта, которые имеют тот же общий функционал, но усовершенствованы, модернизированы либо индивидуализированы.
Коротко, версия говорит об изменении продукта. Как версия говорит об изменении продукта?
Давайте назовем систему упорядочивания символов для обозначения версии продукта — схемой версионирования. [Различные схемы](https://en.wikipedia.org/wiki/Software_versioning#Schemes) версионирования были созданы для отслеживания версий различного программного обеспечения.
### Семантическое версионирование
Схем версионирования много, но мы сталкиваемся с [Семантическим версионированием (Semantic Versioning)](https://semver.org/) каждый день. Для Семантического версионирования характерно то, что номера версий и то, как они меняются, передают смысл содержания исходного кода и какие модификации были применены от одной версии к другой.
Рассмотрим, каким образом формируется номер Семантической версии.
Давайте представим, что у нас имеется проект в разработке. Главная задача проекта — управление построением библиотеки. Проект позволяет производить заказ материалов для построения здания, контролировать этапы построения библиотеки. В настоящее время спроектирована архитектура приложения, произведена реализация базовых задач. При тестировании функционала заказа материалов для построения здания библиотеки обнаруживается ошибка, *bug*. Производится исправление ошибки и повышается **Patch** версия проекта.
У заказчика возникла идея о необходимости внедрить анализ маркетинговой информации в проект. Разработчики искусно и быстро спроектировали сервисы анализа данных, интегрировали сервисы с актуальной архитектурой. Произведено добавление новой функциональности проекта, которая не нарушает [обратной совместимости](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D0%B0%D1%8F_%D1%81%D0%BE%D0%B2%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D1%8C). Повысилась **Minor** версия проекта.
Проект был успешно реализован. Через некоторое время у заказчика возникла идея по развитию данной технологии автоматизации бизнеса. В предстоящих планах были совершенно новые сервисы: формирование команды строителей, внутренняя социальная сеть, внутренний обмен документами и прочее. Разработчики проявили высокую компетентность, и через некоторое время архитектура проекта была спроектирована для решения и новых, и старых задач. Новая архитектура проекта внесла обратно несовместимые изменения. Повысилась **Major** версия проекта.
**Полная картина выглядит так, но с ней вы сталкиваетесь редко.**
---
---
Итак, мы представляем, что же такое версии продукта. Но как ими управлять?
Давайте рассмотрим инструмент автоматизации управления версиями.
### Versionings
NPM: <https://www.npmjs.com/package/versionings>
GitHub: <https://github.com/morozow/versionings>
Управление версиями производится при помощи командной строки:
```
versionings --semver=[ | patch | prepatch | minor | preminor | premajor | prerelease | major] --branch=[ | any-hyphen-case-less-100-characters-string] [--push]
```
Актуальная версия продукта хранится как в ./package.json файле проекта, так и в Git тегах и ветке повышения версии. Автоматизация имеет возможность интеграции с различными сторонними инструментами — управление версиями производится через CLI команду.
Давайте рассмотрим пример повышения версии продукта.
### Действия
Ведется разработка проекта актуальной версии *2.5.3*. Разработка нового сервиса проекта ведется в ветке *crm-user-service*. Завершилась разработка сервиса, закоммичены все изменения и принято решение о повышении минорной версии:
```
versionings --semver=minor --branch=user-service --push
```
### Результат
1. Новая ветка: version/minor/v*2.6.0*-*user-service*
2. Изменение версии в `./package.json`: *2.5.3* -> *2.6.0*
3. Commit новой версии продукта в веткe version/minor/v*2.6.0*-*user-service*
4. Push новой ветки с реализацией сервиса и повышенной версии продукта.
5. Создание Pull Request для ветки version/minor/v*2.6.0*-*user-service*, которая содержит реализацию сервиса и повышенную версию продукта
### Замечания
* Инструмент автоматизации ориентирован на Unix среду
* Пример проекта для построения библиотеки является абстрактным, для общего представления версионирования.
На этом все :)
Всем продуктивного настроения и отличного дня! | https://habr.com/ru/post/433994/ | null | ru | null |
# Математические вычисления и графики в LyX с использованием Sage
[LyX](http://www.lyx.org/) — это WYSIWYM процессор документов, который прозрачным образом работает с LaTeX. То есть пользователь создаёт в этом процессоре файлы \*.lyx, из которых потом создаются и компилируются \*.tex.
[Sage](http://www.sagemath.org/) — это система компьютерной алгебры, работающая прозрачным образом с другими математическими пакетами. Основной интерфейс — командная строка, при этом используется всё многообразие возможностей python. Также доступен web-интерфейс, который можно опробовать на сайте разработчиков.
Совместное использование этих двух разработок открывает интересные возможности. Например, можно создавать отчёты, в которых вычисления, графики и аналитические выкладки будут выполняться автоматически, почти как в маткаде каком-нибудь, но с наглядной структурой LyX, гибкостью python и возможностями вёрстки LaTeX.
[](https://habrastorage.org/storage/habraeffect/6b/4b/6b4b8e47ab3f499ef1d94d7d77e36e61.png)
[](https://habrastorage.org/storage/habraeffect/bd/5c/bd5cae0d6b33eec3ef8447d1a53d60cb.png)
#### Установка
LyX есть почти в любом современном дистрибутиве, так что устанавливается обычным образом. Он написан на Qt, есть порт под Windows. LyX потянет за собой LaTeX.
С Sage всё не так просто. Он сейчас есть только под linux, в дистрибутивах, если и представлен, то в не особо работоспособном виде. Запускать [под виндой](http://www.sagemath.org/download-windows.html) разработчики советуют при помощи виртуальной машины.
Разработчики Sage предлагают [загрузить](http://www.sagemath.org/download-linux.html) сборку под вашу архитектуру (386 или amd64) и дистрибутив (Ubuntu и Fedora, но, думаю, будет работать и в остальных). Сборка содержит в себе, кроме sage-модулей, python, maxima, gap и много чего ещё. Скачиваете архив, распаковываете в какую-нибудь папку и сразу можно запускать из неё sage или sage-notebook — сервер для веб-интерфейса. Также в неё входит стиль для LaTeX, который всегда можно [скачать](http://www.ctan.org/tex-archive/macros/latex/contrib/sagetex/) отдельно.
Пусть всё это не особо совместимо с менеджерами пакетов, но достаточно удобно.
Буду предполагать, что вы распаковали архив в каталог `/usr/local/sage`.
#### Подготовка
Теперь, когда установлены LyX и Sage, можно приступить к их объединению.
Для этого потребуется:
1. Настроить LaTeX.
2. Написать скрипт.
3. Настроить LyX.
##### 1. Настройка LaTeX
Стиль sagetex, о котором упомянуто выше, должен быть виден LaTeX'у. В мануале к стилю советуют положить его в папку `~/texmf/tex/genetic`. Под убунтой, видимо, нужно класть в `~/.local/share/texmf/tex/genetic`
У меня заработало (пока без LyX) так:````
$ sudo ln -s /usr/local/sage/local/share/texmf/tex/generic/sagetex/ /usr/local/share/texmf/tex/generic/sagetex/
````и потом````
$ sudo texhash /usr/local/share/texmf/tex/generic/sagetex/ # ну, или путь, куда вы только что положили стиль
````
Кстати, говоря, TexLive, который ставится по умолчанию в убунте, содержит стиль sagetex. Но есть проблема с версиями — sage и sagetex разных версий друг с другом не дружат, поэтому важно, чтобы LaTeX имел дело именно с новым sagetex.sty.
Узнать, какой файл возмёт LaTeX, если ему сказать `\usepackage{sagetex}`, можно так:````
$ kpsewhich sagetex.sty
````
Этот стиль подразумевает следующую последовательность сборки документов, его использующих:````
$ latex tex_with_sage.tex # генерируется файл с командами sage tex_with_sage.sage
$ sage tex_with_sage.sage # генерируется файл с ответами системы
# сборка индекса и прочие команды, которые вам нужны
$ latex tex_with_sage.tex # получаем результат
````
LyX, понятное дело, не умеет запускать sage. Но он умеет работать с noweb. Что это — сейчас даже и не важно, нам просто нужно, чтобы в системе был файл `noweb.sty`. Можно установить пакет noweb, а можно просто создать этот файл.
##### 2. Скрипт
Как только LyX начинает собирать итоговый файл (например pdf), он генерирует во временном каталоге файл \*.tex и запускает обычные команды (pdflatex, makeindex и т.д). Потом он запускает во вьювере итоговый файл \*.pdf или \*.dvi или копирует этот файл в папку с исходным документом.
Если тип документа — noweb, то будет сгененирован файл \*.nv (по сути тот же \*.tex), для этого файла будет запущена специальная программа, которая создаёт \*.tex, после чего в ход уже идут pdflatex, makeindex и иже с ними.
В качестве этой программы, мы подсунем LyX'у такой простенький скрипт:````
#!/bin/bash
name=`basename $1 .nw`
# uncomment and replace path if you have problems with
# old version of sagetex.sty in texlive
# ln -sf /usr/local/share/texmf/tex/generic/sagetex/sagetex.sty sagetex.sty
# generating *.sage file
latex $1 > $name.sage.log 2>&1
echo "" >> $name.sage.log
# generating *.sout file
/usr/local/sage/sage $name.sage >> $name.sage.log 2>&1
ln -sf $1 $2
# now LyX can run latex in usual way
````
Я положил его в `$HOME` и назвал `sagelyx.sh`.
##### 3. Настройка LyX
В настройках документа должны быть доступны классы с Noweb. Если они недоступны, возможно нужно запустить `Инструменты->Переконфигурировать`.
Дальше, нужно сказать LyX'у, что для документов Noweb нужно запускать наш скрипт (см. рисунок).
[](https://habrastorage.org/storage/habraeffect/02/08/02089eba0cbce94ec33df2ef91f9aaa5.png)
В преамбулу всех документов добавляем:````
\usepackage{sagetex}
````
#### Использование
Теперь можно в документе ввести формулу (или сделать TeX-вставку):
````
$26^{3}\cdot10^{3}=\sage{26**3+10**3}$
````
Если включён предпросмотр формул, то LyX заменит команду `\sage` на `??`. Это потому что для предпросмотра используется только один проход LaTeX. Однако, если нажать кнопку `Просмотр PDF`, то откроется pdf с проставленными числами.
Простенький пример и мой скрипт: <http://www.box.net/shared/air7v45yqk>
#### Что не работает?
Не работает много чего…
Что-то плохо получается в LyX и приходится делать TeX вставки, например не особо получается использовать `\sage{}` внутри математического окружение, потому что LyX удаляет пробелы и вставляет фигурные скобки.
Что-то нельзя сделать в самом sagetex, например использовать строки с юникодовским текстом. Для этого нужно в начале sage-файла разместить сточку ````
# -*- coding: utf-8 -*-
````но средств никаких для этого sagetex не предоставляет.
P.S. Надеюсь, что когда-нибудь всё это станет очень-очень просто (может даже благодаря этому посту) как в крутых коммерческих системах, но при этом останется гибкость и свобода во всех возможных смыслах. | https://habr.com/ru/post/95289/ | null | ru | null |
# Зачем (не)нужны геттеры?
Прошлая статья про [сеттеры/геттеры](https://habr.com/ru/post/469323/) как способ работы с сущностью (на примере Symfony в PHP) получила бурное обсуждение. В данной статье попробую выразить свои мысли отдельно по поводу геттеров: зачем и когда что-то получать, какую ответственность они решают и когда их уместно использовать, когда не уместно. Постарался собрать мысли в одном месте и формализовать их вместе с вами.
*Изображение из блога Фаулера: [TellDontAsk](https://martinfowler.com/bliki/TellDontAsk.html)*
getHumanFactory().getHuman().getDoneWork().getWorkTime()
--------------------------------------------------------
Геттеры нужны для того, чтобы получить некоторое состояние текущего объекта. В ООП языках — это значение некоторой переменной класса, как правило приватной.
```
class Article {
private String name
public function getName(): String {
return this.name
}
}
```
Само значение переменной класса может быть получено как угодно. Мы просто просим объект нам дать что есть, само название метода нам говорит «дай»: но не «сделай», не «отправь», не «создай», не «посчитай». Говорит дай — даем что есть. Это вполне нормально работает в разного рода дата-объектах, ответственность которых как раз давать/нести информацию.
В геттере не может быть никакой логики, тк семантика слова прямолинейна. «Мама, **дай мне пирог**» не содержит в себе «Мама, купи муку, пожарь пирог и наконеееец **дай мне пирог**». Может быть фраза «обеспечь меня пирогом» как-то и может инкапсулировать в себя все эти действия, но это точно не «дай».
Вы удивитесь, но такой способ именовать все методы встречался мне неоднократно. Сложность кода при этом довольно вырастает, тк в цепочках геттеров не всегда понятно, что конкретно происходит в слоях приложений и какие связи задействуются, как правило не все в порядке с дизайном и попустительство такого рода — источник ошибок.
getValue() throw WhyDoYouNeedIt? {}
-----------------------------------
Назначение дата-объекта понятно — это капрал из фильма 1917, который бежит куда-то, чтобы донести некоторое послание о том, что нужно отступать.
Но что делать с бизнес-объектами? Зачем сущности «Документ» кому-то «давать» список своих полей?
Если это бизнес-объект, то документ может быть проведен, отклонен, проверен (в том числе по этим полям), заполнен или подтвержден.
Если же появилась необходимость «дать» поля, то значит данный документ не часть бизнес-процесса. Для чего нужно кому-то дать поля? Может для опубликации? Или выписки, или архивации, или отправки копии по почте, или отчета? Не совсем понятно зачем и кому — вырисовывается отдельная ответственность «дать» как у старого доброго дата-объекта, явно видно использование в виде некоторого источника для чтения в контексте другого бизнес-процесса, не основного в понимании самого документа.
doEverythingEverywhere(world.getGod())
--------------------------------------
Вернемся к бизнес-сущностям. Если оставить геттеры в сущностях, то велик соблазн использовать ее геттеры ровно везде и как угодно. Мы завязываемся на состояние некого объекта и воротим абсолютно любую логику походу. Может даже казаться, что мы не нарушили инкапсуляцию. Но как же? Состояние в одном месте, поведение в другом — классическое нарушение инкапсуляции.
Например есть некоторая сущность:
```
class Order
{
private Status status
private Boolean closed
public function getStatus(): Status {
return this.status
}
public function setClosed(Boolean closed): void {
this.closed = closed
}
}
```
Наверняка, при такой архитектуре статус вы запросите в добром десятке/сотне мест. Это могут быть разного рода сервисы, контроллеры, другие модули. Я видел только один раз, когда искусственно были созданы ограничения для распространения этого кода некоторым набором правил для разработчиков, не кодом… Инкапсуляция была обеспечена стандартами кодирования, а не проектированием кода :).
Если вам понадобилось сделать где-то что-то подобное:
```
if(order.getStatus() == input.getStatus()) {
order.setClosed(true)
}
```
То скорее всего сущность не содержит в себе машину состояний. Значит инварианты объекта изнутри никак не контролируются — нет верификации данных при каждой операции изнутри. Как следствие — высокая связанность, сложное функциональное тестирование, тк недостаточно проверить юнит-логику того кода, который меняет состояние сущности, нужно проверить, что состояние внешней для кода сущности допустимое. И как следствие: увеличенная сложность, вероятность багов, больше кода и сложные тесты.
**Итог:** Надеюсь мои и ваши коллег будут меньше использовать геттеры как любой метод, который делает любую работу с результатом, который вернет.
И надеюсь больше разработчиков обратит внимание на концепцию CQRS, где ответственности для чтения и бизнес-операций разделены.
**Почитать:**
М. Фаулер, [TellDontAsk](https://martinfowler.com/bliki/TellDontAsk.html)
М. Фаулер, [AnemicDomainModel](https://martinfowler.com/bliki/AnemicDomainModel.html)
Всем добра! | https://habr.com/ru/post/500416/ | null | ru | null |
# Почему нельзя установить размер шрифта у посещенной ссылки
Привет, Хабр! Представляю Вашему вниманию перевод статьи [«Why can’t I set the font size of a visited link?»](https://jameshfisher.com/2019/03/08/why-cant-i-set-the-font-size-of-a-visited-link/) автора Jim Fisher.
Посещенные ссылки отображаются фиолетовым; не посещенные — голубым. Это различие пришло к нам с времен появления веба. Но CSS позволяет нам перенастроить эти свойства с помощью псевдо-селектора :visited! Скажем, вы хотите сделать посещенные ссылки серыми и уменьшить их размер, для того чтобы показать пользователю что эта ссылка уже была посещена.
```
a:visited {
color: gray;
font-size: 6px;
}
```
Этот стиль применен к текущей странице:
Окрашивание ссылки в серый цвет, как и предполагалось, уведомляет нас о том что она уже была посещена, но размер шрифта остался прежним! Так происходит, потому что изменение размера шрифта может быть причиной уязвимости! Если CSS сможет изменить размер шрифта, я(Jim) могу сказать посещали ли Вы pornhub.com. Но как?
Веб страницы доступны для инспектирования отображенных элементов на странице. Наиболее очевидный способ — использовать window.getComputedStyle(). Он рассказывает о свойствах, примененных к вышеупомянутой посещенной ссылке; как сообщает браузер: font-size: 18px; color: rgb(0, 0, 238).
Если getComputedStyle сообщит об изменении размера шрифта с 18px до 6px для посещенных ссылок, я(Jim) пойму, что на странице создана ссылка на pornhub.com, затем я проверю размер шрифта, для того чтобы определить историю посещений вашего браузера. Я могу использовать эти данные для таргетированной рекламы, могу продать ваши данные или шантажировать вас, и так далее… Дыра в безопасности была закрыта путем запрета на изменение font-size для a:visited.
Но информация, полученная с помощью getComputedStyle, о цвете посещенной ссылки будет: rgb(0, 0, 238) — то есть голубое. Это ложь — ссылка же серая! Для свойства color, браузеры закрывают дыру в уязвимости другим способом: вместо запрета на изменение, они заставляют getComputedStyle лгать о реальном значении.
Почему же используется два подхода? Почему мы не можем заставить getComputedStyle лгать также и о параметре font-size? Причина в том, что можно исследовать отображенные элементы веб страницы и другими методам, кроме getComputedStyle. Позицию элемента на странице можно проверить так же с помощью .pageXOffset или .pageYOffset. Изменение font-size у посещенной ссылки будет влиять на смещение у других элементов, из-за чего можно косвенно проверить какие ссылки были посещены. Отключение font-size для a:visited — это жесткое, но надежное решение.
По этой [ссылке](https://developer.mozilla.org/en-US/docs/Web/CSS/:visited) содержится краткий список разрешенных свойств, таких же как color, которые не должны влиять на макет страницы, и не могут быть обнаружены. Все они — разные формы изменения цвета. Все другие CSS свойства — заблокированы.
В теории, нет способа, с помощью которого можно было бы определить, что цвет посещенной ссылки был изменен. Единственная возможность — временная атака: скажем, если изменение цвета в розовый заняло больше времени по сравнению с голубым, страница может измерить, сколько времени потребовалось для отображения элемента, и сравнить это с ожидаемой продолжительностью.
**P. S.:**
Отдельное спасибо за помощь в корректировке перевода [Переверзевой Ольге](https://www.linkedin.com/in/olga-pereverzeva-46827a102/).
Спасибо Олегу Яценко([Samber](https://habr.com/ru/users/samber/)), в комментариях он обратил внимание на то что решение проблемы с подобной утечкой данных было впервые реализовано в [Mozilla](https://blog.mozilla.org/security/2010/03/31/plugging-the-css-history-leak/) — автор решения [David Baron](https://dbaron.org/mozilla/visited-privacy). | https://habr.com/ru/post/445052/ | null | ru | null |
# Новости из мира OpenStreetMap № 490 (03.12.2019-09.12.2019)
58 мест, где были высажены живые изгороди [1](#wn490_21443) | Map data OpenStreetMap contributors | Imagery Mapbox
Выборы в Совет Фонда OSM
------------------------
* На ежегодном общем собрании были [объявлены](https://lists.openstreetmap.org/pipermail/osmf-talk/2019-December/006516.html) результаты выборов на четыре вакантных места в Совет Фонда OSM. Членами Совета стали:
1. Гийом Ришар (Люксембург)
2. Аллан Мастард (США),
3. Микель Марон (США),
4. Рори МакКенн (Ирландия).
Кстати, борьба за последнее место была нешуточной: Рори Маккенна и Михало Мигурски (США) [отделяло](https://www.opavote.com/results/6500446103404544) буквально несколько голосов.
Команда WeeklyOSM поздравляет победителей и благодарит всех, кто проявил смелость и выдвинул свою кандидатуру на этих выборах.
Картографирование
-----------------
* Майкл Бехренс, [разработавший](https://lists.openstreetmap.org/pipermail/tagging/2019-December/049528.html) схему тегирования, с помощью которой можно обозначать функции разных частей [пешеходных](https://wiki.openstreetmap.org/wiki/Proposed_features/hiking_trail_relation_roles) дорожек, ждет комментариев сообщества. Речь идет о возможности обозначать, например, подходы к остановкам общественного транспорта, экскурсионные маршруты к обзорным точкам или вершинам вблизи главной тропы.
* [Схема](https://wiki.openstreetmap.org/wiki/Proposed_features/skatepark) тегирования, которой предлагается отмечать тегом `leisure=skatepark` территорию, предназначенную и оборудованную для катания на скейтборде, BMX или самокате, ждет [комментариев](https://lists.openstreetmap.org/pipermail/tagging/2019-December/049619.html) сообщества.
* Маркус [сообщил](https://lists.openstreetmap.org/pipermail/tagging/2019-December/049465.html), что голосование за схему тегирования, которой предлагалось отмечать специально отведенные для [пешеходов полосы](https://wiki.openstreetmap.org/wiki/Proposed_features/Pedestrian_lane) на дорогах, завершилось. Инициативу поддержало всего 62% пользователей, что означает, что она не принята.
* Себастьян Мартин Дик [попросил](https://lists.openstreetmap.org/pipermail/tagging/2019-December/049464.html) прокомментировать его [предложение](https://wiki.openstreetmap.org/wiki/Proposed_features/notary): добавить уточнение к тегу, которым обозначается адвокатская контора, — предоставляет ли она еще нотариальные услуги или нет.
* Мартин Шолтес [предлагает](https://lists.openstreetmap.org/pipermail/tagging/2019-December/049516.html) утвердить еще одно [свойство](https://wiki.openstreetmap.org/wiki/Proposed_features/park_drive) для тега `amenity=parking` — `park_drive`. Он хочет, чтобы им обозначались те парковки, которые используются людьми как место встречи для совместной езды на авто (карпулинга).
* [Началось](https://lists.openstreetmap.org/pipermail/tagging/2019-December/049618.html) голосование за схему тегирования, которой предлагается отмечать точки распределения телекоммуникационных услуг ([коммутаторы](https://wiki.openstreetmap.org/wiki/Proposed_features/Telecom_distribution_points)). Речь идет об оборудовании, которое чаще всего выглядит как небольшая коробочка, «раздающим» интернет гражданам.
* Телеканал France 24 рассказывает о проекте некоммерческой организации "[Code for Africa](https://codeforafrica.org)" по картографированию Макоко — плавучего района в Лагосе (Нигерия). [Статья](https://www.france24.com/en/20191129-drone-project-aims-to-put-floating-lagos-slum-on-map) и [видео](https://www.youtube.com/watch?v=6JQrbgp6zkY&feature=youtu.be) об этом.
* Некоммерческая организация [CartOng](https://cartong.org/) рассказывает в своем [блоге](https://cartong.org/news/helping-marginalized-populations-defend-rights-through-participatory-mapping) о проекте по созданию карты Сен-Лоран-дю-Марони во Французской Гвиане, который был осуществлен при участии местных жителей.
* Вышла [новая версия](https://www.openstreetmap.org/user/mvexel/diary/391500) сервиса MapRoulette (3.5), в которой помимо совершенствования механизма поиска задач при помощи карты, также исправлены ошибки и добавлен ряд небольших улучшений. Попробуйте их сами на maproulette.org!
Сообщество
----------
* [1] На карте "[Волшебная изгородь](https://haie-magique.org/#map)" (Haie magique) вы можете увидеть 58 объектов, где были высажены живые изгороди, в 19 коммунах региона Иль-де-Франс.
* [Местное](https://twitter.com/hashtag/osmph) сообщество OpenStreetMap в Маниле (Филиппины) провело первый тематический картатон [MapBeks](https://www.facebook.com/mapbeks), который был посвящен теме ЛГБТК, во время которого они обучали новичков добавлять данные в OSM с помощью сервиса MapContrib. Подробности об этом можно [прочитать](https://www.openstreetmap.org/user/ockim16/diary/391518) в дневнике пользователя Микко.
* Бельгийский пользователь juminet [высказывает](https://www.openstreetmap.org/user/juminet/diary/391470) ряд доводов в пользу «более интегрированного» сайта OpenStreetMap.org. Энди Аллан (который занимается разработкой большинства сайтов проекта) призывает его принять в этом участие.
* Пользователь kartonage в своем [дневнике](https://www.openstreetmap.org/user/kartonage/diary/391495) подвел итоги своего вклада в проект Mapillary (съемки панорам улиц) в этом году.
* Пользователь thomersch в своем блоге [написал](https://www.openstreetmap.org/user/thomersch/diary/391513) о лучшем [календаре](https://osmcal.org/) для OSM.
* В издании Daily Observer под заголовком «Женщина в картографии» вышло [интервью](https://www.observerbd.com/details.php?id=229126&fbclid=IwAR0oANGshmvORyCce_Cu5MQ95rPw78N7aT_mYKQBvfjvAhur_qpFnhcHdNM) с Антарой Титхил — одним из основных членов команды Открытой инновационной лаборатории Бангладеш ([BOIL](https://boiledbhoot.org/)).
* Фредерик Рамм предельно [негативно](https://www.openstreetmap.org/user/woodpeck/diary/391480) относится к тому, что Facebook все больше и больше влияет на OpenStreetMap, в том числе к выдвижению одного из сотрудников Facebook в качестве кандидата в члены Совета Фонда OSM. Этот пост собрал много интересных комментариев.
Импорты
-------
* Пользователь krizleebear [сообщает](https://lists.openstreetmap.org/pipermail/imports/2019-December/006120.html), что он собирается выполнить массовые автоматические правки в присоединении `admin_centre`. [Обоснование](https://wiki.openstreetmap.org/wiki/Automated_edits/krizleebot) такого решения можно найти в WikiOSM.
OpenStreetMap Foundation
------------------------
* Питер Барт [задал](https://lists.openstreetmap.org/pipermail/osmf-talk/2019-December/006444.html) кандидатам, баллотирующимся в Совет Фонда OSM, несколько дополнительных вопросов, в частности по теме конфликта интересов.
* Сообщество OSM в Великобритании [разработало](https://lists.openstreetmap.org/pipermail/talk-gb/2019-December/023885.html) портал "[OSMUK Talent Pool](https://osmuk.org/join-our-talent-directory/)", с помощью которого компании и английские картографы, готовые выполнять работу, связанную с OSM, на коммерческой или безвозмездной основе, могут найти друг друга. Редакция WeeklyOSM считает, что это отличная идея! Поздравляем!
* Микель Марон [поделился](https://www.openstreetmap.org/user/mikelmaron/diary/391498) некоторыми своими идеями по управлению Фондом OSM. Он считает, что необходимо разделить Консультативный совет на две группы: «Местные представительства» и для корпораций. Помимо этого он предлагает разработать регламент взаимодействия Совета Фонда OSM и рабочих групп, а также документ по конфликту интересов.
События
-------
* Начался [прием](https://blog.openstreetmap.org/2019/12/07/call-for-sotm-2020-presentations/) докладов на конференцию SotM 2020, которая пройдет с 3 по 5 июля 2020 года в Кейптауне (Южная Африка).
* Кот-д’ивуарская газета «FratMap» [рассказывает](https://www.fratmat.info/index.php/economie/cartographie-libre-et-ouverte-500-acteurs-africains-partagent-leur-experience-a-bassam) об успешно прошедшей конференции State of the Map Africа, которая проходила в городе Гранд-Басам (Кот-д’Ивуар).
* Организаторы конференции State of the Map Africа [опубликовали](https://www.flickr.com/photos/sotmafrica/sets/72157711975008092/) снимки с мероприятия на Flickr.
* С 20 по 22 ноября в Абиджане (Кот-д'Ивуар) [прошла](https://understandrisk.org/event/understanding-risk-west-and-central-africa/) конференция «Понимание региональных рисков в 2019 году», спонсором которой выступил Всемирный банк. Последний день был совмещен с конференцией SotM Africa 2019.
Гуманитарный OSM
----------------
* Проекту HOT [#7446](https://tasks.hotosm.org/project/7446) срочно нужна помощь в картографировании Джибути, где случилось сильное наводнение. Из-за очень плотной окружающей среды для решения задачи привлекаются [только](https://lists.openstreetmap.org/pipermail/hot/2019-December/015080.html) опытные или продвинутые картографы.
* Мишель Яни, координатор нового сообщества OSM Южного Судана, ведет [сбор](https://lists.openstreetmap.org/pipermail/hot/2019-December/015077.html) пожертвований для проведения семинаров, обучения беженцев из Южного Судана в Уганде и других странах, а также приобретения картографических приборов.
* Леон, ГИС-специалист и инженер-эколог из Боливии, начал [сбор](https://lists.openstreetmap.org/pipermail/hot/2019-December/015079.html) пожертвований для разработки геоинформационной системы этой страны. Предполагается, что эта система будет совместным проектом местного сообщества OSM, государственных учреждений, организаций по оказанию помощи, исследователей и коммерсантов. В последнее время этот район сильно пострадал от лесных пожаров и очень высоких темпов обезлесения. В настоящему времени ему удалось привлечь всего лишь 250 долларов США из необходимых 7000.
* Элис Гауди [написала](https://www.missingmaps.org/blog/2019/12/09/a-year-of-blogs/) пост о работе некоммерческой организации «Missing Maps», принимавшей участие в ликвидации последствий ураган Дориан, который обрушился на Багамы в сентябре 2019 года. В статье рассказывается о вкладе Missing Maps, о важности OSM, а также есть несколько снимков из серии «OSM в действии».
Образование
-----------
* Вышла новая [книга](https://link.springer.com/book/10.1007/978-981-32-9915-3) из серии [Digital Earth](https://en.wikipedia.org/wiki/Digital_Earth), которую могут скачать абсолютно все. Особое внимание любителям OpenSteetMap рекомендуем обратить на главу "[Гражданская наука в поддержку «Digital Earth](https://link.springer.com/chapter/10.1007/978-981-32-9915-3_18)», написанную Марией Антонией Бровелли, Марисой Понти, Свеном Шадом и Патрицией Солис.
Карты
-----
* Кристиан Рейнсторф aka Spiekerooger, [предлагает](https://forum.openstreetmap.org/viewtopic.php?pid=770439#p770439) [онлайн-карты](https://www.osmap.info/) на семи различных языках, в основе которых данные OpenStreetMap.
Open Data
---------
* Марко Мингини [сообщает](https://lists.openstreetmap.org/pipermail/science/2019-December/000063.html), что в Исследовательском центре Европейской комиссии — Объединенном исследовательском центре (JRC) в Испре (Италия) имеется вакансия [стажёра](https://recruitment.jrc.ec.europa.eu/showprj.php?type=T&id=13310). Заявки принимаются до 10 января 2020 года.
Программное обеспечение
-----------------------
* SomeoneElse сделал [подборку](https://www.openstreetmap.org/user/SomeoneElse/diary/391484) имеющихся инструментов и подходов к преобразованию тегов данных OSM. Это было сделано в ответ на [сообщение](https://lists.openstreetmap.org/pipermail/talk/2019-December/083608.html) Серена Рейнеке в списке рассылки Talk.
Релизы
------
* Вышла [новая](https://osmand.net/blog/osmand-ios-3-10-released) версия OSMAnd для iOS (3.10), в которой переработан экран настройки навигации, появилась поддержка онлайн-карт SQL, а также улучшен контроль контурных линий и пр.
Знаете ли вы …
--------------
* … о блоге *[GeoHipster](https://geohipster.com/)*? Он публикует независимые материалы, посвященные состоянию, проблемам и направлениям развития ГИС-индустрии, как это видят люди, работающие в ней.
* … как написать хорошие [комментарии](https://wiki.openstreetmap.org/wiki/Good_changeset_comments) к набору вносимых правок?
* … как отметить происхождение блюд в ресторанах и товаров в магазинах? Для ресторанов используется тег [`cuisine`](https://wiki.openstreetmap.org/wiki/Key:cuisine), а для товаров в магазинах — [`origin`](https://wiki.openstreetmap.org/wiki/Key:origin).
* … об [экологической зоне](https://www.openstreetmap.org/relation/3937563#map=10/51.4921/-0.0989) в вашем городе? Или она все еще отсутствует? Загляните в [WikiOSM](https://wiki.openstreetmap.org/wiki/Tag:boundary%3Dlow_emission_zone) и отметьте свою зону с низким уровнем выбросов.
OSM в СМИ
---------
* Посмотрите [видео](https://www.youtube.com/watch?v=UzT0i5XhsOQ), в котором Стивен Джонсон рассказывает об OpenStreetMap на конференции TEDx с точки зрения преподавателя.
* Onlinekhabar [сообщает](https://english.onlinekhabar.com/towards-digital-nepal-enabling-citizen-scientists-of-remote-districts-to-map-their-location.html), что жители муниципалитета Будхиганга (Непал) недавно прошли обучение, в ходе которого учились картографировать и загружать данные в OpenStreetMap.
Другие «гео» события
--------------------
* Кристофер Баррингтон-Ли и Адам Миллард-Болл написали [статью](https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0223078) об использовании OpenStreetMap для вычисления степени связности улиц. Они обнаружили, что существует высокая степень взаимосвязи между низкой связностью и увеличением поездок транспортных средств, энергопотреблением и выбросами CO2.
* Weetracker [сообщает](https://weetracker.com/2019/12/02/african-countries-that-ban-drones/), что только в шести африканских стран запрещены полеты беспилотников. Это Алжир, Кения, Кот-д'Ивуар, Мадагаскар, Марокко и Сенегал.
* Феминистская группа в OSM — GeoChicas — создала [карту](http://umap.openstreetmap.fr/es/map/un-violador-en-tu-camino-2019_394247#1/45/-89) мест по всему миру, где "[Un violador en tu camino](https://es.wikipedia.org/wiki/Un_violador_en_tu_camino)" («насильник на вашем пути»), со ссылками на новости о событиях. Целью данного выступления является привлечение внимание к проблеме нарушения прав и свобод женщин.
---
Общение российских участников OpenStreetMap идёт в [чатике](https://t.me/ruosm) Telegram и на [форуме](http://forum.openstreetmap.org/viewforum.php?id=21). Также есть группы в социальных сетях [ВКонтакте](https://vk.com/openstreetmap), [Facebook](https://www.facebook.com/openstreetmap.ru), но в них в основном публикуются новости.
[Присоединяйтесь к OSM!](https://www.openstreetmap.org/user/new)
---
Предыдущие выпуски: [489](https://habr.com/ru/post/480206/), [488](https://habr.com/ru/post/479234/) [487](https://habr.com/ru/post/478196/), [486](https://habr.com/ru/post/477166/), [485](https://habr.com/ru/post/476060/) | https://habr.com/ru/post/481390/ | null | ru | null |
# MVVM: новый взгляд
*Внимание!*
Более свежие и прогрессивные материалы по *MVVM* паттерну представлены в статье [Context Model Pattern via Aero Framework](http://habrahabr.ru/post/251347/) и подробно разобраны в [следующем цикле статей](http://habrahabr.ru/users/makeman/topics/)
**Предисловие**
Некоторое время назад я затеял разработку бесплатного текстового редактора с красивым интерфейсом и широким удобным функционалом на платформе WPF. Довелось решить очень много технических задач, поэтому у меня накопился определённый опыт, которым хочу поделиться с другими людьми.
**К делу**
Разработчикам WPF, Silverlight и WinPhone-приложений хорошо знаком паттерн проектирования MVVM (Model — View — ViewModel). Однако если дополнительно применить к нему ещё немного фантазии, то может получиться что-то более интересное, и немного даже, осмелюсь заверить, революционное.
Допустим, у нас есть классическое окно (View) текстового редактора с меню, тулбар треем и статус баром, которые можно спрятать при желании. Перед нами стоит задача – сохранить позицию и размеры окна, а также визуальное состояние элементов при закрытии приложения, чтобы потом восстановить их.
Обычное решение, которое сразу напрашивается на ум, состоит в добавлении во вью-модель ряда дополнительных свойств для привязки (Top, Left, Width, Heigth, ShowToolBarTray, ShowStatusBar и других), а затем сохранение их значений, например, в файл. Но не будем спешить… Что если я вам скажу, что можно создать такую вью-модель, которая будет реализовывать необходимую функциональность по умолчанию, поэтому для решения задачи не нужно НИ ОДНОЙ дополнительной строки кода?
**Сразу рекомендую скачать пример приложения, который я сделал специально для этой статьи (ссылка [один](http://yadi.sk/d/_iq--fSVFThbk) или [два](http://poet.of.by/downloads/MuseMVVM.zip))**, он поможет понять основные идеи и прочувствовать красоту подхода. Здесь же я приведу определённые части кода, на которые стоит обратить особое внимание.
В WPF часто используется привязка к свойствам, но существует также возможность привязки к элементам массива, которой пользуются довольно редко. Но вот она-то и открывает нам новые горизонты. Попробуем рассмотреть вью-модель, как словарь, где ключом-индексом будет имя свойства, по которому можно получить его значение.
Но как же нам лучше сохранять эти значения? Попробуем сериализовать вью-модели! Но?.. Это ведь не DTO-объект, да и как потом их десериализовать, ведь в конструктор часто нужно инжектировать другие параметры, а для десериализации обычно нужен конструктор без параметров? А вам никода не казалось инжектирование в конструктор несколько неудобным, например, при добавлении или удалении параметра ломались юнит тесты, и их тоже необходимо было править, хотя интерфейс тестируемого объекта, по сути, оставался прежним?
Поэтому откажемся от инжекций в конструктор, благо, существуют и другие способы для подобных целей, и пометим вью-модели атрибутом [DataContract], а свойства, которые нужно сериализовать, атрибутом [DataMember] (эти аттрибуты очень упрощают сериализацию).
Теперь создадим небольшой класс Store.
```
public static class Store
{
private static readonly Dictionary StoredItemsDictionary = new Dictionary();
public static TItem OfType(params object[] args) where TItem : class
{
var itemType = typeof (TItem);
if (StoredItemsDictionary.ContainsKey(itemType))
return (TItem) StoredItemsDictionary[itemType];
var hasDataContract = Attribute.IsDefined(itemType, typeof (DataContractAttribute));
var item = hasDataContract
? Serializer.DeserializeDataContract() ?? (TItem) Activator.CreateInstance(itemType, args)
: (TItem) Activator.CreateInstance(itemType, args);
StoredItemsDictionary.Add(itemType, item);
return (TItem) StoredItemsDictionary[itemType];
}
public static void Snapshot()
{
StoredItemsDictionary
.Where(p => Attribute.IsDefined(p.Key, typeof (DataContractAttribute)))
.Select(p => p.Value).ToList()
.ForEach(i => i.SerializeDataContract());
}
}
```
Тут всё просто – лишь два метода. OfType возвращающает нам статический экземпляр объекта требуемого типа, по возможности десериализуя его, и Snapshot делает «снимок» объектов находящихся в контейнере, сериализуя их. Вызов Snapshot в общем случае можно осуществить лишь один раз при закрытии приложения, например, в обработчике Exit класса Application.
И напишем Json-сериализатор.
```
public static class Serializer
{
public const string JsonExtension = ".json";
public static readonly List KnownTypes = new List
{
typeof (Type),
typeof (Dictionary),
typeof (SolidColorBrush),
typeof (MatrixTransform),
};
public static void SerializeDataContract(this object item, string file = null, Type type = null)
{
try
{
type = type ?? item.GetType();
if (string.IsNullOrEmpty(file))
file = type.Name + JsonExtension;
var serializer = new DataContractJsonSerializer(type, KnownTypes);
using (var stream = File.Create(file))
{
var currentCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
serializer.WriteObject(stream, item);
Thread.CurrentThread.CurrentCulture = currentCulture;
}
}
catch (Exception exception)
{
Trace.WriteLine("Can not serialize json data contract");
Trace.WriteLine(exception.StackTrace);
}
}
public static TItem DeserializeDataContract(string file = null)
{
try
{
if (string.IsNullOrEmpty(file))
file = typeof (TItem).Name + JsonExtension;
var serializer = new DataContractJsonSerializer(typeof (TItem), KnownTypes);
using (var stream = File.OpenRead(file))
{
var currentCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
var item = (TItem) serializer.ReadObject(stream);
Thread.CurrentThread.CurrentCulture = currentCulture;
return item;
}
}
catch
{
return default(TItem);
}
}
}
```
Базовый класс для вью моделей выглядит тоже не сложно.
```
[DataContract]
public class ViewModelBase : PropertyNameProvider, INotifyPropertyChanging, INotifyPropertyChanged
{
protected Dictionary Values = new Dictionary();
private const string IndexerName = System.Windows.Data.Binding.IndexerName; /\* "Item[]" \*/
public event PropertyChangingEventHandler PropertyChanging = (sender, args) => { };
public event PropertyChangedEventHandler PropertyChanged = (sender, args) => { };
public object this[string key]
{
get { return Values.ContainsKey(key) ? Values[key] : null; }
set
{
RaisePropertyChanging(IndexerName);
if (Values.ContainsKey(key)) Values[key] = value;
else Values.Add(key, value);
RaisePropertyChanged(IndexerName);
}
}
public object this[string key, object defaultValue]
{
get
{
if (Values.ContainsKey(key)) return Values[key];
Values.Add(key, defaultValue);
return defaultValue;
}
set { this[key] = value; }
}
public void RaisePropertyChanging(string propertyName)
{
PropertyChanging(this, new PropertyChangingEventArgs(propertyName));
}
public void RaisePropertyChanged(string propertyName)
{
PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
}
[OnDeserializing]
private void Initialize(StreamingContext context = default(StreamingContext))
{
if (PropertyChanging == null) PropertyChanging = (sender, args) => { };
if (PropertyChanged == null) PropertyChanged = (sender, args) => { };
if (Values == null) Values = new Dictionary();
}
}
```
Также унаследуемся от небольшого класса PropertyNameProvider, который пригодится нам в дальнейшем для работы с лямбда-выражениями.
```
[DataContract]
public class PropertyNameProvider
{
public static string GetPropertyName(Expression> expression)
{
var memberExpression = expression.Body as MemberExpression;
var unaryExpression = expression.Body as UnaryExpression;
if (unaryExpression != null)
memberExpression = unaryExpression.Operand as MemberExpression;
if (memberExpression == null || memberExpression.Member.MemberType != MemberTypes.Property)
throw new Exception("Invalid lambda expression format.");
return memberExpression.Member.Name;
}
}
```
Отлично, на данном этапе мы реализовали возможность привязки к свойствам-индексам. В xaml можно писать выражения следующего вида
Height="{Binding '[Height, 600]', Mode=TwoWay}"
где первый параметр — это имя свойства, а второй (опциональный) — его дефолтное значение.
Этот подход чем-то напоминает реализацию стандартного интерфейса IDataErrorInfo. Почему бы нам тоже не реализовать его? Хорошая идея, но не станем спешить, а примем её во внимание… Поиграем ещё с переопределением индексатора. Все помнят про ICommand, а в WPF существует ещё крутой механизм работы RoutedCommands и CommandBindings. Вот было бы классно писать реализацию команд во вью-модели подобным образом.
```
this[ApplicationCommands.Save].CanExecute += (sender, args) => args.CanExecute = HasChanged;
this[ApplicationCommands.New].CanExecute += (sender, args) =>
{
args.CanExecute = !string.IsNullOrEmpty(FileName) || !string.IsNullOrEmpty(Text);
};
this[ApplicationCommands.Help].Executed += (sender, args) => MessageBox.Show("Muse 2014");
this[ApplicationCommands.Open].Executed += (sender, args) => Open();
this[ApplicationCommands.Save].Executed += (sender, args) => Save();
this[ApplicationCommands.SaveAs].Executed += (sender, args) => SaveAs();
this[ApplicationCommands.Close].Executed += (sender, args) => Environment.Exit(0);
this[ApplicationCommands.New].Executed += (sender, args) =>
{
Text = string.Empty;
FileName = null;
HasChanged = false;
};
```
Ну, какая же вью-модель без автоматической нотификации свойств и лябда-выражений? Это должно быть по-любому.
```
public string Text
{
get { return Get(() => Text); }
set { Set(() => Text, value); }
}
```
А что если… Создать PropertyBinding наподобие CommandBinding и совсем чуть-чуть снова поиграть с индексатором?
```
this[() => Text].PropertyChanged += (sender, args) => HasChanged = true;
this[() => FontSize].Validation += () => 4.0 < FontSize && FontSize < 128.0 ? null : "Invalid font size";
```
Выглядит неплохо, неправда ли?
И, конечно, наша чудо-вью-модель.
```
[DataContract]
public class ViewModel : ViewModelBase, IDataErrorInfo
{
public ViewModel()
{
Initialize();
}
string IDataErrorInfo.this[string propertyName]
{
get
{
return PropertyBindings.ContainsKey(propertyName)
? PropertyBindings[propertyName].InvokeValidation()
: null;
}
}
public PropertyBinding this[Expression> expression]
{
get
{
var propertyName = GetPropertyName(expression);
if (!PropertyBindings.ContainsKey(propertyName))
PropertyBindings.Add(propertyName, new PropertyBinding(propertyName));
return PropertyBindings[propertyName];
}
}
public CommandBinding this[ICommand command]
{
get
{
if (!CommandBindings.ContainsKey(command))
CommandBindings.Add(command, new CommandBinding(command));
return CommandBindings[command];
}
}
public string Error { get; protected set; }
public Dictionary CommandBindings { get; private set; }
public Dictionary PropertyBindings { get; private set; }
public CancelEventHandler OnClosing = (o, e) => { };
public TProperty Get(Expression> expression, TProperty defaultValue = default(TProperty))
{
var propertyName = GetPropertyName(expression);
if (!Values.ContainsKey(propertyName))
Values.Add(propertyName, defaultValue);
return (TProperty) Values[propertyName];
}
public void Set(Expression> expression, TProperty value)
{
var propertyName = GetPropertyName(expression);
RaisePropertyChanging(propertyName);
if (!Values.ContainsKey(propertyName))
Values.Add(propertyName, value);
else Values[propertyName] = value;
RaisePropertyChanged(propertyName);
}
public void RaisePropertyChanging(Expression> expression)
{
var propertyName = GetPropertyName(expression);
RaisePropertyChanging(propertyName);
}
public void RaisePropertyChanged(Expression> expression)
{
var propertyName = GetPropertyName(expression);
RaisePropertyChanged(propertyName);
}
[OnDeserializing]
private void Initialize(StreamingContext context = default(StreamingContext))
{
CommandBindings = new Dictionary();
PropertyBindings = new Dictionary();
PropertyChanging += OnPropertyChanging;
PropertyChanged += OnPropertyChanged;
}
private void OnPropertyChanging(object sender, PropertyChangingEventArgs e)
{
var propertyName = e.PropertyName;
if (!PropertyBindings.ContainsKey(propertyName)) return;
var binding = PropertyBindings[propertyName];
if (binding != null) binding.InvokePropertyChanging(sender, e);
}
private void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
{
var propertyName = e.PropertyName;
if (!PropertyBindings.ContainsKey(propertyName)) return;
var binding = PropertyBindings[propertyName];
if (binding != null) binding.InvokePropertyChanged(sender, e);
}
}
```
Теперь мы вооружены по полной, но нет предела совершенству. Как правило, вью-модель связывается со своим представлением (вью) в C# коде, но насколько бы было красиво эту привязку осуществлять непосредственно в xaml! Помните про наш отказ от инжекций в конструктор? Вот он нам и даёт такую возможность. Напишем небольшое расширение для разметки\*.
```
public class StoreExtension : MarkupExtension
{
public StoreExtension(Type itemType)
{
ItemType = itemType;
}
[ConstructorArgument("ItemType")]
public Type ItemType { get; set; }
public override object ProvideValue(IServiceProvider serviceProvider)
{
var service = (IProvideValueTarget) serviceProvider.GetService(typeof (IProvideValueTarget));
var frameworkElement = service.TargetObject as FrameworkElement;
var dependancyProperty = service.TargetProperty as DependencyProperty;
var methodInfo = typeof(Store).GetMethod("OfType").MakeGenericMethod(ItemType);
var item = methodInfo.Invoke(null, new object[] { new object[0] });
if (frameworkElement != null &&
dependancyProperty == FrameworkElement.DataContextProperty &&
item is ViewModel)
{
var viewModel = (ViewModel) item;
frameworkElement.CommandBindings.AddRange(viewModel.CommandBindings.Values);
var window = frameworkElement as Window;
if (window != null)
viewModel.OnClosing += (o, e) => { if (!e.Cancel) window.Close(); };
frameworkElement.Initialized += (sender, args) => frameworkElement.DataContext = viewModel;
return null;
}
return item;
}
}
```
Вуаля, готово!
DataContext="{Store viewModels:MainViewModel}"
Обращаю внимание на то, что во время привязки у контрола изменяется не только DataContext, но и заполняется коллекция CommandBindings, значениями из вью-модели.
(\* чтобы перед расширениями для разметки не писать префиксов вроде "{foundation:Store viewModels:MainViewModel}", они должны быть реализованы в отдельном проекте и в этом же проекте в файде AssemblyInfo.cs нужно написать что-то вроде
```
[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "Foundation")]
[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "Foundation.Converters")]
[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation", "Foundation.MarkupExtensions")]
```
)
Подобным образом приукрасим привязку к индексам, о которой речь шла выше.
```
public class ViewModelExtension : MarkupExtension
{
private static readonly BooleanConverter BooleanToVisibilityConverter = new BooleanConverter
{
OnTrue = Visibility.Visible,
OnFalse = Visibility.Collapsed,
};
private FrameworkElement _targetObject;
private DependencyProperty _targetProperty;
public ViewModelExtension()
{
}
public ViewModelExtension(string key)
{
Key = key;
}
public ViewModelExtension(string key, object defaultValue)
{
Key = key;
DefaultValue = defaultValue;
}
public string Key { get; set; }
public string StringFormat { get; set; }
public string ElementName { get; set; }
public object DefaultValue { get; set; }
public object FallbackValue { get; set; }
public object TargetNullValue { get; set; }
public IValueConverter Converter { get; set; }
public RelativeSource RelativeSource { get; set; }
public override object ProvideValue(IServiceProvider serviceProvider)
{
var service = (IProvideValueTarget) serviceProvider.GetService(typeof (IProvideValueTarget));
_targetProperty = service.TargetProperty as DependencyProperty;
_targetObject = service.TargetObject as FrameworkElement;
if (_targetObject == null || _targetProperty == null) return this;
var key = Key;
if (_targetProperty == UIElement.VisibilityProperty && string.IsNullOrWhiteSpace(key))
key = string.Format("Show{0}",
string.IsNullOrWhiteSpace(_targetObject.Name)
? _targetObject.Tag
: _targetObject.Name);
key = string.IsNullOrWhiteSpace(key) ? _targetProperty.Name : key;
if (!string.IsNullOrWhiteSpace(StringFormat)) Key = string.Format(StringFormat, _targetObject.Tag);
var index = DefaultValue == null ? key : key + "," + DefaultValue;
var path = string.IsNullOrWhiteSpace(ElementName) && RelativeSource == null
? "[" + index + "]"
: "DataContext[" + index + "]";
if (_targetProperty == UIElement.VisibilityProperty && Converter == null)
Converter = BooleanToVisibilityConverter;
var binding = new Binding(path) {Mode = BindingMode.TwoWay, Converter = Converter};
if (ElementName != null) binding.ElementName = ElementName;
if (FallbackValue != null) binding.FallbackValue = FallbackValue;
if (TargetNullValue != null) binding.TargetNullValue = TargetNullValue;
if (RelativeSource != null) binding.RelativeSource = RelativeSource;
_targetObject.SetBinding(_targetProperty, binding);
return binding.ProvideValue(serviceProvider);
}
}
```
В xaml можно писать так:
Width="{ViewModel DefaultValue=800}"
**Итоги**
Пожалуй, достаточно, я преподнёс много информации в сжатом виде, поэтому для полноты понимания лучше ознакомиться с примером проекта.
Резюмируя всё сказанное, можно выделить следующие плюсы подхода:
— чистый, лаконичный и структурированный код. Интерфейсная логика, слабо связанная с бизнес-логикой, инкапсулируется внутри базовых классов вью-модели, в то время как конкретная реализация вью-модели содержит именно ту логику, которая тесно связана с бизнес-правилами;
— простота и универсальность решения. Ко всему прочему, сериализация позволяет очень гибко настраивать интерфейс приложения с помощью конфигурационных файлов;
— удобная реализация валидации через интерфейс IDataErrorInfo.
Минусы:
— отказ от инжекций в конструктор (хотя это и не обязательное требование);
— некоторая неявность решения для человека, не знакомого с ним.
**Освоив данный подход и имея в распоряжении всего несколько базовых классов, вы сможете комфортно, быстро и качественно писать приложения с богатым интерактивным интерфейсом, при этом оставляя вью-модели чистыми и компактными.**
Очень надеюсь, что статья окажется для вас полезной! Спасибо за внимание!
P.S. Не знаю точно, как в Silverlight, но на WinPhone-платформе есть некоторые ограничения (отсутствуют расширения разметки, RoutedCommands и CommandBindings), однако при большом желании их можно обойти. Более детально это описано в статье [WinPhone: пути к совершенству](http://habrahabr.ru/post/210778/).
P.P.S. Как я уже сказал выше, все описанные методы, применены мной при создании полноценного текстового редактора. Те, кому интересно, что же в итоге получилось за творение, могут найти его по [этой ссылке](http://poet.of.by/ru/) или [резервной](http://yadi.sk/d/eU7-sZkAFcv2B). Мне кажется, что **в программировании и поэзии очень много общего**: также как мастер слова способен несколькими фразами выразить то, на что у обычного человека уйдет не один абзац, так и опытный программист решает сложную задачу несколькими строками кода.
Вдохновения вам!
~~~~~~~~~~~~~~~~~~~~~~~~~
*Комментарии:*
— в качестве представления (View) можно использовать любой контрол, поэтому порой не обязательно выделять представление в отдельную сущность (новый класс), а также добавлять свойство в другую вью-модель. Поясню на примере:
```
…
<!--<TextBlock DataContext={Store viewModels:DetailsViewModel} Text={Binding Name}/>--!>
…
```
То есть нам не нужно инжектировать DetailsViewModel в MainViewModel, только ради того, чтобы где-то на интерфейсе отобразить свойство Name, также не нужно, например, создавать DetailsShortView. В проекте получается меньше классов, а структура остаётся понятной.
— в статье я показал основные принципы, используя которые можно быстро и качественно сделать функциональное приложение. Совершенно не обязательно использовать всё как есть, вы в праве совершенствовать, видоизменять и фантазировать! В этом и есть развитие, успехов! | https://habr.com/ru/post/208326/ | null | ru | null |
# Именованные параметры Boost
Временами от C++ хочется более гибкого механизма параметризации функций. Например, есть у нас функция с двумя обязательными параметрами и большим количеством необязательных.
```
bool foo(int important, int& pOut, int sometimes = 1, int occasionally = 2, int rarely = 3)
{
//...
}
```
Проблемы здесь могут быть следующие
1. Пользователи постоянно путают порядок параметров, тип их практически полностью совпадает, поэтому компилятор ничем помочь не может (разве что иногда со вторым параметром).
2. Из необязательных параметров чаще всего нужен один, причем если это не **sometimes**, пользователи вынуждены вспоминать значения по умолчанию, чтобы задать их в вызове явно. Значения по умолчанию разные, так что ошибок снова много
3. Нет никакой возможности выразить зависимость значений по умолчанию одних параметров от других.
Проблемы эти можно решить по-разному: передавать в качестве параметра структуру, использовать перегрузку функций или даже функции с разными именами… Boost предлагает еще один вариант решения.
Это [именованные параметры](http://www.boost.org/doc/libs/1_55_0/libs/parameter/doc/html/index.html). Больше мы не привязаны к порядку следования параметров, возможность же задавать осознанные имена при вызове существенно снижает вероятность ошибок. В качестве дополнительного бонуса получаем возможность использовать одни параметры при вычислении значения по умолчанию других.
В качестве примера рассмотрим, как можно определить функцию **foo** с использованием предлагаемого механизма (имя изменим на **namedParametersFoo**, чтобы не было путаницы). Для начала подключаем заголовочный файл boost и определяем имена параметров с помощью специального макроса. Обратите внимания — никаких знаков препинания.
```
#include
BOOST\_PARAMETER\_NAME(important)
BOOST\_PARAMETER\_NAME(pOut)
BOOST\_PARAMETER\_NAME(sometimes)
BOOST\_PARAMETER\_NAME(occasionally)
BOOST\_PARAMETER\_NAME(rarely)
```
далее задаем функцию
```
BOOST_PARAMETER_FUNCTION(
(bool),
namedParametersFoo,
tag,
(required
(important, *)
(in_out(pOut), *)
)
(optional
(sometimes, *, important * 2)
(occasionally, *, 300)
(rarely, *, 400)
)
)
{
// Тело функции
}
```
Макросу передается четыре параметра, разделяемых запятыми
1. Тип возвращаемого значения — обязательно в скобках
2. Имя функции
3. Пространство имен с параметрами. **BOOST\_PARAMETER\_NAME** автоматически помещает объявления в **tag**
4. Список параметров
Список параметров имеет свою структуру. Также, заметьте, знаков препинания практически никаких — есть только запятые при определении непосредственных параметров.
Вначале идет блок **required**. Как следует из названия, он содержит список обязательных параметров. Каждый параметр должен быть помещен в круглые скобки. Для определения обязательного параметра необходимо задать его имя и ограничения типа. В данной статье механизм ограничения типов не рассматривается, поэтому будем просто использовать звездочку. Подробнее на эту тему можно почитать [здесь](http://www.boost.org/doc/libs/1_55_0/libs/parameter/doc/html/index.html).
Затем следует блок необязательных параметров. Здесь при определении каждого параметра появляется дополнительная возможность задать значение по умолчанию. Как видно из примера выше, можно использовать в выражениях остальные параметры.
Собственно все. Функция поддерживает вызовы «по старинке» — как если бы была определена с обычными необязательными параметрами. Т.е. как будто заработал вариант
```
bool newFoo(int important, int& pOut, int sometimes = important * 2, int occasionally = 2, int rarely = 3)
{
//...
}
```
***newFoo** не скомпилируется из-за зависимости параметра **sometimes** от **important***
Т.е. можно использовать **namedParametersFoo** так
```
int s = 0;
namedParametersFoo(1, s, 1, 1, 1);
namedParametersFoo(1, s, 1, 1);
namedParametersFoo(1, s, 1);
namedParametersFoo(1, s);
```
Но это еще не все! Задействовав именованные параметры, мы освобождаем себя как от порядка следования аргументов, так и от обязательных ненужных значений по умолчанию. Единственное неудобство — требуется добавлять знак подчеркивания вначале имен.
```
namedParametersFoo(_sometimes = 1, _important = 111, _pOut = s);
```
Итак, что в этом примере нового хорошего
1. Наглядность — видно, что именно мы имеем в виду под числами 1 и 111, вероятность запутаться/ошибиться снижается
2. Произвольный порядок — необязательный параметр написан первым, и все работает
Несмотря на то, что появилась возможность изменять позицию обязательных параметров и даже смешивать их с необязательными, все продолжает контролироваться на этапе компиляции, т.е. следующий код
```
namedParametersFoo(_sometimes = 1, _pOut = s);
```
не соберется — пропущен необходимый параметр **\_important**
На этом все. Хочется добавить, что механизм не самый простой и очевидный, поэтому если получается обойти проблему стандартными средствами языка, то лучше так и делать. К тому же применение именованных параметров boost может негативно сказаться на времени компиляции. Но если все обходные пути получаются кривыми, а boost уже и так используется в проекте — польза однозначно будет. | https://habr.com/ru/post/213015/ | null | ru | null |
# Опубликованы спецификации графического формата QOI, который в 20–50 раз быстрее PNG
Примерно месяц назад польский программист Доминик Шаблевски представил на суд публики новый графический формат QOI (Quite OK Image). Формат сжимает без потери качества, ориентируется на максимальную скорость кодирования/декодирования изображений, и по бенчмаркам значительно превосходит libpng и stbi. Разница в сжатии составляет 20−50 раз, в декомпрессии — 3−4 раза.
Кроме того, формат сжатия исключительно простой, закодирован буквально в [300 строчек кода](https://github.com/phoboslab/qoi), и работает по простым правилам типа [кодирования повторов](https://en.wikipedia.org/wiki/Run-length_encoding) (RLE). Естественно, он не связан никакими лицензионными соглашениями и ограничениями.
И вот вчера после исправления всех недочётов наконец-то [опубликованы финальные спецификации](https://phoboslab.org/log/2021/12/qoi-specification), так что теперь QOI документально забетонирован и его можно начинать использовать в продакшне. Что примечательно, полные спецификации QOI [поместились на одной странице](https://qoiformat.org/qoi-specification.pdf)!
Собственно, вот эта страница, то есть спецификации формата целиком:
[](https://habrastorage.org/webt/w9/hy/1d/w9hy1dw5q4nneswn487obs7xdku.png)
В спецификациях описан весь алгоритм кодирования. Доминик уже [объяснял](https://phoboslab.org/log/2021/11/qoi-fast-lossless-image-compression), что он обычный разработчик и не очень хорошо разбирается в сложных методах, которые используются в современных графических кодеках. Как программист он реализовал простые математические методы. Изображение кодируется в один проход, каждый пиксель считывается только один раз и кодируется одним из четырёх методов, по порядку:
1. Если пиксель равен предыдущему, счётчик увеличивается на единицу. Если нет, то применяется метод 2, и так далее
2. Пиксель равен элементу массива последних пикселей
3. Записывается разница с предыдущим пикселем, если она небольшая
4. Полное значение RGBA
Результирующие значения записываются в группы с указанием сначала тега (метод кодирования), после которого идут биты. Все группы выровнены по байтам для ускорения доступа в памяти.
За месяц автор получил более 500 комментариев, в том числе по оптимизации формата, так что теперь QOI стал ещё быстрее, а уровень сжатия вырос, см. [бенчмарки на 2879 изображениях](https://qoiformat.org/benchmark/). Что самое удивительное, благодаря подсказкам коллег алгоритм сжатия стал *ещё проще* — автор удалил из формата заголовок `size` и [некоторые лишние процедуры](https://github.com/phoboslab/qoi/issues/48). Код референсного кодека и декодера [опубликован на Github](https://github.com/phoboslab/qoi). Естественно, в него можно вносить любые изменения и дополнения, приспосабливая для своих нужд.
За последние несколько недель написаны реализации QOI для многих популярных языков программирования и библиотек, включая [Zig](https://github.com/MasterQ32/zig-qoi), [Rust](https://github.com/steven-joruk/qoi), [Rust](https://github.com/ChevyRay/qoi_rs), [Rust](https://github.com/zakarumych/rapid-qoi), [Go](https://github.com/xfmoulet/qoi), [TypeScript](https://github.com/panzi/jsqoi), [Haskell](https://github.com/0xd34df00d/hsqoi), [Ć](https://github.com/pfusik/qoi-ci), [Python](https://github.com/kodonnell/qoi), [C#](https://github.com/NUlliiON/QoiSharp), [Elixir](https://github.com/rbino/qoix), [Swift](https://github.com/elihwyma/Swift-QOI), [Java](https://github.com/saharNooby/qoi-java) и [Pascal](https://github.com/DosWorld/pasqoi), обёртки (врапперы) для [Python](https://github.com/kodonnell/qoi) и [Lua](https://github.com/Cr4xy/lua-qoi). Разработано [нативное приложение для просмотра файлов QOI](https://github.com/floooh/qoiview), плагины для [Gimp, Paint.NET и XNView MP](https://github.com/pfusik/qoi-ci), планируется [поддержка в SDL\_Image](https://github.com/libsdl-org/SDL_image/pull/199).
#### Бенчмарки, база 2879 изображений
| | Декодер, мс | Кодер, мс | Декодер, mpps | Кодер, mpps | Размер, КБ | Пропорция от оригинала |
| --- | --- | --- | --- | --- | --- | --- |
| **libpng** | 22,9 | 310,8 | 47,42 | 3,49 | 1799 | 56,6% |
| **stbi** | 26,7 | 195,6 | 40,63 | 5,55 | 2498 | 78,6% |
| **qoi** | 7,4 | 11,1 | 147,02 | 97,55 | 2102 | 66,2% |
*mpps — миллионов пикселей в секунду*
QOI показывает разную эффективность на изображениях разных типов: скриншоты, текстуры, фотографии, иллюстрации из Википедии и т. д. На некоторых картинках он кодирует в 60 раз быстрее PNG, а на других только в 30.
Новый формат предназначен для задач с интенсивным кодированием/декодированием изображений, где важен не столько размер изображений, сколько нагрузка на CPU и скорость. Например, вычисления на облачном сервисе (с оплатой за CPU), обработка больших фотоколлекций, нагрузка headless-браузеров, скриншоты, веб-скрапинг и др. В наше время накопители очень дёшевы, так что скорость зачастую становится более важным фактором, чем экономия дискового пространства. | https://habr.com/ru/post/596901/ | null | ru | null |
# Кривые линии на Google Maps
Думается мне, что скоро Google даст нам возможность нарисовать не только ломаную на своих картах, но и кривую. А с необходимостью нарисовать кривую линию я столкнулся уже сейчас, в процессе работы с одним проектом. И пришлось вертеться.
Я обычно очень люблю почитать на Хабре посты вида «Смотрите, что я сделал» (особенно, когда это не стартап). Поэтому — смотрите, что я сделал — я реализовал грязный хак, который поможет нарисовать кривые.
Сначала — картинка (не кликабельно):
#### Прежде чем читать много букв, хочу попробовать!
Я бы тоже захотел. Пройдите [вот по этому адресу](http://tvoytlt.ru/approx-polyline/trunk/tests/test.html). Там будет карта. Щелкните по ней один раз, потом щелкните в другом месте, на некотором удалении от первого щелчка. Посмотрите на результат. Можете щелкать дальше.
#### Зачем?
Обычно мне хочется нарисовать кривую линию, когда я изображаю на карте путь пешехода. Ведь люди не ходят через дома, не левитируют над речками и вообще любят тротуар. Поэтому мне всегда хотелось изобразить их путь кривой.
#### Как задавать кривые?
Кажется, заставлять людей учить теорию по кривым Безье, это не очень здорово. Поэтому я решил, что достаточно задавать кривые функциями одного переменного. Я лично больше всего люблю синус и косинус. Они достаточно красочно изображают путь пьяного пешехода.
#### Как они будут отображаться?
Графики функций будут аппроксимироваться графиками многочленов. По-русски: будут выбираться несколько точек на графике и соединяться отрезками. От количества точек зависит качество получаемого графика и скорость работы.
#### Как это выглядит в коде?
`my_poly = ApproxPolyline(gmap, lls, f, range, points);
map_instance.addOverlay(my_poly.get_polyline());`
`gmap` — объект класса `GMap2` (он нужен, потому что в нем есть метод преобразования географических координат в декартовы),
`lls` — массив из двух точек, которые надо соединить графиком (объектов класса `GLatLng`),
`f` — функция одного переменного, которую хочется изобразить,
`range` — массив из двух чисел (отображаемый промежуток),
`points` — количество точек, которые будут соединены отрезками.
#### Где скачать?
##### Ссылки
Я разместил это на GitHub: [страница репозитория](http://github.com/LongMan/approx-polyline/tree/master) и ссылки на архивы со скриптом последней ревизии: [zip](http://github.com/LongMan/approx-polyline/zipball/master) и [tar](http://github.com/LongMan/approx-polyline/tarball/master).
##### Размер
Исходник скрипта на момент публикации весит 3400 байт, после сжатия YUICompressor — 2026 байт.
##### Лицензия
Код распространяется по лицензии MIT.
#### Как помочь?
Есть два способа:
1) Сказать мне, что не так. В комментариях, в почте или любым другим удобным способом.
2) Клонировать ветку на github, сделать изменения и сообщить мне, если вы хотите, чтобы они влились в мою ветку.
#### А он умеет ~~«грабить корованы»~~?
Нет, а еще он не умеет заменять вам [gnuplot](http://www.gnuplot.info/) и другие программы, которые рисуют графики. Поэтому всем, кто хочет нарисовать, например, тангенс на промежутке [-10; 10], сразу хочу сказать — получится плохо, ведь опорные точки распределяются равномерно. Потому что я ума не приложу, зачем рисовать графики неограниченных функций на картах :-)
Хотя тангенс на отрезке [-1; 1] выглядит очень даже ничего — потому что ограничен и непрерывен.
#### [:||||:]
Ах да, возможно это уже кто-то сделал, а я не знаю. Мне захотелось тряхнуть стариной и вспомнить немножко математики. Если это действительно не актуально, дайте мне знать и я скрою топик (только сначала научите — как).
 | https://habr.com/ru/post/40503/ | null | ru | null |
# Частотный метод идентификации линейных динамических систем: теория и практика
В практиктических приложениях ТАУ часто необходимо точно и качественно идентифицировать объект управления. В этой статье речь пойдет об идентификации объекта управления частотным методом. Данный метод применим, когда есть возможность физически протестировать объект управления синусоидальным входным воздействиямем, изменяя частоту в широком диапазоне. Если это условие соблюдено, то результат, как правило, оправдывает самые оптимистичные ожидания.
Что необходимо знать
--------------------
Начнем с краткой теоретической справки. Для понимания материала статьи читателю необходимо иметь представление о следущих вещах:
* Преобразование лапласа
* Линейные динамические системы
* Характеристическое уравнение
* Передаточная функция
* Дискретное преобразование Фурье
* Характеристика Боде: ЛАЧХ и ЛФЧХ
Отклик на синусоидальное воздействие
------------------------------------
Как известно, отклик динамической системы на синусоидальное воздействие — есть синусоида с той же частотой, но отличной амплитудой и фазой. Именно эти две характеристики: амплитуда и фаза образуют график Боде, то есть ЛАЧХ и ЛФЧХ. По сути, задача идентификации динамической системы сводится к экспериментальному нахождению этих двух графиков.
Для примера рассмотрим уравнение гармонического осциллятора с ненулевой правой частью как образец линейной динамической системы второго порядка
Обозначим преобразование Лапласа произвольной функции  через . Применим преобразование Лапласа к обеим частям уравнения
Тогда характеристическое уравнение динамической системы будет
А передаточная функция
Искомые характеристики ЛАЧХ и ЛФЧХ получаются заменой  и взятием модуля и аргумента функции  соответственно
Здесь  — амплитуда (Magnitude), а  — фаза (Phase) соответствующей компоненты на частоте . В результате получится нечто похожее на это
*Характеристика Боде: ЛАЧХ и ЛФЧХ*
Эти два графика однозначным образом характеризуют динамическую систему. Справедливо и обратное, зная ЛАЧХ и ЛФЧХ динамической системы с некоторой точностью, можно полностью идентифицировать данную систему в некоторых доверительных интервалах. Вопрос состоит в том, как получить частотные характеристики. Об этом мы и расскажем далее.
Подавая синусоидальное воздействие на вход, мы будем наблюдать примерно такую картину
*Синусоидальное входное воздействие и отклик системы*
График получен в эксперименте. Как видно из графика, в выходном сигнале явно присутствует синусоидальная составляющая с той же частотой, что и у входного сигнала. Однако, помимо этого там могут содержаться также и высшие гармоники, и шумы. Но не стоит беспокоиться, потому что преобразование Фурье — мощнейший аналитический инструмент, который настолько хорош, что может выделить полезный сигнал, исключая все возмущения.
Дискретное преобразование Фурье
-------------------------------
Допустим, мы измерили два графика, входное воздействие  и отклик системы , для какой-то заданной частоты входного воздействия . Необходимо, чтобы оба измерения были сделаны синхронно и с одинаковым периодом дискретизации , который должен быть известен достаточно точно. Таким образом, мы имеем два набора дискретных значений  и , где , а  и  — значения  и  в соответствующие дискретные моменты времени . Следует заметить, что полное время измерения должно быть достаточно большим, чтобы захватить хотя бы несколько (я бы рекомендовал 3 или больше) периодов колебаний.
К дискретным наборам  и  можем применить дискретное преобразование Фурье. Дискретное преобразование Фурье переводит вышеуказанные сигналы из временн**о**й области в частотную, то есть
где , а  и  — соответствующие комплексные амплитуды -й гармоники.
Применение метода
-----------------
Теперь применим дискретное преобразование Фурье к нашим двум сигналам. На рисунке ниже показаны графики амплитуд  и 
*Амплитудный спектр входного и выходного сигнала*
График также получен при обработке экспериментальных данных. Как можно видеть, на графике выделяется острый пик на частоте  Hz. Это «несущая» частота входного воздействия, то есть частота, на которой происходило возбуждение объекта управления. На обоих графиках, входном и выходном, для данной гармоники наблюдается пик. Из двух значений комплексных амплитуд  и  на данной частоте получим значение передаточной функции .
Как мы помним,
В случае же дискретных  и  имеем
Тогда, на графики ЛАЧХ и ЛФЧХ можем нанести точку:
Какую же частоту имеет гармоника с номером ? Отвечаем: частота гармоники дается формулой
Можно также записать
Выражение же для, собственно, гармоники следующее
Описанную выше процедуру нужно повторить достаточное количество раз, чтобы захватить весь диапазон частот. Как правило, можно использовать более крупный шаг по частоте в области низких и высоких частот. И наоборот, более мелкий шаг необходим в области промежуточных частот, и особенно вблизи резонансов.
Проделав такой эксперимент и обработав данные, получаем таблицу частотных характеристик
Можно сразу построить измеренные графики ЛАЧХ и ЛФЧХ. Выглядит это примерно вот так
*ЛАЧХ и ЛФЧХ, построенные по экспериментальным данным*
Нужно сказать, что, хотя мы и пользовались дискретными методами, эти два графика отражают динамику *исходной* физической системы, то есть объекта управления, без каких-либо упрощений, связанных с дискретизацией (разумеется, в данном диапазоне частот).
Теперь нужно воспользоваться MATLAB, а конкретнее System Identification Toolbox. В составе этого Toolbox'а есть System Identification App — интерактивное приложение, которое может идентифицировать вашу систему по частотным данным. К слову, есть и другие опции, как то, идентификация напрямую по временн**ы**м измерениям.
Для корректной идентификации необходимо знать порядок системы. Здесь нам поможет график ЛФЧХ. Чтобы узнать порядок системы, посмотрите на график ЛФЧХ и прикиньте, на сколько раз по 90 градусов отстает фаза на высокой частоте. Количество раз по 90 градусов и будет порядок (знаменателя) вашей системы.
Во время идентификации автоматически генерируется отчет, который может быть очень полезен. Выглядит он вот так
```
tf1 =
From input "u1" to output "y1":
-97.64 s + 1.063e04
---------------------
s^2 + 1.547 s + 176.7
Name: tf1
Continuous-time identified transfer function.
Parameterization:
Number of poles: 2 Number of zeros: 1
Number of free coefficients: 4
Use "tfdata", "getpvec", "getcov" for parameters and their uncertainties.
Status:
Estimated using TFEST on frequency response data "h".
Fit to estimation data: 92.26% (stability enforced)
FPE: 120.6, MSE: 112.3
```
Согласно отчету об идентификации, входные данные удовлетворяются найденной моделью на 92.26%. Имеем следующую передаточную функцию физической системы
Теперь у вас есть объект типа IDTF c именем tf1, с которым можно делать все то же самое, что и с любой другой LTI System в MATLAB. Кроме того объект содержит в себе информацию о неопределенности внутренних параметров, и если мы построим Bode Plot, то на графике можно вызвать отображение доверительных интервалов. В настройках можно указать количество стандартных отклонений.
*Идентифицированная модель системы с доверительными интервалами*
Чтобы проверить правильность идентификации можно совместить экспериментальные точки с графиками частотных характеристик идентифицированной модели
*Совмещенные графики для ЛАЧХ и ЛФЧХ*
Заключение
----------
Использование данного метода существенно облегчает процесс проектирования системы управления. Автор статьи успешно разработал и воплотил в железе LQG котроллер для гидравлической цепи специального назначения. Кроме того, данный метод можно использовать для оценки эффективности системы управления, при условии, что вам физически доступно входное воздействие на объект управления со стороны нежелательных возмущений. | https://habr.com/ru/post/346812/ | null | ru | null |
# Установка Netbeans 7.0.1 в Mac OS X 10.7 Lion
Я совсем недавно стал обладателем MacBook Pro и пользователем Mac OS X.
Купил я этого «зверя» не забавы ради, а для того что бы работать. Ну и сразу же приступил к настройке системы: установка компиляторов, интерпретаторов, IDE, различных библиотек и расширений, а так же другого софта необходимого для разработки или упрощающего её.
После того как я обновил свою систему до «льва», благодаря вот [этому посту](http://habrahabr.ru/blogs/apple/124713/) абсолютно бесплатно, и поставил из app store, так же бесплатно, новый Xcode, установка приложений, из MacPort или DMG пакетов, пошла как по маслу. Через какое-то время дошла очередь до Netbeans 7.0.1. После установки продуктов от JetBrains, которые установились менее чем за 5 минут, с учетом закачки, Netbeans сказали, что не видят Java и отказались устанавливаться.
Решение для моего случая нашлось [на официальном багтреккере](http://netbeans.org/bugzilla/show_bug.cgi?id=199399):
`# Необходимо выполнить две команды значение, которых скорее всего объяснять не надо
sudo mkdir -p /System/Library/Java/JavaVirtualMachines/
sudo ln -s /Library/Java/JavaVirtualMachines/1.6.0_26-b03-383.jdk /System/Library/Java/JavaVirtualMachines/1.6.0.jdk`
После этого можно запускать инсталяцию и прокликав кнопочку «Next» несколько раз дожидаться появления кнопочки «Finish».
Решил опубликовать заметку про этот баг, так как Netbeans является популярным бесплатным IDE и такие проблемы могут возникнуть у других пользователей.
PS Вообще я надеюсь, что моя статья не будет ни кому полезна и у всех установка пройдет как по маслу. А Юлия Новожилова, разработчица, которой назначили задачу, в скором времени решит эту проблему и надобность в статье пропадет сама собой. | https://habr.com/ru/post/125584/ | null | ru | null |
# Распараллеливание задач. Случай «идеальной параллельности». Часть 2
### Предлагаемые решения в .NET 4
Это вторая часть статьи, посвященной распараллеливанию идеальных циклов. В [первой части](http://habrahabr.ru/blogs/net/104078/ "Распараллеливание задач. Случай «идеальной параллельности». Часть 1") были рассмотрены проблемы, возникающие при этом, и общие подходы к их решению. В этой мы поговорим о конкретных библиотечных компонентах, предоставляемых .NET 4.0 для поддержки этих задач.
Для распараллеливания «идеальных» циклов предоставляются следующие варианты:
* класс System.Threading.Tasks.Parallel с методами For (), ForEach ()
* Parallel LINQ с методом расширения AsParallel ().
#### Методы Parallel.For и Parallel.ForEach
Начнём с рассмотрения класса Parallel и его методов организации циклов.
Первый рассматриваемый нами метод имеет сигнатуру (это базовая, одна из многих перегрузок):
> `1. public static ParallelLoopResult For(int fromInclusive, int toExclusive, Action<int> body);`
Она во многом аналогична сигнатурам наших экспериментальных методов из [первой части статьи](http://habrahabr.ru/blogs/net/104078/ "Распараллеливание задач. Случай «идеальной параллельности». Часть 1"), кроме типа возвращаемого значения.
Второй «в базовой комплектации» выглядит как:
> `1. public static ParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source, Action<TSource> body);`
Рассмотрим, что умеют методы Parallel.For и Parallel.ForEach.
**Обработка исключений.** При возникновении исключения в одной из итераций, новые итерации больше не стартуют. Уже стартовавшие, тем не менее, могут закончить свою работу, и уже по их завершении все исключения (изначальное и возможные последующие исключения в дорабатывавших итерациях) аггрегируются в одно исключение типа AggregateException и оно выкидывается.
**Раннее прерывание цикла.** Соответствующие перегрузки метода For предоставляют возможность прерывать выполнение, вызывая у контекстного объекта (передаваемого в каждую итерацию) методы Stop или Break.
Отличие Stop от Break в том, что Stop сигнализирует о необходимости прекратить запускать новые итерации вообще, а Break — прекратить запускать новые итерации, следующие (по порядку) за той, в которой вызван Break. То есть, при вызове Break на 5-й итерации гарантируется, несмотря на параллельность, что итерации с 1-й по 4-ю всё же будут выполнены. А при вызове Stop на 5 итерации, если итерация 4 ещё не стартовала, то она и не будет стартовать.
Текущие итерации, которые уже были запущены на момент вызова Stop или Break, могут проверять статус прерывания цикла, и завершиться раньше времени, если узнают о прерывании всего цикла. Для этого они могут у контекстного объекта проверить соответствующие свойства: IsStopped и LowestBreakIteration.
**Поддержка хранения данных на уровне потока**. Некоторые перегрузки метода позволяют сохранять промежуточные результаты вычислений в хранилище данных, локальном для каждого потока. Это позволяет, например, при агрегации результата, сперва агрегировать результаты работы отдельного потока, и только потом уже агрегировать их между всеми работавшими потоками. Это избавляет от излишних затрат на синхронизацию в процессе вычислений.
**Возможность конфигурирования уровня параллелизма**. Можно указать максимальное количество потоков, используемое для выполнения.
**Поддержка вложенности вызовов**. Благодаря использованию пула потоков, чрезмерной многопоточности не возникает как при вложенных вызовах методов For и ForEach, так и при параллельном их выполнении.
**Динамическое изменение количества потоков**. Parallel.For был спроектирован из расчёта изменяющейся во времени загрузки, и с учётом того, что некоторые элементы работы могут требовать большего количества вычислений, чем другие. Поэтому количество используемых потоков может изменяться в процессе работы метода.
**Сложное управление загрузкой потоков**. В методе была реализована логика балансировки загрузки потоков, которая учитывает большое количество разных факторов. Также, размер блока («порции данных» для обработки) увеличивается в процессе работы, что позволяет получить более качественную балансировку загрузки для небольшого количества итераций (предполагается, что более «тяжелых» при этом), и меньшие затраты на синхронизацию «раздачи заданий» при большом количестве итераций.
**Поддержка отмены выполнения цикла извне его.** Для этого используется класс CancellationTokenSource. При запуске цикла необходимо передать в него свойство Token, и тогда для запроса отмены цикла извне необходимо просто вызвать у объекта CancellationTokenSource метод Cancel (), что предотвратит запуск новых итераций цикла, и по завершению всех текущих сгенерирует исключение OperationCanceledException. Текущие итерации, кстати, могут проверять статус отмены, чтобы «добровольно» завершиться раньше времени, если они узнают, что весь цикл отменён.
#### Parallel LINQ
Доступный ещё в .NET 3.5 в качестве расширения, Parallel LINQ доступен в .NET 4.0 сразу в System.Core. Идея его использования очень проста: мы добавляем в цепочку LINQ-запросов вызов .AsParallel (), и все последующие вызовы в цепочке выполняются распаралеленно. Например:
> `1. var doubled = new [] {1, 2, 3, 4}.AsParallel().Select(i => i\*2);`
Может оказаться неочевидным, что порядок следования элементов в результирующей коллекции может быть произвольным, так они обрабатываются параллельно. Чтобы сохранить порядок следования элементов в коллекции, мы можем модифицировать наш первый фрагмент вот так:
> `1. var doubled = new [] {1, 2, 3, 4}.AsParallel().AsOrdered().Select(i => i\*2);`
Обработка всё равно пройдёт параллельно, но этап агрегации (сборки результатов от каждого потока) может длиться дольше, так как нужно будет дождаться сперва потоков, считающих «первые» элементы, взять их результат, и только потом взять результат от потоков, считавших «последние» элементы.
Важно осознавать при работе с PLINQ, что есть дополнительные накладные расходы на 1. распределение поступающих элементов исходного перечисления по потокам
2. агрегацию вычисленных элементов в общую коллекцию.
Причём от распределения работы по потокам никуда не деться, а вот агрегацию можно попробовать отсрочить, а то и вообще обойтись без неё, если стоит задача не получить новую коллекцию, а просто обработать элементы существующей.
Метод AsParallel () возвращает не IEnumerable, а ParallelEnumerable, после чего все другие LINQ-методы (Select, Where и т.п.) тоже возвращают этот же тип. До тех пор, пока в цепочке передаётся ParallelEnumarable, результаты вычисления каждого из потоков без необходимости не агрегируются, и строится конвейер.
Важно понимать, что когда конвейер рвётся, параллелизм прекращается и данные агрегируются в единую результирующую коллекцию. Например, вот этот код работает не так, как можно было бы ошибочно предположить:
> `1. List<InputData> inputData = ...;
> 2. foreach (var o in inputData.AsParallel().Select(i => new OutputData(i)))
> 3. {
> 4. ProcessOutput(o);
> 5. }`
Параллельно здесь выполнится только создание объектов OutputData, после чего у всех потоков будут собраны эти объекты и из них будет образована результирующая коллекция, которая последовательно будет обходиться с вызовом ProcessOutput () для каждого элемента.
Чтобы избежать ненужного здесь этапа агрегации, можно воспользоваться методом ParallelEnumarable.ForAll ():
> `1. List<InputData> inputData = ...;
> 2. inputData.AsParallel().Select(i => new OutputData(i)).ForAll(o =>
> 3. {
> 4. ProcessOutput(o);
> 5. });`
В этом случае после этапа «new OutputData (i)» этап «ProcessOutput (o)» тоже будет выполняться параллельно, причём без этапа агрегации между ними.
Надо отметить, что вызов Parallel.ForEach () для «inputData.AsParallel ().Select (i => new OutputData (i))» будет иметь тот же недостаток, что и первый пример с обычным foreach: в Parallel.ForEach () передаётся IEnumerable, а не ParallelEnumerable — поэтому перед передачей коллекции в Parallel.ForEach () произойдёт её агрегация. Именно для избежания этого существует метод ParallelEnumerable.ForAll (), который и следует использовать в этом случае.
#### Типичные проблемы и ошибки
Рассмотрим возможные проблемы при работе с этими компонентами.
##### Потокобезопасность собственного кода
Прежде всего, надо понимать, что использование Parallel.ForEach само по себе не сделает ваш код потокобезопасным — необходимо самому следить, что итерации независимы друг от друга, или, если они зависимы, чётко предусмотреть потокобезопасную работу с разделяемыми ресурсами.
Также, при работе с Parallel.For непосредственно не поддерживаются нисходящие циклы и циклы с нестандартным (не равным единице) приращением счётчика. Если ваши изначальные алгоритмы написаны таким образом, необходимо внимательно проанализировать их, так как часто нестандартные циклы пишут как раз из-за наличия зависимостей между итерациями (обращение к вычисленному на предыдущем этапе предыдущему элементу массива и т.п.).
##### Размеры тела цикла
Использование класса Parallel предполагает накладные расходы, как минимум,
* на вызов делегата для выполнения тела цикла, и
* на синхронизацию между потоками при раздаче заданий.
Если тело цикла достаточно длительное, эти дополнительные расходы играют небольшую роль. Однако, если мы распараллеливаем что-то очень простое вроде «i = i\*i», накладные расходы в этом случае превышают полезную работу. Чтобы избавиться от этого недостатка, необходимо «укрупнить» тело цикла. Это очень просто сделать, включив в него не одну, а много итераций.
Вручную это можно сделать, явно разбив входную последовательность на набор блоков, и запустить параллельный цикл по этому набору, а в теле этого параллельного цикла уже последовательно обрабатывать каждый блок. Однако, тут придётся принимать решение о количестве этих блоков. Его можно возложить на библиотеку и воспользоваться классом, специально созданным для создания поднаборов из входной последовательности: System.Concurrent.Collections.Partitioner.
С его использованием цикл
> `1. for (int i = 0; i < length; i++)
> 2. result[i] = i\*i;`
вместо наивной версии:
> `1. Parallel.For(from, to, i =>
> 2. {
> 3. result[i] = i\*i;
> 4. });`
можно эффективно распараллелить вот так:
> `1. Parallel.ForEach(Partitioner.Create(from, to), range =>
> 2. {
> 3. for (int i = range.Item1; i < range.Item2; i++)
> 4. {
> 5. result[i] = i\*i;
> 6. }
> 7. });`
Partitioner.Create (from, to) создаёт тот самый набор блоков, по которому мы проходим параллельно, внутри тела цикла последовательно обрабатывая каждый блок. Тем самым мы обеспечиваем параллельному циклу длительное тело, и распределяем накладные расходы на большее количество полезной работы.
##### Обработка вложенных циклов
При обработке вложенных циклов возникает вопрос, насколько глубоко стоит проводить распараллеливание. Возьмём пример по обработке прямоугольного изображения:
> `1. for(int y = 0; y < screenHeight; y++)
> 2. {
> 3. int stride = y \* screenWidth;
> 4. for (int x = 0; x < screenWidth; x++)
> 5. {
> 6. rgb[x + stride] = calcColor(x, y); *// вычисляем цвет*
> 7. }
> 8. };`
Можно заменить только внешний цикл на вызов Paralllel.For, а можно и оба. Если сделать оба цикла параллельными, не окажется ли тело внутреннего слишком мало? Если оставить внутрений последовательным, точно ли мы загрузим работой все наши ядра?
Ответ на эти вопросы может дать только тестирование производительности. Вероятно, если вычисления цвета не слишком сложны, стоит оставить внутренний цикл последовательным. Но если мы работаем с широким, но невысоким изображением, вполне возможно, что одно только распараллеливание внешнего цикла загрузит не все ядра процессора.
Альтернативным путём может быть разворачивание двух вложенных циклов в один, и распараллеливание уже его:
> `1. int totalPixels = screenHeight \* screenWidth;
> 2. Parallel.For(0, totalPixels, i =>
> 3. {
> 4. int y = i / screenWidth, x = i % screenWidth;
> 5. rgb[i] = calcColor(x, y);
> 6. });`
Если calcColor () слишком проста, то чтобы укрупнить тело цикла, можно воспользоваться классом Partitioner, как в предыдущем примере:
> `1. int totalPixels = screenHeight \* screenWidth;
> 2. Parallel.ForEach(Partitioner.Create(0, totalPixels), range =>
> 3. {
> 4. for (int i = range.Item1; i < range.Item2; i++)
> 5. {
> 6. int y = i / screenWidth, x = i % screenWidth;
> 7. rgb[i] = calcColor(x, y);
> 8. }
> 9. });`
##### Непотокобезопасные реализации IList
Оба механизма — и Parallel.ForEach, и PLINQ принимают на входе IEnumerable, но при этом пытаются для переданной им коллекции найти наиболее быстрый интерфейс по работе с ней. В частности, для распараллеливания интерфейс IList подходит лучше, чем просто IEnumerable так как в нём есть индексер для произвольного доступа к любому элементу. Поэтому, если для переданной коллекции определён IList, то работа с ней происходит именно через этот интерфейс. Это понижает затраты на синхронизацию, **но при этом библиотечный код полагается на потокобезопасную реализацию индексера**.
Если же используемая коллекция не предоставляет потокобезопасный индексер, что часто может быть в случае, если элементы хранятся в сложном для индексации виде, или вообще подгружаются лениво, то необходимо явным образом указать системе, что для неё не нужно использовать IList, а ограничиться IEnumerable.
Чтобы это сделать, подходят два варианта. Первый — создать для коллекции System.Collections.Concurrent.Partitioner:
> `1. *// Здесь может быть использован IList, если он поддерживается коллекцией*
> 2. IEnumerable<T> source = ...;
> 3. Parallel.ForEach(source, item => { */\*...\*/* });
> 4.
> 5. *// А здесь гарантированно будет использоваться IEnumerable*
> 6. IEnumerable<T> source = ...;
> 7. Parallel.ForEach(Partitioner.Create(source), item => { */\*...\*/* });`
Второй способ очевиден, и знаком по обычному LINQ: просто вызвать для коллекции «.Select (item => item)». Он подходит как для Parallel.For, так и для PLINQ:
> `1. *// Здесь тоже гарантированно будет использоваться IEnumerable*
> 2. source.Select(i => i).AsParallel().Select(i => { */\*...\*/* });`
##### Наличие сродства к потоку (thread affinity) у исходной коллекции
При работе Parallel.ForEach и PLINQ каждый из рабочих потоков сам вызывает у исходной коллекции MoveNext (). Если коллекция такова, что доступ к ней возможен лишь из одного определённого потока (обладает «сродством к потоку»), как, например, бывает при работе с UI-компонентами в Windows Forms или WPF, то использовать эти механизмы непосредственно для неё нельзя.
Чтобы обеспечить параллельную обработку такой коллекции, нужно воспользоваться шаблоном Источник-Потребитель (Producer-Consumer), основной «кирпичик» для которого в .NET 4.0 — это класс BlockingCollection, о котором напишу позже отдельно. Подробнее пока о нём можно почитать на английском в разделе «Producer-Consumer» на 53 странице оригинального документа.
P.S. Данная статья написана под впечатлением книги «[PATTERNS OF PARALLEL PROGRAMMING: UNDERSTANDING AND APPLYING PARALLEL PATTERNS WITH THE .NET FRAMEWORK 4 AND VISUAL C#](http://www.microsoft.com/downloads/en/details.aspx?displaylang=en&FamilyID=86b3d32b-ad26-4bb8-a3ae-c1637026c3ee "Оригинальный документ на английском языке")» и может считаться её вольным переводом с переработкой.
#### Заключение
Надеюсь, этот экскурс поможет совершить меньше собственных ошибок при распараллеливании вашего кода. Но всё равно, удачной отладки, и с праздником:)
#### На будущее
Могу продолжить тему параллельности в 4 framework, если будет интерес. Это может быть про:
* класс Task и инфраструктуру для параллельных вычислений с зависимостями,
* новые потокобезопасные коллекции,
* ленивость и параллелизм,
* разделяемые данные и синхронизацию.
Пишите, что из этого в какой степени интересно:) | https://habr.com/ru/post/104103/ | null | ru | null |
# Мультимедиа центр «Kodi» и Yocto Project
Введение в Yocto Project
-------------------------
Yocto Project — это совместный Open Source проект для упрощения разработки дистрибутивов для встраиваемых систем. Yocto содержит большое количество шаблонов, метаданных и инструментальных средств сборки. В Yocto Project вы можете подключить большое количество BSP (пакет поддержки платформы) слоев для всевозможных аппаратных платформ.
Основное назначение статьи — это попытка показать сборку типового дистрибутива в Yocto Project на примере хорошо известного мультимедиа центра Kodi, версии 17.6 для одноплатного компьютера «Raspberry Pi» 3B.
Если где-то глубоко в душе вы чувствуете, что вы сборщик, но еще не решили, что бы вам такое пособирать, то эта статья для вас. Если же вы уже используете Yocto Project в своей повседневной работе, то можете эту статью пролистать. Сразу переходите к последней главе и соберитесь.
Статья является сугубо практической и демонстрирует возможности использования наработок Yocto Project и OpenEmbedded для сборки мультимедиа центра «Kodi». Управление слоями Yocto осуществляется с помощью утилиты Repo от Google. Статья из серии «Документируй это».
Итак: поехали.
Содержание:
-----------
[Установка](#install_yocto_koditv) Yocto Project в Ubuntu
[Механизм](#mechanism_build_koditv) сборки дистрибутива в Yocto Project
[Использование](#openembedded_koditv) OpenEmbedded совместно c Yocto Project
[Пакет](#package_bsp_koditv) поддержки платформы (BSP)
[Управление](#repo_koditv) слоями Yocto c помощью Repo
[Установка](#install_repo_koditv) Repo
[Манифест](#manifest_repo_koditv) для сборки дистрибутива
[Содержимое](#context_repo_koditv) Манифеста
[Описание](#desc_repo_koditv) Манифеста
[Структура](#struct_repo_koditv) bs-manifest
[Инициализация](#env_repo_koditv) переменных Poky
[Инициализация](#init_repo_koditv) Repo
[Синхронизация](#sync_repo_koditv) Repo
[Создание](#config_koditv) конфигурации Yocto Project
[Конфигурационный](#local_conf_config_koditv) файл build/conf/local.conf
[Конфигурационный](#bblayers_conf_config_koditv) файл build/conf/bblayers.conf
[Слой](#layer_koditv) для сборки мультимедиа центра
[Структура](#struct_top_layer_koditv) слоя
[Конфигурация](#config_layer_koditv) слоя
[Состав](#berserk_layer_koditv) recipes-berserk
[Состав](#core_layer_koditv) recipes-core
[Состав](#kernel_layer_koditv) recipes-kernel
[Состав](#mediacentre_layer_koditv) recipes-mediacentre
[Состав](#multimedia_layer_koditv) recipes-multimedia
[Дополнение рецепта](#build_kodi_koditv) для сборки Kodi
[Добавление нового](#add_menu_koditv) пункта в меню настроек Kodi
[Максимальные настройки](#max_set_video_koditv) буферизации для видео
[Просмотр телевидения](#iptv_koditv) по протоколу IPTV
[Просмотр Youtube](#youtube_koditv) с помощью Kodi плагина
[Консольное](#bsnet_layer_koditv) shell расширение конфигурации сети
[Рецепт](#distrib_recipe_koditv) сборки дистрибутива
[Краткая](#instruction_koditv) инструкция по созданию образа дистрибутива
[Постскриптум](#postscriptum_koditv)
Установка Yocto Project в Ubuntu
---------------------------------
Для сборки дистрибутива с помощью Yocto Project в Ubuntu вам необходимо установить следующие пакеты:
```
sudo apt-get install -y --no-install-suggests --no-install-recommends \
gawk wget git-core diffstat unzip texinfo gcc-multilib \
build-essential chrpath socat cpio python python3 python3-pip python3-pexpect \
xz-utils debianutils iputils-ping python3-git python3-jinja2 libegl1-mesa libsdl1.2-dev \
xterm
```
Пакеты устанавливаются с помощью команды **apt-get install** и команды повышения привилегий — **sudo**. В системе Ubuntu это широко распространенная практика, когда для выполнения административных действий используется команда sudo (при создании основного пользователя системы, он автоматически прописывается в группу «sudo»).
Более подробную инструкцию по установке вы можете посмотреть [здесь:](https://www.yoctoproject.org/docs/latest/ref-manual/ref-manual.html#ubuntu-packages)
Механизм сборки дистрибутива в Yocto Project
--------------------------------------------
В Yocto Project каждая программная единица описывается с помощью рецепта сборки. Язык описания рецепта напоминает «bash» c возможностью вставок частей кода на языке «python». Основную информацию по синтаксису вы можете почерпнуть из [руководства Yocto Project](http://www.yoctoproject.org/docs/latest/ref-manual/ref-manual.html) . Набор рецептов сборки в зависимости от назначения можно объединять в отдельные слои сборки.
Слои разделяются на аппаратно зависимые — BSP слои, UI слои (пользовательского интерфейса), специфические Yocto слои, а также слои реализующие определенную функциональность:
например слои из OpenEmbedded => multimedia, python, perl, ruby, networking, systemd, webserver и т.д.
Использование OpenEmbedded совместно c Yocto Project
----------------------------------------------------
И еще, если вы будете использовать Yocto Project, то наверняка вам понадобятся слои с дополнительной функциональностью т.е. большой набор рецептов на все случаи жизни. И такой набор есть — это рецепты из OpenEmbedded. OpenEmbedded — инфраструктура для сборки пакетов для встраиваемого Linux.
OpenEmbedded полностью совместим с Yocto Project, так как этот проект был взят за основу для Yocto Project. Возможно поэтому Yocto Project отличается немного лучшей стабильностью, лучшей документацией и немного лучшей поддержкой (но в основе своей это все тот же OpenEmbedded).
Пакет поддержки платформы (BSP)
--------------------------------
Пакет поддержки платформы (Board Support Package) — это отдельный, специализированный слой(и) для конкретной платы, который определяет аппаратные особенности платформы т.е. реализует те специфические вещи, которые отличают одну плату от другой: особенности процессора, прерывания, адресация, особенности загрузчика, особенности видео адаптера (GPU) и т.д.
В этой статье используется BSP слой — **meta-raspberrypi**
Репозиторий слоя располагается по адресу: [git.yoctoproject.org/git/meta-raspberrypi](https://git.yoctoproject.org/git/meta-raspberrypi)
Управление слоями Yocto c помощью Repo
---------------------------------------
Yocto Project может использовать большое количество слоев от разных поставщиков — разработчиков оборудования, и всем этим необходимо как то управлять. Представьте себе, что у вас есть десяток различных плат, и к каждой плате поставляется отдельный BSP гит репозиторий, и это не считая инфраструктуры самого Yocto проекта, плюс возможная дополнительная функциональность из OpenEmbedded.
В такой ситуации отдельным простым скриптом установки уже не отделаешься. Волей, неволей приходиться искать инструменты, которые умеют это делать хорошо. Даже более чем хорошо. Одним из лучших инструментов такого рода является утилита Google — Repo.
**Repo** — это основной инструмент для управления GIT репозиториями при сборке операционной системы «Андроид» с его большой кодовой базой. Repo позволяет в одном проекте управлять десятком, если не сотней отдельных гит репозиториев, версии которых вы можете аккуратно указать в одном xml файле **Манифеста**
и для правильной синхронизации всех версий всех репозиториев вам достаточно выполнить одну команду
**repo sync**
### Установка Repo
C помощью следующего набора команд вы можете установить Repo в ваш домашний каталог **~/bin**
(команду curl можно установить отдельно: sudo apt-get install curl)
```
PATH=${PATH}:~/bin
mkdir ~/bin
curl http://commondatastorage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
chmod a+x ~/bin/repo
```
и в дальнейшем вам достаточно использовать в консоли команду: **repo**
> или так,
>
> если каталог HOME/bin не добавился с стандартный путь запуска автоматически
>
> см. файл HOME/.profile
>
>
>
> $
>
> $ PATH=${PATH}:~/bin
>
> $ repo
>
> $
>
>
### Манифест для сборки дистрибутива
Дистрибутив, собираемый в рамках статьи, мне нужно как то назвать. Пусть это будет имя **Torvin** . Под кодовым названием Torvin будет содержаться минималистический Linux дистрибутив со сборкой одной единственной программы. Имеется ввиду одна прикладная пользовательская программа — Kodi, и ничего лишнего (все остальное системный уровень). Для мультимедиа центра, на мой взгляд этого вполне достаточно.
### Содержимое Манифеста
Для управления слоями дистрибутива используется файл **torvin-0.2.5.xml**
```
xml version="1.0" encoding="UTF-8"?
```
### Описание Манифеста
В начале манифеста тегами **remote** обозначены два основных GIT репозитория и один вспомогательный:
**https:⁄⁄git.yoctoproject.org/git** — Yocto репозиторий, именованный как **yocto**
**https:⁄⁄github.com/openembedded** — OpenEmbedded репозиторий, именованный как **oe**
https:⁄⁄github.com/berserktv — вспомогательный GIT репозиторий, именованный как **bs**
В следующей части манифеста с помощью сокращенных именований осуществляется работа с проектами расположенными в этих репозиториях, тег **project** содержит следующие атрибуты:
**remote** — имя удаленного именованного репозитория
**revision** — название ветки или hash версии
**name** — имя проекта в указанном репозитории
**path** — локальный путь проекта в вашей файловой системе
```
Пример работы тега
данный xml тег описывает выполнение примерно следующей команды:
git clone https://github.com/berserktv/bs-manifest -b master sources/bs-manifest
```
В теле тега **project** я указал команды создания символических ссылок на нужную мне инфраструктуру вспомогательных скриптов начальной инициализации и штатного запуска системы сборки **Poky**
```
Пример указания тегов linkfile
Создание символической ссылки разворачивается примерно
в следующую команду: ln -s src dest
т.е.
# создание двух ссылок на файлы
ln -s sources/bs-manifest/setup-environment setup-environment
ln -s sources/bs-manifest/raspberry/shell.sh shell.sh
# создание ссылки на каталог, разворачивается
# примерно в следующий набор команд
cd sources
ln -s bs-manifest/raspberry/rocko base
```
### Структура bs-manifest
```
├── COPYING.MIT
├── raspberry
│ ├── rocko
│ │ ├── conf
│ │ │ ├── bblayers.conf
│ │ │ └── local.conf
│ │ └── torvin-0.2.5.xml
│ └── shell.sh
├── README.md
└── setup-environment
```
Проект **bs-manifest** используется для гибкого управления конфигурациями, с учетом сборок разных версий дистрибутива. У меня это версия — 0.2.5
### Инициализация переменных Poky
Скрипт начальной инициализации **setup-environment** был взят из проекта Freescale Community (в среде yocto это часто встречающееся решение). Скрипт отвечает за стартовую инициализацию переменных системы сборки Poky, скрипт создает структуру каталогов, в которой очень хорошо разделяется:
* **build** — каталог сборки
* **source** — исходный код рецептов сборки
* **download** — каталог загрузки кода программ (git базы, tar.gz архивы)
Содержимое скрипта setup-environment можно посмотреть [здесь:](https://github.com/berserktv/bs-manifest/blob/master/setup-environment)
**Содержимое скрипта shell.sh**
```
#!/bin/bash
MACHINE='raspberrypi3' source ./setup-environment build
echo "you may try 'bitbake core-image-minimal'"
bash
```
этот корневой скрипт служит для начальной конфигурации переменных среды сборки и обычно вызывается в начале сеанса работы.
### Инициализация Repo
Для инициализации repo необходимо выполнить команду:
```
mkdir torvin
cd torvin
repo init -u https:⁄⁄github.com/berserktv/bs-manifest -m raspberry/rocko/torvin-0.2.5.xml
```
где **-u https:⁄⁄github.com/berserktv/bs-manifest** указывает GIT путь к проекту манифеста
примечание: можно еще указать **-b имя\_ветки**
(если ключ -b не указывать, то подразумевается ветка master (по умолчанию))
где путь **-m raspberry/rocko/torvin-0.2.5.xml** к конфигурационному файлу указывает следующее:
1. Имя аппаратной платформы для которой осуществляется сборка — **raspberry**
2. Имя основной рабочей ветки Yocto/OpenEmbedded — **rocko**
3. Кодовое имя версии — **torvin** (все версии серии 0.2.x)
4. Цифровой номер версии которая собирается — **0.2.5**
### Синхронизация Repo
для начальной загрузки или последующей синхронизации достаточно выполнить команду:
```
repo sync
```
которая заберет все последние версии GIT проектов указанных в файле манифеста (обычно указываются ветки), если же у вас указан hash коммита или имя тега в атрибуте revision, то версия для данного git репозитория не измениться. Имя тега можно указать так: revision=«refs/tags/v0.2.5»
### Создание конфигурации Yocto Project
После того, как будет выполнена команда repo sync, можно приступать к созданию основной конфигурации Yocto Project:
```
./shell.sh
```
после завершения работы скрипта, будет создан каталог **build/conf**:
c двумя основными файлами:
* **local.conf** — управляющие переменные сборки:
название платформы, тип дистрибутива и пакетов сборки и т.д.
* **bblayers.conf** — конфигурация подключенных слоев Yocto Project
по умолчанию скрипт setup-environment ищет по пути **sources/base/conf**
начальную конфигурацию, и если файлы **local.conf** и **bblayers.conf**
существуют, то они копируются в **build/conf**
(см. переменную TEMPLATES в setup-environment)
т.е. файлы берутся из sources/bs-manifest/raspberry/rocko/conf
см. создание символической ссылки на base
### Конфигурационный файл build/conf/local.conf
**Показать/Скрыть**
```
MACHINE ??= 'raspberrypi3'
DISTRO ?= 'poky'
PACKAGE_CLASSES ?= "package_deb"
EXTRA_IMAGE_FEATURES ?= "debug-tweaks"
USER_CLASSES ?= "buildstats image-mklibs image-prelink"
PATCHRESOLVE = "noop"
BB_DISKMON_DIRS = "\
STOPTASKS,${TMPDIR},1G,100K \
STOPTASKS,${DL_DIR},1G,100K \
STOPTASKS,${SSTATE_DIR},1G,100K \
STOPTASKS,/tmp,100M,100K \
ABORT,${TMPDIR},100M,1K \
ABORT,${DL_DIR},100M,1K \
ABORT,${SSTATE_DIR},100M,1K \
ABORT,/tmp,10M,1K"
PACKAGECONFIG_append_pn-qemu-native = " sdl"
PACKAGECONFIG_append_pn-nativesdk-qemu = " sdl"
CONF_VERSION = "1"
DL_DIR ?= "${BSPDIR}/downloads/"
# size memory GPU for Raspberry Pi
GPU_MEM = "128"
GPU_MEM_256 = "112"
GPU_MEM_512 = "160"
GPU_MEM_1024 = "320"
# for libs: "mpeg2dec libmad ffmpeg x264"
LICENSE_FLAGS_WHITELIST += "commercial"
```
### Конфигурационный файл build/conf/bblayers.conf
**Показать/Скрыть**
```
# POKY_BBLAYERS_CONF_VERSION is increased each time build/conf/bblayers.conf
# changes incompatibly
LCONF_VERSION = "6"
POKY_BBLAYERS_CONF_VERSION = "2"
BBPATH = "${TOPDIR}"
BSPDIR := \
"${@os.path.abspath(os.path.dirname(d.getVar('FILE', True)) + '/../..')}"
BBFILES ?= ""
BBLAYERS ?= " \
${BSPDIR}/sources/poky/meta \
${BSPDIR}/sources/poky/meta-poky \
${BSPDIR}/sources/poky/meta-yocto-bsp \
${BSPDIR}/sources/meta-openembedded/meta-oe \
${BSPDIR}/sources/meta-openembedded/meta-python \
${BSPDIR}/sources/meta-openembedded/meta-networking \
${BSPDIR}/sources/meta-openembedded/meta-multimedia \
${BSPDIR}/sources/meta-openembedded/meta-filesystems \
${BSPDIR}/sources/meta-raspberrypi \
${BSPDIR}/sources/berserk/meta-berserk \
"
```
основные переменные файла local.conf — на которые нужно обратить внимание:
* MACHINE — название платформы под которую осуществляется сборка
* DISTRO — название категории дистрибутива
* PACKAGE\_CLASSES — формат пакетов для установки ПО
* LICENSE\_FLAGS\_WHITELIST — использование дополнительных лицензий
специфические настройки для семейства плат Raspberry Pi
* GPU\_MEM = «128» — количество видео памяти для видео адаптера GPU (выделяется из ОЗУ)
* GPU\_MEM\_256 = «112» — то же самое только для плат с общим размером ОЗУ = 256Мб
* GPU\_MEM\_512 = «160» — то же самое только для плат с общим размером ОЗУ = 512Мб
* GPU\_MEM\_1024 = «320» — то же самое только для плат с общим размером ОЗУ = 1024Мб
> примечание:
>
> например если оставить только переменную GPU\_MEM = «128»,
>
> то для всех плат RPI, RPI2, RPI3
>
> не зависимо от количества реальной оперативной памяти
>
> на плате будет всегда выделено для GPU — 128Мб
>
> (и общий размер ОЗУ уменьшиться на это значение)
>
>
в случае указания всех переменных, директивы GPU\_MEM\_256, GPU\_MEM\_512, GPU\_MEM\_1024 являются более приоритетными.
Для сборки Мультимедиа центра, помимо штатных слоев Yocto см. файл bblayers.conf
```
${BSPDIR}/sources/poky/meta \
${BSPDIR}/sources/poky/meta-poky \
${BSPDIR}/sources/poky/meta-yocto-bsp \
```
я подключил четыре слоя с дополнительной функциональностью из OpenEmbedded.
Мультимедиа Центр Kodi — является сложной программой, которая использует большое количество внешних библиотек и каждую библиотеку нужно собрать с помощью рецепта сборки, поэтому по возможности я буду использовать все рецепты из OpenEmbedded в категории **Multimedia**
Итак, у меня подключен слой Multimedia и слои от которых он зависит
```
${BSPDIR}/sources/meta-openembedded/meta-oe \
${BSPDIR}/sources/meta-openembedded/meta-python \
${BSPDIR}/sources/meta-openembedded/meta-networking \
${BSPDIR}/sources/meta-openembedded/meta-multimedia \
```
затем подключен еще один слой OpenEmbedded, для работы с файловыми системами
```
${BSPDIR}/sources/meta-openembedded/meta-filesystems \
```
далее подключен основной BSP слой для платформы Raspberry Pi
```
${BSPDIR}/sources/meta-raspberrypi \
```
ну и в самом конце подключен дополнительный слой, отвечающий за сборку образа дистрибутива с функциональностью «Мультимедиа центра»
```
${BSPDIR}/sources/berserk/meta-berserk \
```
Слой для сборки мультимедиа центра
-----------------------------------
На мой взгляд Yocto Project является промышленным комбайном для создания встраиваемых дистрибутивов. Но если вы когда нибудь работали с системой сборки Buildroot, то Yocto может вам показаться достаточно громоздким. Он использует огромное количество свободного места на жестком диске. Для нормальной работы Yocto требуется порядка 80 — 100 Гб свободного пространства и это обычно с учетом сборки только под одну платформу.
Yocto прекрасно справляется со своим основным назначением — поддержкой как можно большего количества различных аппаратных платформ и для этого требуется максимально гибкий механизм по переключению сборок. И этому механизму требуется место и время. Сборка дистрибутива в Yocto процесс не быстрый.
Итак, вся функциональность, для сборки «Мультимедиа центра» у меня находиться с отдельном слое:
```
https://github/berserktv/berserk
```
(Название взято из моей любимой книги «Молот и крест», писателя Гарри Гаррисона.)
(Torvin также является персонажем данной книги.)
Для внесения нужной мне функциональности я по возможности буду использовать так называемые дополнения для рецептов, которые располагаются в файлах с расширением .bbappend
в файле .bbappend вы можете добавить собственные вызовы команд для штатного метода рецепта сборки, например в метод do\_configure, do\_compile, do\_install и т.д.
### Структура слоя
```
├── COPYING.MIT
├── meta-berserk
│ ├── conf
│ │ └── layer.conf
│ ├── recipes-berserk
│ │ ├── bs-net
│ │ ├── first-run
│ │ ├── images
│ │ └── tv
│ ├── recipes-core
│ │ ├── init-ifupdown
│ │ └── psplash
│ ├── recipes-kernel
│ │ └── linux
│ ├── recipes-mediacentre
│ │ ├── kodi
│ │ └── kodi-plugins
│ └── recipes-multimedia
│ └── ffmpeg
├── README.md
└── changelog.txt
```
Состав слоя:
* **conf** — конфигурация слоя
* **recipes-berserk** — рецепт сборки дистрибутива, рецепты настройки тв, сети и первого запуска
* **recipes-core** — базовые рецепты, в частности модификация рецепта стартовой заставки
* **recipes-kernel** — рецепты сборки Linux ядра
* **recipes-mediacentre** — рецепты сборки Kodi и его плагинов
* **recipes-multimedia** — мультимедиа рецепты, сборка ffmpeg
### конфигурация слоя
**включает файл layer.conf**
```
# We have a conf and classes directory, add to BBPATH
BBPATH .= ":${LAYERDIR}"
# We have a packages directory, add to BBFILES
BBFILES += "${LAYERDIR}/recipes-*/*/*.bb \
${LAYERDIR}/recipes-*/*/*.bbappend"
BBFILE_COLLECTIONS += "bs"
BBFILE_PATTERN_bs := "^${LAYERDIR}/"
BBFILE_PRIORITY_bs = "5"
DISTRO_FEATURES_append += " wifi x11"
PREFERRED_VERSION_ffmpeg = "3.1.11"
SYSVINIT_ENABLED_GETTYS = "1"
PREFERRED_VERSION_linux-raspberrypi ?= "4.9%"
```
Файл содержит указание версии библиотеки ffmpeg, номер версии linux ядра, а также количество виртуальных консолей (tty), и включает особенности дистрибутива — wifi x11
> DISTRO\_FEATURES\_append += " wifi x11"
>
>
>
> PREFERRED\_VERSION\_ffmpeg = «3.1.11»
>
> SYSVINIT\_ENABLED\_GETTYS = «1»
>
>
>
> PREFERRED\_VERSION\_linux-raspberrypi ?= «4.9%»
>
>
### состав recipes-berserk
```
├── bs-net
│ └── bs-net_0.1.3.bb
├── first-run
│ ├── files
│ │ └── first-run.sh
│ └── first-run.bb
├── images
│ └── berserk-image.bb
└── tv
├── files
│ └── berserk.m3u8
├── tv-config.bb
└── tv-dir.inc
```
где:
* bs-net\_0.1.3.bb — рецепт сборки shell расширения для WLAN/Ethernet интерфейсов
* first-run.bb — рецепт первого запуска, дополнительное разбиение дисков
* first-run.sh — shell скрипт первого запуска (запускается на уровне исполнения S)
* berserk-image.bb — рецепт сборки образа дистрибутива
* tv-config.bb — рецепт настройки конфигурации ТВ каналов по протоколу IPTV
* berserk.m3u8 — конфигурация общедоступных телевизионных каналов (формат m3u8)
### состав recipes-core
```
├── init-ifupdown
│ ├── files
│ │ └── interfaces
│ └── init-ifupdown_1.0.bbappend
└── psplash
├── files
│ └── psplash-berserk-img.h
└── psplash_git.bbappend
```
где:
* interfaces — файл с текущей настройкой сети
* init-ifupdown\_1.0.bbappend — расширение для рецепта конфигурации сети
* psplash-berserk-img.h — изображение стартовой заставки
заголовочный файл получен с помощью утилиты gdk-pixbuf-csource
* psplash\_git.bbappend — расширение рецепта сборки стартовой заставки
Конфигурация сети на целевом устройстве находиться в файле:
```
/etc/network/interfaces
```
Добавив расширение рецепта init-ifupdown, я заменяю штатный конфигурационный файл на собственный, и меняю порядок (приоритет) запуска скрипта для уровней исполнения
```
INITSCRIPT_PARAMS = "start 98 2 3 4 5 . stop 10 0 6 1 ."
```
В настоящий момент, почти все современные Linux дистрибутивы включают в свой состав стартовую заставку. Обычно стартовая заставка показывает текущее состояние загрузки т.е. индикатор времени прошедшего с момента запуска системы. В этом плане Yocto не исключение и вы можете поменять изображение штатной стартовой заставки на произвольную картинку.
Для этого необходимо:
1. FILESEXTRAPATHS\_prepend — добавить каталог для ресурсов
2. SRC\_URI — добавить заголовочный файл с произвольной картинкой
3. SPLASH\_IMAGES — изменить управляющую переменную пакета
и далее в рецепте образа «berserk-image.bb» необходимо добавить в качестве особенностей образа — стартовую заставку splash
```
IMAGE_FEATURES += "splash"
# и переменную с указанием конкретного названия пакета стартовой заставки
SPLASH = "psplash-berserk"
```
состав recipes-kernel
----------------------
```
└── linux
├── files
│ ├── db.txt.patch
│ └── rbpi.cfg
└── linux-raspberrypi_4.9.bbappend
```
где:
* db.txt.patch — патч с базой Regulatory Domain (используется для WiFi)
* rbpi.cfg — фрагмент конфигурации Linux ядра
* linux-raspberrypi\_4.9.bbappend — расширение рецепта сборки ядра 4.9 для Raspberry Pi
Wi-Fi устройства работают на определенных частотах и для них существует такое понятие как управляющий домен (regulatory domain) – именно в этом параметре указана страна, в которой, как предполагается, работает данное устройство.
В ядре Linux имеется сопутствующая база данных, в которой для каждой страны прописаны разрешенные частоты и разрешенная для них мощность.
В самом простом случае эту базу можно включить непосредственно в ядро статически, указав параметр:
**CONFIG\_CFG80211\_INTERNAL\_REGDB=y**
что собственно я и сделал, подключив патч c этой базой **db.txt.patch**
И еще: в Yocto существует такое понятие как фрагменты конфигураций ядра. Обычно фрагмент конфигурации, файл с расширением cfg, содержит только те параметры ядра, которые вам явно необходимы для определенных целей. И этот фрагмент конфигурации добавляется к параметрам по умолчанию, которые уже присутствуют в рецепте при сборке ядра.
В дополнении рецепта bbappend, также можно изменить параметры, которые передаются ядру во время запуска:
т.е. переопределить переменную
**CMDLINE** см. файл linux-raspberrypi\_4.9.bbappend
**содержимое rbpi.cfg**
```
# use statically compiled regulatory rules database
CONFIG_CFG80211_INTERNAL_REGDB=y
# поддержка Wifi сетевого Asus USB-N53 chipset Ralink RT3572
CONFIG_RT2800USB=m
# поддержка wifi адаптера на чипсете Atheros D-Link DWA-126 802.11n (AR9271),
# NetGear WNDA3200, NetGear WNA1100, TP-Link TL-WN722N (AR9271),
# TL-WN322G v3, TL-WN422G и т.д. см. cateee.net
CONFIG_ATH9K_HW=m
CONFIG_ATH9K_HTC=m
# настройка Wifi драйверов для работы wpa_supplicant
CONFIG_WIRELESS=y
CONFIG_WEXT_CORE=y
CONFIG_WEXT_PROC=y
CONFIG_CRYPTO_AES=y
# поддержка семейства протоколов IPSec, без этих модулей Wifi авторизация
# при подключении wpa_supplicant не работает
CONFIG_CRYPTO_CCM=m
CONFIG_CRYPTO_CTR=m
CONFIG_CRYPTO_ARC4=m
#########################
# оценка производительности
CONFIG_HAVE_PERF_EVENTS=y
CONFIG_PERF_EVENTS=y
CONFIG_HAVE_LATENCYTOP_SUPPORT=y
CONFIG_LATENCYTOP=y
# This option adds support for ASIX AX88xxx
# based USB 2.0 10/100 Ethernet adapters.
CONFIG_USB_NET_AX8817X=m
```
**содержимое linux-raspberrypi\_4.9.bbappend**
```
# дополнительный параметры конфигурации описываются в rpbi.cfg
FILESEXTRAPATHS_prepend := "${THISDIR}/files:"
SRC_URI += "file://db.txt.patch;patch=1 \
file://rbpi.cfg \
"
# в BSP слое meta-raspberrypi не работают фрагменты конфигураций
# https://github.com/agherzan/meta-raspberrypi/issues/14
# поэтому делаю напрямую
# в методе do_kernel_configme конфигурация ядра
# копируется из базы архитектур arch/ в рабочий каталог
do_kernel_configme_append() {
cat ${WORKDIR}/rbpi.cfg >> ${WORKDIR}/defconfig
}
# CMDLINE for raspberrypi
# default CMDLINE = "dwc_otg.lpm_enable=0 console=serial0,115200
# root=/dev/mmcblk0p2 rootfstype=ext4 rootwait"
CMDLINE = "quiet dwc_otg.lpm_enable=0 console=serial0,115200 \
root=/dev/mmcblk0p2 rootfstype=ext4 rootwait"
```
### состав recipes-mediacentre
```
├── kodi
│ ├── kodi
│ ├── kodi_17.bbappend
│ ├── kodi-dir.inc
│ ├── kodi-runner.bb
│ ├── kodi-settings.bb
│ └── kodi-version.inc
└── kodi-plugins
├── files
├── kodi-language-ru_3.0.10.bb
├── kodi-pvr-iptvsimple.bb
├── plugin-video-youtube_5.5.1.bb
├── screensaver-kodi-universe_0.1.2.bb
├── script-berserk-network_0.2.5.bb
└── script-module-requests_2.12.4.bb
```
где:
1. kodi/
* kodi — каталог содержит подкаталоги **icon,run,settings**
и патчи для исходного кода и конфигурации запуска мультимедиа центра
* kodi\_17.bbappend — дополнение для рецепта сборки мультимедиа центра Kodi
* kodi-dir.inc — общие пути расположения Kodi и его плагинов
* kodi-runner.bb — рецепт запуска Kodi на определенном уровне исполнения
* kodi-settings.bb — рецепт размещения конфигурационных файлов Kodi
* kodi-version.inc — общий файл с информацией о собираемой версии Kodi
2. kodi-plugins/
* files — каталог с tar.gz архивами с исходным кодом плагинов
* kodi-language-ru\_3.0.10.bb — рецепт добавления русской локализации (перевод меню Kodi)
* kodi-pvr-iptvsimple.bb — рецепт сборки Kodi плагина pvr-iptvsimple
* plugin-video-youtube\_5.5.1.bb — рецепт сборки Kodi плагина для просмотра «Youtube»
* screensaver-kodi-universe\_0.1.2.bb — рецепт сборки плагина screensaver-kodi-universe
* script-berserk-network\_0.2.5.bb — рецепт сборки плагина настройки сети
* script-module-requests\_2.12.4.bb — рецепт сборки зависимости для плагина Youtube
### состав recipes-multimedia
```
└── ffmpeg
├── ffmpeg
│ ├── 0001-ffmpeg-Call-get_format-to-fix-an-issue-with-MMAL-ren.patch
│ ├── h264_parser.patch
│ └── pfcd_hevc_optimisations.patch
└── ffmpeg_3.1.11.bb
```
где:
* 0001-ffmpeg-Call-get\_format-to-fix-an-issue-with-MMAL-ren.patch — патч для ffmpeg
* h264\_parser.patch — патч для коррекции парсера h264
* pfcd\_hevc\_optimisations.patch — основной патч с оптимизацией для Raspberry Pi
* ffmpeg\_3.1.11.bb — рецепт сборки библиотеки ffmpeg (аудио, видео кодеки)
**FFmpeg** — OpenSource библиотека для кодирования / декодирования огромного количества видео и аудио форматов. FFmpeg поддерживает почти 400 кодеков (ffmpeg -codecs)
и более 300 форматов (ffmpeg -formats).
### Дополнение рецепта для сборки «Kodi»
В слое OpenEmbedded находиться штатный рецепт для сборки Kodi, но он достаточно общий, а мне хотелось бы получить немного более стабильную и проверенную версию для платформы Raspberry Pi.
У разработчиков программного обеспечения есть такое понятие как патч обратного портирования. Программное обеспечение постоянно обновляется, и каждая новая версия включает как новые функции так и исправление известных ошибок. Патч обратного портирования позволяет часть изменений новой версии программы перенести на более старую, тем самым сделав ее более стабильной. Но это очень тяжелая и кропотливая работа, которая всегда выполняется большим количеством разработчиков.
В мире OpenSource сообщества есть несколько хорошо известных проектов, использующих Kodi, лучшим из которых (на мой взляд) является LibreElec (OpenElec). У LibreElec есть хорошая сборка для платформы Raspberry Pi. Вот у них то и лучше всего взять патч обратного портирования для Kodi. Тем самым, можно избавиться от огромного количества проблем, даже не узнав об этом.
Мультимедиа центр Kodi заточен на проигрывание «Медиа» контекста, и на мой взгляд самым критичным компонентом является связка Kodi и FFmpeg, т.е. взаимодействие определенных версий этих программ, остальные библиотеки можно оставить из слоев Yocto и OpenEmbedded.
Для сборки я взял стабильную версия Kodi 17.6 и версию FFmpeg 3.1.11
**Примечание:**
```
Версия дистрибутива, которую я собираю в рамках данной статьи,
пока не включает систему запуска systemD. На данном этапе
можно обойтись и без него (вопрос достаточно спорный (но пока так)).
Для того, чтобы взять патчи из LibreElec вы можете
загрузить нужную версию примерно так:
#!/bin/bash
HASH_VER="934507d922fb011ce46c76566206f2f1f603360b"
git clone https://github.com/LibreELEC/LibreELEC.tv.git libreelec
cd libreelec
git checkout ${HASH_VER}
патчи для Kodi, располагаются в каталоге:
projects/RPi2/patches/kodi
(см. файл: kodi-001-backport.patch)
патчи для библиотеки FFmpeg, можно посмотреть здесь:
packages/multimedia/ffmpeg/patches
```
Включаемый файл с описанием версии будет такой **kodi-version.inc**
```
FILESEXTRAPATHS_prepend := "${THISDIR}/kodi:"
# ветка Krypton
SRCREV = "a9a7a20071bfd759e72e7053cee92e6f5cfb5e48"
PV = "17.6+gitr${SRCPV}"
```
Ветка Yocto и OpenEmbedded, которую я рассматриваю — **rocko**, содержит версию Kodi 17.3, и для того чтобы перейти к версии 17.6, достаточно добавить небольшое дополнение для рецепта — **kodi\_17.bbappend**
```
require kodi-version.inc
# убираю не работающий патч (был для версии 17.3)
SRC_URI_remove = "file://0013-FTPParse.cpp-use-std-string.patch"
# отключаю патч, так как systemd не использую
SRC_URI_remove = "file://0004-handle-SIGTERM.patch"
# добавляю патч обратного портирования для RPI взятого из libreelec
SRC_URI_append += "file://kodi-krypton-rpb-backports.patch"
# исправление error adding symbols: DSO missing from command line
SRC_URI_append += "file://vchostif.patch"
MENU_ICON = "addons/skin.estuary/media/icons/settings"
# добавление нового пункта в меню настроек (значок шестеренки)
SRC_URI_append += "file://bs-menu.patch file://icon/bs-network.png"
do_configure_prepend() {
install -m 0644 ${WORKDIR}/icon/bs-network.png ${S}/${MENU_ICON}
}
# дополнительные зависимости для kodi plugins
RRECOMMENDS_${PN}_append = "\
python-xml python-misc python-db \
python-crypt python-threading python-math python-email \
python-io python-netserver python-urllib3 python-datetime"
# специфическии опции для плат Raspberry Pi
# реализация OPENGL обязательно должна быть --enable-gles
# для kodi зависимости сборки указаны в docs/README.linux => libxmu libxinerama
# libxtst xdpyinfo
# для сборки этих библиотек в DISTRO_FEATURES необходима зависимость "x11"
# но сам kodi для RPI1 и RPI2,3 собирается с опцией --disable-x11
BS_RPI = " --disable-gl --enable-openmax --enable-player=omxplayer \
--with-platform=raspberry-pi --disable-x11"
BS_RPI3 = " --disable-gl --enable-openmax --enable-player=omxplayer \
--with-platform=raspberry-pi2 --disable-x11"
EXTRA_OECONF_append = "${@bb.utils.contains('MACHINE', 'raspberrypi', \
'${BS_RPI}', '', d)}"
EXTRA_OECONF_append = "${@bb.utils.contains('MACHINE', 'raspberrypi2', \
'${BS_RPI3}', '', d)}"
EXTRA_OECONF_append = "${@bb.utils.contains('MACHINE', 'raspberrypi3', \
'${BS_RPI3}', '', d)}"
# опция для появления всплывающего сообщения в Kodi о подключении
# внешнего носителя, например USB или microSDHC диска (через картридер)
EXTRA_OECONF_append = " --enable-optical-drive"
```
Опция сборки "--enable-optical-drive" позволяет подключить удобный механизм оповещения, который используется в Kodi при подключении оптического диска. В этом случае модуль MediaManager(а) (xbmc/storage/MediaManager.cpp) отслеживает подключение/отключение новых дисковых разделов, и выводит на экран всплывающее сообщение об этом.
пример udev правила подключения/отключения дисков:
```
ACTION=="add" SUBSYSTEM=="block" ENV{ID_FS_TYPE}=="vfat" \
KERNEL=="sd[a-z][0-9]" \
RUN+="/bin/mkdir -p /media/%k", \
RUN+="/bin/mount -o iocharset=utf8,noatime /dev/%k /media/%k"
ACTION=="add" SUBSYSTEM=="block" ENV{ID_FS_TYPE}=="ntfs" \
KERNEL=="sd[a-z][0-9]" \
RUN+="/bin/mkdir -p /media/%k", \
RUN+="/usr/bin/ntfs-3g -o \
iocharset=utf8,noatime,windows_names /dev/%k /media/%k"
ACTION=="add" SUBSYSTEM=="block" ENV{ID_FS_TYPE}=="ext2|ext3|ext4" \
KERNEL=="sd[a-z][0-9]" \
RUN+="/bin/mkdir -p /media/%k", \
RUN+="/bin/mount -o noatime /dev/%k /media/%k"
ACTION=="remove" SUBSYSTEM=="block" KERNEL=="sd[a-z][0-9]" \
RUN+="/bin/umount /media/%k", RUN+="/bin/rmdir /media/%k"
```
```
Примечание:
команда rmdir умеет удалять только пустые каталоги,
а вот не пустые уже нет (пример Linux подхода одна программа - одна функция)
и в данном контексте ее применение безопасно.
```
### Добавление нового пункта в меню настроек Kodi
В Kodi 17.6, за отображение пунктов меню отвечают конфигурационные xml файлы. Для добавления еще одного под пункта в меню «Settings», достаточно подкорректировать файл:
kodi/addons/skin.estuary/xml/Settings.xml
где skin.estuary — тема оформления меню по умолчанию
описание пункта выглядит так:
```
$LOCALIZE[13279]
RunAddon(script.berserk.network,butnetwork)
icons/settings/bs-network.png
```
где:
**label** — название пункта меню
**onclick** — обработка событие нажатия на кнопку меню
(запуск плагина, с передачей первым аргументом строки «butnetwork»)
**icon** — иконка пункта меню (путь к png изображению)
Указанная выше функциональность, а также подключение нескольких дополнительных Kodi плагинов интегрирована с помощью файла bs-menu.patch
**Показать/Скрыть**
```
diff -Naur a/addons/skin.estuary/xml/Settings.xml b/addons/skin.estuary/xml/Settings.xml
--- a/addons/skin.estuary/xml/Settings.xml 2018-02-01 18:17:45.000000000 +0300
+++ b/addons/skin.estuary/xml/Settings.xml 2018-03-08 12:06:50.000000000 +0300
@@ -134,6 +134,11 @@
icons/settings/interface.png
+ $LOCALIZE[13279]
+ RunAddon(script.berserk.network,butnetwork)
+ icons/settings/bs-network.png
+
+
$LOCALIZE[20077]
ActivateWindow(SkinSettings)
icons/settings/skin.png
diff -Naur a/system/addon-manifest.xml b/system/addon-manifest.xml
--- a/system/addon-manifest.xml 2018-03-07 15:58:24.000000000 +0300
+++ b/system/addon-manifest.xml 2018-05-14 14:06:58.000000000 +0300
@@ -27,6 +27,7 @@
resource.uisounds.kodi
screensaver.xbmc.builtin.black
screensaver.xbmc.builtin.dim
+ screensaver.kodi.universe
script.module.pil
service.xbmc.versioncheck
skin.estuary
@@ -43,4 +44,8 @@
xbmc.python
xbmc.webinterface
peripheral.joystick
+ script.berserk.network
+ resource.language.ru\_ru
+ script.module.requests
+ plugin.video.youtube
```
### Максимальные настройки буферизации для видео
В мультимедиа центре Kodi для увеличения производительности можно указать максимальные настройки буферизации:
```
1
139460608
20
```
**buffermode=1**
— буферизировать запросы для всех файловых систем (включая локальную)
**readfactor**
— регулирует скорость загрузки на основе среднего битрейта видео. Так, например, если вы воспроизводите видео со средней скоростью передачи данных 5 Мбит/с и устанавливаете коэффициент чтения буфера на 2.0, это ограничит скорость загрузки (и, следовательно, скорость заполнения кеша) примерно до 10 Мбит/с, таким образом:
readfactor=20
снимает ограничение на скорость загрузки
**memorysize** =139460608
— размер буфера составляет 133 МБайт, при этом используется 133\*3 оперативной памяти т.е. около 400 Мбайт оперативной памяти
Просмотр телевидения по протоколу IPTV
---------------------------------------
Медиацентр Kodi является очень мощным инструментом для просмотра цифрового контента.
Основной функцией, для которой я собирал «Медиацентр» является функция просмотра цифрового телевидения по протоколу IPTV (Internet Protocol Television) т.е. телевидение по протоколу интернета. С помощью данной функции вы можете просматривать цифровое телевидение от вашего интернет провайдера.
Это самый современный и оптимальный вариант как с точки зрения качества изображения, так и с точки зрения дополнительных возможностей т.е. предоставляемых услуг. Например телевизионные каналы могут предоставляться в архиве, в котором нужная видео запись доступна еще какое-то время, после трансляции.
Для поддержки IPTV в Kodi существует несколько вариантов плагинов, из которых я остановился на плагине **pvr.iptvsimple**
Для сборки плагина используется рецепт:
```
└── kodi-plugins
└── kodi-pvr-iptvsimple.bb
```
Плагин подключается/настраивается через:
Основное меню Kodi => «Дополнения» => «Мои дополнения» => «Клиенты PVR» => «PVR IPTV Simple Client»
Для проверки работы IPTV телевидения в составе Kodi, я взял несколько общедоступных новостных информационных каналов и добавил их в список в формате m3u8, а также включил автоматический запуск плагина «pvr.iptvsimple» при старте медиацентра.
Просмотр Youtube с помощью Kodi плагина
----------------------------------------
Программисты, которые разработали «Kodi», предусмотрели возможность гибкого расширения его функций. Это сделано для того что бы любой энтузиаст при желании мог добавить в Kodi то, что ему ну очень нужно. И плагинов этих для Kodi тьма тьмущая. Ну вы поняли. Их настолько много, что это заслуживает описания в отдельной статье.
Плагины устанавливаются очень просто, достаточно подключить Kodi к интернету и нажать пару кнопок в меню. Об этом вы можете почитать на любом из форумов посвященным Kodi. Но сборка, есть сборка, и еще один плагин я включу в дистрибутив в качестве примера.
Самым интересным и распространенным plugin(ом) для Kodi по моему убеждению является плагин просмотра Youtube. Kodi же мультимедиа центр, а Youtube самое огромное хранилище этого самого мультимедиа контента, так что плагин Youtube для Kodi почти обязателен.
Плагин написан на языке python, и это штатный механизм плагинов, вам не нужно ничего компилировать, достаточно просто скопировать готовый плагин в корневой каталог с плагинами, и указать имя плагина в xml файле манифеста:
«system/addon-manifest.xml»
Плагин взят из официального репозитория, и его исходный код включен в архив:
recipes-mediacentre/kodi-plugins/files/plugin.video.youtube.tar.gz
Расположение рецепта сборки плагина см. выше в главе «состав recipes-mediacentre»
Консольное shell расширение конфигурации сети
----------------------------------------------
Так как дистрибутив собираемый в рамках данной статьи является демонстрационным, то и требования к настройки «Сетевых интерфейсов» к нему минимальны. Мне не хотелось тащить для этого, какой либо тяжелый сетевой менеджер, сильно мне не понятный и сильно громоздкий, и поэтому я написал два shell скрипта, дополняющих настройку штатного механизма конфигурации:
```
##############################################################
# пример возможного использования в /etc/network/interfaces:
##############################################################
auto eth0
iface eth0 inet manual
up /etc/network/eth-manual $IFACE up
down /etc/network/eth-manual $IFACE down
auto wlan0
iface wlan0 inet manual
up /etc/network/wlan $IFACE up
down /etc/network/wlan $IFACE down
```
Для удобной настройки Ethernet/WLAN сетевых интерфейсов через GUI, у меня используется еще один небольшой Kodi плагин «script.berserk.network». Это почти единственный Kodi plugin, в котором я разобрался, но для этого мне пришлось его написать. Он предельно компактный и минималистичный и написан на языке «python».
Оба этих компонента, собираются с помощью рецептов:
* recipes-berserk/bs-net/bs-net\_0.1.3.bb
* recipes-mediacentre/kodi-plugins/script-berserk-network\_0.2.5.bb
На этом моменте я хотел бы остановиться по подробней. Итак вся гибкость использования Yocto, заключается в разных наборах рецептов т.е. подключили один набор рецептов — в дистрибутив добавился простейший сетевой менеджер, подключили другой набор — добавили ваш любимый сетевой менеджер использующий например systemD и т.д.
Для автоматического подключения к WiFi точке доступа при старте системы, у меня используется udev правило: /etc/udev/rules.d/80-wifi-start.rules
```
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", KERNEL=="wlan*", \
RUN+="/etc/network/wlan-runner $env{INTERFACE} up"
SUBSYSTEM=="net", ACTION=="remove", DRIVERS=="?*", KERNEL=="wlan*", \
RUN+="/etc/network/wlan-runner $env{INTERFACE} down"
```
Скрипт wlan-runner просто выполняет команды:
/etc/network/wlan $IFACE up
или
/etc/network/wlan $IFACE down
Рецепт сборки дистрибутива
---------------------------
В Yocto Project предусмотрен механизм повторного использования. Есть классы, от которых вы можете наследоваться (директива «inherit»), и есть базовые рецепты, которые вы можете подключить (директива «include»).
Покажу наследование на примере класса:
**poky/meta/clasess/core-image.bbclass**
Класс отвечает за описание групп пакетов, которые вы можете включить в тот или иной рецепт. Для этого достаточно указать в начале рецепта конструкцию:
**inherit core-image**
Еще в тексте этого класса вы можете посмотреть особенности образа, каждая особенность отвечает за группу функций включаемых в образ, а каждая группа в конечном итоге описывает набор устанавливаемых программ или библиотек.
Особенности образа указываются так:
```
IMAGE_FEATURES += "ssh-server-dropbear splash"
```
Еще есть DISTRO\_FEATURES — особенности дистрибутива, которые можно указать в конфигурационном файле слоя. Это функции уровня дистрибутива, и если вы например поменяете какую то особенность (например x11), то последующая сборка начнет пересобирать все пакеты, которые зависят от этой опции (это может занимать достаточно длительное время).
Основной базовый рецепт, который я использую:
poky/meta/recipes-core/images/core-image-minimal.bb
**рецепт сборки образа**
```
# Project: "Berserk" - build Kodi for the Raspberry Pi platform
# license - The MIT License (MIT)
DESCRIPTION = "Berserk - the image for the Raspberry PI"
LICENSE = "MIT"
MD5_SUM = "md5=0835ade698e0bcf8506ecda2f7b4f302"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;${MD5_SUM}"
IMAGE_FEATURES += "ssh-server-dropbear splash"
# немного увеличиваю размер rootfs в кило байтах (250000kB=~250Mb)
IMAGE_ROOTFS_EXTRA_SPACE_append += "+ 250000"
# Base this image on core-image-minimal
include recipes-core/images/core-image-minimal.bb
# Set default password for 'root' user
inherit extrausers
ROOTUSERNAME = "root"
ROOTPASSWORD = "berserk"
EXTRA_USERS_PARAMS = "usermod -P ${ROOTPASSWORD} ${ROOTUSERNAME};"
# стартовая заставка, которая выводиться во время загрузки
SPLASH = "psplash-berserk"
BS_DEBUG_TOOLS = "ldd strace ltrace"
BS_GLIBC = "glibc-thread-db \
glibc-gconv-utf-16 \
glibc-gconv-utf-32 \
glibc-binary-localedata-en-us \
glibc-binary-localedata-ru-ru \
glibc-charmap-utf-8 \
"
BS_BASE = "kernel-modules \
lsb \
pciutils \
parted \
tzdata \
dosfstools \
ntp \
ntpdate \
e2fsprogs-resize2fs \
ntfs-3g \
ntfsprogs \
"
BS_WLAN = "kernel-module-rt2800usb \
kernel-module-rt2800lib \
kernel-module-rt2x00lib \
kernel-module-rt2x00usb \
kernel-module-cfg80211 \
kernel-module-nls-utf8 \
kernel-module-ath9k-common \
kernel-module-ath9k-hw \
kernel-module-ath9k-htc \
kernel-module-ctr \
kernel-module-ccm \
kernel-module-arc4 \
"
BS_WIFI_SUPPORT = " \
iw \
dhcp-client \
wireless-tools \
wpa-supplicant \
linux-firmware \
"
BS_SOFT = "mc \
kodi \
kodi-runner \
kodi-settings \
kodi-language-ru \
kodi-pvr-iptvsimple \
bs-net \
tv-config \
first-run \
script-berserk-network \
screensaver-kodi-universe \
plugin-video-youtube \
script-module-requests \
"
# Include modules in rootfs
IMAGE_INSTALL += " \
${BS_BASE} \
${BS_WLAN} \
${BS_WIFI_SUPPORT} \
${BS_GLIBC} \
${BS_SOFT} \
${BS_DEBUG_TOOLS} \
"
```
Хотел бы уточнить, что например пакет **«kernel-modules»**, установит
все модули ядра указанные в файле defconfig в образ дистрибутива.
Но если вы что то сильно кастомизируете, то конечно все модули ядра вам могут и не понадобиться, в таком случае удобно добавлять каждый модуль по имени, как указано в переменной **BS\_WLAN**, это как шпаргалка, указываем только то, что нужно и после проверки работы пакет «kernel-modules» убираем, проверяем и т.д.
Краткая инструкция по созданию образа дистрибутива
--------------------------------------------------
**1) Установите зависимости Yocto Project в Ubuntu:**
```
sudo apt-get install -y --no-install-suggests --no-install-recommends \
gawk wget git-core diffstat unzip texinfo gcc-multilib build-essential \
chrpath socat cpio python python3 python3-pip python3-pexpect \
xz-utils debianutils iputils-ping python3-git python3-jinja2 \
libegl1-mesa libsdl1.2-dev xterm
```
**2) Скачайте и установите Repo:**
```
mkdir ~/bin
curl http://commondatastorage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
chmod a+x ~/bin/repo
```
**3) Загрузите проект с github:**
```
PATH=${PATH}:~/bin
mkdir torvin
cd torvin
repo init -u https://github.com/berserktv/bs-manifest \
-m raspberry/rocko/torvin-0.2.5.xml
repo sync
```
**4) Соберите проект:**
```
./shell.sh
bitbake berserk-image
```
**5) Запишите образ дистрибутива на карту памяти:**
> Собранный образ после сборки будет располагаться по пути
>
> torvin/build/tmp/deploy/images/raspberrypi3
>
>
>
> На последний успешно собранный образ
>
> всегда будет указывать символическая ссылка:
>
> berserk-image-raspberrypi3.rpi-sdimg
>
>
>
> cам файл будет содержать достаточно длинное имя
>
> c датой создания и временем в UTC
>
>
>
> Пример записи образа дистрибутива с помощью команды dd
>
>
>
> ПРЕДУПРЕЖДЕНИЕ:
>
> все предыдущие данные на карте памяти «microSDHC»
>
> после выполнения операции записи будут удалены.
>
>
>
> $ sudo bash
>
> $ cd torvin/build/tmp/deploy/images/raspberrypi3
>
> $ dd if=berserk-image-raspberrypi3.rpi-sdimg of=/dev/sdX bs=1M
>
> $ sync
>
>
>
> где /dev/sdX:
>
> X может быть a,b,c и т.д.
>
> в зависимости от предыдущих подключенных дисковых разделов
>
>
>
> уже собранный образ можно загрузить с моего домашнего [сайта:](https://berserk.tv/download.html)
>
> Для записи образа под Windows, вы можете воспользоваться
>
> программой Win32 Disk Imager находиться [здесь:](https://sourceforge.net/projects/win32diskimager)
>
> более подробную инструкцию можно посмотреть [здесь:](https://berserk.tv/berserk.html#save_gz_dd_card_memory)
>
>
**Примечание:**
```
Время сборки образа дистрибутива достаточно длительное
и может занимать от трех до N часов в зависимости от производительности
компьютера, также в процессе сборки из "Интернета" должны быть
загружены исходные коды всех программ входящих в дистрибутив,
часто это полные git базы
(т.е. время сборки также зависит от скорости подключения сети "Интернет")
например на машине: Процессор - Intel(R) Core(TM) i5-3570 CPU @ 3.40GHz
ОЗУ - 8 Гбайт
Жесткий диск - внешний USB-3.0 1Tбайт
Время сборки - 4 часа 05 минут
Размер образа - 1 Гбайт
размер в архиве - 274.8 Mбайт
Размер каталога torvin/build после завершения сборки
(cache сборки, исходный код программ, промежуточные файлы сборки, объектные файлы,
дополнительные мета данные, файлы пакетов и т.п.)
- Занимает примерно 42 ГБайт
Размер каталога torvin/downloads - Занимают 9.1 Гбайт
(git базы приложений и tar.gz архивы)
Размер rootfs раздела образа - 550 Мбайт
из них каталог /lib/firmware - 212 Мбайт
/lib/modules - 53 Мбайт
примечание: вы можете ставить не все модули и firmware (а только нужные вам)
тем самым можно значительно уменьшить размер дистрибутива,
минимум на 200 Мб
```
Постскриптум
-------------
Возможности OpenSource за последние годы только увеличиваются.
А возможности эти не малые, за примерами даже не надо далеко ходить. Вряд ли та же «Microsoft» ожидала, что OpenSource технологии выбросят ее с рынка мобильных операционных систем. Я имею ввиду ОС от Google — «Android», которая в одночасье выбросила «Пионера» мобильных систем на обочину. И не понятно, сможет ли Microsoft, снова на него вернуться.
Конечно «Google», огромная корпорация с почти не ограниченными финансами и великолепными разработчиками, но все-же, как говориться «без Ядра и не туда и не сюда».
Лучшие OpenSource проекты со временем становятся произведением искусства (например Kodi, Openelec/libre и т.д.)
И сегодня любой желающий может приобщиться к лучшим практикам в OpenSource, так сказать не вылезая из Github(a). Эта статья об этом.
Побольше вам сборок хороших и разных, и помните «мир интернета вещей наступает». | https://habr.com/ru/post/467443/ | null | ru | null |
# Подключаем онлайн-карты к навигатору на смартфоне. Часть 3 — OverpassTurbo
Превращаем созданный ранее скрипт в API для просмотра интерактивной карты с сайта OverpassTurbo.eu через навигационное приложение смартфона.
Содержание:
1 – [Вступление. Стандартные растровые карты](https://habr.com/ru/post/461031/)
2 – [Продолжение. Пишем простой растеризатор для векторных карт](https://habr.com/ru/post/461053/)
3 – Частный случай. Подключаем карту OverpassTurbo
### Что такое OverpassTurbo?
Итак. Существует такая база картографических данных, как OpenStreetMaps. В ней собрано все: моря, контуры материков, горы, леса, дороги, здания, детские площадки и даже лежачие полицейские. У каждого объекта есть название, координаты и свойства. Например, у дороги – материал покрытия, у здания – количество этажей и так далее.
Так вот. Большинство карт, которые сегодня представлены в интернете генерируются на основе именно этой базы данных. Но что, если нам не подходят все эти готовые карты? Можно сделать собственную! Ну, или хотя бы дополнить уже существующую, что в разы проще.
Именно этим и занимается сайт [OverpassTurbo.eu](https://overpass-turbo.eu/). Он представляет из себя онлайн IDE. С его помощью можно составить запрос к базе данных OSM. Нажимаем на кнопку **Старт**, запрос уходит к базе, а к нам через некоторое время возвращаются данные. OverpassTurbo визуализирует эти данные в виде векторных маркеров и линий, располагающихся поверх фонового слоя — карты с сайта [OpenSteerMap.org](https://www.openstreetmap.org).
В качестве примера того, что вы можете сделать с помощью OverpassTurbo я хочу показать вам наиболее понравившийся мне скрипт. Его написал пользователь под ником Erelen. Так вот: этот скрипт отрисовывает на карте различные источники питьевой воды и их название. По моему, очень полезно и весьма наглядно. Чтобы посмотреть, как этот скрипт работает, просто перейдите по ссылке и нажмите **Старт**. (Если же сайт выдаст ошибку, то зайдите через VPN и попробуйте еще раз)
<https://overpass-turbo.eu/s/z95>
Или вот скрипт, который уже делал я под собственные нужды. С его помощью можно легко находить хорошие маршруты для пробежек в незнакомых парках. Для этого скрипт выделяет ярко-оранжевым ухоженные гравийные дорожки: по таким, на мой вкус, бегать удобнее всего. Асфальт помечается белым. Обычные грунтовые тропинки — черным. А вот все тропы, с тегом "труднопрохидимые" или "плохое качество покрытия" будут помечены неприметной пунктирной линией: чтобы реже запинаться я стараюсь их избегать. В общем, карта сделана так, чтобы можно было просто проложить маршрут по наиболее бросающимся в глаза линиям. И чтобы в итоге этот маршрут оказался удачным.
<http://overpass-turbo.eu/s/KXU>
Фактически, с помощью этого инструмента можно дополнить карту какими угодно данными. И, замечу, что это весьма и весьма увлекательно. Но эта статья не об этом. Если вас заинтересовала данная тема, то можете ознакомиться c основами Overpass [здесь](https://wiki.openstreetmap.org/wiki/RU:Overpass_API/Language_Guide).
Но прежде, чем перейти к коду, давайте для начала взглянем на конечный результат, который должен у нас получиться.
### Инструкция для пользователей: как пользоваться нашим API
Итак. Допустим у вас уже есть готовый скрипт для OverpassTurbo, результаты работы которого вы хотите видеть в своем смартфоне. И притом не в браузере, а именно в навигаторе. Для этого приведите свой скрипт к следующему формату.
```
[bbox:{{bbox}}];
(
// Поместите сюда ваш запрос
node[amenity=waste_basket];
);
out;>;out skel qt;
```
В особенности, нас интересует первая строчка: наше приложение будет ее заменять.
После этого нажмите на кнопку **Поделиться**. Обязательно снимите галочку **Включить состояние отображаемой карты**.
После этого скопируйте ссылку. Для примера, будем считать, что ваша скопированная ссылка выглядит так:
`http://overpass-turbo.eu/s/KEy`
Теперь посмотрим на наше API
`https://anygis.herokuapp.com/mapshoter/overpass/{x}/{y}/{z}/{crossZoom}?script={script}`
С **{x} ,{y}** и **{z}** все, вроде бы, понятно: это координаты искомого тайла.
На место **{script}** нужно подставлять **ID** вашего скрипта. В нашем примере — **s/Key**.
Но что такое **{crossZoom}**? Допустим у вас это 15. Тогда если вы будете запросите тайл для зума меньше 15, то сервер не будет делать медленный запрос к OverpassTurbo, а просто перенаправит вас на карту пустой фоновый слой OpenStreetMaps (который загрузится практически моментально). Такой подход нужен для того, чтобы в случае необходимости можно было отдалить карту, быстро проскролить ее до интересующего места, приблизить и ждать. Ждать пока OverpassTurbo сгенерирует карту с результатами выдачи.
Надеюсь, основной принцип понятен. А теперь посмотрите на заполненный URL для нашего запроса. Думаю теперь пользоваться нашим API для вас не составит труда: просто заменяйте **s/KEy** на **ID** вашего скрипта.
`https://anygis.herokuapp.com/mapshoter/overpass/{x}/{y}/{z}/15?script=s/KEy`
А мы, же тем временем, посмотрим, как можно реализовать такое приложение.
### Сценарий 3 – Поиск с помощью URL и кэша браузера
Итак. Начнем с файла **router.js**. Сделаем, чтобы наш метод принимал параметры **crossZoom** и **script**. А затем передадим их воркеру. Так же добавим опцию, которая будет прерывать скрипт и перенаправлять пользователя на другой сайт, если запрашиваемый зум слишком низкий.
```
const express = require( 'express' )
const PORT = process.env.PORT || 5000
const app = express()
app.listen( PORT, () => {
console.log( 'Сервер создан на порту ', PORT )
})
const { StaticPool } = require( 'node-worker-threads-pool' )
const worker = "./worker.js"
const workersPool = new StaticPool({
size: 3,
task: worker,
workerData: "no"
})
// Добавляем новые входные параметры
app.get( '/:x/:y/:z/:crossZoom', async ( req, res, next ) => {
const x = req.params.x
const y = req.params.y
const z = req.params.z
const crossZoom = req.params.crossZoom
const scriptName = req.query.script
// Досрочный выход из скрипта
if ( Number( z ) < Number( crossZoom ) ) {
res.redirect( `http://tile.openstreetmap.org/${z}/${x}/${y}.png` )
}
// Запускаем задачу с новым параметром
const screenshot = await workersPool.exec( { x, y, z, scriptName } )
const imageBuffer = Buffer.from( screenshot, 'base64' )
res.writeHead( 200, {
'Content-Type': 'image/png',
'Content-Length': imageBuffer.length
})
res.end( imageBuffer )
})
```
Файл **worker.js** практически не изменился. Просто пробрасываем новые переменные дальше.
```
const { parentPort, workerData } = require( 'worker_threads' );
const puppeteer = require( 'puppeteer' )
const mapshoter = require( './mapshoter' )
var browser = "empty"
parentPort.on( "message", ( params ) => {
doMyAsyncCode( params )
.then( ( result ) => { parentPort.postMessage( result ) })
})
async function doMyAsyncCode( params ) {
await prepareEnviroment()
// Добавляем параметр
const screenshot = await mapshoter.makeTile( params.x, params.y, params.z, params.scriptName, browser )
return screenshot
}
async function prepareEnviroment( ) {
if ( browser === "empty" ) {
const herokuDeploymentParams = {'args' : ['--no-sandbox', '--disable-setuid-sandbox']}
browser = await puppeteer.launch( herokuDeploymentParams )
}
}
```
Теперь займемся **mapshoter.js**. Для начала посмотрим на код:
```
const puppeteer = require( 'puppeteer' )
const geoTools = require( './geoTools' )
async function makeTile( x, y, z, scriptName, browserLink ) {
// Селекторы для выбора элементов интерфейса
const runButtonSelector = '#navs > div > div.buttons > div:nth-child(1) > a:nth-child(1)'
const codeEditorSelector = '#editor > div.CodeMirror.CodeMirror-wrap > div:nth-child(1) > textarea'
// Рассчитать координаты краев и центра области для загрузки тайла
const coordinates = geoTools.getAllCoordinates( x, y, z )
const bBox = `[bbox:${coordinates.bBox.latMin}, ${coordinates.bBox.lonMin}, ${coordinates.bBox.latMax}, ${coordinates.bBox.lonMax}];`
const centerCoordinates = `${coordinates.center.lat};${coordinates.center.lon};${z}`
// Запустить и настроить страницу браузера
const browser = await browserLink
const page = await browser.newPage()
await page.setViewport( { width: 850, height: 450 } )
// Подождем немного, чтобы не забанили:
// запросы должны приходить немного вразнобой
await page.waitFor( randomInt( 0, 500 ) )
// Призумить к нужному месту с помощью параметров URL
var pageUrl = `http://overpass-turbo.eu/?C=${centerCoordinates}`
await page.goto( pageUrl, { waitUntil: 'networkidle2', timeout: 10000 } )
// Загрузить текст скрипта с помощью параметров URL
pageUrl = 'http://overpass-turbo.eu/' + scriptName
await page.goto( pageUrl, { waitUntil: 'networkidle0', timeout: 20000 } )
// Кликнуть на окно редактора кода
await page.focus( codeEditorSelector )
// Вписать вместо первой строчки новую область для поиска,
// совпадающую с границами тайла
await page.keyboard.type( bBox + ' //' )
// Дождаться, когда онлайн-IDE распознает синтаксис
await page.waitFor( 100 )
// Нажать на кнопку загрузки гео-данных
await page.click( runButtonSelector )
// Дождаться, когда скроется окно с индикатором загрузки.
// И еще немного для надежности.
await page.waitForFunction(() => !document.querySelector('body > div.modal > div > ul > li:nth-child(1)'), {polling: 'mutation'});
await page.waitFor( 1000 )
// Сделать кадрированный скриншот
const cropOptions = {
fullPage: false,
clip: { x: 489, y: 123, width: 256, height: 256 }
}
const screenshot = await page.screenshot( cropOptions )
// Завершение работы
await page.close()
return screenshot
}
// Вспомогательная функция для поиска рандомного числа
function randomInt( low, high ) {
return Math.floor( Math.random() * ( high - low ) + low )
}
module.exports.makeTile = makeTile
```
Начнем с того, что в данном скрипте мы ради разнообразия будем работать с обычными селекторами элементов (которые не **XPath**). Как их найти было описано в [предыдущей статье](https://habr.com/ru/post/461053/).
Далее мы получаем координаты. Только на этот раз помимо координат центра нужны еще и координаты границ тайла (**bBox**).
Далее запускаем браузер. Тут все типично. Но прежде чем перейти к загрузке страницы заставим скрипт подождать рандомный промежуток времени от 0 до 500 мс. Чтобы на сайт от нас не приходило одновременно слишком много одинаковых запросов и нас не забанили.
После этого переходим на сайт по URL, к которому добавили координаты центра тайла. В результате искомое место оказывается в центре карты.
После этого переходим по еще одному URL. На этот раз с **ID** нашего скрипта. В результате в тексте редактора кода появится наш скрипт.
(Обратите внимание, что если бы в меню **Поделиться** при копировании URL для нашего скрипта мы бы не сняли галочку **Сохранять состояние карты**, то карта бы сместилась. А нам этого совсем не нужно)
А теперь отвечу резонный на вопрос: зачем мы целых два раза переходим по URL, то есть дважды тратим время на загрузку этого сайта? Отвечаю. Потому, что, во первых, мне не удалось найти, как совместить в одном URL запросе и загрузку скрипта и переход к указанным координатам. Во вторых, потому, что по каким-то причинам Puppeteer крайне медленно печатает текст и работает с элементами интерфейса на этом сайте. Полторы минуты может печатать! Так что от идеи вставить координаты в поле поиска, а потом покликать по кнопкам зума, как мы делали в прошлой статье, было решено отказаться. В итоге, дважды перейти по ссылке получилось намного быстрее, чем проделывать все это. Возможно, это баг и его рано или поздно исправят, но пока работаем с тем, что есть.
Увы, но совсем от ввода текста уйти не удастся. Нам придется заменить первую строчку в окне редактора кода. В данный момент она сообщает, что нужно загрузить информацию из базы для всей территории, которая в данный момент попала на экран.
```
[bbox:{{bbox}}];
```
Мы же заменим ее на координаты границ тайла. Это чтобы не тратить время на загрузку из базы лишнего. Так что скрипт впечатает в первую строчку примерно такой текст:
```
[bbox:55.6279, 37.5622, 55.6341, 37.5732]; //
```
А чтобы не пришлось стирать изначальную строчку (много раз медленно нажимая для этого **Delete**) мы просто ее закомментируем. Таким образом мы максимально сократим и время, затрачиваемое на ввод текста, и время загрузки из базы данных. В результате, первая строчка будет выглядеть следующим образом:
```
[bbox:55.6279, 37.5622, 55.6341, 37.5732]; //[bbox:{{bbox}}];
```
После этого нашему скрипту остается кликнуть на кнопку **Старт**, немного подождать, сделать скриншот карты и отправить его пользователю. И все: задача выполнена!
Если хотите посмотреть на пример работы получившегося скрипта, то можете перейти по [этой ссылке](https://nakarte.me/#m=16/55.62400/37.57031&l=-cseyJuYW1lIjoiTWFwc2hvdGVyIEdyYXZlbFJ1blRyYWlscyIsInVybCI6Imh0dHBzOi8vYW55Z2lzLmhlcm9rdWFwcC5jb20vbWFwc2hvdGVyL292ZXJwYXNzL3t4fS97eX0ve3p9LzE0P3NjcmlwdD1zL0tUcCIsInRtcyI6ZmFsc2UsInNjYWxlRGVwZW5kZW50IjpmYWxzZSwibWF4Wm9vbSI6MTgsImlzT3ZlcmxheSI6ZmFsc2UsImlzVG9wIjp0cnVlfQ==).
### Заключение
Чтож, как не трудно предположить, эта версия скрипта будет работать еще медленней предыдущих. Ведь теперь сайт тратит время на запрос из сторонней базы данных. Да и сам по себе он работает не слишком быстро. Однако этот метод позволяет крайне легко (пусть и медленно) получить уникальную, настроенную под себя карту. И, притом, на основе самых свежих данных. А это, порой, может оказаться весьма полезно. Так что стоит иметь такой способ в виду.
А на этом все. На всякий случай напоминаю, что на моем сайте [AnyGIS](https://nnngrach.github.io/AnyGIS_maps/Web/Html/DownloadPage_ru) собран архив уже готовых пресетов для навигаторов Locus, OsmAnd и GuruMaps. Там есть как растровые карты, так и "растеризированные" векторные карты, для просмотра которых используется описанное в этих статьях приложение. Заходите и пользуйтесь. | https://habr.com/ru/post/461073/ | null | ru | null |
# Angular: оптимизация обработки событий
Прошла буквально пара недель, как я впервые начал писать на [Angular](https://angular.io/), и сразу же столкнулся с рядом специфических проблем. Из-за малого опыта работы с этим фреймворком, я не уверен, что примененные способы оптимизации — это не стандартная практика. Некоторые признаки указывают, что разработчики предполагают подобные подходы, но делать выводы пришлось по профайлеру, а информацию искать по частям. При этом надо сказать, что решение нашлось очень быстро, когда причины проблем прояснились.
В статье я разберу как оптимизировать обработку часто вызываемых событий: mousemove, scroll, dragover и прочих. Конкретно я столкнулся с проблемами при реализации drag-and-drop интерфейса, поэтому и разбирать буду на примере с перетаскиванием элементов.
Хочу изложить свой ход мыслей на примере нескольких попыток оптимизации, и немного опишу базовые принципы работы Angular — [Демонстрационное приложение с попытками оптимизации](https://ovcharik.github.io/ngx-optimization-demo).
Решаемая задача
---------------
В приложении необходимо было сделать интерфейс, управляемый перетаскиванием элементов между ячейками таблицы.
Количество ячеек и количество элементов, которые можно перетаскивать, достигают нескольких тысяч.
Первый вариант решения
----------------------
Первым делом я направился искать готовые решения, реализующие drag-and-drop, выбор пал на [ng2-dnd](https://github.com/akserg/ng2-dnd), так у данной библиотеки понятное и простое API, и присутствует некоторая популярность в виде звездочек на гитхабе.
Получилось быстро накидать решение, которое работало почти правильно, но даже при относительно небольшом количестве элементов появились проблемы:
* вычисления потребляли все доступные мощности;
* результат отображался с большой задержкой.
[Здесь](https://ovcharik.github.io/ngx-optimization-demo/#/v1) можно посмотреть результат данного подхода.
*Примечание: ниже приведен код компонента, с примером решения задачи с минимальной затратой времени на реализацию. По ходу статьи будет приведено еще несколько примеров кода. Все компоненты имеют общую часть, которая формирует таблицу. Данный код вынесен из компонентов, так как к оптимизации обработки событий он не имеет никакого отношения. Подробнее со всем кодом проекта можно ознакомиться в [репозитории](https://github.com/ovcharik/ngx-optimization-demo).*
**Код**[репозиторий](https://github.com/ovcharik/ngx-optimization-demo/blob/master/src/app/version-1.component.ts), [пример](https://ovcharik.github.io/ngx-optimization-demo/#/v1)
```
@Component({
selector: 'app-version-1',
template: `
{{title}}
=========
| |
| --- |
|
{{item}}
{{cell.entered}}
|
`,
})
export class Version1Component extends VersionBase {
public static readonly title = 'Наивная реализация';
// Курсор с данными был наведен на ячейку
public dragEnter({ dragData }, cell: Cell) {
cell.entered = dragData.item;
}
// Курсор с данными покинул ячейку
public dragLeave({ dragData }, cell: Cell) {
delete cell.entered;
}
// В ячейку положили данные
public drop({ dragData }, cell: Cell) {
const index = dragData.cell.indexOf(dragData.item);
dragData.cell.splice(index, 1);
cell.push(dragData.item);
delete cell.entered;
}
}
```
### Доработки
Доводить до ума подобную реализацию смысла никакого не было, так как работать в таком режиме практически невозможно.
Возникло первое предположение, что уменьшение элементов, которые обрабатываются библиотекой, может существенно улучшить ситуацию. От большого количества draggable элементов избавиться невозможно в рамках задачи, а вот droppable ячейки можно убрать и отслеживать события, которые получает таблица, по событиям можно установить элемент ячейки и ее данные.
Данный подход предполагает взаимодействие с HTML элементами и нативными событиями, что не хорошо в контексте фреймворка, но я посчитал это приемлемым в целях оптимизации.
**Код**[репозиторий](https://github.com/ovcharik/ngx-optimization-demo/blob/master/src/app/version-2.component.ts), [пример](https://ovcharik.github.io/ngx-optimization-demo/#/v2)
```
@Component({
selector: 'app-version-2',
template: `
{{title}}
=========
| |
| --- |
|
{{item}}
{{cell.entered}}
|
`,
})
export class Version2Component extends VersionBase {
public static readonly title = 'Один droppable элемент';
// Ячейка над которой находится курсор с данными
private enteredCell: Cell;
// Поиск элемента на котором сработало событие
private getTargetElement(target: EventTarget): Element {
return (target instanceof Element) ? target
: (target instanceof Text) ? target.parentElement
: null;
}
// Поиск данных ячейки по элементу
private getCell(element: Element): Cell {
if (!element) { return null; }
const td = element.closest('td');
const tr = element.closest('tr');
const body = element.closest('tbody');
const row = body ? Array.from(body.children).indexOf(tr) : -1;
const col = tr ? Array.from(tr.children).indexOf(td) : -1;
return (row >= 0 && col >= 0) ? this.table[row][col] : null;
}
// Сброс состояния активной ячейки
private clearEnteredCell() {
if (this.enteredCell) {
delete this.enteredCell.entered;
delete this.enteredCell;
}
}
// Курсор с данными был наведен на элемент таблицы
public dragEnter({ dragData, mouseEvent }: { dragData: any, mouseEvent: DragEvent }) {
this.clearEnteredCell();
const element = this.getTargetElement(mouseEvent.target);
const cell = this.getCell(element);
if (cell) {
cell.entered = dragData.item;
this.enteredCell = cell;
}
}
// Курсор с данными покинул элемент таблицы
public dragLeave({ dragData, mouseEvent }: { dragData: any, mouseEvent: DragEvent }) {
const element = this.getTargetElement(mouseEvent.target)
if (!element || !element.closest('td')) {
this.clearEnteredCell();
}
}
// На элемент таблицы положили данные
public drop({ dragData, mouseEvent }: { dragData: any, mouseEvent: DragEvent }) {
if (this.enteredCell) {
const index = dragData.cell.indexOf(dragData.item);
dragData.cell.splice(index, 1);
this.enteredCell.push(dragData.item);
}
this.clearEnteredCell();
}
// Перетаскивание завершено
public dragEnd() {
this.clearEnteredCell();
}
}
```
**Профайлер**
По субъективным ощущениям и по профайлеру можно судить, что стало лучше, но в целом ситуация не поменялась. В профайлере видно, что фреймворк запускает большое количество обработчиков событий, для поиска изменений в данных, и на тот момент мне не совсем была понятна природа этих вызовов.
Предположил, что библиотека заставляет Angular подписаться на все эти события и обрабатывать их таким образом.
Второе решение
--------------
По профайлеру было видно, что корень проблемы не в моих обработчиках, а вызов enableProdMode(), хоть и сильно сокращает время поиска и применения изменений, но профайлер показывает, что на выполнение скриптов расходуется основное количество ресурсов. После некоторого количества попыток микрооптимизаций, я все же решил отказаться от библиотеки ng2-dnd, и реализовать все самостоятельно в целях улучшения контроля.
**Код**[репозиторий](https://github.com/ovcharik/ngx-optimization-demo/blob/master/src/app/version-3.component.ts), [пример](https://ovcharik.github.io/ngx-optimization-demo/#/v3)
```
@Component({
selector: 'app-version-3',
template: `
{{title}}
=========
| |
| --- |
|
{{item}}
{{cell.entered}}
|
`,
})
export class Version3Component extends VersionBase {
public static readonly title = 'Нативные события';
// Ячейка над которой находится курсор с данными
private enteredCell: Cell;
// Перетаскиваемые данные
private dragData: { cell: Cell, item: string };
// Поиск элемента, над которым сработало событие
private getTargetElement(target: EventTarget): Element {
return (target instanceof Element) ? target
: (target instanceof Text) ? target.parentElement
: null;
}
// Поиск данных ячейки по элементу
private getCell(element: Element): Cell {
if (!element) { return null; }
const td = element.closest('td');
const tr = element.closest('tr');
const body = element.closest('tbody');
const row = body ? Array.from(body.children).indexOf(tr) : -1;
const col = tr ? Array.from(tr.children).indexOf(td) : -1;
return (row >= 0 && col >= 0) ? this.table[row][col] : null;
}
// Сброс состояния активной ячейки
private clearEnteredCell() {
if (this.enteredCell) {
delete this.enteredCell.entered;
delete this.enteredCell;
}
}
// Начало перетаскивания
public dragStart(event: DragEvent, dragData) {
this.dragData = dragData;
event.dataTransfer.effectAllowed = 'all';
event.dataTransfer.setData('Text', dragData.item);
}
// Курсор с данными был наведен на элемент таблицы
public dragEnter(event: DragEvent) {
this.clearEnteredCell();
const element = this.getTargetElement(event.target);
const cell = this.getCell(element);
if (cell) {
this.enteredCell = cell;
this.enteredCell.entered = this.dragData.item;
}
}
// Курсор с данными покинул элемент таблицы
public dragLeave(event: DragEvent) {
const element = this.getTargetElement(event.target);
if (!element || !element.closest('td')) {
this.clearEnteredCell();
}
}
// Курсор с данными находится над элементом таблицы
public dragOver(event: DragEvent) {
const element = this.getTargetElement(event.target);
const cell = this.getCell(element);
if (cell) {
event.preventDefault();
event.dataTransfer.dropEffect = 'move';
return false;
}
}
// На элемент таблицы положили данные
public drop(event: DragEvent) {
const element = this.getTargetElement(event.target);
event.stopPropagation();
if (this.dragData && this.enteredCell) {
const index = this.dragData.cell.indexOf(this.dragData.item);
this.dragData.cell.splice(index, 1);
this.enteredCell.push(this.dragData.item);
}
this.dragEnd();
return false;
}
// Перетаскивание завершено
public dragEnd() {
delete this.dragData;
this.clearEnteredCell();
}
}
```
**Профайлер**
Ситуация в плане производительности значительно улучшилась, и в продакшн режиме скорость обработки перетаскивания стала близкой к приемлемой.
По профайлеру по-прежнему было видно, что много вычислительных ресурсов тратится на выполнение скриптов, причем эти вычисления не имеют никакого отношения к моему коду.
Тут я уже начал понимать, что ответственен за это Zone.js, который лежит в основе Angular. На это явно указывали методы, которые можно наблюдать в профайлере. В файле polyfills.ts, я увидел, что есть возможность отключить стандартный обработчик фреймворка для некоторых событий. И так как чаще всего при перетаскивании вызывается событие dragover, включение его в черный список, давало практические идеальный результат.
```
/**
* By default, zone.js will patch all possible macroTask and DomEvents
* user can disable parts of macroTask/DomEvents patch by setting following flags
*/
// (window as any).__Zone_disable_requestAnimationFrame = true; // disable patch requestAnimationFrame
// (window as any).__Zone_disable_on_property = true; // disable patch onProperty such as onclick
(window as any).__zone_symbol__BLACK_LISTED_EVENTS = ['dragover']; // disable patch specified eventNames
```
На этом можно было остановиться, но после небольшого поиска в интернете было найдено решение, которое не меняло бы стандартное поведение.
Третий вариант решения
----------------------
В проекте у меня каждая ячейка была отдельным компонентом, в предыдущих примерах я не стал этого делать, чтобы не усложнять код.
### Шаг 1
Когда решение было найдено, я сперва вернулся к первоначальной логике, где каждый компонент ячейки был ответственен только за свое содержание, а таблица в таком варианте стала выполнять только роль контейнера.
Такая декомпозиция позволила сильно ограничить количество данных, в которых будет происходить поиск изменений, и значительно упростила код, одновременно давая больше контроля.
**Код после рефакторинга**[репозиторий](https://github.com/ovcharik/ngx-optimization-demo/blob/master/src/app/version-4.component.ts), [пример](https://ovcharik.github.io/ngx-optimization-demo/#/v4)
```
@Component({
selector: 'app-version-4-cell',
template: `
{{item}}
{{cell.entered}}
`,
})
export class Version4CellComponent {
@Input() public cell: Cell;
private enteredElements: any = [];
constructor(
private element: ElementRef,
private dndStorage: DndStorageService,
) {}
// Начало перетаскивания
public dragStart(event: DragEvent, item: string) {
this.dndStorage.set(this.cell, item);
event.dataTransfer.effectAllowed = 'all';
event.dataTransfer.setData('Text', item);
}
// Курсор с данными был наведен на элемент таблицы
@HostListener('dragenter', ['$event'])
private dragEnter(event: DragEvent) {
this.enteredElements.push(event.target);
if (this.cell !== this.dndStorage.cell) {
this.cell.entered = this.dndStorage.item;
}
}
// Курсор с данными покинул элемент таблицы
@HostListener('dragleave', ['$event'])
private dragLeave(event: DragEvent) {
this.enteredElements = this.enteredElements.filter(x => x != event.target);
if (!this.enteredElements.length) {
delete this.cell.entered;
}
}
// Курсор с данными находится над элементом таблицы
@HostListener('dragover', ['$event'])
private dragOver(event: DragEvent) {
event.preventDefault();
event.dataTransfer.dropEffect = this.cell.entered ? 'move' : 'none';
return false;
}
// На элемент таблицы положили данные
@HostListener('drop', ['$event'])
private drop(event: DragEvent) {
event.stopPropagation();
this.cell.push(this.dndStorage.item);
this.dndStorage.dropped();
delete this.cell.entered;
return false;
}
// Перетаскивание завершено
public dragEnd(event: DragEvent) {
if (this.dndStorage.isDropped) {
const index = this.cell.indexOf(this.dndStorage.item);
this.cell.splice(index, 1);
}
this.dndStorage.reset();
}
}
@Component({
selector: 'app-version-4',
template: `
{{title}}
=========
| |
| --- |
| |
`,
})
export class Version4Component extends VersionBase {
public static readonly title = 'Декомпозированные ячейки';
}
```
### Шаг 2
Из комментария в файле polyfills.js следует, что Zone.js по умолчанию берет на себя контроль за всеми событиями DOM и различными задачами например обработку setTimeout.
[Это позволяет Angular](https://habrahabr.ru/company/wrike/blog/310422/) своевременно запускать механизм поиска изменений, а пользователям фреймворка не задумываться над контекстом выполнения кода.
На Stack Overflow было найдено [решение](https://stackoverflow.com/questions/43108155/angular-2-how-to-keep-event-from-triggering-digest-loop-detection-cycle#answer-43294113), как с помощью переопределения стандартного [EventManager](https://angular.io/api/platform-browser/EventManager), можно заставить события с определенным параметром выполняться вне контекста фреймворка. Данный подход позволяет, точечно контролировать обработку событий в конкретных местах.
Из плюсов можно отметить, что явно указывая, где события будут выполняться вне контекста фреймворка, не будет неожиданностей для разработчиков, не знакомых с данным кодом, в отличие от подхода с включением событий в черный список.
```
import { Injectable, Inject, NgZone } from '@angular/core';
import { EVENT_MANAGER_PLUGINS, EventManager } from '@angular/platform-browser';
@Injectable()
export class OutZoneEventManager extends EventManager {
constructor(
@Inject(EVENT_MANAGER_PLUGINS) plugins: any[],
private zone: NgZone
) {
super(plugins, zone);
}
addEventListener(element: HTMLElement, eventName: string, handler: Function): Function {
// Поиск флага в названии события
if(eventName.endsWith('out-zone')) {
eventName = eventName.split('.')[0];
// Обработчик события будет выполняться вне контекста Angular
return this.zone.runOutsideAngular(() => {
return super.addEventListener(element, eventName, handler);
});
}
// Поведение по умолчанию
return super.addEventListener(element, eventName, handler);
}
}
```
### Шаг 3
Еще один момент заключается в том, что внесение изменений в DOM, провоцируют браузер немедленно отобразить их.
Рендр одного фрейма занимает некоторое время, рендр следующего может быть запущен только после завершения предыдущего. Для того чтобы узнать, когда браузер будет готов к рендеру следующего фрейма, существует [requestAnimationFrame](https://developer.mozilla.org/ru/docs/DOM/window.requestAnimationFrame).
В нашем случае нет потребности вносить изменения чаще, чем браузер сможет их отобразить, поэтому для синхронизации я написал небольшой сервис.
```
import { Observable } from 'rxjs/Observable';
import { animationFrame } from 'rxjs/scheduler/animationFrame.js';
import { Injectable } from '@angular/core';
@Injectable()
export class BeforeRenderService {
private tasks: Array<() => void> = [];
private running: boolean = false;
constructor() {}
public addTask(task: () => void) {
this.tasks.push(task);
this.run();
}
private run() {
if (this.running) { return; }
this.running = true;
animationFrame.schedule(() => {
this.tasks.forEach(x => x());
this.tasks.length = 0;
this.running = false;
});
}
}
```
### Шаг 4
Теперь остается только подсказать фреймворку, где произошли изменения в нужный момент.
Подробнее с механизмом обнаружения изменений можно ознакомиться в [данной статье](https://habrahabr.ru/post/327004/). Я лишь скажу, что явно управлять поиском изменений можно с помощью [ChangeDetectorRef](https://angular.io/api/core/ChangeDetectorRef). Через DI он подключается к нужному компоненту, и как только становится известно об изменениях, которые вносились при выполнении кода вне контекста Angular, необходимо запустить поиск изменений в конкретном компоненте.
### Итоговый вариант
Вносим в код компонента буквально пару изменений: события dragenter, dragleave, dragover заменяем на аналогичные с .out-zone в конце названия, и в обработчиках этих событий явно указываем фреймворку на наличие изменений в данных.
[репозиторий](https://github.com/ovcharik/ngx-optimization-demo/blob/master/src/app/version-5.component.ts), [пример](https://ovcharik.github.io/ngx-optimization-demo/#/v5)
```
-export class Version4CellComponent {
+export class Version5CellComponent {
@Input() public cell: Cell;
constructor(
private element: ElementRef,
private dndStorage: DndStorageService,
+ private changeDetector: ChangeDetectorRef,
+ private beforeRender: BeforeRenderService,
) {}
// ...
// Курсор с данными был наведен на элемент таблицы
- @HostListener('dragenter', ['$event'])
+ @HostListener('dragenter.out-zone', ['$event'])
private dragEnter(event: DragEvent) {
this.enteredElements.push(event.target);
if (this.cell !== this.dndStorage.cell) {
this.cell.entered = this.dndStorage.item;
+ this.beforeRender.addTask(() => this.changeDetector.detectChanges());
}
}
// Курсор с данными покинул элемент таблицы
- @HostListener('dragleave', ['$event'])
+ @HostListener('dragleave.out-zone', ['$event'])
private dragLeave(event: DragEvent) {
this.enteredElements = this.enteredElements.filter(x => x != event.target);
if (!this.enteredElements.length) {
delete this.cell.entered;
+ this.beforeRender.addTask(() => this.changeDetector.detectChanges());
}
}
// Курсор с данными находится над элементом таблицы
- @HostListener('dragover', ['$event'])
+ @HostListener('dragover.out-zone', ['$event'])
private dragOver(event: DragEvent) {
event.preventDefault();
event.dataTransfer.dropEffect = this.cell.entered ? 'move' : 'none';
}
// ...
}
```
Заключение
----------
В итоге получаем чистый и понятный код, с точным контролем за изменениями.
По профайлеру видно, что на выполнение скриптов практически не расходуются ресурсы. А также этот подход никак не меняет стандартное поведение фреймворка или компонента, за исключением конкретных случаев, на которые в коде есть явные указания. | https://habr.com/ru/post/353354/ | null | ru | null |
# Мой опыт настройки окружения для Web-разработки
Речь пойдет не о настройке денвера и не о том, как поставить LAMP-стек. Я решил рассказать о том, какое мы в своей команде используем окружение для разработки. Мы разрабатываем Web-сервисы и ERP-системы, но всё это, в сущности, ничто иное, как сайты. Просто сложные внутри и порой не такие красивые снаружи.
Сразу хочу сказать, что я не претендую на описание идеального окружения для Web-разработки. С удовольствием послушаю критику, приглашаю всех поделиться своими подходами в комментариях. В общем, поехали.
#### Подождите, а чем плох денвер?
Основной недостаток денвера состоит в том, что проекты в production не работают на денвере. А значит мы не можем гарантировать, что тщательно отлаженные на компьютере разработчика скрипты не начнут «чудить», когда попадут в production. В production проекты обычно работают в Linux (в нашем случае это CentOS или Amazon Linux). Кроме того, работая на денвере, мы не сможем использовать различные утилиты и средства, которые нам нужны в проекте (например, catdoc, поиск sphinx и многое другое).
#### Ок, но ведь не все готовы работать в Linux!
Разрабатывать прямо в Linux, конечно круто, но правда жизни такова, что большинство разработчиков пользуются Windows в качестве основной OC на компьютере. Поэтому дальше я опишу наш рецепт, как работая в Windows, разрабатывать сайты в Linux.
Мы используем CentOS 7, но думаю, без существенных изменений все будет работать и на других дистрибутивах.
#### Создаем образ виртуальной машины
Ок. Первое, что нужно сделать — это поставить на компьютер гипервизор (VmWare Workstation, Oracle VirtualBox или может какой-то другой по вкусу). Мы используем VmWare. После этого создаем виртуальную машину и разворачиваем в ней тот образ Linux, на котором будут работать наши проекты в production. Устанавливаем Web-сервер, СУБД, в общем все, что нам нужно для запуска проекта. Кстати, если есть образ виртуалки для production, то еще лучше — можно его и взять за основу.
Виртуалку удобнее всего подключить через bridged-сетевой интерфейс. Так она будет полноценным участником сети и можно будет легко показывать результаты коллегам или заказчикам, если пробросить порт из внешнего мира.
#### Сетевая папка
Первый вопрос, который у нас встал на этом этапе. Нам теперь что, скрипты проекта через putty редактировать?! И очевидное решение, которое мы нашли, было удивительно простым. В Windows-машине нужно завести отдельную папку, в которой будут лежать все наши проекты. Эту папку нужно расшарить для доступа по сети и примонтировать в корневую директорию, с которой работает Web-сервер.
Чтобы все это работало надежнее, я написал скриптик **cifs\_mount.sh**, буквально из 2 строчек кода, который поставил в виртуалке на запуск раз в 5 минут.
```
#!/bin/sh
if ! mount -t cifs | grep -q `cat /root/file_server`
then mount -t cifs -o uid=apache,gid=apache,iocharset=utf8,noserverino,credentials=/root/.cifscreds `cat /root/file_server` /var/www
fi
```
Скрипт проверяет, не отвалилась ли шара (простите мой французский). И если отвалилась, обратно ее монтирует.
Файл /root/file\_server
`//192.168.0.2/Projects`
Файл /root/.cifscreds
`username=developvm
password=secretpass`
В целом, это решение работает надежно, как утюг.
**Но тем не менее есть один небольшой нюанс.**Иногда бывает, что при копировании больших файлов, вылетает ошибка cifs. Как правило, это связано с тем, что в Windows не хватает выделенной памяти для шары. Вылеты происходят из-за того, что Win7 настроена по умолчанию на экономию памяти для сетевых подключений, в частности, размер выделяемого для этих целей пула памяти ограничен, и если для обработки файла требуется больше, то Win7 шлет Linux фатальную ошибку интерфейса и CIFS падает.
Также бывает наблюдаются периодические проблемы с неполной загрузкой страниц (не подгружаются CSS или вообще ошибки при попытке Apache прочитать файл). Причем это возникает время от времени без какой-либо системы.
При этом в логе ошибок Apache следующие ошибки:
`[Tue Oct 20 10:44:28.417589 2015] [core:crit] [pid 9632] (5)Input/output error: [client 192.168.1.5:60666] AH00529: /var/www/project/.htaccess pcfg_openfile: unable to check htaccess file, ensure it is readable and that '/var/www/project/' is executable, referer: http://192.168.1.102/script.php
[Tue Oct 20 10:44:28.418762 2015] [core:error] [pid 9555] (5)Input/output error: [client 192.168.1.5:60670] AH00132: file permissions deny server access: /var/www/project/css/main/layout-main.css, referer: http://192.168.1.102/script.php`
Чтобы ликвидировать все эти проблемы разом, нужно подредактировать реестр Win7, а именно:
1. У HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management\LargeSystemCache установить значение 1
2. У HKEY\_LOCAL\_MACHINE\SYSTEM\CurrentControlSet\Services\lanmanserver\parameters\size установить значение 3
После этого перезапустить LanmanServer. “net stop srv”/“net start srv”. На виртуалке перемонтировать шару.
**И еще один нюанс касается опции noserverino**В свое время он породил этот мой [вопрос](http://stackoverflow.com/questions/13599046/why-mkdir-fails-with-recursive-option-set-true) на stackoverflow. Если кратко, эта опция нужна. Подробнее можно почитать по ссылке.
Не стоит пугаться этих нюансов! Они накопились у нас почти за 10 лет разработки с использованием этого подхода.
Итак, что мы имеем. Теперь мы можем работать со скриптами в привычном нам редакторе кода в Windows. А результаты смотреть в браузере, заходя на нашу виртуальную машину. Идем дальше.
#### Подпапки для проектов.
А что если у нас больше 1 проекта. Каждый раз поднимать новую виртуалку!? Нам на помощь приходят виртуальные хосты. Придется опять написать небольшой скриптик **flush\_vhosts.sh** (сугубо для удобства работы).
```
#!/bin/sh
rm /etc/httpd/conf.d/vhosts/*
rm /etc/hosts
echo '127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain4' >> /etc/hosts
echo '::1 localhost localhost.localdomain localhost6 localhost6.localdomain6' >> /etc/hosts
for D in `find /var/www -maxdepth 1 -mindepth 1 -type d -printf '%f\n'`
do
echo '' >> /etc/httpd/conf.d/vhosts/$D.conf
echo "ServerName $D.wde" >> /etc/httpd/conf.d/vhosts/$D.conf
echo "ServerAlias \*.$D.wde" >> /etc/httpd/conf.d/vhosts/$D.conf
echo "DocumentRoot /var/www/$D" >> /etc/httpd/conf.d/vhosts/$D.conf
if [[ $D == \*"bitrix"\* ]]
then
echo 'php\_admin\_value mbstring.func\_overload 2' >> /etc/httpd/conf.d/vhosts/$D.conf
echo 'php\_admin\_value mbstring.internal\_encoding UTF-8' >> /etc/httpd/conf.d/vhosts/$D.conf
echo 'php\_admin\_value max\_input\_vars 10001' >> /etc/httpd/conf.d/vhosts/$D.conf
echo 'php\_admin\_value pcre.recursion\_limit 1000' >> /etc/httpd/conf.d/vhosts/$D.conf
fi
echo "" >> /etc/httpd/conf.d/vhosts/$D.conf
echo "127.0.0.1 $D.wde" >> /etc/hosts
done
systemctl restart httpd.service
```
Вот что он делает:
1. Очищает конфигурацию виртуальных хостов.
2. Очищает /etc/hosts.
3. Дальше он проходится по всем подкаталогам нашей примонтированной папки и создает для каждого каталога новый виртуальный хост Apache. Если в названии каталога находится страшное слово bitrix, то он добавляет в конфиг виртуального хоста несколько специфических настроек для этой замечательной CMS. Добавляет в /etc/hosts новые записи для созданных виртуальных хостов.
4. Перезапускает Apache.
Мы использует в адресах проектов для разработки условный домен первого уровня wde (web developer environment). Можно использовать local или кому что нравится. У нас разрабатываемые проекты доступны по адресам project1.wde, project2.wde и так далее. При этом виртуальные хосты создаются с директивой ServerAlias \*.your-folder-name.wde, то есть все поддомены будут также обрабатываться созданным для папки виртуальным хостом.
Таким образом, если нам нужно начать работу над новым проектом, достаточно создать новую папку в общей папке проектов. Выполнить скрипт **flush\_vhosts.sh**. А в Windows прописать адрес для нового проекта в файле C:\Windows\System32\drivers\etc\host.
`192.168.1.166 wde
192.168.1.166 site1.wde
192.168.1.166 site2.wde
...и т.д.`
Звездочки файл hosts к великому сожалению, не поддерживает. Надо прописывать каждый адрес, с которым будем работать. Вместо 192.168.1.166 нужно указать ip, который вы присвоили виртуальной машине. После этого соответствующий проект будет открываться в браузере по адресам [site1.wde](http://site1.wde) или [site2.wde](http://site2.wde) и так далее.
Для удобства, если вы пользуетесь, phpMyAdmin, его можно настроить дефолтным хостом. Тогда при обращении по любому адресу, когда Apache не будет находить соответствующую папку проекта, он будет открывать phpMyAdmin. Главное не забыть прописать этот адрес (например, просто wde) в файле hosts в Windows.
##### Организация загрузочного меню
Чтобы было совсем удобно. И не приходилось новым членам команды объяснять, как обновить конфигурацию виртуальных хостов, настроить сетевую папку и т.д. Я написал еще несколько скриптов для вывода и запуска частых действий через меню. В них нет ничего сверхестественного, прикладываю — может быть кому-то тоже пригодятся.
Собственно скрипт, выводящий меню. Его нужно прописать в файле .bash\_profile домашней директории пользователя, под которым мы входим на виртуалку. Для виртуалки, на которой ведется разработка, я считаю можно входить под root, соответственно добавляем в файл /root/.bash\_profile строчку ./menu.sh. Теперь сразу после входа в систему будет запускаться наше меню. При необходимости из него всего можно выйти, нажав Ctrl+C.
**menu.sh**
```
#!/bin/sh
SCRIPT_DIR=`dirname $0`
source $SCRIPT_DIR/utils.sh
#menu actions
act_net () {
nmtui ;
}
act_folder () {
$SCRIPT_DIR/mount_cfg.sh ;
}
act_flushvhosts () {
$SCRIPT_DIR/flush_vhosts.sh ;
}
act_reboot () {
read -p "System is going to reboot, are u sure? (y/N) " key ;
if [ $key = "y" ]; then
systemctl reboot ;
exit
fi
key=
}
act_shutdown () {
read -p "System is going down, are u sure? (y/N) " key ;
if [ $key = "y" ]; then
systemctl halt ;
exit
fi
key=
}
themenu () {
clear
server_uptime
mnt_detect
echo "===================================================================="
echo "======================= WELCOME to CENTOS WDE!!! ==================="
echo "===================================================================="
echo "======================== wish you happy coding ====================="
echo "===================================================================="
echo -e "System time: "$curtime"\tUptime:"$uptime;
echo ;
echo -e "Mounted folder: "$MNT;
echo ;
echo "=========================== network info ==========================="
echo "`ifconfig -a`"
echo ;
echo `grep nameserver /etc/resolv.conf`
echo ;
echo "`route -n`"
echo ;
echo "====================== current vhosts configs ======================"
echo "`ls -1 /etc/httpd/conf.d/vhosts/`"
echo ;
echo "===================================================================="
echo "========================= Available actions: ======================="
echo -e "\t\tConfigure ${FG_UN}net${NORM}"
echo -e "\t\tConfigure mounted ${FG_UN}folder${NORM}";
echo -e "\t\t${FG_UN}Flush${NORM} virtual hosts";
echo -e "\t\t${FG_UN}Reboot${NORM}";
echo -e "\t\t${FG_UN}Shutdown${NORM}";
echo
echo "Type underlined chars(lowercase) and press ENTER or just ENTER to refresh";
echo "Type Ctrl+C to exit to shell";
echo "====================================================================";
}
while true
do
themenu
read answer
case $answer in
"net") act_net;;
"folder") act_folder;;
"flush") act_flushvhosts;;
"reboot") act_reboot;;
"shutdown") act_shutdown;;
*) echo 'No action found! Refreshing...'; sleep 1; continue;;
esac
done
```
**utils.sh - содержит функции и переменные, используемые в других скриптах**
```
#!/bin/sh
set -o pipefail
mnt_dir="/var/www"
if [ "$interactive" != 'no' ]; then
#cursor movements
CU_RIGHT=$(tput hpa $(tput cols))$(tput cub 7)
#background colors
BG_BLACK=$(tput setab 1)
BG_RED=$(tput setab 1)
BG_GREEN=$(tput setab 2)
BG_YELLOW=$(tput setab 3)
BG_BLUE=$(tput setab 4)
BG_PURPLE=$(tput setab 5)
BG_CYAN=$(tput setab 6)
BG_WHITE=$(tput setab 7)
#foreground colors
FG_RED=$(tput setaf 1)
FG_GREEN=$(tput setaf 2)
FG_YELLOW=$(tput setaf 3)
FG_BLUE=$(tput setaf 4)
FG_PURPLE=$(tput setaf 5)
FG_CYAN=$(tput setaf 6)
FG_WHITE=$(tput setaf 7)
#text-decoration
FG_BOLD=$(tput bold)
FG_HB=$(tput dim)
FG_UN=$(tput smul)
FG_REVERSE=$(tput rev)
#back to defaults
NORM=$(tput sgr0)
fi
#functions to display progress
dots () {
if [ "$interactive" != 'no' ]; then
while true; do
echo -n "."; sleep 0.5
done
fi
}
estart(){
if [ "$interactive" != 'no' ]; then
echo -n "$1"
dots &
dots_pid=$!
fi
}
efinish(){
estatus=$?
if [ "$interactive" != 'no' ]; then
if [ "$estatus" -eq 0 ];then
echo "[ ${FG_GREEN}OK${NORM} ]"
else
echo "[ ${FG_RED}FAIL${NORM} ]"
fi
kill $dots_pid
wait $dots_pid 2>/dev/null
fi
}
#detect server uptime
server_uptime () {
uptime=$(
```
**mount\_cfg.sh - настройка параметров сетевой папки**
```
#!/bin/sh
SCRIPT_DIR=`dirname $0`
source $SCRIPT_DIR/utils.sh
clear
echo "========================================="
echo " Mounted folder configuration"
echo " (/var/www)"
echo "========================================="
echo
old_address=$(cat /root/file_server)
old_username=$(grep 'username=' /root/.cifscreds | awk -F '=' '{ print $2 }')
old_password=$(grep 'password=' /root/.cifscreds | awk -F '=' '{ print $2 }')
echo "Type new value and press ENTER or just press ENTER to leave current value.";
echo ;
read -p "Address of fileserver, type like //ip/folder (current value $FG_YELLOW$old_address$NORM): " address ;
read -p "Username (current value $FG_YELLOW$old_username$NORM): " username ;
read -p "Password (current value $FG_YELLOW$old_password$NORM): " password ;
if [ -z "$address" ]; then
address=$old_address; fi
if [ -z "$username" ]; then
username=$old_username; fi
if [ -z "$password" ]; then
password=$old_password; fi
echo "======================================="
echo " New parameters"
echo "======================================="
echo -e "IP address of fileserver: "$address
echo -e "Username: "$username
echo -e "Password: "$password
echo "======================================="
echo
read -p "Save changes? (y/N) " key ;
if [ $key == "Y" -o $key == "y" ]; then
echo "username=$username
password=$password" > /root/.cifscreds
echo "$address" > /root/file_server
estart "Unmounting..."
umount /var/www
efinish
estart "Mounting..."
/root/cifs_mount.sh
efinish
echo ;
read -p "Done. Press any key" key ;
else
echo ;
read -p "Nothing was changed. Press any key" key ;
fi
```
#### Система контроля версий
Дальше остается настроить любимую систему контроля версий. Можно пользоваться desktop-приложением для Windows, можно работать через командную строку в putty прямо на нашей виртуальной машине. Кому, как удобнее.
PS. Кстати, одно из величайших открытий для меня было, что можно поставить git или svn непосредственно на production сервере. Когда я в свое время это понял, это ощущение было сравнимо, наверное, с тем чувством, которое испытал Архимед, когда сел в ванную. Ведь больше не надо мучиться с синхронизацией файлов по ftp\sftp, достаточно ввести svn up или git pull origin master! | https://habr.com/ru/post/282884/ | null | ru | null |
# Пошаговое руководство по настройке DNS-сервера BIND в chroot среде для Red Hat (RHEL / CentOS) 7
*Перевод статьи подготовлен для студентов курса [«Безопасность Linux»](https://otus.pw/U1cp/). Интересно развиваться в данном направлении? Смотрите запись трансляции мастер-класса Ивана Пискунова [«Безопасность в Linux в сравнении с Windows и MacOS»](https://otus.pw/6yM3/)*
В этой статье я расскажу о шагах по настройке DNS-сервера на RHEL 7 или CentOS 7. Для демонстрации я использовал Red Hat Enterprise Linux 7.4. Наша цель — создать одну A-запись и одну PTR-запись для зоны прямого и обратного просмотра соответственно.
Сначала установите необходимые rpm-пакеты для DNS-сервера.
*ПРИМЕЧАНИЕ: Для RHEL у вас должна быть [активная подписка на RHN](https://www.golinuxcloud.com/register-rhel-7-attach-subscription-manager/), или вы можете [настроить локальный автономный репозиторий](https://www.golinuxcloud.com/there-are-no-enabled-repos-yum-dnf-rhel-7-8/), с помощью которого менеджер пакетов «yum» сможет установить необходимые rpm-пакеты и зависимости.*
```
# yum install bind bind-chroot caching-nameserver
```
Мои настройки:
```
# hostname
golinuxhub-client.example
Мой IP-адрес 192.168.1.7
# ip address | egrep 'inet.*enp0s3'
inet 192.168.1.7/24 brd 192.168.1.255 scope global dynamic enp0s3
```
Поскольку мы будем использовать chroot, нужно отключить службу.
```
# systemctl stop named
# systemctl disable named
```
Затем скопируйте необходимые файлы в каталог chroot.
ПРИМЕЧАНИЕ. Используйте аргумент *-p* в команде *cp* для сохранения прав и владельцев.
```
[root@golinuxhub-client ~]# cp -rpvf /usr/share/doc/bind-9.9.4/sample/etc/* /var/named/chroot/etc/
‘/usr/share/doc/bind-9.9.4/sample/etc/named.conf’ -> ‘/var/named/chroot/etc/named.conf’
‘/usr/share/doc/bind-9.9.4/sample/etc/named.rfc1912.zones’ -> ‘/var/named/chroot/etc/named.rfc1912.zones’
```
Затем скопируйте файлы, связанные с зоной, в новое место.
```
[root@golinuxhub-client ~]# cp -rpvf /usr/share/doc/bind-9.9.4/sample/var/named/* /var/named/chroot/var/named/
‘/usr/share/doc/bind-9.9.4/sample/var/named/data’ -> ‘/var/named/chroot/var/named/data’
‘/usr/share/doc/bind-9.9.4/sample/var/named/my.external.zone.db’ -> ‘/var/named/chroot/var/named/my.external.zone.db’
‘/usr/share/doc/bind-9.9.4/sample/var/named/my.internal.zone.db’ -> ‘/var/named/chroot/var/named/my.internal.zone.db’
‘/usr/share/doc/bind-9.9.4/sample/var/named/named.ca’ -> ‘/var/named/chroot/var/named/named.ca’
‘/usr/share/doc/bind-9.9.4/sample/var/named/named.empty’ -> ‘/var/named/chroot/var/named/named.empty’
‘/usr/share/doc/bind-9.9.4/sample/var/named/named.localhost’ -> ‘/var/named/chroot/var/named/named.localhost’
‘/usr/share/doc/bind-9.9.4/sample/var/named/named.loopback’ -> ‘/var/named/chroot/var/named/named.loopback’
‘/usr/share/doc/bind-9.9.4/sample/var/named/slaves’ -> ‘/var/named/chroot/var/named/slaves’
‘/usr/share/doc/bind-9.9.4/sample/var/named/slaves/my.ddns.internal.zone.db’ -> ‘/var/named/chroot/var/named/slaves/my.ddns.internal.zone.db’
‘/usr/share/doc/bind-9.9.4/sample/var/named/slaves/my.slave.internal.zone.db’ -> ‘/var/named/chroot/var/named/slaves/my.slave.internal.zone.db’
```bash
Теперь давайте посмотрим на основной файл конфигурации.
```bash
# cd /var/named/chroot/etc/
```
Очистите содержимое named.conf и вставьте следующее.
```
[root@golinuxhub-client etc]# vim named.conf
options {
listen-on port 53 { 127.0.0.1; any; };
# listen-on-v6 port 53 { ::1; };
directory "/var/named";
dump-file "/var/named/data/cache_dump.db";
statistics-file "/var/named/data/named_stats.txt";
memstatistics-file "/var/named/data/named_mem_stats.txt";
allow-query { localhost; any; };
allow-query-cache { localhost; any; };
};
logging {
channel default_debug {
file "data/named.run";
severity dynamic;
};
};
view my_resolver {
match-clients { localhost; any; };
recursion yes;
include "/etc/named.rfc1912.zones";
};
```
Информация, относящаяся к зоне, должна быть добавлена в */var/named/chroot/etc/named.rfc1912.zones*. Добавьте записи, приведенные ниже. Файл example.zone — это файл зоны прямого просмотра, а *example.rzone* — файл обратной зоны.
**ВАЖНОЕ ПРИМЕЧАНИЕ: Зона обратного просмотра содержит 1.168.192, поскольку мой IP-адрес 192.168.1.7**
```
zone "example" IN {
type master;
file "example.zone";
allow-update { none; };
};
zone "1.168.192.in-addr.arpa" IN {
type master;
file "example.rzone";
allow-update { none; };
};
```
Файлы, связанные с зонами, находятся здесь:
```
# cd /var/named/chroot/var/named/
```
Далее создадим файлы для прямой и обратной зоны. Имена файлов будут такими же, как выше в файле *named.rfc1912.zones*. У нас уже есть несколько шаблонов по умолчанию, которые мы можем использовать.
```
# cp -p named.localhost example.zone
# cp -p named.loopback example.rzone
```
Как видите, текущие разрешения на все файлы и каталоги принадлежат *root*.
```
[root@golinuxhub-client named]# ll
total 32
drwxr-xr-x. 2 root root 6 May 22 2017 data
-rw-r--r--. 1 root root 168 May 22 2017 example.rzone
-rw-r--r--. 1 root root 152 May 22 2017 example.zone
-rw-r--r--. 1 root root 56 May 22 2017 my.external.zone.db
-rw-r--r--. 1 root root 56 May 22 2017 my.internal.zone.db
-rw-r--r--. 1 root root 2281 May 22 2017 named.ca
-rw-r--r--. 1 root root 152 May 22 2017 named.empty
-rw-r--r--. 1 root root 152 May 22 2017 named.localhost
-rw-r--r--. 1 root root 168 May 22 2017 named.loopback
drwxr-xr-x. 2 root root 71 Feb 12 21:02 slaves
```
Измените права всех файлов, указав в качестве владельца пользователя *root* и группу *named*.
```
# chown root:named *
```
Но для data владелец должен быть *named:named*.
```
# chown -R named:named data
# ls -l
total 32
drwxr-xr-x. 2 named named 6 May 22 2017 data
-rw-r--r--. 1 root named 168 May 22 2017 example.rzone
-rw-r--r--. 1 root named 152 May 22 2017 example.zone
-rw-r--r--. 1 root named 56 May 22 2017 my.external.zone.db
-rw-r--r--. 1 root named 56 May 22 2017 my.internal.zone.db
-rw-r--r--. 1 root named 2281 May 22 2017 named.ca
-rw-r--r--. 1 root named 152 May 22 2017 named.empty
-rw-r--r--. 1 root named 152 May 22 2017 named.localhost
-rw-r--r--. 1 root named 168 May 22 2017 named.loopback
drwxr-xr-x. 2 root named 71 Feb 12 21:02 slaves
```
Добавьте приведенное ниже содержимое в файл прямой зоны. Здесь мы создаем A-запись для localhost (golinuxhub-client) и еще одну для сервера (golinuxhub-server).
```
# vim example.zone
$TTL 1D
@ IN SOA example. root (
1 ; serial
3H ; refresh
15M ; retry
1W ; expire
1D ) ; minimum
IN NS example.
IN A 192.168.1.7
golinuxhub-server IN A 192.168.1.5
golinuxhub-client IN A 192.169.1.7
```
Далее добавьте содержимое в файл обратной зоны. Здесь мы создаем PTR-запись для golinuxhub-client и для сервера golinuxhub-server.
```
# vim example.rzone
$TTL 1D
@ IN SOA example. root.example. (
1997022700 ; serial
28800 ; refresh
14400 ; retry
3600000 ; expire
86400 ) ; minimum
IN NS example.
5 IN PTR golinuxhub-server.example.
7 IN PTR golinuxhub-client.example.
```
Прежде чем мы запустим сервис *named-chroot*, проверим конфигурацию файла зоны.
```
[root@golinuxhub-client named]# named-checkzone golinuxhub-client.example example.zone
zone golinuxhub-client.example/IN: loaded serial 1
OK
[root@golinuxhub-client named]# named-checkzone golinuxhub-client.example example.rzone
zone golinuxhub-client.example/IN: loaded serial 1997022700
OK
```
Все выглядит хорошо. Теперь проверьте файл конфигурации, используя следующую команду.
```
[root@golinuxhub-client named]# named-checkconf -t /var/named/chroot/ /etc/named.conf
```
Итак, все выполнено успешно.
```
[root@golinuxhub-client named]# echo $?
0
```
*ВАЖНОЕ ПРИМЕЧАНИЕ: у меня SELinux находится в режиме permissive*
```
# getenforce
Permissive
```
Все выглядит хорошо, так что пора запускать наш сервис *named-chroot* .
```
[root@golinuxhub-client named]# systemctl restart named-chroot
```
```
[root@golinuxhub-client named]# systemctl status named-chroot
● named-chroot.service - Berkeley Internet Name Domain (DNS)
Loaded: loaded (/usr/lib/systemd/system/named-chroot.service; disabled; vendor preset: disabled)
Active: active (running) since Mon 2018-02-12 21:53:23 IST; 19s ago
Process: 5236 ExecStop=/bin/sh -c /usr/sbin/rndc stop > /dev/null 2>&1 || /bin/kill -TERM $MAINPID (code=exited, status=0/SUCCESS)
Process: 5327 ExecStart=/usr/sbin/named -u named -c ${NAMEDCONF} -t /var/named/chroot $OPTIONS (code=exited, status=0/SUCCESS)
Process: 5325 ExecStartPre=/bin/bash -c if [ ! "$DISABLE_ZONE_CHECKING" == "yes" ]; then /usr/sbin/named-checkconf -t /var/named/chroot -z "$NAMEDCONF"; else echo "Checking of zone files is disabled"; fi (code=exited, status=0/SUCCESS)
Main PID: 5330 (named)
CGroup: /system.slice/named-chroot.service
└─5330 /usr/sbin/named -u named -c /etc/named.conf -t /var/named/chroot
Feb 12 21:53:23 golinuxhub-client.example named[5330]: managed-keys-zone/my_resolver: loaded serial 0
Feb 12 21:53:23 golinuxhub-client.example named[5330]: zone 0.in-addr.arpa/IN/my_resolver: loaded serial 0
Feb 12 21:53:23 golinuxhub-client.example named[5330]: zone 1.0.0.127.in-addr.arpa/IN/my_resolver: loaded serial 0
Feb 12 21:53:23 golinuxhub-client.example named[5330]: zone 1.168.192.in-addr.arpa/IN/my_resolver: loaded serial 1997022700
Feb 12 21:53:23 golinuxhub-client.example named[5330]: zone example/IN/my_resolver: loaded serial 1
Feb 12 21:53:23 golinuxhub-client.example named[5330]: zone localhost/IN/my_resolver: loaded serial 0
Feb 12 21:53:23 golinuxhub-client.example named[5330]: zone 1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa/IN/my_resolver: loaded serial 0
Feb 12 21:53:23 golinuxhub-client.example named[5330]: zone localhost.localdomain/IN/my_resolver: loaded serial 0
Feb 12 21:53:23 golinuxhub-client.example named[5330]: all zones loaded
Feb 12 21:53:23 golinuxhub-client.example named[5330]: running
```bash
Убедитесь, что resolv.conf содержит ваш IP-адрес, чтобы он мог работать в качестве DNS-сервера.
```bash
# cat /etc/resolv.conf
search example
nameserver 192.168.1.7
```bash
Давайте проверим наш DNS-сервер для обратной зоны, используя dig.
```bash
[root@golinuxhub-client named]# dig -x 192.168.1.5
; <<>> DiG 9.9.4-RedHat-9.9.4-50.el7 <<>> -x 192.168.1.5
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40331
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 1, ADDITIONAL: 2
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;5.1.168.192.in-addr.arpa. IN PTR
;; ANSWER SECTION:
5.1.168.192.in-addr.arpa. 86400 IN PTR golinuxhub-server.example.
;; AUTHORITY SECTION:
1.168.192.in-addr.arpa. 86400 IN NS example.
;; ADDITIONAL SECTION:
example. 86400 IN A 192.168.1.7
;; Query time: 1 msec
;; SERVER: 192.168.1.7#53(192.168.1.7)
;; WHEN: Mon Feb 12 22:13:17 IST 2018
;; MSG SIZE rcvd: 122
```
Как вы видите, мы получили положительный ответ (ANSWER) на наш запрос (QUERY).
```
[root@golinuxhub-client named]# dig -x 192.168.1.7
; <<>> DiG 9.9.4-RedHat-9.9.4-50.el7 <<>> -x 192.168.1.7
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 55804
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 1, ADDITIONAL: 2
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;7.1.168.192.in-addr.arpa. IN PTR
;; ANSWER SECTION:
7.1.168.192.in-addr.arpa. 86400 IN PTR golinuxhub-client.example.
;; AUTHORITY SECTION:
1.168.192.in-addr.arpa. 86400 IN NS example.
;; ADDITIONAL SECTION:
example. 86400 IN A 192.168.1.7
;; Query time: 1 msec
;; SERVER: 192.168.1.7#53(192.168.1.7)
;; WHEN: Mon Feb 12 22:12:54 IST 2018
;; MSG SIZE rcvd: 122
```
Точно так же мы можем проверить прямую зону.
```
[root@golinuxhub-client named]# nslookup golinuxhub-client.example
Server: 192.168.1.7
Address: 192.168.1.7#53
Name: golinuxhub-client.example
Address: 192.169.1.7
[root@golinuxhub-client named]# nslookup golinuxhub-server.example
Server: 192.168.1.7
Address: 192.168.1.7#53
Name: golinuxhub-server.example
Address: 192.168.1.5
```
Эта статья немного устарела, так как в RHEL 7 теперь не нужно копировать файлы конфигурации bind в chroot. [Step-by-Step Tutorial: Configure DNS Server using bind chroot (CentOS/RHEL 7)](https://www.golinuxcloud.com/configure-dns-server-bind-chroot-named-centos/). | https://habr.com/ru/post/461281/ | null | ru | null |
# Забудьте про div, семантика спасёт интернет
Давным-давно (лет пятнадцать назад) почти все делали сайты и не переживали о том, что под капотом. Верстали таблицами, использовали всё, что попадётся под руку (а попадались в основном и ) и не особо заморачивались о доступности. А потом случился HTML5 и понеслось.
Семантическая вёрстка — подход к разметке, который опирается не на внешний вид сайта, а на смысловое предназначение каждого блока и логическую структуру документа. Даже в этой статье есть заголовки разных уровней — это помогает читателю выстроить в голове структуру документа. Так и на странице сайта — только читатели будут немного другими.
*Дисклеймер: статья может обидеть тех, кто прикипел к вёрстке дивами. Но — не приговор, и мы не призываем от него целиком отказываться. Ну и всегда можно договориться.*
### Почему семантика важна
**Чтобы сделать сайт доступным.** Зрячие пользователи могут без проблем с первого взгляда понять, где какая часть страницы находится — где заголовок, списки или изображения. Для незрячих или частично незрячих всё сложнее. Основной инструмент для просмотра сайтов не браузер, который отрисовывает страницу, а скринридер, который читает текст со страницы вслух.
Этот инструмент «зачитывает» содержимое страницы, и семантическая структура помогает ему лучше определять, какой сейчас блок, а пользователю понимать, о чём идёт речь. Таким образом семантическая разметка помогает б*о*льшему количеству пользователей взаимодействовать с вашим сайтом. Например, наличие заголовков помогает незрячим в навигации по странице. У скринридеров есть функция навигации по заголовкам, что ускоряет знакомство с информацией на сайте.
**Чтобы сайт был выше в поисковиках.** Компании, которые создают поисковики, не разглашают правила ранжирования, но известно, что наличие семантической разметки страниц помогает поисковым ботам лучше понимать, что находится на странице, и в зависимости от этого ранжировать сайты в поисковой выдаче.
Классический пример — расписание поезда «Сапсан» в выдаче Google.
Разработчики tutu.ru сверстали таблицу тегом вместо и их сниппет оказался в выдаче Google по важному коммерческому запросу.
**Семантика прописана в стандартах.** Многие разработчики по старинке пользуются конструкциями типа для обозначения навигации или других структурных элементов страницы. Тем временем в стандарте HTML есть несколько семантических тегов, которые рекомендуется использовать для разметки страниц вместо и . [В спецификации](https://www.w3.org/TR/html52/sections.html#the-nav-element) для каждого семантического элемента описана его роль.
Ну и представьте, насколько проще читать вместо . Или вот такой код. Смотрите и сразу понятно, что тут и зачем.
```
Заголовок страницы
```
### Основные семантические теги HTML
Среди «старых» тегов из ранних версий HTML тоже есть семантические — например, тег , который обозначает параграф. При этом теги или не семантические, потому что они не добавляют смысла выделенному тексту, а просто определяют его внешний вид.
Но в актуальной версии стандарта HTML Living Standard есть семантические теги почти для всех основных частей сайта, и лучше пользоваться ими. Вот несколько примеров семантических тегов.
####
* Значение: независимая, отделяемая смысловая единица, например комментарий, твит, статья, виджет ВК и так далее.
* Особенности: желателен заголовок внутри.
* Типовые ошибки: путают с тегами и .
####
* Значение: смысловой раздел документа. Неотделяемый, в отличие от .
* Особенности: желателен заголовок внутри.
* Типовые ошибки: путают с тегами и .
####
* Значение: побочный, косвенный для страницы контент.
* Особенности: может иметь свой заголовок. Может встречаться несколько раз на странице.
* Типовые ошибки: считать тегом для «боковой панели» и размечать этим тегом основной контент, который связан с окружающими его элементами.
####
* Значение: навигационный раздел со ссылками на другие страницы или другие части страниц.
* Особенности: используется для основной навигации, а не для всех групп ссылок. Основной является навигация или нет — на усмотрение верстальщика. Например, меню в подвале сайта можно не оборачивать в . В подвале обычно появляется краткий список ссылок (например, ссылка на главную, копирайт и условия) — это не является основной навигацией, семантически для такой информации предназначен сам по себе.
* Типовые ошибки: многие считают, что в может быть только список навигационных ссылок, но[согласно спецификации](https://html.spec.whatwg.org/multipage/sections.html#the-nav-element) там может быть навигация в любой форме.
####
* Значение: вводная часть смыслового раздела или всего сайта, обычно содержит подсказки и навигацию. Чаще всего повторяется на всех страницах сайта.
* Особенности: этих элементов может быть несколько на странице.
* Типовые ошибки: использовать только как шапку сайта.
####
* Значение: основное, не повторяющееся на других страницах, содержание страницы.
* Особенности: должен быть один на странице, исходя из определения.
* Типовые ошибки: включать в этот тег то, что повторяется на других страницах (навигацию, копирайты и так далее).
####
* Значение: заключительная часть смыслового раздела или всего сайта, обычно содержит информацию об авторах, список литературы, копирайт и так далее. Чаще всего повторяется на всех страницах сайта.
* Особенности: этих элементов может быть несколько на странице. Тег не обязан находиться в конце раздела.
* Типовые ошибки: использовать только как подвал сайта.
### Как разметить страницу с точки зрения семантики
Процесс разметки можно разделить на несколько шагов с разной степенью детализации.
1. Крупные смысловые блоки на каждой странице сайта. Теги: `, ,` .
2. Крупные смысловые разделы в блоках. Теги: `, , ,` .
3. Заголовок всего документа и заголовки смысловых разделов. Теги: `-
=`.
4. Мелкие элементы в смысловых разделах. Списки, таблицы, демо-материалы, параграфы и переносы, формы, цитаты, контактная информация и прогресс.
5. Фразовые элементы. Изображения, ссылки, кнопки, видео, время и мелкие текстовые элементы.
### Сомневаюсь, какие теги использовать
Есть простые правила для выбора нужных тегов.
* Получилось найти самый подходящий смысловой тег — использовать его.
* Для потоковых контейнеров — .
* Для мелких фразовых элементов (слово или фраза) — .
Правило для определения `,` и :
1. Можете дать имя разделу и вынести этот раздел на другой сайт? —
2. Можете дать имя разделу, но вынести на другой сайт не можете? —
3. Не можете дать имя? Получается что-то наподобие «новости и фотогалерея» или «правая колонка»? —
### Как точно не нужно делать
Не используйте семантические теги для украшательств. Для этого есть CSS.
Может показаться, что некоторые теги подходят для того, чтобы сделать страницу покрасивее, подвигать текст или добавить ему интервалов. Но то, что браузер по умолчанию отображает теги как-то, как вам нужно, не значит, что это нужно использовать. Посмотрим на пример.
Здесь сразу несколько ошибок:
1. Тег должен использоваться для выделения в тексте цитат, а не просто случайного выделения текста. Так совпало, что в браузерах этот блок по умолчанию выделен, но это не значит, что нужно его использовать таким образом.
2. Тег тоже использован для визуального «сдвига» текста. Это неверно, потому что этот тег должен быть использован только для обозначения списков, а во-вторых, в тег можно вкладывать только теги `-` и ничего больше.
3. Тег использован, чтобы визуально раздвинуть текст. На самом деле этот тег используется для выделения параграфов.
А любое выделение, сдвиг или иные превращения текста можно выполнить с помощью CSS.
Поэтому используйте семантические теги по назначению.
---
Более подробно методика создания семантической разметки описана в навыке «[Создание семантической разметки по макету](https://htmlacademy.ru/skills/semantic-markup?utm_source=habr&utm_medium=special&utm_campaign=semantic110321%09%09%09%09%09%09)» и курсах HTML Academy. Можно начать с [бесплатных тренажёров](https://htmlacademy.ru/courses/intro-to-web-development?utm_source=habr&utm_medium=special&utm_campaign=semantic110321) по основам HTML и CSS или с курса «[Профессиональная вёрстка сайтов](https://htmlacademy.ru/intensive/htmlcss?utm_source=habr&utm_medium=special&utm_campaign=semantic110321)». А с промокодом SKUCHNO цена станет ещё приятнее.
В конце концов, один раз живём. | https://habr.com/ru/post/546500/ | null | ru | null |
# Операция TaskMasters: как мы разоблачили кибергруппировку, атакующую организации России и СНГ
[](https://habr.com/ru/company/pt/blog/451566/)
*Изображение: [Unsplash](https://unsplash.com/photos/FCrYdP8gohg)*
Осенью 2018 года эксперты PT Expert Security Center выявили активность преступной группировки, деятельность которой была направлена на хищение конфиденциальных документов и шпионаж. Сегодня мы расскажем о ходе расследования, а также опишем основные методы и инструменты, которые применяла группировка.
*Примечание*: По ссылке представлен [полный отчет](https://www.ptsecurity.com/ru-ru/research/analytics/operation-taskmasters-2019/) о расследовании. В нем также приведены индикаторы компрометации, которые могут быть использованы для выявления следов атаки.
Кого атакует группировка, и когда ее обнаружили
-----------------------------------------------
Группировка была выявлена экспертами PT Expert Security Center в 2018 году. Преступники использовали необычный метод закрепления в инфраструктуре, основанный на создании специфических заданий (тасков) в планировщике задач – поэтому специалисты PT ESC назвали группировку TaskMasters.
Планировщик задач позволяет выполнять команды ОС и запускать ПО в определенный момент времени, указанный в задаче. Причем используемый данной группировкой планировщик AtNow позволяет выполнять задачи не только локально, но и на удаленных компьютерах сети, и делать это независимо от временных настроек этих узлов. Кроме того, эта утилита не требует установки. Эти особенности упрощают автоматизацию атаки.
Хакеры взламывали компании из разных стран, при этом значительное число жертв находилось в России и СНГ. Большинство атакованных компаний можно отнести к сфере промышленности. Всего нам известно о компрометации более 30 организаций различных отраслей, включая энергетический и нефтегазовые секторы и органы государственной власти.
Основной целью группы является кража конфиденциальной информации. Злоумышленники стараются закрепиться в корпоративной информационной системе на длительное время и получить доступ к ключевым серверам компании, рабочим станциям высшего руководства, критически важным бизнес-системам.
Наиболее ранние следы присутствия группировки в инфраструктуре датировались 2010 годом, и на тот момент преступники уже полностью контролировали некоторые серверы и рабочие станции, а значит проникновение произошло намного раньше.
Азиатский след
--------------
В коде на GitHub веб-шелла ASPXSpy2014, который использовался при атаке, имеются ссылки на китайских разработчиков. Однако обнаруженная нами версия содержит вместо этого ссылку на google.ru.
*ASPXSpy: публичная и используемая в атаке версии*
В запросах к веб-шеллам были выявлены IP-адреса, принадлежащие хостинг-провайдеру и типографии в Восточной Европе. Но в событиях журнала прокси-сервера одной из атакованных организаций был отражен момент переключения злоумышленников на резидентный китайский IP-адрес 115.171.23.103, что, вероятнее всего, произошло из-за отключения программного VPN в момент атаки.
В ходе атаки злоумышленники пользовались копией архиватора WinRAR, который был активирован ключом, широко распространенным на форумах, пользователи которых общаются на китайском языке.
*Лицензионная версия WinRAR в ресурсах ПО*
*Лицензионный ключ от WinRAR, опубликованный на китайских форумах*
В одной из задач использовался домен Brengkolang.com, зарегистрированный через китайского регистратора. Также многие утилиты содержат сообщения об ошибках и другую отладочную информацию, написанные на английском языке с ошибками, что может указывать на то, что он не является родным для разработчиков.
Как действуют злоумышленники
----------------------------
Общий вектор атаки достаточно предсказуем. После проникновения в локальную сеть злоумышленники исследуют инфраструктуру, эксплуатируют уязвимости систем (например, [CVE-2017-0176](https://nvd.nist.gov/vuln/detail/CVE-2017-0176)), затем загружают на скомпрометированные узлы и распаковывают набор утилит. С помощью этого набора они ищут, копируют и архивируют интересующие их файлы, а затем отправляют их на управляющие серверы.
Для перемещения по сети преступники выполняют системные команды на удаленных узлах при помощи утилиты AtNow, которая позволяет запускать ПО и выполнять команды по прошествии заданного временного интервала. Для управления узлами используют небольшие бэкдоры, через которые осуществляют подключение к управляющим серверам. При этом существуют и резервные каналы в виде веб-шеллов, загруженных на внешние ресурсы, например, на сервер Exchange.
*Схема атаки*
Группа использует инфраструктуру Dynamic DNS для своих доменов. Злоумышленники пользуются большим набором утилит и инструментов для проведения кибератак и активно применяют схему supply chain attack.
Для сканирования сети и компрометации систем злоумышленники используют свободно распространяемое ПО (в том числе NBTScan, PWDump, Mimikatz). Помимо сторонних инструментов, применяются и программы собственной разработки.
Основное ПО группировки TaskMasters, с помощью которого они контролировали зараженные узлы, состоит из двух компонентов:
* RemShell Downloader — загрузчик,
* RemShell — ПО с основным набором функций.
Рассмотрим подробнее каждый из компонентов.
RemShell Downloader
-------------------
Данный компонент вредоносного ПО предназначен для доставки основной полезной нагрузки в атакуемую систему. Общая схема работы загрузчика показа на рисунке ниже.
*Схема работы загрузчика RemShell*
Загрузчик обращается к HTML-странице по адресу, заранее указанному в его коде, и читает значение атрибута Attribute тега HTML:
*Пример HTML-файла*
Затем прочитанное значение расшифровывается, и в зависимости от того, что там содержалось, загрузчик либо переходит в режим ожидания (команда Sleep), либо сохраняет PE-файл на диск и запускает его. Загруженный PE-файл как раз и является полезной нагрузкой — основным трояном RemShell.
Троян RemShell
--------------
RemShell — основное вредоносное ПО, которое использовалось злоумышленниками для контроля зараженных узлов, предоставляет атакующим следующие возможности:
1. Терминал для удаленного управления узлом (cmd shell).
2. Загрузка файлов на удаленный узел.
3. Загрузка файлов с удаленного узла на управляющий сервер.
Троян использует два управляющих сервера. Первый выполняет роль посредника или прокси, который по запросу вредоносного ПО предоставляет адрес основного управляющего сервера. Также с первого управляющего сервера может быть получена команда для перевода вредоносного ПО на другой управляющий прокси-сервер.
*Переход с первого управляющего сервера к основному*
Мы находили различные вариации данного вредоносного ПО. В одних, например, отсутствовала команда для загрузки файлов с узла на управляющий сервер — в таких случаях злоумышленники использовали утилиту собственной разработки для выгрузки файлов. В других были добавлены команды, позволяющие получить список процессов, запущенных в системе, и завершить процесс по PID (идентификатору процесса).
Конфигурационные данные, такие как адрес управляющего прокси-сервера, порт, user-agent, зашифрованы с помощью RC4 и заданы константами в коде вредоносного ПО.
Данные, пересылаемые между управляющими серверами и вредоносным ПО, зашифрованы с помощью алгоритма RC4 и дополнительно закодированы Base64. Ключ для RC4 генерируется с помощью константной строки путем расчета MD5-хеша. Результат выполнения команд, полученных от управляющего сервера, отправляется в виде HTTP-запроса по URL-адресу со специфичным префиксом 1111.
Также во вредоносном ПО предусмотрен механизм Heartbeat, который через случайные промежутки времени «отстукивает» HTTP-запросом, содержащим результат работы команды hostname, по заданному URL-адресу со специфичным префиксом 0000.
*Heartbeat*
Управляющие серверы
-------------------
Серверная часть для управления вредоносным ПО на зараженных узлах представлена консольными ELF-файлами. Интерфейс управления сервером выполнен в виде шелла и поддерживает команды, представленные на рисунке ниже.
Сервер подробно журналирует все команды, отправленные на удаленный узел. Эти журнальные файлы хранятся на диске в зашифрованном виде. Для шифрования файлов журнала используется алгоритм RC4.
Нам удалось проанализировать несколько экземпляров серверной части вредоносного ПО. В одном случае мы нашли упоминание о разработчике AiMi, отсылки к которому мы встречали в других инструментах группировки TaskMasters.
*Упоминание разработчиков в выводимой скриптом информации*
Веб-шелл 404-input-shell
------------------------
Окно авторизации для доступа к функциональности веб-шелла замаскировано под стандартную страницу ошибки 404 веб-сервера IIS. Чтобы получить доступ к командной строке и выполнять команды, нужно ввести пароль. Поле для ввода пароля скрыто и отображается, если нажать ссылку Back.
```
Click the [Back](#) button to try another link.
```
Для авторизации злоумышленники использовали пароль 0p;/9ol. — такой же пароль они применяли для шифрования архивов. В коде веб-шелла содержится MD5-хеш этого пароля.
Всего в рамках расследований нами было обнаружено три модификации данного веб-шелла. Они различаются функциональностью: один из них используется только для выгрузки файлов с сервера, другой — для загрузки файлов на сервер, третий — для выполнения команд ОС.
Заключение
----------
Наше исследование показывает, что киберпреступники могут преследовать не только сиюминутные финансовые цели. Все чаще они стремятся к получению доступа к данным и захвату контроля информационных потоков организаций.
Жертвами кибершпионажа могут стать компании различных секторов экономики. Для того чтобы понять, как защищаться от подобных атак, необходимо использовать специализированные средства. Также на этапе расследования важно детально изучить тактики, примененные атакующими. Решить эту задачу своими силами организациям довольно трудно, поскольку для этого требуются не только продвинутые инструменты, но и ИБ-специалисты с высокой квалификацией. Внедрение рекомендаций, полученных от профессионалов в области безопасности, повысит уровень защищенности инфраструктуры и усложнит ее взлом. | https://habr.com/ru/post/451566/ | null | ru | null |
# Краткий очерк истории Lisp машин
Привет, Хабр!
В некоторых статьях я замечал, что авторы обещали рассказать про историю Lisp машин, но так и не рассказали. Возможно, эта короткая статья будет интересна любителям истории IT.
Да, на свете было мало машин с аппаратной поддержкой лямбда исчисления — около 7000 штук в мире по состоянию на 1988 год. А сейчас гораздо меньше, конечно же. На самом деле Лисп машины сыграли довольно сильную роль в истории информационных технологий. Благодаря этим странным компьютерам мир получил такие технологии, как лазерная печать и многооконный GUI.
#### Предыстория
В 1930-х годах некоторые математики пытались осознать и анализировать понятие вычислимости. Одну из таких попыток сделал Алонзо Чёрч, создав λ-исчисление. Писать здесь про него я не буду — слишком большая тема. Предполагается, что вы хотя бы знаете это слово :).
Исчисление исчислением, но надо бы его применить. Когда начались работы в области искусственного интеллекта, возникла потребность в языке программирования, позволявшем адекватно решать задачи в этой области. В это время Джон Маккарти работал в MIT и с 1958 по 1963 года разрабатывал Lisp, взяв за основу IPL, предназначавший для реализации ИИ, способного автоматически выводить теоремы математической логики. Первая версия интерпретатора Lisp работала на IBM 704. В 1960 Lisp был портирован на PDP-1. В общем, Лисп распространение получил. Была только одна проблема — Лисп работал довольно медленно на классическом (то есть стандартной архитектуры в данном контексте) компьютере. Прежде чем перейти к самой истории Лисп машин, желательно поверхностно рассмотреть их архитектуру.
#### Теория Лисп-машины
Возьмем сферическую реализацию Лисп машины и взглянем на неё. Как мы уже знаем, программируют её на Lisp'е. Конечно же, процессор не исполняет Lisp код напрямую, но микрокод и стэковая машина оптимизированы для исполнения кода. Это позволяло спокойно работать и с рациональными, и с комплексными числами. ОС использует виртуальную память для обеспечения достаточно большого адресного пространства, а сборщик мусора автоматически удаляет ненужные предметы из памяти, освобождая место для новых вещей (ну про это вы точно знаете, суть в том, что сборщик мусора таки реализован). Архитектура машины относится к tagged arch., я сейчас вкратце поясню, что это такое, так как информации про нее на русском крайне мало.
Tagged (помеченная?) архитектура предпологает, что каждое слово в памяти содержит в себе так называемую метку, делящая слово на две части — в первой части содержится сама информация, вторая часть описывает, каким образом её следует интерпретировать, а также CDR код, упрощающий сборку мусора в разы. Хватит теории, перейдем к «железу».
#### Аппаратные реализации λ-исчисления
Наступил 1973 год. В лаборатории ИИ при Массачусетском институте всерьез задумались над созданием архитектуры компьютера с аппаратной поддержкой LISP, поскольку в те времена исполнение LISP программы на компьютере стандартной архитектуры было занятием не для слабонервных. Типизация одной переменной могла занимать несколько минут, поскольку выполняется она во время исполнения программы, а не её компиляции. Дело создания «чудо-архитектуры» поручили двум программистам — Гринблэтту и Найту.
«Черновая» 24-битная версия архитектуры была названа в честь оператора конструирования списков и называлась CONS. Именно по этой машинке Найт защищал свою докторскую диссертацию. В дальнейшем архитектуру этой машины улучшили и назвали CADR (в честь лисп-функции cadr). Но одно дело разработать архитектуру, а другое дело — создать компьютер. И тут на арену выходит Symbolics, Inc.
#### Symbolics, Inc.
Symbolics, Inc. была основана Русселом (Russell Noftsker) в Массачусете, в дальнейшем она переместилась в Калифорнию. Компания занималась производством LISP-машин, а также написанием ПО для них. Она была не единственной компанией, производящей странные компьютеры, кроме неё, этим же делом занималась Lisp Machines, Inc, но на стороне Symbolics было большее количество специалистов и желания. Кстати, symbolics.com был, возможно, первым Интернет доменом в зоне .com.
В 1981 данной компанией была создана первая и последняя 32-битная машина CADR архитектуры — CADR LM-2 с 1МБ RAM на борту. ОС и приложения для нее писались, как ни странно, на самом Lisp'е, а если быть точнее, то на его диалекте Lisp Machine Lisp. В 1982 была создана операционная система Open Genera и портирован Emacs (Zmacs), стало возможным работать на LISP-машине и показывать жалким людишкам всю мощь лямбда-исчисления.
Именно в Open Genera и Lisp Machine OS появились множество вкусных плюшек, таких как сборщики мусора, менеджер виртуальной памяти, многозадачная GUI, отладчик и поддержка Chaosnet.
В результате перепалок между MIT и Symbolics по поводу лицензий (как вы уже поняли, здесь побывал и Ричард Столлман), их сотрудничество закончилось где-то около 1983 года. А Ричард, как ни в чем ни бывало, организовал свою шайку LISP-хакеров, состоящую преимущественно из MIT-людей.
В 1983 Symbolics представила первую модель новой линейки LISP машин — Symbolics 3600, размером с домашний холодильник, основанный на CADR архитектуре. Конечно же, не обошлось и без новшеств. Помимо «инновационного» нового дизайна машинки получили аппаратную поддержку сборщика мусора и виртуальной памяти. Процессор стал 36-битным, память же оперировала 44 битными словами, из них 8 бит служили для коррекции ошибок (ECC). Архитектура 3600 содержала в себе 4096 регистров (CISC, привет!), из которых половина использовалась для стэка вызовов, а другая половина — микрокодом и любящими время программами, а так же драйверами (Кстати, насколько я знаю, понятие драйвера было введено в процессе создания Lisp-машин).
3600 был построен на TTL интегральных схемах и имел частоту около 5МГц. Не густо, но с учетом аппаратной поддержки LISP в то время было очень даже густо. Поддержка Chaosnet была прекращена, отныне Symbolics поддерживала только Ethernet. Всего за три года было выпущено пять представителей линейки 36хх — 3600, 3670, 3640, 3675 и 3645. Последующие модели отличались только количеством мегагерц и прочих цифр, особых изменений в архитектуре не было.
Представители линейки 3600 были очень популярны в сфере исследования искусственного интеллекта. Кстати говоря, машины 3600 линейки были способны обрабатывать видео HDTV качества, что и послужило причиной их популярности в Японии.
В 1988 эта же компания представила миру линейку Ivory, первым представителем которого был XL400. Эти же компьютеры были уже 40-битными и позволяли адресовать 16ГБ памяти. Чипы архитектуры Ivory производили VLSI и Hewlett Packard, а использовали их, помимо самой Symbolics, также Sun и Apple (да-да, Lisp-процессор использовался и в Макинтошах, правда, не в качестве основного ).
Давайте попробуем взглянуть на ассемблерный исходник для процессоров Ivory:
```
ENTRY: 2 REQUIRED, 0 OPTIONAL
PUSH 0
PUSH FP|3
PUSH NIL
BRANCH 15
SET-TO-CDR-PUSH-CAR FP|5
SET-SP-TO-ADDRESS-SAVE-TOS SP|-1
START-CALL FP|2
PUSH FP|6
FINISH-CALL-1-VALUE
BRANCH-FALSE 15
INCREMENT FP|4
ENDP FP|5
BRANCH-FALSE 6
SET-SP-TO-ADDRESS SP|-2
RETURN-SINGLE-STACK
```
Что равносильно следующему коду на Lisp:
```
(defun example-count (predicate list)
(let ((count 0))
(dolist (i list count)
(when (funcall predicate i)
(incf count)))))
```
Неплохо, да? Как вы видите, мнемоники были довольно длинными, это даже и ассемблером сложно назвать в привычном моем понимании. Если вам интересна суть ассемблера Ivory и других машин, можете глянуть документы на bitsavers.org. Там же есть много других мануалов Symbolics.
Стоит упомянуть и попытку компании создать RISC процессор на базе Ivory — Sunstone. Но проект был свернут. К LISP машинам также приложили свою руку BBN и Xerox. Творением BBN являлась машина Jericho, которая программировалась на Inerlisp. Данное творение никогда не продавалось. Xerox Parc же в 1980-х создал свою Xerox Lisp Machine, которая известна тем, что имела полноценную среду разработки InterLisp-D и первое Hypertext приложение (NoteCards).
Известны удачные попытки создания LISP машин японскими инженерами, из таких машин можно назвать TAKITAC-7 и EVLIS, разработанный в университете Осака. К сожалению, про них я ничего в данный момент рассказать не могу.
##### The End
Но ничто не могло остановить все увеличивающуюся мощь классических компьютеров. Аппаратная поддержка лямбда-исчисления стала ненужной. В конечном итоге Symbolics обанкротилась, а к 1995 году закончилась эра LISP машин. Но мы их не забудем, правда же? :)
В заключение хочу сказать, что лисп-машины — это не единственная попытка сделать компьютер с аппаратной поддержкой языка Х. Существовали реализации Prolog и Java машин, но об этом как нибудь в другой раз. Спасибо за прочтение :).
P.S. Если увидите неточность или ошибку, сообщите в личку. | https://habr.com/ru/post/190082/ | null | ru | null |
# NativeScript, что за зверь и для чего он нужен?
Доброго времени суток, хабражители, меня зовут Владимир Миленко, я frontend-инженер в компании Иннософт, географически расположенной в городе Иннополис и являющейся резидентом особой экономической зоны г. Иннополис.
Сегодня я поведаю о таком звере, как NativeScript(да, он изменился, да, сильно). NativeScript — фреймворк для кроссплатформенной разработки, придерживающийся концепции write once — use everywhere, и, возможно, у него получилось!
Что ты такое?
-------------
Начнем с простого, {N} это JS, который запускается на JSVM, специфичной для каждой системы(V8 для Android, WebKit iOS). И все-бы было бы грустно, если бы не одно но — NS предоставляет доступ ко всем системным API.
Т.е.
```
let card = new com.google.android.support.v7.widget.CardView(someContext);
```
— Валидный {N} код, который создаст proxy-объект, все обращения к которому будут вызывать нативные методы и возвращать результат от них.
Фактически, код выше показывает обращение к нативной подключаемой библиотеке для Android. В большинстве случаев такой длинный вызов вы напишете всего один раз при создании nativescript-плагина.
Execution flow в NativeScript выглядит следующим образом:
*\*Изображение взято с официальной документации NativeScript*
В принципе, до момента релиза Angular 2, {N} имел весьма увесистые минусы, разметка описывалась с помощью xml, а весь функционал приходилось писать самому. Но при этом, {N} развивался и появились модули, позволяющие абстрагироваться от ОС, и использовать большинство стандартных фич, не заботясь о том, как конвертируются в нативные методы.
Например, следующий код будет выполнен нативными методами проверки существования файла.
```
import fs = require(“file-system”)
let exists = fs.File.exists(“abc.ini”); // будет вызван соответствующий нативный метод, после чего boolean из Java конвертируется в JS boolean.
```
В общем и целом, {N} — JS+XML, работающий на JSVM и позволяющий вызывать нативные методы из JS. При этом есть возможность использовать разметку ввиде XML и использовать некий сабсет CSS, а еще применять анимации и прочее.
Почему не ReactNative?
----------------------
//здесь раньше было маленькое сравнение с React.Native, но ввиду моей ошибки я его убрал. Спасибо комментаторам.
Плюсы NativeScript:
Поддерживает все компоненты из AndroidArsenal и Cocoapods.
Поддерживает вызов нативных методов из нативных библиотек.
Минусы:
Эти вызовы придется декларировать, т.е. описать библиотеку(что в общем и целом не обязательно, достаточно описать лишь те методы, которые вы вызываете)
Главное преимущество — Angular 2 + NS
-------------------------------------
С выходом Angular 2 мир веба сотрясся, в т.ч. тряслись те, кто писал на rc версиях и изменял добрую половину кода под новый rc.
Команда проделала очень большуй работу и сделала Angular 2 максимально кастомизируемым. Хочешь переопределить рендер — пожалуйста, это-то и сделали ребята из Telerik.
Что же нам дает возможность писать приложения на Angular 2 + TypeScript + NativeScript? А дает это нам тот самый code-sharing, возможность использовать огромное количество фич ангуляра.
Теперь вы можете шарить ваши сервисы между веб-компонентом и между tns-компонентом.
Рассмотрим небольшой пример шаблона:
Здесь можно заметить директиву ngFor, что позволяет наиболее удобно выводить коллекцию, если же вам необходим ListView — там это делается с помощью шаблона, т.е. android разработчикам можно забыть про ViewHolder’ы и прочее.
А вот так этот код будет выглядеть на Android:
А вот так на iOS:
Также в разметке можно заметить platform-specific разметку, специфичную для каждой платформы:
```
```
И раз уж заговорили о разметке, то нельзя не упомянуть two-way binding, который мы получаем с помощью angular 2:
Т.е. если описать переменную name в классе компонента, то чтобы привязать её к текстовому полю нужно написать вот такой код:
И к слову об анимации, вы можете описывать её с помощью css keyframes, использовать библиотеку keyfraymes или же оперировать через Promise.
Вот так выглядит анимация через Promise:
```
let view = this.page.getViewById("grid");
view
.animate({backgroundColor: new Color("#efefef"), duration: 75})
.then(
() => {
view.animate({backgroundColor: new Color("white"), duration: 75});
}
);
```
На этом небольшое интро подойдет к концу, опрос вы найдете чуть ниже.
Для того, чтобы понять, как Telerik смог использовать ангуляр рекомендую [посмотреть выступление](https://www.youtube.com/watch?v=eqJDM8PV-lE&index=4&list=PLuhR-xNwqdQhyCGY_1SW2olVDSG5VBoxd) Алексея Охрименко с GDG Perm.
→ [NativeScript](http://nativescript.org/)
**P.S.** Разрабатывают NativeScript компания Telerik, которая является частью Progress. Это к слову о комментарие чуть ниже. | https://habr.com/ru/post/318950/ | null | ru | null |
# Кто умнее тот и прав — Записки Хакера часть 1 из 5
Вашему вниманию предлагается увлекательное чтение, навеянное постами прошлой недели из жизни советских хакеров.
Всего планируется 5 выпусков, в зависимости от того, как хабрасообщество их воспримет.
Эти истории были подслушаны в вагоне поезда Москва-Питер примерно полгода назад, и рассказаны в сильном упитии двумя приятелями, путешествующими вместе со мной в одном купе.
Замечу сразу, с тех пор мы не общались, а в поезде мы встретились первый раз в жизни. Так что все попытки аффилировать меня с этими двоими — дохлая затея, я никакого отношения к их поступкам не имел, не имею, и, надеюсь, не буду иметь, но все же истории, которые они рассказали, могут быть вам интересны.
Повествование я буду вести как будто от своего лица, так удобней.
Все названия вымышленные и не должны совпадать с реальными, также, для эпохальности, добавлены краски.
Итак, начнем.
Первая наша история датирована 97 годом, эпохой диалапов и компьютерных клубов. Я все еще учился в школе, и частенько, забивая на уроки, мы с другом наведывались в популярный в то время компьютерный клуб «Орки». Если кто помнит, сначала он располагался в районе м. Октябрьская, потом, после знаковой игры налоговой в Диабло в течении 3 суток, переехали на м. Шаболовская. Именно туда мы и направились. В этот день, хотя нас это мало волновало, там планировался какой-то чемпионат по Q2, с огромным по тем временам призовым фондом, суммы не помню.
Собственно, мы оплатили пару часов и устроились за компьютерами. Это были машинки с Win98 на борту, а вся сеть представляла собой стандартную «рабочую группу». На тот момент компьютеров было там порядка 100. Надо заметить, что они частенько зависали и геймеры их постоянно перезагружали. Этим, в том числе, мы и решили воспользоваться в своих целях.
Оказалось, что на любой компьютер из рабочей группы довольно легко было попасть через сетевое окружение, если в качестве шары указывать что-то типа C$, попадая непосредственно в корень системного диска.
Далее, дело техники — прописываем
`format c: /q /autotest > null в autoexec.bat`
и ждем когда компьютер повиснет, чтобы его перезагрузили. Таким образом, минут за 20 из нашего оплаченного часа, мы окучили все компьютеры в клубе. Чем же заняться оставшиеся 40 минут? Надо сказать, что мы были единственными, кто играл в Q1 — все играли в Q2 и старкрафт, вроде. Как впоследствии оказалось, это сыграло самую непосредственную драматическую роль.
В общем, нам стало скучно, и мы решили «убыстрить» процесс. Соседние компьютеры пустовали, и мы сами нажали на ресет.
Игроки прибывали. Им доставался новые, свободные компьютеры. Как ни удивительно, но они не работали! Игроки звали на помощь.
Пришел суппорт. Долго втыкал, потом достал какой-то баллон из-за пазухи. Мы, к своему стыду, такого никогда не видели. Это оказался баллон с сжатым воздухом. Суппорт начал активно продувать весь комп, особенное внимание уделяя жесткому диску. Нам стоило огромных усилий не заржать.
Проблема началась тогда, когда наше злодейство перешло во вторую фазу, и, буквально, улучив момент, когда суппорт отвернулся, ребутали следующую машину, прямо рядом с ним. Всё старались делать незаметно, идиоты.
Началась массовая эпидемия. Суппорта просто офигевали, наблюдая как каждую минуту из строя выходил все новый и новый комп.
Мы поняли, что пора уходить.
Маленькое лирическое отступление — у местного админа ник был Z. Типа Зед.
И вот, конец истории уже близок, мы приближаемся к выходу из клуба, и тут я, припоминая замечательную цитату из Pulp Fiction, довольно громко говорю, обращаясь к своему другу:
«Z's dead, baby. Z's dead».
Уже через 2 секунды силами всех сотрудников клуба мы оказались прижаты к стенке в довольно неудобных позах. Нас затолкали в какой-то коридор, держали, кричали: «Кто вас послал??».
Мы понять не могли, с чего они взяли, что нас вообще кто-то посылал…
Они решили, что это происки конкурентов, которые хотели сорвать им чемпионат. Нас проводили в какую-то комнату, где непосредственно сидел их админ. К тому моменту мы были напуганы, не забывайте, мы были всего лишь в 9-ом классе. Пока хозяин клуба делал вид, что вызывает ментов, он допросил нас, узнал домашние телефоны, и позвонил по ним, чтобы проверить, реальные ли это номера. Время было уже позднее, мы давно должны были вернуться домой, и представляете, когда дома, мама, вечером, получает звонок с вопросом: «Здравствуйте, будьте добры Ивана к телефону»…
Админ выяснял, как же это нам удалось. Так получилось, что в процессе демонстрации мы грохнули и его машину тоже. Слава богу, он оказался адекватным и понял, что наш лозунг «кто умнее тот и прав» не пустой звук. Короче говоря, нам удалось договориться о «фиксации суммы ущерба» — клуб простаивал всю ночь, пока восстанавливали компьютеры, и сумма составила что-то в районе 300 баксов. Для нас, школьников, с 100 рублями в день на еду максимум, это была невероятная сумма.
Тем не менее, на следующий день, мы позаимствовали несколько убитых винчестеров из кабинета информатики в школе, конкретно WD Caviar, и отдали их утром уже подобревшему Z'у, в надежде, что он их не проверит.
Конец.
В следующих выпусках вас могут ждать: [«атака на терминалы крупнейшего магазина компьютерной техники в районе Совка»](http://habrahabr.ru/blogs/infosecurity/86887/), «провайдер с откровенной рекламой и дефолтным snmp-коммьюнити», «провайдер, забывший удалить файлик demo.php из стандартной поставки spaw»,«маленький провинциальный провайдер и гроза на заказ». | https://habr.com/ru/post/86880/ | null | ru | null |
# Тестирование в 1C Bitrix
### Предисловие
Говоря о разработке сайтов с использованием CMS 1C Bitrix вопрос покрытия тестами поднимается редко. Главная причина в том, что большинство проектов обходится штатным функционалом, который предоставляется системой - его сложно (да и, в общем-то, незачем) тестировать.
Но со временем проект разрастается, появляется необходимость интеграции со сторонними сервисами и службами (платежные системы, API служб доставки и другие), либо же разрабатывается все более и более специализированный функционал. И чем дальше, тем больше объем кода, контроль за которым лежит уже на разработчике.
Это и является предпосылкой для внедрения в CMS механизма тестирования.
Процесс подготовки окружения к написанию тестов состоит из нескольких шагов:
1. установить Composer;
2. настройка Bitrix для работы с Composer;
3. установить PHPUnit;
4. настроить PHPUnit для работы с Bitrix.
### Composer
УстановкаУстановку composer проводим по [инструкции](https://www.digitalocean.com/community/tutorials/how-to-install-and-use-composer-on-ubuntu-18-04).
```
cd ~
curl -sS https://getcomposer.org/installer -o composer-setup.php
HASH=Хеш файла
php -r "if (hash_file('SHA384', 'composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
```
По завершению - в консоли видим сообщение, что установщик скачан успешно:
```
Installer verified
```
Переходим к установке:
```
sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer
```
По окончанию видим сообщение о успешной установке:
```
Output
All settings correct for using Composer
Downloading...
Composer (version 2.1.9) successfully installed to: /usr/local/bin/composer
Use it: php /usr/local/bin/composer
```
Всю работу с зависимостями организуем в каталоге **local**. Инициализируем проект:
```
cd local
composer init
```
Указываем нужные параметры, подтверждаем.
По завершению у нас появляется файл /local/composer.json с примерно таким содержимым:
```
{
"name": "myproject/website",
"type": "project",
"authors": [
{
"name": "Andriy Kryvenko",
"email": "krivenko.a.b@gmail.com"
}
]
}
```
Теперь скажем битриксу, что надо использовать сторонние пакеты, установленные через Composer.
Открываем файл **/local/php\_interface/init.php** (создаем, если не существует) и подключаем файл autoload:
```
php
include_once(__DIR__.'/../vendor/autoload.php');</code
```
После этого скрываем каталог /local/vendor/ от системы контроля версий. В файл .gitignore добавляем /local/vendor/\*
### PHPUnit
Переходим к установке PHPUnit. На прод сервере он нам не нужен, поэтому устанавливаем только в качестве dev зависимости и создаем конфиг-файл. Для этого выполняем в командной строке:
```
composer require --dev phpunit/phpunit ^9.0
./vendor/bin/phpunit --generate-configuration
```
В dev-зависимости был добавлен phpunit, а так же создан файл /local/phpunit.xml
Помимо непосредственно PHPUnit, для более приятного вида результатов тестов я использую пакет [sempro/phpunit-pretty-print](https://packagist.org/packages/sempro/phpunit-pretty-print).
```
composer require --dev sempro/phpunit-pretty-print ^1.4
```
Теперь нужно создать файл, который будет использоваться при тестировании для инициализации ядра продукта. Назовем его **/local/tests/bootstrap.php**
```
php
define("NOT_CHECK_PERMISSIONS", true);
define("NO_AGENT_CHECK", true);
$_SERVER["DOCUMENT_ROOT"] = __DIR__ . '/../..';
require($_SERVER["DOCUMENT_ROOT"]."/bitrix/modules/main/include/prolog_before.php");</code
```
Настроим PHPUnit, чтобы использовался наш файл инициализации и наш класс декорации результатов. Откроем файл **/local/phpunit.xml** и приведем его к следующему виду:
phpunit.xml
```
xml version="1.0" encoding="UTF-8"?
tests
tests/Stubs
tests/Request
tests/Response
classes
```
И добавим команду для быстрого запуска тестов
composer.json
```
{
"name": "myproject/website",
"type": "project",
"authors": [
{
"name": "Andriy Kryvenko",
"email": "krivenko.a.b@gmail.com"
}
],
"require-dev": {
"phpunit/phpunit": "^9",
"sempro/phpunit-pretty-print": "^1.4"
},
"scripts": {
"test": "phpunit"
}
}
```
Теперь при выполнении команды
```
composer test
```
будут запускаться все тесты. На этом процесс настройки закончен и можно переходить к написанию тестов.
Перед тем, как продолжитьДля удобства свои классы лучше размещать в каталоге local/classes, примерно в следующем виде:
```
/local/classes/MyProject/Product.php
/local/classes/MyProject/Rests.php
```
И указать в файле /local/composer.json в секции **autoload** путь к каталогу:
```
{
"name": "myproject/website",
"type": "project",
"authors": [
{
"name": "Andriy Kryvenko",
"email": "krivenko.a.b@gmail.com"
}
],
"require-dev": {
"phpunit/phpunit": "^9",
"sempro/phpunit-pretty-print": "^1.4"
},
"scripts": {
"test": "phpunit"
},
"autoload": {
"psr-4": {
"": "./classes/"
}
}
}
```
### Пример теста
В качестве примера я покажу реальную ситуацию, ее решение и тесты, которые это решение покрывают (часть кода, не относящуюся непосредственно к преобразованиям, в пример не включаю).
Собственно, ситуация: из 1С на сайт в виде строк передается информация о доступных сроках поставки товара, например:
```
24 часа-7|до 2 дней-14|до 15 дней-неогр
```
При покупке до 7 штук - поставим за 24 часа, до 14 штук - за 2 дня, в другом случае - за 15 дней.
Нужно преобразовать их в объекты **Leftover** для дальнейшего использования. Преобразование выполняем с помощью **LeftoverTransformer**:
Leftover
```
php
namespace MyProject\Product\Requisites;
class Leftover
{
public int $time = 0;
/**
* Доступное количество для данного интервала.
* Если количество равно -1.0 - то подразумеваем, что товара неограниченное количество
*/
public float $quantity = 0.0;
public function __construct(int $time, float $quantity)
{
$this-time = $time;
$this->quantity = $quantity;
}
public function isAvailable(): bool
{
return ($this->quantity > 0 || $this->quantity == -1.0);
}
}
```
LeftoverTransformer
```
php
namespace MyProject\Product\Requisites\Transform;
use MyProject\Product\Requisites\Leftover;
class LeftoverTransformer
{
/**
* @param string $leftoversString
* @return Leftover[]
* Строку получаем в виде
* 24 часа-7|до 2 дней-14|до 7 дней-22|до 15 дней-неогр
*/
public static function transform(string $leftoversString): array
{
$leftovers = [];
$intervals = explode('|', $leftoversString);
foreach ($intervals as $v){
$interval = explode('-', $v);
$intervalValues = [];
foreach ($interval as $k = $part) {
$intervalValues[] = trim($part);
}
if (!empty($intervalValues[0]) && !empty($intervalValues[1])) {
$leftovers[] = new Leftover(
self::getTimeFromString($intervalValues[0]),
self::getQuantityFromString($intervalValues[1])
);
}
}
return $leftovers;
}
private static function getTimeFromString(string $timeString): int
{
switch ($timeString) {
case '24 часа':
$time = 1;
break;
default:
$parts = explode(' ', $timeString);
$time = intval($parts[1]);
break;
}
return $time;
}
private static function getQuantityFromString(string $quantityString): int
{
switch ($quantityString) {
case 'неогр':
$quantity = -1;
break;
default:
$quantity = intval($quantityString);
break;
}
return $quantity;
}
}
```
И покрываем эти классы соответствующими тестами:
LeftoverTest
```
php
namespace MyProject\Product\Requisites;
use PHPUnit\Framework\TestCase;
/**
* @covers Leftover
*/
class LeftoverTest extends TestCase
{
public function testIsAvailable(): void
{
$leftover = new Leftover(1, 12.0);
$this-assertTrue($leftover->isAvailable());
}
public function testAvailableUnlimited(): void
{
$leftover = new Leftover(1, -1.0);
$this->assertTrue($leftover->isAvailable());
}
public function testUnavailable(): void
{
$leftover = new Leftover(1, 0.0);
$this->assertFalse($leftover->isAvailable());
}
}
```
LeftoverTransformerTest
```
php
namespace MyProject\Product\Requisites\Transform;
use PHPUnit\Framework\TestCase;
/**
* @covers LeftoverTransformer
*/
class LeftoverTransformerTest extends TestCase
{
public function testEmpty(): void
{
$this-assertEmpty(LeftoverTransformer::transform(''));
}
public function testLeftoversCount(): void
{
$leftoverString = '24 часа-7|до 2 дней-14|до 7 дней-22|до 15 дней-неогр';
$leftovers = LeftoverTransformer::transform($leftoverString);
$this->assertCount(4, $leftovers);
}
/**
* @param string $leftoverString
* @param int $expectedTime
* @param float $expectedQuantity
* @return void
* @dataProvider leftoversProvider
*/
public function testLeftovers(string $leftoverString, int $expectedTime, float $expectedQuantity): void
{
$leftovers = LeftoverTransformer::transform($leftoverString);
$this->assertEquals($expectedTime, $leftovers[0]->time);
$this->assertEquals($expectedQuantity, $leftovers[0]->quantity);
}
public function leftoversProvider(): array
{
return [
'24 часа-7' => [
'24 часа-7',
1, 7.0
],
'до 2 дней-14' => [
'до 2 дней-14',
2, 14.0
],
'до 7 дней-22' => [
'до 7 дней-22',
7, 22.0
],
'до 15 дней-неогр' => [
'до 15 дней-неогр',
15, -1.0
]
];
}
}
```
Приведенный пример теста позволяет быть уверенным в том, что при работе с товарами мы всегда точно знаем, доступно ли к покупке то или иное количество товара и в какой срок.
#### upd
По совету из комментариев убрал ручную регистрацию автозагрузки и указал путь к классам в /local/composer.json | https://habr.com/ru/post/667160/ | null | ru | null |
# Автогенерация CSS Sprites
Свершилось. Долгие бессонные ночи не прошли даром и мысль, [заявленная Вадимом aka pepelsbey](http://habrahabr.ru/blogs/client_side_optimization/52539/#comment_1395595), обрела более-менее физические очертания.
[sprites.webo.in](http://sprites.webo.in/) (сырая-сырая альфа-версия) — название, собственно, говорит само за себя. Вводим URL CSS-файла — на выходе получаем архив с минимизированным (никакой сортировки селекторов, просто базовая минимизация) CSS-файлом и набором свеженьких спрайтов. Здорово?
[Алгоритм генерации CSS Sprites](http://webo.in/articles/habrahabr/08-all-about-css-sprites/) в общих чертах уже был описан. По ходу пришлось уточнить позиционирование для `no-repeat`-картинок: часть из них нужно располагать «лесенкой» (у которых не задан размер блока), а часть можно впихивать как придется (если размеры точно определены).
Для [vkontakte.ru](http://vkontakte.ru/) сходу получился [вот такой образец](http://i.webo.in/vkontakte.png).
Версия сырая, некоторые случаи не обрабатываются, некоторые — обрабатываются неверно. Соответственно, хочется услышать максимально большое число случаев, когда происходит какая-то «фигня». Сразу оговорюсь, что спрайты не создаются в ряде случаев. Во-первых, если уже в качестве фона используется спрайт (потому что разобрать такое изображение в случае с «лесенкой» вообще не представляется возможным). Во-вторых, если всего изображений, которые можно объединить по соответствующей группе, только 1. В-третьих, если изображение представляет собой анимацию. В-четвертых, если не удалось установить корректный `repeat` для элемента и не заданы размеры (тогда изображение будет повторяться по всем направлениям в неизвестном объеме — и его нельзя объединять еще с чем-то).
Самое интересное, конечно, как решается задача расположения изображений в «произвольном» спрайте — но об этом в следующий раз (когда немного уточнится алгоритм, последняя версия [всегда доступна в репозитории](http://code.google.com/p/web-optimizator/)).
И наконец, stand-alone версия будет включена в самое ближайшее время в Web Optimizer (Веб Оптимизатор) — приложение, направленное на автоматизацию клиентской оптимизации. Его всегда можно скачать по адресу: [code.google.com/p/web-optimizator/](http://code.google.com/p/web-optimizator/).
В общем, комментарии, замечания, тестовые случаи, желание помочь руками — все это welcome — [sprites.webo.in](http://sprites.webo.in/)
P.S. за последнюю неделю образовалась пара инвайтов — если нужно помочь хорошим людям, то пишите в приват | https://habr.com/ru/post/54283/ | null | ru | null |
# Лучший способ загрузки файлов в Ruby с помощью Shrine. Часть 1
*Это первая часть из серии постов о [Shrine](https://github.com/janko-m/shrine). Цель этой серии статей – показать преимущества Shrine над существующими загрузчиками файлов.*
---
Прошло уже больше года с того времени, как я начал разрабатывать Shrine. За это время Shrine получил много интересного функционала, экосистема значительно выросла и достаточно разработчиков начало использовать Shrine в продакшене.
Прежде чем углубиться в разъяснение преимуществ, нужно сделать шаг назад и рассмотреть подробно, что в первую очередь послужило мотивацией для разработки Shrine.
В особенности, я хочу рассказать о ограничениях существующих загрузчиков. Я думаю, что важно знать об этих ограничениях, чтобы вы могли сделать выбор, который наилучшим образом отвечает [требованиям](https://twin.github.io/evaluating-ruby-libraries).
Требования
==========
---
Требования были следующие:
1. Файлы на Amazon S3 должны загружаться напрямую
2. Обработка и удаление файлов должно выполнятся в фоновом режиме
3. Обработка может выполнятся в процессе загрузки
4. Интеграция с [Sequel](https://github.com/jeremyevans/sequel)
5. Возможность использовать с фреймворками помимо Rails
По моему мнению первые два пункта очень важны, поскольку они позволяют достичь оптимальной работы пользовательского интерфейса при работе с формами. Но последние два пункта также не должны остаться без внимания:
1. Использование Amazon S3 или аналогов, позволяет оптимизировать процесс загрузки файлов.
Это определенно имеет ряд преимуществ: снижается потребление ресурсов, горизонтальное масштабирование с инкапсуляцией хранилища, работа с облачными решениями типа Heroku, которые не предоставляют [возможности записи на диск](https://devcenter.heroku.com/articles/dynos#ephemeral-filesystem) и имеют ограничение на [время выполнения запроса](https://devcenter.heroku.com/articles/request-timeout).
2. Обработка и удаление файлов в фоновых задачах дает возможность работать с файлами [асинхронно](https://twin.github.io/file-uploads-asynchronous-world), независимо от того, храните ли вы файлы на локальной файловой системе или на внешнем хранилище, таком как Amazon S3, это значительно улучшит работу пользовательского интерфейса. Использование фоновых задач также необходимо для поддержания высокой пропускной способности вашего приложения, потому что воркеры не будут привязаны медленным запросам.
3. Обработка на в процессе загрузки отлично работает с небольшими файлами, особенно когда создаются несколько версий файлов, например, разные размеры для картинок. с другой стороны обработка при загрузке необходима и для больших файлов, таких как видео. Следовательно, нужна библиотека, которая может работать с любыми типами файлов.
4. Использование с ORM помимо ActiveRecord также является очень важным. Поскольку уже появились более функциональные и производительные ORM для Руби.
5. Наконец, в Ruby сообществе появились достойные альтернативы Rails. Нужна возможность легкой интеграции с любым веб-фреймворком.
Теперь пройдемся по существующим библиотекам и рассмотрим их основные недостатки с учетом требований.
Paperclip
---------
---
> Простое управление вложенными файлами для ActiveRecord
Мы стазу можем сказать — прощай Paperclip, поскольку есть сильная зависимость от ActiveRecord. Так как эта очень распространенная библиотека которая используется с ActiveRecord, давайте все же пройдемся по остальным требованиям.
### Прямая загрузка
Paperclip не имеет возможности прямой загрузки. Возможно использование [aws-sdk](https://github.com/aws/aws-sdk-ruby) для генерации ссылки и параметров для прямой загрузки на S3 и потом редактировать атрибуты модели, таким же образом, как при загрузке файла через Paperclip.
Однако, Paperclip работает только с одним хранилищем. Для работы необходимо чтобы все закачки происходили напрямую в основное хранилище S3. Это приводит к проблеме безопасности, поскольку атакующий может загружать файлы без прикрепления, и в итоге может создастся множество файлов-сирот. Было бы намного проще, если бы [S3 сделал это за вас](http://docs.aws.amazon.com/AmazonS3/latest/UG/lifecycle-configuration-bucket-no-versioning.html).
### Фоновые задачи
Для фоновых задач используется [delayed\_papeclip](https://github.com/jrgifford/delayed_paperclip). Однако, delayed\_paperclip запускает задачи только после полной загрузки файла. Это означает, что если вы не хотите или не можете делать прямые закачки на S3, ваши пользователи должны будут дважды загружать файл (сначала в приложение, затем в хранилище), прежде чем произойдет какая-либо фоновая обработка. И это очень медленно.
Кроме того, delayed\_paperclip не поддерживает удаление файлов в фоновом режиме. Это большой минус, потому что придется выполнять HTTP-запрос для каждой версии файла (если у вас есть несколько версий файлов, хранящихся на S3). Не ожидайте добавления этого функционала, поскольку [Paperclip также проверяет существование каждой версии перед удалением](https://github.com/thoughtbot/paperclip/issues/2281). Конечно же, вы можете отключить удаление файлов, но тогда у вас возникнет проблема с файлами-сиротами.
Наконец, [delayed\_paperclip теперь привязан к ActiveJob](https://github.com/jrgifford/delayed_paperclip/pull/178), что означает, что теперь не получится напрямую использовать его с библиотеками для фоновых задач.
### Ложное срабатывание обнаружения mime-type spoofing атаки
Paperclip имеет функционал обнаружения того, пытается ли кто-то подменить MIME-тип файла. Однако этот функционал, часто срабатывает ложно, это приводит к тому, что есть вероятность вызывать ошибку валидации, даже если расширение файла соответствует содержимому файла. Это является довольно решающим фактором, поскольку в данном случае ложное срабатывание может сильно раздражать пользователей.
Конечно можно отключить этот функционал, но это сделает приложение уязвимым для [атак при загрузки файлов](https://www.owasp.org/index.php/Unrestricted_File_Upload#Using_.E2.80.9CContent-Type.E2.80.9D_from_the_Header).
CarrierWave
-----------
---
> Отличное решение для загрузки файлов для Rails, Sinatra и других веб-фреймворков
[CarrierWave](https://github.com/carrierwaveuploader/carrierwave) ответ Paperclip'у который хранил конфигурацию прямо в модели, инкапсуляция в классах.
CarrierWave в есть [интеграция с Sequel](https://github.com/carrierwaveuploader/carrierwave-sequel).
К сожалению, для расширений [carrierwave\_backgrounder](https://github.com/lardawge/carrierwave_backgrounder/blob/38b381faaace6c75f7310ea726dcd1be2604d3fb/lib/backgrounder/orm/activemodel.rb) и [carrierwave\_direct](https://github.com/dwilkie/carrierwave_direct/blob/a0bc3230e544c0ea88f35d2bb6b7eb6a1fdb9196/lib/carrierwave_direct/orm/activerecord.rb) не достаточно интеграции ORM CarrierWave. Нужно много дополнительного ActiveRecord специфичного кода, чтобы все это заработало.
### Прямая загрузка
Как упоминалось ранее, экосистема CarrierWave имеет решения для прямой загрузки на S3 — [carrierwave\_direct](https://github.com/dwilkie/carrierwave_direct/blob/a0bc3230e544c0ea88f35d2bb6b7eb6a1fdb9196/lib/carrierwave_direct/orm/activerecord.rb). Это работает таким образом, что позволяет вам создать форму для прямой загрузки на S3, а затем назначить ключ S3 загруженного файла вашему загрузчику.
```
<%= direct_upload_form_for @photo.image do |f| %>
<%= f.file_field :image %>
<%= f.submit %>
<% end %>
```
Однако что, если вам нужно сделать несколько загрузок напрямую на S3? в README отмечено, что carrierwave\_direct предназначен только для одиночных загрузок. А что на счет JSON API? Это обычная форма, все что онаделает — это генерация URL и параметров для загрузки на S3, Так почему же carrierwave\_direct не позволяет получить эту информацию в формате JSON?
А что если, вместо повторной реализации всей логики генерации запроса на S3 используя [fog-aws](https://github.com/fog/fog-aws) просто полагался на [aws-sdk](https://github.com/aws/aws-sdk-ruby)?
```
# aws-sdk
bucket = s3.bucket("my-bucket")
object = bucket.object(SecureRandom.hex)
presign = object.presigned_post
```
```
<% presign.fields.each do |name, value| %>
<% end %>
```
```
# JSON version
{ "url": presign.url, "fields": presign.fields }
```
Этот способ имеет следующие преимущества: Он не привязан к Rails, он работает с JSON API, он поддерживает множественную загрузок файлов (клиент может просто сделать запрос с этими данными для каждого файла), и он более надежен (так как теперь параметры генерируется официально поддерживаемым гемом).
### Фоновые задачи
Во-первых, стоит отметить, что carrierwave\_direct предоставляет инструкции по настройке фоновой обработки. Однако корректная настройка фоновых задач [является довольно сложной задачей](https://twin.github.io/file-uploads-asynchronous-world), поэтому имеет смысл полагаться на библиотеку, которая делает это за вас.
Что приводит нас к [carrierwave\_backgrounder](https://github.com/lardawge/carrierwave_backgrounder/blob/38b381faaace6c75f7310ea726dcd1be2604d3fb/lib/backgrounder/orm/activemodel.rb). Эта библиотека поддерживает обработку фоновых задач, но по моему опыту она была нестабильна ([1](https://github.com/lardawge/carrierwave_backgrounder/pull/169), и [2](https://github.com/lardawge/carrierwave_backgrounder/pull/186)). Кроме того, она не поддерживает удаление файлов в фоновом режиме, что является решающим фактором при удалении множества файлов.
Даже если мы все это преодолеем, не получится интегрировать carrierwave\_backgrounder с carrierwave\_direct. Как я уже упоминал, я хочу загружать файлы непосредственно на S3 и обрабатывать и удалять их в фоновых задачах. Но кажется, что эти две библиотеки несовместимы друг с другом, а это означает, что я не могу достичь желаемой производительности с CarrierWave для моих кейсов.
### Закрытие не разрешенных issue на Github
Я понимаю, что иногда люди бывают неблагодарны мейнтейнерам популярных open-source библиотек и стоит быть более мягче и уважительными друг к другу. [Тем не менее](https://github.com/carrierwaveuploader/carrierwave/issues/1064), [я](https://github.com/carrierwaveuploader/carrierwave/issues/1349) [не могу](https://github.com/carrierwaveuploader/carrierwave/issues/1773) [понять](https://github.com/carrierwaveuploader/carrierwave/issues/1756), [почему](https://github.com/carrierwaveuploader/carrierwave/issues/1747) [разработчики](https://github.com/carrierwaveuploader/carrierwave/issues/1680) [CarrierWave](https://github.com/carrierwaveuploader/carrierwave/issues/1711) [закрывают](https://github.com/carrierwaveuploader/carrierwave/issues/1555) [неразрешенные](https://github.com/carrierwaveuploader/carrierwave/issues/1543) [задачи](https://github.com/carrierwaveuploader/carrierwave/issues/1320).
[Одна](https://github.com/carrierwaveuploader/carrierwave/issues/1320) из таких закрытых задач является ненужное выполнение обработки CarrierWave перед валидацией. Это серьёзная дыра в безопасности, поскольку атакующий может передать любой файл обработчику изображений, так как валидации размеров файлов/MIME/измерений будут выполняться только после обработки. Это делает ваше приложение уязвимым для атак типа [ImageTragick](https://imagetragick.com/), [image bombs](https://www.bamsoftware.com/hacks/deflate.html) или просто загрузка больших изображений.
Refile
------
---
> Загрузка файлов в Ruby, Попытка №3
[Refile](https://github.com/refile/refile) был создан Джонасом Никласом, автором CarrierWave, как [третья попытка улучшить загрузку файлов в Ruby](https://www.varvet.com/blog/refile-fixing-ruby-file-uploads).Как и Dragonfly, Refile проектировался в возможностью обработки на лету. Помучавшись со сложностью CarrierWave, я обнаружил, что простой и современный дизайн Refile действительно многообещающий, поэтому я начал вносить свой вклад в него, и в итоге я был приглашен в кор-тим.
```
Refile.attachment_url(@photo, :image, :fit, 400, 500) # resize to 400x500
#=> "/attachments/15058dc712/store/fit/400/500/ed3153b9cb"
```
Некоторые из новых идей Refile включают в себя: временное и перманентное хранилище в качестве хранилищ первого порядка, чистые абстракции для хранилищ, Абстракция IO, чистый внутренний дизайн (без GOD объектов), и прямая загрузка из коробки. Благодаря чистому дизайну Refile, создание интеграции Sequel было довольно простым делом.
### Прямая загрузка
Refile — первая библиотека для загрузки файлов, которая поставляется со встроенной поддержкой прямых загрузок, позволяя вам асинхронно загружать вложенный файл в тот момент, когда пользователь его выбирает. Вы можете загрузить файл через Rack или непосредственно на S3, используя Refile, чтобы сгенерировать параметры запроса S3. есть даже JavaScript библиотека, который делает все за вас.
```
<%= form.attachment_field :image, presigned: true %>
```
Здесь также есть отличный прирост производительности. Когда вы загружаете файл прямо на S3, вы загружаете его в каталог bucket, который помечен как «временный». Затем, когда проходит валидация и запись сохраняется, загруженный файл перемещается в перманентное хранилище. Если временное и постоянное хранилище находится на S3, то вместо повторной загрузки Refile просто выдаст запрос S3 COPY.
Нет слов, мои требования для прямых загрузках были удовлетворены.
### Фоновые задачи
Одним из ограничений Refile является отсутствие поддержки фоновых заданий. Вы можете подумать, что, поскольку Refile выполняет обработку в процессе загрузки и имеет оптимизацию S3 COPY, фоновые задачи здесь не нужны.
Тем не менее запрос S3 COPY по-прежнему является HTTP-запросом и влияет на продолжительность отправки формы. Кроме того, скорость запроса S3 COPY зависит от размера файла, поэтому чем больше файл, тем медленнее будет запрос S3 COPY.
Кроме того, Amazon S3 является лишь одним из многих облачных хранилищ, вы можете использовать другой сервис, который лучше подходит вашим потребностям, но который не имеет такой оптимизации или даже поддерживает прямую загрузку.
### Обработка в процессе загрузки
Я думаю, что обработка в процессе загрузки отлично подходит для изображений, которые хранятся локально и быстро обрабатываются. Однако, если вы храните оригиналы на S3, то Refile будет обслуживать первоначальный запрос к версии гораздо медленнее, так как ему нужно сначала загрузить оригинал с S3. В этом случае нужно подумать о добавлении фоновых задач, которые предварительно обрабатывают все версии.
Если вы загружаете более крупные файлы, такие как видео, то обычно лучше обрабатывать их после загрузки, а не в процессе загрузки. Но Refile в настоящее время не поддерживает это.
Dragonfly
---------
---
> Ruby gem для обработки в процессе загрузки — подходит для загрузки изображений в Rails, Sinatra
[Dragonfly](https://github.com/markevans/dragonfly) — еще одно решение для обработки в процессе загрузки, которое было на сцене гораздо дольше, чем Refile, и, на мой взгляд, обладает гораздо более продвинутыми и гибкими возможностями обработки в процессе загрузки.
Dragonfly не работает с Sequel, этого и следовало ожидать, я даже был бы готов написать адаптер, но [общее поведение связанное с моделью](https://github.com/markevans/dragonfly/blob/b8af810e647fc21e43ccc42b69beb6c9baa40abe/lib/dragonfly/model/attachment.rb), похоже, смешивается с поведением, [специфичным для моделей ActiveRecord](https://github.com/markevans/dragonfly/blob/b8af810e647fc21e43ccc42b69beb6c9baa40abe/lib/dragonfly/model/attachment.rb#L215), поэтому не ясно, как это сделать.
Также нет поддержки фоновых задач или прямых загрузок. Вы можете сделать последнее вручную, но это будет иметь те же недостатки, что и у Paperclip.
Есть еще одно важное замечание. Получение файлов через сервер изображений (приложение Dragonfly для обработки в процессе загрузки) является полностью отдельной ответственностью. Я имею в виду, что вы можете использовать другую библиотеку загрузки файлов, которая поставляется со всем (прямые загрузки, фоновые задачи, различные ORM и т. д.), чтобы загружать файлы в хранилище, и по-прежнему использовать Dragonfly для обслуживания этих файлов.
```
map "/attachments" do
run Dragonfly.app # doesn't care how the files were uploaded
end
```
Attache
-------
---
> Еще один подход к загрузке файлов
[Attache](https://github.com/choonkeat/attache) относительно новая библиотека, которая поддерживает обработку в процессе загрузки. Разница между Dragonfly и Refile заключается в том, что Attache был разработан для запуска в виде отдельной службы, поэтому файлы загружаются и раздаются через сервер Attache.
Attache имеет интеграцию ActiveRecord для связывания загруженных файлов к записям базы данных и имеет поддержку прямых загрузок. Но все еще не хватает возможности создавать резервные копии и удалять файлы в фоновых задачах. К тому же Attache недостаточно гибок.
Обратите внимание, аналогично Dragonfly, Attache не нуждается в интеграции с моделью — для этого можно использовать Shrine. В этом году я побывал в RedDotRubyConf в Сингапуре, где мне довелось встретиться с автором Attache, и после очень интересного обсуждения о проблемах при загрузках файлов, мы пришли к решению, что было бы полезно использовать Shrine для логики вложения файлов, и просто подключать Attache в качестве бекенда.
Таким образом, Attache все еще может делать то, что он делает лучше всего — раздавать файлы, но при этом делегировать работу со вложениями на Shrine.
### В заключение
Поддержка прямых загрузок, управление файлами в фоне, обработка при загрузке, а также возможность использования с другими ORM — это то, чего я действительно ожидаю от библиотеки. Однако ни одна из существующих библиотек не поддерживала все эти требования.
Поэтому я решил создать новую библиотеку [Shrine](https://github.com/janko-m/shrine), основываясь на знаниях из существующих библиотек.
Цель Shrine — не быть топорным, предоставить функционал и гибкость, которые позволят оптимизировать различные задачи при работе с файлами.
Это амбициозная цель, но после года активной разработки и исследований я чувствую, что достиг этого. По крайней мере, возможностей, стало больше, чем в любой другой библиотеке для Ruby. В остальной части этой серии статей я познакомлю вас со всеми классными фичами, которые вы можете использовать со Shrine, так что следите за обновлениями!
---
*Оригинал: [Better File Uploads with Shrine: Motivation](https://twin.github.io/better-file-uploads-with-shrine-motivation)
Остальные статьи из серии в блоге автора:
* [Better File Uploads with Shrine: Uploader](https://twin.github.io/better-file-uploads-with-shrine-uploader/)
* [Better File Uploads with Shrine: Attachment](https://twin.github.io/better-file-uploads-with-shrine-attachment)
* [Better File Uploads with Shrine: Processing](https://twin.github.io/better-file-uploads-with-shrine-processing)
* [Better File Uploads with Shrine: Metadata](https://twin.github.io/better-file-uploads-with-shrine-metadata)* | https://habr.com/ru/post/328558/ | null | ru | null |
# Как создать email-письмо, которое увидит только Apple Watch
[](http://habrahabr.ru/company/pechkin/blog/258871/)
В блоге компании Litmus опубликован [материал](https://litmus.com/blog/how-to-send-hidden-version-email-apple-watch), в котором рассказывается, как можно создать «скрытую» версию электронного письма [почтовой рассылки](https://pechkin-mail.ru/?utm_source=habr&utm_medium=referral&utm_campaign=applewatch), которая будет отображаться только на Apple Watch.
Как правило, Watch отображает только plain text-часть почтового сообщения — когда устройство «замечает», что в письме используется изображение, хранящееся на удаленном сервере, оно решает, что все это слишком сложно, и показывает только текст. Речь все-таки идет о часах.
#### Так в чем же секрет?
Поговорим немного о базовых вещах. Обычно HTML-письма состоят из двух частей — кода HTML (в качестве `Content-Type` выбран `text/html`) и Plain Text-части (`text/plain`). Не так давно Apple разослала клиентам письмо, содержащее третью часть — `text/watch-html`.
Если в письмо включить еще одну HTML-часть с Content-Type, установленным в `text/watch-html`, то Apple Watch будет использовать эту дополнительную часть вместо простого текста.
Для тестовой отправки оптимизированного под Apple Watch сообщения можно воспользоваться сервисом [PutsMail](https://putsmail.com/tests/new?utm_campaign=applewatch&utm_source=litmusblog&utm_medium=blog).
#### Watch-HTML в действии
Представители Litmus взяли одну из своих почтовых рассылок и добавили в нее часть для Apple Watch. Во всех почтовых клиентах, кроме почтовой программы на Watch, письмо отображалось, как ни в чем не бывало.
Но на часах от Apple появилась возможность отображения оптимизированной версии:
#### Насколько хорошо может выглядеть письмо на Watch
С помощью описанной техники можно несколько улучшить отображение письма на часах, но не слишком сильно. Добиться чего-то кроме чуть более красивого текста вряд ли удастся. Иными словами не стоит рассчитывать на отображение письма в привычном многоколоночном виде.
Если посмотреть на использованные для письма выше [HTML-код](https://litmus.com/builder/15e6e13), то выяснится, что там почти нет элементов блочных (block-level). На самом деле, код едва похож на HTML, сего помощью можно совсем чуть-чуть отформатировать текст, но ни о каком многоколоночном виде не идет и речи.
Поскольку Watch не умеет отображать HTML, устройство с помощью iPhone транслирует его в «богатый текст» (rich text) и только затем отображает его на своем экране. Чем-то напоминает «старые деньки» Lotus Notes и AOL — по сути, только текст с небольшими вкраплениями rich-контента.
#### Советы по вёрстке
Вместо использования тегов абзаца следует создавать абзац прямо в коде письма. Нельзя использовать стили или теги strong для повышения веса шрифта, лучше обойтись простым ``. Нецелесообразно использование дивов, не поддерживается большинства стилей (кроме цветов текста, которые не черные).
Ниже представлена информация о том, что поддерживается в настоящий момент:
| Элемент форматирования | Watch HTML |
| --- | --- |
| Жирный шрифт | **Text** |
| Курсив | *Text* |
| Подчеркивание | Text |
| Цвет шрифта | Text
Текст черного цвета (#000000) или не выбранный будет конвертирован в белый (#FFFFFF). Остальные цвета поддерживаются. |
| Выравнивание | Text
Поддерживается только выравнивание по центру, левому и правому краю. |
| Цитаты | Text
До 7 уровней вложенности цитаты, отступы отсутствуют, но текущий уровень выделяется затемнением. |
| Нумерованный список | 1. Элемент 1
|
| Маркированный список | * Элемент 1
|
| Изображения | Текст
Поддерживаются только встроенные изображение, очень много багов |
#### Поддержка изображений
Первая версия «родного» почтового приложения Watch имеет большие проблемы с изображениями. Помимо того, что они должны быть вставлены «эмбедом», есть и другие примечательные моменты.
Существует баг в позиционировании изображений, который приводит к «поломке» соотношения его сторон. Когда Watch «ресайзит» изображение, встроенное в письмо, то вставляет прозрачную границу шириной 2 пикселя (4px на retina-экране). Проблема том, что это происходит «внутри» изображения, что искажает его. К примеру, если у вас есть изображение с соотношением сторон 100x50px, то Watch ужмет его до 96x46px, что нарушит соотношение сторон.
Можно попытаться обойти эту проблему, растянув изображение на те самые 4x4px. В примере ниже изображение имеет размер 104x54px. В результате Watch ужмет его обратно до 100x50px. Но этот метод все равно характеризуется искажением картинки:
`.
```
Content-Type: text/watch-html; charset="utf-8"
```
Важный момент: часть Watch HTML должна стоять в коде перед стандартным HTML, но после plain text-части.Если разместить ее иначе, то Apple Watch отобразит email как простой текст. Если что-то не работает, нужно проверить, не меняет ли почтовый софт MIMI-части местами.
Ниже представлен код, в котором все три части размещены корректно:
```
From: from@example.org
To: to@example.org
Subject: Apple Watch Example
Content-Type: multipart/alternative; boundary="your-boundary"
--your-boundary
Content-Type: text/plain; charset="utf-8"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline
Plain text часть письма
--your-boundary
Content-Type: text/watch-html; charset="utf-8"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline
**Это часть Watch HTML**
--your-boundary
Content-Type: text/html; charset="utf-8"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline
Это стандартная часть HTML
--your-boundary—
```
Кроме того, Apple Watch обратится к части кода watch-html, если встретит что-то неподходящее в стандартном HTML. Чтобы добиться этого, можно использовать простой трюк с изображением, расположенным на внешнем сервере.
Этот метод работает, потому что Apple Watch сначала обработает часть `text/html`, затем пройдет по частям MIMI в поисках подходящего контента. В этом материале Content-Type назван `text/watch-html`, но на самом деле можно назвать его как угодно, лишь бы все начиналось с `text/`.` | https://habr.com/ru/post/258871/ | null | ru | null |
# Suggest.io: для людей с запросами
Живой поиск Suggest.io продолжает совершенствоваться.
Основные обновления:
* 1. Всвязи с увеличением числа пользователей внесены небольшие изменения в регистрацию/индексацию вновь подключаемых сайтов. Теперь индексация начинается после установки кода в шаблоны страниц сайта. Ход индексации можно наблюдать из личного кабинета.
* 2. Введена система личных кабинетов – теперь можно настраивать внешний вид элементов поиска, настраивать выдачу поисковых запросов, включая картинки в результатах выдачи.
В дальнейшем в личном кабинете появятся большое колличество дополнительного функционала.
Личный кабинет.
---------------
Авторизация нужна тем, кто хочет изменить дефолтовые настройки системы и в дальнейшем пользоваться всеми появляющимися возможностями.
В настоящее время поддерживается авторизация через Mozilla Persоna.
В личном кабинете можно добавить все свои сайты для дальнейшей настройки поиска Suggest.io.
Для работы с настройками необходимо пройти верификацию. После добавления домена, система предложит скачать небольшой .txt файл — его следует загрузить в корневой каталог вашего вебсайта. После того как Suggest.io проверит наличие файла, можно приступать к настройкам.
Персонализированные настройки.
------------------------------
Всеми так ожидаемая возможность настройки внешнего вида поиска.
Настройки дизайна поисковых элементов происходят прямо на вашем сайте, после перехода по ссылке из админки.
Что можно настроить:
— Шаблон окна поисковой выдачи. Пока шаблонов не очень много, но их колличество будет постоянно пополняться.
— Цвета. Почти любые. Палитра генерируется на основе цветов, используемых на сайте.
— Размеры и положение поискового окна на странице.
Для наших иностранных клиентов — быстрая настройка языка поисковых окон.
Настройки поисковой выдачи.
---------------------------
Теперь в результатах поиска вы можете настроить отображение картинок со страниц вашего сайта.
Функция настраивается из панели настроек Suggest.io.
Для привязки иллюстраций к страницам необходимо добавить в страницы тег, содержащий адрес основного изображения для страницы.
Пример тега:
`/>`
Обратите внимание, что необходимо заменить содержание атрибута «content» на реальные адреса картинок.
Формат тега удовлетворяет спецификации Open Graph protocol, и, возможно, уже используется на вашем сайте для взаимодействия с другими системами поиска и синдикации. После добавления нового тега в шаблоны сайта, необходимо вернутся в администраторскую панель Suggest.io и включить выдачу картинок, после чего запустить переиндексацию сайта.
Альтернативный способ — добавить для тегов , которые указывают на основное изображение страницы атрибут `class="sio-search-image"`.
Поведение поисковой выдачи при наличии иллюстраций настраивается здесь же. Например, не цитировать текст со страницы, если показывается картинка.
Изменения в поисковом движке и индексаторе
------------------------------------------
Исправлено:
* Частичная или полная утрата поисковых функций на сайте при выпадении узлов в кластере Suggest.io.
* Некорректный обход сайта при некоторых сложных конструкциях в robots.txt. Переписан парсер robots.txt.
* Некорректная дедубликация страниц при активном использовании длинных повторяющихся текстовых конструкций (скрытых через display:none).
* Длительная задержка при добавлении нового сайта в систему Suggest.io.
Дополнительно:
* Улучшена обработка незакрытых php-тегов на отрендеренных страницах.
* Автоматическое исправление некорректных ссылок вида «[хабр.рф/страница](http://хабр.рф/страница)» "/%С0%C1/что-то", т.е. когда выполнено неполное percent/punicode-кодирование ссылок.
* Ускорен поиск, улучшена стабильность и исправлена ещё сотня менее значительных проблем.
Пока всё.
Команда Suggest.io продолжает поиск решений по улучшению сервиса. Следите за обновлениями. | https://habr.com/ru/post/162289/ | null | ru | null |
# Обзор примитивов синхронизации — mutex и cond
Синхронизация нужна в любой малтитредной программе. (Если, конечно, она не состоит из локлесс алгоритмов на 100%, что вряд ли). Будь то приложение или компонента ядра современной операционной системы.
Меня всё нижесказанное, конечно, больше волнует с точки зрения разработки ядра ОС. Но почти всё применимо и к пользовательскому коду.
Кстати, ядра старых ОС в примитивах синхронизации не нуждались, поскольку преемптивной мультизадачности внутри ядра в старые добрые времена не было. (Уж за Юникс 7-й версии я отвечаю. Не было.) Точнее, единственным методом синхронизации был запрет прерываний. Но об этом позже.
Сначала перечислим героев. Мне известны следующие примитивы синхронизации:
User/kernel mode: mutex+cond, sema, enter/leave critical section.
Kernel only: spinlock, управление прерываниями.
Зачем всё это нужно, читатель, наверное, знает, но всё же уточним.
Если некоторая структура данных может быть доступна двум параллельно работающим нитям (или нити и прерыванию), и являет собой сущность, к которой нельзя обеспечить атомарный доступ, то работу с такой структурой нужно производить так, чтобы только одна нить одновременно выполняла сложные манипуляции с состоянием структуры.
Простой пример. Список.
```
struct list { list *next; list *prev };
```
Вставляем элемент в список.
```
new_el->next = curr_el->next;
new_el->prev = curr_el;
curr_el->next->prev = new_el; // 3
curr_el->next = new_el;
```
Всё примитивно. Но если этот код будут исполнять две нити параллельно, то вместо связного списка получится взрыв на макаронной фабрике. Например, если вторая нить включится в момент, когда первая нить закончила строку 3, то обходя список слева направо мы встретим на одном и том же месте один объект, а справа налево — другой.
Неприятно.
Применим мьютекс — mutually exclusive lock. Этот замок запрещает параллельное исполнение запертого им кода — если одна нить начала его исполнять, вторая будет ждать на входе до тех пор, пока первая не закончит.
```
mutex_lock( &list->mutex);
new_el->next = curr_el->next;
new_el->prev = curr_el;
curr_el->next->prev = new_el; // 3
curr_el->next = new_el;
mutex_unlock( &list->mutex);
```
Теперь хорошо. (Ну, не очень хорошо, если у нас более ста процессоров и участок кода у них популярен, но это совсем отдельный разговор.)
Что происходит? Нить А делает вызов mutex\_lock для мьютекса list->mutex. Который, очевидно, принадлежит списку, который мы хотим поменять, и защищает доступ именно к нему. Он не заперт, нить А запирает мьютекс (теперь он знает, что заперт, и знает, кто его запер) и продолжает работу. Если теперь нить Б попробует войти в тот же регион кода (или другой, защищённый тем же мьютексом — например, в функции удаления элемента списка), то второй раз запереть запертый мьютекс не получится. Нить Б будет ждать, пока нить А не вызовет mutex\_unlock.
Кстати, если мы с вами — ядерные разработчики, то важно понимать ещё одно, неинтересное для прикладного программиста свойство мьютекса (как и всех «тяжеловесных» примитивов синхронизации) — если мы пытаемся запереть мьютекс, который уже заперт другой нитью, мы не просто ждём — нашу нить «снимут с процессора», произойдёт переключение контекста. Это ценно, потому что позволяет куда более эффективно загружать процессор, но есть и проблемы. Внутри обработчика прерываний, например, такие примитивы применять нельзя совсем, потому что переключение контекста внутри прерывания запрещено и грозит изрядным раздраем в работе системы. Но, наверное, об этом надо будет написать отдельно.
Это вполне решает задачу, если надо поработать со сложной структурой данных. Но есть и другие задачи. Например, проинформировать другую нить о событии, которое та, другая нить, ждёт.
Рассмотрим функции alloc\_mem и free\_mem:
```
// NB! Заведомо неверный код!
alloc_mem()
{
while(total_free_mem <= 0)
{
wait_cond(&got_free_mem);
}
// actually allocate
}
free_mem()
{
// actually free mem
total_free_mem++;
signal_cond(&got_free_mem);
}
```
Что здесь происходит? Всё банально. В функции аллокации памяти мы смотрим на глобальный счётчик свободной памяти. Если пусто, свободной памяти нет, ждём пока кто-то не освободит память — вызываем wait\_cond, который нас приостанавливает, пока кто-то не просигналит — готово, память освободили.
Это, конечно, функция free\_mem() — она возвращает память в кучу, увеличивает счётчик свободной памяти и вызывает signal\_cond — сообщает страждущим, что память есть. Тот, кто спал внутри wait\_cond, «проснётся» после такого сигнала, проверит что да, память есть, и выделит её. Всё верно?
Ну, нет, конечно. Если функцию alloc\_mem вызовут две нити сразу, то будет беда — одна из них получит сигнал первой, проснётся, убедится, что свободная память есть, и тут вдруг шедулер возьми да сними её с процессора. И дай проснуться второй такой же нити. Вторая нить проснётся, тоже увидит, что память есть, заберёт её и закончится. Просыпается ~~мафия~~ первая нить, и у неё всё плохо. Только что она проверила переменную free\_mem, убедилась, что всё есть, и вот — никакой свободной памяти в пуле не находится. Беда.
Для данного случая беда не смертельная — можно просто вернуться к началу функции и снова ждать у моря погоды. Хотя, конечно, и это плохо — мы теряем процессорное время на пустые метания.
Но, вроде бы, мы же знаем ответ? Добавим mutex!
```
// NB! Снова заведомо неверный код!
alloc_mem()
{
mutex_lock( &allocator_mutex );
while(total_free_mem <= 0)
{
wait_cond(&got_free_mem);
}
// actually allocate
mutex_unlock( &allocator_mutex );
}
free_mem()
{
mutex_lock( &allocator_mutex );
// actually free mem
total_free_mem++;
signal_cond(&got_free_mem);
mutex_unlock( &allocator_mutex );
}
```
Так хорошо? Нет. Освобождение памяти не случится — функция alloc\_mem() его заперла, заснула на ожидании cond, и никто больше в мьютекс войти не может, и никто не освободит память, и не просигналит.
Беда. Но ладно же, мы знаем, что делать! Перед тем, как заснуть на ожидании cond, мы отопрём mutex, и позволим другим войти в free и вернуть нам память. Вот так:
```
// NB! И опять заведомо неверный код!
alloc_mem()
{
mutex_lock( &allocator_mutex );
while(total_free_mem <= 0)
{
mutex_unlock( &allocator_mutex );
wait_cond(&got_free_mem);
mutex_lock( &allocator_mutex );
}
// actually allocate
mutex_unlock( &allocator_mutex );
}
```
По комментарию вы уже видите, что опять не слава богу. Что теперь? А теперь есть щёлочка, тонкая линия между моментом, когда мы проснулись и вышли из функции wait\_cond, получив от free\_mem сигнал об освобождении памяти, и захватом мьютекса. В этот момент мьютекс не взят, и другие нити опять могут нас опередить и набезобразить. Именно по этой причине функция wait\_cond выглядит несколько иначе:
```
wait_cond( cond *c, mutex *m );
```
Работает это вот как: функция принимает на вход conditional variable, которая передаст нам сигнал «проснуться», и **запертый** мьютекс:
```
alloc_mem()
{
mutex_lock( &allocator_mutex );
while(total_free_mem <= 0)
{
wait_cond(&got_free_mem,&allocator_mutex);
}
// actually allocate
mutex_unlock( &allocator_mutex );
}
```
Функция wait\_cond отопрёт мьютекс, во-первых, самостоятельно, а во-вторых сделает это **атомарно** по отношению к переходу в спящее состояние. То есть нить, входящая в wait\_cond сначала заснёт, а потом, не прерывая сна, отопрёт мьютекс. И наоборот, просыпаясь, она сначала захватит мьютекс, а потом проснётся и продолжит работу. (Это требует от кода переключения нитей изрядной хитрости, постараюсь рассказать об этом в одной из следующих заметок.)
Только такая семантика обеспечивает 100% консистентность и отсутствие «гонок» — race conditions.
Отметим, что код функции free у нас получился вполне правильный:
```
free_mem()
{
mutex_lock( &allocator_mutex );
// actually free mem
total_free_mem++;
signal_cond(&got_free_mem); // 4
mutex_unlock( &allocator_mutex ); // 5
}
```
Только с учётом вышесказанного надо понимать, что хотя формально мы пробуждаем аллокатор на строке 4, реально проснётся он после исполнения строки 5, потому что до этого момента он не в состоянии захватить мьютекс.
К сказанному, наверное, имеет смысл добавить, что реальная функция signal\_cond пробуждает не все ожидающие потоки, а только один (обычно — с наивысшим приоритетом), так что ситуация в приведённом примере несколько проще и сложнее одновременно. Проще потому что уже внутри сигнализации встроен механизм, который после одного free пробудит только один alloc, а сложнее потому, что реально это ничего не решает — мы не знаем, подойдёт ли данному alloc-у освобождённый участок, так что надо вместо signal\_cond применить broadcast\_cond, который таки пробудит всех страждущих, дав им возможность в честной драке определиться, кому достанется ресурс.
Посмотреть на фактическую реализацию этих примитивов можно здесь:
[mutex.c](https://github.com/dzavalishin/phantomuserland/blob/master/phantom/threads/mutex.c), [cond.c](https://github.com/dzavalishin/phantomuserland/blob/master/phantom/threads/cond.c)
В следующей серии — sema семафор, который в одиночку заменяет и mutex, и cond. Практически без ансамбля.
Это серия статей «Обзор примитивов синхронизации»:
* [mutex и cond](https://habrahabr.ru/post/278413/)
* [Семафор и немного lockless-а](https://habrahabr.ru/post/278661/)
* [спинлоки и тайны ядра процессора](https://habrahabr.ru/post/278685/) | https://habr.com/ru/post/278413/ | null | ru | null |
# Справочник методов console в JS
Со времён систематизации методов объекта console прошло достаточно много времени, некоторые браузеры получили поддержку недостающих ранее методов. Таблица вызывает естественный интерес у разработчиков, поэтому — почему бы её не обновить, дополнив в одной статье описаниями? [Github](http://spmbt.github.io/jsConsoleApiReference/jsConsoleApiReference-ru.htm).
\* -⊝- — метод в данной среде не используется;
\* ± — метод используется, но с особенностями (видны в подсказке);
\* `+` — полноценная реализация метода.
| | Chrome | Firebug | Firefox | IE | Node.js | Safari | Opera |
| --- | --- | --- | --- | --- | --- | --- | --- |
| **assert(expression[, object, ...])**Если выражение expression ложно, выводит console.error, иначе — ничего не выводит. |
| | + | + | [+](https://developer.mozilla.org/en-US/docs/Web/API/Console/assert) (28.0+) | [+](https://msdn.microsoft.com/en-us/library/ie/hh772171%28v=vs.85%29.aspx) | + | + | ± |
| **clear()**Очищает окно консоли. |
| | + | + | -⊝- | [+](https://msdn.microsoft.com/en-us/library/ie/jj152131%28v=vs.85%29.aspx) | -⊝- | + | + |
| **count([object])**Каждый раз выводит количество проходов данной точки кода. Если есть аргумент *object*, то перед значением счётчика выводится object.toString(). |
| | + | + | [+](https://developer.mozilla.org/en-US/docs/Web/API/Console/count) (30.0+) | [+](https://msdn.microsoft.com/en-us/library/ie/dn265064%28v=vs.85%29.aspx) | -⊝- | + | ± ... |
| **debug(object[, object, ...])**Эквивалент console.log для совместимости со старым вариантом объекта console, когда .debug выводил дополнительно ссылку на строку кода, из которой он был вызван. |
| *равно .log()* | + | + | + | [+](https://msdn.microsoft.com/en-us/library/ie/dn265066%28v=vs.85%29.aspx) | -⊝- | + | ± ... |
| **dir(object)***object* выводится как Javascript-объект (для DOM-элементов — все их атрибуты и методы). Похожим образом работает %O в console.log в Chrome. |
| | + | + | [+](https://developer.mozilla.org/en-US/docs/Web/API/Console/dir) (8+) | [+](https://msdn.microsoft.com/en-us/library/ie/jj152132%28v=vs.85%29.aspx) (9+) | + | + | + |
| **dirxml(object)**Выводится XML-код объекта. |
| | + | + | -⊝- | [+](https://msdn.microsoft.com/en-us/library/ie/dn265067%28v=vs.85%29.aspx) (11+) | -⊝- | + | ± ... |
| **error(object[, object, ...])**Выводит ошибку и результат console.trace для места, откуда она была вызвана (не останавливая выполнение программы). Поддерживаются паттерны(%s, %d (%i), %f, %o, %O, %c), как в console.log. Пример с трассировкой стека вызовов (Firefox 31+):
|
| | + | ± ... | + | [+](https://msdn.microsoft.com/en-us/library/ie/hh772176%28v=vs.85%29.aspx) (8+) | + | + | ± ... |
| **exception(object[, object, ...])**Эквивалент error() |
| *равно .error()* | -⊝- | -⊝- | [+](https://developer.mozilla.org/en-US/docs/Web/API/Console/error) (28+) | -⊝- | -⊝- | -⊝- | -⊝- |
| **group(object[, object, ...])**Начинает развёрнутую группу записей в консоли, которая вручную затем может сворачиваться. Группа оканчивается командой .groupEnd(). Поддерживаются паттерны (см. *.log()*). Пример кода и результата (из статьи "[Возможности консоли браузера](http://stepansuvorov.com/blog/2013/04/%D0%B2%D0%BE%D0%B7%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8-%D0%BA%D0%BE%D0%BD%D1%81%D0%BE%D0%BB%D0%B8-%D0%B1%D1%80%D0%B0%D1%83%D0%B7%D0%B5%D1%80%D0%B0/)", 2013):
```
console.group("module A")
console.log('a')
console.log('a')
console.log('a')
console.group("nested module B")
console.log('b')
console.log('b')
console.log('b')
console.groupEnd()
console.groupCollapsed("nested collapsed module C")
console.log('c')
console.log('c')
console.log('c')
console.groupEnd()
console.groupEnd()
console.group("module D")
console.log('d')
console.log('d')
console.log('d')
console.groupEnd()
```
|
| | + | + | ± ... | [+](https://msdn.microsoft.com/en-us/library/ie/dn265068%28v=vs.85%29.aspx) (11+) | -⊝- | + (4+) | + |
| **groupCollapsed(object[, object, ...])**Начинает изначально свёрнутую группу записей в консоли, которая вручную затем может разворачиваться. Группа оканчивается командой .groupEnd(). Поддерживаются паттерны (см. *.log()*). |
| | + | + | ± ... (9+) | [+](https://msdn.microsoft.com/en-us/library/ie/dn265069%28v=vs.85%29.aspx) (11+) | -⊝- | + (5.1+) | + |
| **groupEnd()**Обозначает конец группы сообщений лога, которые способны сворачиваться-разворачиваться (кроме Firefox) вручную. |
| | + | [+](https://getfirebug.com/wiki/index.php/Console.groupEnd) | [+](https://developer.mozilla.org/en-US/docs/Web/API/Console/groupEnd) (9+) | [+](https://msdn.microsoft.com/en-us/library/ie/dn265070%28v=vs.85%29.aspx) (11+) | -⊝- | + (4+) | + |
| | Chrome | Firebug | Firefox | IE | Node.js | Safari | Opera |
| **info(object[, object, ...])**Аналогична .log(), но оформляется в ином дизайне, для различения типов сообщений, например, для градации важности или для иного смыслового значения этой группы сообщений. Поддерживаются паттерны (описаны в *.log()*). Пример различий для Firebug, Chrome, IE9:
|
| | + | + | + | + | + | + | + |
| **log(object[, object, ...])**Выводит аргументы в консоль, разделяя пробелами. Самая популярная из команд console.
Поддерживает паттерны — специальные имена в первом аргументе, указывающие, что его надо использовать как шаблон, в который будут подставляться следующие аргументы вместо термов (как в printf() на С, но значительно проще). Примеры:
```
console.log('У Пети было %d %s',10,'яблок');
console.log('Пи равно %f',Math.PI);
console.log('%cКаждый %cОхотник %cЖелает%c знать, где сидит фазан','color:red;','font-size:16px;color:orange;','background:black;color:yellow;','font:normal;color:normal;background:normal;');
console.log('body as DOM: %o',document.getElementsByTagName('body')[0]);
console.log('object: %O',{a:1,b:2});
console.log('body as Object: %O',document.getElementsByTagName('body')[0]);
```
Виды паттернов и тип данного, в который преобразуется значение подставляемого аргумента:
**%s** — строка.
**%d** или **%i** — число.
**%f** — число с плавающей точкой (Firebug тоже поддерживает).
**%o** — DOM-элемент (Firebug выводит как ссылку на элемент. Chrome, кроме ссылки, отображает элемент в консоли. Firefox по клику открывает элемент в модальном окне (доступны все атрибуты и методы этого объекта)).
**%O** — JS-объект (не поддерживается в Firefox; Chrome преобразует DOM-объект в js-объект для этого паттерна; Firebug не отличает **%o** от **%O**).
**%c** — CSS-стиль (color, background, font; в Firefox — с версии 31). Пример стилизации паттерном **%c** (Firefox):
|
| *(важно)* | + | + | + | + | + | + | ± ... |
| **markTimeline()**Аналог .timeStamp() для Safari, но в нём .timeStamp() не поддерживается, и наоборот. |
| *=.timeStamp()* | -⊝- | -⊝- | -⊝- | -⊝- | -⊝- | + | -⊝- |
| **profile([label])**[Запускает Javascript-профайлер](https://developer.chrome.com/devtools/docs/console-api#consoleprofile), затем показывает результаты под именем «label». |
| | + | + | (devtools) | + (10+) | -⊝- | + | -⊝- |
| **profileEnd()**Выключает Javascript-профайлер. |
| | + | + | (devtools) | + (10+) | -⊝- | + | -⊝- |
| **table(data[, columns])**Двумерные табличные данные — в формате таблицы. Data — массив или объект (или объект из объектов, объект из массивов), каждый элемент которого будет строкой в таблице. Первый столбец двумерного массива будет его индексом (от 0). Или, если это — объект, первый столбец будет состоять из ключей объекта. Пример из Firefox (объект объектов):
Columns — дополнительный массив названий колонок для заголовков таблицы, если строки созданы из массивов, а мы не хотим, чтобы названиями были числовые индексы. Выше — был пример результата (Firefox), полученного или из именованных колонок, или из объекта объектов. Ниже — что было бы из массива массивов без параметра columns:
|
| | + | [+](http://www.softwareishard.com/blog/firebug/tabular-logs-in-firebug/) | [+](https://developer.mozilla.org/en-US/docs/Web/API/Console/table) (34.0+) | -⊝- | -⊝- | -⊝- | -⊝- |
| **time(label)**Включает счётчик (миллисекунд) под именем label. |
| | + | [+](https://getfirebug.com/wiki/index.php/Console.time) | [+](https://developer.mozilla.org/en-US/docs/Web/API/Console/time) (10+) | + (11+) | + | + (4+) | ± |
| **timeEnd(label)**Останавливает счётчик (миллисекунд) под именем label и публикует результат под этим именем. Пример (Хром):
|
| | + | [+](http://www.stoimen.com/blog/2010/02/02/firebugs-console-time-accuracy/) | [+](https://developer.mozilla.org/en-US/docs/Web/API/Console/timeEnd) (10+) | + (11+) | + | + (4+) | ± |
| **timeStamp([label])**Отрисовывает метки времени на диаграмме таймингов скрипта, что позволяет следить за динамикой поведения программы. Пример (Firebug):
|
| | + | [+](http://www.softwareishard.com/blog/firebug/firebug-1-8-console-timestamp/) | -⊝- | -⊝- | -⊝- | -⊝- | -⊝- |
| **trace()**Показывает стек трассировки функции на данный момент исполнения (то же, что обычно показывается при остановке на месте ошибки). Пример в Safari (в боковой панели), в Хроме (в консоли):
В Firefox:
|
| | + | + | [+](https://developer.mozilla.org/en-US/docs/Web/API/Console/trace) (10+) | + (11+) | + | + (7.0.1+) | ± ... |
| **warn(object[, object, ...])**Аналогична .log() и .info(), но оформляется в ином дизайне, для различения типов сообщений. Поддерживаются паттерны (описаны в *.log()*). |
| | + | + | + | + | + | + | + |
| **debugger;**Останавливает выполнение Javascript на текущей строке. Равносилен установке точки останова (breakpoint) в отладчике. Кроме остановки, никак не отражается на исполняемой программе. |
| *(оператор)* | + | + | + | + | + | + | + |
| **throw new Error('mesasge');**Останавливает выполнение Javascript на текущей строке, прерывая выполнение. *(Поддерживается всеми средами исполнения Javascript.)* |
| | [Chrome](https://developer.chrome.com/devtools/docs/console-api) | [Firebug](https://getfirebug.com/wiki/index.php/Console_API) | [Firefox](https://developer.mozilla.org/en-US/docs/Web/API/Console) | [IE](https://msdn.microsoft.com/en-us/library/ie/hh772169%28v=vs.85%29.aspx) | [Node.js](https://nodejs.org/api/console.html) | [Safari](https://developer.apple.com/library/mac/documentation/AppleApplications/Conceptual/Safari_Developer_Guide/Console/Console.html#//apple_ref/doc/uid/TP40007874-CH6-SW3) | [Opera](http://www.opera.com/dragonfly/documentation/console/) |
• [Console API Reference for Chrome](https://developer.chrome.com/devtools/docs/console-api)
• [Console API in Firebug](https://getfirebug.com/wiki/index.php/Console_API)
• [Console object (MDN)](https://developer.mozilla.org/en-US/docs/Web/API/Console)
• [Console object in IE10 (MSDN)](https://msdn.microsoft.com/en-us/library/ie/hh772169%28v=vs.85%29.aspx)
• [in Node.js v0.12.0](https://nodejs.org/api/console.html)
• [… in Safari Web Inspector Guide](https://developer.apple.com/library/mac/documentation/AppleApplications/Conceptual/Safari_Developer_Guide/Console/Console.html#//apple_ref/doc/uid/TP40007874-CH6-SW3)
• [Console in Opera Dragonfly](http://www.opera.com/dragonfly/documentation/console/)
• [Используем console на полную](http://habrahabr.ru/post/114483/)
• [Продвинутая JavaScript отладка при помощи console.table()](http://habrahabr.ru/post/202394/)
• [Релиз Firebug 1.6](http://habrahabr.ru/post/109046/) (console.table)
• [Using the F12 Tools Console to View Errors and Status](https://msdn.microsoft.com/library/gg589530) (MSDN)
• [… + much more – Firefox Developer Tools Episode 31](https://hacks.mozilla.org/2014/05/editable-box-model-multiple-selection-sublime-text-keys-much-more-firefox-developer-tools-episode-31/) — console stack traces, styled console logs в Fx31.
• [FireBug\* Console API](http://habrahabr.ru/post/188066/) — описаны тонкости реализации, замеченные в тестах браузеров 2013 г;
• [API консоли Javascript](http://habrahabr.ru/post/198372/)
**UPD**: для того, чтобы каждый мог доводить до совершенства это описание, перевести его на другой язык, внести обновления по мере развития браузеров, [код выложен на Гитхаб](https://github.com/spmbt/jsConsoleApiReference/blob/master/jsConsoleApiReference-ru.md) и заложены основы мультиязычности и возможности дописывания в эту табличку собственного спойлера (спойлеры в статье, естественно, привязаны к сайту публикации). (Корень описания — английский вариант, но до него надо довести до качества разметку таблицы на Гитхабе).
**UPD**: в комментарии появилось предложение сделать сортировку по колонкам (отделять неподдерживаемые для данной среды методы). Если (на Гитхабе.io) описания со спойлерами загнать в один ряд, можно будет применить стандартный скрипт-сортировщик (энтузиасты найдутся? пишите в ЛС или issue, если потребуется согласовка выкладки, т.к. спойлеры я как-то сделаю).
**UPD** 2015-03-21: сделаны более гибкие, чем в данной публикации, спойлеры, режимы просмотра и HTML. Не только в данном и [полностью развёрнутом виде](http://spmbt.github.io/jsConsoleApiReference/jsConsoleApiReference-ru.htm#expand_all), но и [в более плотном виде](http://spmbt.github.io/jsConsoleApiReference/jsConsoleApiReference-ru.htm#collapse_max), по 1 методу на строку таблицы, с возможностью 1 кликом переходить между ними. [Английская версия](http://spmbt.github.io/jsConsoleApiReference/jsConsoleApiReference.htm). | https://habr.com/ru/post/253359/ | null | ru | null |
# Основы Irrlicht Engine для новичков
Хотелось бы рассказать о такой интересной вещи, как Irrlicht Engine. Для начала определимся что это вообще такое. Irrlicht — это мощный графический 3D движок, написанный на C++. Подходит сие чудо для разработки как простых 2D и 3D приложений, так и для игр. Как и любой другой движок, Irrlicht имеет ряд особенностей, основной из которых является платформенная независимость, то есть программисту, писавшему игру под Windows не нужно переписывать ни строчки кода, чтоб перенести её на устройство под управлением Linux или OSX.
#### Установка
Так как данный урок рассчитан на новичков, мы будем использовать простейший способ установки движка. Для этого нам понадобится code::blocks. Irrlich не очень хорошо дружит с последними версиями блокса, поэтому качаем [отсюда](http://prdownload.berlios.de/codeblocks/codeblocks-10.05mingw-setup.exe) и устанавливаем проверенную версию 10.05. Code::blocks уже содержит в своем установщике компилятор, поэтому качать его отдельно не нужно. Далее создаем на жестком диске папку, где будут храниться наши проекты (у меня «D:/IrrlichtDev»). Теперь качаем [отсюда](http://downloads.sourceforge.net/irrlicht/irrlicht-1.7.2.zip) последнюю версию Irrlicht'а и разархивируем ее в созданный нами каталог.
#### Создание проекта
Все необходимое у нас есть, настало время для создания проекта. Открываем Code:blocks, далее «File>New>Project», там выбираем «Irrlicht project». Следуя инструкции задаем имя нашему проекту, выбираем тот каталог для хранения, указываем в качестве компилятора «GNU GCC Compiler» и, если просит, говорим где находится движок.
Все, проект создан, минимальный код сгенерирован автоматически, но если попробовать скомпилировать его, то получим в ответ 2 ошибки. Ничего страшного, просто в 70 строке заменяем ``dimension2d на dimension2du`. Компилируем, запускаем и видим прекрасную, низкополигональную женщину с примитивной анимацией.
Поздравляю, это ваш первый проект на движке Irrlicht. Давайте сотрем ненужные комментарии (мы же умные, мы и так все поймем) и оставим следующее:
```
#include
using namespace irr; //
using namespace core; // Здесь указываем пространства имен движка, для того, чтобы
using namespace scene; // не указывать их каждый раз, когда обращаемся
using namespace video; // к объекту движка.
using namespace io; //
using namespace gui; //
int main(int argc, char\*\* argv)
{
IrrlichtDevice \*device = // Здесь создаем ссылку на главный объект движка.
createDevice(EDT\_SOFTWARE, dimension2du(640, 480), 16, // 1-й параметр - это рендер. Сейчас стоит программный
false, false, false, 0); // рендер, но можно указать EDT\_OPENGL, например.
device->setWindowCaption(L"Hello HABRAHABR"); // Указываем заголовок нашего окошка.
IVideoDriver\* driver = device->getVideoDriver(); // Ссылки на видео драйвер и менеджер сцены.
ISceneManager\* smgr = device->getSceneManager(); // Подробнее о них можно почитать в документации.
smgr->addCameraSceneNode(0, vector3df(0,30,-40), vector3df(0,5,0)); // Добавляем в менеджер сцены новую камеру.
while(device->run()) // Это наш основной цикл. Он будет выполняться постоянно, пока работает движок.
{
driver->beginScene(true, true, SColor(0,200,200,200)); // Драйвер начинает отрисовку сцены.
smgr->drawAll(); // Менеджер сцены рисует свои объекты.
driver->endScene(); // Драйвер заканчивает отрисовку сцены.
}
device->drop(); // Движок перестает работать, можно его удалить.
return 0;
}
```
Сейчас на нашей сцене ничего нет кроме камеры, так что давайте добавим простой кубик. Для этого просто добавим следующую строчку:
```
IMeshSceneNode * wall = smgr->addCubeSceneNode();
```
Если запустим проект, то увидим, что наш кубик полностью черный. Это потому, что на сцене нет освещения.
Чтобы на него не распространялись законы физики, связанные с освещением, ниже добавим следующее:
```
wall->setMaterialFlag(EMF_LIGHTING,false);
```
Думаю не нужно объяснять содержание этой строки.
Чтобы наш рукотворный примитив не был незримо белым, наложим на него текстуру, которую возьмем в стандартном наборе движка. Ниже пишем следующее:
```
wall->setMaterialTexture(0, driver->getTexture("../../media/wall.jpg")); //Цифра "0" обозначает слой текстуры.
```
Запускаем и видим красивый кусок стены.
Ну что это за кусок стены, если он не вращается? Значит далее пишем:
```
wall->setRotation(wall->getRotation() + vector3df(0,1,0));
```
Запускаем, проверяем.
Раз уж наш куб так истерично вращается, то поддержим психоделическую атмосферу неистово меняющимся цветом фона.
Создадим некую переменную "i", к которой каждый кадр будет прибавляться единица, а когда она будет достигать значения больше 256, будем сбрасывать её на ноль. Затем эту переменную укажем в качестве значения R, G и B цвета фона при отрисовке сцены. Таким образом, весь наш цикл `while` будет выглядеть так:
```
while(device->run()) {
int i;
i++;
if (i>256) i=0;
driver->beginScene(true, true, SColor(0,i,i,i)); // Здесь указывается цвет фона.
wall->setRotation(wall->getRotation() + vector3df(0,1,0));
smgr->drawAll();
driver->endScene();
}
```
Запускаем, наблюдаем.
Для ленивых вот полный исходный код урока:
```
#include
using namespace irr; //
using namespace core; // Здесь указываем пространства имен движка, дл того, чтобы
using namespace scene; // не указывать их каждый раз, когда обращаемся
using namespace video; // к объекту движка.
using namespace io; //
using namespace gui; //
int main(int argc, char\*\* argv)
{
IrrlichtDevice \*device = // Здесь создаем ссылку на главный объект движка.
createDevice(EDT\_OPENGL, dimension2du(640, 480), 16, // 1-й параметр - это рендер. Сейчас стоит программный
false, false, false, 0); // рендер, но можно указать EDT\_OPENGL, например.
device->setWindowCaption(L"Hello HABRAHABR"); // Указываем заголовок нашего окошка.
IVideoDriver\* driver = device->getVideoDriver(); // Ссылки на видео драйвер и менеджер сцены.
ISceneManager\* smgr = device->getSceneManager(); // Подробнее о них можно почитать в документации.
smgr->addCameraSceneNode(0, vector3df(0,30,-40), vector3df(0,5,0)); // Дабавляем в менеджер сцены новую камеру.
IMeshSceneNode \* wall = smgr->addCubeSceneNode();
wall->setMaterialFlag(EMF\_LIGHTING,false);
wall->setMaterialTexture(0, driver->getTexture("../../media/wall.jpg"));
int i = 0;
while(device->run()) // Это наш основной цикл. Он будет выполняться постоянно, пока работает движок.
{
i++;
if (i>256) i=0;
driver->beginScene(true, true, SColor(0,i,i,i)); // Драйвер начинает отрисовку сцены.
wall->setRotation(wall->getRotation() + vector3df(0,1,0));
smgr->drawAll(); // Менеджер сцены рисует свои объекты.
driver->endScene(); // Драйвер заканчивает отрисовку сцены.
}
device->drop(); // Движок перестает работать, можно его удалить.
return 0;
}
```` | https://habr.com/ru/post/191994/ | null | ru | null |
# Разработка HTML5-игр в Intel XDK. Часть 3. Знакомство со змейкой
[Часть 1](https://habrahabr.ru/company/intel/blog/281380/) » [Часть 2](https://habrahabr.ru/company/intel/blog/281453/) » [Часть 3](https://habrahabr.ru/company/intel/blog/281523/) » [Часть 4](https://habrahabr.ru/company/intel/blog/281607/) » [Часть 5](https://habrahabr.ru/company/intel/blog/281639/) » [Часть 6](https://habrahabr.ru/company/intel/blog/281873/) » [Часть 7](https://habrahabr.ru/company/intel/blog/281981/) // Конец )
Сегодня поговорим об архитектуре игры Snake, построенной на платформе Cocos2d-JS и приступим к её созданию. Пожалуйста, читайте этот материал, заглядывая в [документацию](http://www.cocos2d-x.org/reference/html5-js/V3.7/index.html) по Cocos2d-JS и загрузите [набор игровых ресурсов](https://software.intel.com/sites/default/files/managed/0e/b6/snake_assets.zip). Их мы будем использовать при разработке.
[](https://habrahabr.ru/company/intel/blog/281523/)
Обзор архитектуры игры
----------------------
Если вы никогда не играли в Snake, вот [готовый проект](https://github.com/alling9495/sample-snake). Скачайте его себе на компьютер, импортируйте в Intel XDK и испытайте в деле. Для того, чтобы это сделать, перейдите на вкладку Проект (Project) и щёлкните по кнопке Открыть проект Intel XDK (Open An Intel XDK Project), которая расположена в нижнем левом углу.
*Кнопка импорта проекта в Intel XDK*
Snake – простая игра. Сначала на экране лишь голова змеи. Управляя змейкой, надо нацеливать её на нечто съедобное, появляющееся случайным образом на экране. В нашем случае это – «печенье», представленное красной точкой. Змея, найдя угощение, съедает его и увеличивается в размере. При этом растёт и скорость её перемещения. Игра заканчивается, если подросшая змейка, в погоне за вкуснятиной, ненароком цапнет себя за хвост.
В нашей версии игры персонаж может выходить за границы экрана и появляться с другой его стороны. Для управления игрой на компьютере служат клавиши W, S, A, D. Они, соответственно, позволяют направлять змею вверх, вниз, влево и вправо. На устройствах с сенсорным дисплеем ту же функцию выполняет жест касания экрана с протягиванием в нужном направлении. На эмуляторе это можно воспроизвести, щёлкая по экрану мышью, и, не отпуская левую кнопку, перетаскивая указатель в том направлении, куда должна двигаться змейка.
Реализация
----------
Игра состоит из трёх сцен. Это меню (MenuScene), игровой экран (GameScene) и экран завершения игры (GameOver).
*Сцены, из которых состоит игра*
MenuScene включает в себя два спрайта, выводящих текст. Это – название игры и приглашение коснуться экрана (или щёлкнуть по нему) для запуска игры. Слоёв на этой сцене нет. Так же устроена и сцена GameOverScene. Единственное отличие в том, что она содержит три спрайта, данные для одного из которых, выводящего количество набранных очков, берутся из GameScene.
Главный игровой экран
---------------------
Сцена GameScene, представляющая собой главный игровой экран – это то место, где и происходит практически всё, что называется «игрой». Осваивая это руководство, вы будете создавать здесь игру по частям.
Убираем лишнее из шаблона проекта
---------------------------------
Стандартный шаблон проекта, который даёт нам Intel XDK, содержит компоненты, которыми мы пользоваться не будем. Уберём из него всё лишнее.
1. Откройте Проводник или другой системный файловый менеджер.
2. Войдите в папку с игровыми ресурсами (www/assets), которая расположена в папке проекта.
3. Удалите из неё всё, что там есть.
4. Извлеките в эту папку всё то, что находится в архиве с ресурсами игры.
5. Откройте файл resource.js.
```
var asset = {
HelloWorld_png : "asset/HelloWorld.jpg",
CloseNormal_png : "asset/CloseNormal.png",
CloseSelected_png : "asset/CloseSelected.png"
};
var g_resources = [];
for (var i in asset) {
g_resources.push(asset[i]);
}
```
6. Внесите в переменную asset сведения о новых ресурсах, удалив старые данные. Остальной код в файле не меняйте.
```
var asset = {
SnakeHead_png : "asset/snake_head.png",
SnakeBody_png : "asset/snake_body.png",
SnakeBiscuit_png : "asset/snake_biscuit.png"
};
```
7. Удалите файл app.js
8. Откройте файл project.json
```
"jsList" : [
"src/resource.js",
"src/app.js"
]
```
9. Удалите из jsList описание файла app.js
10. Добавьте в jsList описание файла game.js
```
"jsList" : [
"src/resource.js",
"src/game.js"
]
```
11. Откройте файл index.html
12. Найдите теги «»
13. Замените то, что в них содержится, на «Snake».
В итоге структура файлов проекта должна выглядеть так, как показано ниже.
*Структура файлов проекта после изменений*
Если в менеджере файлов редактора Brackets всё ещё видны удалённые файлы, app.js, например, перезапустите XDK.
Каркас игры готов, правда, если открыть её сейчас в эмуляторе, ничего работать не будет. Для того, чтобы это исправить, займёмся реализацией GameScene.
Реализация GameScene
--------------------
1. Создайте файл game.js. Для этого перейдите на вкладку Разработка (Develop), выполните команду меню Файл > Новый (File > New) и сохраните файл в папке www/src, дав ему имя game.js.
2. Добавьте в файл следующий код:
```
var GameScene = cc.Scene.extend({
onEnter:function () {
this._super();
}
});
```
Здесь мы описываем переменную GameScene и вызываем метод onEnter объекта-родителя нового слоя.
3. Ниже «this.\_super();» добавьте следующий код:
```
var GameScene = cc.Scene.extend({
snake_layer: {},
onEnter: function() {
this._super();
// Место для нового кода
this.snake_layer = new SnakeLayer();
this.addChild(this.snake_layer, 0);
}
});
```
Здесь создаётся слой SnakeLayer, который мы реализуем позже. Этот слой добавляется в качестве потомка GameScene. GameScene лишь включает в себя слой SnakeLayer, а уже в слое будет содержаться логика игры.
Разбираемся с головой змеи
--------------------------
Для того, чтобы игровой персонаж был похож на змею, мы создаём его из множества фрагментов, которые следуют за головой. Делается это из-за того, что змея должна уметь увеличиваться в размерах и делать повороты на 90 градусов. Классический вариант игры Snake устроен именно так. Мы, создавая свой вариант, следуем сложившейся традиции.
Приступим к реализации задуманного, добавив в game.js следующий класс.
```
var SnakePart = cc.Sprite.extend({
ctor: function(sprite) {
/* Вызов конструктора суперкласса с передачей ему спрайта, представляющего фрагмент тела змеи */
this._super(sprite);
},
move: function(posX, posY) {
/* Обновляем текущую позицию */
this.x = posX;
this.y = posY;
},
})
```
Этот класс служит для описания одного сегмента змейки. Он уже содержит метод move, который позволяет независимо перемещать каждый из сегментов.
Сама змея будет находиться в слое SnakeLayer. Это – движущая сила и мозг нашего персонажа.
Опишем слой, добавив в game.js следующий код.
```
var SnakeLayer = cc.Layer.extend({
ctor: function () {
this._super();
}
});
```
С подобным описанием мы уже встречались, в GameScene, например. Только, вместо метода onEnter здесь – конструктор объекта. Дело тут в том, что мы не просто «переходим» на слой (под руководством управляющего объекта), а создаём его. Кроме того, в этом классе будет свойство, символизирующее фрагмент тела змеи (пока – лишь её голову). Эту переменную будем использовать для того, чтобы размещать соответствующие спрайты на слое.
В ходе работы над игрой конструктор слоя SnakeLayer будет расти – в него будут добавляться команды инициализации различных объектов.
Начнём с создания головы змеи. Это, фактически, один из сегментов тела с особыми свойствами и собственным графическим представлением.
Для того, чтобы инициализировать голову змеи (переменная snakeHead), надо добавить в SnakeLayer следующий код.
```
var SnakeLayer = cc.Layer.extend({
snakeHead: null,
ctor: function () {
/* Вызов конструктора суперкласса */
this._super();
/* Создание головы змеи */
this.snakeHead = new SnakePart(asset.SnakeHead_png);
/* Добавление головы в качестве объекта-потомка слоя */
this.addChild(this.snakeHead);
},
});
```
Здесь мы добавляем объект класса SnakePart в качестве объекта-потомка слоя SnakeLayer. Мы почти готовы к тому, чтобы запустить проект в эмуляторе и увидеть там кое-что интересное, но сначала нужно подправить код управляющего объекта.
1. Перейдите в файл main.js
2. Найдите строчку «runScene»
```
cc.director.runScene(new HelloWorldScene());
```
3. Замените HelloWorldScene на GameScene.
```
cc.director.runScene(new GameScene());
```
Сохраните изменения и запустите проект в эмуляторе.
*Игра, запущенная в эмуляторе*
Результат наших трудов вполне заметен, но голова змеи закатилась в угол, да ещё и перекрыта счётчиком частоты кадров. Уберём счётчик. Для этого надо сделать следующее.
1. Откройте файл project.json
2. Измените «showFPS: true,» на «showFPS: false,»
Выводы
Подведём итоги сегодняшнего занятия.
* Игра, которую мы будем разрабатывать – это вариант классической Snake.
* Игра включает в себя три сцены: меню (Menu), игровой экран (Game), экран завершения игры (GameOver).
* Игровой персонаж, змейка, состоит из нескольких частей
Вот, что вы теперь умеете.
* Добавлять в проект игровые ресурсы и удалять их.
* Обновлять resourse.js для учёта новых или отсутствующих ресурсов.
* Удалять из проекта файлы с кодом и добавлять их.
* Обновлять заголовок игры.
* Создавать игровую сцену (GameScene).
* Создавать слои (на примере SnakeLayer).
* Реализовывать часть тела змейки (SnakePart).
* Инициализировать голову змеи.
* Отключать вывод сведений о частоте кадров.
На данном этапе работы над проектом у нас имеется игровой экран и голова змеи в углу. В следующий раз займёмся системой координат и позволим змее перебраться в более интересное место.
[Часть 1](https://habrahabr.ru/company/intel/blog/281380/) » [Часть 2](https://habrahabr.ru/company/intel/blog/281453/) » [Часть 3](https://habrahabr.ru/company/intel/blog/281523/) » [Часть 4](https://habrahabr.ru/company/intel/blog/281607/) » [Часть 5](https://habrahabr.ru/company/intel/blog/281639/) » [Часть 6](https://habrahabr.ru/company/intel/blog/281873/) » [Часть 7](https://habrahabr.ru/company/intel/blog/281981/) // Конец )
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | https://habr.com/ru/post/281523/ | null | ru | null |
# Как работает автозаполнение в браузерах и что важно учитывать веб-разработчику
Если человек пользуется автозаполнением в браузере, он ждёт, что сможет быстро заполнять формы на любом сайте, где посчитает нужным. Наладить такой механизм на стороне сайта или веб-приложения несложно, но важно помнить пару вещей — я покажу кейсы, где подходы «в лоб» приводили к непредсказуемым результатам. Чтобы автозаполнение работало эффективно и не нарушало логику, стоит хотя бы примерно представлять, как оно устроено под капотом разных браузеров, которые могут быть у пользователей. Под катом распишу, каким образом движок подставляет данные в формы.
Пароли, карты, личные данные
----------------------------
Есть три основные группы форм, где обычно требуется автозаполнение: личные данные, банковские карты и пароли.
Самая широкая группа — личные данные. К ним относятся имена, адреса, телефоны, дата рождения, пол и всё, что не попадает в группу паролей и банковских карт. У этих данных очень разный формат, поэтому часто браузеры и сайты слабо прорабатывают автозаполнение. В статье я в основном буду говорить про заполнение личных данных.
У банковских карт есть особенности сохранения и подстановки, так как речь идёт про очень чувствительные данные. Допустим, браузеры на основе Chromium, в том числе Яндекс Браузер, запрещают подстановку данных карты на сайтах с небезопасным http-соединением — и требуют https. В целом, обработка данных банковских карт укладывается в общий с личными данными механизм. Я не буду углубляться в особенности автозаполнения банковских карт, но большая часть статьи будет актуальна и для этой группы.
Пароли — тоже чувствительная к безопасности группа данных. Существенная часть всех автозаполнений приходится именно на парольные формы, так что этот сценарий лучше всего проработан браузерами и сайтами. В Chromium механизм сохранения и автозаполнения паролей сильно отличается от аналогичного для личных данных и банковских карт. В этой статье углубляться в парольную специфику мы не станем.
Как это работает?
-----------------
Чтобы понять, как работает автозаполнение, предположим, что у браузера уже есть сохранённые данные пользователя. К механизму их получения перейдём ниже, а пока рассмотрим вставку значения в поле с момента, когда пользователь нажал на это поле:
1. Браузер получает сигнал о том, что нужно подготовить подсказки для заполнения поля. Как правило, этот сигнал происходит в момент, когда пользователь устанавливает фокус в поле.
2. Браузер собирает информацию о поле и для целей автозаполнения его интересуют в первую очередь атрибуты autocomplete, name, placeholder, id и label.
3. В зависимости от собранной информации, браузер вычисляет подсказку с данными для автозаполнения на основе алгоритма:
* если указан атрибут autocomplete с указанием типа, то он выдаёт соответствующие данные, например ФИО, адрес или дату рождения;
* в противном случае браузер пробует вычислить тип на основе значений атрибутов name, placeholder, id и label и возвращает соответствующие данные;
* если вычислить тип не удаётся, то браузер ищет историческую подсказку, то есть ранее сохранённое значение для поля по значению его атрибута name.
4. Пользователь выбирает подсказку, и браузер подставляет значения в поля формы на странице.
Интересно, что само по себе заполнение полей на странице не всегда происходит гладко и без багов. Например, номера телефонов доставляют целый ворох проблем. В России номера начинаются на +7, а люди часто используют вместо этого 8. Браузер может хранить номера в обоих форматах. Проблемы начинаются во время вставки:
* Сайт может запрещать редактировать первую цифру и давать ввести номер, начиная с 9.
* Сайт может позволить вставить 8, ожидая +7, и жаловаться на неверный формат номера.
* Сайты могут самовольно форматировать введённый номер и не всегда оказываются готовы к автозаполнению. Они добавляют пробелы, скобочки или дефисы и портят номер телефона так, что пользователю приходится его стирать и вводить вручную.
* На сайтах можно встретить выпадающие списки, которые тоже не всегда готовы к автозаполнению со стороны браузера и ломаются, потому что ожидают, что поле будет пустым, пока пользователь не выберет значение из списка.
Программируйте системы форматирования, выпадающие списки и формы в целом с учётом того, что данные в поле попадут со стороны браузера, а не только в ходе заполнения пользователем.
Так выглядит автозаполнение от выделения поля до вставки в него значения в общем виде. Самый интересный и сложный этап — вычисление подсказки. Разобьём его на несколько тем:
* система типов полей,
* исторические подсказки,
* атрибут autocomplete.
Система типов полей
-------------------
Тип поля — характеристика, однозначно описывающая данные, которые это поле ожидает в качестве ввода. Типов полей бывает очень много. За их добавление и поддержку отвечают разработчики браузера. Задача типов — однозначно сопоставить поле и соответствующую ему информацию о пользователе.
Примеры типов полей представлены в таблице ниже, а их полный список можно посмотреть в исходниках Chromium.
| | | |
| --- | --- | --- |
| **Тип** | **Описание** | **Пример** |
| UNKNOWN\_TYPE | Тип данных не определился | - |
| NAME\_FIRST | Имя | Александр |
| NAME\_MIDDLE | Отчество | Александрович |
| NAME\_LAST | Фамилия | Алехин |
| NAME\_FULL | ФИО | Александр
Александрович
Алехин |
| EMAIL\_ADDRESS | Электронная почта | test@ya.ru |
| ADDRESS\_HOME\_LINE1 | Улица и дом | Льва Толстого, 16 |
| ADDRESS\_HOME\_CITY | Город | Москва |
| ADDRESS\_HOME\_STATE | Область | Московская |
| ADDRESS\_HOME\_ZIP | Индекс | 119021 |
| ADDRESS\_HOME\_COUNTRY | Страна | Россия |
| CREDIT\_CARD\_NAME\_FULL | Полное имя владельца
банковской карты | Ivanov Ivan |
| CREDIT\_CARD\_NUMBER | Номер банковской карты | 5555 5555 5555 4444 |
| CREDIT\_CARD\_VERIFICATION\_CODE | CVV банковской карты | 123 |
| USERNAME | Логин | User0197 |
Автозаполнение на основе типов гарантирует, что в поле окажутся данные только конкретного типа. Допустим, в поле адреса не окажется ФИО. В этом и есть его важное преимущество и отличие от исторических подсказок, которые работают без привязки к типам.
Регулярные выражения — важный инструмент в определении типов. С их помощью сопоставляются значения атрибутов полей с существующими типами. Проще всего объяснить логику работы регулярных выражений с помощью примеров.
Примеры успешных сопоставлений полей и типов:
```
```
В примере успешных сопоставлений браузер видит на одном из полей атрибут id со значением first\_name. Регулярные выражения сопоставляют это значение с типом NAME\_FIRST и таким образом определяют тип поля. Аналогично определяются типы других полей.
Примеры неудавшихся сопоставлений:
```
```
Здесь заметно несовершенство подхода с регулярными выражениями. Оно проявляется в атрибутах, по которым невозможно установить тип. Яркий пример — неосмысленные значения полей, как `id="xdia_13"` в примере выше. Регулярные выражения по-разному настроены для разных языков. Поэтому в полях с, казалось бы, идентичными значениями `name="address_mail"` и `placeholder="Адрес почты"` тип определяется по-разному.
Другая проблема состоит в логически неверном определении типа. Такое случается, если атрибуты недостаточно точно говорят о назначении поля. Допустим, сайт может предложить пользователю заполнить фамилию и имя в двух разных полях. При этом поле с именем отмечено атрибутом `name=“name”`. В этом случае браузер определит тип поля как NAME\_FULL, то есть ФИО, а не NAME\_FIRST — только имя, и покажет неверную подсказку или неверно сохранит данные.
Другой подобный пример связан с датами. В форме покупки авиабилета часто встречается поле с датой вылета. Браузер может вычислить тип такого поля как дату рождения пользователя, с неприятными последствиями в виде неверной подсказки или сохранения неверной информации.
Как видим, система, основанная на типах, имеет свои минусы:
* требует дополнительных вычислений;
* определение типа в ней не всегда возможно и иногда оно работает неверно;
* лишена гибкости, потому что типы определяют разработчики браузера, и сложно предусмотреть все виды полей.
Разработчики сайтов могут осмысленно заполнять атрибуты name, placeholder, id и label. Это поможет браузеру верно определить тип поля и улучшить опыт взаимодействия с сайтом.
Исторические подсказки
----------------------
Система типов полей не всегда работает надёжно. Ей могут помешать неосмысленные значения атрибутов или поле может изначально не попадать ни под один известный тип. В этом случае на помощь приходит ещё один механизм, который вносит свою большую лепту в автозаполнение. Мы называем его историческими подсказками.
Суть механизма состоит в том, что браузер пробует найти в своём хранилище данные для заполняемого поля по его атрибуту name. Если такие данные нашлись, то пользователь увидит подсказку. Если нет, то после заполнения и отправки формы значение поля будет сохранено в виде пары: `name: value`. Далее браузер сможет использовать эту пару для формирования подсказки, в том числе и на других сайтах, если встретит там поле с уже известным именем. Периодически браузер удаляет записи, которые не использовались определённое время.
Важно отметить, что браузер накладывает некоторые условия на сохранение таких полей. Например, у поля не должно быть значения атрибута `autocomplete=“off”`. Значение поля сохраняться не будет, и браузер не подскажет его пользователю.
Логично ожидать, что `autocomplete=“off”` выключит автозаполнение и сохранение информации из поля. По факту это выключит только исторические подсказки, но пользователи могут увидеть другие — основанные на типах! Дело в том, что стандарт HTML даёт весьма нечёткое определение поведения для некоторых значений атрибута.
Атрибут autocomplete
--------------------
С помощью атрибута autocomplete разработчики сайта могут вручную контролировать поведение автозаполнения. Значениями атрибута могут быть “on”, “off” или тип поля, например “street-address” или “username”. Этот инструмент приоритетнее остальных, он прописан в стандарте HTML. Это самый надёжный способ управлять автозаполнением.
Можно сказать, что огромная машинерия браузера по угадыванию типов полей со всеми недостатками, ошибками и проблемами во многом нужна только потому, что сайты зачастую игнорируют autocomplete. В лучшем случае они используют `autocomplete=”on”/”off”`.
Значение `autocomplete=”on”` согласно стандарту [подразумевает](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#attr-fe-autocomplete-on), что браузер волен сохранять и подсказывать значения как угодно:
> The «on» keyword indicates that the user agent is allowed to provide the user with autocompletion values, but does not provide any further information about what kind of data the user might be expected to enter.
Намного интереснее значение `autocomplete=”off”`. Логично ожидать, что так можно выключить все подсказки для поля, но это носит рекомендательный характер. В стандарте написано, что не следует сохранять данные из поля и предлагать ранее сохранённые значения. В случае обязательных требований стандарт использует must/must not.
> When an element's autofill field name is «off», the user agent **should not** remember the control's data, and **should not** offer past values to the user.
Здесь и ниже под autofill field name подразумевается значение атрибута autocomplete.
Более того, в стандарте можно найти формулировку, согласно которой браузер позволяет пользователю самому изменить значение `autocomplete=”off”` и сохранить заполненные данные или автозаполнить поле.
> A user agent may allow the user to override an element's autofill field name, e.g. to change it from «off» to «on» to allow values to be remembered and prefilled despite the page author's objections, or to always «off», never remembering values.
Другая формулировка вообще говорит, что браузер может рассмотреть возможность менять значение autocomplete.
> More specifically, user agents may in particular consider replacing the autofill field name of form controls…
Согласно стандарту мусорные значения типа “none”, “smth” и другие наряду с отсутствием атрибута нужно интерпретировать как поведение по умолчанию, то есть “on”: [Processing model, пункт 5](https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill-processing-model). Любопытно, что в этой части Chromium отходит от стандарта и не предлагает подсказки для полей с мусорными значениями. Яндекс Браузер поступает так же. Таким образом, самый надёжный ~~костыль~~ способ выключить автозаполнение с помощью атрибута — задать ему мусорное значение типа “none”, “smth” или любое другое.
Стандарт HTML весьма расплывчато регламентирует работу автозаполнения. Дисклеймер стандарта в части автозаполнения [помечен](https://html.spec.whatwg.org/#enabling-client-side-automatic-filling-of-form-controls) как «This section is non-normative», из-за чего браузеры вынуждены по-своему его интерпретировать. Поэтому поведение атрибута autocomplete со значением “off” только на первый взгляд кажется неожиданным.
Таким образом, Chromium интерпретирует `autocomplete=“off”` как отключение исключительно исторических подсказок. Браузер изменит значение “off” на “on”, если смог определить тип поля, и покажет подсказку, основанную на типе.
В то же время стандарт весьма чётко определяет поведение атрибута со значением “on” и особенно с конкретным типом. Получается, что лучший способ управлять автозаполнением на странице — указать тот тип для поля, который максимально соответствует его смыслу.
#### Отправка формы
Дальше поговорим о том, как браузер получает данные для последующей подстановки. Отправка формы — единственный источник данных о пользователе для браузера. Также браузер даёт пользователям возможность самим сохранить имя, адрес, банковскую карту для оплаты покупок и прочие данные в настройках. Но доля данных, сохранённых таким образом, ничтожно мала по сравнению с отправкой.
В самом простом случае браузер обрабатывает событие submit согласно стандартному поведению отправки формы — это сигнал для сохранения данных. Однако далеко не все формы отправляют такое событие. Многие формы используют нестандартные механизмы отправки данных на сервер. А ещё многие сайты предлагают пользователям заполнять данные в формах, где нет тега form — назовём их **бесформенными формами**. Это так же мешает браузеру обработать отправку и сохранить данные (ниже обсудим, почему). Всё это вынуждает разработчиков браузера изобретать дополнительные способы наблюдения отправки формы на сайте.
Выделим несколько сценариев отправки с примерами:
* С тегом и событием.
```
```
* С тегом, но без события.
```
```
* Без тега, но с событием.
```
```
* Без тега и без события.
```
Button
```
В интернете встречаются все перечисленные комбинации, поэтому браузеру важно уметь работать с отправкой всевозможных форм.
**iOS-специфика**
Я занимаюсь автозаполнением в Яндекс Браузере на iOS, поэтому примеры ниже будут про эту платформу. По большей части логика сохранения данных и наблюдения за отправкой форм одинакова для всех платформ. Механизм строится по одному и тому же алгоритму и будет интересен вне зависимости от ваших предпочтений в платформе. Но у iOS есть своя специфика, которую важно объяснить прежде, чем мы углубимся в реализацию наблюдения отправки форм.
#### WebKit
Особенность разработки браузера на iOS состоит в том, что в работе со страницами приходится полагаться на движок WebKit. Он отвечает за рендеринг страницы, хранит данные HTML-формы, позволяет работать с JavaScript и прочее. Desktop и Android работают со страницей с помощью движка Blink. При желании вы можете изменить его код и добиться нужного поведения. На iOS приходится подстраиваться под API, которое предоставляет WebKit. При этом Apple в своём браузере Safari использует так называемое приватное API (методы движка WebKit), которое запрещает использовать его другим разработчикам. К счастью, есть способы обойти ограничение, но они могут не понравиться Apple.
Например, внутри WebKit есть [функция](https://github.com/WebKit/WebKit/blob/main/Source/WebKit/UIProcess/API/Cocoa/_WKInputDelegate.h#L48), которая сообщает в нативный код браузера информацию об отправке формы. Выглядит так, что это то, что нужно, чтобы отловить submit, и даже Blink работает по аналогии. Но использовать эту функцию нельзя, так как она спрятана в недрах WebKit и не является открытым API. Это лишь одно из ограничений. По сравнению с Blink их очень много.
#### Chromium
Для обхода ограничений Chromium нашёл «изящный» выход. При загрузке страницы браузер добавляет к ней скрипт, в котором подписывается на события JavaScript. С их помощью браузер отлавливает события отправки форм, изменения DOM-дерева, заполняет поля формы и многое другое. Нативный код в iOS взаимодействует со страницей с помощью JavaScript, в отличие от Android и Desktop. Они взаимодействуют со страницей напрямую из нативного кода благодаря движку Blink.
У подхода со скриптом есть свои минусы:
* скорость выполнения JavaScript ниже нативного кода;
* асинхронный обмен данными со страницей;
* дублирование логики, схожей с Blink, и переписывание её на JavaScript;
* код страницы может делать непонятное и ломать работу автозаполнения браузера, например, переписывать стандартный конструктор строки (случай из реальной жизни).
Скрипт добавляет обработчик на JS-событие submit, и он оповещает нативный код об этом событии. И это единственный способ узнать об отправке формы с личными данными в Chromium для iOS на текущий момент.
Важно отметить, что ситуация с парольными формами обстоит значительно лучше. Для них Chromium обрабатывает поля без тега form и применяет эвристики по определению отправки при отсутствии явного события submit. **То есть разработчики браузеров пришли к тому, что странно полагаться только на submit.**
Итак, Chromium на iOS не умеет анализировать бесформенные формы с личными данными и оставляет их без внимания, потому что они выпадают из стандартного механизма отправки. Это ведёт к тому, что значительная часть введённых данных не сохраняется, и пользователь не увидит в дальнейшем подсказку, если будет заполнять похожую форму.
В парольных формах с наиболее чувствительной информацией Chromium ориентируется на событие click. Это менее говорящее событие, поэтому браузер вынужден делать дополнительные проверки, чтобы убедиться, что произошла отправка. Суть проверки состоит в том, чтобы понять, что нажатие случилось по кнопке, и это единственная на форме кнопка.
Эти элементы считаются кнопками:
```
```
Таким образом, на отправку может указывать нажатие кнопки в том числе без явного JS-события submit.
#### Бесформенные формы
Отсутствие тега form вносит сложность во многие аспекты механизма автозаполнения, например вставку данных, обработку отправки и сохранение данных.
Основная сложность в работе с бесформенными формами заключается в том, что браузер не может чётко определить границы заполняемой формы. Фактически браузеру приходится анализировать всю страницу с целью собрать все поля ввода и найти кнопки, которые могут вызвать отправку. Ограничение на клик по единственной на форме кнопке для таких форм превращается в ограничение на единственную кнопку на странице.
Немного острее проблема проявляется в single-page applications, где отправиться может малая часть полей, например адрес доставки, но браузер вынужден заодно считать отправленными все остальные поля — почту и телефон, которые могут быть заполненными не полностью.
На удивление, бесформенных форм очень много, и по нашим данным, около трети отправок на Android- и Desktop-версии Яндекс Браузера приходится на такие формы.
#### Эвристики
У браузера есть ещё несколько козырей в рукаве для того, чтобы обнаружить отправку формы, в том числе по сценарию с отсутствием тега и события submit. Более того, многие формы достаточно ~~упороты~~ сложны, чтобы браузер не смог определить отправку и в других сценариях с помощью JavaScript, например:
```
Button
```
Или:
```
```
Видно, что эти примеры с точки зрения автозаполнения отличаются лишь наличием тега form. С этими формами мы наблюдаем две проблемы, которые не дают поймать отправку:
* нет события submit,
* есть несколько кнопок, и мы не можем с уверенностью считать клик отправкой.
Но есть и косвенные признаки отправки формы, на которые браузер умеет реагировать. Как правило, отправка формы вызывает некоторые действия на странице, например:
* переход на страницу успешной отправки формы,
* удаление iframe, внутри которого пользователь заполнял форму,
* удаление заполненных элементов формы или формы целиком.
Итак, можно выделить признаки, которые могут говорить об отправке:
* навигация,
* удаление формы,
* удаление iframe.
Эти признаки — потенциальные триггеры к отправке. Чтобы она случилась, браузер наблюдает за процессом заполнения формы и фиксирует введённые данные во внутренних структурах. Далее при наступлении одного из трёх триггеров браузер проверяет наличие сохранённой формы с заполненными полями и фиксирует это как отправку.
Главным минусом такого подхода предполагается возможность ложных срабатываний. Ложные срабатывания приведут к тому, что браузер сохранит неверную информацию и будет показывать пользователю нерелевантные подсказки. Может проявиться и проблема быстродействия, потому что эвристики требуют от нативного и JS-кода браузера дополнительной работы.
Chromium не использует эвристики для заполнения личных данных и банковских карт, зато применяет их в случае с паролями.
Итоги
-----
Автозаполнение — настолько же сложная и многогранная тема, как и сам веб. Есть множество вариантов форм, и их разновидности ограничены лишь полётом фантазии разработчиков сайтов. Браузеры подстраиваются и учатся обрабатывать максимально возможное число форм, чтобы облегчить пользователям взаимодействие с сайтами.
Подытожим моменты, на которые браузер обращает внимание. Вот к чему я призываю разработчиков сайтов, чтобы автозаполнение работало эффективно:
* Используйте атрибут autocomplete и настраивайте автозаполнение согласно логике сайта.
* Заполняйте атрибуты осмысленными значениями и не допускайте неоднозначности.
* По возможности применяйте стандартный способ отправки.
Я постарался приоткрыть завесу сложностей вокруг автозаполнения, с которыми сталкиваюсь я и мои коллеги. Надеюсь, команды популярных браузеров и разработчики сайтов будут работать ещё теснее, чтобы делать автозаполнение корректным и удобным. | https://habr.com/ru/post/686668/ | null | ru | null |
# Краткое сравнение библиотек отказоустойчивости на JVM
Независимо от того, внедряете ли вы микросервисы или нет, есть вероятность, что вы вызываете конечные точки HTTP. С HTTP-вызовами многое может пойти не так. Опытные разработчики планируют это и проектируют не только успешные пути. В общем отказоустойчивость (Fault Tolerance) включает в себя следующие функции:
* Retry (повтор попытки)
* Timeout (тайм-аут)
* Circuit Breaker (автоматический выключатель)
* Fallback (откат)
* Rate Limiter (ограничитель скорости), чтобы избежать кода ответа 429 от сервера
* Bulkhead: ограничитель скорости ограничивает количество вызовов в определенный период времени, а Bulkhead ограничивает количество одновременных вызовов.
Несколько библиотек реализуют эти функции на JVM. В этом посте мы рассмотрим [Microprofile Fault Tolerance](https://download.eclipse.org/microprofile/microprofile-fault-tolerance-1.1.2/microprofile-fault-tolerance-spec.html), [Failsafe](https://failsafe.dev/) и Resilience4J.
### Отказоустойчивость Microprofile
[Отказоустойчивость Microprofile](https://download.eclipse.org/microprofile/microprofile-fault-tolerance-1.1.2/microprofile-fault-tolerance-spec.html) является частью зонтичного проекта Microprofile. Она отличается от двух других тем, что это *спецификация*, которая полагается на среду выполнения для обеспечения этих возможностей. Например, Open Liberty является одной из таких сред выполнения. [SmallRye Fault Tolerance](https://smallrye.io/docs/smallrye-fault-tolerance/5.2.1/index.html) — еще одна. В свою очередь, другие компоненты, такие как Quarkus и WildFly, включают SmallRye.
Microprofile определяет *аннотации* для каждой функции: `@Timeout`, `@Retry Policy`, `@Fallback`, `@Circuit Breaker`и `@Bulkhead`. Он также определяет *аннотацию* `@Asynchronous`.
Поскольку среда выполнения считывает аннотации, следует внимательно прочитать документацию, чтобы понять, как они взаимодействуют, если установлено более одной аннотации.
> *Можно указать аннотацию* `@Fallback`, и она будет вызываться, если генерируется исключение `TimeoutException`. Если используется аннотация `@Timeout` вместе с `@Retry`, `TimoutException` вызовет `@Retry`. Когда используется `@Timeout` с `@CircuitBreaker`и если происходит `TimeoutException`, отказ будет вызывать `@Circuit Breaker`.
>
> *—*[*Timeout Usage*](https://download.eclipse.org/microprofile/microprofile-fault-tolerance-1.1.2/microprofile-fault-tolerance-spec.html#_timeout_usage)
>
>
### Resilience4J
Я наткнулся на [Resilience4J](https://resilience4j.readme.io/docs), когда вел свой доклад о шаблоне Circuit Breaker. Доклад включал демонстрацию, и она опиралась на [Hystrix](https://github.com/Netflix/Hystrix). Однажды я захотел обновить демоверсию до последней версии Hystrix и заметил, что разработчики отказались от нее в пользу Resilience4J.
Resilience4J основан на нескольких основных концепциях:
* Один JAR-файл для каждой функции отказоустойчивости с дополнительными JAR-файлами для определенных интеграций, *например*, с Kotlin.
* Статические фабрики
* Композиция функций с помощью *шаблона Decorator,* примененного к функциям
* Интеграция с функциональными интерфейсами Java, *например*, `Runnable`, `Callable`, `Function`, и т. д.
* Распространение исключений: можно использовать функциональный интерфейс, который выбрасывает исключение, и библиотека будет распространять его по цепочке вызовов.
Вот упрощенная диаграмма классов для `Retry`.
Каждая функция отказоустойчивости построена на основе одного и того же шаблона, показанного выше. Можно создать конвейер из нескольких функций, используя композицию функций, каждая из которых вызывает другую.
Проанализируем пример:
| | |
| --- | --- |
| 1 | Декорируем базовую функцию `server.call()` с помощью `Retry`: эта функция должна быть protected. |
| 2 | Используем конфигурацию по умолчанию |
| 3 | Создаем новую конфигурацию *Circuit Breaker* |
| 4 | Установим порог, выше которого вызов считается медленным |
| 5 | Подсчитаем скользящее окно из 2 вызовов |
| 6 | Минимальное количество вызовов для принятия решения о размыкании *Circuit Breaker* |
| 7 | Декорируем функцию повтора *Circuit Breaker* с приведенной выше конфигурацией. |
| 8 | Создаем значение fallback, которое будет возвращаться при отключении *Circuit Breaker.* |
| 9 | Список исключений для обработки: они не будут распространяться. Resilience4J генерирует исключение `CallNotPermittedException` когда цепь разомкнута. |
| 10 | В случае возникновения какого-либо из настроенных исключений вызываем эту функцию |
Может быть трудно разобраться с порядком, в котором расположены эти функции. Поэтому проект предлагает класс `Decorators`, объединяющий их с помощью гибкого API. Вы можете найти его в модуле `resilience4j-all`. Можно переписать приведенный выше код как:
```
var pipeline = Decorators.ofSupplier(() -> server.call())
.withRetry(Retry.ofDefaults("retry"))
.withCircuitBreaker(CircuitBreaker.of("circuit-breaker", config))
.withFallback(
List.of(IllegalStateException.class, CallNotPermittedException.class),
e -> "fallback"
);
```
Это делает цель более ясной.
### Failsafe
Я наткнулся на Failsafe не так давно. Его принципы аналогичны Resilience4J: статические фабрики, композиция функций и распространение исключений.
В то время как функция отказоустойчивости Resilience4J не имеет общей иерархии классов, Failsafe предоставляет концепцию `Policy`:
Я считаю, что основное отличие Failsafe от Resilience4J заключается в его конвейерном подходе.
API Resilience4J требует, чтобы вы сначала предоставили «базовую» функцию, а затем встроили ее в любую функцию обертку (wrapper function). Вы не можете использовать цепочку из различных базовых функций.
Failsafe разрешает это с помощью класса `FailsafeExecutor`.
Вот как можно создать конвейер, *т*. е. экземпляр `FailsafeExecutor`. Обратите внимание, что в коде нет ссылки на базовый вызов:
| | |
| --- | --- |
| 1 | Определяем список политик, применяемых от последней к первой по порядку. |
| 2 | Fallback значение |
| 3 | Если время вызова превышает 2000 мс, генерируется исключение TimeoutExceededException. |
| 4 | Политика повторных попыток по умолчанию |
Теперь можно обернуть вызов:
```
pipeline.get(() -> server.call());
```
Failsafe также предоставляет удобный API. С его помощью можно переписать приведенный выше код так:
```
var pipeline = Failsafe.with(Fallback.of("fallback"))
.compose(RetryPolicy.ofDefault())
.compose(Timeout.ofDuration(Duration.of(2000, MILLIS)));
```
### Вывод
Все три библиотеки предоставляют более или менее равноценные функции. Если вы не используете среду выполнения, совместимую с CDI, такую как сервер приложений или Quarkus, забудьте о Microprofile Fault Tolerance.
Failsafe и Resilience4J основаны на композиции функций и очень похожи. Если вам нужно определить цепочку функций независимо от вызова базовых, отдайте предпочтение Failsafe. В противном случае можно выбрать любой из них.
Поскольку я лучше знаком с Resilience4J, я, вероятно, буду использовать Failsafe в своем следующем проекте, чтобы получить больше опыта.
### Дальнейшее чтение:
* [Microprofile Fault Tolerance specification](https://download.eclipse.org/microprofile/microprofile-fault-tolerance-1.1.2/microprofile-fault-tolerance-spec.html)
* [SmallRye Fault Tolerance Documentation](https://smallrye.io/docs/smallrye-fault-tolerance/5.0.0/index.html)
* [Introduction to Resilience4J](https://resilience4j.readme.io/docs)
* [Failsafe overview](https://failsafe.dev/) | https://habr.com/ru/post/645377/ | null | ru | null |
# Пятничный JS: минус без минуса
И вновь я приветствую всех в моей традиционной рубрике. Сегодня вы узнаете, что же такого особенного произошло 31 декабря 1969 года, ровно за миллисекунду до полуночи. Точнее, вы узнаете не только лишь это, но только к этому примеру я смог подобрать картинку, а развлекательная статья без картинок — нонсенс.
В последнее время я немного занимаюсь преподаванием. С целью расширить ученику сознание я задал ему такую задачку:
> Написать функцию sub(a, b), которая будет находить разность чисел a и b. Однако в тексте функции не должно быть символа "-".
Сейчас для любознательного читателя наступило время отложить чтение статьи и попытатся решить задачу самостоятельно. Поэтому, чтобы он случайно не увидел одно из решений, приведённых ниже, я вставлю картинку со снежинкой, которая не растает, пока часы двенадцать бьют.
Формулируя задачу, я намекал на один конкретный способ, связанный с темой, которую мы недавно проходили. Но уже после я задумался: а какие способы ещё существуют в этом богатом на неочевидные возможности языке? Результатами нескольких часов размышлений на эту тему я хотел бы с вами поделиться.
### Общие соображения
Самый простой и безглючный способ сделать вычитание без вычитания — это каким-то образом получить значение «минус единица», а затем написать:
```
return a + b * minusOne;
```
Если получить каким-то образом строку "-", можно элементарно превратить её в минус единицу:
```
let minusOne = (minusChar + 1) | 0;
```
Если мы захотим обойтись без этих маленьких трюков, нас ожидает боль. Доставят нам её, во-первых, специальные значения (Infinity, NaN), во-вторых, возможная потеря точности при менее тривиальных операциях над числами. Но это не значит, что нам не нужно пытаться. Всё, что нас не убивает, нас делает сильней.
### Самое очевидное
Первый способ, который, по моему разумению, должен прийти в голову новичку — это использование [Array#indexOf](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf). Конечно, это не первая подходящая вещь, на которую можно наткнуться, если методично читать Флэнагана по порядку. Однако новичку не нужно читать Флэнагана по порядку, так он быстро утонет в обилии ненужной информации. Array#indexOf удачно сочетает в себе простоту и практическую полезность, потому я склонен полагать это самым очевидным решением.
```
function sub(a, b){
let minusOne = [].indexOf(0);
return a + b * minusOne;
}
```
Метод indexOf, как следует из его названия, возвращает индекс элемента в массиве. Если в массиве такой элемент отсутствует, возвращается специальное значение -1. Очень кстати.
### Битовые операции
А это первое, что должно было прийти в голову какому-нибудь суровому сишнику. Например, так:
```
function sub(a, b){
let minusOne = ~0;
return a + b * minusOne;
}
```
Тильда в джаваскрипте символизирует побитовое отрицание. Из-за [особенностей](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%B4) внутреннего представления отрицательных чисел побитовое отрицание нуля волшебным образом оказывается минус единицей. Кстати говоря, верно и обратное, из-за чего некоторые имеют привычку записывать условие вхождения элемента в массив следующим образом:
```
if(~arr.indexOf(elem)){ //...
```
Сейчас, с появлением [Array#includes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes), этот хак становится менее актуальным.
Также минус единицу можно получить и более изощрёнными способами. Например, побитовым сдвигом:
```
let minusOne = 1 << 31 >> 31;
```
### Math
А это первое, что должно приходить в голову математику. Методы глобального объекта Math предоставляют множество способов. Например:
```
function sub(a, b){
let minusOne = Math.cos(Math.PI);
return a + b * minusOne;
}
```
Или альтернативные способы:
```
let minusOne = Math.log(1/Math.E);
//или даже так
minusOne = Math.sign(Number.NEGATIVE_INFINITY);
```
Кстати, способ с логарифмом даёт возможность вычитать числа «напрямую», без предварительного получения минус единицы:
```
function sub(a, b){
return Math.log( Math.E ** a / Math.E ** b);
}
```
Впрочем, о проблемах такого подхода я уже писал в «общих соображениях».
### Строки
Способов получить строку "-" много. Самый очевидный, пожалуй, этот:
```
function sub(a, b){
let minusChar = String.fromCharCode(45);
let minusOne = (minusChar + 1) | 0;
return a + b * minusOne;
}
```
Также можно воспользоваться замечательными возможностями Юникода ~~провались они в ад~~:
```
let minusChar = "\u002d";
```
Кроме того, этот символ можно вытащить из строки, уже его содержащей. Например, так:
```
let minusChar = 0.5.toExponential()[2];
// 0.5.toExponential() == "5e-1"
minusChar = (new Date(0)).toISOString()[4].
//(new Date(0)).toISOString() == "1970-01-01T00:00:00.000Z"
```
Кстати говоря, если мы получили символ минуса, нам вовсе не обязательно получать минус единицу. Можно сделать следующим образом:
```
function sub(a, b){
let minusChar = "\u002d";
return eval("(" + a + ")" + minusChar + "(" + b + ")");
}
```
За это, конечно, придётся в следующей жизни родиться кольчатым червём, но если вы дочитали эту статью до текущего предложения, очевидно, вам нечего терять.
### Когда приходит год молодой
И раз уж речь зашла о датах, вот ещё один способ получить минус единицу:
```
let minusOne = Date.UTC(1969, 11, 31, 23, 59, 59, 999);
```
Дело в том, что джаваскриптовые даты «под капотом» содержат т.н. [Unix time](https://en.wikipedia.org/wiki/Unix_time) — количество миллисекунд, прошедших с полуночи первого января 1970 года. Соответственно, тридцать первого декабря 1969 года, в 23:59:59 и 999 миллисекунд это значение равнялось в точности -1.
### Не повторять дома
Напоследок приведу пару сложных и плохо работающих способов.
Если оба числа положительны, конечны и первое больше второго, можно воспользоваться делением с остатком.
```
function sub(a, b){
let r = a % b;
while(r + b < a){
r += b;
}
return r;
}
```
Это будет работать за счёт того, что `a == a % b + b * n`, где n — некоторое целое число. Соответственно, `a - b == a % b + b * (n - 1)`, а значит, прибавляя к остатку b, мы рано или поздно получим искомую величину.
Если хорошенько подумать, можно избавиться от цикла. Действительно, цикл проходит больше нуля итераций, только если b укладывается в a более одного раза. Этого можно избежать следующим образом:
```
function sub(a, b){
return (a + a) % (a + b);
}
```
Однако этот способ по-прежнему некорректно работает с отрицательными числами (из-за того, что с ними очень странно работает оператор "%"), с вычитаемым больше уменьшаемого и со специальными значениями.
И наконец (барабанная дробь, фанфары), в лучших традициях вычислительной математики мы можем посчитать разность методом половинного деления:
```
function sub(a, b){
var d = 1; // дельта. то, что мы будем пытаться прибавить к b так, чтобы получилось не более чем a
var r = 0; // наш будущий результат вычитания
//сначала находим d, превышающее разность.
while(b + d < a){
d *= 2;
}
//далее последовательно прибавляем его к r, при необходимости уменьшая вдвое
while(b + r < a){
if(b + r + d > a){
d /= 2;
}else{
r += d;
}
}
//в силу конечной точности представления чисел в js этот процесс когда-нибудь закончится
return r;
}
```
Опять же, этот способ работает, только если a >= b, и если ни одно из чисел не является бесконечностью или NaN.
На этом я заканчиваю. Если вам удалось придумать способ, существенно отличающийся от приведённых в статье, обязательно напишите об этом в комментариях. Хорошей вам пятницы! | https://habr.com/ru/post/352428/ | null | ru | null |
# Самая маленькая система управления перезагрузкой для Linux
*Делаем из мухи слона или кнопка для пингвина*
### Введение
После установки системы Gentoo Linux на свой нетбук я неожиданно обнаружил, что в системе нет штатного средства выключения и перезагрузки от обычного пользователя без использования **sudo.**
### Защитное слово автора
Сразу хотел бы отметить, что не призываю пользоваться данной программой, так как решение для управления выключением и перезагрузкой, предложенное мной, является нестандартным средством и по этой причине не может быть рекомендовано. Код программы также не может служить примером для обучения, поскольку автор программы не является профессиональным программистом. Данная статья и код на языке C публикуются в ознакомительных целях.
### История вопроса
После установки системы Gentoo Linux на свой нетбук я неожиданно обнаружил, что в системе нет штатного средства выключения и перезагрузки от обычного пользователя без использования дополнительных средств вроде программы **sudo,** а исследование файла
**/etc/group** показало, что в нём нет группы **operator.** Любые попытки добавить эту группу и пользователя в неё не принесли желаемого результата - компьютер не перезагружался от простого пользователя.
Несколько поразмыслив, я пришёл к идеи (вероятно, я не был первым) научить планировщик **cron** перезагружать и выключать компьютер . Для этого мной наскоро был написан скрипт на **bash** и добавлено задание в cron для суперпользователя.
Скрипт запускался раз в минуту от **root,** проверял файл в директории пользователя на наличие в нём **управляющего символа** и осуществлял перезагрузку или выключение, записывал в этот файл **код 0** для бездействия, чтобы компьютер не начал перезагружаться бесконечно. Я и сам не заметил, что своими руками создал уязвимость в системе (хотя подозрения были). Спасибо участникам форума [Linux.org.ru](http://Linux.org.ru), которые вовремя [указали мне](https://www.linux.org.ru/forum/desktop/17045140?cid=17045842) на ошибки и [дали ряд дельных советов](https://www.linux.org.ru/forum/desktop/17045140?cid=17045842) по улучшению моей скромной системы.
### Описание технологии
После некоторых переработок система приобрела следующий вид:
1. На языке C написана программа, которая выполняется 1 раз при старте системы через **планировщик cron** и создаёт специальный файл **/run/shut.txt**. Данному файлу присваиваются права на чтение для **root** и права на запись для пользователя. Хозяином файла назначается пользователь.
2. Написана еще одна программа на C, назначение которой один раз в минуту проверять появление управляющего символа в файле **/run/shut.txt.**
3. Если символ появился, то **выполнить перезагрузку или выключение.**
4. Для пользователя добавлены два **sh** скрипта, назначение которых отправить в файл **/run/shut.txt** управляющий символ для выключения и перезагрузки. Это вся система. По настроению в пользовательские скрипты можно добавить звуковой эффект.
Данная система интересна тем, что её код получился крайне минималистичным, фактически - это тот случай, когда программу можно собрать, используя примеры из классического учебника по языку C. Таким образом данная система служит примером того, что "учебный код" может иметь полезное применение.
1) Программа создания файла **/run/shut.txt** с управляющим символом:
**check\_shutdown\_reboot\_file.c**
```
#include
#include
#include А
int main ()
{
mode\_t mode = S\_IRUSR | S\_IWUSR | S\_IRGRP | S\_IROTH;
char \*filename = "/run/shut.txt";
/\*Cоздадим файл, установим права и владельца\*/
creat(filename, mode);
chown(filename, 1000, 0);
}
```
2) Программа проверки управляющего символа:
**shut\_and\_reb.c**
```
#include
#include
int main ()
{
char c;
FILE \*file;
/\*Откроем файл, прочитаем управляющий символ, перезагрузим или выключим.\*/
file = fopen("/run/shut.txt", "r");
c = getc (file);
if (c == '9')
system("/sbin/reboot");
if (c == '8')
system("/sbin/poweroff");
fclose(file);
}
```
3) Скрипт sh (кнопка) для перезагрузки (можно поместить в /usr/local/bin или /home/USER/bin или создать alias):
**reboot\_com.sh**
```
echo 9 > /run/shut.txt
amixer set Master off & amixer set Master toggle & beep -f 2200 -l 3000
```
4) 3) Скрипт sh (кнопка) для выключения (можно поместить в /usr/local/bin или /home/USER/bin или создать alias, etc):
**shutdown\_comp.sh**
```
echo 8 > /run/shut.txt
amixer set Master off & amixer set Master toggle & beep -f 2200 -l 3000
#mplayer /home/iv/Музыка/zavershenie-raboty-cistemnyy-zvuk-windows-xp.mp3
```
5) Содержимое **crontab -e** суперпользователя root:
```
@reboot /usr/local/bin/check_shutdown_reboot_file
*/1 * * * * /usr/local/bin/shut_or_reb
```
P.S.
[Код на Gitflic.ru](https://gitflic.ru/project/dcc0/system-reboot-control) | https://habr.com/ru/post/703924/ | null | ru | null |
# .NET Core vs Node.js
Цель данной статьи — не выбор лучшей из двух платформ, а поиск сильных и слабых сторон каждой из них. Обе технологии прочно зарекомендовали себя в мире веб-разработки. Каждая из них имеет своих фанатов, получивших хорошие результаты и делящиеся своими достижениями на просторах интернета. В сети имеются многочисленные отзывы о тех преимуществах, которые получили разработчики при переходе на .Net Core или Node.js. Попытаемся разобраться в этом.
#### Немного контекста
Я работаю в [компании](http://audit-sml.ru/), которая занимается заказной разработкой с 2015 года, сначала мы писали на .NET, затем перешли на .NET Core и потом постепенно сменили стек на Node.JS. Основной причиной была скорость разработки.
Общие сведения
--------------
**.Net Core**
.NET Core — фреймворк общего назначения с открытым кодом, предназначенной для создания кроссплатформенных приложений. Позволяет создавать приложения для различных операционных систем Windows, macOS и Linux. [Поддерживает](https://docs.microsoft.com/en-us/dotnet/core/) процессоры x64, x86, ARM32 и ARM64. Первый официальный релиз был выпущен 27 июня 2016 года.
**Node.js**
Согласно данным на официальном [сайте](https://nodejs.org), Node.js — это программная платформа, построенная на V8. V8 в свою очередь – разработанный Google движок JavaScript с открытым исходным кодом (написан на с++), транслирующий JavaScript в машинный код. Node.js позволяет создавать приложения на macOS, Linux, SmartOS, FreeBSD, Microsoft Windows, AIX и Android. Первый релиз был в 2009 году.
Система обмена знаниями “Stackoverflow” опубликовала рейтинг популярности фреймворков за прошлый год на основе опроса более 90 тысяч разработчиков, результаты опроса следующие:
Node.js [более популярна](https://insights.stackoverflow.com/survey/2019#technology-_-other-frameworks-libraries-and-tools) согласно этому опросу. Однако, результаты могут измениться, когда будет выпущен .Net 5.0, в результате чего второе и третье место по сути объединятся, получив суммарное количество голосов, сравнимое с Node.js на текущий момент.
Язык программирования
---------------------
**Net Core**
В основном используется C# — объектно-ориентированный язык программирования, разработан Microsoft в 1998-2001 годах. Строгая типизация позволяет отлавливать ошибки на этапе компиляции, как результат получать более быстрый цикл обратной связи, и в более короткие сроки с меньшим числом ошибок разрабатывать приложения. По средствам ключевого слова “dynamic” позволяет эмулировать динамическую типизацию.
**Node.js**
JavaScript – это интерпретируемый, объектно-ориентированный язык с динамической типизацией. Так же обладает рядом особенностей присущих функциональным языкам.
Стандартом языка JavaScript является ECMAScript. JavaScript прост в использовании, но многие ошибки приходится отлаживать во время исполнения, в отличие от C#. Для устранения этого недостатка можно воспользоваться TypeScript, представленный Microsoft в 2012 году. TypeScript является надстройкой над JavaScript, обратно совместим с JavaScript и компилируется в последний. Однако TypeScript так же не дает всю мощь строго типизированного объектно-ориентированного языка которую предлагает C#. TypeScript неразрывно связан с JavaScript, который имеет структурную типизацию, как результат может только имитировать работу с типами на подобии С#.
Пример ошибки, которая не проявится на этапе сборки:
```
interface A {
x: number;
}
let a: A = {x: 5}
let b: {x: number | string} = a;
b.x = "unsound";
a.x.toFixed(0); // Not a function error occurs.
```
Проблема в этом коде с тем, что в результате присваиваний тип у “a.x” будет строка, и ошибка будет только в рантайме.
В заключении этой части представим рейтинг отражающий [частоту запросов](http://pypl.github.io/PYPL.html) в Google касаемо интересующих языков:
Модули и инструменты
--------------------
**Net Core**
Сообщество распространяет инструменты по средствам [NuGet](https://www.nuget.org/) пакетов. На текущий момент насчитывается 205 000 пакетов. Для разработки наиболее распространены Visual Studio и Rider, которые упрощают и ускоряют создание приложений.
**Node.js**
Инструментарием является NPM, который насчитывает 1 298 879 пакетов. Официальной среды разработки не объявлено, но наиболее распространено использование Visual Studio Сode с плагинами для разработки под Node.js.
В целом, выглядит так, что Node.js имеет более широкий выбор инструментов, альтернативных пакетов.
Масштабируемость
----------------
Рассмотрим только один вариант масштабируемости – горизонтальный т.е. добавление серверов для обработки увеличивающееся нагрузки.
**Net Core**
Платформа предоставляет возможность писать многопоточные приложения, поэтому задача загрузки отдельного сервера несколько проще, чем для Node.js. Для задач развертывания, масштабирование и обеспечения отказоустойчивости сервисов Microsoft выпустила “Azure Service Fabric SDK”. Можно использовать этот SDK на своих серверах, в Azure или AWS. Документация размещена [тут](https://docs.microsoft.com/en-us/azure/service-fabric/).
**Node.js**
Одиночный инстанс использует только один поток, поэтому чтобы загрузить все ядра сервера придется воспользоваться модулем “[Cluster](https://nodejs.org/api/cluster.html#cluster_cluster)” или внешним управлением процессами. Для масштабирования на несколько серверов понадобится балансировщик нагрузки (AWS ELB/NGINX). Так же имеются инструменты, предоставляющие возможность управления сервисами и трафиком, например, Istio.
В целом проблема масштабирования решается на базе обеих технологий, которые предоставляют все необходимые инструменты для этого.
Производительность
------------------
Производительность зависит от многих параметров, в том числе выбранных технологий, на базе которых построено приложение. Так же играют свою роль выбранные сценарии, результаты которых будут сравниваться. Поэтому, задача сравнения производительности в большей степени заключается в выравнивании условий экспериментов в которых проводятся замеры. Я выбрал наиболее близкие к реальности конфигурации среди имеющихся [бенчмарков](https://www.techempower.com/benchmarks), чтобы сравнить их результаты.
Во всех тестах ниже параметры едины и имеют такие значения: ОС – Linux, DB – Postgres, тип ORM – FULL (т.е. не микро ROM и не прямой доступ к DB).
**Одиночный запрос в БД**
В этом тесте каждый запрос извлекает одну строку из таблицы, далее эта строка сериализуется в JSON и отправляется ответ. Число конкурентных соединений от 16 до 512.
**Множественные запросы в БД**
В этом тесте каждый запрос выполняет несколько запросов в БД, при этом каждый из них извлекает множество строк. В этом тесте 512 конкурентных соединений.
**Обновление данных в БД**
Каждый запрос извлекает из БД множество строк, конвертирует их в объекты, изменяет объекты, сохраняет изменения в БД по одному. Далее сериализует обновленные объекты и отправляет их в ответе. В этом тесте 512 конкурентных соединений.
**Hello World тест**
На запрос получаем ответ в виде простого текста “Hello, World”.
Согласно бенчмаркам, Net Core быстрее Node.js, но нужно всегда рассматривать конкретный сценарий и используемые технологии.
Заключение
----------
Сводная таблица оценок по рассмотренным выше пунктам.
Стоит еще раз отметить, что нет универсального инструмента на все случаи жизни. Если вы начинающий и хотите быстро создавать приложения, имеющие пользовательский интерфейс и серверный код, то Node.js будет отличным выбором. Достаточно разобраться с JavaScript, и он может стать единым языком для серверной и клиентской части.
Сложные, объемные задачи лучше решать с использованием .Net Core, это в большинстве случаев позволяет сократить число внешних зависимостей, что в конечном итоге упрощает поддержку. Node.js имеет хорошую производительность, но если вам нужно что-то большее и ваше приложение подвержено экстремальным нагрузкам, то это повод задуматься об использовании .Net Core. | https://habr.com/ru/post/506282/ | null | ru | null |
# Wi-Fi-модуль WF121 и HTTP-сервер впридачу
Прочитав статью [[HOW-TO] Add HTML button press functionality to the application](http://community.silabs.com/t5/Wireless-Knowledge-Base/HOW-TO-Add-HTML-button-press-functionality-to-the-application/ta-p/147761) на сайте Silicon Labs про использование встроенного HTTP-сервера Wi-Fi-модуля WF121, мне захотелось попробовать, как это работает. Тем более, что отладочная плата модуля оказалась под рукой.
*\* Полезные ссылки — в конце статьи.*
План у меня был простой — реализовать управление лампочками (а точнее — светодиодами отладочной платы) с телефона/планшета/ПК по Wi-Fi через WEB-интерфейс, используя возможности встроенного HTTP-сервера модуля WF121 и языка BGScript.
Конечно, можно управлять лампочкой просто TCP-командами, но для этого потребуется создать и установить на телефон/планшет/ПК специальное приложение, а это не всегда удобно. Преимущество встроенного HTTP-сервера – в том, что про установку приложения можно забыть и использовать любой браузер на любом устройстве. Собственно, поэтому HTTP-сервер и реализован в WF121.
Что такое WF121?
----------------
**WF121** — Wi-Fi-модуль b/g/n 2,4 ГГц для встраиваемых систем, который может работать и как клиент, и как точка доступа. К особенностям модуля можно отнести:
* поддержку до пяти клиентов в режиме точки доступа;
* способность перенаправлять трафик от одного клиента к другому в режиме точки доступа;
* в дополнение к UART, SPI, I2C, USB, GPIO наличие интерфейса RMII, который позволяет подключать к модулю Ethernet;
* наличие конфигурируемого HTTP-сервера;
* возможность гибко всем этим управлять, загружая в модуль приложения, написанные на BGScript.
Существует три варианта управления модулем WF121:
1. С помощью внешнего контроллера и протокола BGAPI;
2. С помощью приложения BGScript, которое загружается в сам модуль;
3. Комбинированный, когда одновременно используется и BGAPI, и BGScript.
Возможности BGAPI меня сейчас мало интересуют, так как я собираюсь реализовать задуманное при помощи BGScript.
Что такое BGScript?
-------------------
**BGScript** – это простой скриптовый язык, «изобретенный» компанией Bluegiga для своих Bluetooth- и Wi-Fi-модулей. С помощью BGScript разработчик может написать собственное приложение и загрузить его в модуль, так что модуль превращается в самодостаточное устройство и не требует внешнего управления. После объединения компаний Bluegiga и SiLabs язык продолжает развиваться и совершенствоваться под флагом Silicon Labs.
При использовании BGScript разработчик описывает реакцию системы на возникающие в ней события примерно таким образом:
```
event system_boot(major,minor,patch,build,bootloader,tcpip,hw) # событие – включение и успешная загрузка Wi-Fi-модуля
call sme_wifi_on() # включаем Wi-Fi
end
event sme_wifi_is_on(result) # событие - Wi-Fi включен
call sme_connect_ssid(6,"myWiFi") # соединяемся с точкой доступа myWiFi
end
```
Т.е. включился модуль –> включаем Wi-Fi,
включился Wi-Fi -> соединяемся с точкой доступа и так далее.
Кроме управления Wi-Fi, из BGScript можно работать с интерфейсами, таймерами, создавать TCP/UDP сокеты (клиент/сервер), сохранять важные данные в энергонезависимой памяти и пр. Если хочется подробностей – приглашаю ознакомиться с *BGScript for WF121 Developer Guide* (ссылки — в конце статьи).
Когда BGScript готов – он включается в проект WF121 в виде файла с расширением .bgs.
Что такое проект WF121?
-----------------------
**Проект WF121** – набор файлов, которые содержат описание настроек и логику работы Wi-Fi-модуля WF121. Перечень файлов проекта содержится в файле project.xml. В случае проекта http\_serv файл project.xml выглядит так:
```
xml version="1.0" encoding="UTF-8" ?
```
Как вы уже догадались, в теги помещается название файла, содержащего BGScript.
Файл wifi\_http\_serv.juo недоступен для конфигурирования и здесь рассматривается не будет.
В тегах файла project.xml описывается конфигурация внешних интерфейсов модуля, в общем случае — UART, SPI, I2C, Ethernet, ADC, GPIO. В данном случае показан пример конфигурирования UART – такая конфигурация будет полезна для сохранения возможности прошивки модуля с помощью программы *Bluegiga WiFi GUI*. В альтернативном варианте описание интерфейсов может быть вынесено в отдельный файл. Детальное описание конфигурирования интерфейсов WF121 приведено в *WF121 Configuration Guide*.
Тег содержит названия файлов прошивки, которые мы получим после компиляции и будем загружать в модуль. Можно сгенерировать файлы в двух форматах: dfu и hex. Нас сейчас больше интересует формат dfu, который используется программой *Bluegiga WiFi GUI*.
Наконец, тег содержит описание файлов, относящихся к нашему HTTP-серверу.
Если интересны детали – добро пожаловать в *WF121 Configuration Guide* (см. ссылки в конце статьи).
Изменяем исходный проект, чтобы включать и выключать лампочки из браузера
-------------------------------------------------------------------------
Чтобы управлять лампочками (светодиодами) из браузера любимого смартфона или планшета, нам потребуется:
* включить в проект WEB-страничку с кнопками;
* описать с помощью BGScript реакцию Wi-Fi-модуля на нажатие отдельных кнопок;
* не забыть в файле BGScript сконфигурировать выводы модуля, к которым подключены наши светодиоды.
Примеры создания кнопок и конфигурирования выводов в исходном проекте есть, нам остается только добавить обработку событий нажатия WEB-кнопок. Всего на отладочной плате DKWF121 установлены 4 светодиода, которыми можно управлять: RD4, RD5, RD6 и RD7. Так как светодиоды RD6 и RD7 используются в данном примере для индикации состояния модуля, для имитации лампочек задействуем светодиоды RD4 и RD5. Внесём минимальные изменения, чтобы адаптировать проект под наши нужды:
1. HTTP-сервер исходного примера содержит несколько страниц и много ненужных нам кнопок – всё это можно осторожно удалить и оставить только две пары кнопок для управления светодиодами (см. файл appl.html проекта):
```
```
2. При нажатии кнопки на WEB-страничке в модуле генерируется событие https\_button(number). Реакцию на это событие опишем в файле main.bgs следующим образом:
```
event https_button(number)
if number = 1 then
call hardware_io_port_write(3, $0010, $0010) # нажали кнопку 1 – зажгли RD4
end if
if number = 2 then
call hardware_io_port_write(3, $0020, $0020) # нажали кнопку 2 – зажгли RD5
end if
if number = 3 then
call hardware_io_port_write(3, $0010, $0000) # нажали кнопку 3 – погасили RD4
end if
if number = 4 then
call hardware_io_port_write(3, $0020, $0000) # нажали кнопку 4 – погасили RD5
end if
end
```
3. Сконфигурируем выводы, к которым подключены светодиоды RD4 и RD5:
```
event system_boot(major, minor, patch, build, bootloader_version, tcpip_version, hw)
...
...
call hardware_io_port_config_direction(3, $0020, $0000) # Сконфигурируем RD4 как выход
call hardware_io_port_write(3, $0020, $0000) # Установим RD4 в 0 при включении модуля
call hardware_io_port_config_direction(3, $0010, $0000) # Сконфигурируем RD5 как выход
call hardware_io_port_write(3, $0010, $0000) # Установим RD5 в 0 при включении модуля
...
end
...
```
Конечно, внесенные изменения являются минимально необходимыми и для нормальной работы модуля требуется дальнейшее «причесывание» BGScript и наведение красоты в других файлах проекта.
Отмечу, что я назначил разные кнопки для включения и выключения светодиодов, так как в процессе тестирования выяснилось, что при использовании Mozilla Firefox или IE и нажатии WEB-кнопки в модуле генерируется одно событие https\_button(number), а при использовании Хрома — целых два! Поэтому при использовании Хрома и совмещенной кнопке вкл/выкл лампочка включается и тут же выключается, вызывая неудовольствие тестирующих. В результате я предпочел сделать отдельные кнопочки «On» и «Off» для включения и выключения светодиодов соответственно. Всё это относится к SDK 1.2.4-73.
Когда проект готов, остается только сгенерировать файл прошивки и загрузить его в модуль.
Компилируем проект и загружаем полученный код в WF121
-----------------------------------------------------
Для быстрой компиляции прошивок и загрузки их в модуль предназначена программа *Bluegiga WiFi GUI*. Её же удобно использовать для быстрого конфигурирования/тестирования модуля, а также исследования BGAPI. Программа работает только под 64-битными ОС, при запуске на 32-битных пишет, что нужны 64 бита. Есть мнение, что это ограничение можно обойти, но я не пробовал, подробностей не знаю и врать не буду. Программа *Bluegiga WiFi GUI* вместе с примерами приложений входит в состав SDK.
В целом, алгоритм действий при компиляции проекта и загрузки его в модуль следующий:
* устанавливаем на ПК SDK WF121;
* запускаем *Bluegiga WiFi GUI*;
* выбираем порт, скорость и нажимаем «Connect»;
* переходим на вкладку «Firmware upgrade»;
* выбираем проект кнопкой «Open project»;
* компилируем его кнопкой «Build»;
* нажимаем «Boot into DFU mode», чтобы перевести модуль в режим программирования;
* и загружаем нашу прошивку кнопкой «Upload».
После загрузки проекта в модуль можно подключаться телефоном, планшетом и пр. к Wi-Fi точке доступа Bluegiga, запускать браузер, заходить на страничку по адресу 192.168.1.1, после чего нажимать кнопки и наблюдать за реакцией светодиодов. Экран смартфона при этом получился такой:
Документацию на WF121, SDK, проект можно скачать на сайте [wless.ru](http://wless.ru/technology/?action=details&id=600&pf=tech&pf_id=7&prod=24&tech=7&type=20)
Обратите внимание, что сейчас есть две актуальные версии SDK: 1.2.4-73 и 1.3.0-85, и они не во всём совместимы между собой. В данном случае предполагается, что вы используете этот пример с версией 1.2.4-73, в противном случае он работать не будет.
Всем успехов и хорошего настроения!
---
[WF121 на wless.ru](http://wless.ru/technology/?action=details&id=600&pf=tech&pf_id=7&prod=24&tech=7&type=20)
[BGScript for WF121 Developer Guide](http://wless.ru/files/WiFi/Bluegiga/WF121/BGScript_for_WF121_Developer_Guide_v19.pdf)
[WF121 Configuration Guide](http://wless.ru/files/WiFi/Bluegiga/WF121/WF121_Configuration_Guide_v22.pdf)
[WF121 Datasheet](http://wless.ru/files/WiFi/Bluegiga/WF121/WF121_Datasheet.pdf)
[DKWF121 Datasheet](http://wless.ru/files/WiFi/Bluegiga/WF121/DKWF121_v131_Datasheet.pdf)
[SDK 1.2.4-73](http://wless.ru/files/WiFi/Bluegiga/WF121/Bluegiga_wifi-1.2.4-73.exe)
[Проект http\_serv с внесенными изменениями](http://wless.ru/files/WiFi/Bluegiga/WF121/http_serv_new.zip)
[WF121 на сайте Bluegiga (требуется регистрация)](https://www.bluegiga.com/en-US/products/wf121-wifi-module/)
[Комьюнити SiLabs Wi-Fi](http://community.silabs.com/t5/forums/filteredbylabelpage/board-id/4/label-name/wifi) | https://habr.com/ru/post/280894/ | null | ru | null |
# Выпуск Rust 1.41.1: корректирующий выпуск
Команда Rust опубликовала новый корректирующий выпуск Rust, 1.41.1. Rust — это язык программирования, позволяющий каждому создавать надёжное и эффективное программное обеспечение.
Если вы установили предыдущую версию Rust средствами `rustup`, то для обновления до версии 1.41.1 вам достаточно выполнить следующую команду:
```
rustup update stable
```
Если у вас ещё не установлен `rustup`, вы можете [установить его](https://www.rust-lang.org/tools/install) с соответствующей страницы нашего веб-сайта
Что вошло в стабильную версию 1.41.1
------------------------------------
Rust 1.41.1 посвящён двум критическим регрессиям, появившимся в Rust 1.41.0: некорректность в статических временах жизни и неправильная компиляция, вызывающая ошибки сегментирования. Эти регрессии не затрагивают предыдущие выпуски Rust и мы рекомендуем пользователям Rust 1.41.0 обновиться настолько быстро, насколько это возможно. Другая проблема, связанная со взаимодействием между временем жизни `'static` и реализациями типажа `Copy`, присутствовала ещё с Rust 1.0 и тоже исправляется данным выпуском.
### Несостоятельность проверки `static` элементов
В Rust 1.41.0, из-за некоторых изменений во внутреннем представлении `static` значений, анализатор заимствований случайно разрешал некоторые ошибочные программы. В частности, анализатор заимствований не проверял правильность типа `static` элементов. Это, в свою очередь, позволяло временно присваивать значения со временем жизни, меньшим чем `'static`, к `static` переменной:
```
static mut MY_STATIC: &'static u8 = &0;
fn main() {
let my_temporary = 42;
unsafe {
// Ошибочно разрешённая операция в 1.41.0:
MY_STATIC = &my_temporary;
}
}
```
В 1.41.1 такой код не будет компилироваться:
```
error[E0597]: `my_temporary` does not live long enough
--> src/main.rs:6:21
|
6 | MY_STATIC = &my_temporary;
| ------------^^^^^^^^^^^^^
| | |
| | borrowed value does not live long enough
| assignment requires that `my_temporary` is borrowed for `'static`
7 | }
8 | }
| - `my_temporary` dropped here while still borrowed
```
Вы можете узнать больше об этой ошибке в [#69114](https://github.com/rust-lang/rust/issues/69114) и [PR, который её исправил](https://github.com/rust-lang/rust/pull/69145).
### Реализация `Copy` для времени жизни `'static`
Начиная ещё с Rust 1.0 следующая ошибочная программа успешно компилировалась:
```
#[derive(Clone)]
struct Foo<'a>(&'a u32);
impl Copy for Foo<'static> {}
fn main() {
let temporary = 2;
let foo = (Foo(&temporary),);
drop(foo.0); // Доступ к необходимой части `foo`.
drop(foo.0); // Индексация массива так же работает.
}
```
В Rust 1.41.1 эта проблема была исправлена [тем же PR, что и выше](https://github.com/rust-lang/rust/pull/69145). Компиляция программы теперь выдаёт следующую ошибку:
```
error[E0597]: `temporary` does not live long enough
--> src/main.rs:7:20
|
7 | let foo = (Foo(&temporary),);
| ^^^^^^^^^^ borrowed value does not live long enough
8 | drop(foo.0);
| ----- copying this value requires that
| `temporary` is borrowed for `'static`
9 | drop(foo.0);
10 | }
| - `temporary` dropped here while still borrowed
```
Эта ошибка возникает из-за того, что `Foo<'a>`, для некоторого времени жизни `'a`, реализует `Copy` только тогда, когда `'a: 'static`. Однако `temporary` переменная с некоторым временем жизни `'0` не переживает `'static` и, следовательно, `Foo<'0>` не является `Copy`, поэтому использование `drop` во второй раз должно быть ошибкой.
### Неправильно скомпонованные проверки, приводящие к ошибкам сегментации памяти.
В некоторых случаях программы, скомпилированные Rust 1.41.0, при выделении памяти пропускали проверки границ. Это приводило к ошибкам сегментирования, если предоставлялись значения, находящиеся за пределами выделенной области памяти. Причиной этого была ошибка компиляции, вызванная изменением оптимизационного прохода LLVM, который появился в LLVM 9 и был удалён в LLVM 10.
Rust 1.41.0 использует собственную ветку LLVM 9 и мы в Rust 1.41.1 отменили те коммиты, которые были связаны с ошибкой компиляции. Подробнее об это ошибке вы можете узнать здесь: [#69225](https://blog.rust-lang.org/2019/12/19/Rust-1.40.0.html#borrow-check-migration-warnings-are-hard-errors-in-rust-2015).
Участники 1.41.1
----------------
Множество людей собрались вместе, чтобы создать Rust 1.41.1. Мы не смогли бы сделать это без всех вас, [спасибо](https://thanks.rust-lang.org/rust/1.41.1/)!
От переводчиков
---------------
С любыми вопросами по языку Rust вам смогут помочь в [русскоязычном Телеграм-чате](https://t.me/rustlang_ru) или же в аналогичном [чате для новичковых вопросов](https://t.me/rust_beginners_ru). | https://habr.com/ru/post/490132/ | null | ru | null |
# Как реализовать шаринг в социальные сети
Меня зовут Илья Степанов. Я – технический директор digital-агентства. Так как у нас много разных клиентских проектов, то мы постоянно сталкиваемся с новыми для нас задачами. Одной из таких оказалась реализация шаринга в социальные сети.
### Почему мы озадачились этой темой
Наш клиент – застройщик северной столицы Legenda Intelligent Development уже давно работает на рынке недвижимости и в этом году отметил свой юбилей – 10 лет. В честь этого события они устроили конкурс, где любой человек мог выиграть ювелирное украшение по своему индивидуальному эскизу. Для этого нужно было сконфигурировать кольцо, серьги или кулон с элементами, созданными по интерьерным мотивам. Далее пользователь должен расшарить свой дизайн хотя бы в одну из социальных сетей: Facebook и Vkontakte. Потом случайным образом между участниками, выполнившими условия, разыгрывали призы.
### Что надо было сделать
Помимо разработки самого лендинга с конфигуратором нужно было реализовать возможность шаринга созданного украшения с сопроводительным текстом в социальные сети. Для этого требовалось создать приложения в Facebook и VKontakte и настроить необходимые разрешения, а в коде разобрать и подключить API этих соцсетей и запустить функционал шаринга. Также нужно было собрать email поделившихся пользователей для проведения розыгрыша. Мы решили все это сделать на JavaScript.
### Реализация шаринга в Facebook
Мы поделимся собственным опытом и граблями, которые уже обезврежены, поэтому вам идти по этому пути можно будет с гордо поднятой головой.
Для начала необходимо разобраться, какое приложение нужно создать. Facebook предлагает множество приложений, но далеко не все из них нужного нам функционала. Когда вроде бы выяснили, что конкретно нам подходит, нужно было правильно это настроить и предоставить Facebook информацию о нас: юридическую, политику конфиденциальности и так далее. Потом проверяем все на тестовом аккаунте разработчика и запрашиваем необходимые разрешения. Например, на предоставление личных данных пользователя: почта, телефон, разрешение на публикацию в его ленте поста.
**Грабли: выбор неправильного приложения**
Проблема была в том, что клиент заранее создал приложение и предложил дальше работать именно с ним. Но по факту оно было игровым и не поддерживало необходимый нам функционал. А именно позволяло постить на стену только тем, кто находится у пользователя в друзьях (знаете, вот эти истории, когда просят помощи в покупке овец на онлайн-ферму и тп). В итоге запросили неправильные разрешения. Согласование со стороны Facebook длилось около недели. И в конце выяснилось, что делали мы совершенно не то.
**Как надо было сделать в идеале, чтобы не потерять драгоценное время.**
1. Выбрать приложение с нужным функционалом, изучив документацию Facebook.
2. Заполнить всю необходимую юридическую информацию о себе.
3. Выбрать требуемые разрешения.
4. Протестировать на аккаунте разработчика (такой функционал по умолчанию есть у всех аккаунтов на [Facebook for Developers](https://developers.facebook.com/?locale=ru_RU)).
5. И только потом отправлять всё это на согласование.
#### Подробная инструкция
* Перейдите на страницу ваших приложений <https://developers.facebook.com/apps/> и нажмите «Создать приложение».
* Выберите тип приложения «Компания».
* Перейдите в **Настройки >> Основное** и заполните поле «Домены приложений». Также нужно указать ссылку на политику конфиденциальности, потому что это обязательное поле и без его заполнения данные не сохранятся.
* Далее выбираем нужные разрешения. Для авторизации и шаринга достаточно базовых разрешений.
Если же вам нужно получить информацию, которой нет в базовых разрешениях, то их необходимо получить. Нам, например, нужно было получить разрешение на получение email адреса пользователя. Для этого нужно перейти в раздел **Проверка приложения >> Разрешения**
* Потом найдите нужное разрешение и запросите расширенный доступ. Разрешение на email можно получить автоматически просто по нажатию кнопки. Но большинство разрешений требует отправки запроса, где нужно указывать, зачем вам это и подробно описывать (прикрепив видео), как это будет использоваться в вашем приложении. Если в коде вы запрашиваете какое-то разрешение, которого у вашего приложения нет, то Facebook выдаст ошибку, что не все разрешения были одобрены.
#### Реализация в коде и использование API
Выбираем нужное API. Мы реализовывали все на JavaScript, поэтому выбирали, исходя из этого.
Для интеграции мы использовали Facebook SDK for JavaScript v11.0.
**Методы**
**Инициализация** <https://developers.facebook.com/docs/javascript/reference/FB.init/v11.0>
```
FB.init({
appId : this.APP_ID,
autoLogAppEvents : true,
xfbml : true,
version : 'v11.0'
});
```
В параметр appId необходимо передать id вашего приложения.
**Авторизация** <https://developers.facebook.com/docs/reference/javascript/FB.login/v11.0>
```
FB.login(function(response) {
// handle the response
}, {scope: 'email'});
```
В параметре scope указываются запрашиваемые разрешения.
**Шаринг** <https://developers.facebook.com/docs/sharing/reference/share-dialog>
```
FB.ui({
method: 'share',
display: 'popup',
hashtag: '#legends',
quote: 'Тест',
href: 'https://www.google.com'
}, function(response){
// handle the response
});
```
**Получение данных пользователя** <https://developers.facebook.com/docs/javascript/reference/FB.api>
```
FB.api(
'/me',
'GET',
{"fields":"id,name,email"},
function(response) {
// handle the response
}
);
```
#### Результат
В итоге функционал на сайте выглядит следующим образом:
* Авторизация
* Шаринг
#### Публикация приложения
Когда вы убедились, что всё реализовано верно, протестировали, получили разрешения, можно нажимать заветную кнопку «Опубликовать приложение». Оно отправляется на модерацию на пару-тройку дней.
Дело сделано! Вашим приложением смогут пользоваться все участники Facebook.
### Реализация шаринга в VKontakte
Тут всё намного проще, чем с Facebook. ВКонтакте разрешает практически всё, что хочешь. Нужно внимательно прочитать инструкцию на странице разработчика. Дальше создать приложение, выбрать категорию, заполнить нужные данные (их намного меньше, чем требует FB). Дальше подключить API для JavaScript, протестировать и в продакшн!
#### Подробная инструкция
#### Создание приложения
* Перейдите на страницу ваших приложений <https://vk.com/apps?act=manage> и нажмите «Создать».
* Введите название приложения и выберите тип «Standalone-приложение».
* Перейдите в Настройки и включите Open API.
* После чего заполните поля «Адрес сайта» и «Базовый домен».
* Введите название приложения и выберете тип “Standalone-приложение”
* После чего заполните поля «Адрес сайта» и «Базовый домен»
### Интеграция приложения
Для работы с API мы использовали JavaSсript SDK <https://vk.com/dev/Javascript_SDK>.
**Методы:**
**Инициализация**
```
VK.init({
apiId: this.APP_ID
});
```
В параметр appId необходимо передать id вашего приложения.
**Авторизация** <https://vk.com/dev/implicit_flow_user>
Для авторизации необходимо просто перенаправить пользователя по определённому адресу.
```
login(){
window.location.href='https://oauth.vk.com/authorize?client_id=' + this.APP_ID + '&display=page&redirect_uri=' + this.REDIRECT_URL + '&scope=wall,email&response_type=token&v=5.126;
}
```
**Шаринг** <https://vk.com/dev/wall.post>
```
VK.Api.call('wall.post', {message: _this.MESSAGE, attachments: _this.img}, function(r) {
// handle the response
});
```
**Получение данных пользователя** <https://vk.com/dev/users.get>
```
VK.Api.call('users.get', {'v':'5.126'}, function(r) {
// handle the response
});
```
**После того, как всё протестировано, можно включать приложение**.
### Результат
В итоге функционал на сайте выглядит следующим образом:
* Авторизация
* Разрешения
* Шаринг
#### Вывод
Читайте документацию и шарьте в социальные сеточки! | https://habr.com/ru/post/574710/ | null | ru | null |
# Java Stream API на простых примерах
Стримы и коллекции чем-то похожи друг на друга, но у них разное назначение. Коллекции обеспечивают эффективный доступ к одиночным объектам, а стримы, наоборот, для прямого доступа и обработки отдельных элементов не используются. Стримы предназначены для параллельных и последовательных агрегаций, выполняемых через цепочку методов.
Давайте сразу перейдем к примерам.
Для начала создадим класс `User` — основной класс для наших экспериментов.
```
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.ToString;
@Data
@AllArgsConstructor
@ToString
public class User {
private long id;
private String firstName;
private String lastName;
private int age;
private String nationality;
}
```
Далее напишем класс `Sample`, в котором будем запускать наш код.
```
import java.util.Arrays;
import java.util.List;
public class Sample {
private final List userList = Arrays.asList(
new User(1, "Michael", "Robert", 37, "TR"),
new User(2, "Mary", "Patricia", 11, "EN"),
new User(3, "John", "Michael", 7, "FR"),
new User(4, "Jennifer", "Linda", 77, "TR"),
new User(5, "William", "Elizabeth", 23, "US"),
new User(6, "Sue", "Jackson", 11, "IT"),
new User(7, "Michael", "Tommy", 37, "EN")
);
public static void main(String... args) {
Sample sample = new Sample();
}
}
```
1. Перебор всех элементов `userList` с помощью `forEach()` и вывод их в консоль.
```
public static void main(String... args) {
Sample sample = new Sample();
sample.test1();
}
private void test1() {
System.out.println("Test 1");
userList.stream()
.forEach(System.out::println);
}
```
Результат:
```
Test 1
User(id=1, firstName=Michael, lastName=Robert, age=37, nationality=TR)
User(id=2, firstName=Mary, lastName=Patricia, age=11, nationality=EN)
User(id=3, firstName=John, lastName=Michael, age=7, nationality=FR)
User(id=4, firstName=Jennifer, lastName=Linda, age=77, nationality=TR)
User(id=5, firstName=William, lastName=Elizabeth, age=23, nationality=US)
User(id=6, firstName=Sue, lastName=Jackson, age=11, nationality=IT)
User(id=7, firstName=Michael, lastName=Tommy, age=37, nationality=EN)
```
Так как `userList` — это `ArrayList`, то элементы выводятся в консоль в порядке добавления их в список.
2. Перебор всех элементов с выполнением некоторой операции над каждым элементом списка и вывод их на консоль.
```
private void test2() {
System.out.println("Test 2");
userList.stream()
.map(u -> {
return new User(
u.getId(),
"X " + u.getFirstName(),
"Y " + u.getLastName(),
u.getAge() + 10),
u.getNationality());
})
.collect(Collectors.toList())
.forEach(System.out::println);
}
```
Результат:
```
Test 2
User(id=1, firstName=X Michael, lastName=Y Robert, age=47, nationality=TR)
User(id=2, firstName=X Mary, lastName=Y Patricia, age=21, nationality=EN)
User(id=3, firstName=X John, lastName=Y Michael, age=17, nationality=FR)
User(id=4, firstName=X Jennifer, lastName=Y Linda, age=87, nationality=TR)
User(id=5, firstName=X William, lastName=Y Elizabeth, age=33, nationality=US)
User(id=6, firstName=X Sue, lastName=Y Jackson, age=21, nationality=IT)
User(id=7, firstName=X Michael, lastName=Y Tommy, age=47, nationality=EN)
```
3. Сортировка списка по свойству `age`.
```
private void test3() {
System.out.println("Test 3");
userList.stream()
.sorted(Comparator.comparing(User::getAge))
.collect(Collectors.toList())
.forEach(System.out::println);
}
```
Результат:
```
Test 3
User(id=3, firstName=John, lastName=Michael, age=7, nationality=FR)
User(id=2, firstName=Mary, lastName=Patricia, age=11, nationality=EN)
User(id=6, firstName=Sue, lastName=Jackson, age=11, nationality=IT)
User(id=5, firstName=William, lastName=Elizabeth, age=23, nationality=US)
User(id=1, firstName=Michael, lastName=Robert, age=37, nationality=TR)
User(id=7, firstName=Michael, lastName=Tommy, age=37, nationality=EN)
User(id=4, firstName=Jennifer, lastName=Linda, age=77, nationality=TR)
```
4. Сортировка списка по нескольким свойствам: `age`, `firstName`, `lastName`.
```
private void test4() {
System.out.println("Test 4");
userList.stream()
.sorted(Comparator.comparing(User::getAge)
.thenComparing(User::getFirstName)
.thenComparing(User::getLastName))
.collect(Collectors.toList())
.forEach(System.out::println);
}
```
Результат:
```
Test 4
User(id=3, firstName=John, lastName=Michael, age=7, nationality=FR)
User(id=2, firstName=Mary, lastName=Patricia, age=11, nationality=EN)
User(id=6, firstName=Sue, lastName=Jackson, age=11, nationality=IT)
User(id=5, firstName=William, lastName=Elizabeth, age=23, nationality=US)
User(id=1, firstName=Michael, lastName=Robert, age=37, nationality=TR)
User(id=7, firstName=Michael, lastName=Tommy, age=37, nationality=EN)
User(id=4, firstName=Jennifer, lastName=Linda, age=77, nationality=TR)
```
5. Вычисление среднего возраста (`age`) и максимальной длины `firstName`.
```
private void test5() {
System.out.println("Test 5");
double averageAge = userList.stream()
.mapToInt(User::getAge)
.summaryStatistics()
.getAverage();
System.out.print("averageAge: " + averageAge);
int maxFirstNameLenght = userList.stream()
.mapToInt((value) -> {
return value.getFirstName().length();
})
.summaryStatistics()
.getMax();
System.out.println(" maxFirstNameLenght: " + maxFirstNameLenght);
}
```
Результат:
```
Test 5
averageAge: 29.0 maxFirstNameLenght: 8
```
6. Проверка, что у всех User возраст (`age`) больше 6.
```
private void test6() {
System.out.println("Test 6");
boolean isAllAgesGreaterThan6 = userList.stream()
.allMatch(user -> user.getAge() > 6);
System.out.println("isAllAgesGreaterThan6: " + isAllAgesGreaterThan6);
}
```
Результат:
```
Test 6
isAllAgesGreaterThan6: true
```
7. Проверка, есть ли кто-то с `firstName`, начинающийся с символа `S`.
```
private void test7() {
System.out.println("Test 7");
boolean isFirstCharS = userList.stream()
.anyMatch(user -> user.getFirstName().charAt(0) == 'S');
System.out.println("isFirstCharS " + isFirstCharS);
}
```
Результат:
```
Test 7
isFirstCharS: true
```
8. Преобразование одной коллекцию в другую.
```
private void test8() {
System.out.println("Test 8");
List list = userList.stream()
.collect(Collectors.toList());
Set set = userList.stream()
.collect(Collectors.toSet());
List linkedList = userList.stream()
.collect(Collectors.toCollection(LinkedList::new));
Map map = userList.stream()
.collect(Collectors.toMap(user -> user.getId(), user -> user));
}
```
9. Количество разных национальностей (nationality).
```
private void test9() {
long countDifferentNationalites = userList.stream()
.map(User::getNationality)
.distinct()
.count();
System.out.println("countDifferentNationalites: " + countDifferentNationalites);
}
```
Результат:
```
Test 9
countDifferentNationalites: 5
```
10. `User` старше 10 лет, у которых первый символ `firstName` не равен `M`.
```
private void test10() {
System.out.println("Test 10");
userList.stream()
.filter(p -> (p.getFirstName().charAt(0) != 'M'))
.filter(p -> (p.getAge() > 10))
.collect(Collectors.toList())
.forEach(System.out::println);
}
```
Результат:
```
Test 10
User(id=4, firstName=Jennifer, lastName=Linda, age=77, nationality=TR)
User(id=5, firstName=William, lastName=Elizabeth, age=23, nationality=US)
User(id=6, firstName=Sue, lastName=Jackson, age=11, nationality=IT)
```
Резюмируя, Java Stream — это не структура хранения данных. Стримы передают элементы из источника (какой-либо структуры данных) через конвейер операций и возвращают некоторое значение, не модифицируя источник.
Все примеры находятся в репозитории [GitHub](https://github.com/meteergin/medium-java-streams).
---
Приглашаем всех желающих на открытый урок «Переопределение, скрытие, передекларация». Будет рассмотрено переопределение и скрытие методов в Java, а также передекларация и скрытие переменных. Познакомимся с четырьмя правилами, а потом ещё и с пятым. Регистрация [здесь.](https://otus.pw/zWOY/) | https://habr.com/ru/post/658999/ | null | ru | null |
# «Щадящая» балансировка между несколькими провайдерами на офисном шлюзе
Эта статья описывает конфигурацию шлюза под управлением Linux для балансировки трафика между каналами разных провайдеров.
Результат, достигаемый в этом руководстве, отличается от результата [подобных руководств](https://www.opennet.ru/docs/RUS/LARTC/x348.html#LOADBALANCING): для каждого клиента используется один и тот же внешний IP-адрес, что избавляет от проблем с интернет-сервисами, которые не готовы к смене IP-адреса клиента в рамках одной сессии.
#### Проблемы
Для рядового потребителя, не обладающего ни одним собственным блоком адресов и не участвующего в обмене маршрутами на уровне операторов связи, доступ к интернету возможен только с тех адресов, которые предоставляет ему каждый интернет-провайдер для каждого канала. Это означает, что любое подключение нескольких каналов от «бытовых» интернет-провайдеров к одному узлу требует не только выбора между разными вышестоящими шлюзами, но ещё и выбора правильного исходящего адреса для общения с ними.
Такое положение дел идёт вразрез с тем, как работает стандартный механизм маршрутизации. В общем случае маршрут в таблице маршрутизации зависит только от адреса назначения и не меняет адрес отправителя. Поэтому первая задача, которую требуется решить — организовать соответствие интерфейса отправки, шлюза и исходящего адреса при пересылке пакетов от клиентов.
Вторая задача, которую нужно решить, состоит в том, как разумно распределить нагрузку от клиентов.
Балансировка с использованием многолучевых маршрутов (как по ссылке в начале статьи) осуществляется по адресу назначения и не всегда выглядит привлекательным решением. Там, где стоило бы иметь одинаковый внешний адрес, у клиента в одной сессии может получиться разный и наоборот — при обращении к популярным ресурсам, все клиенты будут использовать один общий канал.
Балансировка по адресу отправителя может послужить компромиссом между совместимостью и гранулярностью распределения. У каждого компьютера в локальной сети будет всегда один и тот же внешний адрес и при немалом числе компьютеров в сети мы получим сносное распределение нагрузки по каналам. Такого деления можно добиться, если образовать от локальных адресов хэши, поделить всё пространство хэшей пропорционально весам каналов и использовать значение этого хэша для выбора канала.
#### Инструменты
В ядре Linux есть возможность использовать одновременно несколько разных таблиц в зависимости от того, каким критериям соответствует пакет. Часто этот механизм называют policy based routing (PBR). Управление этим механизмом осуществляется через набор утилит iproute2.
Несколько упрощая постановку задачи, можно сказать: всё, что от нас требуется для разграничения маршрутов, интерфейсов и исходящих адресов — это создать для каждого провайдера дополнительную таблицу маршрутизации, имеющую вид, как если бы этот канал этого провайдера был единственным. Затем нужно добавить правила (те самые политики маршрутизации), пускающие в ход подходящую таблицу маршрутизации для соответствующего ей трафика.
Что же касается балансировки по отправителю, то для этого можно воспользоваться сетевым фильтром ядра — netfilter (iptables). С помощью действия HMARK мы промаркируем пакет хэшом от адреса. По критерию fwmark в правилах маршрутизации (команда ip rule) мы направим пакет в нужную таблицу маршрутизации. iproute2 и iptables здесь неплохо играют в паре.
#### Пример
В качестве примера возьму шлюз на базе Debian, который предоставляет доступ к интернету через три канала от двух разных провайдеров. Такой пример выбран специально, так как он рассматривает щекотливую ситуацию, когда один и тот же вышестоящий шлюз одного провайдера доступен через 2 разных провода. Описываемая конфигурация будет иметь схожий вид и во всех других debian-подобных операционных системах, включая Ubuntu.
Шлюз имеет 4 рабочих интерфейса:
| Инт. | Описание | Ёмкость | Адрес | Шлюз |
| --- | --- | --- | --- | --- |
| eth0 | локальная сеть | | 10.0.0.1/16 | - |
| eth1 | первый канал первого провайдера | 100 Мбит/с | 100.1.1.92/24 | 100.1.1.1 |
| eth2 | единственный канал от второго провайдера | 80 Мбит/с | 200.2.2.22/24 | 200.2.2.1 |
| eth3 | второй канал первого провайдера | 100 Мбит/с | 100.1.1.93/24 | 100.1.1.1 |
Каждый канал подключен через обычный ethernet со статическим адресом.
##### Начальное состояние
Предположим, у нас уже настроен доступ через один канал. Файл /etc/network/interfaces имеет вид:
**/etc/network.interfaces, 3 интерфейса, 1 основной**`# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).
source /etc/network/interfaces.d/*
# The loopback network interface
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet static
address 10.0.0.1
netmask 255.255.0.0
auto eth1
iface eth1 inet static
address 100.1.1.92
gateway 100.1.1.1
netmask 255.255.255.0
auto eth2
iface eth2 inet static
address 200.2.2.22
# gateway 200.2.2.1 #correct gateway value, but commented out to avoid routing conflicts
netmask 255.255.255.0
auto eth3
iface eth3 inet dhcp
address 100.1.1.93
# gateway 100.1.1.1 # correct gateway value, but commented out to avoid routing conflicts
netmask 255.255.255.0`
Как видите, только на одном из интерфейсов обозначен маршрут по умолчанию.
В /etc/sysctl.conf значение net.ipv4.ip\_forward установлено равным 1. Пакет iptables-persistent установлен и содержимое файла /etc/iptables/rules.v4 таково:
**/etc/iptables/rules.v4, NAT-правила и ничего более**`# Generated by iptables-save v1.4.21 on Tue Feb 30 13:14:06 2016
*mangle
:PREROUTING ACCEPT [0:0]
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
:POSTROUTING ACCEPT [0:0]
COMMIT
# Completed on Tue Feb 30 13:14:06 2016
# Generated by iptables-save v1.4.21 on Tue Feb 30 13:14:06 2016
*filter
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
-A FORWARD -s 10.0.0.0/16 -i eth0 -j ACCEPT # Proposed by ValdikSS due to security clues
-A FORWARD -d 10.0.0.0/16 -o eth0 -j ACCEPT # --//--
-A FORWARD -j DROP # --//--
COMMIT
# Completed on Tue Feb 30 13:14:06 2016
# Generated by iptables-save v1.4.21 on Tue Feb 30 13:14:06 2016
*nat
:PREROUTING ACCEPT [0:0]
:INPUT ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
:POSTROUTING ACCEPT [0:0]
-A POSTROUTING -s 10.0.0.0/8 -o eth1 -j MASQUERADE
-A POSTROUTING -s 10.0.0.0/8 -o eth2 -j MASQUERADE
-A POSTROUTING -s 10.0.0.0/8 -o eth3 -j MASQUERADE
COMMIT
# Completed on Tue Feb 30 13:14:06 2016`
Только три правила для трансляции адресов у пакетов, исходящих через три внешних интерфейса. Не принципиально использовать именно маскарад, но я остановился на нём. Поскольку в данный момент шлюз настроен только на одном интерфейсе, на деле работает только первое правило.
##### Правила маршрутизации
Теперь самое сложное: решим первую задачу соответствия адресов, интерфейсов и шлюзов. Подготовим три дополнительные таблицы маршрутизации, которые будем использовать для разных провайдеров.
Начнём с опционального шага — чтобы не упоминать везде таблицы маршрутизации по их номеру, заведём их в файле соответствий номеров и имён таблиц /etc/iproute2/rt\_tables:
**/etc/iproute2/rt\_tables**`#
# reserved values
#
255 local
254 main
253 default
0 unspec
#
# local
#
#1 inr.ruhep
10 Provider1_Cable1
20 Provider2
30 Provider1_Cable2`
Пока довольно просто. Теперь наполним эти таблицы маршрутами. Пусть каждая таблица под каждый внешний канал содержит все маршруты всех интерфейсов, кроме маршрутов через другие внешние интерфейсы. При поднятии каждого внешнего интерфейса — добавлять правило, предписывающее использовать оговоренную дополнительную таблицу маршрутизации, если адрес отправителя равен адресу на этом интерфейсе.
**/etc/network/interfaces: маршруты в дополнительных таблицах и правила маршрутизации по исходному адресу**`# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).
source /etc/network/interfaces.d/*
# The loopback network interface
auto lo
iface lo inet loopback
up ip route add 127.0.0.0/8 dev lo table Provider1_Cable1
up ip route add 127.0.0.0/8 dev lo table Provider2
up ip route add 127.0.0.0/8 dev lo table Provider1_Cable2
auto eth0
iface eth0 inet static
address 10.0.0.1
netmask 255.255.0.0
up ip route add 10.0.0.0/16 dev eth0 table Provider1_Cable1
up ip route add 10.0.0.0/16 dev eth0 table Provider2
up ip route add 10.0.0.0/16 dev eth0 table Provider1_Cable2
auto eth1
iface eth1 inet static
address 100.1.1.92
gateway 100.1.1.1
netmask 255.255.255.0
up ip route add 100.1.1.0/24 dev eth1 table Provider1_Cable1
up ip route add default dev eth1 via 100.1.1.1 table Provider1_Cable1
up ip rule add from 100.1.1.92 table Provider1_Cable1
auto eth2
iface eth2 inet static
address 200.2.2.22
# gateway 200.2.2.1 #correct gateway value, but commented out to avoid routing conflicts
netmask 255.255.255.0
up ip route add 200.2.2.22/24 dev eth2 table Provider2
up ip route add default dev eth2 via 200.2.2.1 table Provider2
up ip rule add from 200.2.2.22 table Provider2
auto eth3
iface eth3 inet dhcp
address 100.1.1.93
# gateway 100.1.1.1 # correct gateway value, but commented out to avoid routing conflicts
netmask 255.255.255.0
up ip route add 100.1.1.0/24 dev eth3 table Provider1_Cable2
up ip route add default dev eth3 via 100.1.1.1 table Provider1_Cable2
up ip rule add from 100.1.1.93 table Provider1_Cable2`
Обратите внимание: в основную таблицу маршрутизации всё равно попадает только один gateway — все директивы gateway, кроме одной, закомментированы.
Здесь дополнительные маршруты и правила оформлены директивами up, которые просто выполняют команду при поднятии интерфейса. Команды добавления маршрутов и правил сгруппированы под интерфейсами, через которые они могут быть реализованы — яснее всего это видно на примере интерфейса lo.
Перезагрузив сеть, мы можем заметить, как изменился вывод списка правил в команде ip rule list:
**ip rule list**`# ip ru li
0: from all lookup local
32763: from 100.1.1.93 lookup Provider1_Cable2
32764: from 200.2.2.22 lookup Provider2
32765: from 100.1.1.92 lookup Provider1_Cable1
32766: from all lookup main
32767: from all lookup default`
Соответствующую таблицу можно просмотреть командой «ip ro li table XXX».
Уже в таком положении сервер готов использовать все интерфейсы сразу. Проверим это, попробовав воспользоваться всеми интерфейсами по очереди и сверяя наблюдаемый внешней стороной адрес:
**проверка внешних адресов через разные интерфейсы**`# curl --interface 100.1.1.92 http://canihazip.com/s ; echo
100.1.1.92
# curl --interface 100.1.1.93 http://canihazip.com/s ; echo
100.1.1.93
# curl --interface 200.2.2.22 http://canihazip.com/s ; echo
200.2.2.22`
Если на внешних интерфейсах реальные «белые» адреса, то можно попробовать присоединиться к серверу, используя любой адрес — сервер будет общаться через каждый из них через правильный канал и правильного провайдера. Если всё так, то самое сложное позади.
##### Балансировка
В моём примере есть два канала по 100 Мб/c и один 80 Мб/с. Для того, чтобы поделить нагрузку поровну между ними, мне достаточно поделить её на 14 частей и отправить по 5 частей на два 100-мегабитных канала и 4 части на 80-мегабитный канал. Добавим в файрвол правило, маркирующее пакет числами от 10000 до 10013 в зависимости от исходящего IP-адреса:
`# iptables -t mangle -A PREROUTING -s 10.0.0.0/16 -j HMARK --hmark-tuple src --hmark-offset 10000 --hmark-mod 14 --hmark-rnd 0xfeedcafe
# /etc/init.d/netfilter-persistent save`
Достаточно просто. Параметры и значения говорят сами за себя. Теперь осталось направить трафик, промаркированный разными числами, через разные интерфейсы. В итоге /etc/network/interfaces принимает вид:
**/etc/network/interfaces, окончательный**`# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).
source /etc/network/interfaces.d/*
# The loopback network interface
auto lo
iface lo inet loopback
up ip route add 127.0.0.0/8 dev lo table Provider1_Cable1
up ip route add 127.0.0.0/8 dev lo table Provider2
up ip route add 127.0.0.0/8 dev lo table Provider1_Cable2
auto eth0
iface eth0 inet static
address 10.0.0.1
netmask 255.255.0.0
up ip route add 10.0.0.0/16 dev eth0 table Provider1_Cable1
up ip route add 10.0.0.0/16 dev eth0 table Provider2
up ip route add 10.0.0.0/16 dev eth0 table Provider1_Cable2
auto eth1
iface eth1 inet static
address 100.1.1.92
gateway 100.1.1.1
netmask 255.255.255.0
up ip route add 100.1.1.0/24 dev eth1 table Provider1_Cable1
up ip route add default dev eth1 via 100.1.1.1 table Provider1_Cable1
up ip rule add from 100.1.1.92 table Provider1_Cable1
up ip rule add from 10.0.0.0/8 fwmark 10000 table Provider1_Cable1
up ip rule add from 10.0.0.0/8 fwmark 10003 table Provider1_Cable1
up ip rule add from 10.0.0.0/8 fwmark 10006 table Provider1_Cable1
up ip rule add from 10.0.0.0/8 fwmark 10009 table Provider1_Cable1
up ip rule add from 10.0.0.0/8 fwmark 10012 table Provider1_Cable1
auto eth2
iface eth2 inet static
address 200.2.2.22
# gateway 200.2.2.1 #correct gateway value, but commented out to avoid routing conflicts
netmask 255.255.255.0
up ip route add 200.2.2.22/24 dev eth2 table Provider2
up ip route add default dev eth2 via 200.2.2.1 table Provider2
up ip rule add from 200.2.2.22 table Provider2
up ip rule add from 10.0.0.0/8 fwmark 10002 table Provider2
up ip rule add from 10.0.0.0/8 fwmark 10005 table Provider2
up ip rule add from 10.0.0.0/8 fwmark 10008 table Provider2
up ip rule add from 10.0.0.0/8 fwmark 10011 table Provider2
auto eth3
iface eth3 inet dhcp
address 100.1.1.93
# gateway 100.1.1.1 # correct gateway value, but commented out to avoid routing conflicts
netmask 255.255.255.0
up ip route add 100.1.1.0/24 dev eth3 table Provider1_Cable2
up ip route add default dev eth3 via 100.1.1.1 table Provider1_Cable2
up ip rule add from 100.1.1.93 table Provider1_Cable2
up ip rule add from 10.0.0.0/8 fwmark 10001 table Provider1_Cable2
up ip rule add from 10.0.0.0/8 fwmark 10004 table Provider1_Cable2
up ip rule add from 10.0.0.0/8 fwmark 10007 table Provider1_Cable2
up ip rule add from 10.0.0.0/8 fwmark 10010 table Provider1_Cable2
up ip rule add from 10.0.0.0/8 fwmark 10013 table Provider1_Cable2`
Для каждого интерфейса добавились строчки вида «up ip rule add from 10.0.0.0/8 fwmark MARK table TABLE». Каждая из них отправляет пакеты с соответсвующей маркировкой на маршрутизацию в указанную таблицу. В моём примере числа перемешаны между интерфейсами ради равномерности.
#### Всё!
Опционально к такой схеме маршрутизации можно добавить скрипты, обнаруживающие падение одного из каналов и перебалансирующие нагрузку с учётом этого. Однако, детали реализации зависят от вкуса и лучше оставить это на усмотрение читателю. | https://habr.com/ru/post/279777/ | null | ru | null |
# Раздаем права на запуск/остановку сервисов под Windows
Буквально сегодня понадобилось дать человеку возможность перезапускать тестовый вебсервер под виндой.
Права админа давать естественно давать не хочется.
«Мощный» юзер не подходит.
букв много
и тут на помощь приходит [technet](http://technet.microsoft.com/en-us/library/cc754599(WS.10).aspx), который расcказывает про sc.
В данном случае нас интересуют 2 команды:
**sc sdshow** — показывает права
**sc sdset** — устанавливает права
Для начала узнаем, какие права у нашего сервиса уже есть:
`C:\Users\administrator>sc sdshow service_name
D:(A;;CCLCSWRPWPDTLOCRRC;;;SY)(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;BA)(A;;CCLCSWLOCR
RC;;;IU)(A;;CCLCSWLOCRRC;;;SU)S:(AU;FA;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;WD)`
Без изысков.
Как видно, есть 2 интересных префикса:
S: — System Access Control List (SACL) — это нас сейчас не интересует.
D: — Discretionary ACL (DACL) — здесь указываются права для всех и всего.
Смотрим далее.
Первая буква после скобок означает разрешаем (A, Allow) или запрещаем (D, Deny).
Мы разрешаем:
(A;;;;;)
И потом видим комбинации из двух букв:
`CC - SERVICE_QUERY_CONFIG
LC - SERVICE_QUERY_STATUS
SW - SERVICE_ENUMERATE_DEPENDENTS
LO - SERVICE_INTERROGATE
CR - SERVICE_USER_DEFINED_CONTROL
RC - READ_CONTROL
RP - SERVICE_START
WP - SERVICE_STOP
DT - SERVICE_PAUSE_CONTINUE`
По сути, нас будут интересовать последние три опции:
(A;;RPWPDT;;;)
Последние 2 буквы обозначают кому мы разрешаем или запрещаем:
`AU Authenticated Users
AO Account operators
RU Alias to allow previous Windows 2000
AN Anonymous logon
AU Authenticated users
BA Built-in administrators
BG Built-in guests
BO Backup operators
BU Built-in users
CA Certificate server administrators
CG Creator group
CO Creator owner
DA Domain administrators
DC Domain computers
DD Domain controllers
DG Domain guests
DU Domain users
EA Enterprise administrators
ED Enterprise domain controllers
WD Everyone
PA Group Policy administrators
IU Interactively logged-on user
LA Local administrator
LG Local guest
LS Local service account
SY Local system
NU Network logon user
NO Network configuration operators
NS Network service account
PO Printer operators
PS Personal self
PU Power users
RS RAS servers group
RD Terminal server users
RE Replicator
RC Restricted code
SA Schema administrators
SO Server operators
SU Service logon user`
+ к этому списку можно явно указать пользователя по SID'у.
Вот это самое интересное!
как узнать SID пользователя?
есть не один способ :)
но, самый простой и удобный (на мой взгляд), написать маленький скриптик на vb:
`strComputer = "."
Set objWMIService = GetObject("winmgmts:\\" & strComputer & "\root\cimv2")
Set objAccount = objWMIService.Get _
("Win32_UserAccount.Name='username',Domain='domain'")
Wscript.Echo objAccount.SID`
Заменяем имя пользователя и домен по своему вкусу, сохраняем файл с расширением .vbs и запускаем.
Появляется алерт с SID.
Копируем в блокнот(или в любое другое место)
Можно скрипт запустить в консоли, сэкономим время :)
И так. Узнали SID.
Вставляем в ключ:
(A;;RPWPDT;;;S-1-5-21-3992622163-2725220152-438995547-4172)
Теперь подготавливаем команду целиком:
`sc sdset D:(A;;RPWPDT;;;S-1-5-21-3992622163-2725220152-438995547-4172)(A;;CCLCSWRPWPDTLOCRRC;;;SY)(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;BA)(A;;CCLCSWLOCR
RC;;;IU)(A;;CCLCSWLOCRRC;;;SU)S:(AU;FA;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;WD)`
Наш ключ вставляем в любое место, но важно чтобы он был перед префиксом S.
Важно не ошибиться, иначе можем потерять доступ к сервису :)
Запускаем.
проверяем:
sc \\server stop «service\_name»
Надеюсь, основную мысль донес.
Так же жду критики, тк подозреваю что могут быть способы проще.
**UPD** можно, кстате, использовать группы.
для того чтобы узнать SID группы — вместо username, напишите имя группы. | https://habr.com/ru/post/75090/ | null | ru | null |
# Mozart: ссылки Вперед — Назад в списочных материалах
Понадобилось мне в разделе Статьи одного из проектов, что использует в качестве базиса Mozart (mozartframework.ru), реализовать в конце каждой статьи ссылку на следующую и предыдущую. Нет ничего проще, дальше по большей части будет инструкция по использованию XSLT.
Для начала я залез в XML и поправил немножко тот участок, который отвечает за вывод списка уроков и параллельно за полный вывод информации об одном уроке.
> `Copy Source | Copy HTML
>
>
> <newt:include match="query[lesson\_id/@value='' or not(lesson\_id)]">
> <newt:base id="lessons-list" add-query="lessons-list" query-filter="lesson\_id">
> <request>
> <get limit="20" object="lesson" sort="sort">
> <info attr="shortdescription"/>
> get>
> request>
> newt:base>
> newt:include>
>
>
>
> <newt:include match="query[lesson\_id/@value!='']">
> <newt:base id="lessons-list" add-query="lessons-list" query-filter="lesson\_id">
> <request>
> <get limit="20" object="lesson" sort="sort">
> <info attr="description"/>
> get>
> request>
> newt:base>
> newt:include>`
Get'ом выбираем уроки в кол-ве не более 20 и дополнительно выбираем через Info полный текст. Больше 20 нам пока не понадобится. Я лишь для наглядности привел такую реализацию выборки данных для списка и полного вывода через newt:include, чтобы было более понятно (на самом деле способов сделать это множество). По тексту ясно, что один участок для списка, а второй — для полного текста. В реальной системе все несколько лаконичней описано.
Теперь самая главная фишка — это разворачиваемость объектов. Она нам тут поможет тем, что не заставит нас совершать какие-то сложные действия для того, чтобы выбрать предыдущий и следующий уроки. Когда мы используем get и не указываем дополнительных ограничений по id (именно id), то мы можем использовать понятие разворачиваемости вот каким образом. Если в query (в данном случае в виде параметра через УРЛ) мы подаем параметр lesson\_id, и этот параметр пропускаем до нашего newt:base и инструкции get, инструкция эта ведет себя особенным образом: разворачивается (т.е. выбираются полные даные по объекту и все его вложенные инструкции типа info и т.п.) только тот объект, чей id совпадает с переданными нами. Остальные объекты будут просто идти в виде краткой записи в XML до и после развернутого.
Т.е. на выходе в случае наличия lesson\_id=85 мы получим:
> `Copy Source | Copy HTML
> <base id="lessons-list" add-query="lessons-list" ... >
> <lesson id="83" query="&lesson\_id=83" title="Урок 1: Создание новой страницы"/>
> <lesson id="84" query="&lesson\_id=84" title="Урок 2: Навигация по сайту"/>
> <lesson id="85" query="&lesson\_id=85" title="Урок 3: Работа с БД">
> <description>
> ...
> description>
> lesson>
> <lesson id="86" query="&lesson\_id=86" title="Урок 4: Создание раздела Новости"/>
> <lesson id="87" query="&lesson\_id=87" title="Урок 5: Репликация"/>
> <lesson id="88" query="&lesson\_id=88" title="Урок 6: Работа с формами"/>
> base>`
Далее нам осталось только правильно обработать данный XML в XSLT трансформе, а это просто. Под текстом урока ставим вызов нужного созданного нами позже темплейта:
> `Copy Source | Copy HTML
> <xsl:template match="lesson[description]">
> ...
> ...
> <xsl:apply-templates select="." mode="pagelisting"/>
> xsl:template>
>
> <xsl:template match="lesson[description]" mode="pagelisting">
> <p style="text-align: center;">
> <xsl:if test="preceding-sibling::lesson[1]">
> <a href="/docs.xml?lesson\_id={preceding-sibling::lesson[1]/@id}"><xsl:value-of select="preceding-sibling::lesson[1]/@title"/>a>
> xsl:if>
> <xsl:if test="preceding-sibling::lesson[1] and following-sibling::lesson[1]"> | xsl:if>
> <xsl:if test="following-sibling::lesson[1]">
> <a href="/docs.xml?lesson\_id={following-sibling::lesson[1]/@id}"><xsl:value-of select="following-sibling::lesson[1]/@title"/>a>
> xsl:if>
> p>
> xsl:template>`
В самом темплейте мы используем оси (preceding-sibling и following-sibling) а так же через указания номера элемента ([1]) указываем, какой именно нам нужен, ведь мы хотим поставил ссылку только на один элемент вперед и один элемент назад. Это чистый XSLT и никаких приблуд от Mozart тут нет. | https://habr.com/ru/post/89262/ | null | ru | null |
# Механический дисплей из лего и Arduino
Если верить учебникам, то первые «телевизоры» были с механической развёрткой на [диске Нипкова](http://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%81%D0%BA_%D0%9D%D0%B8%D0%BF%D0%BA%D0%BE%D0%B2%D0%B0). Понятное дело, определение телевизора у каждого своё и для бытового применения механика малопригодна, однако решил и я попробовать сделать механический дисплей. К счастью в семье обнаружился восьмилетний специалист по моторчикам, он и смастерил «хардверную» часть установки. Lego Power Functions Medium Motor, питаясь от девяти вольт, способен при помощи кривошипно-шатунного механизма раскачивать планку на 15 отверстий с частотой в несколько Герц.
Следующим шагом была установка светодиодов. К счастью, диаметр отверстий Lego ровно 5мм, так что диоды идеально входят с большим усилием и не расшатываются в время работы. Катоды соединил вместе, а аноды вывел по отдельности наружу мягким проводом на 0.05. Получилось девять проводников, но силы мотора хватает с избытком.
Теперь надо позаботиться о синхронизации. Двигатель у меня самый простой — не шаговый и без энкодера, так что решил ловить начало цикла фотоячейкой. Позади мотора укрепил яркий светодиод, который светит через тонкую трубку. Луч света при каждом обороте пересекается кривошипом и затемняет фоторезистор. Для уменьшения помех от внешнего освещения он смотрит точно на светодиод, тоже через трубочку.
Фоторезистор закрепил просто зажав его между двумя кубиками лего.
Теперь осталось подсоединить конструкцию к Arduino. Светодиоды подключил к цифровым выходам через ограничительные резисторы на 150 Ом, фоторезистор — к входу АЦП.
В результате, мой «телевизор» стал выглядеть вот так:
Заливаем простенькую программу, которая ждёт затемнения фоторезистора, а потом выстреливает с заданным интервалом на цифровые выходы (2..9) нужные данные. Горизонтальный размер одного пикселя определяется подбираемой вручную задержкой, для моей установки оптимальное значение составило 2,3 миллисекунды.
```
/*
Shows a picture on mechanical desply connected to Arduino
Display's LED connected to digital pins 2..9 via 150 Ohm resisitors
Photoresistor connected to analog pin 0 and GND. It is also connected to 5V using 10 kOhm resistor.
*/
void setup()
{
for (int i = 2; i <= 9; i++)
{
pinMode(i, OUTPUT);
}
}
// Bit map of the picture (right to left) that we are going to show
unsigned char Pivo[] = {
B01111100,
B10000010,
B10000010,
B10000010,
B10000010,
B01111100,
B00000000,
B00000000,
B01101100,
B10010010,
B10010010,
B11111110,
B00000000,
B00000000,
B11111110,
B01000000,
B00111000,
B00000100,
B11111110,
B00000000,
B00000000,
B11111110,
B10000000,
B10000000,
B10000000,
B11111110 };
void loop()
{
// Wait for the synchronization (photoresistor covered by the motor bar)
waitForBegin();
// Do not start from the imidiatelly as the LED beam is moving too slow in the first milliseconds
delay(20);
int del = 2300; // pixel "length" in microseconds
for(int i = 0; i < 26; i++)
{
showByte(Pivo[i], del);
}
}
void waitForBegin()
{
while (analogRead(0) > 650)
{
delayMicroseconds(200);
}
}
void showByte(int info, long del)
{
// Light LEDs if necessary
for (int i = 2; i <= 9; i++)
{
digitalWrite(i, (info & 0x01) ? HIGH : LOW);
info >>= 1;
}
// Wait a little
if (del < 30000)
{
delayMicroseconds(del);
}
else
{
delay (del/1000);
}
// Turn LEDs off
for (int i = 2; i <= 9; i++)
{
digitalWrite(i, LOW);
}
}
```
Теперь, затаив дыхание, включаем, и вот оно, чудесное мгновенье!
Разрешение порядка 30 пикселей по горизонатали на 8 по вертикали, при меньших задержках пиксели получаются слишком сжатыми. Частота кадров — около пяти в секунду.
##### Что дальше?
* Можно подключить светодиоды не непосредственно к цифровым выходам, а через восьмибитный расширитель шины PCF 8574, который смонтировать непосредственно на качающейся планке. Тогда хватит четырёх проводов вместо восьми (питание и два для I2C).
* Можно попробовать вставить RGB светодиоды вместо монохромных и сделать цветной «телевизор».
* В Arduino UNO USB-разъём подключён к конвертеру Atmel ATmega8U2. По-умолчанию он видится компьютером как последовательный порт, но его можно перепрограммировать чтоб он представлялся мышью или, например, джойстиком. Интересно, можно ли сделать чтоб он распознался как внешний монитор?
##### Ссылки
Идея использовать лего позаимстована из книги Михаэля Гаспери "[Extreme NXT](http://www.amazon.com/Extreme-NXT-Extending-MINDSTORMS-Technology/dp/1590598180/)". К счастью, покупать Mindstorms NXT за три сотни евро не нужно, и можно обойтись на порядок более дешёвым Arduino. | https://habr.com/ru/post/135709/ | null | ru | null |
# Транслируем звук по сети с помощью Java
Стало мне интересно поэкспериментировать с передачей звука по сети.
Выбрал для этого технологию Java.
В итоге написал три компоненты — передатчик для Java SE, приемник для Java SE и приемник для Android.
В Java SE для работы со звуком использовались классы из пакета *javax.sound.sampled*, в Android — классы *android.media.AudioFormat*, *android.media.AudioManager* и *android.media.AudioTrack*.
Для работы с сетью — стандартные *Socket* и *ServerSocket*.
С помощью этих компонент удалось успешно провести сеанс голосовой связи между Дальним Востоком России и Нидерландами.
И еще одно возможное применение — если установить виртуальную звуковую карту, например, Virtual Audio Cable, можно транслировать музыку на другие устройства, и, таким образом, слушать музыку одновременно в нескольких комнатах квартиры (при наличии соответствующего количества девайсов).
#### 1. Передатчик.
Способ трансляции звука тривиален — считываем поток байтов с микрофона, и записываем его в выходной поток сокета.
Работа с микрофоном и передача данных по сети происходит в отдельных потоках:
```
mr = new MicrophoneReader();
mr.start();
ServerSocket ss = new ServerSocket(7373);
while (true) {
Socket s = ss.accept();
Sender sndr = new Sender(s);
senderList.add(sndr);
sndr.start();
}
```
Поток для работы с микрофоном:
```
public void run() {
try {
microphone = AudioSystem.getTargetDataLine(format);
DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
microphone = (TargetDataLine) AudioSystem.getLine(info);
microphone.open(format);
data = new byte[CHUNK_SIZE];
microphone.start();
while (!finishFlag) {
synchronized (monitor) {
if (senderNotReady==sendersCreated) {
monitor.notifyAll();
continue;
}
numBytesRead = microphone.read(data, 0, CHUNK_SIZE);
}
System.out.print("Microphone reader: ");
System.out.print(numBytesRead);
System.out.println(" bytes read");
}
} catch (LineUnavailableException e) {
e.printStackTrace();
}
}
```
UPD. Примечание: важно правильно подобрать параметр *CHUNK\_SIZE*. При слишком малом значении будут слышны заикания, при слишком большом — становится заметной задержка звука.
Поток для передачи звука:
```
public void run() {
try {
OutputStream os = s.getOutputStream();
while (!finishFlag) {
synchronized (monitor) {
senderNotReady++;
monitor.wait();
os.write(data, 0, numBytesRead);
os.flush();
senderNotReady--;
}
System.out.print("Sender #");
System.out.print(senderNumber);
System.out.print(": ");
System.out.print(numBytesRead);
System.out.println(" bytes sent");
}
} catch (Exception e) {
e.printStackTrace();
}
}
```
Оба класса потоков — вложенные, переменные внешнего класса *data*, *numBytesRead*, *senderNotReady*, *sendersCreated* и *monitor* должны быть объявлены как *volatile*.
Объект *monitor* используется для синхронизации потоков.
#### 2. Приемник для Java SE.
Способ так же тривиален — считываем поток байтов из сокета, и записываем в аудиовыход.
```
try {
InetAddress ipAddr = InetAddress.getByName(host);
Socket s = new Socket(ipAddr, 7373);
InputStream is = s.getInputStream();
DataLine.Info dataLineInfo = new DataLine.Info(SourceDataLine.class, format);
speakers = (SourceDataLine) AudioSystem.getLine(dataLineInfo);
speakers.open(format);
speakers.start();
Scanner sc = new Scanner(System.in);
int numBytesRead;
byte[] data = new byte[204800];
while (true) {
numBytesRead = is.read(data);
speakers.write(data, 0, numBytesRead);
}
} catch (Exception e) {
e.printStackTrace();
}
```
#### 3. Приемник для Android.
Способ тот же самый.
Единственное отличие — вместо *javax.sound.sampled.SourceDataLine* используем *android.media.AudioTrack*.
Так же нужно учесть, что в Android работы с сетью не может происходить в основном потоке выполнения приложения.
С созданием сервисов решил не заморачиваться, запускать рабочий поток будем из основной Activity.
```
toogle.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (!isRunning) {
isRunning = true;
toogle.setText("Stop");
rp = new ReceiverPlayer(hostname.getText().toString());
rp.start();
} else {
toogle.setText("Start");
isRunning = false;
rp.setFinishFlag();
}
}
});
```
Код самого рабочего потока:
```
class ReceiverPlayer extends Thread {
volatile boolean finishFlag;
String host;
public ReceiverPlayer(String hostname) {
host = hostname;
finishFlag = false;
}
public void setFinishFlag() {
finishFlag = true;
}
public void run() {
try {
InetAddress ipAddr = InetAddress.getByName(host);
Socket s = new Socket(ipAddr, 7373);
InputStream is = s.getInputStream();
int bufferSize = AudioTrack.getMinBufferSize(16000,
AudioFormat.CHANNEL_OUT_STEREO, AudioFormat.ENCODING_PCM_16BIT);
int numBytesRead;
byte[] data = new byte[bufferSize];
AudioTrack aTrack = new AudioTrack(AudioManager.STREAM_MUSIC,
16000, AudioFormat.CHANNEL_OUT_STEREO, AudioFormat.ENCODING_PCM_16BIT,
bufferSize, AudioTrack.MODE_STREAM);
aTrack.play();
while (!finishFlag) {
numBytesRead = is.read(data, 0, bufferSize);
aTrack.write(data, 0, numBytesRead);
}
aTrack.stop();
s.close();
} catch (Exception e) {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
e.printStackTrace(pw);
Log.e("Error",sw.toString());
}
}
}
```
#### 4. Примечание о форматах аудио.
В Java SE используется класс [javax.sound.sampled.AudioFormat](https://docs.oracle.com/javase/7/docs/api/javax/sound/sampled/AudioFormat.html).
В Android — параметры аудио передаются напрямую в конструктор объекта [android.media.AudioTrack](http://developer.android.com/reference/android/media/AudioTrack.html).
Рассмотрим конструкторы этих классов, которые использовались в моем коде.
Java SE:
*AudioFormat(float sampleRate, int sampleSizeInBits, int channels, boolean signed, boolean bigEndian)*
Constructs an AudioFormat with a linear PCM encoding and the given parameters.
Android:
*AudioTrack(int streamType, int sampleRateInHz, int channelConfig, int audioFormat, int bufferSizeInBytes, int mode)*.
Для успешного воспроизведения параметры приемника и передатчика *sampleRate/sampleRate*, *sampleSizeInBits/audioFormat* и *channels/channelConfig* должны соответствовать друг другу.
Помимо этого, значение *mode* для Android нужно установить в *AudioTrack.MODE\_STREAM*.
Так же, экспериментально удалось установить, что для успешного воспроизведения на Android нужно передавать данные в формате *signed little endian*, то есть:
*signed = true; bigEndian = false.*
В итоге были выбраны следующие форматы:
```
// Java SE:
AudioFormat format = new AudioFormat(16000.0f, 16, 2, true, bigEndian);
// Android:
AudioTrack aTrack = new AudioTrack(AudioManager.STREAM_MUSIC,
16000, AudioFormat.CHANNEL_OUT_STEREO, AudioFormat.ENCODING_PCM_16BIT,
bufferSize, AudioTrack.MODE_STREAM);
```
#### 5. Тестирование.
Между ноутбуком на Windows 8 и десктопом на Debian Wheezy все завелось сразу без проблем.
Приемник на Android изначально издавал лишь шум, но эта проблема устранилась после правильного подбора параметров *signed* и *bigEndian* для формата аудио.
На Raspberry Pi (Raspbian Wheezy) изначально были слышны заикания — понадобились костыли в виде установки легковесной виртуальной java-машины avian.
Написал следующий скрипт запуска:
```
case "$1" in
start)
java -avian -jar jAudioReceiver.jar 192.168.1.50 &
echo "kill -KILL $!">kill_receiver.sh
;;
stop)
./kill_receiver.sh
;;
esac
```
Исходные коды всех компонент здесь:
[github.com/tabatsky/NetworkingAudio](https://github.com/tabatsky/NetworkingAudio) | https://habr.com/ru/post/242949/ | null | ru | null |
# Стилизация iOS-приложений: как мы натягиваем шрифты, цвета и изображения
[](http://habrahabr.ru/company/redmadrobot/blog/255381/)
В ходе работы над мобильным приложением разработчики получают от дизайнеров макеты, шрифты и изображения. Преобразование этих материалов в код — нудное занятие, да и в процессе каждый норовит изобрести свой велосипед. Чтобы проекты оставались чистыми, мы приняли единую конвенцию по работе со стилями.
#### **Цветовая схема**
[](https://habrastorage.org/files/61a/4f7/24d/61a4f724d3014897ad67564b1c060640.png)
Это первый кандидат на кодогенерацию. Мы решили передавать список цветов в формате, который легко набрать руками и так же легко распарсить, чтобы сгенерировать категорию UIColor.
Дизайнеры собирают простой текстовый файл #COLOR — TITLE. Разработчики включают этот файл в проект, а скрипт перед компиляцией генерирует файлы с кодом и палитрой в формате CLR. Такую палитру можно использовать для работы в Interface Builder.
```
#B3ED3B green
#5ABBF2 blue
#FD86C9 pink
#FD4737 red
#FEAE30 orange
```
[](https://habrastorage.org/files/9b8/111/aff/9b8111affd2c4501b0a4e3946dba42b0.png)[](https://habrastorage.org/files/abb/f25/30a/abbf2530a7e3461982c4264ffba4985a.png)
#### **Нюансы**
В использовании палитры есть несколько проблем.
Первая заключается в том, что панель Colors не обновляет список доступных палитр, как и их содержимое. Каждое приложение в OS X может иметь свой экземпляр панели Colors, и чтобы вновь сгенерированная палитра была добавлена в панель или обновилась, необходимо перезапустить всё приложение.
Поэтому мы написали небольшой плагин для Xcode, который после каждого билда передергивает все пользовательские палитры в панели Colors.
Вторая проблема происходит из формата, в котором Interface Builder сохраняет установленный для элемента цвет:
```
```
Голые цифры, и ни одного намёка на палитру — а значит, если мы её обновим, в xib/storyboard всё останется по-старому. К сожалению, эту проблему нам решить не удалось, но мы определили два возможных подхода:
1. **Не использовать палитры.** На все элементы провешивать Outlet’ы и красить кодом. Проблема неактуального представления элементов в Interface Builder частично решается технологией IBDesignable.
2. **Использовать решение в лоб.** Если необходимо заменить цвет, пробегаться по xml, который стоит за каждым xib или storyboard, и заменять совпадения на новый цвет. Как, например, [здесь](https://github.com/ramonpoca/ColorTools/blob/master/xibcolor). Не самое изящное решение, но работает.
Нашу утилиту для генерации категории UIColor и плагин для перезагрузки списка палитр панели Colors вы можете найти на GitHub — [RMRColorTools-iOS](https://github.com/RedMadRobot/RMRColorTools-iOS).
С плагином всё просто. Необходимо клонировать репозиторий и запустить на исполнение таргет RMRRefreshColorPanelPlugin, а затем перезапустить Xcode.
Для автоматической генерации UIColor при каждом билде на вкладке Build Phases добавьте Run Script Phase с вызовом утилиты RMRHexColorGen.
[](https://habrastorage.org/files/9c6/1a6/d91/9c61a6d91266442abbad2241f5080898.png)
[](https://habrastorage.org/files/ab7/0f4/a08/ab70f4a08e214ddc8e6dc79bb4827992.png)
[](https://habrastorage.org/files/b98/f9f/6e2/b98f9f6e2f5d4ebd8f13681ac4a6b01c.png)
[](https://habrastorage.org/files/f0f/a0d/862/f0fa0d862e874c4c9236b27a343e74fa.png)
#### **Шрифты**
[](https://habrastorage.org/files/708/6ec/c18/7086ecc18c6d4b74b44f67a316df90e9.png)
Мы хотели, чтобы была одна точка входа для работы со шрифтами, поэтому на основе таблицы стилей мы реализуем категорию UIFont:
```
@implementation UIFont (RMRFonts)
+ (UIFont *)rmr_regularFontOfSize:(CGFloat)size
{
return [UIFont fontWithName:@"HelveticaNeue"
size:size];
}
+ (UIFont *)rmr_mediumFontOfSize:(CGFloat)size
{
return [UIFont fontWithName:@"HelveticaNeue-Medium"
size:size];
}
#pragma mark - Style fonts
+ (UIFont *)rmr_fontA1 { return [self rmr_mediumFontOfSize:17.f]; }
+ (UIFont *)rmr_fontA2 { return [self rmr_regularFontOfSize:17.f]; }
+ (UIFont *)rmr_fontB1 { return [self rmr_regularFontOfSize:14.f]; }
+ (UIFont *)rmr_fontB2 { return [self rmr_regularFontOfSize:11.f]; }
+ (UIFont *)rmr_fontB3 { return [self rmr_mediumFontOfSize:10.f]; }
@end
```
Провешивать на каждый label outlet для установки шрифта — даже звучит не очень. Поэтому мы реализовали сабкласс UILabel с установкой стиля при инициализации. Стиль устанавливается в конкретном сабклассе.
```
@implementation RMRLabel
- (void)prepareAppearance
{
// Абстрактный метод для переопределения наследниками
}
- (instancetype)initWithFrame:(CGRect)frame
{
if (self = [super initWithFrame:frame]) {
[self prepareAppearance];
}
return self;
}
- (void)awakeFromNib
{
[self prepareAppearance];
}
@end
@implementation RMRLabelA1
- (void)prepareAppearance { self.font = [UIFont rmr_fontA1]; }
@end
```
Это позволяет определять установленный стиль, задавая конкретный сабкласс UILabel в Interface Builder.
Профит от такой схемы (Font ⇢ UlLabel ⇢ IB) — если потребуется стиль изменить, то вся работа будет локализована в единственном файле.
#### **Изображения**
В Xcode 6 мы получили возможность использовать векторные изображения в формате pdf. Вкупе с tint color и возможностью использовать изображения как шаблон мы получаем простой механизм, который позволяет забыть о танцах с ресурсами, если потребовалось на полтона изменить цвет иконок.
[](https://habrastorage.org/files/f11/c41/908/f11c419086e1468a8b2cedbef6b1917f.png)
[](https://habrastorage.org/files/b09/b58/c56/b09b58c56b6049979ff04aeb4a1aaa5b.png)
#### **Заключение**
Цвета скодогенерировали, шрифты засабклассили, иконки перекрасили. Эти простые механизмы позволили нам уменьшить количество ошибок и упростить взаимодействие между дизайнерами и разработчиками.
##### Читайте также:
[Архитектурный дизайн мобильных приложений: часть 2](http://habrahabr.ru/company/redmadrobot/blog/251337/)
[Архитектурный дизайн мобильных приложений: часть 1](http://habrahabr.ru/company/redmadrobot/blog/246551/)
[Что может быть проще кнопки?](http://habrahabr.ru/company/redmadrobot/blog/243075/) | https://habr.com/ru/post/255381/ | null | ru | null |
# Cisco Router + 2ISP + NAT. Доступность сервиса через 2ух провайдеров
Толчок. За ним ещё один, сильнее. Вот и всё. Перед глазами проносились альпийские луга, и девушка в бежевом сарафане, игриво крутя в точёных ручках кружевной зонтик проносилась мимо тоже. Проносилась, не сбавляя скорости, несмотря на то, что я тянул к ней свои менее точенные, но крепкие ручонки, а также жестами и мимикой изображал, в меру сил своих, какой всесторонний кундюшок её может ожидать, раскинь она мне руки навстречу (ну или ещё что раскинь).
Но случилось что случилось, и лишь ловко выхваченный зонтик из её, кстати, не только точённых но и цепких рук, немного оттенял розовыми тонами последние секунды моего пробуждения и согревал разбитое сердце (без зонтика, закрывающего её шевелюру, девушка оказалась на поверку немного, мягко говоря, плешиватой). Открыв глаза я, как то не странно, увидел себя не посреди развалин Ниигаты, и сразу отринул сейсмическую природу толчков. Немного отлегло. Перестал кричать – «Покинуть корабль!». С укором взглянул на начальника отдела трясущего меня за плечо. Который, вместо извинений принёс мне весть, что нас с ним ожидают у директора, для постановки одного маленького, но очень ответственного задания. Не приняв его слова близко к сердцу, я несколько раз пытался вернуться к своей плешивой искусительнице, но начальник продолжал проявлять чудеса настойчивости. Пришлось идти.
Опущу момент пребывания в кабинете у директора и процесс постановки нам боевой задачи — ни к чему вам знать подробности этих преступных сцен преисполненных плохо завуалированных угроз и открытого шантажа, слёз и мольб с показыванием фотокарточек приёмных детей своих родителей, и вздыманием рук над головой, полных отчаяния просьб не губить и бросания трубок с уже набранным номером следователя комитета безопасности (были… были, как видите, и у меня на такой случай козыри в рукаве — а раньше нужно было думать, отчего я так рьяно бросался лично проверять настройки вай-фай на директорских лэптопах, а теперь как говориться — «Who is your Daddy now, darling? А? А БЛ###Ь!?»). Но, так или иначе, задача, была поставлена, и стояла она в полотне Project сервера так, что у увидевших её молоденьких девушек рделись щёки, а прочий женский коллектив с некоторым, знаете ли, отвращением поглядывал на фотокарточки своих рахитичных половинок, стоящих на углах столов пожилых прелестниц. Пути назад не было – задачу нужно было решать.
Итак, суть – необходимо было обеспечить удалённый доступ к некоему серверу для группы лиц, для совершения оными на оном сервере действий явновыраженного коррупционного характера, не терпящих отлагательств и неприемлющих простоя. Сетевая часть данной задачи тяжелым бременем взгромоздилась на мои хрупкие плечи и крепко обняла за шею. Становилось трудно дышать и подниматься по лестницам на верхние этажи.
Вернувшись в кабинет, я сел крепко думать над поставленной задачей и способами получения загранпаспорта из ломбарда назад, не возвращая денег. «Ну что, случиться то может» – успокаивал я себя, — «Интернет у нас стабильный, включу шнурочек, и пущай себе работает, на радость людям и прочему преступному элементу». Отчитавшись начальству, что «Вероятность падения канала – КРАЙНЕ!!! КРАЙНЕ МАЛА!!!», и, приняв эту мысль за аксиому, я, счастливо улыбаясь, вернулся к просмотру видений с лысоватыми девушками в розовых сарафанах. Но, как назло, пытливые умы инженеров нашего уездного оператора связи в аккурат в это время начали подбираться к трём (крайне неприятным мне с той поры) буквам – BGP, и активно осваивать всяческие изыски фильтрации path атрибутов (придуманных, как нам всем известно, шайтаном, с которым, эти инженеры, наверняка, имеют прямые родственные связи), а также испытывать алгоритм выбора маршрута на соответствие заявленному, не доверяя до конца RFC 4274. Вследствие действий этой группы лиц по предварительному сговору (инженеров, а далее – сил зла), в благостной тишине нашего отдела всё чаще и чаще раздавались звонки. Дословное содержание звонков мне неизвестно, но судя по появлению первых седых волос на голове начальника отдела (что при его причёске “под ноль” — довольно тревожный знак) и по его богатой мимике, при пересказе мне впечатлений пользователей сервиса о качестве его (сервиса) предоставления, ситуация требовала оперативного вмешательства.
По результатам непродолжительного мозгового штурма командой высокопрофессиональных сетевых инженеров (мной), было решено подключить резервный канал. Но так как борьба разворачивалась не за определённый участок трассы, который можно было бы тречить по sla и в случае чего преключать канал с основного на резервный, а с силами зла, серьёзно взявшимися за изучение BGP, то необходимо было настроить доступность сервера на обоих каналах единовременно (Рис 1). И в случае недоступности первого адреса из какой-то автономки (откуда то адрес мог быть доступен, а откуда то нет), пользователь бы подключался на второй, но в тоже время другие пользователи, могли бы иметь доступ к серверу, обращаясь на первый адрес.
Рис1.
**NOTE:** *Была конечно мыслишка самим взяться да и использовать орудие врага супротив него, но так как при каждом упоминании о BGP весь отдел вскакивал и осенял округу крёстными знамениями, то решено было в RIPE с челобитной не писать, Бога не гневить.*
Итак, имея на руках условия и ограничения при решении задачи, было найдено решение, использующее следующие средства: NAT, static routes, route-maps. Рассмотрим данное решение на примере, приведённом на рисунке 2. Схеме адресации в примере использует только приватные адреса. Адреса на участке между офисным маршрутизатором (R1)и гейтом (R2)первого оператора связи (ISP1) изменены на 172.16.12.0/29, а между офисным маршрутизатором (R1)и гейтом (R3) второго оператора связи (ISP2) на 172.16.13.0/29. Локальная сеть, как в жизни, так и в примере использует приватные адреса сети 192.168.1.0/24, где 192.168.1.1 принадлежат маршрутизатору, а 192.168.1.31 серверу.
`R1#sh ip int br
Interface IP-Address OK? Method Status Protocol
FastEthernet0/0 172.16.12.1 YES NVRAM up up
FastEthernet0/1 172.16.13.1 YES manual up up
FastEthernet1/0 192.168.1.1 YES NVRAM up up`
Для НАТа сервера определим следующие ip адреса в пуле каждого из провайдеров:
ISP1: 192.168.1.31 -> 172.16.12.4
ISP2: 192.168.1.31 -> 172.16.13.4
Рис2.
Настраиваем доступность сервера на канале первого провайдера -ISP1.
Дефолтный маршрут через первого провайдера:
`R1(config)#ip route 0.0.0.0 0.0.0.0 172.16.12.2`
Определяем интерфейсы, используемые при НАТ трансляциях:
`R1(config)#int fa 0/0
R1(config-if)#ip nat outside
R1(config-if)#int fa 1/0
R1(config-if)#ip nat inside`
Натим сервер
`R1(config)#ip nat inside source static 192.168.1.31 172.16.12.4 extendable`
На этом всё – сервер доступен для пользователей по адресу 172.168.12.4, и это, безусловно, нестоящий пристального рассмотрения участок настройки, но для общей картины, тем не менее, необходим.
Теперь переходим к настройке доступности сервера на канале второго провайдера -ISP2.
Определяем интерфейсы, используем при НАТ трансляциях:
`R1(config)#int fa 0/1
R1(config-if)#ip nat outside`
Натим сервер
`R1(config)#ip nat inside source static 192.168.1.31 172.16.13.4 extendable`
И вот теперь мы подошли к наиболее интересному вопросу – как направить ответы от сервера через интерфейс FastEthernet0/1, в случае если клиент пришел через ISP 2. Первое, что приходит на ум, и как выяснилось далее (выяснение велось, посредством нескольких весьма эффективных процедур, заимствованных у испанского отделения трибунала священной канцелярии инквизиции, и результаты сомнению не подлежат) является верным решением – это использование route-map. Итак, на интерфейсе fa1/0 нам необходимо перехватить пакеты, возвращающиеся к клиентам, пришедшим через ISP2. Как заmatchить эти пакеты пока не совсем понятно. Source адрес пакета одинаков – 192.168.1.31, Destination тоже никоим образом не идентифицирует интерфейс, с которого пакет попал на маршрутизатор. Напряжение росло, решение не приходило. Перспективы повторных встреч с коленоликой соблазнительницей уменьшались. После обильного гугления и прочтения трактата “Camouflage and Art: Design for Deception in World War 2. Unicorn Press” решение пришло — вносим в конфигурацию, и чуть позже объясним.
`R1(config)#ip nat pool ISP_2nd 192.168.133.0 192.168.133.254 prefix-length 24
R1(config)#access-list 100 permit ip any host 172.16.13.4
R1(config)#ip nat outside source list 100 pool ISP_2nd add-route`
Для пакетов приходящих на интерфейс fa 0/1 от второго провайдера мы транслируем адреса пользователей (source ip address) в пул 192.168.133.x/24 и теперь возвращающиеся пакеты к пользователям, обратившихся к серверу через второго оператора, будут на интерфейсе fa 1/0 иметь поле dst ip addr=192.168.133.x что позволит нам провернуть следующие:
`R1(config)#access-list 101 permit ip any 192.168.133.0 0.0.0.255
R1(config)#route-map 2ISP permit 10
R1(config-route-map)#match ip address 101
R1(config-route-map)#set ip next-hop 172.16.13.3
R1(config-route-map)#exit
R1(config)# int fa 1/0
R1(config-if)#ip policy route-map 2ISP`
И вуаля — работоспособное решение готово. Краткий отчёт руководству, имплементейшн и … казалось бы – закатывай той, лей вино, жги близлежащие деревни, в общем отмечай как обычно выполнение планов за месяц и радуйся жизни, но… но нет. Собрав лабу в GNS3 и, пожалев ресурсов на два клиентских хоста, ограничился одним и заметил следующую особенность – если клиент соединяется с сервером через второго оператора связи на адрес 172.16.13.4 в НАТ трансляциях у нас появляются следующие строчки:
`R1#show ip nat translations
Pro Inside global Inside local Outside local Outside global
--- --- --- 192.168.133.1 ZZ.ZZ.ZZ.ZZ
tcp 172.16.13.4:3389 192.168.1.31:3389 192.168.133.1:59324 ZZ.ZZ.ZZ.ZZ:59324`
Особое внимание обращаем на первую строчку. Теперь если в силу каких либо причин пользователь будет разъединён и переподключится на адрес 172.16.12.4 через ISP1, source address пакетов идущих от него также будет транслирован в пул 192.168.133.x/24 и пакеты от сервера идущие к нему попадут под route-map и будут выкинуты через интерфейс fa0/1 в сеть ISP2. И если трансляция
t`cp 172.16.13.4:3389 192.168.1.31:3389 192.168.133.136:59324 ZZ.ZZ.ZZ.ZZ:59324`
со временем заэкспайрится и трансляция очиститься по истечению тайм аута, то первая так и остаётся висеть, что создает, согласитесь, серьёзную проблему. И, как говорилось в рекламе, – «Чем я его только не пробовала!», был испробован и дополнительный NAT на первом fa 0/0, и попытки локализовать второй интерфейс в VRF, и NAT NVI, и щедрые кровавые воздаяния уссурийскому мифическому тигру — «дусэ», и даже верный способ выстраивания 7 девственных дев (нагих ессесно, это ритуал, а не утренник в младшей школе) в звезду Давида вокруг маршрутизатора, глаз усладил, но желаемого результата не принес (хотя судя по томным лицам некоторых коллег выбегающих из кабинета в ходе обряда – желаемые результаты у всех разные). Ситуация требовала оперативного сбора всё той же команды высокопрофессиональных инженеров (не путать с инженерами сил зла), и она (ситуация) этот сбор получила. Ну а дальше всё по накатанной схеме – мозговой штурм, решение найдено, имплементейшн, отчёт начальству, той с кровавыми воздаяниями, алое зарево над Сосновкой и т.д.
Ну, приступим быстрее к рассмотрению. Никаких критических изменений топология не притерпивает, единственно добавляется интерфейс loopback 0 c ip адресом 10.0.0.1/32. Что касается используемых IOS features, то это будет опять policy based routing.
Рис 3.
Производим конфигурацию (конфигурация производится с 0 – предыдущие настройки удалены).
Определяем интерфейсы для NAT трансляций:
`R1(config)#int fa 0/0
R1(config-if)#ip nat outside
R1(config-if)#int lo0
R1(config-if)#ip nat outside
R1(config-if)#int fa 1/00
R1(config-if)#ip nat inside`
Особенно стоит отметить, что теперь интерфейс fa 0/1 в операциях NAT не участвует.
Добавляем правила NAT:
`R1(config)#ip nat inside source static 192.168.1.31 172.16.12.4 extendable
R1(config)#ip nat inside source static 192.168.1.31 172.16.13.4 extendable`
Дефолтный маршрут через первого провайдера:
`R1(config)#ip route 0.0.0.0 0.0.0.0 172.16.12.2`
Итак, доступ через fa0/0 (через ISP1) уже обеспечен, а что касается работы через второго оператора то, если вы ещё не догадались, идея такова, что вместо того чтобы производить NAT трансляцию на интерфейсе fa0/1, мы будем перенаправлять входящие пакеты с этого интерфейса на интерфейс lo0 и натить сервер в 172.16.13.4 там. Это даст нам в последствие возможность при помощи route-map на lo0 отследить пакеты от сервера, которые должны возвращаться через второго провайдера и перенаправить их через fa 0/1 в обход GRT (general routing table). Итого в этом действе будет задействовано 3 route-map:
`R1(config)#ip access-list extended from_2ndISP
R1(config-ext-nacl)#permit ip any host 172.16.13.4
R1(config-ext-nacl)#route-map from_2ndISP permit 10
R1(config-route-map)#match ip address from_2ndISP
R1(config-route-map)#set interface Loopback1
R1(config-route-map)#int fa 0/1
R1(config-if)#ip policy route-map from_2ndISP`
Эта роут мапа (from\_2ndISP) будет перенаправлять все пакеты пришедшие на интерфейс fa0/1 на интерфейс lo0 где будет происходить NAT трансляция и дальнейшая маршрутизация пакетов к серверу посредством connected маршрута в GRT.
Далее,
`R1(config)#ip access-list extended srv_2_loop
R1(config-ext-nacl)#permit ip host 192.168.1.31 any
R1(config-ext-nacl)# route-map srv_2_loop permit 10
R1(config-route-map)#match ip address srv_2_loop
R1(config-route-map)#set interface Loopback1
R1(config-route-map)#int fa 1/0
R1(config-if)#ip policy route-map srv_2_loop`
С помощью этой роут мапы (srv\_2\_loop) все пакеты идущие от сервера будут перенаправлены на интерфейс lo0, причём в input queue на интерфейс пакеты попадут уже после прохождения обратной NAT трансляции (в source поле будет уже не 192.168.1.31 а 172.16.13.4 для сессий инициированных через второго оператора связи), что позволит нам
`R1(config)#ip access-list extended back_2ndISP
R1(config-ext-nacl)#permit ip host 172.16.13.4 any
R1(config-ext-nacl)# route-map back_2ndISP permit 10
R1(config-route-map)#match ip address back_2ndISP
R1(config-route-map)#set ip nex-hop 172.16.13.3
R1(config-route-map)#int fa lo0
R1(config-if)#ip policy route-map back_2ndISP`
пакеты с source 172.16.13.4 перенаправить на шлюз второго оператора связи, а всё что не попало под acl back\_2ndISP будет cмаршрутизировано при помощи GRT.
Вот собственно и всё. Оба варианта можно признать рабочими, но первый в ряде ситуаций таковым быть перестаёт, что делает второй способ более надёжным, хоть и менее изящным.
За сим оставляю Вас за осмысливанием (возможно кому то было откровение после прочтения, так что не торопитесь), а сам пойду прогуливаться по живописным набережным, освежая окружающий пейзаж своей статной фигурой под бежевым кружевным зонтом.
Используемая литература:
Jeff Doyle, Jennifer DeHaven Carroll. Routing TCP/IP, Volume II (2001 CiscoPress)
И. А. Крывелев. Костром и пыткой против науки и ученых (1933; переизд., 1934).
М. М. Шейнман. Огнем и кровью во имя бога (1924); Папство (1959); От Пия IX до Иоанна XXIII (1966).
И.О. Сусанин. Спортивное ориентирование и азы пользования ГЛОНАСС (2010; Полит Издат.) | https://habr.com/ru/post/117573/ | null | ru | null |
# Multithreading in Photon
**What this article is about**
In this article, we will talk about multithreading in the backend.
* how it is implemented
* how is it used
* what can be done
* what we invented ourselves
All these questions are relevant only if you develop something for the server side - modify the Server SDK code, write your own plugin, or even start some server application from scratch.
#### What is Photon?
*Photon* or *Photon Engine* is a well-known solution for implementing multiplayer games. Using one of their client libraries, developers (or even a single developer) implements data exchange between players. The client library establishes a connection to the backend which can be the *Photon Cloud* or the developer’s own servers.
#### How does Photon solve the issue of multithreading?
The photon server application accepts requests from multiple client connections at the same time. I will call such connections ***peers***. These requests form queues. One for each peer. If the peers are connected to the same room, their queues are merged into one - the room queue.
There are up to several thousand such rooms, and their request queues are processed in parallel.
As a basis for the implementation of task queues in Photon, the Retlang library was used, which was developed on the basis of the Jetlang library.
#### Why don't we use Task and async/await
It’s because ofthe following considerations:
1. Photon Server development started before the appearance of these features
2. The number of tasks that are performed by fibers is huge - tens of thousands per second. Therefore, there was no point in adding another abstraction, which, as it seems to me, also causesGC (Garbage Collector). The fiber abstraction is much more subtle, so to speak.
3. For sure, there is a *TaskScheduler* that does the same thing as fibers and I would have learned about it in the comments, but in general, I did not want to reinvent the wheel.
#### What is a Fiber?
A fiber is a class that implements a command queue. The commands are queued and executed **one after the other** - FIFO. We can say that the template multiple writers - single reader is implemented here. Once again, I want to draw attention to the fact that the commands are executed in the order in which they were received, i.e. one after the other. This is the basis for the security of data access in a multithreaded environment.
Although in *Photon* we use only one fiber type, namely *PoolFiber*, the library provides five types. All of them implement the *IFiber* interface. Here is a short description of each.
* ***ThreadFiber*** - an **IFiber** backed by a dedicated thread. Use for frequent or performance sensitive operations.
* ***PoolFiber*** - an **IFiber** backed by the .NET thread pool. Note**:** execution is still sequential and only executes on one pool thread at a time. Use for infrequent, less performance-sensitive executions, or when one desires to not raise the thread count.
* ***FormFiber***/***DispatchFiber*** - an **IFiber** backed by a **WinForms**/**WPF** message pump. The **FormFiber**/**DispatchFiber** entirely removes the need to call Invoke or BeginInvoke to communicate with a window from a different thread.
* ***StubFiber*** - useful for deterministic testing. Fine grain control is given over execution to make **testing races simple**. Executes all actions on the caller thread
#### About PoolFiber
Let’s talk about tasks execution in PoolFiber. Even though it uses a thread pool, the tasks in it are still executed sequentially and only one thread is used at a time. It works like this:
1. We enqueue a task in the fiber and it starts to be executed. To do this, the *ThreadPool.QueueUserWorkItem* is called. And at some point, one thread is selected from the pool and it performs this task.
2. If while the first task was running, we set several more tasks, then at the end of the first task, all the new ones are taken from the queue and the *ThreadPool.QueueUserWorkItem* is called again, so that all these tasks are sent for execution. A new thread from the pool will be selected for them. And when it finishes, if there are tasks in the queue, everything repeats from the beginning.
That is, each time a new batch of tasks is executed by a new thread from the pool, but ***only*** ONE at a time. Therefore, if all the tasks for working with the game room are placed in its fiber, you can safely access the room data from them (tasks). If the object is accessed from tasks running in different fibers, synchronization is required.
#### Why PoolFiber
*Photon* uses *PoolFiber* everywhere. First of all, just because it does not create additional threads and anyone who needs it can have their own fiber. By the way, we modified it a little and now it can't be stopped. I.e. *PoolFiber.Stop* will not stop the execution of the current tasks. It was important for us.
You can set tasks in the fiber from any thread. All this is thread-safe. A task that is currently being executed can also enqueue new tasks in the fiber in which it is being executed.
There are three ways to set a task in fiber:
1. put the task in the queue
2. put a task in a queue that will be executed after a certain interval
3. put a task in a queue that will be executed regularly.
It looks something like this:
```
// equeue task
fiber.Enqueue(()=>{some action code;});
// schedule a task to be executed in 10 seconds
var scheduledAction = fiber.Schedule(()=>{some action code;}, 10_000); ...
// stop the timer
scheduledAction.Dispose()
// schedule a task to be executed in 10 seconds and repeat every 5 seconds var scheduledAction = fiber.Schedule(()=>{some action code;}, 10_000, 5_000); ...
// stop the timer
scheduledAction.Dispose()
```
For tasks that run at some interval, it is important to keep the reference to the objectreturned by *fiber.Schedule*. This is the only way to stop the execution of such a task.
#### Executors
Now about the executors. These are the classes that actually execute the tasks. They implement the Execute(Action a) and Execute(List a) methods. *PoolFiber* uses the second one. That is, the tasks fall into the executor in a batch. What happens to them next depends on the executor. At first, we used the *DefaultExecutor* class. All it does is:
```
public void Execute(List toExecute)
{
foreach (var action in toExecute)
{
Execute(action);
}
}
public void Execute(Action toExecute)
{
if (\_running)
{
toExecute();
}
}
```
#### What else did we invent ourselves
**BeforeAfterExecutor**
Later, we added another executor to solve our logging problems. It is called *BeforeAfterExecutor*. It "wraps" the executor passed to it. If nothing is passed, *FailSafeBatchExecutor* is created. A special feature of *BeforeAfterExecutor* is the ability to perform an action before executing the task list and another action after executing the task list. The constructor looks like this:
public BeforeAfterExecutor(Action beforeExecute, Action afterExecute, IExecutor executor = null)
What is it used for? The fiber and the executor have the same owner. When creating an executor, two actions are passed to it. The first one adds key/value pairs to the thread context, and the second one removes them, thereby performing the cleaner function. The pairs added to the thread context are added by the logging system to the messages and we can see some meta data of the object that left the message.
Example:
`var beforeAction = ()=>`
`{`
`log4net.ThreadContext.Properties["Meta1"] = "value";`
`};`
`var afterAction = () => ThreadContext.Properties.Clear();`
`//we create an executor`
`var e = new BeforeAfterExecutor(beforeAction, afterAction);`
`//we create PoolFiber`
`var fiber = new PoolFiber(e);`
Now, if something is logged from a task that runs in *fiber*, log4net will add the *Meta1* tag with the value *value*.
**ExtendedPoolFiber and ExtendedFailSafeExecutor**
There is another thing that was not in the original version of *retlang*, and that we developed later. This was preceded by the following story**:**There is *PoolFiber* (this is the one that runs on top of the .NET thread pool). In the task that this fiber executes, we needed to execute a HTTP request synchronously.
We did it in a simple way like this:
1. before executing the request, we create *sync event*;
2. the task that executes the request is sent to another fiber, and, upon completion, puts *sync event* in the signaled stage;
3.after that, we start to wait for *sync event*.
It was not the best solution in terms of scalability and began to give an unexpected failure. It turned out that the task that we put in another fiber in step two falls into the queue of the very thread that started to wait for *sync event*. Thus, we get a deadlock. Not always. But often enough to worry about it.
The solution was implemented in *ExtendedPoolFiber* and *ExtendedFailSafeExecutor*. We came up with the idea of putting the entire fiber on pause. In this state, it can accumulate new tasks in the queue, but does not execute them. In order to pause the fiber, the *Pause* method is called. As soon as it is called, the fiber (namely, the fiber executor) waits until the current task is completed and freezes. All other tasks will wait for the first of the two events:
1. Call of method *Resume*
2. Timeout (specified when calling the Pause method). In the *Resume* method, you can also set a task that will be executed before all the queued tasks.
We use this trick when the plugin needs to load the room state using an HTTP request. In order for players to see the updated state of the room immediately, the room's fiber is paused. When calling the *Resume* method, we pass it a task that applies the loaded state and all other tasks are already working with the updated state..
By the way, the need to put the fiber *on pause completely killed the ability to use \_ThreadFiber* for the task queue of game rooms.
**IFiberAction**
*IFiberAction* is an experiment to reduce the load on the GC. We can't control the process of creating actions in .NET. Therefore, it was decided to replace the standard actions with instances of the class that implements the *IFiberAction* interface. It is assumed that instances of such classes are taken from the object pool and returned there immediately after completion. This reduces the load on the GC.
The *IFiberAction* interface looks like this:
`public interface IFiberAction`
`{`
`void Execute()`
`void Return()`
`}`
The *Execute* method contains exactly what needs to be executed. The *Return* method is called after *Execute* when it is time to return the object to the pool.
Example:
`public class PeerHandleRequestAction : IFiberAction`
`{`
`public static readonly ObjectPool Pool = initialization;`
`public OperationRequest Request {get; set;}`
`public PhotonPeer Peer {get; set;}`
`public void Execute()`
`{`
`this.Peer.HandleRequest(this.Request);`
`}`
`public void Return()`
`{`
`this.Peer = null;`
`this.Request = null;`
`Pool.Return(this);`
`}`
`}`
`//now we use it next way`
`var action = PeerHandleRequestAction.Pool.Get();`
`action.Peer = peer;`
`action.Request = request;`
`peer.Fiber.Enqueue(action);`
#### Conclusion
In conclusion, I will briefly summarize: To ensure thread-safety in *Photon*, we use task queues, which in our case are represented by fibers. The main type of fiber that we use is *PoolFiber* and classes that extend it. *PoolFiber* implements a task queue on top of the standard .NET thread pool. Due to the small performance footprintof *PoolFiber*, everyone who needs it can have their own fiber. If you need to pause the task queue, use *ExtendedPoolFiber*.
The executors that implement the *IExecutor* interface directly perform tasks in fibers. *DefaultExecutor* is good for everyone, but in case of an exception, it loses the entire remainder of the tasks that were passed to it for execution. *FailSafeExecutor* **seems like a reasonable choice in this regard**. If you need to perform some action before the executor executes a batch of tasks and after it, *BeforeAfterExecutor can be useful* | https://habr.com/ru/post/559314/ | null | en | null |
# Персональные предложения для клиента – интеграция с платформой лояльности и начисление повышенных баллов
Рассмотрим взаимодействие с компанией SweetCard, которая представляет достаточно удобную платформу таргетированных предложений держателям карт. В «МКБ Онлайн» это раздел «Персональные предложения».
Данная статья не преследует цели раскрыть все нюансы технического взаимодействия систем (это обусловлено политикой безопасности банка – по запрету предоставления программного кода в открытых источниках), а носит ознакомительный характер общих принципов взаимодействия со сторонними организациями и между подразделениями, у которых может быть своя среда разработки.
Проект стартовал в июне 2018 года – и на тот момент еще слабо представлялось, какое дальнейшее развитие он может получить.
Было запланировано взаимодействие с ритейлерами, список которых предоставляется в формате JSON со стороны компании-посредника – SweetСard. Единый формат позволяет подключать большое количество ритейлеров по унифицированному способу взаимодействия. Доходы обеих сторон – банка и ритейлеров – зависят от транзакционной активности клиентов. При этом промоматериалы размещаются на стороне банка (в данном случае в интерфейсе «МКБ Онлайн» «Персональные предложения»), а ритейлеры делятся частью прибыли от привлечения новых клиентов.
Обезличенные данные по транзакционной активности в банке поступают в виде текстовых файлов на sftp-сервер по защищенному каналу в установленном формате обмена. Далее платформа SweetCard обрабатывает полученные данные по транзакциям, сохраняет у себя в базе, и раз в месяц производится расчет суммы кешбэка для каждого счета клиента. После того как расчет произведен, SweetCard возвращает реестр со списком уникальных идентификаторов карты и суммой кешбэка – согласно условиям акции. После того как на стороне АБС банка появляется платежный документ на сумму, которая совпадает с суммой реестра, производится автоматизированное начисление кешбэка в рублях на карточный счет клиента.
Формат JSON выбран не случайно – он имеет более компактный код и, следовательно, меньший размер файлов для передачи по sftp-каналу – если сравнивать с XML. Обмен осуществляется большими объемами данных (более чем 5 млн записей), т. к. для каждого клиента свои, уникальные акции с учетом его возраста, пола, покупок на основе предыдущих транзакций. Также формат JSON позволяет реализовать более гибкое взаимодействие с веб-сервисами банка. В файлах с предлагаемыми акциями со стороны ритейлеров также учтен не только тип файла и процентная ставка кешбэка, но и детально прописаны почтовые адреса, мерчанты и терминалы, в которых действует та или иная акция.
Пример файла акций со стороны SweetCard за прошлый год. Файлы фотографий для оформления акции в интерфейсе для мобильного приложения предоставляются со стороны ритейлера (сохраняются банком на сетевом ресурсе с ограниченным доступом).
```
{
"id": 31610,
"title": "Телега",
"value": 10,
"start": "2019-05-01",
"stop": "2019-05-31",
"www": "",
"activationRequired": false,
"shortdesc": "Кафе домашней кухни",
"description": "10% на все покупки",
"conditions": "",
"fullDescription": "«Телега» — кафе домашней кухни, ориентированное на здоровый образ жизни. Свежие и вкусные блюда русской, европейской, узбекской, грузинской кухни, приготовленные исключительно из натуральных продуктов. Быстрое обслуживание и уютная атмосфера никого не оставят равнодушными. Также вы можете выбрать бизнес-ланч из отдельного меню.",
"geo": [
{
"id": 329697970,
"title": "Москва, Автозаводская ул., 18, этаж 3",
"lat": 55.704687,
"lon": 37.638143,
"address": "Москва, Автозаводская ул., 18, этаж 3\r\n"
}
],
"period": "с 1 мая по 31 мая",
"daysToExp": 36,
"category": {
"id": 3,
"title": "Кафе и рестораны"
},
"type": "на все покупки",
"techType": "ALL_PURCHASE_DISCOUNT",
"image": "31610_i.jpeg",
"smImage": "31610_sm_i.jpeg",
"logo": "31610_l.png",
"smLogo": "31610_sm_l.png"
},
...
```
Можно также отметить, что формат JSON вполне читаемый даже для человека, который далек от разработки. Т. е. в случае необходимости даже контент-менеджер способен редактировать текст акции (если вдруг ритейлер изменил условия в последний момент или отказался от акции) в исходном файле, не прибегая к полной выгрузке программными средствами всех акций или полного объема предложений для клиентов. JSON-файл обрабатывается последовательно, что позволяет даже в случае ошибки в исходных данных сохранить ранее обработанные строки, потеряв данные только проблемной строки. Эта его особенность позволяет сэкономить время, что особенно важно при работе с большими объемами данных и необходимостью быстро предоставить клиентам оперативные данные по акциям.
После того как файл передан посредством sftp-канала в сетевое хранилище банка, запускается робот обработки файлов. Содержимое файла загружается в CLOB-поле в темповой таблице в базе Oracle – реализовано посредством использования хранимых процедур Java в Oracle на языке PL/SQL. Полученный список файлов обрабатывается посредством функционала стандартного пакета dbms\_lob. Не буду описывать последовательные вызовы, т. к. информации по этой теме более чем достаточно на просторах Рунета. Далее производится парсинг полученного CLOB-формата согласно формату, оговоренному банком и платформой SweetCard. Полученные данные в таблицах Oracle доступны для чтения посредством хранимых процедур – для функционала других систем банка, т. е. формирования справочников для ведения статистики через интерфейс – для сотрудников бэк-офиса и, соответственно, для вывода в интерфейс для клиентов.
Ниже приведен скриншот из мобильного приложения банка.
Ритейлер заинтересован в том, чтобы клиент знал об участии в акции и осознанно совершил ту или иную покупку, а не случайно «попал под акцию», поэтому в 2021 году в дополнение к имеющемуся и работающему с 2018 года коду был добавлен функционал активирования той или иной акции в интерфейсе. Конечно, это вызывает дополнительные действия со стороны клиентов, но это вынужденная необходимость. Также это помогает избежать вопросов в службу поддержки банка, что за суммы поступили на счет клиента.
С октября 2021 года с начислений в рублях на карточный счет клиента планируется перейти на баллы банка. На первый взгляд может показаться, что это несет неудобства клиенту, т. к. деньги на его счету не требуют каких-то дополнительных действий, т. е. получается живой кешбэк – клиент оплатил покупку рублями (валютных выплат не предусмотрено в рамках акции «Персональные предложения») – в рублях же получил кешбэк. Но это только на первый взгляд. В рамках программ лояльности для любых покупок клиента действует программа лояльности «МКБ Бонус». Т. к. повышенный кешбэк для программы лояльности обычно составляет 5%, а кешбэк для остальных операций 1%, то у клиента, который недостаточно активно пользуется картой, не всегда получается быстро накопить баллы для компенсации (необходимая сумма должна быть более 1000 баллов). Теперь же, когда программа «Персональные предложения» также переходит на баллы, сумма 1000 баллов может быть накоплена гораздо быстрее, поскольку в персональных предложениях бывает до 30% (!) кешбэка от ритейлеров. Соответственно, поучаствовав в акции из «Персональных предложений», клиент может увеличить свой доход, т. к. выведет из «МКБ Бонус» все баллы, которые раньше могли бы быть потеряны (сгорали с течением времени), если клиент забыл о них. По факту клиент ничего не теряет с переходом на баллы, т. к. 1 балл равен 1 рублю. Вот такие изменения были предусмотрены технически, т. е. даже в них есть забота о клиенте, который будет более эффективно участвовать в акциях банка.
Соответственно, если по каким-то причинам клиент (отключена бонусная программа, например) не может получать баллы, в «МКБ Бонус» производится возврат на счет SweetCard в рублях. Конечно же, это указано в условиях акции – и информационные баннеры в приложении напомнят, как получить максимально выгодные предложения от партнеров банка.
Казалось бы, очень хорошая программа – с большим количеством ритейлеров – предоставляется благодаря использованию платформы SweetCard. Но банк шагнул дальше: теперь у клиентов МКБ появились новые акции – больший список, чем был ранее, до 2021 года. А связано это с тем, что у банка есть своя платформа лояльности, которая предоставляет доступ к ритейлерам, которых не было у SweetCard. Т. е. заключаются отдельные договоры с ритейлерами напрямую, на очень выгодных условиях для клиентов, т. к. нет выплат посредникам. Среди партнеров банка развлекательные площадки, компании, предоставляющие медицинские услуги, турфирмы, распространенные сетевые магазины и многое другое. Разработчиками МКБ был реализован свой механизм взаимодействия с ритейлерами посредством интеграционной шины. Ритейлеры могут использовать платформу лояльности для внесения информации по акциям. В текущей версии приложения «МКБ Онлайн» многие пользователи уже оценили новые акции от платформы лояльности МКБ. Статистика переходов, кликов по рекламным баннерам свидетельствует об этом. Немаловажным является то, что в интерфейсе акции от платформы лояльности банка и от ритейлеров SweetCard для клиентов выглядят идентично, т. к. способ взаимодействия партнеров с банком – это избыточная информация для них. Статистика участия в акции и все действия клиентов сохраняются посредством иерархического логирования в хранилище данных на основе платформы Oracle. Реализован комплекс хранимых процедур для подробного журнализирования действий клиента. Т. е. если клиент обратится с вопросом, за что был начислен тот или иной кешбэк, то банк сможет предоставить информацию за все время существования проекта (более 3 лет). Но это уже тема для отдельной статьи.
Для пользователей Private Bank, которые, конечно же, ценят свое время, реализован специальный интерфейс, в котором отображаются только самые интересные и выгодные предложения с повышенным кешбэком. Эту доработку разработчики банка реализовали не так давно, но по статистике переходов можно видеть, что она помогла увеличить процент участников акции «Персональные предложения» именно со стороны vip-клиентов.
Следите за новостями банка, не забывайте вовремя обновлять приложение «МКБ Онлайн». Вас ждет еще много интересных акций с повышенным кешбэком и специальные предложения по бонусам. | https://habr.com/ru/post/582128/ | null | ru | null |
# Кофе с огурцами (Espresso + Cucumber)
Относительно не так давно появилась замечательная библиотека Espresso для тестирования UI Android приложений. Её преимущества над аналогами обозревались не один раз. Если вкратце, то они заключаются в том, что это разработка Google для собственной ОС (ранее они сами использовали Robotium), а так же в лаконичности синтаксиса и скорости работы. Итак, мы решили идти в ногу со временем и использовать Espresso. Но нам мало тех плюсов, что уже есть, мы хотим BDD (<http://en.wikipedia.org/wiki/Behavior-driven_development>), мы хотим скриншотов и отчетов в json и html, мы хотим запускать это все на CI, в конце концов! Но обо всем по порядку. Я расскажу как подружить Cucumber (<http://habrahabr.ru/post/62958/>) и Espresso (<http://habrahabr.ru/post/212425/>) на небольшом примере. Всех, кто устал от Appium, кто хочет уйти от Robotium и тех, кому небезразлично тестирование Android, прошу под кат.
**Подключение**
Мы будем использовать Gradle как средство сборки и разрешения зависимостей для нашего проекта. Очень рекомендую для тех, кто еще не видел, сайт <http://gradleplease.appspot.com/>. Сообщаем ему имя искомого модуля, а он возвращает строку для подключения ее в Gradle.
Создадим проект и подключим к нему Espresso и необходимые для нашей задачи модули Cucumber, для этого дополняем блок dependency, файла build.gradle следующим образом:
```
dependencies {
androidTestCompile('com.jakewharton.espresso:espresso-support-v4:1.1-r3')
androidTestCompile 'info.cukes:cucumber-core:1.1.8'
androidTestCompile 'info.cukes:cucumber-java:1.1.8'
androidTestCompile 'info.cukes:cucumber-html:0.2.3'
androidTestCompile ('info.cukes:cucumber-android:1.2.2')
androidTestCompile ('info.cukes:cucumber-junit:1.1.8')
{
exclude group: 'org.hamcrest', module: 'hamcrest-core'
exclude group: 'org.hamcrest', module: 'hamcrest-integration'
exclude group: 'org.hamcrest', module: 'hamcrest-library'
}
}
```
Для того, чтобы мы могли использовать средства Espresso, нам необходимо, чтобы тесты запускались через GoogleInstrumentationTestRunner. Значит для подключения Cucumber нужно наследоваться от этого класса, внутри которого мы передадим ему все управление.
```
public class CucuRunner extends GoogleInstrumentationTestRunner{
private CucumberInstrumentationCore helper;
public CucuRunner() {
helper = new CucumberInstrumentationCore(this);
}
@Override
public void onCreate(Bundle arguments) {
helper.create(arguments);
super.onCreate(arguments);
}
@Override
public void onStart() {
helper.start();
}
}
```
Не забываем указать наш свежесозданный instrumentation test runner в build.gradle
```
defaultConfig {
...
testInstrumentationRunner 'habrahabr.ru.myapplication.test.CucuRunner'
...
}
```
**Шаги (Steps)**
Теперь нам необходимо создать шаги, которые будут использоваться в наших тестовых сценариях. В нашем случае ими будут небольшие тесты, объединенные в один кейс. Для этого создаем соответствующий класс, который наследуем от стандартного для Espresso набора тестов, дабы иметь доступ ко всем необходимым вещам. Добавляем к этому классу аннотацию, где указываем, что это тесты Cucumber, а результат их работы следует поместить в отчеты соответствующих форматов, в нужные нам директории. Обратите внимание, Espresso-тесты исполняются на устройстве, и поэтому доступа к директориям компьютера у нас нет. Значит складываем все в директорию нашего приложения:
```
@CucumberOptions(format = {"pretty","html:/data/data/habrahabr.ru.myapplication/html", "json:/data/data/habrahabr.ru.myapplication/jreport"},features = "features")
public class CucumberActivitySteps extends ActivityInstrumentationTestCase2 {
```
Теперь можем заняться непосредственно реализацией шагов. Для этого необходимо разделить методы по их назначению в соответствии с BDD, то есть на Given, When и Then. Для этого используются аннотации, содержащие строку для нахождения соответствий в файле сценария на основе регулярных выражений, группы в которых играют роль входных аргументов, а в теле самих шагов мы будем использовать вызовы Espresso:
```
@Given("^Счетчик попыток входа показывает (\\d)$")
public void givenLoginTryCounter(Integer counterValue) {
String checkString = String.format(getActivity().getResources().getString(R.string.login_try_left), counterValue);
onView(withId(R.id.lblCounter)).check(matches(withText(checkString)));
}
@When("^Пользователь нажимает кнопку назад$")
public void clickOnBackButton() {
ViewActions.pressBack();
}
@When("^Пользователь '(.+)' авторизуется в системе с паролем '(.+)'$")
public void userLogin(String login, String password) {
onView(withId(R.id.txtUsername)).perform(ViewActions.clearText());
onView(withId(R.id.txtPassword)).perform(ViewActions.clearText());
onView(withId(R.id.txtUsername)).perform(ViewActions.typeText(login));
onView(withId(R.id.txtPassword)).perform(ViewActions.typeText(password));
onView(withId(R.id.btnLogin)).perform(ViewActions.click());
}
@Then("^Счетчик попыток входа должен показывать (\\d)$")
public void checkLoginTryCounter(Integer counterValue) {
givenLoginTryCounter(counterValue);
}
@Then("^Кнопка входа стала неактивной$")
public void checkLoginButtonDisabled() {
onView(withId(R.id.btnLogin)).check(matches(not(isEnabled())));
}
```
**Скриншоты**
В случае неудачного завершения последнего шага мы будем снимать скриншот и добавлять полученное изображение к отчету. Все остальное за нас сделает Cucumber, и мы сможем увидеть состояние экрана в момент ошибки. Приведенный далее способ не подходит, например, для снятия снимка с диалогом, но это тема для отдельного разговора.
```
@After
public void embedScreenshot(Scenario scenario) {
if(scenario.isFailed()) {
Bitmap bitmap;
final Activity activity = getActivity();
View view = getActivity().getWindow().getDecorView();
view.setDrawingCacheEnabled(true);
bitmap = Bitmap.createBitmap(view.getDrawingCache());
view.setDrawingCacheEnabled(false);
ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream);
scenario.embed(stream.toByteArray(), "image/png");
}
}
```
**Сценарии**
Осталась самая приятная часть. Имея в руках шаги, описанные в CucumberActivitySteps, мы можем написать сами тесты на человеческом языке, который будет доступен не только разработчикам, но и всем другим заинтересованным лицам:
```
Feature: Авторизация
Scenario: Пользователь пытается авторизоваться, используя неверные логин и пароль
Given Счетчик попыток входа показывает 3
When Пользователь 'RandomName' авторизуется в системе с паролем 'wrongPassword'
Then Счетчик попыток входа должен показывать 2
And Появилось сообщение 'Неверное имя пользователя или пароль.'
```
Эти сценарии мы сохраняем в директорию features, в которой наш исполняющий класс будет их искать (см. аннотацию CucumberOptions).
**Изъятие отчетов с устройства**
Если мы запустим тесты, они пройдут, но отчеты останутся лежать на устройстве. Значит по завершению тестирования их необходимо оттуда забрать. Идем в файл build.gradle и пишем соответствующий task, который посредством утилиты adb и команды pull скопирует файлы отчетов в заданную директорию.
```
task afterTests(type: Exec, dependsOn:runCucuTests) {
commandLine "${android.sdkDirectory}" + "/platform-tools/adb", 'pull', '/data/data/habrahabr.ru.myapplication/html', System.getProperty("user.dir") + "/cucumber_reports"
}
```
Теперь можно все запустить через IDE, нужно лишь создать соответствующую конфигурацию запуска, а после завершения тестов исполнить наш task для изъятия отчетов.
Отчеты же будут сохранены в указанную выше директорию
**Запуск на CI**
Но мы не хотим запускать тесты через IDE, мы хотим запускать их из консоли, а connectedCheck нам не подходит. Значит пишем новый task. И здесь мы, к сожалению, не придумали ничего лучше, чем собирать приложение и устанавливать его на устройство, после чего отсылать команду на старт тестирования через adb. А после всего этого забирать отчеты описанным выше task'ом.
```
task runCucuTests(type: Exec, dependsOn:'installDebugTest'){
commandLine "${android.sdkDirectory}" + "/platform-tools/adb", 'shell', 'am', 'instrument', '-w', 'habrahabr.ru.myapplication.test/.CucuRunner', 'echo', 'off'
finalizedBy('afterTests')
}
```
В принципе этого уже достаточно, чтобы запустить тесты на CI.
На выходе мы получим вот такие отчеты:
И к каждому сценарию, который завершился неудачно, у нас будет приложен скриншот:
На этом, пожалуй, и остановимся. Здесь многое еще хочется улучшить, например, получить нормальный output в консоль во время выполнения тестов, содержащий информацию о прогрессе, хочется сделать файл с отчетами красивым и многое другое. Надеюсь будет еще такая возможность. Для всех заинтересованных сам проект выложен на Github: <https://github.com/Stabilitron/espresso-cucumber-example>
Спасибо за внимание. Стабильных вам релизов! | https://habr.com/ru/post/255763/ | null | ru | null |
# Как Android запускает MainActivity
Недавно я провел исследование о main() методе в Java и то, как он служит точкой входа для любого приложения Java. Это заставило меня задуматься, а как насчет Android-приложений? Есть ли у них основной метод? Как они загружаются? Что происходит за кулисами до выполнения onCreate()? Майкл Бэйли очень [подробно рассказал](https://www.youtube.com/watch?v=aFGbv9Ih9qQ) о том, как работает Main Thread, так что это быстрый обзор его доклада плюс дополнительная информация из Android Open Source Project (AOSP).
**В этой статье мы рассмотрим:**
1. Что происходит от нажатия на иконку приложения до запуска MainActivity
2. Найдем основной метод приложения и узнаем, как основной поток (он же UI, он же Main Thread) получает свое назначение.
3. Рассмотрим роль, которую играют Looper & Handler в передаче сообщений, которые в конечном итоге приводят к созданию вашей Activity.
### Что происходит при запуске приложения
При запуске любого приложения, многое происходит глубоко внутри на уровне ядра, например начальная загрузка Zygote, загрузка классов в JVM, а для JVM — найти основной метод static void main(String args []) и вызывать его. В случае Android JVM находит основной метод main() в ActivityThread. Затем он вызывает main(), после чего ядро передает управление вашему приложению. Итак, мы нашли точку входа — ActivityThread, но прежде чем подробно изучить это, давайте посмотрим на дорожную карту процесса, чтобы визуализировать всю операцию.
1 Схема запуска приложения
--------------------------
Между вызовом метода main() и onCreate() в нашем MainActivity примерно 15 шагов, и в этой статье мы пройдем по ним. На рисунке 1 изображена общая схема запуска приложения, показывающая различные классы взаимодействия сверху и соответствующую цепочку методов. Шаги пронумерованы, и когда я обращаюсь к ним, я буду использовать следующие обозначения Process3 или Process14
***Рисунок 1: Схема запуска приложения по шагам от вызова main() до onCreate() в MainActivity***
2. Класс ActivityThread
-----------------------
В классе ActivityThread чуть более 6500 строк. Для краткости я определил самые важные для нас части. Давайте рассмотрим, что делает этот класс и связанный с ним основной метод, чтобы запустить нашу Activity
```
/**
* Code retrieved from https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/app/ActivityThread.java
* Modifications are indicated in the comments
*/
public static void main(String[] args) {
//Modification - Removed unrelated initializers.
//Android initializes some tracers, event loggers, enviroment initializers, trusted certificates and updates the process' state
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
// More logging
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
```
***Рисунок 2: Метод main() в ActivityThread, который служит точкой входа для запуска вашего приложения.***
**Как видно в коде: метод main() выполняет три важных дела:**
1. Подготавливает основной Looper (MainLooper) (Process 2)
2. Настройка Handler'a (Process 4)
3. Вызов метода Looper.loop() в главном потоке (MainThread) (Process 6)
#### 2.1 Подготовка main looper (Process 2–3)
Основной Looper задается вызовом Looper.prepareMainLooper() (см. Строку 8 в коде). Это отмечает текущий случайный поток, который выполняет всю работу по вызову метода main() в качестве основного потока приложений. Именно так и именно здесь определяется знаменитый главный поток для приложения в Android!
#### 2.2 Вызов Handler'a (Process 4-5)
Внутри класса ActivityThread существует приватный внутренний класс H, да-да, все верно, просто H, который наследуется от класса Handler (см. рис. 4 и 7). В 12й строке экземпляр H-обработчика устанавливается как главный Handler потока. Что очень интересно знать о классе H, как вы сами увидите позже, это то, что он содержит более 50 определений состояния/событий, в которых может находиться ваше приложение, например LAUNCH\_ACTIVITY, PAUSE\_ACTIVITY, BIND\_SERVICE и т.д.
#### 2.3 Вызов метод loop() у Looper’а (Process 6–7)
После назначения главного потока в этом же главном потоке, для того чтоб мы могли в нем что-то выполнять, вызывается метод Looper.loop() (см. Строку 20). Это начинает выполнение сообщений в очереди сообщений Loopers. Теперь главный поток запущен и может начать обработку задач из очереди.
Обратите внимание, что в строке 18, если выполнение кода пойдет дальше чем Looper.loop() в 17 строке вдруг и приложение выйдет из цикла, то будет брошено исключение RuntimeException. Это говорит о том, что метод loop() в идеале никогда преждевременно не заканчивается. Мы увидим как это в следущем разделе.
3. Бесконечный loop() в Looper'е (Process 7,8,9)
------------------------------------------------
```
/**
* AOSP
* Looper class
*/
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
//code removed
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
}
}
```
***Рисунок 3: Код внутри метода loop() в классе Looper'e***
Как мы видим в коде, в методе Looper.loop() есть очередь сообщений (строка 10) и внутри цикла вызывается queue.next(). MessageQueue заполняется Handler-'ом, о котором мы говорили в предыдущем разделе (см. Process 8). Обратите внимание на интересное описание условия в цикле for — здесь нет аргументов, только две точки с запятой говорят что это бесконечный цикл. Поэтому Looper в идеале никогда не заканчивается, если данное сообщение не null.
Итак, теперь мы определили главный поток, выполняемый благодаря Looper, мы также видели, что Handler добавляет сообщения в цикл Looper.loops() и обрабатывает сообщения. Давайте посмотрим, как они вместе вызывают нашу Activity.
4. Запуск MainActivity (Process 10 to 15)
-----------------------------------------
Важно помнить, что этот бесконечный цикл и обработка сообщений выполнялись в main() методе класса ActivityThread, потому что именно там они были вызваны (см. в коде строки с 12 по 17). Мы поверхностно просмотрели Loopers, MessageQueues и Handlers, чтобы вникнуть в контекст. Итак, давайте вернемся к классу ActivityThread, в частности, к внутреннему классу H, о котором мы говорили ранее, который действует как основной Handler главного потока.
Итак, у нас есть Looper, передающий сообщения нашему Handler'у, давайте узнаем, как эти сообщения обрабатываются. Это делается внутри класса H. Этот класс содержит метод handleMessage(Message msg). Помните, что все классы, которые наследуются от Handler, должны переопределить этот метод.
```
/**
* Retrieved from AOSP
* H class embedded in the ActivityThread class
*/
private class H extends Handler {
//Several Application State Identifiers ...
public void handleMessage(Message msg) {
//other code
switch (msg.what) {
case LAUNCH_ACTIVITY: {
//create Activity records
handleLaunchActivity(r, null, "LAUNCH_ACTIVITY");
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
...
//handle other cases e.g ResumeActivity, PauseActivity, BindService, UnbindService etc.
}
}
}
}
```
***Рисунок 4: Приватный внутренний класс H и его handleMessage() метод***
Как видно в коде, в 8й строке есть оператор switch, в котором определяется обработка входящего сообщения по его содержимому.
Один из случаев (cases) включает в себя запуск активности (строка 11), что интересно, так это то, что этот метод предназначен для обработки около 50 случаев, которые варьируются от возобновления, приостановки, запуска Activity, привязки Service'ов, обработки Receiver'ов, предоставления предупреждений lowMemory или trimMemory, когда память устройства заполняется и т. д.
В case LAUNCH\_ACTIVITY вызывается метод handleLaunchActivity(), как показано в строке 13, см Process11 на схеме. Затем этот метод вызывает другой метод, называемый performLaunchActivity(), который возвращает объект Activity (см. Рис. 5, строка 7).
```
/**
* Retrieved from AOSP.
* ActivityThread class
*/
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
//... initialize graphics,do some logging, call GC if need be, etc
Activity a = performLaunchActivity(r, customIntent);
//... handle how to resume an existing activity
}
```
***Рисунок 5: Метод handleLaunchActivity() в котором создается Activity***
Метод performLaunchActivity() добавляет в Activity важную информацию, такую как Instrumentation, Context, Component, а также Intent; а также задает Application. Затем этот метод вызывает Instrumentation.callActivityOnCreate() (Process 13), который является последним этапом перед вызовом метода onCreate() в Activity (Process 14-15, см. Рисунок 5 (код), строки 8-10).
```
/**
* @Retrieved from AOSP
* Instrumentation class
*/
public void callActivityOnCreate(Activity activity, Bundle icicle) {
// Заметьте что Activity уже создана в prepareLaunchActivity().
// все что нужно жто вызвать onCreate()
prePerformCreate(activity); // подготовка Activity
activity.performCreate(icicle); // вызов onCreate()
postPerformCreate(activity);
}
```
***Рисунок 6: Класс Instrumentation наконец запускает Activity***
На данный момент ваша Activity загружена c множеством полезных переменных и методов, которые можно использовать для создания вашего нового удивительного приложения для Android! Все это благодаря ActivityThread, умной работе Handler'a и Looper'a, и огромному классу Activity в 7600 строк кода, который позволяет аттачить фрагменты, получить контекст и легко управлять View's — и много еще чего.
Примерно так наша Activity и создается!
Оригинал статьи [здесь](https://medium.com/@martinomburajr/android-internals-1-how-android-starts-your-main-activity-8fcf80e65222). | https://habr.com/ru/post/345120/ | null | ru | null |
# Telegram-бот для управления инфраструктурой
По мотивам статьи [Телеграмм-бот для системного администратора](https://habr.com/ru/post/317906/) (статья не моя, я только прочитал) захотел поделиться опытом создания Telegram-бота на PowerShell для управления серверами приложений. Будет текст, код и немножко картинок. Конструктивная критика приветствуется ( главное чтобы не звучало «зачем на PowerShell? Надо было на perl» ).
Думаю что статья больше подойдет «новичкам» в PowerShell, но и опытные администраторы могут что-то полезное здесь увидеть.
Саму статью старался построить по частям – от простого к сложному. Возможно, встретится плагиат, будьте бдительны!
Итак, у нас есть необходимость осуществлять управление сервисами или приложениями на нескольких серверах (останавливать, запускать), перезагружать сервера, смотреть логи и еще какую-то информацию при необходимости. Всё это хочется делать (на самом деле нет), находясь в метро, в магазине или даже лёжа на диване, без VPN и ноутбуков. Из требований (которые были написаны, конечно, на коленке).
* Простота добавления/изменения задач в Telegram-бот
* Многозадачность или параллелизация
* «Понятный» интерфейс управления
* Хоть какая-то безопасность
В какой то момент было решено выносить конфиг в отдельный файл – в нашем случае xml (тут кто-то может сказать, что давайте всё в json, но мы сделали в xml и были довольны)
Начнем с начала:
### Часть 1: простой телеграм-бот
Ищем папку-бота (не каталог) – *BotFather (@BotFather)* в Telegram
Пишем [/newbot](https://core.telegram.org/bots#creating-a-new-bot)
Далее, нужно придумать имя боту (в моем случае я назвал Haaaabr специально для статьи) и username, который должен заканчиваться на «bot» (Haaaabr\_bot)
После этого BotFather выдаст токен, который мы и будем использовать:
Дальше можно загрузить для бота картинку, поставить Description, создать список команд, но мне было лень.
Делаем простого бота, который будет принимать сообщения и отвечать на них.
Я буду писать код PS частями и периодически вставлять full-код для референса.
Для справки нам понадобятся описания вызовов API [Telegram Bot API](https://core.telegram.org/bots/api)
Нам будет нужно 2 метода:
*getUpdates* – получение ботом(скриптом) сообщений
*sendMessage* – отправка сообщений ботом(скриптом) пользователю
Там же, видим, что:
> Making requests
>
> All queries to the Telegram Bot API must be served over HTTPS and need to be presented in this form: [api.telegram.org/bot/METHOD\_NAME](https://api.telegram.org/bot<token>/METHOD_NAME)
Шаг 1 – прием сообщений
Переменные
```
# Token
$token = "***********************"
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
```
Теперь будем проверять, что отдает вызов *$URL\_get*
```
Invoke-RestMethod -Uri $URL_get
```
`ok result
-- ------
True {}`
Нот бэд. Напишем что-нибудь боту:
И прочитаем:
```
# Token
$token = "***********************"
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
Invoke-RestMethod -Uri $URL_get
```
`ok result
-- ------
True {@{update_id=635172027; message=}, @{update_id=635172028; message=}`}
Очевидно, что нам нужен result. Сразу скажу, что нас интересует только последнее сообщение от пользователя, поэтому так:
```
# Token
$token = "***********************"
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
$json = Invoke-RestMethod -Uri $URL_get
$data = $json.result | Select-Object -Last 1
$data.update_id
$data.message.chat.id
$data.message.text
$data.message.chat.first_name
$data.message.chat.last_name
$data.message.chat.type
$data.message.chat.username
```
Теперь нужно сделать confirm, что мы получили сообщение. Делается это все также, через метод *getUpdates* с параметром *offset*:
> By default, updates starting with the earliest unconfirmed update are returned. An update is considered confirmed as soon as getUpdates is called with an offset higher than its update\_id
Делаем
```
Invoke-RestMethod "$($URL_get)?offset=$($($data.update_id)+1)" -Method Get | Out-Null
```
И кидаем это все в цикл c таймаутом в 1 секунду:
```
# Token
$token = "***********************"
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
# timeout sec
$timeout = 1
while($true) # вечный цикл
{
$json = Invoke-RestMethod -Uri $URL_get
$data = $json.result | Select-Object -Last 1
$data.update_id
$data.message.chat.id
$data.message.text
$data.message.chat.first_name
$data.message.chat.last_name
$data.message.chat.type
$data.message.chat.username
Invoke-RestMethod "$($URL_get)?offset=$($($data.update_id)+1)" -Method Get | Out-Null
Start-Sleep -s $timeout
}
```
Теперь сделаем из этого функцию чтения сообщений. Т.к. нам нужно возвращать несколько значений из функции – решили использовать HashTable (именованный/ассоциативный массив)
**Скрипт получения сообщений**
```
# Token
$token = "***********************"# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
# timeout sec
$timeout = 1
function getUpdates($URL)
{
$json = Invoke-RestMethod -Uri $URL
$data = $json.result | Select-Object -Last 1
#$data.update_id
$chat_id = $data.message.chat.id
$text = $data.message.text
$f_name = $data.message.chat.first_name
$l_name = $data.message.chat.last_name
$type = $data.message.chat.type
$username = $data.message.chat.username
# проверяем что text есть
if($text)
{
# confirm
Invoke-RestMethod "$($URL)?offset=$($($data.update_id)+1)" -Method Get | Out-Null
# HashTable
$ht = @{}
$ht["chat_id"] = $chat_id
$ht["text"] = $text
$ht["f_name"] = $f_name
$ht["l_name"] = $l_name
$ht["username"] = $username
return $ht
}
}
while($true) # вечный цикл
{
# вызываем функцию
getUpdates $URL_get
Start-Sleep -s $timeout
}
```
Шаг 2 – отправка данных
Для отправки сообщения нам нужен метод *sendMessage* и поля *chat\_id* и *text* (остальные опционально <https://core.telegram.org/bots/api#sendmessage>).
Сразу запилим функцию
```
function sendMessage($URL, $chat_id, $text)
{
# создаем HashTable, можно объявлять ее и таким способом
$ht = @{
text = $text
# указан способ разметки Markdown
parse_mode = "Markdown"
chat_id = $chat_id
}
# Данные нужно отправлять в формате json
$json = $ht | ConvertTo-Json
# Делаем через Invoke-RestMethod, но никто не запрещает сделать и через Invoke-WebRequest
# Method Post - т.к. отправляем данные, по умолчанию Get
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json
}
```
Теперь, вызвав
```
sendMessage $URL_set <ваш_телеграм_id> "Тест123"
```
получим сообщение в телеге.
Шаг 3 – собираем все вместе
Ниже весь код для отправки-получения сообщений
**Показать код**
```
# Token
$token = "***********************"
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
# timeout sec
$timeout = 1
function getUpdates($URL)
{
$json = Invoke-RestMethod -Uri $URL
$data = $json.result | Select-Object -Last 1
#$data.update_id
$chat_id = $data.message.chat.id
$text = $data.message.text
$f_name = $data.message.chat.first_name
$l_name = $data.message.chat.last_name
$type = $data.message.chat.type
$username = $data.message.chat.username
# проверяем что text есть
if($text)
{
# confirm
Invoke-RestMethod "$($URL)?offset=$($($data.update_id)+1)" -Method Get | Out-Null
# HashTable
$ht = @{}
$ht["chat_id"] = $chat_id
$ht["text"] = $text
$ht["f_name"] = $f_name
$ht["l_name"] = $l_name
$ht["username"] = $username
return $ht
}
}
function sendMessage($URL, $chat_id, $text)
{
# создаем HashTable, можно объявлять ее и таким способом
$ht = @{
text = $text
# указан способ разметки Markdown
parse_mode = "Markdown"
chat_id = $chat_id
}
# Данные нужно отправлять в формате json
$json = $ht | ConvertTo-Json
# Делаем через Invoke-RestMethod, но никто не запрещает сделать и через Invoke-WebRequest
# Method Post - т.к. отправляем данные, по умолчанию Get
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json | Out-Null
}
while($true) # вечный цикл
{
$return = getUpdates $URL_get
if($return)
{
# http://apps.timwhitlock.info/emoji/tables/unicode#block-1-emoticons
sendMessage $URL_set $return.chat_id (Get-Random("", "", "", ""))
}
Start-Sleep -s $timeout
}
```
Дальнейшую логику можно строить на основе *$return.text* и, например, оператора *switch*:
```
switch -Wildcard ($return["text"])
{
"*привет*" { sendMessage $URL_set $return.chat_id "Привет, $($return["f_name"])" }
"*как дела?*" { sendMessage $URL_set $return.chat_id "Хорошо" }
default {sendMessage $URL_set $return.chat_id "$(Get-Random("", "", "", ""))"}
}
```
**Emoji:**в командлете Get-Random используются emoji, в код в статье у меня их встроить не получилось, но PS понимает их нативно
### Часть 2: нужны кнопки
В телеграм боте есть опция задания списка команд (открывается вот по этому значку  )
Первоначально мы так и сделали – был набор команд, в качестве параметров передавали туда имена серверов или сервисов. Потом решили, что нужно двигаться дальше в сторону User Friendly интерфейсов и подключили функционал кнопок.
Используется вызвов *sendMessage* c параметром *reply\_markup*
Для нашего функционала мы использовали тип *InlineKeyboardMarkup*
<https://core.telegram.org/bots/api#inlinekeyboardmarkup>.
Из описания следует, что поле *inline\_keyboard*– это массив из массива кнопок
> (Array of Array of InlineKeyboardButton )
Пробуем сделать тестовую отправку кнопок
```
# Token
$token = "***********************"
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
# Используем поле callback_data чтобы знать, какую кнопку нажал пользователь
$button1 = @{ "text" = "Test1"; callback_data = "Test1_CD"}
$button2 = @{ "text" = "Test2"; callback_data = "Test2_CD"}
$keyboard = @{"inline_keyboard" = @(,@($button1, $button2))}
$ht = @{
parse_mode = "Markdown"
reply_markup = $keyboard
chat_id = ******** # здесь нужно указать свой Telegram ID
text = "Test Text"
}
$json = $ht | ConvertTo-Json
Invoke-RestMethod $URL_set -Method Post -ContentType 'application/json; charset=utf-8' -Body $json
```
Получаем Error:
*Invoke-RestMethod: {«ok»:false,«error\_code»:400,«description»:«Bad Request: field \»inline\_keyboard\" of the InlineKeyboardMarkup should be an Array of Arrays"}
At line:21 char:1*
Проверяем что содержит переменная *$json*
Вывод:
```
{
"reply_markup": {
"inline_keyboard": [
"System.Collections.Hashtable System.Collections.Hashtable"
]
},
"chat_id": **********,
"text": "Test Text",
"parse_mode": "Markdown"
}
```
Видимо как-то не очень передавать объект HashTable («System.Collections.Hashtable System.Collections.Hashtable») для api телеграма. Немного гугла и итог – при конвертации в Json ставим глубину конвертации
```
# Token
$token = "***********************"
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
# Используем поле callback_data чтобы знать, какую кнопку нажал пользователь
$button1 = @{ "text" = "Test1"; callback_data = "Test1_CD"}
$button2 = @{ "text" = "Test2"; callback_data = "Test2_CD"}
$keyboard = @{"inline_keyboard" = @(,@($button1, $button2))}
$ht = @{
parse_mode = "Markdown"
reply_markup = $keyboard
chat_id = ********
text = "Test Text"
}
$json = $ht | ConvertTo-Json -Depth 5
Invoke-RestMethod $URL_set -Method Post -ContentType 'application/json; charset=utf-8' -Body $json
```
Получаем кнопки:
Делаем функцию по отправке кнопок, на вход будем подавать массив кнопок
```
# Token
$token = "***********************"
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
# Используем поле callback_data чтобы знать, какую кнопку нажал пользователь
$button1 = @{ "text" = "Test1"; callback_data = "Test1_CD"}
$button2 = @{ "text" = "Test2"; callback_data = "Test2_CD"}
$buttons = ($button1, $button2)
function sendKeyboard($URL, $buttons)
{
$keyboard = @{"inline_keyboard" = @(,$buttons)}
$ht = @{
parse_mode = "Markdown"
reply_markup = $keyboard
chat_id = ********
text = "Test Text"
}
$json = $ht | ConvertTo-Json -Depth 5
Invoke-RestMethod $URL_set -Method Post -ContentType 'application/json; charset=utf-8' -Body $json
}
sendKeyboard $URL_set $buttons
```
**Собираем все воедино, немного поменяв блок switch**
```
# Token
$token = "***********************"
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
# timeout sec
$timeout = 1
function getUpdates($URL)
{
$json = Invoke-RestMethod -Uri $URL
$data = $json.result | Select-Object -Last 1
#$data.update_id
$chat_id = $data.message.chat.id
$text = $data.message.text
$f_name = $data.message.chat.first_name
$l_name = $data.message.chat.last_name
$type = $data.message.chat.type
$username = $data.message.chat.username
# проверяем что text есть
if($text)
{
# confirm
Invoke-RestMethod "$($URL)?offset=$($($data.update_id)+1)" -Method Get | Out-Null
# HashTable
$ht = @{}
$ht["chat_id"] = $chat_id
$ht["text"] = $text
$ht["f_name"] = $f_name
$ht["l_name"] = $l_name
$ht["username"] = $username
return $ht
}
}
function sendMessage($URL, $chat_id, $text)
{
# создаем HashTable, можно объявлять ее и таким способом
$ht = @{
text = $text
# указан способ разметки Markdown
parse_mode = "Markdown"
chat_id = $chat_id
}
# Данные нужно отправлять в формате json
$json = $ht | ConvertTo-Json
# Делаем через Invoke-RestMethod, но никто не запрещает сделать и через Invoke-WebRequest
# Method Post - т.к. отправляем данные, по умолчанию Get
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json | Out-Null
}
function sendKeyboard($URL, $buttons, $chat_id, $text)
{
$keyboard = @{"inline_keyboard" = @(,$buttons)}
$ht = @{
parse_mode = "Markdown"
reply_markup = $keyboard
chat_id = $chat_id
text = $text
}
$json = $ht | ConvertTo-Json -Depth 5
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json
}
while($true) # вечный цикл
{
$return = getUpdates $URL_get
if($return)
{
# http://apps.timwhitlock.info/emoji/tables/unicode#block-1-emoticons
#sendMessage $URL_set $return.chat_id (Get-Random("", "", "", ""))
write-host "$($return["chat_id"])"
switch -Wildcard ($return["text"])
{
"*привет*" {
$button1 = @{ "text" = "Project1"; callback_data = "Project1_CD"}
$button2 = @{ "text" = "Project2"; callback_data = "Project2_CD"}
$buttons = ($button1, $button2)
$text = "Available projects:"
$chat_id = $return.chat_id
sendKeyboard $URL_set $buttons $chat_id $text
#sendMessage $URL_set $return.chat_id "Привет, $($return["f_name"])"
}
"*как дела?*" { sendMessage $URL_set $return.chat_id "Хорошо" }
default {sendMessage $URL_set $return.chat_id "$(Get-Random("", "", "", ""))"}
}
}
Start-Sleep -s $timeout
}
```
Теперь на «привет» бот будет отправлять нам пару кнопок. Осталось понять, какую кнопку нажал пользователь. В текущей ps-функции getUpdates есть проверка на
```
if($text)...
```
При нажатии на кнопку никакой текст не возвращается, соответственно, нужно модифицировать функцию. Нажимаем на кнопку
И запускаем кусок кода для проверки содержимого *$data*
```
# Token
$token = "***********************"
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
# timeout sec
$timeout = 1
function getUpdates($URL)
{
$json = Invoke-RestMethod -Uri $URL
$data = $json.result | Select-Object -Last 1
$data
<#
$chat_id = $data.message.chat.id
$text = $data.message.text
$f_name = $data.message.chat.first_name
$l_name = $data.message.chat.last_name
$type = $data.message.chat.type
$username = $data.message.chat.username
# проверяем что text есть
if($text)
{
# confirm
Invoke-RestMethod "$($URL)?offset=$($($data.update_id)+1)" -Method Get | Out-Null
# HashTable
$ht = @{}
$ht["chat_id"] = $chat_id
$ht["text"] = $text
$ht["f_name"] = $f_name
$ht["l_name"] = $l_name
$ht["username"] = $username
return $ht
}
#>
}
getUpdates $URL_get
```
Никакой message больше не прилетает. Вместо него теперь *callback\_query*. Правим функцию
```
# Token
$token = "***********************"
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
# timeout sec
$timeout = 1
function getUpdates($URL)
{
$json = Invoke-RestMethod -Uri $URL
$data = $json.result | Select-Object -Last 1
# Нажатие на кнопку
if($data.callback_query)
{
$callback_data = $data.callback_query.data
$chat_id = $data.callback_query.from.id
$f_name = $data.callback_query.from.first_name
$l_name = $data.callback_query.from.last_name
$username = $data.callback_query.from.username
}
# Обычное сообщение
elseif($data.message)
{
$chat_id = $data.message.chat.id
$text = $data.message.text
$f_name = $data.message.chat.first_name
$l_name = $data.message.chat.last_name
$type = $data.message.chat.type
$username = $data.message.chat.username
}
$ht = @{}
$ht["chat_id"] = $chat_id
$ht["text"] = $text
$ht["f_name"] = $f_name
$ht["l_name"] = $l_name
$ht["username"] = $username
$ht["callback_data"] = $callback_data
# confirm
Invoke-RestMethod "$($URL)?offset=$($($data.update_id)+1)" -Method Get | Out-Null
return $ht
}
getUpdates $URL_get
```
Теперь функция возвращает *text*, если есть сообщение, или *callback\_data*, если было нажатие на кнопку. На этапе тестов словили ошибку при вызове:
```
sendMessage $URL_set $($return.chat_id) $($return.callback_data)
```
*Invoke-RestMethod: {«ok»:false,«error\_code»:400,«description»:«Bad Request: can't parse entities: Can't find end of the entity starting at byte offset 8»}*
Так как *parse\_mode* выставлен в *Markdown*, а отправляемый текст
```
$return.callback_data = “Project1_CD”
```
нужно перед отправкой форматировать сообщение, подробнее тут:
<https://core.telegram.org/bots/api#formatting-options>
или убрать нижнее подчеркивание «\_»
**Итоговый скрипт**
```
# Token
$token = "***********************"
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
# timeout sec
$timeout = 1
function getUpdates($URL)
{
$json = Invoke-RestMethod -Uri $URL
$data = $json.result | Select-Object -Last 1
# Обнуляем переменные
$text = $null
$callback_data = $null
# Нажатие на кнопку
if($data.callback_query)
{
$callback_data = $data.callback_query.data
$chat_id = $data.callback_query.from.id
$f_name = $data.callback_query.from.first_name
$l_name = $data.callback_query.from.last_name
$username = $data.callback_query.from.username
}
# Обычное сообщение
elseif($data.message)
{
$chat_id = $data.message.chat.id
$text = $data.message.text
$f_name = $data.message.chat.first_name
$l_name = $data.message.chat.last_name
$type = $data.message.chat.type
$username = $data.message.chat.username
}
$ht = @{}
$ht["chat_id"] = $chat_id
$ht["text"] = $text
$ht["f_name"] = $f_name
$ht["l_name"] = $l_name
$ht["username"] = $username
$ht["callback_data"] = $callback_data
# confirm
Invoke-RestMethod "$($URL)?offset=$($($data.update_id)+1)" -Method Get | Out-Null
return $ht
}
function sendMessage($URL, $chat_id, $text)
{
# создаем HashTable, можно объявлять ее и таким способом
$ht = @{
text = $text
# указан способ разметки Markdown
parse_mode = "Markdown"
chat_id = $chat_id
}
# Данные нужно отправлять в формате json
$json = $ht | ConvertTo-Json
# Делаем через Invoke-RestMethod, но никто не запрещает сделать и через Invoke-WebRequest
# Method Post - т.к. отправляем данные, по умолчанию Get
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json | Out-Null
}
function sendKeyboard($URL, $buttons, $chat_id, $text)
{
$keyboard = @{"inline_keyboard" = @(,$buttons)}
$ht = @{
parse_mode = "Markdown"
reply_markup = $keyboard
chat_id = $chat_id
text = $text
}
$json = $ht | ConvertTo-Json -Depth 5
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json
}
while($true) # вечный цикл
{
$return = getUpdates $URL_get
#$return
# Если обычное сообщение
if($return.text)
{
# http://apps.timwhitlock.info/emoji/tables/unicode#block-1-emoticons
#sendMessage $URL_set $return.chat_id (Get-Random("", "", "", ""))
write-host "$($return["chat_id"])"
switch -Wildcard ($return["text"])
{
"*привет*" {
$button1 = @{ "text" = "Project1"; callback_data = "Project1CD"}
$button2 = @{ "text" = "Project2"; callback_data = "Project2CD"}
$buttons = ($button1, $button2)
$text = "Available projects:"
$chat_id = $return.chat_id
sendKeyboard $URL_set $buttons $chat_id $text
#sendMessage $URL_set $return.chat_id "Привет, $($return["f_name"])"
}
"*как дела?*" { sendMessage $URL_set $return.chat_id "Хорошо" }
default {sendMessage $URL_set $return.chat_id "$(Get-Random("", "", "", ""))"}
}
}
# если было нажатие на кнопку
elseif($return.callback_data)
{
sendMessage $URL_set $($return.chat_id) $($return.callback_data)
}
Start-Sleep -s $timeout
}
```
### Часть 3: делаем конфиг
Настало время всё вынести в конфиг. Тут все просто – делаем xml:
```
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
1
```
Описываем задачи (tasks) и для каждой задачи указываем скрипт или команду.
Проверяем:
```
[xml]$xmlConfig = Get-Content -Path ("c:\Temp\Habr\telegram_bot.xml")
$token = $xmlConfig.config.system.token
$timeout = $xmlConfig.config.system.timeout.'#text'
foreach($task in $xmlConfig.config.tasks.task)
{
$task.name # имя кнопки
$task.script # скрипт
}
```
**Собираем в основной скрипт**
```
[xml]$xmlConfig = Get-Content -Path ("c:\Temp\Habr\telegram_bot.xml")
$token = $xmlConfig.config.system.token
$timeout = $xmlConfig.config.system.timeout.'#text'
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
function getUpdates($URL)
{
$json = Invoke-RestMethod -Uri $URL
$data = $json.result | Select-Object -Last 1
# Обнуляем переменные
$text = $null
$callback_data = $null
# Нажатие на кнопку
if($data.callback_query)
{
$callback_data = $data.callback_query.data
$chat_id = $data.callback_query.from.id
$f_name = $data.callback_query.from.first_name
$l_name = $data.callback_query.from.last_name
$username = $data.callback_query.from.username
}
# Обычное сообщение
elseif($data.message)
{
$chat_id = $data.message.chat.id
$text = $data.message.text
$f_name = $data.message.chat.first_name
$l_name = $data.message.chat.last_name
$type = $data.message.chat.type
$username = $data.message.chat.username
}
$ht = @{}
$ht["chat_id"] = $chat_id
$ht["text"] = $text
$ht["f_name"] = $f_name
$ht["l_name"] = $l_name
$ht["username"] = $username
$ht["callback_data"] = $callback_data
# confirm
Invoke-RestMethod "$($URL)?offset=$($($data.update_id)+1)" -Method Get | Out-Null
return $ht
}
function sendMessage($URL, $chat_id, $text)
{
# создаем HashTable, можно объявлять ее и таким способом
$ht = @{
text = $text
# указан способ разметки Markdown
parse_mode = "Markdown"
chat_id = $chat_id
}
# Данные нужно отправлять в формате json
$json = $ht | ConvertTo-Json
# Делаем через Invoke-RestMethod, но никто не запрещает сделать и через Invoke-WebRequest
# Method Post - т.к. отправляем данные, по умолчанию Get
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json | Out-Null
}
function sendKeyboard($URL, $buttons, $chat_id, $text)
{
$keyboard = @{"inline_keyboard" = @(,$buttons)}
$ht = @{
parse_mode = "Markdown"
reply_markup = $keyboard
chat_id = $chat_id
text = $text
}
$json = $ht | ConvertTo-Json -Depth 5
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json
}
while($true) # вечный цикл
{
$return = getUpdates $URL_get
# Если обычное сообщение
if($return.text)
{
# http://apps.timwhitlock.info/emoji/tables/unicode#block-1-emoticons
#sendMessage $URL_set $return.chat_id (Get-Random("", "", "", ""))
write-host "$($return["chat_id"])"
switch -Wildcard ($return["text"])
{
"*привет*" {
# Пустой массив
$buttons = @()
foreach($task in $xmlConfig.config.tasks.task)
{
$button = @{ "text" = $task.name; callback_data = $task.script}
$buttons += $button
}
$text = "Available tasks:"
$chat_id = $return.chat_id
sendKeyboard $URL_set $buttons $chat_id $text
#sendMessage $URL_set $return.chat_id "Привет, $($return["f_name"])"
}
"*как дела?*" { sendMessage $URL_set $return.chat_id "Хорошо" }
default {sendMessage $URL_set $return.chat_id "$(Get-Random("", "", "", ""))"}
}
}
# если было нажатие на кнопку
elseif($return.callback_data)
{
sendMessage $URL_set $($return.chat_id) $($return.callback_data)
}
Start-Sleep -s $timeout
}
```
Теперь, если написать «привет» — бот вернет список кнопок, который соответствует задачам, описанным в xml-файлы. В callback\_data будет команда или скрипт.
Если делать косметические изменения – то желательно, чтобы кнопок было 3-4 на строку, иначе они отображаются не полностью:
Будем делать по 3 кнопки в линию (максимально).
Схематично массив keyboard должен выглядеть так:
Таким образом:
Button[i] — массив (ассоциативный) вида
```
$button = @{ "text" = $task.name; callback_data = $task.script}
```
Line[1-3] — это массивы (из кнопок), которые хранят в себе массивы кнопок (это важно)
Keyboard – массив из Line’ов.
Модифицируем функцию *sendKeyboard*
```
function sendKeyboard($URL, $buttons, $chat_id, $text)
{
$keyboard = @{}
# Тут необходимо использовать ArrayList, т.к внутри него мы будем хранить объекты - другие массивы
$lines = 3
$buttons_line = New-Object System.Collections.ArrayList
for($i=0; $i -lt $buttons.Count; $i++)
{
# Добавляем кнопки в линию (line). Как только добавили 3 - добавляем line в keyboard
$buttons_line.Add($buttons[$i]) | Out-Null
# Проверяем счетчик - остаток от деления должен быть 0
if( ($i + 1 )%$lines -eq 0 )
{
# добавляем строку кнопок в keyboard
$keyboard["inline_keyboard"] += @(,@($buttons_line))
$buttons_line.Clear()
}
}
# добавляем оставшиеся последние кнопки
$keyboard["inline_keyboard"] += @(,@($buttons_line))
#$keyboard = @{"inline_keyboard" = @(,$buttons)}
$ht = @{
parse_mode = "Markdown"
reply_markup = $keyboard
chat_id = $chat_id
text = $text
}
$json = $ht | ConvertTo-Json -Depth 5
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json
}
```
Проверяем:
**Итоговый скрипт**
```
[xml]$xmlConfig = Get-Content -Path ("c:\Temp\Habr\telegram_bot.xml")
$token = $xmlConfig.config.system.token
$timeout = $xmlConfig.config.system.timeout.'#text'
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
function getUpdates($URL)
{
$json = Invoke-RestMethod -Uri $URL
$data = $json.result | Select-Object -Last 1
# Обнуляем переменные
$text = $null
$callback_data = $null
# Нажатие на кнопку
if($data.callback_query)
{
$callback_data = $data.callback_query.data
$chat_id = $data.callback_query.from.id
$f_name = $data.callback_query.from.first_name
$l_name = $data.callback_query.from.last_name
$username = $data.callback_query.from.username
}
# Обычное сообщение
elseif($data.message)
{
$chat_id = $data.message.chat.id
$text = $data.message.text
$f_name = $data.message.chat.first_name
$l_name = $data.message.chat.last_name
$type = $data.message.chat.type
$username = $data.message.chat.username
}
$ht = @{}
$ht["chat_id"] = $chat_id
$ht["text"] = $text
$ht["f_name"] = $f_name
$ht["l_name"] = $l_name
$ht["username"] = $username
$ht["callback_data"] = $callback_data
# confirm
Invoke-RestMethod "$($URL)?offset=$($($data.update_id)+1)" -Method Get | Out-Null
return $ht
}
function sendMessage($URL, $chat_id, $text)
{
# создаем HashTable, можно объявлять ее и таким способом
$ht = @{
text = $text
# указан способ разметки Markdown
parse_mode = "Markdown"
chat_id = $chat_id
}
# Данные нужно отправлять в формате json
$json = $ht | ConvertTo-Json
# Делаем через Invoke-RestMethod, но никто не запрещает сделать и через Invoke-WebRequest
# Method Post - т.к. отправляем данные, по умолчанию Get
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json | Out-Null
}
function sendKeyboard($URL, $buttons, $chat_id, $text)
{
$keyboard = @{}
# Тут необходимо использовать ArrayList, т.к внутри него мы будем хранить объекты - другие массивы
$lines = 3
$buttons_line = New-Object System.Collections.ArrayList
for($i=0; $i -lt $buttons.Count; $i++)
{
# Добавляем кнопки в линию (line). Как только добавили 3 - добавляем line в keyboard
$buttons_line.Add($buttons[$i]) | Out-Null
# Проверяем счетчик - остаток от деления должен быть 0
if( ($i + 1 )%$lines -eq 0 )
{
# добавляем строку кнопок в keyboard
$keyboard["inline_keyboard"] += @(,@($buttons_line))
$buttons_line.Clear()
}
}
# добавляем оставшиеся посление кнопки
$keyboard["inline_keyboard"] += @(,@($buttons_line))
$ht = @{
parse_mode = "Markdown"
reply_markup = $keyboard
chat_id = $chat_id
text = $text
}
$json = $ht | ConvertTo-Json -Depth 5
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json
}
while($true) # вечный цикл
{
$return = getUpdates $URL_get
#$return.text = "привет"
# Если обычное сообщение
if($return.text)
{
# http://apps.timwhitlock.info/emoji/tables/unicode#block-1-emoticons
#sendMessage $URL_set $return.chat_id (Get-Random("", "", "", ""))
switch -Wildcard ($return["text"])
{
"*привет*" {
# Пустой массив
$buttons = @()
foreach($task in $xmlConfig.config.tasks.task)
{
$i++
$button = @{ "text" = $task.name; callback_data = $task.script}
$buttons += $button
}
$text = "Available tasks:"
$chat_id = $return.chat_id
sendKeyboard $URL_set $buttons $chat_id $text
#sendMessage $URL_set $return.chat_id "Привет, $($return["f_name"])"
}
"*как дела?*" { sendMessage $URL_set $return.chat_id "Хорошо" }
default {sendMessage $URL_set $return.chat_id "$(Get-Random("", "", "", ""))"}
}
}
# если было нажатие на кнопку
elseif($return.callback_data)
{
#sendMessage $URL_set $($return.chat_id) $($return.callback_data)
write-host "$($return.chat_id) $($return.callback_data)"
}
Start-Sleep -s $timeout
}
```
### Часть 4: задачность и многозадачность
Настало время по кнопке делать дела.
Для многозадачности будем использовать механизм Job’ов. Проверяем такой кусок кода:
```
$script = "ipconfig"
$script_block = { Param($script) ; Invoke-Expression $script }
$job_name = "TestJob"
Start-Job -ScriptBlock $script_block -ArgumentList $script -Name $job_name | Out-Null
```
И через 5 секунд выполняем:
```
foreach($job in (Get-Job | Where {$_.State -eq "Completed"} ))
{
$output = Get-Job -ID $job.Id | Receive-Job
$output
$job | Remove-Job
}
```
*$output* должен возвращать ipconfig с localhost
Добавляем это в основной скрипт, в блок callback\_data
```
# если было нажатие на кнопку
elseif($return.callback_data)
{
$script = $($return.callback_data)
$job_name = $($return.chat_id)
$script_block = { Param($script) ; Invoke-Expression $script }
#запускаем Job
Start-Job -ScriptBlock $script_block -ArgumentList $script -Name $job_name | Out-Null
}
```
А это ниже
```
# смотрим, какие job'ы уже выполнились
foreach($job in (Get-Job | Where {$_.State -eq "Completed"} ))
{
$output = Get-Job -ID $job.Id | Receive-Job
# отправляем результат тому, кто вызвал job
sendMessage $URL_set $job.Name $output
$job | Remove-Job
# и снова шлем клавиатуру
$text = "Available tasks:"
sendKeyboard $URL_set $buttons $job.Name $text
}
```
Проверяем, ловим error
*Invoke-RestMethod: {«ok»:false,«error\_code»:400,«description»:«Bad Request: message is too long»}*
На просторах интернета находим информацию, что длина сообщения не может превышать 4096 символов. Оукей…
```
$output.Length
```
говорит что длина 39
Долго думаем что не так, в результате пробуем такой кусок кода:
```
$text = $null
foreach($string in $output)
{
$text = "$text`n$string"
}
sendMessage $URL_set $job.Name $text
```
**Пробуем всё вместе**
```
[xml]$xmlConfig = Get-Content -Path ("c:\Temp\Habr\telegram_bot.xml")
$token = $xmlConfig.config.system.token
$timeout = $xmlConfig.config.system.timeout.'#text'
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
function getUpdates($URL)
{
$json = Invoke-RestMethod -Uri $URL
$data = $json.result | Select-Object -Last 1
# Обнуляем переменные
$text = $null
$callback_data = $null
# Нажатие на кнопку
if($data.callback_query)
{
$callback_data = $data.callback_query.data
$chat_id = $data.callback_query.from.id
$f_name = $data.callback_query.from.first_name
$l_name = $data.callback_query.from.last_name
$username = $data.callback_query.from.username
}
# Обычное сообщение
elseif($data.message)
{
$chat_id = $data.message.chat.id
$text = $data.message.text
$f_name = $data.message.chat.first_name
$l_name = $data.message.chat.last_name
$type = $data.message.chat.type
$username = $data.message.chat.username
}
$ht = @{}
$ht["chat_id"] = $chat_id
$ht["text"] = $text
$ht["f_name"] = $f_name
$ht["l_name"] = $l_name
$ht["username"] = $username
$ht["callback_data"] = $callback_data
# confirm
Invoke-RestMethod "$($URL)?offset=$($($data.update_id)+1)" -Method Get | Out-Null
return $ht
}
function sendMessage($URL, $chat_id, $text)
{
# создаем HashTable, можно объявлять ее и таким способом
$ht = @{
text = $text
# указан способ разметки Markdown
parse_mode = "Markdown"
chat_id = $chat_id
}
# Данные нужно отправлять в формате json
$json = $ht | ConvertTo-Json
# Делаем через Invoke-RestMethod, но никто не запрещает сделать и через Invoke-WebRequest
# Method Post - т.к. отправляем данные, по умолчанию Get
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json | Out-Null
}
function sendKeyboard($URL, $buttons, $chat_id, $text)
{
$keyboard = @{}
$lines = 3
# Тут необходимо использовать ArrayList, т.к внутри него мы будем хранить объекты - другие массивы
$buttons_line = New-Object System.Collections.ArrayList
for($i=0; $i -lt $buttons.Count; $i++)
{
# Добавляем кнопки в линию (line). Как только добавили 3 - добавляем line в keyboard
$buttons_line.Add($buttons[$i]) | Out-Null
# Проверяем счетчик - остаток от деления должен быть 0
if( ($i + 1 )%$lines -eq 0 )
{
# добавляем строку кнопок в keyboard
$keyboard["inline_keyboard"] += @(,@($buttons_line))
$buttons_line.Clear()
}
}
# добавляем оставшиеся последние кнопки
$keyboard["inline_keyboard"] += @(,@($buttons_line))
$ht = @{
parse_mode = "Markdown"
reply_markup = $keyboard
chat_id = $chat_id
text = $text
}
$json = $ht | ConvertTo-Json -Depth 5
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json
}
while($true) # вечный цикл
{
$return = getUpdates $URL_get
#$return.text = "привет"
# Если обычное сообщение
if($return.text)
{
# http://apps.timwhitlock.info/emoji/tables/unicode#block-1-emoticons
#sendMessage $URL_set $return.chat_id (Get-Random("", "", "", ""))
switch -Wildcard ($return["text"])
{
"*привет*" {
# Пустой массив
$buttons = @()
foreach($task in $xmlConfig.config.tasks.task)
{
$i++
$button = @{ "text" = $task.name; callback_data = $task.script}
$buttons += $button
}
$text = "Available tasks:"
$chat_id = $return.chat_id
sendKeyboard $URL_set $buttons $chat_id $text
#sendMessage $URL_set $return.chat_id "Привет, $($return["f_name"])"
}
"*как дела?*" { sendMessage $URL_set $return.chat_id "Хорошо" }
default {sendMessage $URL_set $return.chat_id "$(Get-Random("", "", "", ""))"}
}
}
# если было нажатие на кнопку
elseif($return.callback_data)
{
$script = $($return.callback_data)
$job_name = $($return.chat_id)
write-host "$script $job_name"
$script_block = { Param($script) ; Invoke-Expression $script }
#запускаем Job
Start-Job -ScriptBlock $script_block -ArgumentList $script -Name $job_name | Out-Null
}
# смотрим, какие job'ы уже выполнились
foreach($job in (Get-Job | Where {$_.State -eq "Completed"} ))
{
$output = Get-Job -ID $job.Id | Receive-Job
$text = $null
foreach($string in $output)
{
$text = "$text`n$string"
}
# отправляем результат тому, кто вызвал job
sendMessage $URL_set $job.Name $text
$job | Remove-Job
# и снова шлем клавиатуру
$text = "Available tasks:"
sendKeyboard $URL_set $buttons $job.Name $text
}
Start-Sleep -s $timeout
}
```
Теперь прикрутим «немного безопасности»
Добавляем в xml конфиг новую строку, назовем ее *users* и укажем там chat\_id тех, кому можно общаться с ботом:
```
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
1
111111111, 222222222
```
В скрипте будем получать массив *users*
```
$users = (($xmlConfig.config.system.users).Split(",")).Trim()
```
И проверять
```
if($users -contains $return.chat_id)
{
...
}
```
**Скрипт целиком**
```
[xml]$xmlConfig = Get-Content -Path ("c:\Temp\Habr\telegram_bot.xml")
$token = $xmlConfig.config.system.token
$timeout = $xmlConfig.config.system.timeout.'#text'
$users = (($xmlConfig.config.system.users).Split(",")).Trim()
# Telegram URLs
$URL_get = "https://api.telegram.org/bot$token/getUpdates"
$URL_set = "https://api.telegram.org/bot$token/sendMessage"
function getUpdates($URL)
{
$json = Invoke-RestMethod -Uri $URL
$data = $json.result | Select-Object -Last 1
# Обнуляем переменные
$text = $null
$callback_data = $null
# Нажатие на кнопку
if($data.callback_query)
{
$callback_data = $data.callback_query.data
$chat_id = $data.callback_query.from.id
$f_name = $data.callback_query.from.first_name
$l_name = $data.callback_query.from.last_name
$username = $data.callback_query.from.username
}
# Обычное сообщение
elseif($data.message)
{
$chat_id = $data.message.chat.id
$text = $data.message.text
$f_name = $data.message.chat.first_name
$l_name = $data.message.chat.last_name
$type = $data.message.chat.type
$username = $data.message.chat.username
}
$ht = @{}
$ht["chat_id"] = $chat_id
$ht["text"] = $text
$ht["f_name"] = $f_name
$ht["l_name"] = $l_name
$ht["username"] = $username
$ht["callback_data"] = $callback_data
# confirm
Invoke-RestMethod "$($URL)?offset=$($($data.update_id)+1)" -Method Get | Out-Null
return $ht
}
function sendMessage($URL, $chat_id, $text)
{
# создаем HashTable, можно объявлять ее и таким способом
$ht = @{
text = $text
# указан способ разметки Markdown
parse_mode = "Markdown"
chat_id = $chat_id
}
# Данные нужно отправлять в формате json
$json = $ht | ConvertTo-Json
# Делаем через Invoke-RestMethod, но никто не запрещает сделать и через Invoke-WebRequest
# Method Post - т.к. отправляем данные, по умолчанию Get
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json | Out-Null
}
function sendKeyboard($URL, $buttons, $chat_id, $text)
{
$keyboard = @{}
$lines = 3
# Тут необходимо использовать ArrayList, т.к внутри него мы будем хранить объекты - другие массивы
$buttons_line = New-Object System.Collections.ArrayList
for($i=0; $i -lt $buttons.Count; $i++)
{
# Добавляем кнопки в линию (line). Как только добавили 3 - добавляем line в keyboard
$buttons_line.Add($buttons[$i]) | Out-Null
# Проверяем счетчик - остаток от деления должен быть 0
if( ($i + 1 )%$lines -eq 0 )
{
# добавляем строку кнопок в keyboard
$keyboard["inline_keyboard"] += @(,@($buttons_line))
$buttons_line.Clear()
}
}
# добавляем оставшиеся последние кнопки
$keyboard["inline_keyboard"] += @(,@($buttons_line))
$ht = @{
parse_mode = "Markdown"
reply_markup = $keyboard
chat_id = $chat_id
text = $text
}
$json = $ht | ConvertTo-Json -Depth 5
Invoke-RestMethod $URL -Method Post -ContentType 'application/json; charset=utf-8' -Body $json
}
while($true) # вечный цикл
{
$return = getUpdates $URL_get
if($users -contains $return.chat_id)
{
# Если обычное сообщение
if($return.text)
{
#write-host $return.chat_id
# http://apps.timwhitlock.info/emoji/tables/unicode#block-1-emoticons
#sendMessage $URL_set $return.chat_id (Get-Random("", "", "", ""))
switch -Wildcard ($return["text"])
{
"*привет*" {
# Пустой массив
$buttons = @()
foreach($task in $xmlConfig.config.tasks.task)
{
$i++
$button = @{ "text" = $task.name; callback_data = $task.script}
$buttons += $button
}
$text = "Available tasks:"
$chat_id = $return.chat_id
sendKeyboard $URL_set $buttons $chat_id $text
#sendMessage $URL_set $return.chat_id "Привет, $($return["f_name"])"
}
"*как дела?*" { sendMessage $URL_set $return.chat_id "Хорошо" }
default {sendMessage $URL_set $return.chat_id "$(Get-Random("", "", "", ""))"}
}
}
# если было нажатие на кнопку
elseif($return.callback_data)
{
$script = $($return.callback_data)
$job_name = $($return.chat_id)
write-host "$script $job_name"
$script_block = { Param($script) ; Invoke-Expression $script }
#запускаем Job
Start-Job -ScriptBlock $script_block -ArgumentList $script -Name $job_name | Out-Null
}
# смотрим, какие job'ы уже выполнились
foreach($job in (Get-Job | Where {$_.State -eq "Completed"} ))
{
$output = Get-Job -ID $job.Id | Receive-Job
$text = $null
foreach($string in $output)
{
$text = "$text`n$string"
}
# отправляем результат тому, кто вызвал job
sendMessage $URL_set $job.Name $text
$job | Remove-Job
# и снова шлем клавиатуру
$text = "Available tasks:"
sendKeyboard $URL_set $buttons $job.Name $text
}
}
else
{
if($return.text)
{
sendMessage $URL_set $return.chat_id "Вы кто такие? Я вас не звал!"
}
}
Start-Sleep -s $timeout
}
```
### Часть 5: в заключение
Проверяем функционал бота – добавим туда скриптов, которые будут делать что-то полезное
Для операций на удаленных серверах мы используем Invoke-Command с последующим Write-Output
```
$hostname = "hostname"
$service = "MSSQLSERVER"
$output = Invoke-Command -ComputerName $hostname -ScriptBlock{param($service); (Get-Service -Name $service).Status} -ArgumentList $service
write-output $output.Value
```
В этом случае, учетная запись, из-под которой будет работать скрипт телеграм-бота должна иметь соответствующие привилегии на удаленной машине.
Также, я не затронул функционал логировая, но здесь, думаю, все просто, по желанию каждый сам может решить что он хочет логировать, а что нет.
Наверняка у кого-то будет проблема с отправкой сообщения > 4096 символов, но это решаемо Substring и циклом отправки.
И напоследок – удаленное управление из любой точки мира (почти из любой) это хорошо, но всегда есть риск, что что-то пойдет не так (управление ботом вдруг может получить кто-то нехороший). На этот случай мы просто добавили Exit из скрипта по определенному слову
```
switch -Wildcard ($return["text"])
{
"*привет*" {
# Пустой массив
$buttons = @()
foreach($task in $xmlConfig.config.tasks.task)
{
$i++
$button = @{ "text" = $task.name; callback_data = $task.script}
$buttons += $button
}
$text = "Available tasks:"
$chat_id = $return.chat_id
sendKeyboard $URL_set $buttons $chat_id $text
#sendMessage $URL_set $return.chat_id "Привет, $($return["f_name"])"
}
"*как дела?*" { sendMessage $URL_set $return.chat_id "Хорошо" }
"алярма!" {sendMessage $URL_set $return.chat_id "bb" ; Exit}
default {sendMessage $URL_set $return.chat_id "$(Get-Random("", "", "", ""))"}
}
```
У меня всё. | https://habr.com/ru/post/483660/ | null | ru | null |
# Сага о типизации и тайпчекинге для JavaScript
Привет! Хочу поделиться своими мыслями по, казалось бы, простой теме — типизации. В частности, поговорить о тайпчекинге в JavaScript.
Часто люди воспринимают типизацию как эдакую серебряную пулю, которая защищает от всех проблем. Но это не так, часто ожидания от типизации неоправданны, а простота таких инструментов, как TypeScript, обманчива и слишком переоценена.
Это не типичная статья из серии «Изучаем TypeScript», а, как мне кажется, фундаментальная история. Мы начнем с основ, поговорим о данных, о способе их хранения, а затем перейдем к типизации и посмотрим, как она влияет на работу программы.
Вопросы, над которыми я предлагаю задуматься после прочтения статьи:
* Что такое типизация?
* Чего я ожидаю от типизации?
* Оправданны ли эти ожидания?
Основы
------
Как известно, переменные нужны для хранения данных. Это могут быть строки, числа, булевы значения или разного рода структуры. Когда мы создаем переменную, то присваиваем ей имя и значение (данные). Данные должны где-то физически храниться. Таким хранилищем выступает оперативная память (ОЗУ). Каждый раз, когда мы записываем что-то в переменную, мы фактически модифицируем содержимое ОЗУ. Другой вопрос — как значения переменных хранятся в памяти и сколько места занимают. Посмотрим на пример из языка C/С++:
```
int foo = 1;
cout << sizeof foo << endl; // 4
```
Здесь мы создаем переменную `foo` и говорим, что будем хранить там целочисленные значения. При объявлении этой переменной из оперативной памяти будет выделено 4 байта или 32 бита. В 32 бита умещается число от 0 до 4 294 967 295. Это значит, что вне зависимости от того, какое число мы будем хранить в переменной (100 или 3 000 000), размер выделенной для нее памяти всегда будет составлять 4 байта. Правда, здесь стоит упомянуть, что один бит выделяется под хранение знака, а это значит, что в переменных типа `int` мы можем хранить числа от -2 147 483 648 до 2 147 483 647. Такой тип данных еще называется `signed int`, то есть целочисленное со знаком. Если же знак нас не интересует и мы хотим задействовать все 32 бита, то должны явно указать, что интерпретировать значение в переменной стоит как беззнаковое:
```
unsigned int foo = 1;
cout << foo << endl; // 1
```
Теперь мы можем хранить в переменной `foo` числа от 0 до 4 294 967 295. Это не запрещает нам хранить там отрицательные числа, но они будут интерпретированы как беззнаковые, то есть старший бит будет считаться частью числа, а не знаком этого числа:
```
unsigned int foo = -100;
cout << foo << endl; // 4 294 967 196
```
Мы можем использовать и более «экономные» типы данных. Например, если мы планируем хранить небольшие положительные числа (до 65 535), то нам вполне подойдет тип `unsigned short` или `uint16` (беззнаковое целое число размером в 16 бит):
```
unsigned short foo = 1;
cout << sizeof foo << endl; // 2
```
> **Вывод:** типизация может влиять на способ хранения и интерпретации данных.
>
>
Но не стоит путать этот эффект с типобезопасностью. В том же C++ мы можем делать страшные (с точки зрения стабильности) вещи:
```
string foo = "hello!";
int bar = 100;
foo = bar; // нет ошибок от компилятора
cout << foo << endl; // 'd' ???
```
Типизация здесь влияет на способ интерпретации данных, поэтому число 100 воспринимается как код символа (а 100 — это как раз символ `d`). Хуже всего, когда добавляется какая-то семантика:
```
string name = "John";
int age = 40;
name = age;
cout << name << endl; // '('
```
С точки зрения семантики мы не хотели бы иметь возможность присваивать возраст имени, тем более что это можно сделать случайно, тем более что компилятор ничего нам об этом не говорит. Более того, если очень захотим, можем сделать и обратное преобразование:
```
string name = "John";
int age = 40;
void* vp = &age
*(string*)vp = name;
cout << age << endl; // 1752123912
```
Это вполне легально и будет работать, вот только за результат никто не ручается. В таких языках, как C++, вы вольны делать практически все, что вам вздумается, и в данном случае мы своими руками попросили сделать нечто небезопасное.
Итак, примеры с C++ показали, что типизация здесь используется в качестве источника знаний для интерпретации значений в памяти. В конце концов, в памяти хранятся только единицы и нули, а как их интерпретировать, решаете уже вы. Так, число 4 294 967 140 может быть и символом `d`, так как младший байт этого числа в двоичной системе равен 01100100(2) или 0x64(16) или 100(10), а это символ `d` в таблице ASCII.
Статическая типизация
---------------------
Все примеры, которые мы рассмотрели выше, относятся к статической типизации. Статическая типизация говорит, что тип переменной определяется только при ее объявлении и не может быть изменен в дальнейшем. Если мы указали, что планируем хранить в переменной число, то ничего кроме числа мы там хранить не сможем. Но что произойдет, если мы все же попытаемся это сделать? Это зависит от силы типизации. Статическая типизация бывает сильной и слабой. Вот это как раз и определяет, что произойдет при попытке присвоить значение с одним типом данных переменной с другим типом данных.
В случае со слабой типизацией будет сделана неявная попытка приведения одного типа к другому. Мы видели этот эффект в примере выше, когда пытались присвоить возраст строке и число было интерпретировано как код символа.
> С/С++ — язык со слабой статической типизацией.
>
>
В случае с сильной типизацией мы получим ошибку на этапе компиляции. Посмотрим пример на языке Kotlin:
```
val foo: Int = 123
val bar: String = foo // Type mismatch: inferred type is Int but String was expected
```
А если попытаемся осуществить принудительное приведение, то рискуем получить ошибку уже в рантайме:
```
val foo: Int = 123
val bar: String = foo as String // java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String
```
Тем не менее, если мы берем для примера язык Kotlin, то там можно обезопасить себя от такого выстрела в ногу — избавиться от ошибки времени выполнения и при этом ничего не сломать:
```
val foo: Int = 123
val bar: String? = foo as? String // нет ошибки
print(bar) // null
```
`as?` — это [safe cast operator](https://kotlinlang.org/docs/reference/typecasts.html#safe-nullable-cast-operator), и он вернет `null`, если преобразовать тип не удалось. Ну а дальше мы уже знаем, что в переменной `bar` может быть либо строка, либо `null`, и исходя из этого будем выстраивать дальнейшую логику работы нашей программы.
> **Вывод:** сильная статическая типизация может сделать код более безопасным.
>
>
Динамическая типизация
----------------------
Переходим к JavaScript.
В языках с динамической типизацией тип переменной может быть изменен в любой момент любое количество раз:
```
let a = "привет";
console.log(a); // "привет"
a = 123;
console.log(a); // 123
```
Это значит, что такой код абсолютно легален:
```
function sqr(n) {
return n * n;
}
const result = sqr("привет!");
```
Никаких ошибок показано не будет, а в переменной `result` будет записано специальное значение `NaN`.
Здесь сразу же напрашивается вопрос: как мы можем быть уверены в том, что в данный момент в переменной хранится то, что мы ожидаем?
**Ответ:** при помощи специальных проверок прямо в момент исполнения программы:
```
function sqr(n) {
if (isFinite(n)) {
return n * n;
}
return 1;
}
const result = sqr("привет!");
```
Типов таких проверок несколько:
* [typeof](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/typeof)
* [instanceof](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/instanceof)
* [Array.isArray()](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)
* [isFinite()](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/isFinite)
Но здесь есть свои нюансы, и их довольно много. Ниже приведены примеры:
```
typeof [] // 'object'
typeof null // 'object'
isFinite("") // true
```
1. Массивы — это не отдельный тип данных, несмотря на то, что для них есть отдельный литерал. Вот что [говорит](https://262.ecma-international.org/10.0/#sec-array-objects) нам спецификация:
> Array objects are exotic objects that give special treatment to a certain class of property names.
>
>
2. Так [исторически](https://900913.ru/2020/04/07/history-of-typeof-null/) сложилось.
3. Несмотря на то, что глобальная функция `isFinite()` проверяет, является ли переданный ей аргумент небесконечным числом, делает она это с учетом принудительного преобразования типов. Подробнее [здесь](https://medium.com/developers-arena/type-coercion-in-javascript-c973b369b272) (попроще) и [здесь](https://2ality.com/2019/10/type-coercion.html) (посложнее). У `isFinite()` есть более строгий вариант `Number.isFinite()`.
Справедливости ради отмечу, что не все языки с динамической типизацией замалчивают неожиданные результаты. Например, Python и PHP в некоторых случаях выбрасывают ошибку времени выполнения. Скажем, если попытаться умножить число на объект.
А теперь снова копнем ближе к внутренностям и подумаем, как хранятся значения в языках с динамической типизацией.
Тип переменной может быть изменен в любое время, а значит, и максимальный размер данных заранее неизвестен. Следовательно, мы не знаем, сколько байт памяти нам нужно выделить, чтобы удовлетворить потребности всех типов данных:
```
let foo = true;
// ...
foo = 1234567890;
```
Для хранения bool-значения достаточно одного бита, а для хранения числа 1 234 567 890 нужно выделить уже 32 бита. Каждый раз выделять память заново — дорого. Вместо этого можно попытаться описать значение в виде структуры, которая будет иметь максимально возможный размер, чтобы вместить все поддерживаемые нами типы данных. Давайте посмотрим на очень упрощенную реализацию значения в языке с динамической типизацией:
Развернуть
```
// объединение для хранения значения
union ValueUnion {
bool boolValue; // bool-значение (1 байт)
double doubleValue; // число (8 байт)
void *objectPtr; // указатель на участок памяти (8 байт из-за 64-битной адресации памяти)
};
// поддерживаемые типы значений
enum class Type : char {
number = 1,
boolean = 2,
object = 4
};
// описание значения
struct ValueWrapper {
Type type; // тип значения (1 байт)
ValueUnion value; // значение (8 байт)
};
// набор сеттеров
void setNumber(ValueWrapper *value, double data) {
value->type = Type::number;
value->value.doubleValue = data;
}
void setBool(ValueWrapper *value, bool data) {
value->type = Type::boolean;
value->value.boolValue = data;
}
void setObjPtr(ValueWrapper *value, void *data) {
value->type = Type::object;
value->value.objectPtr = data;
}
int main() {
cout << sizeof(ValueWrapper) << endl; // 16
auto *pValueWrapper = new ValueWrapper;
// записываем число
setNumber(pValueWrapper, 100);
cout << pValueWrapper->value.doubleValue << endl; // 100
// записываем boolean
setBool(pValueWrapper, true);
cout << pValueWrapper->value.boolValue << endl; // 1
auto *strP = new string("hello!");
// записываем указатель на участок памяти
setObjPtr(pValueWrapper, strP);
cout << *(string*)pValueWrapper->value.objectPtr << endl; // hello!
return 0;
}
```
В этом примере мы поддерживаем три вида значений:
* число
* boolean
* указатель на произвольный участок памяти
[Объединения](https://docs.microsoft.com/ru-ru/cpp/cpp/unions?view=msvc-160&viewFallbackFrom=vs-2019) в C/C++ устроены так, что значения, которые мы туда записываем, делят между собой один и тот же участок памяти, а значит, размер такого объединения в байтах будет равен самому большому типу данных в объединении (в данном случае 8 байт). Этот объем памяти и выделяется при создании объединения.
Следовательно, структура, которая описывает наше значение, должна занимать 9 байт (1 байт на тип значения и 8 байт на объединение), но `sizeof(ValueWrapper)` возвращает 16 вместо 9. И это [нормально](https://docs.microsoft.com/ru-ru/cpp/cpp/alignment-cpp-declarations?view=msvc-160).
Очевидно, что при таком подходе мы платим возможностью более гибко управлять памятью из самого языка с динамической типизацией за удобства, которые дает нам эта самая динамическая типизация.
Тайпчекинг
----------
Итак, к чему это все? Код на языках с динамической типизацией (в частности на JavaScript):
* просто и быстро писать,
* сложно контролировать и рефакторить,
* почти не дает возможности гибко работать с памятью.
В результате с ростом кодовой базы возникает естественная потребность контролировать типы и уменьшать вероятность ошибки.
В попытке решить эти проблемы люди придумали линтеры и различные надстройки/тайпчекеры над языком, расширяющие синтаксис JS до состояния, в котором можно описывать типы. Одной из таких надстроек является TypeScript:
```
const foo: number = 123;
const bar: string = foo; // Type 'number' is not assignable to type 'string'
```
По большому счету TS дает нам возможность описать типы и проверяет, что мы их нигде явно не нарушаем, не пытаемся присвоить один тип данных другому.
На первый взгляд, TypeScript делает из JavaScript язык со строгой статической типизацией, ведь теперь мы не можем записать число в переменную, где планировали хранить строку. Да и судя по примеру выше, никаких неявных преобразований не будет, все свалится еще на этапе компиляции. Но все далеко не так однозначно.
Для начала стоит отметить, что код, который мы пишем на TS, просто трансформируется в JS, часто (но не всегда) один к одному, за исключением типов. То есть получившийся JS-код использует общий рантайм. В браузер попадает и выполняется старый добрый JS со всеми своими особенностями и отсутствием типов. Фатальный недостаток такого подхода в том, что сама по себе среда, в которой выполняется JS, открыта практически к любым изменениям:
```
Array.prototype.filter = () => ':(';
[1, 2, 3].filter(isEven); // ':('
```
С этого момента весь наш код, который завязан на стандартный метод `Array#filter()`, будет сломан вне зависимости от того, насколько полно мы до этого покрыли его типами.
Развивая эту тему, давайте подумаем еще о том, что помимо типизированного и строгого кода, который пишем мы, есть еще внешний код, который может быть не типизирован:
```
type Foo = { a: string, b: number };
const foo: Foo = { a: "привет", b: 123 };
someExternalFunction(foo); // внешний код, написанный не нами
console.log(foo.b); // ???
```
Есть ли у нас хоть какая-то уверенность, что типы полей `a` и `b` (а точнее, типы их значений) были сохранены? Нет, абсолютно никакой. `someExternalFunction` может быть вообще не типизирована и написана на чистом JS. И несмотря на то, что ее автор, возможно, предоставил `d.ts`-файл с описанием этой функции, совершенно не факт, что она должным образом протестирована и вообще соответствует заявленному интерфейсу.
> JS дает слишком много свободы.
>
>
Давайте посмотрим еще на один пример:
```
type Foo = { a: string, b: number };
function handleFoo(foo: Foo) {
// ...
}
handleFoo({a: "hello!", b: 123 }); // OK
handleFoo({a: "hello!", b: 123, c: 456 }); // Argument of type '{ a: string; b: number; c: number; }' is not assignable to parameter of type 'Foo'. Object literal may only specify known properties, and 'c' does not exist in type 'Foo'.
```
Вроде бы все логично, во втором случае мы пытаемся передать объект со структурой, отличной от того, что ожидается, и получаем ошибку на этапе компиляции. В то же время:
```
type Foo = { a: string, b: number };
type Bar = { a: string, b: number, c: number };
function handleFoo(foo: Foo) {
// ...
}
const bar: Bar = { a: "hello!", b: 123, c: 456 };
handleFoo(bar); // OK
```
Никаких ошибок здесь не будет, хотя по факту мы передали объект другого типа и никакой явной связи между ними нет (как, например, в случае с наследованием классов).
Документация отдельно [описывает](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-1-6.html#stricter-object-literal-assignment-checks) этот случай так:
> ***Stricter object literal assignment checks***
>
> *TypeScript 1.6 enforces stricter object literal assignment checks for the purpose of* ***catching excess or misspelled properties****. Specifically, when a fresh object literal is assigned to a variable or passed as an argument for a non-empty target type, it is an error for the object literal to specify properties that don’t exist in the target type.*
>
>
Тем не менее такое поведение может вводить в заблуждение и приводить к неверным выводам:
```
type Foo = { a: string, b: number };
type Bar = { a: string, b: number, [key: string]: any};
function serializeFoo(foo: Foo) {
return JSON.stringify(foo)
}
const bar: Bar = { a: "hello!", b: 123, ...tons of properties };
serializeFoo(bar); // OK
```
В примере выше очень легко допустить ошибку и случайно передать в функцию не то, что нужно, понадеявшись на типизацию. В результате сериализуется избыток данных, которого быть не должно.
Так происходит из-за логики сравнения типов:
> Если что-то ведет себя как утка, значит, это утка.
>
>
Такому способу сравнения типов даже выделили свое название — [утиная типизация](https://ru.wikipedia.org/wiki/%D0%A3%D1%82%D0%B8%D0%BD%D0%B0%D1%8F_%D1%82%D0%B8%D0%BF%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F).
С другой стороны, во Flow (аналог TS в плане проверки типов) есть [exact object type](https://flow.org/en/docs/types/objects/#toc-exact-object-types), что не позволит примеру выше скомпилироваться:
```
type Foo = {| a: string, b: number |}; // exact object type
type Bar = { a: string, b: number, c: number};
function serializeFoo(foo: Foo) {
return JSON.stringify(foo)
}
const bar: Bar = { a: "hello!", b: 123, c: 123 };
serializeFoo(bar); // Cannot call `serializeFoo` with `bar` bound to `foo` because inexact `Bar` is incompatible with exact `Foo`
```
Здесь вы вполне справедливо можете возразить: мол, с наследованием классов та же самая история. Посмотрим пример на Kotlin:
```
open class A(val foo: String)
class B(foo: String, val bar: String) : A(foo)
fun main() {
val b: B = B("foo", "bar")
val a: A = b // используем объект типа B в качества значения типа A
serializeA(a) // OK
}
```
Но здесь мы видим следствие полиморфизма, а не утиной типизации, так как типы явно связаны через наследование. Более того, при помощи рефлексии мы сможем выделить из объекта типа `B` только поля типа `A` и отправить их на сериализацию:
```
open class A(val foo: String)
class B(foo: String, val bar: String) : A(foo)
class PropertyInfo(val name: String, val type: KType, val value: T)
fun main() {
val b: B = B("foo value", "bar value")
val a: A = b // используем объект типа B в качества значения типа A
val items = A::class.memberProperties // получаем только поля типа A
.map { PropertyInfo(it.name, it.returnType, it.getter.call(a)) }
items.forEach { println("${it.name}: ${it.type} = ${it.value}") } // foo: kotlin.String = foo value
}
```
Благодаря динамичности JS структуру любого объекта можно изменить как угодно: добавить или удалить свойство, изменить его тип. Очень часто для этих целей пишут различные хелперы: `marge`, `renameProp` и т. п. Поэтому возникает новая необходимость: иметь возможность описать возвращаемый хелпером тип так, чтобы он автоматически выводился из типов входящих аргументов. Для этого TypeScript предлагает целый набор всяческих [хелперов](https://www.typescriptlang.org/docs/handbook/utility-types.html), [keyof](https://www.typescriptlang.org/docs/handbook/2/keyof-types.html) и [infer](https://www.typescriptlang.org/docs/handbook/advanced-types.html#type-inference-in-conditional-types). При необдуманном использовании они могут превратить типизированную систему в очень связный и труднораспутываемый клубок. Это отдельная тема, я постараюсь раскрыть ее как-нибудь в другой раз.
Альтернативы
------------
В качестве альтернатив тайпчекингу через TypeScript/Flow можно рассмотреть такие языки, как Dart или Kotlin, которые не просто трансформируются в JS, но еще и тащат за собой свой рантайм. Это значит, что, например, для фильтрации массива будет использована собственная реализация языка, а не встроенный метод `Array#filter` и т. д. С одной стороны, это позволяет создать эдакую песочницу, которая изолирована от общего рантайма и реализовывает свои собственные методы для работы с массивами, строками, объектами и т. д. С другой, даже при таком подходе невозможно полностью уйти от внешнего влияния общего рантайма, который может быть изменен в любой момент. Но несомненно, такой подход сильно снижает связь с внешней средой и код становится более безопасным, правда, до тех пор, пока мы не начнем вызывать из нашей замечательной изолированной коробочки внешний код, написанный не нами. Например, это не спасет нас от манкипатчинга какого-нибудь базового конструктора типа `Array`.
Другой альтернативный вариант — WASM. Пишите код на любом языке (с нужной вам типизацией, строгостью и т. д.), превращайте его в бинарный wasm-файл и запускайте в браузере. Здесь вы сами себе рантайм. Абсолютно все придется реализовывать самостоятельно (или использовать имплементацию языка, на котором вы пишете).
Выводы
------
> Нужно четко понимать, чего ожидать от типизации, какие задачи она решает, а какие нет (особенно когда дело касается очень свободного языка, такого как JS).
>
>
Так какую же тогда проблему решает TypeScript (и ему подобные) и какие ожидания по отношению к нему оправданны?
TypeScript помогает контролировать типы внутри того кода, который вы сами написали, но как только дело доходит до работы с внешним кодом, то здесь уже без каких-либо гарантий. Как только вы в коде используете нечто внешнее, что угодно может пойти не так. Более того, рассчитывать на типы в своем коде вы можете только до старта приложения. Как только ваш код запущен внутри нестабильной среды (коей является рантайм JS), то, опять же, что угодно может пойти не так.
Все это совсем не означает, что тайпчекинг для JS плох и бесполезен, просто нужно понимать, чего от него стоит ожидать и какие задачи он точно не решает.
В качестве очень приятного бонуса можно отметить, что тулинг того же TypeScript помогает в таких важных вещах, как навигация по коду, code completion и рефакторинг.
Может показаться, что я немного перегнул с тягой к полной изоляции. Дело в том, что JS уже столько лет дает нам настолько большую свободу действий, что отсутствие такой изоляции принимается как само собой разумеющееся. Это ведет к снижению безопасности и стабильности в работе нашего кода, и тайпчекинг не решает эту проблему. Языки, которые трансформируются в JS и тянут за собой свой рантайм, с одной стороны, повышают изоляцию, с другой — всегда остается «дыра» на стыке с внешним кодом. | https://habr.com/ru/post/541338/ | null | ru | null |
# Прекрати злоупотреблять массивами в PHP
Меня давно мучает мысль об одной проблеме — тотально злоупотребление массивами в PHP. Возможно корень проблемы в процедурном наследии PHP или в том, что PHP привлекает большое количество неопытных разработчиков, не знаю. Но дело в том, что очень многие используют массивы там, где должны использоваться объекты!
Взглянем на типичный пример ужасающего, на мой взгляд кода, злоупотребляющего массивами. Для примера, предположим, мы извлекаем данные из БД и работаем с ними посредством массива. Вот такие примеры я вижу ежедневно:
```
$ponds = array(
array(
"name" => "Breakspear",
"size" => "large",
"pegs" => "23",
"amenities" => array(
"toilets" => false,
"shop" => true,
),
"fishBreeds" => array(
array(
"name" => "Bream",
"stocked" => "2013-10-04 12:16:47",
"number" => "100",
"record" => "5.4lbs",
),
array(
"name" => "Perch",
"stocked" => "2012-02-02 05:23:32",
"number" => "50",
"record" => "1.2lbs",
),
array(
"name" => "Common Carp",
"stocked" => "2011-01-23 14:42:59",
"number" => "10",
"record" => "15.4lbs",
),
),
),
);
```
Мы видим огромный многомерный массив, хранящий информацию о конкретном рыболовном пруду. Здесь описан только один пруд, но представьте, что было бы, будь там описана сотня прудов? Что в итоге? Мы имеем набор данных, хранящийся в массиве, но не имеющий никакого связанного поведения. Когда нам нужно будет работать с этими данными, нам придется создавать сложный код, полный вложенных циклов. Например, как я могу получить общее количество рыб в пруду? Мне придется пройтись по всему массиву и сложить все количество рыб. Для малоопытного разработчика это не показалось бы чем-то плохим, так бы он и сделал, но мне больше по душе пришелся бы такой подход:
```
$ponds->getNamed("Breakspear")->getTotalStocked();
```
Намного меньше кода для получения того же результата. Конечно, полного перебора данных не избежать, но функциональность красиво инкапсулирована. Собственно, этот пример и раскрывает основную проблему — не стоит избегать преимуществ ООП. Примерно так должен выглядеть код из первого примера:
```
$ponds = new PondCollection();
$pond = new Pond("Breakspear");
$pond->addStockData(new StockData("Bream", 100, "2013-10-04 12:16:47"));
$pond->addStockData(new StockData("Perch", 50, "2012-02-02 05:23:32"));
$pond->addStockData(new StockData("Common Carp", 10, "2011-01-23 14:42:59"));
$pond->addAmenity(new ShopAmenity());
$ponds->add($pond);
```
#### Излишняя сложность
Использование огромных массивов означают не только невозможность добавления связанного поведения, но и обязывает создавать сложные механизмы доступа к данным. Часто это реализовывается как многофункциональные классы со здоровыми методами, использующими вложенные циклы. Вроде этого
```
foreach ($ponds as $pond)
{
foreach ($pond["fishBreeds"] as $breed)
{
$stockedFish += $breed["number"];
}
}
```
Писать и поддерживать такой код сложно, особенно, если происходит какое-то изменение в структуре данных. Кроме того реализация методов не имеет ничего общего с данными, которые использует.
Используя классы для инкапсуляции может показаться, что кода в итоге приходится писать больше, но я гарантирую по своему опыту, что это обернется меньшими расходами в дальнейшем. Просто подумайте, не придется каждый раз писать новый цикл для перебора значений. Кода будет меньше, он будет чище, вы будете видеть четкие границы того, что каждый класс делает.
#### Ты делаешь это неверно
Единственные причины, по которым разработчики продолжают писать подобный код — это или неопытность или потерянность в процедурном прошлом. ООП было изобретено как раз для подобного рода вещей, особенно для связывания поведения с состоянием. Поверите или нет, но я видел код очень популярной компании, работающей на рынке электронной коммерции использующий этот антипаттерн для таких важных частей как корзина и заказы. Есть места в коде, которые разработчики просто запрещают трогать, (несмотря на наличие багов) потому как код очень сложен и хрупок, что изменения просто невозможны. Сумасшествие.
#### Работа с наборами данных
Выбросьте из головы, что вам нужно использовать массивы для работы с набором данных. «Набор данных» (или коллекция) не означает использование массивов! Неопытные разработчики поступают так, потому что не слышали про итераторы. Их использование позволяет вам работать с коллекциями, реализуя конкретное поведение. На первый взгляд сложно, но на деле все просто. Вот класс, реализующий итератор
```
class PondsCollection implements IteratorAggregate
{
private $collection = array();
public function getIterator()
{
return new ArrayIterator($this->collection);
}
public function add($pond)
{
$this->collection[] = $pond;
}
}
```
Вот и все. Реализация класса, который создает итерируемую коллекцию данных в сочетании с поведением. В своем сердце класс содержит массив, но который теперь оформлен с соответствующими методами для работы с данными. Реализация интерфейса IteratorAggregate делает объект класса доступным для работы с циклом.
```
$ponds = new PondsCollection();
$ponds->add(...);
foreach ($ponds as $pond)
{
...
}
```
Теперь нет необходимости в каждом месте, где нам необходимо получить данные из набора реализовывать связанное поведения, оно будет связано с коллекцией данных и доступно из объекта, а не разбросано по всему коду.
##### Подробнее в документации:
* <http://www.php.net/manual/en/class.iteratoraggregate.php>
* <http://www.php.net/manual/en/spl.iterators.php> | https://habr.com/ru/post/279917/ | null | ru | null |
# Обработка файлов RAW, полученных с камеры Raspberry Pi HQ
Когда большинство людей делает фотографию, им просто нужно нажать кнопку спуска на фотокамере или телефоне, и готовое к просмотру изображение, обычно в известном формате JPEG, почти мгновенно появится на экране. Однако для некоторых случаев требуется больше контроля над получением этого самого JPEG. К примеру, вам может захотеться увеличить или уменьшить активность функции удаления шума, или вам может показаться, что цвета получились не совсем верно.
И тогда на помощь приходят файлы RAW. В данном контексте необработанное (raw) изображение – это прямая передача данных, полученных от пикселей фотоматрицы, и [не прошедших дополнительную обработку](https://habr.com/ru/post/516228/). Обычно такие файлы имеют относительно стандартный формат байеровского изображения, названный в честь Брайса Байера, изобретшего эту технику в 1974 году во время работы на компанию Kodak. Идея в том, чтобы не дать имеющемуся на борту процессору обработки изображений (ISP) превратить необработанное байеровское изображение в пригодное для просмотра, а сделать это самостоятельно при помощи отдельной программы, которую обычно называют конвертером RAW.
*Байеровское изображение записывает только один цвет для каждого из пикселя по приведённой схеме*
Иногда необработанное изображение сравнивают со старой технологий фотографического негатива, и хотя многие производители фотокамер используют собственный формат, наиболее распространённым видом файла RAW является формат Digital Negative [«цифровой негатив»] (или DNG), описанный Adobe в 2004. Остаётся вопрос – как получить DNG-файлы от Raspberry Pi так, чтобы обработать их при помощи любимого конвертера RAW.
Получение необработанного изображения от Raspberry Pi
-----------------------------------------------------
Многим читателям будет знакомо приложение raspistill, получающее изображения формата JPEG с камеры. У raspistill есть команда –r, дописывающая в конец файла JPEG необработанные данные. Программы для просмотра JPEG всё равно покажут этот файл как обычно, проигнорировав многие мегабайты необработанных данных, прикреплённых сзади. Такой файл JPEG+RAW можно получить про помощи команды в терминале:
```
raspistill -r -o image.jpg
```
К сожалению, формат JPEG+RAW – это просто то, что выходит из камеры, и он не поддерживается конвертером RAW. Чтобы воспользоваться им, нам нужно преобразовать его в формат DNG.
PyDNG
-----
Данная утилита преобразовывает собственный файл JPEG+RAW Raspberry Pi в DNG. PyDNG можно поставить с github.com/schoolpost/PyDNG, там же есть и более развёрнутая инструкция. Вкратце, нам надо выполнить следующие шаги:
```
git clone https://github.com/schoolpost/PyDNG
cd PyDNG
pip3 install src/. # для PyDNG требуется Python3
```
PyDNG можно использовать как часть более крупных скриптов на Python, или запускать самостоятельно. Продолжая пример с raspistill, мы можем ввести в строку ввода:
```
python3 examples/utility.py image.jpg
```
Полученный файл формата DNG можно обработать различными конвертерами RAW. Некоторые из них бесплатные (к примеру, RawTherapee или dcraw, хотя последний уже не разрабатывается и не поддерживается), а ещё есть много известных коммерческих вариантов (Adobe Camera Raw или Lightroom).
Баланс белого и цветовые матрицы
--------------------------------
Одна из проблем с обработкой файлов RAW с Raspberry Pi на этом этапе связана с получением осмысленных цветов. До этого изображения рендерелись с уклоном в зелёный, поскольку не проводилось никакой балансировки цвета, а зелёный – обычно наиболее чувствительный цветовой канал. Что ещё хуже, поскольку значения RGB в необработанном изображении просто отражают чувствительность пикселей датчика к различным длинам волн, они априори не точно коррелируют с теми цветами, которые мы воспринимаем глазами. Именно тут нам и пригодятся баланс белого и цветовые матрицы.
Нам требуются правильные множители белого для того, чтобы нейтральные части сцены выглядели нейтральными. Мы можем использовать обоснованное предположение от raspistill на их счёт, содержащееся в файле JPEG+RAW (или вы можете измерить собственное значение на каком-либо участке снимка – например, на серой карточке). После этого для преобразования цветов, полученных с камеры, в цветовое пространство типа sRGB или Adobe RGB потребуются матрицы и справочные таблицы.
Результаты
----------
Предыдущие попытки конвертации RAW и итоги, полученные после применения обновлённой версии PyDNG.
Файлы DCP
---------
Для людей, знакомых с файлами DNG, мы приводим ссылки на файлы DCP (DNG Camera Profile) с профилем камеры (в двоичном формате). Попробуйте разные файлы, мы поощряем пользователей на эксперименты, на создание собственных файлов и на публикацию полученных результатов!
1. [Базовый цветовой профиль](https://github.com/davidplowman/Colour_Profiles/blob/master/imx477/PyDNG_profile.dcp), встроенный в PyDNG, результаты его работы приведены выше. Он относительно мелкий, и его можно посмотреть в виде [файла JSON](https://github.com/davidplowman/Colour_Profiles/blob/master/imx477/PyDNG_profile.json).
2. [Улучшенный профиль](https://github.com/davidplowman/Colour_Profiles/blob/master/imx477/Raspberry%20Pi%20High%20Quality%20Camera%20Lumariver%202860k-5960k%20Neutral%20Look.dcp) большего размера со справочными таблицами для сбалансированного рендеринга цветов.
3. [Похожий на предыдущий](https://github.com/davidplowman/Colour_Profiles/blob/master/imx477/Raspberry%20Pi%20High%20Quality%20Camera%20Lumariver%202860k-5960k%20Skin%2BSky%20Look.dcp), но с некоторыми исправлениями для улучшения цвета кожи и неба.
Однако у этих файлов есть несколько особенностей:
* Они откалиброваны для одной определённой Raspberry Pi High Quality Camera, а не для некоего среднего «типичного» модуля.
* Источники света были те, что оказались у нас под руками – в особенности, кажется, что лампа D65 передаётся немного неточно.
* Калибровка работает только если цветовая температура не сильно отличается от двух источников цвета, участвовавших в калибровке – в нашем случае это диапазон от 2900K до 6000K.
Поэтому тут ещё есть, что улучшать. Тем не менее, испытания на многих модулях показали, что эти параметры являются значительным шагом вперёд.
Благодарности
-------------
Джеку Хогану – за калибрацию цветовой матрицы при помощи DCamProf, Цсабе Наги – за добавление новых особенностей в PyDNG.
Дополнительные материалы
------------------------
* Существует много ресурсов, описывающих преобразование необработанного байеровского изображения в пригодное для просмотра изображения формата RGB or YUV. Например, [статья в блоге Джека](https://habr.com/ru/post/516228/).
* Чтобы понять роль цветовых матриц, которую они играют в файле DNG, обращайтесь к [его спецификации](https://wwwimages2.adobe.com/content/dam/acom/en/products/photoshop/pdfs/dng_spec_1.5.0.0.pdf). В частности, это описывается в главе 6. | https://habr.com/ru/post/516658/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.